Return to util.c CVS log

Up to [Research Unix] / researchv10no / cmd / nupas / ipc

Annotation of researchv10no/cmd/nupas/ipc/util.c, revision 1.1

1.1     ! root        1: #include <stdio.h>
        !             2: #include <sysexits.h>
        !             3: 
        !             4: static char is_sep[256], is_field[256];
        !             5: static init = 0;
        !             6: 
        !             7: extern int errno;
        !             8: extern char *errstr;
        !             9: 
        !            10: void
        !            11: setfields(arg)
        !            12:        char *arg;
        !            13: {
        !            14:        register unsigned char *s = (unsigned char *)arg;
        !            15: 
        !            16:        memset(is_sep, 0, sizeof is_sep);
        !            17:        memset(is_field, 1, sizeof is_field);
        !            18:        while(*s){
        !            19:                is_sep[*s] = 1;
        !            20:                is_field[*s++] = 0;
        !            21:        }
        !            22:        is_field[0] = 0;
        !            23:        init = 1;
        !            24: }
        !            25: 
        !            26: getfields(ss, sp, nptrs)
        !            27:        char *ss;
        !            28:        char **sp;
        !            29: {
        !            30:        register unsigned char *s = (unsigned char *)ss;
        !            31:        register unsigned char **p = (unsigned char **)sp;
        !            32:        register unsigned c;
        !            33: 
        !            34:        if(init == 0)
        !            35:                setfields(" \t");
        !            36:        for(;;){
        !            37:                if(--nptrs < 0) break;
        !            38:                *p++ = s;
        !            39:                while(is_field[c = *s++]);
        !            40:                if(c == 0) break;
        !            41:                s[-1] = 0;
        !            42:        }
        !            43:        if(nptrs > 0)
        !            44:                *p = 0;
        !            45:        else if(--s >= (unsigned char *)ss)
        !            46:                *s = c;
        !            47:        return(p - (unsigned char **)sp);
        !            48: }
        !            49: 
        !            50: getmfields(ss, sp, nptrs)
        !            51:        char *ss;
        !            52:        char **sp;
        !            53: {
        !            54:        register unsigned char *s = (unsigned char *)ss;
        !            55:        register unsigned char **p = (unsigned char **)sp;
        !            56:        register unsigned c;
        !            57:        unsigned char *goo;
        !            58: 
        !            59:        if(init == 0)
        !            60:                setfields(" \t");
        !            61:        if(*s){
        !            62:                while(nptrs-- > 0){
        !            63:                        *p++ = s;
        !            64:                        while(is_field[*s++]);
        !            65:                        goo = s-1;
        !            66:                        if((c = *goo) == 0)
        !            67:                                break;
        !            68:                        *goo = 0;
        !            69:                        while(is_sep[*s]) s++;
        !            70:                        if(*s == 0) break;
        !            71:                }
        !            72:        }
        !            73:        if(nptrs > 0)   /* plenty of room */
        !            74:                *p = 0;
        !            75:        else if(*s)     /* no room and we found a trailing non-is_seper */
        !            76:                *goo = c;
        !            77:        return(p - (unsigned char **)sp);
        !            78: }
        !            79: 
        !            80: /*
        !            81:  * Crude version of BSD socket recv command
        !            82:  */
        !            83: int
        !            84: recv(fd, buf, n, flags)
        !            85: int fd;
        !            86: char *buf;
        !            87: int n, flags;
        !            88: {
        !            89:        if (flags != 0) {
        !            90:                ipcseterror(EX_SOFTWARE, "flags not allowed", "recv");
        !            91:                return(-1);
        !            92:        }
        !            93:        return(read(fd, buf, n));
        !            94: }
        !            95: 
        !            96: /*
        !            97:  * Crude version of BSD socket send command
        !            98:  */
        !            99: int
        !           100: send(fd, buf, n, flags)
        !           101: int fd;
        !           102: char *buf;
        !           103: int n, flags;
        !           104: {
        !           105:        if (flags != 0) {
        !           106:                ipcseterror(EX_SOFTWARE, "flags not allowed", "send");
        !           107:                return(-1);
        !           108:        }
        !           109:        return(write(fd, buf, n));
        !           110: }

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