Return to ipcproto.c CVS log

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

Annotation of researchv9/ipc/src/libipc/ipcproto.c, revision 1.1

1.1     ! root        1: #include <sys/types.h>
        !             2: #include <sys/ioctl.h>
        !             3: #include <pwd.h>
        !             4: #include <ipc.h>
        !             5: #include "defs.h"
        !             6: 
        !             7: /* buffer definition */
        !             8: #define BUFLEN 512
        !             9: 
        !            10: /* have to define this somewhere */
        !            11: char *ipcname;
        !            12: 
        !            13: /*
        !            14:  *  Recieve an fd
        !            15:  */
        !            16: _fd_read(onfd, pp)
        !            17:        int onfd;
        !            18:        struct passfd *pp;
        !            19: {
        !            20:        register int rv;
        !            21: 
        !            22:        while((rv=ioctl(onfd, FIORCVFD, pp))<0 && errno==EINTR)
        !            23:                ;
        !            24:        return rv;
        !            25: }
        !            26: 
        !            27: /*
        !            28:  *  Send an fd
        !            29:  */
        !            30: _fd_write(onfd, tofd)
        !            31: {
        !            32:        return ioctl(onfd, FIOSNDFD, &tofd);
        !            33: }
        !            34: 
        !            35: /*
        !            36:  *  Send the connection info.
        !            37:  */
        !            38: int
        !            39: _info_write(fd, ip)
        !            40:        int fd;
        !            41:        ipcinfo *ip;
        !            42: {
        !            43:        char b[BUFLEN];
        !            44:        int n;
        !            45: 
        !            46:        if (ip->name==NULL)
        !            47:                ip->name = "";
        !            48:        if (ip->param==NULL)
        !            49:                ip->param = "";
        !            50:        if (ip->machine==NULL)
        !            51:                ip->machine = "";
        !            52:        if (ip->user==NULL)
        !            53:                ip->user = "";
        !            54:        if (ip->myname==NULL)
        !            55:                ip->myname = "";
        !            56:        sprintf(b, "%s\n%s\n%s\n%s\n%s\n%d\n%d\n%d\n", ip->myname, ip->name,
        !            57:                ip->param, ip->machine, ip->user, ip->flags, ip->uid, ip->gid);
        !            58:        n = strlen(b);
        !            59:        if (write(fd, b, n)!=n)
        !            60:                return ABORT(errno, "can't send request", NULLINFO);
        !            61:        return 0;
        !            62: }
        !            63: 
        !            64: /*
        !            65:  *  Read the connection info.  If an error occurs, ip->reply and ip->conn are
        !            66:  *  closed.
        !            67:  */
        !            68: int
        !            69: _info_read(fd, ip)
        !            70:        int fd;
        !            71:        ipcinfo *ip;
        !            72: {
        !            73:        static char b[BUFLEN];
        !            74:        char *f[8];
        !            75:        int n;
        !            76: 
        !            77:        while((n=read(fd, b, sizeof(b)))<0 && errno==EINTR)
        !            78:                ;
        !            79:        if (n <= 0) 
        !            80:                return ABORT(errno, "error reading request", ip);
        !            81:        b[n] = '\0';
        !            82:        setfields("\n");
        !            83:        if (getfields(b, f, 8)!=8)
        !            84:                return ABORT(EINVAL, "protocol botch", ip);
        !            85:        ip->myname = f[0];
        !            86:        ip->name = f[1];
        !            87:        ip->param = f[2];
        !            88:        ip->machine = f[3];
        !            89:        ip->flags = atoi(f[5]);
        !            90: 
        !            91:        /* supply a system name */
        !            92:        if (ip->uid!=ROOTUID || ip->machine[0]=='\0')
        !            93:                ip->machine = "";
        !            94: 
        !            95:        /* supply a user name */
        !            96:        if (ip->uid==ROOTUID && *(f[4])!='\0')
        !            97:                ip->user = f[4];
        !            98: 
        !            99:        /* supply uid/gid cruft */
        !           100:        if (ip->uid==ROOTUID && atoi(f[6])!=-1) {
        !           101:                ip->uid = atoi(f[6]);
        !           102:                ip->gid = atoi(f[7]);
        !           103:        }
        !           104:        return 0;
        !           105: }
        !           106: 
        !           107: /*
        !           108:  *  Send a reply to a connection request
        !           109:  */
        !           110: _reply_write(fd, no, str)
        !           111:        int fd;
        !           112:        int no;
        !           113:        char *str;
        !           114: {
        !           115:        char b[BUFLEN];
        !           116:        int n;
        !           117: 
        !           118:        if (str==NULL)
        !           119:                str = "";
        !           120:        sprintf(b, "%d\n%s\n", no, str);
        !           121:        n = strlen(b);
        !           122:        if (write(fd, b, n)!=n)
        !           123:                return -1;
        !           124:        return 0;
        !           125: }
        !           126: 
        !           127: /*
        !           128:  *  Get a reply to a connection request.
        !           129:  */
        !           130: int
        !           131: _reply_read(fd)
        !           132:        int fd;
        !           133: {
        !           134:        static char b[BUFLEN];
        !           135:        char *f[2];
        !           136:        char *ptr;
        !           137:        int n;
        !           138: 
        !           139:        while((n=read(fd, b, sizeof(b)))<0 && errno==EINTR)
        !           140:                ;
        !           141:        if (n <= 0) 
        !           142:                return ABORT(errno, "error reading request", NULLINFO);
        !           143:        b[n] = '\0';
        !           144:        setfields("\n");
        !           145:        getfields(b, f, 2);
        !           146:        errno = atoi(f[0]);
        !           147:        if ((ptr=strchr(f[1], '\n'))!=NULL)
        !           148:                *ptr = '\0';
        !           149:        if (errno!=0)
        !           150:                errstr = f[1];
        !           151:        else
        !           152:                ipcname = f[1];
        !           153:        return 0;
        !           154: }
        !           155: 

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