Return to talkd.c CVS log

Up to [CSRG BSD Unix] / 42BSD / ucb / talk

Annotation of 42BSD/ucb/talk/talkd.c, revision 1.1

1.1     ! root        1: /* $Header: talkd.c 1.5 83/05/10 13:57:29 moore Exp $ */
        !             2: 
        !             3: /* The top level of the daemon, the format is heavily borrowed
        !             4:    from rwhod.c. Basically: find out who and where you are; 
        !             5:    disconnect all descriptors and ttys, and then endless
        !             6:    loop on waiting for and processing requests
        !             7:  */
        !             8: 
        !             9: #include "ctl.h"
        !            10: 
        !            11: #include <stdio.h>
        !            12: #include <errno.h>
        !            13: #include <sgtty.h>
        !            14: #include <sys/ioctl.h>
        !            15: 
        !            16: #define MAX_ERR 20     /* Number of times to attempt to open the 
        !            17:                           control socket */
        !            18: 
        !            19: extern errno;
        !            20: 
        !            21: struct sockaddr_in sin = { AF_INET };
        !            22: 
        !            23: CTL_MSG request;
        !            24: CTL_RESPONSE response;
        !            25: int sockt;
        !            26: char hostname[HOST_NAME_LENGTH];
        !            27: 
        !            28: struct hostent *gethostbyname();
        !            29: struct servent *getservbyname();
        !            30: 
        !            31: int debug = 0;
        !            32: 
        !            33: main(argc)
        !            34: int argc;
        !            35: {
        !            36:     struct sockaddr_in from;
        !            37:     int from_size;
        !            38:     int cc;
        !            39:     int name_length = sizeof(hostname);
        !            40:     struct servent *sp;
        !            41:     struct hostent *hp;
        !            42: 
        !            43: 
        !            44:     if ( argc > 1 ) {
        !            45:        debug = 1;
        !            46:     }
        !            47: 
        !            48:     if ( !debug ) {
        !            49:        if (fork()) {
        !            50:            exit(0);
        !            51:        }
        !            52:     }
        !            53: 
        !            54:     gethostname(hostname, &name_length);
        !            55: 
        !            56:     hp = gethostbyname(hostname);
        !            57:     if (hp == (struct hostent *) 0) {
        !            58:            fprintf(stderr, "talkd: Cannot obtain local address\n");
        !            59:            exit(1);
        !            60:     }
        !            61: 
        !            62: #ifdef NTALK
        !            63:     sp = getservbyname("ntalk", "udp");
        !            64: #else
        !            65:     sp = getservbyname("talk", "udp");
        !            66: #endif
        !            67: 
        !            68:     if (sp == 0) {
        !            69:            fprintf(stderr, "talkd: udp/talk: unknown service\n");
        !            70:            exit(1);
        !            71:     }
        !            72: 
        !            73:     if (getuid()) {
        !            74:        fprintf(stderr, "Talkd : not super user\n");
        !            75:        exit(1);
        !            76:     }
        !            77: 
        !            78:     setup_desc();
        !            79: 
        !            80:     sin.sin_port = sp->s_port;
        !            81:     sockt = socket(AF_INET, SOCK_DGRAM, 0, 0);
        !            82:     if (sockt < 0) {
        !            83:            print_error("talkd: socket");
        !            84:            exit(1);
        !            85:     }
        !            86: 
        !            87:     if (bind(sockt, (caddr_t)&sin, sizeof (sin), 0) < 0) {
        !            88:        print_error("bind");
        !            89:        exit(1);
        !            90:     }
        !            91: 
        !            92:     for (;;) {
        !            93: 
        !            94:        from_size = sizeof(from);
        !            95:        cc = recvfrom(sockt, (char *)&request, sizeof (request), 0, 
        !            96:                      &from, &from_size);
        !            97: 
        !            98:        if (cc != sizeof(request)) {
        !            99:            if (cc < 0 && errno != EINTR) {
        !           100:                print_error("receive");
        !           101:            }
        !           102:        } else {
        !           103: 
        !           104:            if (debug) printf("Request received : \n");
        !           105:            if (debug) print_request(&request);
        !           106: 
        !           107:            process_request(&request, &response);
        !           108: 
        !           109:            if (debug) printf("Response sent : \n");
        !           110:            if (debug) print_response(&response);
        !           111: 
        !           112:                /* can block here, is this what I want? */
        !           113: 
        !           114:            cc = sendto(sockt, (char *) &response, sizeof(response), 0,
        !           115:                        &request.ctl_addr, sizeof(request.ctl_addr));
        !           116: 
        !           117:            if (cc != sizeof(response)) {
        !           118:                print_error("Send");
        !           119:            }
        !           120:        }
        !           121:     }
        !           122: }
        !           123: 
        !           124:     /* disconnect all descriptors, remove ourself from the process
        !           125:      * group that spawned us
        !           126:      */
        !           127: 
        !           128: setup_desc()
        !           129: {
        !           130:     int s;
        !           131: 
        !           132:     if (debug) return;
        !           133: 
        !           134:     for (s = 0; s < 10; s++) {
        !           135:        (void) close(s);
        !           136:     }
        !           137: 
        !           138:     (void) open("/dev/null", 0);
        !           139:     (void) dup2(0, 1);
        !           140:     (void) dup2(0, 2);
        !           141: 
        !           142:     s = open("/dev/tty", 2);
        !           143: 
        !           144:     if (s >= 0) {
        !           145:        ioctl(s, TIOCNOTTY, (struct sgttyb *) 0);
        !           146:        (void) close(s);
        !           147:     }
        !           148: 
        !           149:     (void) chdir("/dev");
        !           150: }
        !           151: 
        !           152: extern int sys_nerr;
        !           153: extern char *sys_errlist[];
        !           154: 
        !           155: print_error(string)
        !           156: char *string;
        !           157: {
        !           158:     FILE *cons;
        !           159:     char *err_dev = "/dev/console";
        !           160:     char *sys;
        !           161:     int val, pid;
        !           162: 
        !           163:     if (debug) err_dev = "/dev/tty";
        !           164: 
        !           165:     sys = "Unknown error";
        !           166: 
        !           167:     if(errno < sys_nerr) {
        !           168:        sys = sys_errlist[errno];
        !           169:     }
        !           170: 
        !           171:        /* don't ever open tty's directly, let a child do it */
        !           172:     if ((pid = fork()) == 0) {
        !           173:        cons = fopen(err_dev, "a");
        !           174:        if (cons != NULL) {
        !           175:            fprintf(cons, "Talkd : %s : %s(%d)\n\r", string, sys,
        !           176:                    errno);
        !           177:            fclose(cons);
        !           178:        }
        !           179:        exit(0);
        !           180:     } else {
        !           181:            /* wait for the child process to return */
        !           182:        do {
        !           183:            val = wait(0);
        !           184:            if (val == -1) {
        !           185:                if (errno == EINTR) {
        !           186:                    continue;
        !           187:                } else if (errno == ECHILD) {
        !           188:                    break;
        !           189:                }
        !           190:            }
        !           191:        } while (val != pid);
        !           192:     }
        !           193: }

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