Index: write.c
===================================================================
--- write.c (nonexistent)
+++ write.c (revision 5)
@@ -0,0 +1,570 @@
+/*
+ * This code is copyrighted. Please see the file COPYING for a full notice.
+ */
+
+/*
+ * write.c - Write to another user's tty
+ *
+ * $Log: write.c,v $
+ * Revision 1.15 1999/12/12 19:56:40 dholland
+ * Clean up 8-bit character handling.
+ *
+ * Revision 1.14 1999/12/12 19:53:21 dholland
+ * reindent.
+ *
+ * Revision 1.13 1999/11/25 05:05:05 netbug
+ * minor DEC stuff
+ *
+ * Revision 1.12 1999/10/02 17:58:51 dholland
+ * More header file cleanup; we don't use pathnames.h any more, so toast it.
+ *
+ * Revision 1.11 1999/10/02 01:46:45 netbug
+ * some extraneous header files commented out
+ * added socklen_t to MCONFIG.in and to writed.c
+ *
+ * Revision 1.10 1999/08/01 00:05:24 dholland
+ * Use new version of confgen. Set version to 0.15. Update README.
+ *
+ * Revision 1.9 1997/09/23 03:33:40 dholland
+ * keep getservbyname() from trashing gethostbyname() results
+ *
+ * Revision 1.8 1997/04/06 01:40:49 dholland
+ * better utmp handling
+ *
+ * Revision 1.7 1997/03/08 12:41:48 dholland
+ * Fix for irix
+ *
+ * Revision 1.6 1997/01/19 06:16:00 dholland
+ * in hunt_utmp, savebuf should be the same size as ttybuf
+ *
+ * Revision 1.5 1997/01/06 05:40:59 dholland
+ * use pathnames.h
+ *
+ * Revision 1.4 1996/12/29 17:36:47 dholland
+ * fix potential buffer overrun
+ *
+ * Revision 1.3 1996/11/25 18:52:59 dholland
+ * better handling of CHECK_UT_TYPE
+ *
+ * Revision 1.2 1996/11/25 18:43:25 dholland
+ * clean compile; fix h_length issues; use inet_aton instead of inet_addr
+ *
+ * Revision 1.1 1996/11/23 19:50:40 dholland
+ * Initial revision
+ *
+ * Revision 1.8 1996/04/29 21:43:25 dholland
+ * Copyright fixes.
+ *
+ * Revision 1.7 1996/04/29 20:25:43 dholland
+ * Config improvements.
+ *
+ * Revision 1.6 1996/04/29 19:59:14 dholland
+ * Add RCS stuff.
+ *
+ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <utmp.h>
+#include <time.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <pwd.h>
+#include <unistd.h>
+
+#define NMAX sizeof(((struct utmp *)NULL)->ut_name) /* hack */
+#define LMAX sizeof(((struct utmp *)NULL)->ut_line)
+
+/*
+ * From:
+ * /afs/athena.mit.edu/astaff/project/olcdev/src/server/writed/RCS/write.c,v
+ * 1.1 91/05/15 12:36:40 lwvanels Exp
+ *
+ * @(#)write.c 4.13 3/13/86
+ */
+
+char rcsid[] = "$Id: write.c,v 1.15 1999/12/12 19:56:40 dholland Exp $";
+#include "../version.h"
+
+/*********************** conditionals for ports ************************/
+
+#ifdef _AIX
+#define SYSVISH_SETPGRP
+#endif
+
+#ifdef __linux__
+#define SYSVISH_SETPGRP
+#endif
+
+#ifdef __hpux__
+#define SYSVISH_SETPGRP
+#define CHECK_UT_TYPE
+#endif
+
+#ifdef ultrix
+ char *rindex(const char *, int);
+ int socket(int af, int type, int protocol);
+ void bcopy(char *b1, const char *b2, int length);
+ int connect(int s, struct sockaddr *, int len);
+ int setpgrp (int pid, int pgrp);
+ int gethostname(char *, int);
+#endif
+
+/*
+ * In sysV, and sysVish or POSIX environments like Linux, setpgrp() takes
+ * no arguments, and what we want is actually called setpgid.
+ */
+#ifdef SYSVISH_SETPGRP
+#define setpgrp setpgid
+#endif
+
+/*
+ * Just in case.
+ */
+#if defined(USER_PROCESS) && !defined(CHECK_UT_TYPE)
+#define CHECK_UT_TYPE
+#endif
+
+/*
+ * Some types.
+ */
+
+typedef void (*sigfunc)(int);
+
+typedef struct {
+ const char *user;
+ const char *host;
+ const char *tty;
+ const char *asktty;
+ int fromnet;
+ int authentic;
+} person;
+
+
+/**************************** lookup operations **************************/
+
+/*
+ * Get local "me" tty
+ */
+static char *getmytty(void) {
+ struct stat stbuf;
+ char *mytty = ttyname(2);
+ if (!mytty) {
+ fprintf(stderr, "write: Can't find your tty\n");
+ exit(1);
+ }
+ if (stat(mytty, &stbuf) < 0) {
+ perror("write: Can't stat your tty");
+ exit(1);
+ }
+ if ((stbuf.st_mode&020) == 0) {
+ fprintf(stderr, "write: You have write permission turned off.\n");
+ if (getuid()!=0) exit(1);
+ }
+ mytty += 5; /* skip /dev/ */
+ return mytty;
+}
+
+/*
+ * Search utmp file
+ */
+static int hunt_utmp(person *himm) {
+ static char savebuf[LMAX+5];
+ int gothim = 0, logcnt=0;
+ struct stat stbuf;
+ struct utmp *uptr;
+ char tempbuf[NMAX+1];
+ char ttybuf[LMAX+5];
+ setutent();
+ while ((uptr = getutent())!=NULL) {
+#ifdef CHECK_UT_TYPE
+ if (uptr->ut_type != USER_PROCESS) continue;
+#endif
+ if (uptr->ut_name[0] == '\0') continue;
+ memcpy(tempbuf, uptr->ut_name, NMAX); /* ut_name doesn't necessarily */
+ tempbuf[NMAX]=0; /* come null-terminated... */
+ if (strchr(tempbuf, ' ')) *strchr(tempbuf, ' ')=0;
+ if (strcmp(himm->user, tempbuf)) continue;
+ if (himm->asktty && strcmp(himm->asktty, uptr->ut_line)) continue;
+ logcnt++;
+ if (gothim) continue;
+ strcpy(ttybuf, "/dev/");
+ strcat(ttybuf, uptr->ut_line);
+ if (!stat(ttybuf, &stbuf) && (stbuf.st_mode&020)) {
+ strcpy(savebuf, ttybuf);
+ gothim=1;
+ }
+ }
+ endutent();
+ himm->tty = savebuf;
+ return logcnt;
+}
+
+/*
+ * Go grub for the target [local] user in /etc/utmp.
+ */
+static void doutmp(person *him) {
+ int logcnt = hunt_utmp(him);
+ if (logcnt==0) {
+ fprintf(stderr, "write: %s not logged in%s\n", him->user,
+ him->asktty ? " on that tty" : "");
+ exit(1);
+ }
+ if (!him->asktty && logcnt > 1) {
+ fprintf(stderr, "write: %s logged in more than once ... writing to %s\n",
+ him->user, him->tty+5);
+ }
+ /*#ifdef _AIX*/
+ /* This appears to flush the stderr buffer on the PS/2 so that
+ both sides of the connection don't receive the message.
+ Weird. - Ezra */
+ /* HP-UX has the same problem, but flushing stderr doesn't solve it.
+ I'm leaving the flush in, because it's not a bad idea anyway. See
+ below for the real fix. - dholland */
+ fflush(stderr);
+ /*#endif*/
+}
+
+/********************* open socket for net write **************************/
+
+/*
+ * Open write socket to specified host.
+ */
+static FILE *opensocket(struct hostent *hp) {
+ FILE *f;
+ int fds;
+ struct sockaddr_in sin;
+ struct servent *sp;
+ sin.sin_family = hp->h_addrtype;
+ if (hp->h_length > (int)sizeof(sin.sin_addr)) {
+ hp->h_length = sizeof(sin.sin_addr);
+ }
+ memcpy(&sin.sin_addr, hp->h_addr, hp->h_length);
+
+ sp = getservbyname("write", "tcp");
+ if (sp == 0) {
+ fprintf(stderr, "tcp/write: unknown service\n");
+ exit(1);
+ }
+ sin.sin_port = sp->s_port;
+
+ fds = socket(sin.sin_family, SOCK_STREAM, 0);
+ if (fds < 0) {
+ perror("socket");
+ exit(1);
+ }
+ if (connect(fds, (struct sockaddr *)&sin, sizeof (sin)) < 0) {
+ perror("connect");
+ close(fds);
+ exit(1);
+ }
+ f = fdopen(fds, "r+");
+ if (!f) {
+ perror("fdopen");
+ close(fds);
+ exit(1);
+ }
+ return f;
+}
+
+/*
+ * Translate machine name into hostent.
+ */
+static struct hostent *find_remote(const char *hishost) {
+ struct hostent *hp;
+ hp = gethostbyname(hishost);
+ if (hp == NULL) {
+ static struct hostent def;
+ static struct in_addr defaddr;
+ static char namebuf[256];
+
+ if (!inet_aton(hishost, &defaddr)) {
+ printf("unknown host: %s\n", hishost);
+ exit(1);
+ }
+ strncpy(namebuf, hishost, sizeof(namebuf));
+ namebuf[sizeof(namebuf)-1] = 0;
+ def.h_name = namebuf;
+ def.h_addr = (char *)&defaddr;
+ def.h_length = sizeof (struct in_addr);
+ def.h_addrtype = AF_INET;
+ def.h_aliases = 0;
+ hp = &def;
+ }
+ return hp;
+}
+
+/*
+ * Open a remote machine for writing.
+ */
+static FILE *open_to_remote(const person *me, const person *him) {
+ char buf[128];
+ struct hostent *hp = find_remote(him->host);
+ FILE *tf = opensocket(hp);
+ fprintf(tf, "%s@%s@%s %s%s%s\r\n", me->user, me->host, me->tty,
+ him->user, him->asktty ? " " : "", him->asktty ? him->asktty : "");
+ fflush(tf);
+ while (1) {
+ if (fgets(buf, sizeof(buf), tf) == NULL) exit(1);
+ if (buf[0] == '\n') break;
+ write(1, buf, strlen(buf));
+ }
+ fflush(tf); /* Apparently this is needed in Irix */
+ return tf;
+}
+
+/*********************** open a tty for local write ******************/
+
+/*
+ * Signal handler for timeout
+ */
+static void timout(int ignore) {
+ (void)ignore;
+ fprintf(stderr, "write: open tty: timed out\n");
+ exit(1);
+}
+
+/*
+ * Open a local tty for writing.
+ */
+static FILE *open_to_local(const person *me, const person *him) {
+ FILE *tf;
+ int fd;
+ struct stat stbuf;
+ time_t clock = time(NULL);
+ struct tm *localclock = localtime( &clock );
+
+ signal(SIGALRM, timout);
+ alarm(5);
+
+ if (stat(him->tty, &stbuf) < 0 || (stbuf.st_mode&020) == 0
+ || (fd = open(him->tty, O_WRONLY|O_NOCTTY)) < 0) {
+ fprintf(stderr, "write: Permission denied\n");
+ exit(1);
+ }
+ tf = fdopen(fd, "w");
+ if (!tf) {
+ fprintf(stderr, "write: fdopen failed\n");
+ exit(1);
+ }
+
+ alarm(0);
+
+ if (me->fromnet) {
+ printf("\n");
+ fflush(stdout);
+ }
+ fprintf(tf, "\r\nMessage from %s@%s%s%s %sat %d:%02d ...\r\n\007\007\007",
+ me->user, me->host, me->tty ? " on " : "", me->tty ? me->tty : "",
+ me->authentic ? "" : "[UNAUTHENTICATED] ",
+ localclock->tm_hour, localclock->tm_min);
+ fflush(tf);
+ return tf;
+}
+
+/***************************** main loop ***********************************/
+
+static int mainloop_done=0;
+
+/*
+ * Catch a bunch of signals and cause mainloop to exit.
+ * closing stdin is a hack that causes the read call the main loop is
+ * blocked in to return immediately.
+ */
+static void catch(int ignore) {
+ (void)ignore;
+ mainloop_done=1;
+ close(0);
+}
+
+/*
+ * Treats 0-31 and 128-159 as nonprinting control characters,
+ * except for \r, \n, and \t.
+ */
+static int printc(int ch, FILE *tf) {
+ if (ch=='\n') {
+ fputs("\r\n", tf);
+ fflush(tf);
+ }
+ else if (ch=='\r' || ch=='\t' || ((ch&127)>=32 && (ch&127)<127)) {
+ fputc(ch, tf);
+ }
+ else if (ch==127) {
+ fputs("^?", tf);
+ }
+ else {
+ fputc('^', tf);
+ fputc(ch|64, tf);
+ }
+ if (ferror(tf) || feof(tf)) return -1;
+ return 0;
+}
+
+/*
+ * Main loop.
+ */
+static void writeloop(FILE *tf, int nethim, const char *hisname) {
+ char buf[BUFSIZ];
+ int j,len;
+ signal(SIGHUP, catch);
+ signal(SIGINT, catch);
+ signal(SIGQUIT, catch);
+ while (!mainloop_done) {
+ len = read(0, buf, sizeof(buf));
+ if (len<=0) break;
+ for (j=0; j<len && !mainloop_done; j++)
+ if (printc(buf[j], tf)) {
+ printf("\n\007Write failed (%s logged out?)\n", hisname);
+ exit(1);
+ }
+ }
+ if (!nethim) {
+ fprintf(tf, "EOF\r\n");
+ fflush(tf);
+ }
+}
+
+/**************************** setup *************************************/
+
+/*
+ * Fill in the person structure for the target.
+ */
+static void makehim(person *him, char *himarg, const char *histtya) {
+ char *x;
+ him->tty = NULL;
+ him->asktty = histtya;
+ him->user = himarg;
+ him->authentic = 1; /* not really relevant anyway */
+ x = strchr(himarg, '@');
+ if (x) {
+ *x++=0;
+ if (strchr(x, '@')) {
+ fprintf(stderr, "Usage: write user [tty]\n");
+ exit(1);
+ }
+ him->host = x;
+ him->fromnet = 1;
+ }
+ else {
+ him->host = NULL;
+ him->fromnet = 0;
+ doutmp(him);
+ }
+}
+
+/*
+ * Convert "net arg" of the form user@host@tty and fill in person structure.
+ * We may get just user@host though.
+ */
+static int makeme_net(person *me, char *netarg, int authentic) {
+ char *x;
+
+ /*
+ * It appears that on some systems (including AIX and HP-UX), inetd
+ * doesn't bother to open stderr. This leads to the file opened to
+ * the user also being stderr, with two different FILE * open on it,
+ * which causes just absolutely wonderful things to happen.
+ * This should fix the problem and be harmless on nonbroken systems.
+ * Gotta love System V.
+ * dholland 4/28/96
+ *
+ * Actually, this is more puzzling than I thought, since writed does
+ * dup2(0,1); dup2(0,2); ... and yet this fix caused the bug to go away.
+ * Still very strange.
+ * dholland 4/29/96
+ */
+ dup2(1,2);
+
+ me->user = netarg;
+ me->asktty = NULL;
+ me->tty = NULL;
+ me->fromnet = 1;
+ me->authentic = authentic;
+ x = strchr(netarg, '@');
+ if (!x) return -1; /* no @'s */
+ *x++ = 0;
+ me->host = x;
+ x = strchr(x, '@');
+ if (x) {
+ *x++=0;
+ me->tty = x;
+ if (strchr(x, '@')) return -1; /* too many @'s */
+ }
+ return 0;
+}
+
+/*
+ * Construct person structure based on where we are.
+ * If we can't getlogin(), people can't write back, so deny access.
+ */
+static void makeme_local(person *me) {
+ static char hostname[128];
+ struct hostent *h;
+ gethostname(hostname, sizeof(hostname));
+ h = gethostbyname(hostname);
+ if (h) { /* if we fail, pretend we didn't try */
+ strncpy(hostname, h->h_name, sizeof(hostname));
+ hostname[sizeof(hostname)-1] = 0; /* ensure null termination */
+ }
+
+ me->user = getlogin();
+ me->host = hostname;
+ me->tty = getmytty();
+ me->asktty = NULL;
+ me->fromnet = 0;
+ me->authentic = 1;
+ if (!me->user) {
+ if (getuid()) {
+ fprintf(stderr, "Where are you?\n");
+ exit(1);
+ }
+ else {
+ fprintf(stderr, "Warning - you aren't really logged in...\n");
+ me->user = "root";
+ }
+ }
+}
+
+
+
+/*
+ * Accept arguments of the form
+ * write [-{f|a} from@fromhost@fromtty] user@host [tty]
+ * -{f|a} is reserved for root.
+ * -a indicates that the username on the remote host is authenticated.
+ */
+
+static void usage(void) {
+ fprintf(stderr, "Usage: write user [ttyname]\n");
+ exit(1);
+}
+
+int main(int argc, char *argv[]) {
+ person me, him;
+ FILE *tf;
+ if (argc<2 || argc>5) usage();
+ if (!strcmp(argv[1], "-f") || !strcmp(argv[1], "-a")) {
+ if (getuid()!=0 || argc<4) usage();
+ if (makeme_net(&me, argv[2], !strcmp(argv[1], "-a"))) usage();
+ argv += 2;
+ }
+ else if (argc>3) usage();
+ else makeme_local(&me);
+ makehim(&him, argv[1], argv[2]);
+ if (me.fromnet && him.fromnet) usage();
+ if (him.fromnet) tf = open_to_remote(&me, &him);
+ else tf = open_to_local(&me, &him);
+
+ writeloop(tf, him.fromnet, him.user);
+ fclose(tf);
+ return 0;
+}
Index: .
===================================================================
--- . (nonexistent)
+++ . (revision 5)
Property changes on: .
___________________________________________________________________
Added: svn:ignore
## -0,0 +1,73 ##
+
+# install dir
+dist
+
+# Target build dirs
+.a1x-newlib
+.a2x-newlib
+.at91sam7s-newlib
+
+.build-machine
+
+.a1x-glibc
+.a2x-glibc
+.h3-glibc
+.h5-glibc
+.i586-glibc
+.i686-glibc
+.imx6-glibc
+.jz47xx-glibc
+.makefile
+.am335x-glibc
+.omap543x-glibc
+.p5600-glibc
+.power8-glibc
+.power8le-glibc
+.power9-glibc
+.power9le-glibc
+.m1000-glibc
+.riscv64-glibc
+.rk328x-glibc
+.rk33xx-glibc
+.rk339x-glibc
+.s8xx-glibc
+.s9xx-glibc
+.x86_64-glibc
+
+# Hidden files (each file)
+.makefile
+.dist
+.rootfs
+
+# src & hw requires
+.src_requires
+.src_requires_depend
+.requires
+.requires_depend
+
+# Tarballs
+*.gz
+*.bz2
+*.lz
+*.xz
+*.tgz
+*.txz
+
+# Signatures
+*.asc
+*.sig
+*.sign
+*.sha1sum
+
+# Patches
+*.patch
+
+# Descriptions
+*.dsc
+*.txt
+
+# Default linux config files
+*.defconfig
+
+# backup copies
+*~
Radix cross Linux
The main Radix cross Linux repository contains the build scripts of packages, which have the most complete and common functionality for desktop machines
452 Commits
2 Branches
1 Tag