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