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

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.