Return to wall.c CVS log

Up to [Research Unix] / researchv9 / cmd

Annotation of researchv9/cmd/wall.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  *
                      3:  * This program is not related to David Wall, whose Stanford Ph.D. thesis
                      4:  * is entitled "Mechanisms for Broadcast and Selective Broadcast".
                      5:  */
                      6: 
                      7: #include <stdio.h>
                      8: #include <utmp.h>
                      9: #include <time.h>
                     10: #include <sys/utsname.h>
                     11: #include <signal.h>
                     12: #include <sys/types.h>
                     13: #include <sys/stat.h>
                     14: 
                     15: char   *strcpy(), *strncpy();
                     16: char   *strcat(), *strncat();
                     17: long   time();
                     18: struct tm *localtime();
                     19: 
                     20: main()
                     21: {
                     22:        register int c;
                     23:        register char *p;
                     24:        struct utmp utmp;
                     25:        struct tm *tm;
                     26:        long clock;
                     27:        FILE *f;
                     28:        char *who, *mytty;
                     29:        struct utsname node;
                     30:        char mesg[3000];
                     31:        char *getlogin(), *ttyname();
                     32:        long time();
                     33:        struct tm *localtime();
                     34: 
                     35:        if((f = fopen("/etc/utmp", "r")) == NULL) {
                     36:                fprintf(stderr, "Cannot open /etc/utmp\n");
                     37:                exit(1);
                     38:        }
                     39:        if ((who = getlogin()) == NULL)
                     40:                who = "greg";
                     41:        if ((mytty = ttyname(2)) == NULL)
                     42:                mytty = "???";
                     43:        else if (strncmp(mytty, "/dev/", 5) == 0)
                     44:                mytty += 5;             /* for prettiness */
                     45:        uname(&node);
                     46:        clock = time((long *)0);
                     47:        tm = localtime(&clock);
                     48:        sprintf(mesg,  "\nBroadcast Message from %s!%s (%s) at %d:%02d ...\r\n",
                     49:                node.nodename, who, mytty, tm->tm_hour, tm->tm_min);
                     50:        p = &mesg[strlen(mesg)];
                     51:        while((c = getchar()) != EOF) {
                     52:                if (p >= &mesg[sizeof(mesg)]) {
                     53:                        fprintf(stderr, "Message too long\n");
                     54:                        exit(1);
                     55:                }
                     56:                if (c == '\n')
                     57:                        *p++ = '\r';
                     58:                *p++ = c;
                     59:        }
                     60:        while (fread((char *)&utmp, sizeof(utmp), 1, f) == 1) {
                     61:                if (utmp.ut_name[0] == 0)
                     62:                        continue;
                     63:                /* reject people not really logged in */
                     64:                for (c = 0; c < sizeof(utmp.ut_name); c++)
                     65:                        if (utmp.ut_name[c] == '*')
                     66:                                break;
                     67:                if (c < sizeof(utmp.ut_name))
                     68:                        continue;
                     69:                sendmes(utmp.ut_line, sizeof(utmp.ut_line), mesg, p - mesg);
                     70:        }
                     71:        exit(0);
                     72: }
                     73: 
                     74: sendmes(tty, len, mesg, mlen)
                     75: char *tty, *mesg;
                     76: int len, mlen;
                     77: {
                     78:        int i;
                     79:        char t[50];
                     80:        int fd;
                     81: 
                     82:        while ((i = fork()) == -1)
                     83:                if (wait((int *)0) == -1) {
                     84:                        fprintf(stderr, "Try again\n");
                     85:                        return;
                     86:                }
                     87:        if(i)
                     88:                return;
                     89:        sprintf(t, "/dev/%.*s", len, tty);
                     90:        if (ckmode(t) == 0)
                     91:                exit(0);
                     92:        signal(SIGALRM, SIG_DFL);       /* blow away if open hangs */
                     93:        alarm(10);
                     94:        if((fd = open(t, 1)) < 0) {
                     95:                fprintf(stderr,"cannot open %s\n", t);
                     96:                exit(1);
                     97:        }
                     98:        write(fd, mesg, mlen);
                     99:        close(fd);
                    100: 
                    101:        /*
                    102:         * Bitchin'.
                    103:         */
                    104: 
                    105:        exit(0);
                    106: }
                    107: 
                    108: /*
                    109:  * don't write on ttys whose mode is 0
                    110:  * hack to prevent hanging ndcon
                    111:  */
                    112: 
                    113: ckmode(tty)
                    114: char *tty;
                    115: {
                    116:        struct stat sb;
                    117: 
                    118:        if (stat(tty, &sb) < 0)
                    119:                return (1);     /* eh? */
                    120:        if (sb.st_mode & ~S_IFMT)
                    121:                return (1);
                    122:        return (0);
                    123: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.