Return to getpwnamuid.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / lib / libc / gen

Annotation of 43BSDTahoe/lib/libc/gen/getpwnamuid.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1983 Regents of the University of California.
        !             3:  * All rights reserved.  The Berkeley software License Agreement
        !             4:  * specifies the terms and conditions for redistribution.
        !             5:  */
        !             6: 
        !             7: #if defined(LIBC_SCCS) && !defined(lint)
        !             8: static char sccsid[] = "@(#)getpwnamuid.c      5.3 (Berkeley) 12/21/87";
        !             9: #endif LIBC_SCCS and not lint
        !            10: 
        !            11: #include <stdio.h>
        !            12: #include <pwd.h>
        !            13: #include <ndbm.h>
        !            14: 
        !            15: #include <sys/file.h>
        !            16: 
        !            17: static char line[BUFSIZ+1];
        !            18: static struct passwd passwd;
        !            19: 
        !            20: /*
        !            21:  * The following are shared with getpwent.c
        !            22:  */
        !            23: extern char *_pw_file;
        !            24: DBM    *_pw_db;
        !            25: int    _pw_stayopen;
        !            26: 
        !            27: static struct passwd *
        !            28: fetchpw(key)
        !            29:        datum key;
        !            30: {
        !            31:         register char *cp, *tp;
        !            32: 
        !            33:         if (key.dptr == 0)
        !            34:                 return ((struct passwd *)NULL);
        !            35:        key = dbm_fetch(_pw_db, key);
        !            36:        if (key.dptr == 0)
        !            37:                 return ((struct passwd *)NULL);
        !            38:         cp = key.dptr;
        !            39:        tp = line;
        !            40: 
        !            41: #define        EXPAND(e)       passwd.e = tp; while (*tp++ = *cp++);
        !            42:        EXPAND(pw_name);
        !            43:        EXPAND(pw_passwd);
        !            44:        bcopy(cp, (char *)&passwd.pw_uid, sizeof (int));
        !            45:        cp += sizeof (int);
        !            46:        bcopy(cp, (char *)&passwd.pw_gid, sizeof (int));
        !            47:        cp += sizeof (int);
        !            48:        bcopy(cp, (char *)&passwd.pw_quota, sizeof (int));
        !            49:        cp += sizeof (int);
        !            50:        EXPAND(pw_comment);
        !            51:        EXPAND(pw_gecos);
        !            52:        EXPAND(pw_dir);
        !            53:        EXPAND(pw_shell);
        !            54:         return (&passwd);
        !            55: }
        !            56: 
        !            57: struct passwd *
        !            58: getpwnam(nam)
        !            59:        char *nam;
        !            60: {
        !            61:         datum key;
        !            62:        register struct passwd *pw;
        !            63: 
        !            64:         if (_pw_db == (DBM *)0 &&
        !            65:            (_pw_db = dbm_open(_pw_file, O_RDONLY)) == (DBM *)0) {
        !            66:        oldcode:
        !            67:                setpwent();
        !            68:                while ((pw = getpwent()) && strcmp(nam, pw->pw_name))
        !            69:                        ;
        !            70:                if (!_pw_stayopen)
        !            71:                        endpwent();
        !            72:                return (pw);
        !            73:        }
        !            74:        if (flock(dbm_dirfno(_pw_db), LOCK_SH) < 0) {
        !            75:                dbm_close(_pw_db);
        !            76:                _pw_db = (DBM *)0;
        !            77:                goto oldcode;
        !            78:        }
        !            79:         key.dptr = nam;
        !            80:         key.dsize = strlen(nam);
        !            81:        pw = fetchpw(key);
        !            82:        (void) flock(dbm_dirfno(_pw_db), LOCK_UN);
        !            83:        if (!_pw_stayopen) {
        !            84:                dbm_close(_pw_db);
        !            85:                _pw_db = (DBM *)0;
        !            86:        }
        !            87:         return (pw);
        !            88: }
        !            89: 
        !            90: struct passwd *
        !            91: getpwuid(uid)
        !            92:        int uid;
        !            93: {
        !            94:         datum key;
        !            95:        register struct passwd *pw;
        !            96: 
        !            97:         if (_pw_db == (DBM *)0 &&
        !            98:            (_pw_db = dbm_open(_pw_file, O_RDONLY)) == (DBM *)0) {
        !            99:        oldcode:
        !           100:                setpwent();
        !           101:                while ((pw = getpwent()) && pw->pw_uid != uid)
        !           102:                        ;
        !           103:                if (!_pw_stayopen)
        !           104:                        endpwent();
        !           105:                return (pw);
        !           106:        }
        !           107:        if (flock(dbm_dirfno(_pw_db), LOCK_SH) < 0) {
        !           108:                dbm_close(_pw_db);
        !           109:                _pw_db = (DBM *)0;
        !           110:                goto oldcode;
        !           111:        }
        !           112:         key.dptr = (char *) &uid;
        !           113:         key.dsize = sizeof uid;
        !           114:        pw = fetchpw(key);
        !           115:        (void) flock(dbm_dirfno(_pw_db), LOCK_UN);
        !           116:        if (!_pw_stayopen) {
        !           117:                dbm_close(_pw_db);
        !           118:                _pw_db = (DBM *)0;
        !           119:        }
        !           120:         return (pw);
        !           121: }

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