Return to getname.c CVS log

Up to [CSRG BSD Unix] / 42BSD / ucb / Mail

Annotation of 42BSD/ucb/Mail/getname.c, revision 1.1

1.1     ! root        1: #ifndef lint
        !             2: static char sccsid[] = "@(#)getname.c  2.2 (Berkeley) 8/11/83";
        !             3: #endif
        !             4: 
        !             5: /*
        !             6:  * Getname / getuserid for those with no
        !             7:  * hashed passwd data base).
        !             8:  * Do not compile this module in if you DO have hashed
        !             9:  * passwd's -- this is slower.
        !            10:  *
        !            11:  * Also provided here is a getpw routine which can share
        !            12:  * the open file.  This is used for the Version 6 getenv
        !            13:  * implementation.
        !            14:  */
        !            15: 
        !            16: #include "rcv.h"
        !            17: 
        !            18: static FILE *pwfile =  NULL;           /* Pw file held open */
        !            19: static char *pwname =  "/etc/passwd";  /* Name of passwd file */
        !            20: 
        !            21: /*
        !            22:  * Search the passwd file for a uid.  Return name through ref parameter
        !            23:  * if found, indicating success with 0 return.  Return -1 on error.
        !            24:  * If -1 is passed as the user id, close the passwd file.
        !            25:  */
        !            26: 
        !            27: getname(uid, namebuf)
        !            28:        char namebuf[];
        !            29: {
        !            30:        register char *cp, *cp2;
        !            31:        char linebuf[BUFSIZ];
        !            32: 
        !            33:        if (uid == -1) {
        !            34:                if (pwfile != NULL)
        !            35:                        fclose(pwfile);
        !            36:                pwfile = NULL;
        !            37:                return(0);
        !            38:        }
        !            39:        if (pwfile == NULL && (pwfile = fopen(pwname, "r")) == NULL)
        !            40:                return(-1);
        !            41:        rewind(pwfile);
        !            42:        while (fgets(linebuf, BUFSIZ, pwfile) != NULL)
        !            43:                if (pweval(linebuf) == uid) {
        !            44:                        for (cp = linebuf, cp2 = namebuf; *cp != ':';
        !            45:                            *cp2++ = *cp++)
        !            46:                                ;
        !            47:                        *cp2 = '\0';
        !            48:                        return(0);
        !            49:                }
        !            50:        return(-1);
        !            51: }
        !            52: 
        !            53: /*
        !            54:  * Read the users password file line into the passed line
        !            55:  * buffer.
        !            56:  */
        !            57: 
        !            58: getpw(uid, linebuf)
        !            59:        char linebuf[];
        !            60: {
        !            61:        register char *cp, *cp2;
        !            62: 
        !            63:        if (uid == -1) {
        !            64:                if (pwfile != NULL)
        !            65:                        fclose(pwfile);
        !            66:                pwfile = NULL;
        !            67:                return(0);
        !            68:        }
        !            69:        if (pwfile == NULL && (pwfile = fopen(pwname, "r")) == NULL)
        !            70:                return(-1);
        !            71:        rewind(pwfile);
        !            72:        while (fgets(linebuf, BUFSIZ, pwfile) != NULL)
        !            73:                if (pweval(linebuf) == uid) {
        !            74:                        if (linebuf[0] != '\0')
        !            75:                                linebuf[strlen(linebuf)-1] = '\0';
        !            76:                        return(0);
        !            77:                }
        !            78:        return(-1);
        !            79: }
        !            80: 
        !            81: /*
        !            82:  * Look for passwd line belonging to 'name'
        !            83:  */
        !            84: 
        !            85: getpwnam(name, linebuf)
        !            86:        char name[], linebuf[];
        !            87: {
        !            88:        register char *cp, *cp2;
        !            89: 
        !            90:        if (name == NOSTR) {
        !            91:                if (pwfile != NULL)
        !            92:                        fclose(pwfile);
        !            93:                pwfile = NULL;
        !            94:                return(0);
        !            95:        }
        !            96:        if (pwfile == NULL && (pwfile = fopen(pwname, "r")) == NULL) {
        !            97:                perror(pwname);
        !            98:                return(-1);
        !            99:        }
        !           100:        rewind(pwfile);
        !           101:        while (fgets(linebuf, BUFSIZ, pwfile) != NULL) {
        !           102:                cp = linebuf;
        !           103:                cp2 = name;
        !           104:                while (*cp2++ == *cp++)
        !           105:                        ;
        !           106:                if (*--cp == ':' && *--cp2 == 0)
        !           107:                        return(0);
        !           108:        }
        !           109:        return(-1);
        !           110: }
        !           111: 
        !           112: /*
        !           113:  * Convert the passed name to a user id and return it.  Return -1
        !           114:  * on error.  Iff the name passed is -1 (yech) close the pwfile.
        !           115:  */
        !           116: 
        !           117: getuserid(name)
        !           118:        char name[];
        !           119: {
        !           120:        register char *cp, *cp2;
        !           121:        char linebuf[BUFSIZ];
        !           122: 
        !           123:        if (name == (char *) -1) {
        !           124:                if (pwfile != NULL)
        !           125:                        fclose(pwfile);
        !           126:                pwfile = NULL;
        !           127:                return(0);
        !           128:        }
        !           129:        if (pwfile == NULL && (pwfile = fopen(pwname, "r")) == NULL)
        !           130:                return(-1);
        !           131:        rewind(pwfile);
        !           132:        while (fgets(linebuf, BUFSIZ, pwfile) != NULL) {
        !           133:                for (cp = name, cp2 = linebuf; *cp++ == *cp2++;)
        !           134:                        ;
        !           135:                if (*--cp == '\0' && *--cp2 == ':')
        !           136:                        return(pweval(linebuf));
        !           137:        }
        !           138:        return(-1);
        !           139: }
        !           140: 
        !           141: /*
        !           142:  * Evaluate the user id of the passed passwd line and return it.
        !           143:  */
        !           144: 
        !           145: static
        !           146: pweval(line)
        !           147:        char line[];
        !           148: {
        !           149:        register char *cp;
        !           150:        register int i;
        !           151:        register int uid;
        !           152: 
        !           153:        for (cp = line, i = 0; i < 2; i += (*cp++ == ':'))
        !           154:                ;
        !           155:        uid = atoi(cp);
        !           156: 
        !           157: #ifdef UIDGID
        !           158:        while (*cp && *cp != ':')
        !           159:                cp++;
        !           160:        cp++;
        !           161:        uid |= atoi(cp) << 8;
        !           162: #endif
        !           163: 
        !           164:        return(uid);
        !           165: }

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