Return to tcp_lib.c CVS log

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

Annotation of researchv9/ipc/src/libin/tcp_lib.c, revision 1.1

1.1     ! root        1: #include <sys/inet/tcp_user.h>
        !             2: #include <sys/inet/socket.h>
        !             3: #include <ctype.h>
        !             4: #include <stdio.h>
        !             5: #include <errno.h>
        !             6: #include "config.h"
        !             7: 
        !             8: extern errno;
        !             9: 
        !            10: tcp_sock()
        !            11: {
        !            12:        int fd, n;
        !            13:        char name[32];
        !            14: 
        !            15:        for(n = 01; n < 100; n += 2){
        !            16:                sprintf(name, "/dev/tcp%02d", n);
        !            17:                fd = open(name, 2);
        !            18:                if(fd >= 0)
        !            19:                        return(fd);
        !            20:                if(errno != ENXIO)
        !            21:                        break;
        !            22:        }
        !            23:        perror(name);
        !            24:        return(-1);
        !            25: }
        !            26: 
        !            27: tcp_connect(fd, tp)
        !            28:        int fd;
        !            29:        struct tcpuser *tp;
        !            30: {
        !            31:        tp->code = TCPC_CONNECT;
        !            32:        if (write(fd, (char *)tp, sizeof(struct tcpuser))!=sizeof(struct tcpuser))
        !            33:                return -1;
        !            34:        if (read(fd, (char *)tp, sizeof(struct tcpuser))!=sizeof(struct tcpuser))
        !            35:                return -2;
        !            36:        if(tp->code != TCPC_OK)
        !            37:                return -3;
        !            38:        return 0;
        !            39: }
        !            40: 
        !            41: tcp_listen(fd, tp)
        !            42:        int fd;
        !            43:        struct tcpuser *tp;
        !            44: {
        !            45:        tp->code = TCPC_LISTEN;
        !            46:        if (write(fd, (char *)tp, sizeof(struct tcpuser))!=sizeof(struct tcpuser))
        !            47:                return -1;
        !            48:        if (read(fd, (char *)tp, sizeof(struct tcpuser))!=sizeof(struct tcpuser))
        !            49:                return -1;
        !            50:        if(tp->code != TCPC_OK)
        !            51:                return -1;
        !            52:        return 0;
        !            53: }
        !            54: 
        !            55: tcp_accept(fd, tp)
        !            56:        int fd;
        !            57:        struct tcpuser *tp;
        !            58: {
        !            59:        char name[128];
        !            60: 
        !            61:        if (read(fd, (char *)tp, sizeof(struct tcpuser))!=sizeof(struct tcpuser))
        !            62:                return -1;
        !            63:        if (tp->code != TCPC_OK)
        !            64:                return -1;
        !            65:        sprintf(name, "/dev/tcp%02d", tp->param);
        !            66:        return open(name, 2);
        !            67: }
        !            68: 
        !            69: tcp_rcmd(host, port, locuser, remuser, cmd, fd2p)
        !            70: char *host, *port, *locuser, *remuser, *cmd;
        !            71: int *fd2p;
        !            72: {
        !            73:        char buf[1];
        !            74:        int fd;
        !            75:        struct in_service *sp;
        !            76:        struct tcpuser tu;
        !            77:        in_addr in_address();
        !            78: 
        !            79:        tu.faddr = in_address(host);
        !            80:        if(tu.faddr == 0){
        !            81:                fprintf(stderr, "%s: unknown host\n", host);
        !            82:                return(-1);
        !            83:        }
        !            84:        sp = in_service(port, "tcp", 0L);
        !            85:        if(sp == 0){
        !            86:                fprintf(stderr, "%s: unknown service\n", port);
        !            87:                return(-1);
        !            88:        }
        !            89:        tu.fport = sp->port;
        !            90:        fd = tcp_sock();
        !            91:        if(fd < 0){
        !            92:                perror(host);
        !            93:                return(-1);
        !            94:        }
        !            95:        tu.laddr = INADDR_ANY;
        !            96:        tu.lport = 0;
        !            97:        tu.param = 0;
        !            98:        if(tcp_connect(fd, &tu) < 0){
        !            99:                fprintf(stderr, "%s: connection failed\n", host);
        !           100:                goto bad;
        !           101:        }
        !           102: 
        !           103:        if(fd2p == 0)
        !           104:                write(fd, "", 1);
        !           105:        else
        !           106:                goto bad;       /* later */
        !           107: 
        !           108:        write(fd, locuser, strlen(locuser)+1);
        !           109:        write(fd, remuser, strlen(remuser)+1);
        !           110:        write(fd, cmd, strlen(cmd)+1);
        !           111: 
        !           112:        if(read(fd, buf, 1) != 1){
        !           113:                perror(host);
        !           114:                goto bad;
        !           115:        }
        !           116:        if(buf[0] != 0){
        !           117:                while(read(fd, buf, 1) == 1){
        !           118:                        write(2, buf, 1);
        !           119:                        if(buf[0] == '\n')
        !           120:                                break;
        !           121:                }
        !           122:                goto bad;
        !           123:        }
        !           124:        return(fd);
        !           125: bad:
        !           126:        close(fd);
        !           127:        return(-1);
        !           128: }

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