Return to whereis.c CVS log

Up to [CSRG BSD Unix] / 3BSD / cmd

Annotation of 3BSD/cmd/whereis.c, revision 1.1

1.1     ! root        1: #include <sys/types.h>
        !             2: #include <stdio.h>
        !             3: #include <ctype.h>
        !             4: #include <sys/dir.h>
        !             5: 
        !             6: char   sflag = 1;
        !             7: char   bflag = 1;
        !             8: char   mflag = 1;
        !             9: char   **Sflag;
        !            10: int    Scnt;
        !            11: char   **Bflag;
        !            12: int    Bcnt;
        !            13: char   **Mflag;
        !            14: int    Mcnt;
        !            15: char   uflag;
        !            16: /*
        !            17:  * whereis name
        !            18:  * look for source, documentation and binaries
        !            19:  */
        !            20: main(argc, argv)
        !            21:        int argc;
        !            22:        char *argv[];
        !            23: {
        !            24: 
        !            25: #ifdef CORY
        !            26:        if (getuid() == 0)
        !            27:                nice(-20);
        !            28:        if (((getuid() >> 8) & 0377) > 10)
        !            29:                setuid(getuid());
        !            30: #endif
        !            31:        argc--, argv++;
        !            32:        if (argc == 0) {
        !            33: usage:
        !            34:                fprintf(stderr, "whereis [ -sbmu ] [ -SBM dir ... -f ] name...\n");
        !            35:                exit(1);
        !            36:        }
        !            37:        do
        !            38:                if (argv[0][0] == '-') {
        !            39:                        register char *cp = argv[0] + 1;
        !            40:                        while (*cp) switch (*cp++) {
        !            41: 
        !            42:                        case 'f':
        !            43:                                break;
        !            44: 
        !            45:                        case 'S':
        !            46:                                getlist(&argc, &argv, &Sflag, &Scnt);
        !            47:                                break;
        !            48: 
        !            49:                        case 'B':
        !            50:                                getlist(&argc, &argv, &Bflag, &Bcnt);
        !            51:                                break;
        !            52: 
        !            53:                        case 'M':
        !            54:                                getlist(&argc, &argv, &Mflag, &Mcnt);
        !            55:                                break;
        !            56: 
        !            57:                        case 's':
        !            58:                                zerof();
        !            59:                                sflag++;
        !            60:                                continue;
        !            61: 
        !            62:                        case 'u':
        !            63:                                uflag++;
        !            64:                                continue;
        !            65: 
        !            66:                        case 'b':
        !            67:                                zerof();
        !            68:                                bflag++;
        !            69:                                continue;
        !            70: 
        !            71:                        case 'm':
        !            72:                                zerof();
        !            73:                                mflag++;
        !            74:                                continue;
        !            75: 
        !            76:                        default:
        !            77:                                goto usage;
        !            78:                        }
        !            79:                        argv++;
        !            80:                } else
        !            81:                        lookup(*argv++);
        !            82:        while (--argc > 0);
        !            83: }
        !            84: 
        !            85: getlist(argcp, argvp, flagp, cntp)
        !            86:        char ***argvp;
        !            87:        int *argcp;
        !            88:        char ***flagp;
        !            89:        int *cntp;
        !            90: {
        !            91: 
        !            92:        (*argvp)++;
        !            93:        *flagp = *argvp;
        !            94:        *cntp = 0;
        !            95:        for ((*argcp)--; *argcp > 0 && (*argvp)[0][0] != '-'; (*argcp)--)
        !            96:                (*cntp)++, (*argvp)++;
        !            97:        (*argcp)++;
        !            98:        (*argvp)--;
        !            99: }
        !           100: 
        !           101: 
        !           102: zerof()
        !           103: {
        !           104: 
        !           105:        if (sflag && bflag && mflag)
        !           106:                sflag = bflag = mflag = 0;
        !           107: }
        !           108: int    count;
        !           109: int    print;
        !           110: 
        !           111: 
        !           112: lookup(cp)
        !           113:        register char *cp;
        !           114: {
        !           115:        register char *dp;
        !           116: 
        !           117:        for (dp = cp; *dp; dp++)
        !           118:                continue;
        !           119:        for (; dp > cp; dp--) {
        !           120:                if (*dp == '.') {
        !           121:                        *dp = 0;
        !           122:                        break;
        !           123:                }
        !           124:        }
        !           125:        for (dp = cp; *dp; dp++)
        !           126:                if (*dp == '/')
        !           127:                        cp = dp + 1;
        !           128:        if (uflag) {
        !           129:                print = 0;
        !           130:                count = 0;
        !           131:        } else
        !           132:                print = 1;
        !           133: again:
        !           134:        if (print)
        !           135:                printf("%s:", cp);
        !           136:        if (sflag) {
        !           137:                looksrc(cp);
        !           138:                if (uflag && print == 0 && count != 1) {
        !           139:                        print = 1;
        !           140:                        goto again;
        !           141:                }
        !           142:        }
        !           143:        count = 0;
        !           144:        if (bflag) {
        !           145:                lookbin(cp);
        !           146:                if (uflag && print == 0 && count != 1) {
        !           147:                        print = 1;
        !           148:                        goto again;
        !           149:                }
        !           150:        }
        !           151:        count = 0;
        !           152:        if (mflag) {
        !           153:                lookman(cp);
        !           154:                if (uflag && print == 0 && count != 1) {
        !           155:                        print = 1;
        !           156:                        goto again;
        !           157:                }
        !           158:        }
        !           159:        if (print)
        !           160:                printf("\n");
        !           161: }
        !           162: 
        !           163: looksrc(cp)
        !           164:        char *cp;
        !           165: {
        !           166:        static char *srcdirs[]  = {
        !           167:                "cmd",
        !           168:                "libc/gen",
        !           169:                "libc/stdio",
        !           170:                "libc/sys",
        !           171:                "games",
        !           172:                "new",
        !           173:                "old",
        !           174:                "local",
        !           175:                "undoc",
        !           176:                0
        !           177:        };
        !           178:        if (Sflag == 0) {
        !           179:                chdir("/usr/src");
        !           180:                find(srcdirs, cp);
        !           181:        } else
        !           182:                findv(Sflag, Scnt, cp);
        !           183: }
        !           184: 
        !           185: lookbin(cp)
        !           186:        char *cp;
        !           187: {
        !           188:        static char *bindirs[] = {
        !           189:                "/etc",
        !           190:                "/bin",
        !           191:                "/lib",
        !           192:                "/usr/bin",
        !           193:                "/usr/ucb",
        !           194:                "/usr/lib",
        !           195:                "/usr/local",
        !           196:                "/usr/new",
        !           197:                "/usr/old",
        !           198:                "/usr/games",
        !           199:                0
        !           200:        };
        !           201:        if (Bflag == 0)
        !           202:                find(bindirs, cp);
        !           203:        else
        !           204:                findv(Bflag, Bcnt, cp);
        !           205: }
        !           206: 
        !           207: lookman(cp)
        !           208:        char *cp;
        !           209: {
        !           210:        static char *mandirs[] = {
        !           211:                "man1",
        !           212:                "man2",
        !           213:                "man3",
        !           214:                "man4",
        !           215:                "man5",
        !           216:                "man6",
        !           217:                "man7",
        !           218:                "man8",
        !           219:                0
        !           220:        };
        !           221:        if (Mflag == 0) {
        !           222:                chdir("/usr/man");
        !           223:                find(mandirs, cp);
        !           224:        } else
        !           225:                findv(Mflag, Mcnt, cp);
        !           226: }
        !           227: 
        !           228: findv(dirv, dirc, cp)
        !           229:        char **dirv;
        !           230:        int dirc;
        !           231:        char *cp;
        !           232: {
        !           233: 
        !           234:        while (dirc > 0)
        !           235:                findin(*dirv++, cp), dirc--;
        !           236: }
        !           237: 
        !           238: find(dirs, cp)
        !           239:        char **dirs;
        !           240:        char *cp;
        !           241: {
        !           242: 
        !           243:        while (*dirs)
        !           244:                findin(*dirs++, cp);
        !           245: }
        !           246: 
        !           247: findin(dir, cp)
        !           248:        char *dir, *cp;
        !           249: {
        !           250:        register FILE *d;
        !           251:        struct direct direct;
        !           252: 
        !           253:        d = fopen(dir, "r");
        !           254:        if (d == NULL)
        !           255:                return;
        !           256:        while (fread(&direct, sizeof direct, 1, d) == 1) {
        !           257:                if (direct.d_ino == 0)
        !           258:                        continue;
        !           259:                if (itsit(cp, direct.d_name)) {
        !           260:                        count++;
        !           261:                        if (print)
        !           262:                                printf(" %s/%.14s", dir, direct.d_name);
        !           263:                }
        !           264:        }
        !           265:        fclose(d);
        !           266: }
        !           267: 
        !           268: itsit(cp, dp)
        !           269:        register char *cp, *dp;
        !           270: {
        !           271:        register int i = 14;
        !           272: 
        !           273:        if (dp[0] == 's' && dp[1] == '.' && itsit(cp, dp+2))
        !           274:                return (1);
        !           275:        while (*cp && *dp && *cp == *dp)
        !           276:                cp++, dp++, i--;
        !           277:        if (*cp == 0 && *dp == 0)
        !           278:                return (1);
        !           279:        while (isdigit(*dp))
        !           280:                dp++;
        !           281:        if (*cp == 0 && *dp++ == '.') {
        !           282:                --i;
        !           283:                while (i > 0 && *dp)
        !           284:                        if (--i, *dp++ == '.')
        !           285:                                return (*dp++ == 'C' && *dp++ == 0);
        !           286:                return (1);
        !           287:        }
        !           288:        return (0);
        !           289: }

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