Return to id.c CVS log

Up to [Research Unix] / researchv10no / cmd / dist / lib

Annotation of researchv10no/cmd/dist/lib/id.c, revision 1.1

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

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