Return to pwsearch.c CVS log

Up to [Research Unix] / researchv10dc / ipc / libipc

Annotation of researchv10dc/ipc/libipc/pwsearch.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * pwsearch(name, uid, pwline)
        !             3:  *   search for name (if non null) or uid in password.
        !             4:      return ptr to passwd structure.
        !             5:      if pwline is non null return whole password line.
        !             6:  */
        !             7: #include <stdio.h>
        !             8: #include <sys/types.h>
        !             9: #include <sys/stat.h>
        !            10: #include <pwd.h>
        !            11: 
        !            12: #define PASSWD "/etc/passwd"
        !            13: #define PWLINE 500
        !            14: #define CHUNK 64       /* allocation of hint table -- must be a power of two */
        !            15: 
        !            16: static struct hint {
        !            17:        long    hint;
        !            18:        char    *name;
        !            19:        short   uid;
        !            20: } *htab;
        !            21: 
        !            22: static int htabsize = 0;
        !            23: static char buf[PWLINE];
        !            24: static FILE *pwf;
        !            25: static time_t pwtime;
        !            26: 
        !            27: struct passwd *pwdecode();
        !            28: char *malloc(), *realloc(), *strcpy();
        !            29: static int buildtable();
        !            30: 
        !            31: struct passwd *
        !            32: pwsearch(name, uid, pwline)
        !            33: char *name, *pwline;
        !            34: {
        !            35:        register int min, max, mid;
        !            36:        register struct passwd *pw;
        !            37:        int ntries = 0;
        !            38:        struct stat sbuf;
        !            39: 
        !            40: again:
        !            41:        if (ntries>1)
        !            42:                return(NULL);
        !            43:        if (pwf)
        !            44:                fstat(fileno(pwf), &sbuf);
        !            45:        if (pwf==NULL || ntries || pwtime < sbuf.st_ctime) {
        !            46:                buildtable();
        !            47:                pwtime = sbuf.st_ctime;
        !            48:        }
        !            49:        ntries++;
        !            50:        if (name) {
        !            51:                /* binary search for name */
        !            52:                min = 0;
        !            53:                max = htabsize - 1;
        !            54:                while (min <= max) {
        !            55:                        register n;
        !            56:                        mid = (min + max) >> 1;
        !            57:                        n = strcmp (name, htab[mid].name);
        !            58:                        if (n == 0)
        !            59:                                break;
        !            60:                        if (n < 0)
        !            61:                                max = mid - 1;
        !            62:                        else
        !            63:                                min = mid + 1;
        !            64:                }
        !            65:                if (min > max)
        !            66:                        goto again;
        !            67:        } else {
        !            68:                /* linear search for uid */
        !            69:                for (mid = 0; mid <htabsize; mid++)
        !            70:                        if (htab[mid].uid == uid)
        !            71:                                break;
        !            72:                if (mid == htabsize)
        !            73:                        goto again;
        !            74:        }
        !            75:        /*
        !            76:         * We have a hint.  Seek to the given point in the file.
        !            77:         * If it's not the very beginning, ensure it is the start
        !            78:         * of a line by peeking at the preceding character.
        !            79:         */
        !            80:        if (htab[mid].hint) {
        !            81:                fseek(pwf, htab[mid].hint-1, 0);
        !            82:                if (getc(pwf) != '\n')
        !            83:                        goto again;
        !            84:        } else
        !            85:                fseek(pwf, htab[mid].hint, 0);
        !            86:        if (fgets(buf, PWLINE, pwf) == NULL)
        !            87:                goto again;
        !            88:        if (pwline)
        !            89:                strcpy(pwline, buf);
        !            90:        pw = pwdecode(buf);
        !            91:        if (name) {
        !            92:                if (strcmp(name, pw->pw_name))
        !            93:                        goto again;
        !            94:        } else if (uid != pw->pw_uid)
        !            95:                goto again;
        !            96:        return(pw);
        !            97: }
        !            98: 
        !            99: /* comparison function for call to qsort */
        !           100: static int
        !           101: comp (p, q)
        !           102: struct hint *p, *q;
        !           103: {
        !           104:        return(strcmp (p->name, q->name));
        !           105: }
        !           106: 
        !           107: static int
        !           108: buildtable()
        !           109: {
        !           110:        long where;
        !           111:        register int i;
        !           112: 
        !           113:        /* free the old hint table */
        !           114:        for (i = 0; i < htabsize; i++) {
        !           115:                if (htab[i].name) {
        !           116:                        (void)free((char *)htab[i].name);
        !           117:                        htab[i].name = NULL;
        !           118:                }
        !           119:        }
        !           120:        if (htab) {
        !           121:                (void)free((char *)htab);
        !           122:                htab = NULL;
        !           123:        }
        !           124:        htabsize = 0;
        !           125:        if (pwf)
        !           126:                fclose(pwf);
        !           127:        pwf = fopen(PASSWD, "r");
        !           128:        if (pwf == NULL)
        !           129:                return;
        !           130:        while (where = ftell(pwf), fgets(buf, PWLINE, pwf) != NULL) {
        !           131:                register struct passwd *pw = pwdecode(buf);
        !           132:                register char *p = malloc(strlen(pw->pw_name) + 1);
        !           133: 
        !           134:                if (p == NULL)
        !           135:                        return;
        !           136:                /* time to expand the hint table? */
        !           137:                if ((htabsize & (CHUNK - 1)) == 0) {
        !           138:                        unsigned s = (htabsize + CHUNK) * sizeof(struct hint);
        !           139:                        if (htab)
        !           140:                                htab = (struct hint *) realloc((char *)htab, s);
        !           141:                        else
        !           142:                                htab = (struct hint *) malloc(s);
        !           143:                        if (htab == NULL) {
        !           144:                                htabsize = 0;
        !           145:                                return;
        !           146:                        }
        !           147:                }
        !           148:                htab[htabsize].name = strcpy(p, pw->pw_name);
        !           149:                htab[htabsize].uid = pw->pw_uid;
        !           150:                htab[htabsize].hint = where;
        !           151:                htabsize++;
        !           152:        }
        !           153:        qsort((char *) htab, htabsize, sizeof (struct hint), comp);
        !           154: }
        !           155: 
        !           156: pwclose()
        !           157: {
        !           158:        if (pwf)
        !           159:                fclose(pwf);
        !           160: }

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