Return to mapping.c CVS log

Up to [Research Unix] / researchv9 / ipc / src / mgrs / svcmgr

Annotation of researchv9/ipc/src/mgrs/svcmgr/mapping.c, revision 1.1.1.1

1.1       root        1: #include "mgr.h"
                      2: 
                      3: Mapping *maphead;              
                      4: Mapping *maptail;
                      5: 
                      6: /*
                      7:  *  Create a new mapping from a string.  The mapping is of the form:
                      8:  *  `service-re source-re olduser-re newuser-exp'
                      9:  */
                     10: Mapping *
                     11: newmap(cp)
                     12:        char *cp;
                     13: {
                     14:        Mapping *mp = (Mapping *)malloc(sizeof(Mapping));
                     15: #      define FIELDS 4
                     16:        char *fields[FIELDS];
                     17:        int n;
                     18: 
                     19:        if(mp==NULL) {
                     20:                logevent("out of memory allocating mapping\n");
                     21:                return NULL;
                     22:        }
                     23:        mp->user = mp->from = mp->serv = NULL;
                     24:        mp->luser = NULL;
                     25:        setfields(" \t");
                     26:        n = getmfields(cp, fields, FIELDS);
                     27:        switch(n) {
                     28:        case 0:
                     29:                freemap(mp);
                     30:                return NULL;
                     31:        case 1:
                     32:                fields[1] = "";
                     33:        case 2:
                     34:                fields[2] = ".*";
                     35:        case 3:
                     36:                fields[3] = "&";
                     37:                break;
                     38:        case 4:
                     39:                break;
                     40:        default:
                     41:                logevent("incorrect number of fields in mapping %s\n", fields[0]);
                     42:                freemap(mp);
                     43:                return NULL;
                     44:        }
                     45:        if((mp->serv=nregcomp(fields[0]))==NULL
                     46:        || (mp->from=nregcomp(fields[1]))==NULL
                     47:        || (mp->user=nregcomp(fields[2]))==NULL) {
                     48:                logevent("illegal reg exp in mapping `%s %s %s %s'\n", fields[0],
                     49:                        fields[1], fields[2], fields[3]);
                     50:                freemap(mp);
                     51:                return NULL;
                     52:        }
                     53:        mp->luser = strdup(fields[3]);
                     54:        logevent("newmap(%s %s %s %s)\n", fields[0], fields[1], fields[2], fields[3]);
                     55:        return mp;
                     56: }
                     57: 
                     58: freemap(mp)
                     59:        Mapping *mp;
                     60: {
                     61:        if(mp==NULL)
                     62:                return;
                     63:        if(mp->from)
                     64:                free((char *)mp->from);
                     65:        if(mp->serv)
                     66:                free((char *)mp->serv);
                     67:        if(mp->user)
                     68:                free((char *)mp->user);
                     69:        if(mp->luser)
                     70:                free(mp->luser);
                     71: }
                     72: 
                     73: /*
                     74:  *  add a map entry
                     75:  */
                     76: addmap(mp)
                     77:        Mapping *mp;
                     78: {
                     79:        mp->next = NULL;
                     80:        if(maphead==NULL)
                     81:                maphead = mp;
                     82:        else
                     83:                maptail->next = mp;
                     84:        maptail = mp;
                     85: }
                     86: 
                     87: /*
                     88:  *  free all map entries
                     89:  */
                     90: resetmaps()
                     91: {
                     92:        Mapping *mp, *nxt;
                     93: 
                     94:        logevent("resetmaps()\n");
                     95:        for(mp=maphead; mp; mp=nxt) {
                     96:                nxt = mp->next;
                     97:                freemap(mp);
                     98:        }
                     99:        maphead = maptail = NULL;
                    100: }
                    101: 
                    102: /*
                    103:  *  return a new user id for call
                    104:  */
                    105: char *
                    106: mapuser(service, source, user)
                    107:        char *service;
                    108:        char *source;
                    109:        char *user;
                    110: {
                    111:        Mapping *mp;
                    112:        regsubexp sub[10];
                    113:        static char luser[ARB];
                    114: 
                    115:        for(mp=maphead; mp; mp=mp->next) {
                    116:                if(!regexec(mp->serv, service, 0, 0))
                    117:                        continue;
                    118:                if(!regexec(mp->from, source, 0, 0))
                    119:                        continue;
                    120:                if(!regexec(mp->user, user, sub, 10))
                    121:                        continue;
                    122:                regsub(mp->luser, luser, sub, 10);
                    123:                return luser;
                    124:        }
                    125:        return NULL;
                    126: }

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