![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to find.y CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / bin / find|
Return to find.y CVS log | Up to [MW Coherent from dump] / coherent / d / bin / find |
1.1 root 1: %{
2: /*
3: * Find all files in the given
4: * directory hierarchies that
5: * satisfy the given expression
6: * primaries.
7: */
8:
9: #include <stdio.h>
10: #include <sys/stat.h>
11: #include <sys/dir.h>
12: #include <pwd.h>
13: #include <grp.h>
14: #include "findnode.h"
15:
16: #define NPRIM (sizeof(primaries)/sizeof(primaries[0]))
17: #define NARG 50
18: #define NRECUR 14 /* Maximum recursion depth before forking */
19: #define NFNAME 600 /* size of filename buffer */
20: #define FILEARG ((char *)EOF)
21: #define DAYSEC (60L*60L*24L) /* seconds in a day */
22: #define inode(f,v) lnode(FUN,f,v,NULL)
23: #define snode(f,s) lnode(FUN,f,0,s)
24: %}
25: %start command
26:
27: %union {
28: NODE *nodeptr;
29: }
30:
31: %left OR
32: %left AND
33: %left '!'
34: %token <nodeptr> NAME PERM TYPE LINKS USER GROUP SIZE INUM
35: %token <nodeptr> ATIME CTIME MTIME EXEC OK PRINT NEWER FUN NOP
36: %type <nodeptr> exp
37:
38: %%
39:
40: command:
41: exp '\n' { if (seflag)
42: code = $1; else
43: code = bnode(AND,$1,snode(xprint,NULL));
44: return;
45: }
46: | '\n' { code = snode(xprint, NULL); return; }
47: ;
48:
49: exp:
50: '(' exp ')' { $$ = $2; }
51: | '!' exp { $$ = bnode('!', $2, NULL); }
52: | exp OR exp { $$ = bnode(OR, $1, $3); }
53: | exp AND exp { $$ = bnode(AND, $1, $3); }
54: | NAME { $$ = snode(xname, next()); }
55: | PERM { $$ = onode(xperm); }
56: | TYPE { $$ = snode(xtype, next()); }
57: | LINKS { $$ = nnode(xlinks); }
58: | USER { $$ = getuser(); }
59: | GROUP { $$ = getgroup(); }
60: | SIZE { $$ = nnode(xsize); }
61: | INUM { $$ = nnode(xinum); }
62: | ATIME { $$ = nnode(xatime); }
63: | CTIME { $$ = nnode(xctime); }
64: | MTIME { $$ = nnode(xmtime); }
65: | EXEC { $$ = enode(0); }
66: | OK { $$ = enode(1); }
67: | PRINT { $$ = snode(xprint, NULL); seflag++; }
68: | NEWER { $$ = getnewer(); }
69: | NOP { $$ = snode(xnop, NULL); seflag++; }
70: ;
71:
72: %%
73: struct primary {
74: char *p_name;
75: int p_lval;
76: } primaries[] = {
77: "-name", NAME,
78: "-perm", PERM,
79: "-type", TYPE,
80: "-links", LINKS,
81: "-user", USER,
82: "-group", GROUP,
83: "-size", SIZE,
84: "-inum", INUM,
85: "-atime", ATIME,
86: "-ctime", CTIME,
87: "-mtime", MTIME,
88: "-exec", EXEC,
89: "-ok", OK,
90: "-print", PRINT,
91: "-newer", NEWER,
92: "-nop", NOP,
93: "-o", OR,
94: "-a", AND,
95: };
96:
97: char **gav;
98: int gac;
99: int depth; /* Recursive depth */
100:
101: struct stat sb;
102: char fname[NFNAME];
103: char *prompt;
104:
105: char toodeep[] = "directory structure too deep to traverse";
106: char nospace[] = "out of memory";
107:
108: time_t curtime;
109:
110: NODE *code;
111: int seflag; /* Set if a side effect (print, exec) found */
112:
113: char *next();
114: NODE *bnode();
115: NODE *enode();
116: NODE *lnode();
117: NODE *nnode();
118: NODE *onode();
119: NODE *getuser();
120: NODE *getgroup();
121: NODE *getnewer();
122: int xname();
123: int xperm();
124: int xtype();
125: int xlinks();
126: int xuser();
127: int xgroup();
128: int xsize();
129: int xinum();
130: int xatime();
131: int xctime();
132: int xmtime();
133: int xnewer();
134: int xexec();
135: int xprint();
136: int xnop();
137: char *getenv();
138:
139: main(argc, argv)
140: char *argv[];
141: {
142: register int i;
143: register char *ap;
144: register int eargc;
145:
146: for (i=1; i<argc; i++) {
147: ap = argv[i];
148: if (*ap == '-')
149: break;
150: if (ap[1]=='\0' && (*ap=='!' || *ap=='('))
151: break;
152: }
153: if ((eargc=i) < 2)
154: usage();
155: gav = argv+i;
156: gac = argc-i;
157: yyparse();
158: time(&curtime);
159: if ((prompt = getenv("PS1")) == NULL)
160: prompt = "> ";
161: for (i=1; i<eargc; i++)
162: find(argv[i]);
163: }
164:
165: /*
166: * Lexical analyser
167: */
168: yylex()
169: {
170: static int binop = 0;
171: static int ntoken = 0;
172: register char *ap;
173: struct primary *pp;
174: register int token;
175:
176: if (ntoken) {
177: token = ntoken;
178: ntoken = 0;
179: } else if ((ap = next()) == NULL)
180: token = '\n';
181: else if (ap[1] == '\0')
182: token = ap[0];
183: else if (*ap == '-') {
184: for (pp = primaries; pp < &primaries[NPRIM]; pp++)
185: if (strcmp(pp->p_name, ap) == 0) {
186: token = pp->p_lval;
187: break;
188: }
189: if (pp >= &primaries[NPRIM])
190: ferr("`%s' is an illegal primary", ap);
191: } else
192: ferr("Illegal expression %s\n", ap);
193: if (binop && token!=')' && token!='\n' && token!=OR && token!=AND) {
194: binop = 0;
195: ntoken = token;
196: return (AND);
197: }
198: if (token!=OR && token!=AND && token!='!' && token!='\n' && token!='(')
199: binop = 1; else
200: binop = 0;
201: return (token);
202: }
203:
204: yyerror()
205: {
206: fprintf(stderr, "Primary expression syntax error\n");
207: usage();
208: }
209:
210: /*
211: * Return the next argument from the arg list.
212: */
213: char *
214: next()
215: {
216: if (gac < 1)
217: return (NULL);
218: gac--;
219: return (*gav++);
220: }
221:
222: /*
223: * Produce a node consisting
224: * of an octal number.
225: */
226: NODE *
227: onode(fun)
228: int (*fun)();
229: {
230: register char *ap;
231: register int num;
232: register NODE *np;
233: register int type;
234: char *aap;
235:
236: if ((ap = next()) == NULL)
237: ferr("Missing octal permission");
238: aap = ap;
239: if (*ap == '-') {
240: ap++;
241: type = -1;
242: } else
243: type = 0;
244: num = 0;
245: while (*ap>='0' && *ap<='7')
246: num = num*8 + *ap++-'0';
247: if (*ap != '\0')
248: ferr("%s: bad octal permission", aap);
249: np = inode(fun, num);
250: np->n_un.n_val = num;
251: np->n_type = type;
252: return (np);
253: }
254:
255: /*
256: * Get a number -- it also may be
257: * prefixed by `+' or `-' to
258: * represent quantities greater or
259: * less.
260: */
261: NODE *
262: nnode(fun)
263: int (*fun);
264: {
265: register char *ap;
266: register int num = 0;
267: register int type = 0;
268: register NODE *np;
269: char *aap;
270:
271: if ((ap = next()) == NULL)
272: ferr("Missing number");
273: aap = ap;
274: if (*ap == '+') {
275: type = 1;
276: ap++;
277: } else if (*ap == '-') {
278: type = -1;
279: ap++;
280: }
281: while (*ap>='0' && *ap<='9')
282: num = num*10 + *ap++ - '0';
283: if (*ap != '\0')
284: ferr("%s: invalid number", aap);
285: np = inode(fun, num);
286: np->n_type = type;
287: return (np);
288: }
289:
290: /*
291: * Get a user name or number.
292: */
293: NODE *
294: getuser()
295: {
296: register struct passwd *pwp;
297: register char *cp;
298: register int uid;
299:
300: if ((cp = next()) == NULL)
301: ferr("Missing username");
302: if (*cp>='0' && *cp<='9')
303: uid = atoi(cp);
304: else {
305: if ((pwp = getpwnam(cp)) == NULL)
306: ferr("%s: bad user name", cp);
307: uid = pwp->pw_uid;
308: }
309: return (lnode(FUN, xuser, uid, NULL));
310: }
311:
312: /*
313: * Get group
314: */
315: NODE *
316: getgroup()
317: {
318: register struct group *grp;
319: register char *cp;
320: register int gid;
321:
322: if ((cp = next()) == NULL)
323: ferr("Missing group name");
324: if (*cp>='0' && *cp<='9')
325: gid = atoi(cp);
326: else {
327: if ((grp = getgrnam(cp)) == NULL)
328: ferr("%s: bad group name", cp);
329: gid = grp->gr_gid;
330: }
331: return (lnode(FUN, xgroup, gid, NULL));
332: }
333:
334: /*
335: * Get the time for the file used in
336: * the `-newer' primary.
337: */
338: NODE *
339: getnewer()
340: {
341: register NODE *np;
342: register char *fn;
343:
344: if ((fn = next()) == NULL)
345: ferr("Missing filename for `-newer'");
346: if (stat(fn, &sb) < 0)
347: ferr("%s: nonexistent", fn);
348: np = inode(xnewer, 0);
349: np->n_un.n_time = sb.st_mtime;
350: return (np);
351: }
352:
353: /*
354: * Build an expression tree node (non-leaf).
355: */
356: NODE *
357: bnode(op, left, right)
358: int op;
359: NODE *left, *right;
360: {
361: register NODE *np;
362:
363: if ((np = malloc(sizeof (NODE))) == NULL)
364: ferr(nospace);
365: np->n_op = op;
366: np->n_left = left;
367: np->n_right = right;
368: np->n_un.n_val = 0;
369: return (np);
370: }
371:
372: /*
373: * Build a leaf node in expression tree.
374: */
375: NODE *
376: lnode(op, fn, val, str)
377: int (*fn)();
378: char *str;
379: {
380: register NODE *np;
381:
382: if ((np = malloc(sizeof (NODE))) == NULL)
383: ferr(nospace);
384: np->n_left = np->n_right = NULL;
385: np->n_op = op;
386: np->n_fun = fn;
387: if (str != NULL)
388: np->n_un.n_str = str; else
389: np->n_un.n_val = val;
390: return (np);
391: }
392:
393: /*
394: * Build an execution node
395: * for -ok or -exec.
396: */
397: NODE *
398: enode(type)
399: {
400: register NODE *np;
401: register char **app;
402: register char *ap;
403:
404: seflag++;
405: np = snode(xexec, NULL);
406: np->n_type = type;
407: if ((np->n_un.n_strp = (char**)malloc(sizeof(char*[NARG])))==NULL)
408: ferr(nospace);
409: app = np->n_un.n_strp;
410: for (;;) {
411: if ((ap = next()) == NULL)
412: ferr("Non-terminated -exec or -ok command list");
413: if (strcmp(ap, "{}") == 0)
414: ap = FILEARG;
415: else if (strcmp(ap, ";") == 0)
416: break;
417: if (app-np->n_un.n_strp >= NARG-1)
418: ferr("Too many -exec or -ok command arguments");
419: *app++ = ap;
420: }
421: *app = NULL;
422: return (np);
423: }
424:
425: /*
426: * Execute find on a single
427: * pathname hierarchy.
428: */
429: find(dir)
430: char *dir;
431: {
432: register char *ep, *cp;
433:
434: cp = dir;
435: ep = fname;
436: while (*cp)
437: *ep++ = *cp++;
438: *ep = '\0';
439: if (stat(dir, &sb) < 0)
440: ferr("Cannot find directory `%s'", dir);
441: if ((sb.st_mode&S_IFMT) != S_IFDIR)
442: ferr("%s: not a directory", dir);
443: fentry(ep, &sb);
444: }
445:
446: /*
447: * The pointer is the end pointer
448: * into the fname buffer.
449: * And the stat buffer is passed to this
450: * which traverses the directory hierarchy.
451: */
452: fentry(ep, sbp)
453: char *ep;
454: struct stat *sbp;
455: {
456: char *buildname();
457: register char *np;
458: register struct direct *dp;
459: register int nb;
460: int fd;
461: int dirflag;
462: char *iobuf;
463:
464: if (sbp != NULL) {
465: dirflag = (sbp->st_mode&S_IFMT)==S_IFDIR;
466: execute(code);
467: } else
468: dirflag = 1;
469: if (dirflag) {
470: if (++depth >= NRECUR) {
471: depth = 0;
472: ffork(ep, sbp);
473: return;
474: }
475: if ((fd = open(fname, 0)) < 0) {
476: fmsg("%s: cannot open directory", fname);
477: return;
478: }
479: if ((iobuf = malloc(BUFSIZ)) == NULL)
480: ferr(nospace);
481: while ((nb = read(fd, iobuf, BUFSIZ)) > 0)
482: for (dp = iobuf; dp < &iobuf[nb]; dp++) {
483: if (dp->d_ino == 0)
484: continue;
485: np = dp->d_name;
486: if (*np++=='.'
487: && (*np=='\0' || (*np++=='.' && *np=='\0')))
488: continue;
489: np = buildname(dp, ep);
490: if (stat(fname, &sb) < 0) {
491: fmsg("%s: cannot stat", fname);
492: continue;
493: }
494: fentry(np, &sb);
495: }
496: if (nb < 0)
497: fmsg("%s: directory read error", fname);
498: free(iobuf);
499: *ep = '\0';
500: close(fd);
501: depth--;
502: }
503: }
504:
505: /*
506: * Fork to do a find on recursive directory
507: * structure that is too deep to fit into
508: * user's open files.
509: */
510: ffork(ep, sbp)
511: char *ep;
512: struct stat *sbp;
513: {
514: register int i;
515: register int pid;
516: int status;
517:
518: fflush(stdout);
519: if ((pid = fork()) < 0) {
520: fmsg(toodeep);
521: return;
522: }
523: if (pid) {
524: while (wait(&status) >= 0)
525: ;
526: if (status)
527: fmsg("panic: child failed: %o", status);
528: return;
529: }
530: for (i=3; i<_NFILE; i++)
531: close(i);
532: fentry(ep, (struct stat *)NULL);
533: fflush(stdout);
534: exit(0);
535: }
536:
537: /*
538: * Build up the next entry
539: * in the name.
540: */
541: char *
542: buildname(dp, ep)
543: struct direct *dp;
544: register char *ep;
545: {
546: register char *cp = dp->d_name;
547: register unsigned n = DIRSIZ;
548:
549: if (ep+DIRSIZ+2 >= &fname[NFNAME]) {
550: fmsg(toodeep);
551: return (NULL);
552: }
553: if (ep>fname && ep[-1]!='/')
554: *ep++ = '/';
555: do {
556: if (*cp == '\0')
557: break;
558: *ep++ = *cp++;
559: } while (--n);
560: *ep = '\0';
561: return (ep);
562: }
563:
564: /*
565: * Execute compiled code.
566: */
567: execute(np)
568: register NODE *np;
569: {
570: switch (np->n_op) {
571: case AND:
572: if (execute(np->n_left) && execute(np->n_right))
573: return (1);
574: return (0);
575:
576: case OR:
577: if (execute(np->n_left) || execute(np->n_right))
578: return (1);
579: return (0);
580:
581: case '!':
582: return (!execute(np->n_left));
583:
584: case FUN:
585: return ((*np->n_fun)(np));
586:
587: default:
588: ferr("Panic: bad expression tree (op %d)", np->n_op);
589: }
590: /* NOTREACHED */
591: }
592:
593: /*
594: * Check for a match on the filename
595: */
596: xname(np)
597: NODE *np;
598: {
599: register char *ep;
600:
601: ep = fname;
602: while (*ep != '\0')
603: ep++;
604: while (ep>fname && *--ep!='/')
605: ;
606: if (*ep == '/')
607: ep++;
608: return (pnmatch(ep, np->n_un.n_str, 0));
609: }
610:
611: /*
612: * Compare the mode for a match again
613: * octal number `np->n_un.n_val'.
614: */
615: xperm(np)
616: NODE *np;
617: {
618: register int onum;
619: register int mode;
620:
621: mode = np->n_type<0 ? sb.st_mode&017777 : sb.st_mode&0777;
622: onum = np->n_un.n_val;
623: if (np->n_type < 0)
624: return ((mode&onum) == onum);
625: return (mode == onum);
626: }
627:
628: /*
629: * Compare again filetypes
630: */
631: xtype(np)
632: NODE *np;
633: {
634: register char *type;
635: register int ftype;
636:
637: type = np->n_un.n_str;
638: ftype = sb.st_mode&S_IFMT;
639: if (type[1] == '\0')
640: switch (type[0]) {
641: case 'b':
642: return (ftype == S_IFBLK);
643:
644: case 'c':
645: return (ftype == S_IFCHR);
646:
647: case 'd':
648: return (ftype == S_IFDIR);
649:
650: case 'f':
651: return (ftype == S_IFREG);
652:
653: case 'm':
654: return (ftype==S_IFMPB || ftype==S_IFMPC);
655:
656: case 'p':
657: return (ftype == S_IFPIP);
658: }
659: ferr("Bad file type `%s'", type);
660: }
661:
662: /*
663: * Compare link counts.
664: */
665: xlinks(np)
666: NODE *np;
667: {
668: return (ncomp(np, sb.st_nlink));
669: }
670:
671: /*
672: * Compare uid.
673: */
674: xuser(np)
675: NODE *np;
676: {
677: return (np->n_un.n_val == sb.st_uid);
678: }
679:
680: /*
681: * Compare group id of file
682: * with given one.
683: */
684: xgroup(np)
685: NODE *np;
686: {
687: return (np->n_un.n_val == sb.st_gid);
688: }
689:
690: /*
691: * Compare size of file in blocks
692: * with given.
693: */
694: xsize(np)
695: NODE *np;
696: {
697: register int fsize;
698:
699: fsize = (sb.st_size+BUFSIZ-1)/BUFSIZ;
700: return (ncomp(np, fsize));
701: }
702:
703: /*
704: * Compare the i-number of the file
705: * with that given.
706: */
707: xinum(np)
708: NODE *np;
709: {
710: return (ncomp(np, sb.st_ino));
711: }
712:
713: /*
714: * Return true if file has been accessed
715: * in `n' days.
716: */
717: xatime(np)
718: NODE *np;
719: {
720: return (ndays(np, sb.st_atime));
721: }
722:
723: /*
724: * Return non-zero if file has been created
725: * in `n' days.
726: */
727: xctime(np)
728: NODE *np;
729: {
730: return (ndays(np, sb.st_ctime));
731: }
732:
733: /*
734: * Return true if file has been modified
735: * in `n' days.
736: */
737: xmtime(np)
738: NODE *np;
739: {
740: return (ndays(np, sb.st_mtime));
741: }
742:
743: /*
744: * Execute a command based on the filename
745: */
746: xexec(np)
747: NODE *np;
748: {
749: static char command[200];
750: register char *ap, **app;
751: register int c;
752: int ok;
753:
754: command[0] = '\0';
755: app = np->n_un.n_strp;
756: while (*app != NULL) {
757: if ((ap = *app++) == FILEARG)
758: ap = fname;
759: strcat(command, ap);
760: if (*app != NULL)
761: strcat(command, " ");
762: }
763: if (np->n_type) {
764: printf("%s%s? ", prompt, command);
765: ok = (c = getchar()) == 'y';
766: while (c!='\n' && c!=EOF)
767: c = getchar();
768: if (!ok)
769: return (0);
770: }
771: return (!system(command));
772: }
773:
774: /*
775: * Print the filename.
776: */
777: /* ARGSUSED */
778: xprint(np)
779: NODE *np;
780: {
781: printf("%s\n", fname);
782: return (1);
783: }
784:
785: xnop(np)
786: NODE *np;
787: {
788: return (1);
789: }
790:
791: /*
792: * Return true if the file is newer than
793: * the given one.
794: */
795: xnewer(np)
796: register NODE *np;
797: {
798: return (sb.st_mtime > np->n_un.n_time);
799: }
800:
801: /*
802: * Do a numerical comparison on dates.
803: */
804: ndays(np, t)
805: register NODE *np;
806: time_t t;
807: {
808: register int days;
809:
810: days = (curtime-t+DAYSEC/2)/DAYSEC;
811: return (ncomp(np, days));
812: }
813:
814: /*
815: * Numerical compare.
816: */
817: ncomp(np, val)
818: register NODE *np;
819: register unsigned val;
820: {
821: if (np->n_type == 0)
822: return (np->n_un.n_val == val);
823: if (np->n_type > 0)
824: return (val > np->n_un.n_val);
825: return (val < np->n_un.n_val);
826: }
827:
828: /*
829: * Errors
830: */
831: /* VARARGS */
832: ferr(x)
833: {
834: fprintf(stderr, "find: %r\n", &x);
835: exit (1);
836: }
837:
838: /* VARARGS */
839: fmsg(x)
840: {
841: fprintf(stderr, "find: %r\n", &x);
842: }
843:
844: usage()
845: {
846: fprintf(stderr, "Usage: find directory ... [ expression ]\n");
847: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.