Return to acssort.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / new / notes / src

Annotation of 43BSDTahoe/new/notes/src/acssort.c, revision 1.1

1.1     ! root        1: #include "parms.h"
        !             2: #include "structs.h"
        !             3: 
        !             4: #ifdef RCSIDENT
        !             5: static char rcsid[] = "$Header: acssort.c,v 1.7 85/01/18 15:40:40 notes Rel $";
        !             6: #endif RCSIDENT
        !             7: 
        !             8: /*
        !             9:  *     acssort
        !            10:  *
        !            11:  *     Routines in this file are used to sort access lists.
        !            12:  *     Splintered off from access.c so that nfaccess.c can use
        !            13:  *     them.
        !            14:  *
        !            15:  *     Also contains routines to add entries to an access list
        !            16:  *     and to parse an ascii representation of an access right.
        !            17:  *
        !            18:  *     Ray Essick
        !            19:  */
        !            20: 
        !            21: 
        !            22: acscmp (a, b)
        !            23: struct perm_f  *a,
        !            24:                *b;
        !            25: {
        !            26: /*
        !            27:  *     people before groups before systems
        !            28:  *     Alphabetical within each class
        !            29:  */
        !            30:     if (a -> ptype < b -> ptype)
        !            31:        return (-1);
        !            32:     if (a -> ptype > b -> ptype)
        !            33:        return 1;
        !            34:     if (strcmp ("Other", a -> name) == 0)
        !            35:        if (strcmp ("Other", b -> name) == 0)
        !            36:            return 0;
        !            37:        else
        !            38:            return 1;                                   /* put "Other" last */
        !            39:     if (strcmp ("Other", b -> name) == 0)
        !            40:        return (-1);                                    /* is correct */
        !            41:     return strcmp (a -> name, b -> name);
        !            42: }
        !            43: 
        !            44: /*
        !            45:  *     acssort
        !            46:  *
        !            47:  *     sort the access list
        !            48:  */
        !            49: 
        !            50: acssort (alist, items)
        !            51: struct perm_f   alist[];
        !            52: int     items;
        !            53: {
        !            54:     qsort (alist, items, sizeof (struct perm_f), acscmp);
        !            55: }
        !            56: /*
        !            57:  *     addmodes(io) struct io_f *io;
        !            58:  *
        !            59:  *     reads the access list and adds the modes specified in the
        !            60:  *     Newmodes array.
        !            61:  *     Checks for duplication and merely replaces with the new
        !            62:  *     permission in those cases.
        !            63:  */
        !            64: 
        !            65: addmodes (io, nmodes, Newmodes, verbose)
        !            66: struct io_f *io;
        !            67: int     nmodes;
        !            68: struct perm_f  *Newmodes;
        !            69: int     verbose;
        !            70: {
        !            71:     struct perm_f   alist[NPERMS];
        !            72:     int     pcount;                                    /* items in list */
        !            73:     FILE * acs;
        !            74:     int     i,
        !            75:             j;
        !            76:     char    fn[WDLEN];                                 /* hold a filename */
        !            77: 
        !            78:     sprintf (fn, "%s/%s/%s", io -> basedir, io -> nf, ACCESS);
        !            79:     x ((acs = fopen (fn, "r")) == NULL, "addmode: no access list");
        !            80:     x ((pcount = fread (alist, sizeof (struct perm_f), NPERMS, acs)) == 0, "addmode: empty access list");
        !            81:     fclose (acs);
        !            82: 
        !            83:     for (i = 0; i < nmodes; i++)                       /* for each mode */
        !            84:     {
        !            85:        for (j = 0; j < pcount; j++)                    /* look for match */
        !            86:            if (Newmodes[i].ptype == alist[j].ptype &&
        !            87:                    strcmp (Newmodes[i].name, alist[j].name) == 0)
        !            88:                break;                                  /* match */
        !            89:        if (j == pcount)                                /* wasn't there */
        !            90:        {
        !            91:            if (pcount == NPERMS)
        !            92:            {
        !            93:                if (verbose)
        !            94:                    printf ("%s: access list full\n", io -> nf);
        !            95:                break;
        !            96:            }
        !            97:            alist[pcount].ptype = Newmodes[i].ptype;
        !            98:            alist[pcount].perms = Newmodes[i].perms;
        !            99:            strcpy (alist[pcount].name, Newmodes[i].name);
        !           100:            pcount++;
        !           101:        }
        !           102:        else                                            /* update existing one */
        !           103:        {
        !           104:            alist[j].perms = Newmodes[i].perms;
        !           105:            if (verbose)
        !           106:                printf ("%s: replaced extant permission for %s\n",
        !           107:                        io -> nf, Newmodes[i].name);
        !           108:        }
        !           109:     }
        !           110: /*
        !           111:  *     replace the access list
        !           112:  */
        !           113: 
        !           114:     acssort (alist, pcount);
        !           115:     x ((acs = fopen (fn, "w")) == NULL, "addmodes: can't write access list");
        !           116:     x (fwrite (alist, sizeof (struct perm_f), pcount, acs) != pcount, "addmodes: writing access");
        !           117:     fclose (acs);
        !           118: }
        !           119: 
        !           120: /*
        !           121:  *     parsemode
        !           122:  *
        !           123:  *     Parse the supplied (character string) access specification
        !           124:  *     into the specified perm_f structure.
        !           125:  *
        !           126:  *     Ray Essick
        !           127:  */
        !           128: 
        !           129: parsemode (asciimode, pstuff, verbose)
        !           130: char   *asciimode;
        !           131: struct perm_f  *pstuff;
        !           132: int     verbose;
        !           133: {
        !           134:     char   *p;
        !           135:     char    name[WDLEN];                               /* hold the name */
        !           136:     char    namespec[WDLEN];                           /* entire name */
        !           137:     int     nametype;                                  /* name class */
        !           138:     char    mode[WDLEN];                               /* and the mode */
        !           139:     char    imode = 0;                                 /* internalized */
        !           140: 
        !           141: 
        !           142:     if ((p = index (asciimode, '=')) == NULL)          /* find the mode */
        !           143:     {
        !           144:        if (verbose)
        !           145:            printf ("No mode separator: %s\n", asciimode);
        !           146:        return (1);
        !           147:     }
        !           148: 
        !           149:     *p++ = '\0';                                       /* split out mode */
        !           150:     strcpy (mode, p);                                  /* grab mode */
        !           151:     strcpy (namespec, asciimode);                      /* and name */
        !           152:     *--p = '=';                                                /* replace marker */
        !           153: 
        !           154: 
        !           155:     if ((p = index (namespec, ':')) == NULL)           /* implicitly user? */
        !           156:     {
        !           157:        strcpy (name, namespec);                        /* user name */
        !           158:        nametype = PERMUSER;                            /* default to user */
        !           159:     }
        !           160:     else
        !           161:     {
        !           162:        *p++ = '\0';                                    /* break specification */
        !           163:        strcpy (name, p);                               /* load name */
        !           164:        switch (namespec[0])                            /* determine class */
        !           165:        {
        !           166:            case 'u': 
        !           167:            case 'U': 
        !           168:                nametype = PERMUSER;
        !           169:                break;
        !           170: 
        !           171:            case 'g': 
        !           172:            case 'G': 
        !           173:                nametype = PERMGROUP;
        !           174:                break;
        !           175: 
        !           176:            case 's': 
        !           177:            case 'S': 
        !           178:                nametype = PERMSYSTEM;
        !           179:                break;
        !           180: 
        !           181:            default: 
        !           182:                if (verbose)
        !           183:                    printf ("Invalid name class: %s\n", namespec);
        !           184:                return (1);
        !           185:                break;
        !           186:        }
        !           187: 
        !           188:     }
        !           189: /*
        !           190:  *     Check that user/group are defined on our system. Don't
        !           191:  *     want to be filling our tables with bogus stuff.
        !           192:  */
        !           193: 
        !           194:     switch (nametype)
        !           195:     {
        !           196:        case PERMUSER: 
        !           197:            if (getpwnam (name) == NULL)                /* does he exist? */
        !           198:            {
        !           199:                if (verbose)
        !           200:                    printf ("%s: no such user\n", name);
        !           201:                return (1);
        !           202:            }
        !           203:            break;
        !           204: 
        !           205:        case PERMGROUP: 
        !           206:            if (getgrnam (name) == NULL)                /* does it exist */
        !           207:            {
        !           208:                if (verbose)
        !           209:                    printf ("%s: no such group\n", name);
        !           210:                return (1);
        !           211:            }
        !           212:            break;
        !           213: 
        !           214:        case PERMSYSTEM: 
        !           215:        default: 
        !           216:            break;
        !           217:     }
        !           218: 
        !           219: /*
        !           220:  *     Now internalize the mode
        !           221:  */
        !           222: 
        !           223:     imode = 0;                                         /* initially null */
        !           224:     for (p = mode; *p; p++)                            /* each specifier */
        !           225:     {
        !           226:        switch (*p)
        !           227:        {
        !           228:            case 'd':                                   /* director */
        !           229:                imode = DRCTOK + READOK + WRITOK + RESPOK;
        !           230:                break;
        !           231:            case 'r':                                   /* read */
        !           232:                imode |= READOK;
        !           233:                break;
        !           234:            case 'w':                                   /* write (and respond) */
        !           235:                imode |= WRITOK + RESPOK;
        !           236:                break;
        !           237:            case 'a':                                   /* respond */
        !           238:                imode |= RESPOK;
        !           239:                break;
        !           240:            case 'n':                                   /* nullify */
        !           241:                imode = 0;
        !           242:                break;
        !           243:            default: 
        !           244:                if (verbose)
        !           245:                    printf ("%c: Invalid permission mode\n", *p);
        !           246:                break;
        !           247:        }
        !           248: 
        !           249:     }
        !           250:     pstuff -> ptype = nametype;                                /* load structure */
        !           251:     pstuff -> perms = imode;
        !           252:     strcpy (pstuff -> name, name);
        !           253:     return 0;
        !           254: }

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