Return to config.c CVS log

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

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

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

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