Return to which.c CVS log

Up to [MW Coherent from dump] / coherent / d / bin

Annotation of coherent/d/bin/which.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * locate a program file along the user's PATH.
                      3:  * try to mimic output of the BSD version.
                      4:  */
                      5: #include <stdio.h>
                      6: #include <sys/stat.h>
                      7: #include <access.h>
                      8: 
                      9: char   *getenv();
                     10: char   *index();
                     11: char   **parsepath();          /* parse PATH into argv-like structure */
                     12: void   fatal();                /* display error message and die */
                     13: void   usage();                /* display usage message and die */
                     14: char   *calloc();
                     15: char   *index();
                     16: 
                     17: #define        TRUE            (0 == 0)
                     18: #define        FALSE           (0 != 0)
                     19: #define        EXEC_BITS       (S_IEXEC | (S_IEXEC >> 3) | (S_IEXEC >> 6))
                     20: 
                     21: main(argc, argv)
                     22: int    argc;
                     23: char   *argv[];
                     24: {
                     25:        char    *pathp;                         /* pointer to PATH string */
                     26:        char    **pathpp;                       /* pointer to path entries */
                     27:        char    **pathlist;                     /* pointer to path list */
                     28:        static  char    pathbuf[BUFSIZ];        /* expanded file names */
                     29:        static  char    path[BUFSIZ];           /* saved copy for error msgs */
                     30: 
                     31:        if ((pathp = getenv("PATH")) == NULL)
                     32:                fatal("PATH not found in environment");
                     33:        strcpy(path, pathp);
                     34:        if (--argc < 1)
                     35:                usage();
                     36:        pathlist = parsepath(pathp);
                     37: 
                     38:        for (++argv; argc-- > 0; ++argv) {
                     39:                pathpp = pathlist;
                     40:                for ( ; *pathpp != NULL; ++pathpp) {
                     41:                        if (**pathpp != '\0') {
                     42:                                strcpy(pathbuf, *pathpp);
                     43:                                strcat(pathbuf, "/");
                     44:                                strcat(pathbuf, *argv);
                     45:                        } else
                     46:                                strcpy(pathbuf, *argv);
                     47:                        if (is_exec(pathbuf)) {
                     48:                                puts(pathbuf);
                     49:                                break;
                     50:                        }
                     51:                }
                     52:                if (*pathpp == NULL)
                     53:                        if (index(*argv, '/') != NULL)
                     54:                                printf("%s not found\n", *argv);
                     55:                        else
                     56:                                printf("no %s in %s\n", *argv, path);
                     57:        }
                     58:        exit(0);
                     59: }
                     60: 
                     61: /*
                     62:  * check to see if the given name is executable.
                     63:  * this isn't as trivial as it may seem since access() says
                     64:  * that root (UID 0) can execute anything, even if the
                     65:  * execute mode bits are not set.
                     66:  */
                     67: is_exec(name)
                     68: char   *name;
                     69: {
                     70:        static  struct  stat    statbuf;
                     71: 
                     72:        if (access(name, AEXEC) != 0)
                     73:                return FALSE;
                     74:        if (stat(name, &statbuf) == -1) {
                     75:                fprintf(stderr, "%s: Unable to stat\n", name);
                     76:                return FALSE;
                     77:        }
                     78:        if ((statbuf.st_mode & S_IFMT) != S_IFREG)
                     79:                return FALSE;
                     80:        return (getuid() != 0 || (statbuf.st_mode & EXEC_BITS));
                     81: }
                     82: 
                     83: /*
                     84:  * parse a path of the form dir1:dir2:dir3 into an array of pointers to
                     85:  * the individual directory entries. Note that this null terminates each
                     86:  * directory entry by replacing all ':' characters in "path" with NUL's. 
                     87:  * take special care of leading and trailing ':' which imply the current
                     88:  * directory.
                     89:  */
                     90: char   **
                     91: parsepath(path)
                     92: char   *path;
                     93: {
                     94:        register char   *cp;
                     95:        register int    i = 1;
                     96:        char    **patharray, **pp;
                     97: 
                     98:        for (cp = path; *cp != '\0'; )  /* calculate number of entries */
                     99:                if (*cp++ == ':')
                    100:                        ++i;
                    101:        if ((patharray = (char **)calloc(i + 1, sizeof (char *))) == NULL)
                    102:                fatal("Out of memory for PATH list");
                    103:        for (cp = path, pp = patharray; *cp != '\0' || pp == patharray; ) {
                    104:                *pp++ = cp;
                    105:                while (*cp != '\0') {
                    106:                        if (*cp == ':') {
                    107:                                *cp++ = '\0';
                    108:                                break;
                    109:                        }
                    110:                        ++cp;
                    111:                }
                    112:                if ((pp - patharray) < i)
                    113:                        *pp = cp;
                    114:        }
                    115:        return (patharray);
                    116: }
                    117: 
                    118: void
                    119: usage()
                    120: {
                    121:        fatal("usage: which name ....");
                    122: }
                    123: 
                    124: void
                    125: fatal(info)
                    126: char   *info;
                    127: {
                    128:        fprintf(stderr, "which: %r\n", &info);
                    129:        exit(1);
                    130: }

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