![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to find.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / usr.bin / find|
Return to find.c CVS log | Up to [CSRG BSD Unix] / 43BSD / usr.bin / find |
1.1 root 1: #ifndef lint
2: static char *sccsid = "@(#)find.c 4.17 (Berkeley) 1/31/86";
3: #endif
4:
5: #include <stdio.h>
6: #include <sys/param.h>
7: #include <sys/dir.h>
8: #include <sys/stat.h>
9:
10: #define A_DAY 86400L /* a day full of seconds */
11: #define EQ(x, y) (strcmp(x, y)==0)
12:
13: int Randlast;
14: char Pathname[MAXPATHLEN+1];
15:
16: #define MAXNODES 100
17:
18: struct anode {
19: int (*F)();
20: struct anode *L, *R;
21: } Node[MAXNODES];
22: int Nn; /* number of nodes */
23: char *Fname;
24: long Now;
25: int Argc,
26: Ai,
27: Pi;
28: char **Argv;
29: /* cpio stuff */
30: int Cpio;
31: short *Buf, *Dbuf, *Wp;
32: int Bufsize = 5120;
33: int Wct = 2560;
34:
35: long Newer;
36:
37: int Xdev = 1; /* true if SHOULD cross devices (file systems) */
38: struct stat Devstat; /* stats of each argument path's file system */
39:
40: struct stat Statb;
41:
42: struct anode *exp(),
43: *e1(),
44: *e2(),
45: *e3(),
46: *mk();
47: char *nxtarg();
48: char Home[MAXPATHLEN + 1];
49: long Blocks;
50: char *rindex();
51: char *sbrk();
52:
53: /*
54: * SEE ALSO: updatedb, bigram.c, code.c
55: * Usenix ;login:, February/March, 1983, p. 8.
56: *
57: * REVISIONS: James A. Woods, Informatics General Corporation,
58: * NASA Ames Research Center, 6/81.
59: *
60: * The second form searches a pre-computed filelist
61: * (constructed nightly by /usr/lib/crontab) which is
62: * compressed by updatedb (v.i.z.) The effect of
63: * find <name>
64: * is similar to
65: * find / +0 -name "*<name>*" -print
66: * but much faster.
67: *
68: * 8/82 faster yet + incorporation of bigram coding -- jaw
69: *
70: * 1/83 incorporate glob-style matching -- jaw
71: */
72: #define AMES 1
73:
74: main(argc, argv)
75: int argc;
76: char *argv[];
77: {
78: struct anode *exlist;
79: int paths;
80: register char *cp, *sp = 0;
81: #ifdef SUID_PWD
82: FILE *pwd, *popen();
83: #endif
84:
85: #ifdef AMES
86: if (argc < 2) {
87: fprintf(stderr,
88: "Usage: find name, or find path-list predicate-list\n");
89: exit(1);
90: }
91: if (argc == 2) {
92: fastfind(argv[1]);
93: exit(0);
94: }
95: #endif
96: time(&Now);
97: #ifdef SUID_PWD
98: pwd = popen("pwd", "r");
99: fgets(Home, sizeof Home, pwd);
100: pclose(pwd);
101: Home[strlen(Home) - 1] = '\0';
102: #else
103: if (getwd(Home) == NULL) {
104: fprintf(stderr, "find: Can't get current working directory\n");
105: exit(1);
106: }
107: #endif
108: Argc = argc; Argv = argv;
109: if(argc<3) {
110: usage: fprintf(stderr, "Usage: find path-list predicate-list\n");
111: exit(1);
112: }
113: for(Ai = paths = 1; Ai < (argc-1); ++Ai, ++paths)
114: if(*Argv[Ai] == '-' || EQ(Argv[Ai], "(") || EQ(Argv[Ai], "!"))
115: break;
116: if(paths == 1) /* no path-list */
117: goto usage;
118: if(!(exlist = exp())) { /* parse and compile the arguments */
119: fprintf(stderr, "find: parsing error\n");
120: exit(1);
121: }
122: if(Ai<argc) {
123: fprintf(stderr, "find: missing conjunction\n");
124: exit(1);
125: }
126: for(Pi = 1; Pi < paths; ++Pi) {
127: sp = 0;
128: chdir(Home);
129: strcpy(Pathname, Argv[Pi]);
130: if(cp = rindex(Pathname, '/')) {
131: sp = cp + 1;
132: *cp = '\0';
133: if(chdir(*Pathname? Pathname: "/") == -1) {
134: fprintf(stderr, "find: bad starting directory\n");
135: exit(2);
136: }
137: *cp = '/';
138: }
139: Fname = sp? sp: Pathname;
140: if (!Xdev)
141: stat(Pathname, &Devstat);
142: descend(Pathname, Fname, exlist); /* to find files that match */
143: }
144: if(Cpio) {
145: strcpy(Pathname, "TRAILER!!!");
146: Statb.st_size = 0;
147: cpio();
148: printf("%D blocks\n", Blocks*10);
149: }
150: exit(0);
151: }
152:
153: /* compile time functions: priority is exp()<e1()<e2()<e3() */
154:
155: struct anode *exp() { /* parse ALTERNATION (-o) */
156: int or();
157: register struct anode * p1;
158:
159: p1 = e1() /* get left operand */ ;
160: if(EQ(nxtarg(), "-o")) {
161: Randlast--;
162: return(mk(or, p1, exp()));
163: }
164: else if(Ai <= Argc) --Ai;
165: return(p1);
166: }
167: struct anode *e1() { /* parse CONCATENATION (formerly -a) */
168: int and();
169: register struct anode * p1;
170: register char *a;
171:
172: p1 = e2();
173: a = nxtarg();
174: if(EQ(a, "-a")) {
175: And:
176: Randlast--;
177: return(mk(and, p1, e1()));
178: } else if(EQ(a, "(") || EQ(a, "!") || (*a=='-' && !EQ(a, "-o"))) {
179: --Ai;
180: goto And;
181: } else if(Ai <= Argc) --Ai;
182: return(p1);
183: }
184: struct anode *e2() { /* parse NOT (!) */
185: int not();
186:
187: if(Randlast) {
188: fprintf(stderr, "find: operand follows operand\n");
189: exit(1);
190: }
191: Randlast++;
192: if(EQ(nxtarg(), "!"))
193: return(mk(not, e3(), (struct anode *)0));
194: else if(Ai <= Argc) --Ai;
195: return(e3());
196: }
197: struct anode *e3() { /* parse parens and predicates */
198: int exeq(), ok(), glob(), mtime(), atime(), user(),
199: group(), size(), perm(), links(), print(),
200: type(), ino(), cpio(), newer(),
201: nouser(), nogroup(), ls(), dummy();
202: struct anode *p1;
203: int i;
204: register char *a, *b;
205: register int s;
206:
207: a = nxtarg();
208: if(EQ(a, "(")) {
209: Randlast--;
210: p1 = exp();
211: a = nxtarg();
212: if(!EQ(a, ")")) goto err;
213: return(p1);
214: }
215: else if(EQ(a, "-print")) {
216: return(mk(print, (struct anode *)0, (struct anode *)0));
217: }
218: else if (EQ(a, "-nouser")) {
219: return (mk(nouser, (struct anode *)0, (struct anode *)0));
220: }
221: else if (EQ(a, "-nogroup")) {
222: return (mk(nogroup, (struct anode *)0, (struct anode *)0));
223: }
224: else if (EQ(a, "-ls")) {
225: return (mk(ls, (struct anode *)0, (struct anode *)0));
226: }
227: else if (EQ(a, "-xdev")) {
228: Xdev = 0;
229: return (mk(dummy, (struct anode *)0, (struct anode *)0));
230: }
231: b = nxtarg();
232: s = *b;
233: if(s=='+') b++;
234: if(EQ(a, "-name"))
235: return(mk(glob, (struct anode *)b, (struct anode *)0));
236: else if(EQ(a, "-mtime"))
237: return(mk(mtime, (struct anode *)atoi(b), (struct anode *)s));
238: else if(EQ(a, "-atime"))
239: return(mk(atime, (struct anode *)atoi(b), (struct anode *)s));
240: else if(EQ(a, "-user")) {
241: if((i=getuid(b)) == -1) {
242: if(gmatch(b, "[0-9]*"))
243: return mk(user, (struct anode *)atoi(b), (struct anode *)s);
244: fprintf(stderr, "find: cannot find -user name\n");
245: exit(1);
246: }
247: return(mk(user, (struct anode *)i, (struct anode *)s));
248: }
249: else if(EQ(a, "-inum"))
250: return(mk(ino, (struct anode *)atoi(b), (struct anode *)s));
251: else if(EQ(a, "-group")) {
252: if((i=getgid(b)) == -1) {
253: if(gmatch(b, "[0-9]*"))
254: return mk(group, (struct anode *)atoi(b), (struct anode *)s);
255: fprintf(stderr, "find: cannot find -group name\n");
256: exit(1);
257: }
258: return(mk(group, (struct anode *)i, (struct anode *)s));
259: } else if(EQ(a, "-size"))
260: return(mk(size, (struct anode *)atoi(b), (struct anode *)s));
261: else if(EQ(a, "-links"))
262: return(mk(links, (struct anode *)atoi(b), (struct anode *)s));
263: else if(EQ(a, "-perm")) {
264: for(i=0; *b ; ++b) {
265: if(*b=='-') continue;
266: i <<= 3;
267: i = i + (*b - '0');
268: }
269: return(mk(perm, (struct anode *)i, (struct anode *)s));
270: }
271: else if(EQ(a, "-type")) {
272: i = s=='d' ? S_IFDIR :
273: s=='b' ? S_IFBLK :
274: s=='c' ? S_IFCHR :
275: s=='f' ? S_IFREG :
276: s=='l' ? S_IFLNK :
277: s=='s' ? S_IFSOCK :
278: 0;
279: return(mk(type, (struct anode *)i, (struct anode *)0));
280: }
281: else if (EQ(a, "-exec")) {
282: i = Ai - 1;
283: while(!EQ(nxtarg(), ";"));
284: return(mk(exeq, (struct anode *)i, (struct anode *)0));
285: }
286: else if (EQ(a, "-ok")) {
287: i = Ai - 1;
288: while(!EQ(nxtarg(), ";"));
289: return(mk(ok, (struct anode *)i, (struct anode *)0));
290: }
291: else if(EQ(a, "-cpio")) {
292: if((Cpio = creat(b, 0666)) < 0) {
293: fprintf(stderr, "find: cannot create < %s >\n", s);
294: exit(1);
295: }
296: Buf = (short *)sbrk(512);
297: Wp = Dbuf = (short *)sbrk(5120);
298: return(mk(cpio, (struct anode *)0, (struct anode *)0));
299: }
300: else if(EQ(a, "-newer")) {
301: if(stat(b, &Statb) < 0) {
302: fprintf(stderr, "find: cannot access < %s >\n", b);
303: exit(1);
304: }
305: Newer = Statb.st_mtime;
306: return mk(newer, (struct anode *)0, (struct anode *)0);
307: }
308: err: fprintf(stderr, "find: bad option < %s >\n", a);
309: exit(1);
310: }
311: struct anode *mk(f, l, r)
312: int (*f)();
313: struct anode *l, *r;
314: {
315: if (Nn >= MAXNODES) {
316: fprintf(stderr, "find: Too many options\n");
317: exit(1);
318: }
319:
320: Node[Nn].F = f;
321: Node[Nn].L = l;
322: Node[Nn].R = r;
323: return(&(Node[Nn++]));
324: }
325:
326: char *nxtarg() { /* get next arg from command line */
327: static strikes = 0;
328:
329: if(strikes==3) {
330: fprintf(stderr, "find: incomplete statement\n");
331: exit(1);
332: }
333: if(Ai>=Argc) {
334: strikes++;
335: Ai = Argc + 1;
336: return("");
337: }
338: return(Argv[Ai++]);
339: }
340:
341: /* execution time functions */
342: and(p)
343: register struct anode *p;
344: {
345: return(((*p->L->F)(p->L)) && ((*p->R->F)(p->R))?1:0);
346: }
347: or(p)
348: register struct anode *p;
349: {
350: return(((*p->L->F)(p->L)) || ((*p->R->F)(p->R))?1:0);
351: }
352: not(p)
353: register struct anode *p;
354: {
355: return( !((*p->L->F)(p->L)));
356: }
357: glob(p)
358: register struct { int f; char *pat; } *p;
359: {
360: return(gmatch(Fname, p->pat));
361: }
362: print(p)
363: struct anode *p;
364: {
365: puts(Pathname);
366: return(1);
367: }
368: mtime(p)
369: register struct { int f, t, s; } *p;
370: {
371: return(scomp((int)((Now - Statb.st_mtime) / A_DAY), p->t, p->s));
372: }
373: atime(p)
374: register struct { int f, t, s; } *p;
375: {
376: return(scomp((int)((Now - Statb.st_atime) / A_DAY), p->t, p->s));
377: }
378: user(p)
379: register struct { int f, u, s; } *p;
380: {
381: return(scomp(Statb.st_uid, p->u, p->s));
382: }
383: nouser(p)
384: struct anode *p;
385: {
386: char *getname();
387:
388: return (getname(Statb.st_uid) == NULL);
389: }
390: ino(p)
391: register struct { int f, u, s; } *p;
392: {
393: return(scomp((int)Statb.st_ino, p->u, p->s));
394: }
395: group(p)
396: register struct { int f, u; } *p;
397: {
398: return(p->u == Statb.st_gid);
399: }
400: nogroup(p)
401: struct anode *p;
402: {
403: char *getgroup();
404:
405: return (getgroup(Statb.st_gid) == NULL);
406: }
407: links(p)
408: register struct { int f, link, s; } *p;
409: {
410: return(scomp(Statb.st_nlink, p->link, p->s));
411: }
412: size(p)
413: register struct { int f, sz, s; } *p;
414: {
415: return(scomp((int)((Statb.st_size+511)>>9), p->sz, p->s));
416: }
417: perm(p)
418: register struct { int f, per, s; } *p;
419: {
420: register i;
421: i = (p->s=='-') ? p->per : 07777; /* '-' means only arg bits */
422: return((Statb.st_mode & i & 07777) == p->per);
423: }
424: type(p)
425: register struct { int f, per, s; } *p;
426: {
427: return((Statb.st_mode&S_IFMT)==p->per);
428: }
429: exeq(p)
430: register struct { int f, com; } *p;
431: {
432: fflush(stdout); /* to flush possible `-print' */
433: return(doex(p->com));
434: }
435: ok(p)
436: struct { int f, com; } *p;
437: {
438: char c; int yes;
439: yes = 0;
440: fflush(stdout); /* to flush possible `-print' */
441: fprintf(stderr, "< %s ... %s > ? ", Argv[p->com], Pathname);
442: fflush(stderr);
443: if((c=getchar())=='y') yes = 1;
444: while(c!='\n') c = getchar();
445: if(yes) return(doex(p->com));
446: return(0);
447: }
448:
449: #define MKSHORT(v, lv) {U.l=1L;if(U.c[0]) U.l=lv, v[0]=U.s[1], v[1]=U.s[0]; else U.l=lv, v[0]=U.s[0], v[1]=U.s[1];}
450: union { long l; short s[2]; char c[4]; } U;
451: long mklong(v)
452: short v[];
453: {
454: U.l = 1;
455: if(U.c[0] /* VAX */)
456: U.s[0] = v[1], U.s[1] = v[0];
457: else
458: U.s[0] = v[0], U.s[1] = v[1];
459: return U.l;
460: }
461: cpio(p)
462: struct anode *p;
463: {
464: #define MAGIC 070707
465: struct header {
466: short h_magic,
467: h_dev,
468: h_ino,
469: h_mode,
470: h_uid,
471: h_gid,
472: h_nlink,
473: h_rdev;
474: short h_mtime[2];
475: short h_namesize;
476: short h_filesize[2];
477: char h_name[256];
478: } hdr;
479: register ifile, ct;
480: static long fsz;
481: register i;
482:
483: hdr.h_magic = MAGIC;
484: strcpy(hdr.h_name, !strncmp(Pathname, "./", 2)? Pathname+2: Pathname);
485: hdr.h_namesize = strlen(hdr.h_name) + 1;
486: hdr.h_uid = Statb.st_uid;
487: hdr.h_gid = Statb.st_gid;
488: hdr.h_dev = Statb.st_dev;
489: hdr.h_ino = Statb.st_ino;
490: hdr.h_mode = Statb.st_mode;
491: MKSHORT(hdr.h_mtime, Statb.st_mtime);
492: hdr.h_nlink = Statb.st_nlink;
493: fsz = hdr.h_mode & S_IFREG? Statb.st_size: 0L;
494: MKSHORT(hdr.h_filesize, fsz);
495: hdr.h_rdev = Statb.st_rdev;
496: if(EQ(hdr.h_name, "TRAILER!!!")) {
497: bwrite((short *)&hdr, (sizeof hdr-256)+hdr.h_namesize);
498: for(i = 0; i < 10; ++i)
499: bwrite(Buf, 512);
500: return;
501: }
502: if(!mklong(hdr.h_filesize))
503: return;
504: if((ifile = open(Fname, 0)) < 0) {
505: cerror:
506: fprintf(stderr, "find: cannot copy < %s >\n", hdr.h_name);
507: return;
508: }
509: bwrite((short *)&hdr, (sizeof hdr-256)+hdr.h_namesize);
510: for(fsz = mklong(hdr.h_filesize); fsz > 0; fsz -= 512) {
511: ct = fsz>512? 512: fsz;
512: if(read(ifile, (char *)Buf, ct) < 0)
513: goto cerror;
514: bwrite(Buf, ct);
515: }
516: close(ifile);
517: return;
518: }
519: newer(p)
520: struct anode *p;
521: {
522: return Statb.st_mtime > Newer;
523: }
524: ls(p)
525: struct anode *p;
526: {
527: list(Pathname, &Statb);
528: return (1);
529: }
530: dummy(p)
531: struct anode *p;
532: {
533: /* dummy */
534: return (1);
535: }
536:
537: /* support functions */
538: scomp(a, b, s) /* funny signed compare */
539: register a, b;
540: register char s;
541: {
542: if(s == '+')
543: return(a > b);
544: if(s == '-')
545: return(a < (b * -1));
546: return(a == b);
547: }
548:
549: doex(com)
550: {
551: register np;
552: register char *na;
553: static char *nargv[50];
554: static ccode;
555: register int w, pid, omask;
556:
557: ccode = np = 0;
558: while (na=Argv[com++]) {
559: if(np >= sizeof nargv / sizeof *nargv - 1) break;
560: if(strcmp(na, ";")==0) break;
561: if(strcmp(na, "{}")==0) nargv[np++] = Pathname;
562: else nargv[np++] = na;
563: }
564: nargv[np] = 0;
565: if (np==0) return(9);
566: switch (pid = vfork()) {
567: case -1:
568: perror("find: Can't fork");
569: exit(1);
570: break;
571:
572: case 0:
573: chdir(Home);
574: execvp(nargv[0], nargv, np);
575: write(2, "find: Can't execute ", 20);
576: perror(nargv[0]);
577: /*
578: * Kill ourselves; our exit status will be a suicide
579: * note indicating we couldn't do the "exec".
580: */
581: kill(getpid(), SIGUSR1);
582: break;
583:
584: default:
585: omask = sigblock(sigmask(SIGINT)|sigmask(SIGQUIT));
586: while ((w = wait(&ccode)) != pid && w != -1)
587: ;
588: (void) sigsetmask(omask);
589: if ((ccode & 0177) == SIGUSR1)
590: exit(1);
591: return (ccode != 0 ? 0 : 1);
592: }
593: }
594:
595: getunum(f, s) char *f, *s; { /* find user/group name and return number */
596: register i;
597: register char *sp;
598: register c;
599: char str[20];
600: FILE *pin;
601:
602: i = -1;
603: pin = fopen(f, "r");
604: c = '\n'; /* prime with a CR */
605: do {
606: if(c=='\n') {
607: sp = str;
608: while((c = *sp++ = getc(pin)) != ':')
609: if(c == EOF) goto RET;
610: *--sp = '\0';
611: if(EQ(str, s)) {
612: while((c=getc(pin)) != ':')
613: if(c == EOF) goto RET;
614: sp = str;
615: while((*sp = getc(pin)) != ':') sp++;
616: *sp = '\0';
617: i = atoi(str);
618: goto RET;
619: }
620: }
621: } while((c = getc(pin)) != EOF);
622: RET:
623: fclose(pin);
624: return(i);
625: }
626:
627: descend(name, fname, exlist)
628: struct anode *exlist;
629: char *name, *fname;
630: {
631: DIR *dir = NULL;
632: register struct direct *dp;
633: register char *c1;
634: int rv = 0;
635: char *endofname;
636:
637: if (lstat(fname, &Statb)<0) {
638: fprintf(stderr, "find: bad status < %s >\n", name);
639: return(0);
640: }
641: (*exlist->F)(exlist);
642: if((Statb.st_mode&S_IFMT)!=S_IFDIR ||
643: !Xdev && Devstat.st_dev != Statb.st_dev)
644: return(1);
645:
646: for (c1 = name; *c1; ++c1);
647: if (*(c1-1) == '/')
648: --c1;
649: endofname = c1;
650:
651: if (chdir(fname) == -1)
652: return(0);
653: if ((dir = opendir(".")) == NULL) {
654: fprintf(stderr, "find: cannot open < %s >\n", name);
655: rv = 0;
656: goto ret;
657: }
658: for (dp = readdir(dir); dp != NULL; dp = readdir(dir)) {
659: if ((dp->d_name[0]=='.' && dp->d_name[1]=='\0') ||
660: (dp->d_name[0]=='.' && dp->d_name[1]=='.' && dp->d_name[2]=='\0'))
661: continue;
662: c1 = endofname;
663: *c1++ = '/';
664: strcpy(c1, dp->d_name);
665: Fname = endofname+1;
666: if(!descend(name, Fname, exlist)) {
667: *endofname = '\0';
668: chdir(Home);
669: if(chdir(Pathname) == -1) {
670: fprintf(stderr, "find: bad directory tree\n");
671: exit(1);
672: }
673: }
674: }
675: rv = 1;
676: ret:
677: if(dir)
678: closedir(dir);
679: if(chdir("..") == -1) {
680: *endofname = '\0';
681: fprintf(stderr, "find: bad directory <%s>\n", name);
682: rv = 1;
683: }
684: return(rv);
685: }
686:
687: gmatch(s, p) /* string match as in glob */
688: register char *s, *p;
689: {
690: if (*s=='.' && *p!='.') return(0);
691: return amatch(s, p);
692: }
693:
694: amatch(s, p)
695: register char *s, *p;
696: {
697: register cc;
698: int scc, k;
699: int c, lc;
700:
701: scc = *s;
702: lc = 077777;
703: switch (c = *p) {
704:
705: case '[':
706: k = 0;
707: while (cc = *++p) {
708: switch (cc) {
709:
710: case ']':
711: if (k)
712: return(amatch(++s, ++p));
713: else
714: return(0);
715:
716: case '-':
717: cc = p[1];
718: k |= lc <= scc && scc <= cc;
719: }
720: if (scc==(lc=cc)) k++;
721: }
722: return(0);
723:
724: case '?':
725: caseq:
726: if(scc) return(amatch(++s, ++p));
727: return(0);
728: case '*':
729: return(umatch(s, ++p));
730: case 0:
731: return(!scc);
732: }
733: if (c==scc) goto caseq;
734: return(0);
735: }
736:
737: umatch(s, p)
738: register char *s, *p;
739: {
740: if(*p==0) return(1);
741: while(*s)
742: if (amatch(s++, p)) return(1);
743: return(0);
744: }
745:
746: bwrite(rp, c)
747: register short *rp;
748: register c;
749: {
750: register short *wp = Wp;
751:
752: c = (c+1) >> 1;
753: while(c--) {
754: if(!Wct) {
755: again:
756: if(write(Cpio, (char *)Dbuf, Bufsize)<0) {
757: Cpio = chgreel(1, Cpio);
758: goto again;
759: }
760: Wct = Bufsize >> 1;
761: wp = Dbuf;
762: ++Blocks;
763: }
764: *wp++ = *rp++;
765: --Wct;
766: }
767: Wp = wp;
768: }
769: chgreel(x, fl)
770: {
771: register f;
772: char str[22];
773: FILE *devtty;
774: struct stat statb;
775: extern errno;
776:
777: fprintf(stderr, "find: errno: %d, ", errno);
778: fprintf(stderr, "find: can't %s\n", x? "write output": "read input");
779: fstat(fl, &statb);
780: if((statb.st_mode&S_IFMT) != S_IFCHR)
781: exit(1);
782: again:
783: fprintf(stderr, "If you want to go on, type device/file name %s\n",
784: "when ready");
785: devtty = fopen("/dev/tty", "r");
786: fgets(str, 20, devtty);
787: str[strlen(str) - 1] = '\0';
788: if(!*str)
789: exit(1);
790: close(fl);
791: if((f = open(str, x? 1: 0)) < 0) {
792: fprintf(stderr, "That didn't work");
793: fclose(devtty);
794: goto again;
795: }
796: return f;
797: }
798:
799: #ifdef AMES
800: /*
801: * 'fastfind' scans a file list for the full pathname of a file
802: * given only a piece of the name. The list has been processed with
803: * with "front-compression" and bigram coding. Front compression reduces
804: * space by a factor of 4-5, bigram coding by a further 20-25%.
805: * The codes are:
806: *
807: * 0-28 likeliest differential counts + offset to make nonnegative
808: * 30 escape code for out-of-range count to follow in next word
809: * 128-255 bigram codes, (128 most common, as determined by 'updatedb')
810: * 32-127 single character (printable) ascii residue
811: *
812: * A novel two-tiered string search technique is employed:
813: *
814: * First, a metacharacter-free subpattern and partial pathname is
815: * matched BACKWARDS to avoid full expansion of the pathname list.
816: * The time savings is 40-50% over forward matching, which cannot efficiently
817: * handle overlapped search patterns and compressed path residue.
818: *
819: * Then, the actual shell glob-style regular expression (if in this form)
820: * is matched against the candidate pathnames using the slower routines
821: * provided in the standard 'find'.
822: */
823:
824: #define FCODES "/usr/lib/find/find.codes"
825: #define YES 1
826: #define NO 0
827: #define OFFSET 14
828: #define ESCCODE 30
829:
830: fastfind ( pathpart )
831: char pathpart[];
832: {
833: register char *p, *s;
834: register int c;
835: char *q, *index(), *patprep();
836: int i, count = 0, globflag;
837: FILE *fp, *fopen();
838: char *patend, *cutoff;
839: char path[1024];
840: char bigram1[128], bigram2[128];
841: int found = NO;
842:
843: if ( (fp = fopen ( FCODES, "r" )) == NULL ) {
844: fprintf ( stderr, "find: can't open %s\n", FCODES );
845: exit ( 1 );
846: }
847: for ( i = 0; i < 128; i++ )
848: bigram1[i] = getc ( fp ), bigram2[i] = getc ( fp );
849:
850: if ( index ( pathpart, '*' ) || index ( pathpart, '?' ) || index ( pathpart, '[' ) )
851: globflag = YES;
852: patend = patprep ( pathpart );
853:
854: c = getc ( fp );
855: for ( ; ; ) {
856:
857: count += ( (c == ESCCODE) ? getw ( fp ) : c ) - OFFSET;
858:
859: for ( p = path + count; (c = getc ( fp )) > ESCCODE; ) /* overlay old path */
860: if ( c < 0200 )
861: *p++ = c;
862: else /* bigrams are parity-marked */
863: *p++ = bigram1[c & 0177], *p++ = bigram2[c & 0177];
864: if ( c == EOF )
865: break;
866: *p-- = NULL;
867: cutoff = ( found ? path : path + count);
868:
869: for ( found = NO, s = p; s >= cutoff; s-- )
870: if ( *s == *patend ) { /* fast first char check */
871: for ( p = patend - 1, q = s - 1; *p != NULL; p--, q-- )
872: if ( *q != *p )
873: break;
874: if ( *p == NULL ) { /* success on fast match */
875: found = YES;
876: if ( globflag == NO || amatch ( path, pathpart ) )
877: puts ( path );
878: break;
879: }
880: }
881: }
882: }
883:
884: /*
885: extract last glob-free subpattern in name for fast pre-match;
886: prepend '\0' for backwards match; return end of new pattern
887: */
888: static char globfree[100];
889:
890: char *
891: patprep ( name )
892: char *name;
893: {
894: register char *p, *endmark;
895: register char *subp = globfree;
896:
897: *subp++ = '\0';
898: p = name + strlen ( name ) - 1;
899: /*
900: skip trailing metacharacters (and [] ranges)
901: */
902: for ( ; p >= name; p-- )
903: if ( index ( "*?", *p ) == 0 )
904: break;
905: if ( p < name )
906: p = name;
907: if ( *p == ']' )
908: for ( p--; p >= name; p-- )
909: if ( *p == '[' ) {
910: p--;
911: break;
912: }
913: if ( p < name )
914: p = name;
915: /*
916: if pattern has only metacharacters,
917: check every path (force '/' search)
918: */
919: if ( (p == name) && index ( "?*[]", *p ) != 0 )
920: *subp++ = '/';
921: else {
922: for ( endmark = p; p >= name; p-- )
923: if ( index ( "]*?", *p ) != 0 )
924: break;
925: for ( ++p; (p <= endmark) && subp < (globfree + sizeof ( globfree )); )
926: *subp++ = *p++;
927: }
928: *subp = '\0';
929: return ( --subp );
930: }
931: #endif
932:
933: /* rest should be done with nameserver or database */
934:
935: #include <pwd.h>
936: #include <grp.h>
937: #include <utmp.h>
938:
939: struct utmp utmp;
940: #define NMAX (sizeof (utmp.ut_name))
941: #define SCPYN(a, b) strncpy(a, b, NMAX)
942:
943: #define NUID 64
944: #define NGID 300
945:
946: struct ncache {
947: int uid;
948: char name[NMAX+1];
949: } nc[NUID];
950: char outrangename[NMAX+1];
951: int outrangeuid = -1;
952: char groups[NGID][NMAX+1];
953: char outrangegroup[NMAX+1];
954: int outrangegid = -1;
955:
956: /*
957: * This function assumes that the password file is hashed
958: * (or some such) to allow fast access based on a name key.
959: * If this isn't true, duplicate the code for getgroup().
960: */
961: char *
962: getname(uid)
963: {
964: register struct passwd *pw;
965: struct passwd *getpwent();
966: register int cp;
967: extern int _pw_stayopen;
968:
969: _pw_stayopen = 1;
970:
971: #if (((NUID) & ((NUID) - 1)) != 0)
972: cp = uid % (NUID);
973: #else
974: cp = uid & ((NUID) - 1);
975: #endif
976: if (uid >= 0 && nc[cp].uid == uid && nc[cp].name[0])
977: return (nc[cp].name);
978: pw = getpwuid(uid);
979: if (!pw)
980: return (0);
981: nc[cp].uid = uid;
982: SCPYN(nc[cp].name, pw->pw_name);
983: return (nc[cp].name);
984: }
985:
986: char *
987: getgroup(gid)
988: {
989: register struct group *gr;
990: static init;
991: struct group *getgrent();
992:
993: if (gid >= 0 && gid < NGID && groups[gid][0])
994: return (&groups[gid][0]);
995: if (gid >= 0 && gid == outrangegid)
996: return (outrangegroup);
997: rescan:
998: if (init == 2) {
999: if (gid < NGID)
1000: return (0);
1001: setgrent();
1002: while (gr = getgrent()) {
1003: if (gr->gr_gid != gid)
1004: continue;
1005: outrangegid = gr->gr_gid;
1006: SCPYN(outrangegroup, gr->gr_name);
1007: endgrent();
1008: return (outrangegroup);
1009: }
1010: endgrent();
1011: return (0);
1012: }
1013: if (init == 0)
1014: setgrent(), init = 1;
1015: while (gr = getgrent()) {
1016: if (gr->gr_gid < 0 || gr->gr_gid >= NGID) {
1017: if (gr->gr_gid == gid) {
1018: outrangegid = gr->gr_gid;
1019: SCPYN(outrangegroup, gr->gr_name);
1020: return (outrangegroup);
1021: }
1022: continue;
1023: }
1024: if (groups[gr->gr_gid][0])
1025: continue;
1026: SCPYN(groups[gr->gr_gid], gr->gr_name);
1027: if (gr->gr_gid == gid)
1028: return (&groups[gid][0]);
1029: }
1030: init = 2;
1031: goto rescan;
1032: }
1033:
1034: int
1035: getuid(username)
1036: char *username;
1037: {
1038: register struct passwd *pw;
1039: struct passwd *getpwnam();
1040: #ifndef NO_PW_STAYOPEN
1041: extern int _pw_stayopen;
1042:
1043: _pw_stayopen = 1;
1044: #endif
1045:
1046: pw = getpwnam(username);
1047: if (pw != NULL)
1048: return (pw->pw_uid);
1049: else
1050: return (-1);
1051: }
1052:
1053: int
1054: getgid(groupname)
1055: char *groupname;
1056: {
1057: register struct group *gr;
1058: struct group *getgrnam();
1059:
1060: gr = getgrnam(groupname);
1061: if (gr != NULL)
1062: return (gr->gr_gid);
1063: else
1064: return (-1);
1065: }
1066:
1067: #define permoffset(who) ((who) * 3)
1068: #define permission(who, type) ((type) >> permoffset(who))
1069: #define kbytes(bytes) (((bytes) + 1023) / 1024)
1070:
1071: list(file, stp)
1072: char *file;
1073: register struct stat *stp;
1074: {
1075: char pmode[32], uname[32], gname[32], fsize[32], ftime[32];
1076: char *getname(), *getgroup(), *ctime();
1077: static long special[] = { S_ISUID, 's', S_ISGID, 's', S_ISVTX, 't' };
1078: static time_t sixmonthsago = -1;
1079: #ifdef S_IFLNK
1080: char flink[MAXPATHLEN + 1];
1081: #endif
1082: register int who;
1083: register char *cp;
1084: time_t now;
1085:
1086: if (file == NULL || stp == NULL)
1087: return (-1);
1088:
1089: time(&now);
1090: if (sixmonthsago == -1)
1091: sixmonthsago = now - 6L*30L*24L*60L*60L;
1092:
1093: switch (stp->st_mode & S_IFMT) {
1094: #ifdef S_IFDIR
1095: case S_IFDIR: /* directory */
1096: pmode[0] = 'd';
1097: break;
1098: #endif
1099: #ifdef S_IFCHR
1100: case S_IFCHR: /* character special */
1101: pmode[0] = 'c';
1102: break;
1103: #endif
1104: #ifdef S_IFBLK
1105: case S_IFBLK: /* block special */
1106: pmode[0] = 'b';
1107: break;
1108: #endif
1109: #ifdef S_IFLNK
1110: case S_IFLNK: /* symbolic link */
1111: pmode[0] = 'l';
1112: break;
1113: #endif
1114: #ifdef S_IFSOCK
1115: case S_IFSOCK: /* socket */
1116: pmode[0] = 's';
1117: break;
1118: #endif
1119: #ifdef S_IFREG
1120: case S_IFREG: /* regular */
1121: #endif
1122: default:
1123: pmode[0] = '-';
1124: break;
1125: }
1126:
1127: for (who = 0; who < 3; who++) {
1128: if (stp->st_mode & permission(who, S_IREAD))
1129: pmode[permoffset(who) + 1] = 'r';
1130: else
1131: pmode[permoffset(who) + 1] = '-';
1132:
1133: if (stp->st_mode & permission(who, S_IWRITE))
1134: pmode[permoffset(who) + 2] = 'w';
1135: else
1136: pmode[permoffset(who) + 2] = '-';
1137:
1138: if (stp->st_mode & special[who * 2])
1139: pmode[permoffset(who) + 3] = special[who * 2 + 1];
1140: else if (stp->st_mode & permission(who, S_IEXEC))
1141: pmode[permoffset(who) + 3] = 'x';
1142: else
1143: pmode[permoffset(who) + 3] = '-';
1144: }
1145: pmode[permoffset(who) + 1] = '\0';
1146:
1147: cp = getname(stp->st_uid);
1148: if (cp != NULL)
1149: sprintf(uname, "%-9.9s", cp);
1150: else
1151: sprintf(uname, "%-9d", stp->st_uid);
1152:
1153: cp = getgroup(stp->st_gid);
1154: if (cp != NULL)
1155: sprintf(gname, "%-9.9s", cp);
1156: else
1157: sprintf(gname, "%-9d", stp->st_gid);
1158:
1159: if (pmode[0] == 'b' || pmode[0] == 'c')
1160: sprintf(fsize, "%3d,%4d",
1161: major(stp->st_rdev), minor(stp->st_rdev));
1162: else {
1163: sprintf(fsize, "%8ld", stp->st_size);
1164: #ifdef S_IFLNK
1165: if (pmode[0] == 'l') {
1166: /*
1167: * Need to get the tail of the file name, since we have
1168: * already chdir()ed into the directory of the file
1169: */
1170: cp = rindex(file, '/');
1171: if (cp == NULL)
1172: cp = file;
1173: else
1174: cp++;
1175: who = readlink(cp, flink, sizeof flink - 1);
1176: if (who >= 0)
1177: flink[who] = '\0';
1178: else
1179: flink[0] = '\0';
1180: }
1181: #endif
1182: }
1183:
1184: cp = ctime(&stp->st_mtime);
1185: if (stp->st_mtime < sixmonthsago || stp->st_mtime > now)
1186: sprintf(ftime, "%-7.7s %-4.4s", cp + 4, cp + 20);
1187: else
1188: sprintf(ftime, "%-12.12s", cp + 4);
1189:
1190: printf("%5lu %4ld %s %2d %s%s%s %s %s%s%s\n",
1191: stp->st_ino, /* inode # */
1192: #ifdef S_IFSOCK
1193: (long) kbytes(dbtob(stp->st_blocks)), /* kbytes */
1194: #else
1195: (long) kbytes(stp->st_size), /* kbytes */
1196: #endif
1197: pmode, /* protection */
1198: stp->st_nlink, /* # of links */
1199: uname, /* owner */
1200: gname, /* group */
1201: fsize, /* # of bytes */
1202: ftime, /* modify time */
1203: file, /* name */
1204: #ifdef S_IFLNK
1205: (pmode[0] == 'l') ? " -> " : "",
1206: (pmode[0] == 'l') ? flink : "" /* symlink */
1207: #else
1208: "",
1209: ""
1210: #endif
1211: );
1212:
1213: return (0);
1214: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.