Return to setupmap.c CVS log

Up to [Research Unix] / researchv10no / netfs / libnetb

Annotation of researchv10no/netfs/libnetb/setupmap.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * make userid and groupid maps
        !             3:  * combine the client ids sent by setup
        !             4:  * with the server ids left around by the user code
        !             5:  */
        !             6: 
        !             7: #include <ctype.h>
        !             8: #include "rf.h"
        !             9: #include "perm.h"
        !            10: 
        !            11: #define        NULL    0
        !            12: 
        !            13: Idmap *rfuidmap, *rfgidmap;
        !            14: 
        !            15: char *defaultuser = 0;
        !            16: char *defaultgroup = 0;
        !            17: 
        !            18: int defaultuid = RFNOID;
        !            19: int defaultgid = RFNOID;
        !            20: 
        !            21: static int mapbuild();
        !            22: static char *getpair();
        !            23: 
        !            24: extern char *malloc(), *realloc();
        !            25: 
        !            26: _rfmapuid(rbuf)
        !            27: char *rbuf;
        !            28: {
        !            29:        static int nuids;
        !            30: 
        !            31:        if (defaultuser)
        !            32:                defaultuid = _rflookid(rfuidmap, defaultuser);
        !            33:        if (mapbuild(rbuf, rfuidmap, &_rfuids, &nuids, defaultuser) == 0)
        !            34:                return (0);
        !            35:        _rfmkhash(_rfuids, nuids, &_rfuhp, &_rfcu, &_rfsu);
        !            36:        return (1);
        !            37: }
        !            38: 
        !            39: _rfmapgid(rbuf)
        !            40: char *rbuf;
        !            41: {
        !            42:        static int ngids;
        !            43: 
        !            44:        if (defaultgroup)
        !            45:                defaultgid = _rflookid(rfgidmap, defaultgroup);
        !            46:        if (mapbuild(rbuf, rfgidmap, &_rfgids, &ngids, defaultgroup) == 0)
        !            47:                return (0);
        !            48:        _rfmkhash(_rfgids, ngids, &_rfghp, &_rfcg, &_rfsg);
        !            49:        return (1);
        !            50: }
        !            51: 
        !            52: /*
        !            53:  * combine server names and ids (locmap)
        !            54:  * with client names and ids (rdata)
        !            55:  * to make an id-id map (returned, length in *lsize)
        !            56:  * return nonzero if this was the last buffer,
        !            57:  * zero if more data are expected.  If the remote name
        !            58:  * doesn't map to a local name, and defaultlocal is non-zero,
        !            59:  * map it to the defaultlocal name.
        !            60:  */
        !            61: static int
        !            62: mapbuild(rdata, locmap, lmap, lsize, defaultlocal)
        !            63: char *rdata;
        !            64: Idmap *locmap;
        !            65: Tuid **lmap;
        !            66: int *lsize;
        !            67: char *defaultlocal;
        !            68: {
        !            69:        char *cname;
        !            70:        char *p;
        !            71:        int cid, sid;
        !            72:        Tuid *map;
        !            73:        register Tuid *cur, *last;
        !            74:        int size;
        !            75:        int curoff;
        !            76:        Idmap nilmap;
        !            77:        int done;
        !            78: 
        !            79:        if (locmap == NULL) {
        !            80:                locmap = &nilmap;
        !            81:                nilmap.name[0] = 0;
        !            82:        }
        !            83:        if ((size = *lsize) != 0) {     /* already started */
        !            84:                map = *lmap;
        !            85:                cur = &map[size];
        !            86:                while (--cur >= map && cur->sid == RFNOID)
        !            87:                        ;
        !            88:                cur++;          /* point to first unused slot */
        !            89:        } else {
        !            90:                size = 100;     /* too big for groups, but too bad */
        !            91:                if ((map = (Tuid *)malloc(size * sizeof(Tuid))) == NULL)
        !            92:                        rfpanic("out of memory making id map\n");
        !            93:                cur = map;
        !            94:        }
        !            95:        last = &map[size-1];
        !            96:        p = rdata;
        !            97:        done = 1;               /* assume we'll get whole buffer */
        !            98:        while ((p = getpair(p, &cname, &cid)) != NULL) {
        !            99:                if (cname[0] == 0 || cid == RFNOID)
        !           100:                        continue;
        !           101:                if (cname[0] == ':' && cname[1] == 0) { /* continuation mark */
        !           102:                        done = 0;
        !           103:                        break;
        !           104:                }
        !           105:                if ((sid = _rflookid(locmap, cname)) == RFNOID)
        !           106: #ifdef notdef
        !           107:                        if (defaultlocal == 0 ||
        !           108:                           (sid = _rflookid(locmap, defaultlocal)) == RFNOID)
        !           109: #endif
        !           110:                                continue;
        !           111:                if (cur >= last) {
        !           112:                        curoff = cur - map;
        !           113:                        size += 100;
        !           114:                        if ((map = (Tuid *)realloc((char *)map, size*sizeof(Tuid))) == NULL)
        !           115:                                rfpanic("out of memory making id map\n");
        !           116:                        last = &map[size-1];
        !           117:                        cur = &map[curoff];
        !           118:                }
        !           119:                cur->sid = sid;
        !           120:                cur->cid = cid;
        !           121:                cur++;
        !           122:        }
        !           123:        cur->sid = cur->cid = RFNOID;   /* end marker */
        !           124:        if (done == 0) {        /* i don't especially like this */
        !           125:                for (cur++; cur <= last; cur++)
        !           126:                        cur->sid = RFNOID;
        !           127:                /* now (cur-map) == size == allocated size */
        !           128:        }
        !           129:        *lsize = cur - map;
        !           130:        *lmap = map;
        !           131:        return (done);
        !           132: }
        !           133: 
        !           134: static char *
        !           135: getpair(line, pname, pnum)
        !           136: char *line;
        !           137: char **pname;
        !           138: int *pnum;
        !           139: {
        !           140:        register char *p;
        !           141: 
        !           142:        p = line;
        !           143:        while (isspace(*p))
        !           144:                p++;
        !           145:        *pname = p;
        !           146:        while (!isspace(*p)) {
        !           147:                if (*p == '\n' || *p == 0)
        !           148:                        return (NULL);
        !           149:                p++;
        !           150:        }
        !           151:        while (isspace(*p))
        !           152:                *p++ = 0;
        !           153:        *pnum = atoi(p);
        !           154:        if (*p == '-' || *p == '+')     /* well ... */
        !           155:                p++;
        !           156:        while (isdigit(*p))
        !           157:                p++;
        !           158:        if (*p != '\n')
        !           159:                return (NULL);
        !           160:        return (p+1);
        !           161: }

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