Return to fsmkidmap.c CVS log

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

Annotation of researchv10no/netfs/libnetb/fsmkidmap.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * make an ID map for the file server library
                      3:  * takes a /etc/passwd-like file and an optional `exception' list
                      4:  * of explicit mappings;
                      5:  * returns a list of local name-ID mappings to be combined
                      6:  * with those from the client to make an ID-ID map.
                      7:  */
                      8: 
                      9: #include <stdio.h>
                     10: #include <ctype.h>
                     11: #include "rf.h"
                     12: 
                     13: static Idmap *exmerge();
                     14: static int nextid();
                     15: 
                     16: extern char *malloc(), *realloc();
                     17: 
                     18: Idmap *
                     19: rfmkidmap(file, ex)
                     20: char *file;
                     21: Namemap *ex;
                     22: {
                     23:        Idmap *map;
                     24:        register Idmap *cur;
                     25:        register int size;
                     26:        register Idmap *last;
                     27:        int curoff;
                     28:        FILE *fp;
                     29: 
                     30:        if ((fp = fopen(file, "r")) == NULL)
                     31:                rfpanic("can't open map %s\n", file);
                     32:        size = 100;
                     33:        if ((map = (Idmap *)malloc(size*sizeof(Idmap))) == NULL)
                     34:                rfpanic("out of mem for %s map\n", file);
                     35:        last = &map[size - 1];
                     36:        for (cur = map;; cur++) {
                     37:                if (cur >= last) {
                     38:                        curoff = cur - map;     /* realloc may move map */
                     39:                        size += 100;
                     40:                        if ((map = (Idmap *)realloc((char *)map, size*sizeof(Idmap))) == NULL)
                     41:                                rfpanic("out of mem for %s map\n", file);
                     42:                        last = &map[size - 1];
                     43:                        cur = &map[curoff];
                     44:                }
                     45:                if (nextid(cur, fp) == 0)
                     46:                        break;
                     47:        }
                     48:        cur->name[0] = 0;
                     49:        fclose(fp);
                     50:        return (exmerge(map, last, ex));
                     51: }
                     52: 
                     53: /*
                     54:  * pick out the next name and ID from the file
                     55:  * name:junk:number:junk until newline
                     56:  * this matches /etc/passwd and /etc/group,
                     57:  * and is simple enough to fake up
                     58:  */
                     59: static
                     60: nextid(cur, fp)
                     61: Idmap *cur;
                     62: register FILE *fp;
                     63: {
                     64:        register char *p;
                     65:        char buf[150];          /* assume big enough for now */
                     66: 
                     67:        for (;;) {
                     68:                if (fgets(buf, sizeof(buf), fp) == NULL)
                     69:                        return (0);     /* EOF */
                     70:                p = buf;
                     71:                while (*p && *p != ':')
                     72:                        p++;
                     73:                if (*p == 0)
                     74:                        continue;
                     75:                *p++ = 0;
                     76:                strncpy(cur->name, buf, sizeof(cur->name)-1);
                     77:                cur->name[sizeof(cur->name)-1] = 0;
                     78:                while (*p && *p != ':')
                     79:                        p++;
                     80:                if (*p == 0)
                     81:                        continue;
                     82:                p++;
                     83:                if (!isdigit(*p) && *p != '-')
                     84:                        continue;
                     85:                cur->id = atoi(p);
                     86:                return (1);
                     87:        }
                     88: }
                     89: 
                     90: static Idmap *
                     91: exmerge(map, last, ex)
                     92: Idmap *map, *last;
                     93: Namemap *ex;
                     94: {
                     95:        register Idmap *lp;
                     96:        register Namemap *ep;
                     97:        int size, curoff;
                     98:        static Namemap nilex;
                     99: 
                    100:        if (ex == NULL)
                    101:                ex = &nilex;
                    102:        for (ep = ex; ep->cname[0]; ep++) {
                    103:                if (ep->sname[0] == 0)
                    104:                        ep->sid = RFNOID;
                    105:                else
                    106:                        ep->sid = _rflookid(map, ep->sname);
                    107:        }
                    108:        for (lp = map; lp->name[0]; lp++)
                    109:                for (ep = ex; ep->cname[0]; ep++) {
                    110:                        if (ep->cname[0] != lp->name[0])        /* hash */
                    111:                                continue;
                    112:                        if (strcmp(ep->cname, lp->name) == 0) {
                    113:                                lp->id = ep->sid;
                    114:                                ep->sid = RFNOID;
                    115:                        }
                    116:                }
                    117:        /*
                    118:         * add client names not in local file
                    119:         * lp was left at the end of the map
                    120:         */
                    121:        for (ep = ex; ep->cname[0]; ep++) {
                    122:                if (ep->sid == RFNOID)  /* no need to enter */
                    123:                        continue;
                    124:                if (lp >= last) {
                    125:                        curoff = lp - map;
                    126:                        size = curoff + 10;
                    127:                        if ((map = (Idmap *)realloc((char *)map,
                    128:                            size*sizeof(Idmap))) == NULL)
                    129:                                rfpanic("out of mem merging except\n");
                    130:                        last = &map[size - 1];
                    131:                        lp = &map[curoff];
                    132:                }
                    133:                strncpy(lp->name, ep->cname, sizeof(lp->name)-1);
                    134:                lp->id = ep->sid;
                    135:                lp++;
                    136:        }
                    137:        lp->name[0] = 0;
                    138:        return (map);
                    139: }

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