Return to rcmd.c CVS log

Up to [CSRG BSD Unix] / 42BSD / lib / libc / net

Annotation of 42BSD/lib/libc/net/rcmd.c, revision 1.1

1.1     ! root        1: #ifndef lint
        !             2: static char sccsid[] = "@(#)rcmd.c     4.8 3/19/83";
        !             3: #endif
        !             4: 
        !             5: #include <stdio.h>
        !             6: #include <sys/types.h>
        !             7: #include <sys/socket.h>
        !             8: 
        !             9: #include <netinet/in.h>
        !            10: 
        !            11: #include <netdb.h>
        !            12: #include <errno.h>
        !            13: 
        !            14: extern errno;
        !            15: char   *index(), *sprintf();
        !            16: 
        !            17: rcmd(ahost, rport, locuser, remuser, cmd, fd2p)
        !            18:        char **ahost;
        !            19:        int rport;
        !            20:        char *locuser, *remuser, *cmd;
        !            21:        int *fd2p;
        !            22: {
        !            23:        int s, timo = 1;
        !            24:        struct sockaddr_in sin, sin2, from;
        !            25:        char c;
        !            26:        int lport = IPPORT_RESERVED - 1;
        !            27:        struct hostent *hp;
        !            28: 
        !            29:        hp = gethostbyname(*ahost);
        !            30:        if (hp == 0) {
        !            31:                fprintf(stderr, "%s: unknown host\n", *ahost);
        !            32:                return (-1);
        !            33:        }
        !            34:        *ahost = hp->h_name;
        !            35: retry:
        !            36:        s = rresvport(&lport);
        !            37:        if (s < 0)
        !            38:                return (-1);
        !            39:        sin.sin_family = hp->h_addrtype;
        !            40:        bcopy(hp->h_addr, (caddr_t)&sin.sin_addr, hp->h_length);
        !            41:        sin.sin_port = rport;
        !            42:        if (connect(s, (caddr_t)&sin, sizeof (sin), 0) < 0) {
        !            43:                if (errno == EADDRINUSE) {
        !            44:                        close(s);
        !            45:                        lport--;
        !            46:                        goto retry;
        !            47:                }
        !            48:                if (errno == ECONNREFUSED && timo <= 16) {
        !            49:                        (void) close(s);
        !            50:                        sleep(timo);
        !            51:                        timo *= 2;
        !            52:                        goto retry;
        !            53:                }
        !            54:                perror(hp->h_name);
        !            55:                return (-1);
        !            56:        }
        !            57:        lport--;
        !            58:        if (fd2p == 0) {
        !            59:                write(s, "", 1);
        !            60:                lport = 0;
        !            61:        } else {
        !            62:                char num[8];
        !            63:                int s2 = rresvport(&lport), s3;
        !            64: 
        !            65:                if (s2 < 0) {
        !            66:                        (void) close(s);
        !            67:                        return (-1);
        !            68:                }
        !            69:                listen(s2, 1);
        !            70:                (void) sprintf(num, "%d", lport);
        !            71:                if (write(s, num, strlen(num)+1) != strlen(num)+1) {
        !            72:                        perror("write: setting up stderr");
        !            73:                        (void) close(s2);
        !            74:                        goto bad;
        !            75:                }
        !            76:                { int len = sizeof (from);
        !            77:                  s3 = accept(s2, &from, &len, 0);
        !            78:                  close(s2);
        !            79:                  if (s3 < 0) {
        !            80:                        perror("accept");
        !            81:                        lport = 0;
        !            82:                        goto bad;
        !            83:                  }
        !            84:                }
        !            85:                *fd2p = s3;
        !            86:                from.sin_port = ntohs((u_short)from.sin_port);
        !            87:                if (from.sin_family != AF_INET ||
        !            88:                    from.sin_port >= IPPORT_RESERVED) {
        !            89:                        fprintf(stderr,
        !            90:                            "socket: protocol failure in circuit setup.\n");
        !            91:                        goto bad2;
        !            92:                }
        !            93:        }
        !            94:        (void) write(s, locuser, strlen(locuser)+1);
        !            95:        (void) write(s, remuser, strlen(remuser)+1);
        !            96:        (void) write(s, cmd, strlen(cmd)+1);
        !            97:        if (read(s, &c, 1) != 1) {
        !            98:                perror(*ahost);
        !            99:                goto bad2;
        !           100:        }
        !           101:        if (c != 0) {
        !           102:                while (read(s, &c, 1) == 1) {
        !           103:                        (void) write(2, &c, 1);
        !           104:                        if (c == '\n')
        !           105:                                break;
        !           106:                }
        !           107:                goto bad2;
        !           108:        }
        !           109:        return (s);
        !           110: bad2:
        !           111:        if (lport)
        !           112:                (void) close(*fd2p);
        !           113: bad:
        !           114:        (void) close(s);
        !           115:        return (-1);
        !           116: }
        !           117: 
        !           118: rresvport(alport)
        !           119:        int *alport;
        !           120: {
        !           121:        struct sockaddr_in sin;
        !           122:        int s;
        !           123: 
        !           124:        sin.sin_family = AF_INET;
        !           125:        sin.sin_addr.s_addr = 0;
        !           126:        s = socket(AF_INET, SOCK_STREAM, 0, 0);
        !           127:        if (s < 0)
        !           128:                return (-1);
        !           129:        for (;;) {
        !           130:                sin.sin_port = htons((u_short)*alport);
        !           131:                if (bind(s, (caddr_t)&sin, sizeof (sin), 0) >= 0)
        !           132:                        return (s);
        !           133:                if (errno != EADDRINUSE && errno != EADDRNOTAVAIL) {
        !           134:                        perror("socket");
        !           135:                        return (-1);
        !           136:                }
        !           137:                (*alport)--;
        !           138:                if (*alport == IPPORT_RESERVED/2) {
        !           139:                        fprintf(stderr, "socket: All ports in use\n");
        !           140:                        return (-1);
        !           141:                }
        !           142:        }
        !           143: }
        !           144: 
        !           145: ruserok(rhost, superuser, ruser, luser)
        !           146:        char *rhost;
        !           147:        int superuser;
        !           148:        char *ruser, *luser;
        !           149: {
        !           150:        FILE *hostf;
        !           151:        char ahost[32];
        !           152:        int first = 1;
        !           153: 
        !           154:        hostf = superuser ? (FILE *)0 : fopen("/etc/hosts.equiv", "r");
        !           155: again:
        !           156:        if (hostf) {
        !           157:                while (fgets(ahost, sizeof (ahost), hostf)) {
        !           158:                        char *user;
        !           159:                        if (index(ahost, '\n'))
        !           160:                                *index(ahost, '\n') = 0;
        !           161:                        user = index(ahost, ' ');
        !           162:                        if (user)
        !           163:                                *user++ = 0;
        !           164:                        if (!strcmp(rhost, ahost) &&
        !           165:                            !strcmp(ruser, user ? user : luser)) {
        !           166:                                (void) fclose(hostf);
        !           167:                                return (0);
        !           168:                        }
        !           169:                }
        !           170:                (void) fclose(hostf);
        !           171:        }
        !           172:        if (first == 1) {
        !           173:                first = 0;
        !           174:                hostf = fopen(".rhosts", "r");
        !           175:                goto again;
        !           176:        }
        !           177:        return (-1);
        !           178: }

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