Return to tcpd.c CVS log

Up to [Research Unix] / researchv9 / ipc / src / servers

Annotation of researchv9/ipc/src/servers/tcpd.c, revision 1.1

1.1     ! root        1: #include <stdio.h>
        !             2: #include <ctype.h>
        !             3: #include <sys/inet/tcp_user.h>
        !             4: 
        !             5: int debug;
        !             6: 
        !             7: main(argc, argv)
        !             8: int argc;
        !             9: char **argv;
        !            10: {
        !            11:        int myport;
        !            12:        int mysock;
        !            13:        struct in_service *sp;
        !            14:        struct tcpuser tu;
        !            15:        char *lname;
        !            16:        char *cmd;
        !            17:        char *catargs();
        !            18: 
        !            19:        if (argc < 3) {
        !            20:                fprintf(stderr, "usage: tcpd service login [ cmd ]\n");
        !            21:                exit(1);
        !            22:        }
        !            23:        if (isdigit(argv[1][0]))
        !            24:                myport = atoi(argv[1]);
        !            25:        else {
        !            26:                sp = in_service(argv[1], "tcp", 0);
        !            27:                if (sp == NULL) {
        !            28:                        fprintf(stderr, "tcpd: unlisted service %s\n", argv[1]);
        !            29:                        exit(1);
        !            30:                }
        !            31:                myport = sp->port;
        !            32:        }
        !            33:        tu.laddr = 0;
        !            34:        tu.lport = myport;
        !            35:        lname = argv[2];
        !            36:        if (argc > 3 && strcmp(argv[3], "-x") == 0) {
        !            37:                debug++;
        !            38:                argv++;
        !            39:                argc--;
        !            40:        }
        !            41:        cmd = catargs(&argv[3], argc - 3);
        !            42:        if (debug)
        !            43:                fprintf(stderr, "starting: %d: %s: %s\n", myport, lname, cmd);
        !            44:        if ((mysock = tcp_sock()) < 0) {
        !            45:                fprintf(stderr, "tcpd: no socket\n");
        !            46:                exit(1);
        !            47:        }
        !            48:        tu.fport = 0;
        !            49:        tu.faddr = 0;
        !            50:        tu.param = 0;
        !            51:        if (tcp_listen(mysock, &tu) < 0) {
        !            52:                fprintf(stderr, "tcpd: can't listen\n");
        !            53:                exit(1);
        !            54:        }
        !            55:        for (;;)
        !            56:                daemon(mysock, lname, cmd);
        !            57: }
        !            58: 
        !            59: char *
        !            60: catargs(ap, n)
        !            61: register char **ap;
        !            62: register int n;
        !            63: {
        !            64:        static char buf[200];
        !            65: 
        !            66:        if (n <= 0)
        !            67:                return (NULL);
        !            68:        while (--n >= 0)
        !            69:                strcat(buf, *ap++);
        !            70:        return (buf);
        !            71: }
        !            72: 
        !            73: daemon(s, lname, cmd)
        !            74: int s;
        !            75: char *lname;
        !            76: char *cmd;
        !            77: {
        !            78:        int fd;
        !            79:        int pid;
        !            80:        struct tcpuser tu;
        !            81: 
        !            82:        tu.lport = 0;
        !            83:        tu.laddr = 0;
        !            84:        tu.fport = 0;
        !            85:        tu.faddr = 0;
        !            86:        tu.param = 0;
        !            87:        if ((fd = tcp_accept(s, &tu)) < 0) {
        !            88:                fprintf(stderr, "uucpd: can't accept\n");
        !            89:                perror("accept");
        !            90:                return;
        !            91:        }
        !            92:        if (debug)
        !            93:                logconn(tu.faddr, tu.fport, fd);
        !            94:        if ((pid = fork()) < 0) {
        !            95:                fprintf(stderr, "uucpd: can't fork\n");
        !            96:                close(fd);
        !            97:                return;
        !            98:        }
        !            99:        else if (pid != 0) {
        !           100:                close(fd);
        !           101:                while (wait((int *)0) != pid)
        !           102:                        ;
        !           103:                return;
        !           104:        }
        !           105:        if ((pid = fork()) != 0)
        !           106:                _exit(1);
        !           107:        close(s);
        !           108:        dup2(fd, 0);
        !           109:        dup2(0, 1);
        !           110:        dup2(0, 2);
        !           111:        dup2(0, 3);
        !           112:        execl("/etc/login", "login", "-f", lname, cmd ? cmd: NULL, NULL);
        !           113:        perror("tcpd login");
        !           114:        _exit(1);
        !           115: }
        !           116: 
        !           117: logconn(fa, fp, fd)
        !           118: in_addr fa;
        !           119: tcp_port fp;
        !           120: int fd;
        !           121: {
        !           122:        long t;
        !           123: 
        !           124:        time(&t);
        !           125:        fprintf(stderr, "%.15s conn from %s port %d fd %d\n",
        !           126:                ctime(&t)+4, in_ntoa(fa), fp, fd);
        !           127: }

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