Return to getuid.c CVS log

Up to [Research Unix] / researchv10no / cmd

Annotation of researchv10no/cmd/getuid.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * getuid user group passwd uid gid acct bin gcid home shell
                      3:  */
                      4: #include <stdio.h>
                      5: extern char *user(), *group(), *passwd(), *uid(), *gid(), *acct(), *bin(), *gcid(), *home(), *shell();
                      6: struct op{
                      7:        char    *name;
                      8:        char *  (*fn)();
                      9: } op[] = {
                     10:        "user",         user,   /* login id */
                     11:        "group",        group,  /* group id */
                     12:        "passwd",       passwd, /* encrypted password */
                     13:        "uid",          uid,    /* numerical user id */
                     14:        "gid",          gid,    /* numerical group id */
                     15:        "acct",         acct,   /* GCOS account number */
                     16:        "bin",          bin,    /* GCOS output bin */
                     17:        "gcid",         gcid,   /* GCOS user id */
                     18:        "home",         home,   /* home directory */
                     19:        "shell",        shell,  /* default shell */
                     20:        0,              0,
                     21: };
                     22: int tagflag=0;
                     23: char buf[132];
                     24: main(argc, argv)
                     25:        char *argv[];
                     26: {
                     27:        register i;
                     28:        if(getpw(getuid(), buf)!=0){
                     29:                fprintf(stderr, "getuid: no line in /etc/passwd for %d\n", getuid());
                     30:                return (1);
                     31:        }
                     32:        if(argc>1 && argv[1][0]=='-'){
                     33:                tagflag++;
                     34:                --argc; argv++;
                     35:        }
                     36:        if(argc < 2)
                     37:                print(0);
                     38:        else{
                     39:                if(argc > 2)
                     40:                        tagflag++;
                     41:                for(i=1; i<argc; i++)
                     42:                        print(lookup(argv[i]));
                     43:        }
                     44:        return (0);
                     45: }
                     46: lookup(s)
                     47:        register char *s;
                     48: {
                     49:        register struct op *p;
                     50:        for(p=op; p->name; p++)
                     51:                if(strcmp(p->name, s)==0)
                     52:                        return(p-op);
                     53:        fprintf(stderr, "getuid: unknown option %s\n", s);
                     54:        exit(1);
                     55: }
                     56: print(n)
                     57:        register n;
                     58: {
                     59:        if(tagflag)
                     60:                printf("%s=", op[n].name);
                     61:        printf("%s\n", (*op[n].fn)());
                     62: }
                     63: char *
                     64: field(b, n, delim)
                     65:        register char *b;
                     66:        register n, delim;
                     67: {
                     68:        register char *s, *t;
                     69:        static char rbuf[64];
                     70:        s=b;
                     71:        rbuf[0]='\0';
                     72:        while(n-- > 0){
                     73:                while(*s!=delim)
                     74:                        if(*s++ == '\0')
                     75:                                return(rbuf);
                     76:                s++;    /* Point past the delim */
                     77:        }
                     78:        t=rbuf;
                     79:        while(*t = *s++)
                     80:                if(*t++ == delim){
                     81:                        *--t = '\0';
                     82:                        break;
                     83:                }
                     84:        return(rbuf);
                     85: }
                     86: char *
                     87: whois(uid){
                     88:        static char buf[132];
                     89:        register char *p = buf;
                     90:        if(getpw(uid,buf)!=0)
                     91:                sprintf(buf, "%d", uid);
                     92:        else{
                     93:                while(*p!=':')
                     94:                        p++;
                     95:                *p=0;
                     96:        }
                     97:        return(buf);
                     98: }
                     99: char *
                    100: user(){
                    101:        return(field(buf, 0, ':'));
                    102: }
                    103: char *
                    104: passwd(){
                    105:        return(field(buf, 1, ':'));
                    106: }
                    107: char *
                    108: uid(){
                    109:        return(field(buf, 2, ':'));
                    110: }
                    111: char *
                    112: gid(){
                    113:        return(field(buf, 3, ':'));
                    114: }
                    115: char *
                    116: group(){
                    117: #      include <grp.h>
                    118:        struct group *getgrgid();
                    119:        register struct group *g;
                    120:        g=getgrgid(atoi(field(buf, 3, ':')));
                    121:        return(g? g->gr_name : field(buf, 3, ':'));
                    122: }
                    123: char *
                    124: acct(){
                    125:        char sbuf[64];
                    126:        strcpy(sbuf, field(buf, 4, ':'));
                    127:        return(field(sbuf, 0, ','));
                    128: }
                    129: char *
                    130: bin(){
                    131:        char sbuf[64];
                    132:        strcpy(sbuf, field(buf, 4, ':'));
                    133:        return(field(sbuf, 1, ','));
                    134: }
                    135: char *
                    136: gcid(){
                    137:        char *c, sbuf[64];
                    138:        strcpy(sbuf, field(buf, 4, ':'));
                    139:        if (*(c = field(sbuf, 2, ',')) == '\0') {
                    140:           return(field(buf, 0, ':'));
                    141:         }
                    142:         else {
                    143:            return(c);
                    144:         }
                    145: }
                    146: char *
                    147: home(){
                    148:        return(field(buf, 5, ':'));
                    149: }
                    150: char *
                    151: shell(){
                    152:        return(field(buf, 6, ':'));
                    153: }

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