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