![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to function.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / find|
Return to function.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / find |
1.1 ! root 1: /*- ! 2: * Copyright (c) 1990 The Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * This code is derived from software contributed to Berkeley by ! 6: * Cimarron D. Taylor of the University of California, Berkeley. ! 7: * ! 8: * Redistribution and use in source and binary forms are permitted provided ! 9: * that: (1) source distributions retain this entire copyright notice and ! 10: * comment, and (2) distributions including binaries display the following ! 11: * acknowledgement: ``This product includes software developed by the ! 12: * University of California, Berkeley and its contributors'' in the ! 13: * documentation or other materials provided with the distribution and in ! 14: * all advertising materials mentioning features or use of this software. ! 15: * Neither the name of the University nor the names of its contributors may ! 16: * be used to endorse or promote products derived from this software without ! 17: * specific prior written permission. ! 18: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED ! 19: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF ! 20: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 21: */ ! 22: ! 23: #ifndef lint ! 24: static char sccsid[] = "@(#)function.c 5.8 (Berkeley) 6/30/90"; ! 25: #endif /* not lint */ ! 26: ! 27: #include <sys/types.h> ! 28: #include <sys/stat.h> ! 29: #include <sys/wait.h> ! 30: #include <sys/mount.h> ! 31: #include <grp.h> ! 32: #include <pwd.h> ! 33: #include <fts.h> ! 34: #include <unistd.h> ! 35: #include <tzfile.h> ! 36: #include <stdio.h> ! 37: #include <string.h> ! 38: #include "find.h" ! 39: ! 40: #define FIND_EQUAL 0 ! 41: #define FIND_LESSTHAN 1 ! 42: #define FIND_GREATER 2 ! 43: ! 44: #define COMPARE(a, b) { \ ! 45: switch(plan->flags) { \ ! 46: case FIND_EQUAL: \ ! 47: return(a == b); \ ! 48: case FIND_LESSTHAN: \ ! 49: return(a < b); \ ! 50: case FIND_GREATER: \ ! 51: return(a > b); \ ! 52: } \ ! 53: return(0); \ ! 54: } ! 55: ! 56: #define NEW(t, f) { \ ! 57: new = (PLAN *)emalloc(sizeof(PLAN)); \ ! 58: new->type = t; \ ! 59: new->eval = f; \ ! 60: new->flags = 0; \ ! 61: new->next = NULL; \ ! 62: } ! 63: ! 64: /* ! 65: * find_parsenum -- ! 66: * Parse a string of the form [+-]# and return the value. ! 67: */ ! 68: long ! 69: find_parsenum(plan, option, str, endch) ! 70: PLAN *plan; ! 71: char *option, *str, *endch; ! 72: { ! 73: long value; ! 74: char *endchar; /* pointer to character ending conversion */ ! 75: ! 76: /* determine comparison from leading + or - */ ! 77: switch(*str) { ! 78: case '+': ! 79: ++str; ! 80: plan->flags = FIND_GREATER; ! 81: break; ! 82: case '-': ! 83: ++str; ! 84: plan->flags = FIND_LESSTHAN; ! 85: break; ! 86: default: ! 87: plan->flags = FIND_EQUAL; ! 88: break; ! 89: } ! 90: ! 91: /* ! 92: * convert the string with strtol(). Note, if strtol() returns zero ! 93: * and endchar points to the beginning of the string we know we have ! 94: * a syntax error. ! 95: */ ! 96: value = strtol(str, &endchar, 10); ! 97: if (!value && endchar == str || ! 98: endchar[0] && (!endch || endchar[0] != *endch)) ! 99: bad_arg(option, "illegal numeric value"); ! 100: if (endch) ! 101: *endch = endchar[0]; ! 102: return(value); ! 103: } ! 104: ! 105: /* ! 106: * -atime n functions -- ! 107: * ! 108: * True if the difference between the file access time and the ! 109: * current time is n 24 hour periods. ! 110: * ! 111: */ ! 112: f_atime(plan, entry) ! 113: PLAN *plan; ! 114: FTSENT *entry; ! 115: { ! 116: extern time_t now; ! 117: ! 118: COMPARE((now - entry->fts_statb.st_atime + ! 119: SECSPERDAY - 1) / SECSPERDAY, plan->t_data); ! 120: } ! 121: ! 122: PLAN * ! 123: c_atime(arg) ! 124: char *arg; ! 125: { ! 126: PLAN *new; ! 127: ! 128: ftsoptions &= ~FTS_NOSTAT; ! 129: ! 130: NEW(T_ATIME, f_atime); ! 131: new->t_data = find_parsenum(new, "-atime", arg, (char *)NULL); ! 132: return(new); ! 133: } ! 134: /* ! 135: * -ctime n functions -- ! 136: * ! 137: * True if the difference between the last change of file ! 138: * status information and the current time is n 24 hour periods. ! 139: */ ! 140: f_ctime(plan, entry) ! 141: PLAN *plan; ! 142: FTSENT *entry; ! 143: { ! 144: extern time_t now; ! 145: ! 146: COMPARE((now - entry->fts_statb.st_ctime + ! 147: SECSPERDAY - 1) / SECSPERDAY, plan->t_data); ! 148: } ! 149: ! 150: PLAN * ! 151: c_ctime(arg) ! 152: char *arg; ! 153: { ! 154: PLAN *new; ! 155: ! 156: ftsoptions &= ~FTS_NOSTAT; ! 157: ! 158: NEW(T_CTIME, f_ctime); ! 159: new->t_data = find_parsenum(new, "-ctime", arg, (char *)NULL); ! 160: return(new); ! 161: } ! 162: ! 163: /* ! 164: * -depth functions -- ! 165: * ! 166: * Always true, causes descent of the directory hierarchy to be done ! 167: * so that all entries in a directory are acted on before the directory ! 168: * itself. ! 169: */ ! 170: /* ARGSUSED */ ! 171: f_always_true(plan, entry) ! 172: PLAN *plan; ! 173: FTSENT *entry; ! 174: { ! 175: return(1); ! 176: } ! 177: ! 178: PLAN * ! 179: c_depth() ! 180: { ! 181: extern int depth; ! 182: PLAN *new; ! 183: ! 184: depth = 1; ! 185: ! 186: NEW(T_DEPTH, f_always_true); ! 187: return(new); ! 188: } ! 189: ! 190: /* ! 191: * [-exec | -ok] utility [arg ... ] ; functions -- ! 192: * ! 193: * True if the executed utility returns a zero value as exit status. ! 194: * The end of the primary expression is delimited by a semicolon. If ! 195: * "{}" occurs anywhere, it gets replaced by the current pathname. ! 196: * The current directory for the execution of utility is the same as ! 197: * the current directory when the find utility was started. ! 198: * ! 199: * The primary -ok is different in that it requests affirmation of the ! 200: * user before executing the utility. ! 201: */ ! 202: f_exec(plan, entry) ! 203: register PLAN *plan; ! 204: FTSENT *entry; ! 205: { ! 206: register int cnt; ! 207: char *find_subst(); ! 208: union wait pstat; ! 209: pid_t pid, waitpid(); ! 210: ! 211: for (cnt = 0; plan->e_argv[cnt]; ++cnt) ! 212: if (plan->e_len[cnt]) ! 213: find_subst(plan->e_orig[cnt], &plan->e_argv[cnt], ! 214: entry->fts_path, plan->e_len[cnt]); ! 215: ! 216: if (plan->flags && !find_queryuser(plan->e_argv)) ! 217: return(0); ! 218: ! 219: switch(pid = vfork()) { ! 220: case -1: ! 221: (void)fprintf(stderr, "find: fork: %s.\n", strerror(errno)); ! 222: exit(1); ! 223: /* NOTREACHED */ ! 224: case 0: ! 225: execvp(plan->e_argv[0], plan->e_argv); ! 226: (void)fprintf(stderr, ! 227: "find: %s: %s.\n", plan->e_argv[0], strerror(errno)); ! 228: exit(1); ! 229: /* NOTREACHED */ ! 230: } ! 231: pid = waitpid(pid, &pstat, 0); ! 232: return(pid != -1 && !pstat.w_status); ! 233: } ! 234: ! 235: /* ! 236: * c_exec -- ! 237: * build three parallel arrays, one with pointers to the strings passed ! 238: * on the command line, one with (possibly duplicated) pointers to the ! 239: * argv array, and one with integer values that are lengths of the ! 240: * strings, but also flags meaning that the string has to be massaged. ! 241: */ ! 242: PLAN * ! 243: c_exec(argvp, isok) ! 244: char ***argvp; ! 245: int isok; ! 246: { ! 247: PLAN *new; /* node returned */ ! 248: register int cnt; ! 249: register char **argv, **ap, *p; ! 250: ! 251: ftsoptions |= FTS_NOCHDIR; ! 252: output_specified = 1; ! 253: ! 254: NEW(T_EXEC, f_exec); ! 255: new->flags = isok; ! 256: ! 257: for (ap = argv = *argvp;; ++ap) { ! 258: if (!*ap) ! 259: bad_arg(isok ? "-ok" : "-exec", "no terminating \";\""); ! 260: if (**ap == ';') ! 261: break; ! 262: } ! 263: ! 264: cnt = ap - *argvp + 1; ! 265: new->e_argv = (char **)emalloc((u_int)cnt * sizeof(char *)); ! 266: new->e_orig = (char **)emalloc((u_int)cnt * sizeof(char *)); ! 267: new->e_len = (int *)emalloc((u_int)cnt * sizeof(u_char)); ! 268: ! 269: for (argv = *argvp, cnt = 0; argv < ap; ++argv, ++cnt) { ! 270: new->e_orig[cnt] = *argv; ! 271: for (p = *argv; *p; ++p) ! 272: if (p[0] == '{' && p[1] == '}') { ! 273: new->e_argv[cnt] = emalloc((u_int)1024); ! 274: new->e_len[cnt] = 1024; ! 275: break; ! 276: } ! 277: if (!*p) { ! 278: new->e_argv[cnt] = *argv; ! 279: new->e_len[cnt] = 0; ! 280: } ! 281: } ! 282: new->e_argv[cnt] = new->e_orig[cnt] = NULL; ! 283: ! 284: *argvp = argv + 1; ! 285: return(new); ! 286: } ! 287: ! 288: /* ! 289: * -follow functions -- ! 290: * ! 291: * Always true, causes symbolic links to be followed on a global ! 292: * basis. ! 293: */ ! 294: PLAN * ! 295: c_follow() ! 296: { ! 297: PLAN *new; ! 298: ! 299: ftsoptions &= ~FTS_PHYSICAL; ! 300: ftsoptions |= FTS_LOGICAL; ! 301: ! 302: NEW(T_FOLLOW, f_always_true); ! 303: return(new); ! 304: } ! 305: ! 306: /* ! 307: * -fstype functions -- ! 308: * ! 309: * True if the file is of a certain type. ! 310: */ ! 311: f_fstype(plan, entry) ! 312: PLAN *plan; ! 313: FTSENT *entry; ! 314: { ! 315: static dev_t curdev; /* need a guaranteed illegal dev value */ ! 316: static int first = 1; ! 317: struct statfs sb; ! 318: static short val; ! 319: ! 320: /* only check when we cross mount point */ ! 321: if (first || curdev != entry->fts_statb.st_dev) { ! 322: curdev = entry->fts_statb.st_dev; ! 323: if (statfs(entry->fts_accpath, &sb)) { ! 324: (void)fprintf(stderr, "find: %s: %s.\n", ! 325: entry->fts_accpath, strerror(errno)); ! 326: exit(1); ! 327: } ! 328: first = 0; ! 329: val = plan->flags == MOUNT_NONE ? sb.f_flags : sb.f_type; ! 330: } ! 331: return(plan->flags == MOUNT_NONE ? ! 332: val & MNT_LOCAL : val == plan->flags); ! 333: } ! 334: ! 335: PLAN * ! 336: c_fstype(arg) ! 337: char *arg; ! 338: { ! 339: register PLAN *new; ! 340: ! 341: ftsoptions &= ~FTS_NOSTAT; ! 342: ! 343: NEW(T_FSTYPE, f_fstype); ! 344: switch(*arg) { ! 345: case 'l': ! 346: if (!strcmp(arg, "local")) { ! 347: new->flags = MOUNT_NONE; ! 348: return(new); ! 349: } ! 350: break; ! 351: case 'm': ! 352: if (!strcmp(arg, "mfs")) { ! 353: new->flags = MOUNT_MFS; ! 354: return(new); ! 355: } ! 356: break; ! 357: case 'n': ! 358: if (!strcmp(arg, "nfs")) { ! 359: new->flags = MOUNT_NFS; ! 360: return(new); ! 361: } ! 362: break; ! 363: case 'p': ! 364: if (!strcmp(arg, "pc")) { ! 365: new->flags = MOUNT_PC; ! 366: return(new); ! 367: } ! 368: break; ! 369: case 'u': ! 370: if (!strcmp(arg, "ufs")) { ! 371: new->flags = MOUNT_UFS; ! 372: return(new); ! 373: } ! 374: break; ! 375: } ! 376: (void)fprintf(stderr, "find: unknown file type %s.\n", arg); ! 377: exit(1); ! 378: /* NOTREACHED */ ! 379: } ! 380: ! 381: /* ! 382: * -group gname functions -- ! 383: * ! 384: * True if the file belongs to the group gname. If gname is numeric and ! 385: * an equivalent of the getgrnam() function does not return a valid group ! 386: * name, gname is taken as a group ID. ! 387: */ ! 388: f_group(plan, entry) ! 389: PLAN *plan; ! 390: FTSENT *entry; ! 391: { ! 392: return(entry->fts_statb.st_gid == plan->g_data); ! 393: } ! 394: ! 395: PLAN * ! 396: c_group(gname) ! 397: char *gname; ! 398: { ! 399: PLAN *new; ! 400: struct group *g; ! 401: gid_t gid; ! 402: ! 403: ftsoptions &= ~FTS_NOSTAT; ! 404: ! 405: g = getgrnam(gname); ! 406: if (g == NULL) { ! 407: gid = atoi(gname); ! 408: if (gid == 0 && gname[0] != '0') ! 409: bad_arg("-group", "no such group"); ! 410: } else ! 411: gid = g->gr_gid; ! 412: ! 413: NEW(T_GROUP, f_group); ! 414: new->g_data = gid; ! 415: return(new); ! 416: } ! 417: ! 418: /* ! 419: * -inum n functions -- ! 420: * ! 421: * True if the file has inode # n. ! 422: */ ! 423: f_inum(plan, entry) ! 424: PLAN *plan; ! 425: FTSENT *entry; ! 426: { ! 427: COMPARE(entry->fts_statb.st_ino, plan->i_data); ! 428: } ! 429: ! 430: PLAN * ! 431: c_inum(arg) ! 432: char *arg; ! 433: { ! 434: PLAN *new; ! 435: ! 436: ftsoptions &= ~FTS_NOSTAT; ! 437: ! 438: NEW(T_INUM, f_inum); ! 439: new->i_data = find_parsenum(new, "-inum", arg, (char *)NULL); ! 440: return(new); ! 441: } ! 442: ! 443: /* ! 444: * -links n functions -- ! 445: * ! 446: * True if the file has n links. ! 447: */ ! 448: f_links(plan, entry) ! 449: PLAN *plan; ! 450: FTSENT *entry; ! 451: { ! 452: COMPARE(entry->fts_statb.st_nlink, plan->l_data); ! 453: } ! 454: ! 455: PLAN * ! 456: c_links(arg) ! 457: char *arg; ! 458: { ! 459: PLAN *new; ! 460: ! 461: ftsoptions &= ~FTS_NOSTAT; ! 462: ! 463: NEW(T_LINKS, f_links); ! 464: new->l_data = find_parsenum(new, "-links", arg, (char *)NULL); ! 465: return(new); ! 466: } ! 467: ! 468: /* ! 469: * -ls functions -- ! 470: * ! 471: * Always true - prints the current entry to stdout in "ls" format. ! 472: */ ! 473: /* ARGSUSED */ ! 474: f_ls(plan, entry) ! 475: PLAN *plan; ! 476: FTSENT *entry; ! 477: { ! 478: printlong(entry->fts_path, entry->fts_accpath, &entry->fts_statb); ! 479: return(1); ! 480: } ! 481: ! 482: PLAN * ! 483: c_ls() ! 484: { ! 485: PLAN *new; ! 486: ! 487: ftsoptions &= ~FTS_NOSTAT; ! 488: output_specified = 1; ! 489: ! 490: NEW(T_LS, f_ls); ! 491: return(new); ! 492: } ! 493: ! 494: /* ! 495: * -name functions -- ! 496: * ! 497: * True if the basename of the filename being examined ! 498: * matches pattern using Pattern Matching Notation S3.14 ! 499: */ ! 500: f_name(plan, entry) ! 501: PLAN *plan; ! 502: FTSENT *entry; ! 503: { ! 504: return(fnmatch(plan->c_data, entry->fts_name, FNM_QUOTE)); ! 505: } ! 506: ! 507: PLAN * ! 508: c_name(pattern) ! 509: char *pattern; ! 510: { ! 511: PLAN *new; ! 512: ! 513: NEW(T_NAME, f_name); ! 514: new->c_data = pattern; ! 515: return(new); ! 516: } ! 517: ! 518: /* ! 519: * -newer file functions -- ! 520: * ! 521: * True if the current file has been modified more recently ! 522: * then the modification time of the file named by the pathname ! 523: * file. ! 524: */ ! 525: f_newer(plan, entry) ! 526: PLAN *plan; ! 527: FTSENT *entry; ! 528: { ! 529: return(entry->fts_statb.st_mtime > plan->t_data); ! 530: } ! 531: ! 532: PLAN * ! 533: c_newer(filename) ! 534: char *filename; ! 535: { ! 536: PLAN *new; ! 537: struct stat sb; ! 538: ! 539: ftsoptions &= ~FTS_NOSTAT; ! 540: ! 541: if (stat(filename, &sb)) { ! 542: (void)fprintf(stderr, "find: %s: %s.\n", ! 543: filename, strerror(errno)); ! 544: exit(1); ! 545: } ! 546: NEW(T_NEWER, f_newer); ! 547: new->t_data = sb.st_mtime; ! 548: return(new); ! 549: } ! 550: ! 551: /* ! 552: * -nogroup functions -- ! 553: * ! 554: * True if file belongs to a user ID for which the equivalent ! 555: * of the getgrnam() 9.2.1 [POSIX.1] function returns NULL. ! 556: */ ! 557: /* ARGSUSED */ ! 558: f_nogroup(plan, entry) ! 559: PLAN *plan; ! 560: FTSENT *entry; ! 561: { ! 562: return(group_from_gid(entry->fts_statb.st_gid, 1)); ! 563: } ! 564: ! 565: PLAN * ! 566: c_nogroup() ! 567: { ! 568: PLAN *new; ! 569: ! 570: ftsoptions &= ~FTS_NOSTAT; ! 571: ! 572: NEW(T_NOGROUP, f_nogroup); ! 573: return(new); ! 574: } ! 575: ! 576: /* ! 577: * -nouser functions -- ! 578: * ! 579: * True if file belongs to a user ID for which the equivalent ! 580: * of the getpwuid() 9.2.2 [POSIX.1] function returns NULL. ! 581: */ ! 582: /* ARGSUSED */ ! 583: f_nouser(plan, entry) ! 584: PLAN *plan; ! 585: FTSENT *entry; ! 586: { ! 587: return(user_from_uid(entry->fts_statb.st_uid, 1)); ! 588: } ! 589: ! 590: PLAN * ! 591: c_nouser() ! 592: { ! 593: PLAN *new; ! 594: ! 595: ftsoptions &= ~FTS_NOSTAT; ! 596: ! 597: NEW(T_NOUSER, f_nouser); ! 598: return(new); ! 599: } ! 600: ! 601: /* ! 602: * -perm functions -- ! 603: * ! 604: * The mode argument is used to represent file mode bits. If it starts ! 605: * with a leading digit, it's treated as an octal mode, otherwise as a ! 606: * symbolic mode. ! 607: */ ! 608: f_perm(plan, entry) ! 609: PLAN *plan; ! 610: FTSENT *entry; ! 611: { ! 612: mode_t mode; ! 613: ! 614: mode = entry->fts_statb.st_mode & ! 615: (S_ISUID|S_ISGID|S_ISTXT|S_IRWXU|S_IRWXG|S_IRWXO); ! 616: if (plan->flags) ! 617: return((plan->m_data | mode) == mode); ! 618: else ! 619: return(mode == plan->m_data); ! 620: /* NOTREACHED */ ! 621: } ! 622: ! 623: PLAN * ! 624: c_perm(perm) ! 625: char *perm; ! 626: { ! 627: PLAN *new; ! 628: mode_t *set, *setmode(); ! 629: ! 630: ftsoptions &= ~FTS_NOSTAT; ! 631: ! 632: NEW(T_PERM, f_perm); ! 633: ! 634: if (*perm == '-') { ! 635: new->flags = 1; ! 636: ++perm; ! 637: } ! 638: ! 639: if ((set = setmode(perm)) == NULL) ! 640: bad_arg("-perm", "illegal mode string"); ! 641: ! 642: new->m_data = getmode(set, 0); ! 643: return(new); ! 644: } ! 645: ! 646: /* ! 647: * -print functions -- ! 648: * ! 649: * Always true, causes the current pathame to be written to ! 650: * standard output. ! 651: */ ! 652: /* ARGSUSED */ ! 653: f_print(plan, entry) ! 654: PLAN *plan; ! 655: FTSENT *entry; ! 656: { ! 657: (void)printf("%s\n", entry->fts_path); ! 658: return(1); ! 659: } ! 660: ! 661: PLAN * ! 662: c_print() ! 663: { ! 664: PLAN *new; ! 665: ! 666: output_specified = 1; ! 667: ! 668: NEW(T_PRINT, f_print); ! 669: return(new); ! 670: } ! 671: ! 672: /* ! 673: * -prune functions -- ! 674: * ! 675: * Prune a portion of the hierarchy. ! 676: */ ! 677: /* ARGSUSED */ ! 678: f_prune(plan, entry) ! 679: PLAN *plan; ! 680: FTSENT *entry; ! 681: { ! 682: extern FTS *tree; ! 683: ! 684: if (ftsset(tree, entry, FTS_SKIP)) { ! 685: (void)fprintf(stderr, ! 686: "find: %s: %s.\n", entry->fts_path, strerror(errno)); ! 687: exit(1); ! 688: } ! 689: return(1); ! 690: } ! 691: ! 692: PLAN * ! 693: c_prune() ! 694: { ! 695: PLAN *new; ! 696: ! 697: NEW(T_PRUNE, f_prune); ! 698: return(new); ! 699: } ! 700: ! 701: /* ! 702: * -size n[c] functions -- ! 703: * ! 704: * True if the file size in bytes, divided by an implementation defined ! 705: * value and rounded up to the next integer, is n. If n is followed by ! 706: * a c, the size is in bytes. ! 707: */ ! 708: #define FIND_SIZE 512 ! 709: static int divsize = 1; ! 710: ! 711: f_size(plan, entry) ! 712: PLAN *plan; ! 713: FTSENT *entry; ! 714: { ! 715: off_t size; ! 716: ! 717: size = divsize ? (entry->fts_statb.st_size + FIND_SIZE - 1) / ! 718: FIND_SIZE : entry->fts_statb.st_size; ! 719: COMPARE(size, plan->o_data); ! 720: } ! 721: ! 722: PLAN * ! 723: c_size(arg) ! 724: char *arg; ! 725: { ! 726: PLAN *new; ! 727: char endch; ! 728: ! 729: ftsoptions &= ~FTS_NOSTAT; ! 730: ! 731: NEW(T_SIZE, f_size); ! 732: new->o_data = find_parsenum(new, "-size", arg, &endch); ! 733: if (endch == 'c') ! 734: divsize = 0; ! 735: return(new); ! 736: } ! 737: ! 738: /* ! 739: * -type c functions -- ! 740: * ! 741: * True if the type of the file is c, where c is b, c, d, p, or f for ! 742: * block special file, character special file, directory, FIFO, or ! 743: * regular file, respectively. ! 744: */ ! 745: f_type(plan, entry) ! 746: PLAN *plan; ! 747: FTSENT *entry; ! 748: { ! 749: return((entry->fts_statb.st_mode & S_IFMT) == plan->m_data); ! 750: } ! 751: ! 752: PLAN * ! 753: c_type(typestring) ! 754: char *typestring; ! 755: { ! 756: PLAN *new; ! 757: mode_t mask; ! 758: ! 759: ftsoptions &= ~FTS_NOSTAT; ! 760: ! 761: switch (typestring[0]) { ! 762: case 'b': ! 763: mask = S_IFBLK; ! 764: break; ! 765: case 'c': ! 766: mask = S_IFCHR; ! 767: break; ! 768: case 'd': ! 769: mask = S_IFDIR; ! 770: break; ! 771: case 'f': ! 772: mask = S_IFREG; ! 773: break; ! 774: case 'l': ! 775: mask = S_IFLNK; ! 776: break; ! 777: case 'p': ! 778: mask = S_IFIFO; ! 779: break; ! 780: case 's': ! 781: mask = S_IFSOCK; ! 782: break; ! 783: default: ! 784: bad_arg("-type", "unknown type"); ! 785: } ! 786: ! 787: NEW(T_TYPE, f_type); ! 788: new->m_data = mask; ! 789: return(new); ! 790: } ! 791: ! 792: /* ! 793: * -user uname functions -- ! 794: * ! 795: * True if the file belongs to the user uname. If uname is numeric and ! 796: * an equivalent of the getpwnam() S9.2.2 [POSIX.1] function does not ! 797: * return a valid user name, uname is taken as a user ID. ! 798: */ ! 799: f_user(plan, entry) ! 800: PLAN *plan; ! 801: FTSENT *entry; ! 802: { ! 803: return(entry->fts_statb.st_uid == plan->u_data); ! 804: } ! 805: ! 806: PLAN * ! 807: c_user(username) ! 808: char *username; ! 809: { ! 810: PLAN *new; ! 811: struct passwd *p; ! 812: uid_t uid; ! 813: ! 814: ftsoptions &= ~FTS_NOSTAT; ! 815: ! 816: p = getpwnam(username); ! 817: if (p == NULL) { ! 818: uid = atoi(username); ! 819: if (uid == 0 && username[0] != '0') ! 820: bad_arg("-user", "no such user"); ! 821: } else ! 822: uid = p->pw_uid; ! 823: ! 824: NEW(T_USER, f_user); ! 825: new->u_data = uid; ! 826: return(new); ! 827: } ! 828: ! 829: /* ! 830: * -xdev functions -- ! 831: * ! 832: * Always true, causes find not to decend past directories that have a ! 833: * different device ID (st_dev, see stat() S5.6.2 [POSIX.1]) ! 834: */ ! 835: PLAN * ! 836: c_xdev() ! 837: { ! 838: PLAN *new; ! 839: ! 840: ftsoptions &= ~FTS_NOSTAT; ! 841: ftsoptions |= FTS_XDEV; ! 842: ! 843: NEW(T_XDEV, f_always_true); ! 844: return(new); ! 845: } ! 846: ! 847: /* ! 848: * ( expression ) functions -- ! 849: * ! 850: * True if expression is true. ! 851: */ ! 852: f_expr(plan, entry) ! 853: PLAN *plan; ! 854: FTSENT *entry; ! 855: { ! 856: register PLAN *p; ! 857: register int state; ! 858: ! 859: for (p = plan->p_data[0]; ! 860: p && (state = (p->eval)(p, entry)); p = p->next); ! 861: return(state); ! 862: } ! 863: ! 864: /* ! 865: * T_OPENPAREN and T_CLOSEPAREN nodes are temporary place markers. They are ! 866: * eliminated during phase 2 of find_formplan() --- the '(' node is converted ! 867: * to a T_EXPR node containing the expression and the ')' node is discarded. ! 868: */ ! 869: PLAN * ! 870: c_openparen() ! 871: { ! 872: PLAN *new; ! 873: ! 874: NEW(T_OPENPAREN, (int (*)())-1); ! 875: return(new); ! 876: } ! 877: ! 878: PLAN * ! 879: c_closeparen() ! 880: { ! 881: PLAN *new; ! 882: ! 883: NEW(T_CLOSEPAREN, (int (*)())-1); ! 884: return(new); ! 885: } ! 886: ! 887: /* ! 888: * -mtime n functions -- ! 889: * ! 890: * True if the difference between the file modification time and the ! 891: * current time is n 24 hour periods. ! 892: */ ! 893: f_mtime(plan, entry) ! 894: PLAN *plan; ! 895: FTSENT *entry; ! 896: { ! 897: extern time_t now; ! 898: ! 899: COMPARE((now - entry->fts_statb.st_mtime + SECSPERDAY - 1) / ! 900: SECSPERDAY, plan->t_data); ! 901: } ! 902: ! 903: PLAN * ! 904: c_mtime(arg) ! 905: char *arg; ! 906: { ! 907: PLAN *new; ! 908: ! 909: ftsoptions &= ~FTS_NOSTAT; ! 910: ! 911: NEW(T_MTIME, f_mtime); ! 912: new->t_data = find_parsenum(new, "-mtime", arg, (char *)NULL); ! 913: return(new); ! 914: } ! 915: ! 916: /* ! 917: * ! expression functions -- ! 918: * ! 919: * Negation of a primary; the unary NOT operator. ! 920: */ ! 921: f_not(plan, entry) ! 922: PLAN *plan; ! 923: FTSENT *entry; ! 924: { ! 925: register PLAN *p; ! 926: register int state; ! 927: ! 928: for (p = plan->p_data[0]; ! 929: p && (state = (p->eval)(p, entry)); p = p->next); ! 930: return(!state); ! 931: } ! 932: ! 933: PLAN * ! 934: c_not() ! 935: { ! 936: PLAN *new; ! 937: ! 938: NEW(T_NOT, f_not); ! 939: return(new); ! 940: } ! 941: ! 942: /* ! 943: * expression -o expression functions -- ! 944: * ! 945: * Alternation of primaries; the OR operator. The second expression is ! 946: * not evaluated if the first expression is true. ! 947: */ ! 948: f_or(plan, entry) ! 949: PLAN *plan; ! 950: FTSENT *entry; ! 951: { ! 952: register PLAN *p; ! 953: register int state; ! 954: ! 955: for (p = plan->p_data[0]; ! 956: p && (state = (p->eval)(p, entry)); p = p->next); ! 957: ! 958: if (state) ! 959: return(1); ! 960: ! 961: for (p = plan->p_data[1]; ! 962: p && (state = (p->eval)(p, entry)); p = p->next); ! 963: return(state); ! 964: } ! 965: ! 966: PLAN * ! 967: c_or() ! 968: { ! 969: PLAN *new; ! 970: ! 971: NEW(T_OR, f_or); ! 972: return(new); ! 973: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.