Return to id.c CVS log

Up to [Research Unix] / researchv10no / cmd / odist / tar

Annotation of researchv10no/cmd/odist/tar/id.c, revision 1.1

1.1     ! root        1: #include <limits.h>
        !             2: #include <stddef.h>
        !             3: #include <stdio.h>
        !             4: #include <pwd.h>
        !             5: #include <grp.h>
        !             6: #include "misc.h"
        !             7: 
        !             8: struct idmap {
        !             9:        char *str;
        !            10:        int num;
        !            11:        struct idmap *next;
        !            12: };
        !            13: 
        !            14: static struct idmap *umap, *gmap;
        !            15: 
        !            16: static struct idmap *
        !            17: idnum(struct idmap **map, char *str)
        !            18: {
        !            19:        while (*map) {
        !            20:                if (strcmp((*map)->str, str) == 0)
        !            21:                        return *map;
        !            22:                map = &(*map)->next;
        !            23:        }
        !            24:        return 0;
        !            25: }
        !            26: 
        !            27: static struct idmap *
        !            28: idstr(struct idmap **map, int num)
        !            29: {
        !            30:        while (*map) {
        !            31:                if ((*map)->num == num)
        !            32:                        return *map;
        !            33:                map = &(*map)->next;
        !            34:        }
        !            35:        return 0;
        !            36: }
        !            37: 
        !            38: static struct idmap *
        !            39: idset(struct idmap **map, char *str, int num)
        !            40: {
        !            41:        struct idmap *mapent;
        !            42: 
        !            43:        mapent = xmalloc(sizeof (struct idmap));
        !            44:        if (str)
        !            45:                mapent->str = xstrdup(str);
        !            46:        else
        !            47:                mapent->str = 0;
        !            48:        mapent->num = num;
        !            49:        mapent->next = *map;
        !            50:        *map = mapent;
        !            51:        return mapent;
        !            52: }
        !            53: 
        !            54: int
        !            55: uidnum(char *str)
        !            56: {
        !            57:        struct idmap *id;
        !            58:        struct passwd *pw;
        !            59:        int num;
        !            60: 
        !            61:        id = idnum(&umap, str);
        !            62:        if (!id) {
        !            63:                pw = getpwnam(str);
        !            64:                id = idset(&umap, str, pw ? pw->pw_uid : -1);
        !            65:        }
        !            66:        return id->num;
        !            67: }
        !            68: 
        !            69: char *
        !            70: uidstr(int num)
        !            71: {
        !            72:        struct idmap *id;
        !            73:        struct passwd *pw;
        !            74:        char *str;
        !            75: 
        !            76:        id = idstr(&umap, num);
        !            77:        if (!id) {
        !            78:                pw = getpwuid(num);
        !            79:                id = idset(&umap, pw ? pw->pw_name : 0, num);
        !            80:        }
        !            81:        return id->str;
        !            82: }
        !            83: 
        !            84: int
        !            85: gidnum(char *str)
        !            86: {
        !            87:        struct idmap *id;
        !            88:        struct group *gr;
        !            89:        int num;
        !            90: 
        !            91:        id = idnum(&gmap, str);
        !            92:        if (!id) {
        !            93:                gr = getgrnam(str);
        !            94:                id = idset(&gmap, str, gr ? gr->gr_gid : -1);
        !            95:        }
        !            96:        return id->num;
        !            97: }
        !            98: 
        !            99: char *
        !           100: gidstr(int num)
        !           101: {
        !           102:        struct idmap *id;
        !           103:        struct group *gr;
        !           104:        char *str;
        !           105: 
        !           106:        id = idstr(&gmap, num);
        !           107:        if (!id) {
        !           108:                gr = getgrgid(num);
        !           109:                id = idset(&gmap, gr ? gr->gr_name : 0, num);
        !           110:        }
        !           111:        return id->str;
        !           112: }

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