1/*-
2 * Copyright (c) 1990, 1993
3 * The Regents of the University of California. 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, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. All advertising materials mentioning features or use of this software
17 * must display the following acknowledgement:
18 * This product includes software developed by the University of
19 * California, Berkeley and its contributors.
20 * 4. Neither the name of the University nor the names of its contributors
21 * may be used to endorse or promote products derived from this software
22 * without specific prior written permission.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 * SUCH DAMAGE.
35 */
36
37#ifndef lint
38static char sccsid[] = "@(#)function.c 8.10 (Berkeley) 5/4/95";
39#endif /* not lint */
40
41#include <sys/param.h>
42#include <sys/ucred.h>
43#include <sys/stat.h>
44#include <sys/wait.h>
45#include <sys/mount.h>
46
47#include <err.h>
48#include <errno.h>
49#include <fnmatch.h>
50#include <fts.h>
51#include <grp.h>
52#include <pwd.h>
53#include <stdio.h>
54#include <stdlib.h>
55#include <string.h>
56#include <unistd.h>
57
58#include "find.h"
59
60#define COMPARE(a, b) { \
61 switch (plan->flags) { \
62 case F_EQUAL: \
63 return (a == b); \
64 case F_LESSTHAN: \
65 return (a < b); \
66 case F_GREATER: \
67 return (a > b); \
68 default: \
69 abort(); \
70 } \
71}
72
73static PLAN *palloc __P((enum ntype, int (*) __P((PLAN *, FTSENT *))));
74
75/*
76 * find_parsenum --
77 * Parse a string of the form [+-]# and return the value.
78 */
79static long long
80find_parsenum(plan, option, vp, endch)
81 PLAN *plan;
82 char *option, *vp, *endch;
83{
84 long long value;
85 char *endchar, *str; /* Pointer to character ending conversion. */
86
87 /* Determine comparison from leading + or -. */
88 str = vp;
89 switch (*str) {
90 case '+':
91 ++str;
92 plan->flags = F_GREATER;
93 break;
94 case '-':
95 ++str;
96 plan->flags = F_LESSTHAN;
97 break;
98 default:
99 plan->flags = F_EQUAL;
100 break;
101 }
102
103 /*
104 * Convert the string with strtoq(). Note, if strtoq() returns zero
105 * and endchar points to the beginning of the string we know we have
106 * a syntax error.
107 */
108 value = strtoq(str, &endchar, 10);
109 if (value == 0 && endchar == str)
110 errx(1, "%s: %s: illegal numeric value", option, vp);
111 if (endchar[0] && (endch == NULL || endchar[0] != *endch))
112 errx(1, "%s: %s: illegal trailing character", option, vp);
113 if (endch)
114 *endch = endchar[0];
115 return (value);
116}
117
118/*
119 * The value of n for the inode times (atime, ctime, and mtime) is a range,
120 * i.e. n matches from (n - 1) to n 24 hour periods. This interacts with
121 * -n, such that "-mtime -1" would be less than 0 days, which isn't what the
122 * user wanted. Correct so that -1 is "less than 1".
123 */
124#define TIME_CORRECT(p, ttype) \
125 if ((p)->type == ttype && (p)->flags == F_LESSTHAN) \
126 ++((p)->t_data);
127
128/*
129 * -amin n functions --
130 *
131 * True if the difference between the file access time and the
132 * current time is n min periods.
133 */
134int
135f_amin(plan, entry)
136 PLAN *plan;
137 FTSENT *entry;
138{
139 extern time_t now;
140
141 COMPARE((now - entry->fts_statp->st_atime +
142 60 - 1) / 60, plan->t_data);
143}
144
145PLAN *
146c_amin(arg)
147 char *arg;
148{
149 PLAN *new;
150
151 ftsoptions &= ~FTS_NOSTAT;
152
153 new = palloc(N_AMIN, f_amin);
154 new->t_data = find_parsenum(new, "-amin", arg, NULL);
155 TIME_CORRECT(new, N_AMIN);
156 return (new);
157}
158
159
160/*
161 * -atime n functions --
162 *
163 * True if the difference between the file access time and the
164 * current time is n 24 hour periods.
165 */
166int
167f_atime(plan, entry)
168 PLAN *plan;
169 FTSENT *entry;
170{
171 extern time_t now;
172
173 COMPARE((now - entry->fts_statp->st_atime +
174 86400 - 1) / 86400, plan->t_data);
175}
176
177PLAN *
178c_atime(arg)
179 char *arg;
180{
181 PLAN *new;
182
183 ftsoptions &= ~FTS_NOSTAT;
184
185 new = palloc(N_ATIME, f_atime);
186 new->t_data = find_parsenum(new, "-atime", arg, NULL);
187 TIME_CORRECT(new, N_ATIME);
188 return (new);
189}
190
191
192/*
193 * -cmin n functions --
194 *
195 * True if the difference between the last change of file
196 * status information and the current time is n min periods.
197 */
198int
199f_cmin(plan, entry)
200 PLAN *plan;
201 FTSENT *entry;
202{
203 extern time_t now;
204
205 COMPARE((now - entry->fts_statp->st_ctime +
206 60 - 1) / 60, plan->t_data);
207}
208
209PLAN *
210c_cmin(arg)
211 char *arg;
212{
213 PLAN *new;
214
215 ftsoptions &= ~FTS_NOSTAT;
216
217 new = palloc(N_CMIN, f_cmin);
218 new->t_data = find_parsenum(new, "-cmin", arg, NULL);
219 TIME_CORRECT(new, N_CMIN);
220 return (new);
221}
222
223/*
224 * -ctime n functions --
225 *
226 * True if the difference between the last change of file
227 * status information and the current time is n 24 hour periods.
228 */
229int
230f_ctime(plan, entry)
231 PLAN *plan;
232 FTSENT *entry;
233{
234 extern time_t now;
235
236 COMPARE((now - entry->fts_statp->st_ctime +
237 86400 - 1) / 86400, plan->t_data);
238}
239
240PLAN *
241c_ctime(arg)
242 char *arg;
243{
244 PLAN *new;
245
246 ftsoptions &= ~FTS_NOSTAT;
247
248 new = palloc(N_CTIME, f_ctime);
249 new->t_data = find_parsenum(new, "-ctime", arg, NULL);
250 TIME_CORRECT(new, N_CTIME);
251 return (new);
252}
253
254
255/*
256 * -depth functions --
257 *
258 * Always true, causes descent of the directory hierarchy to be done
259 * so that all entries in a directory are acted on before the directory
260 * itself.
261 */
262int
263f_always_true(plan, entry)
264 PLAN *plan;
265 FTSENT *entry;
266{
267 return (1);
268}
269
270PLAN *
271c_depth()
272{
273 isdepth = 1;
274
275 return (palloc(N_DEPTH, f_always_true));
276}
277
278/*
279 * [-exec | -ok] utility [arg ... ] ; functions --
280 *
281 * True if the executed utility returns a zero value as exit status.
282 * The end of the primary expression is delimited by a semicolon. If
283 * "{}" occurs anywhere, it gets replaced by the current pathname.
284 * The current directory for the execution of utility is the same as
285 * the current directory when the find utility was started.
286 *
287 * The primary -ok is different in that it requests affirmation of the
288 * user before executing the utility.
289 */
290int
291f_exec(plan, entry)
292 register PLAN *plan;
293 FTSENT *entry;
294{
295 extern int dotfd;
296 register int cnt;
297 pid_t pid;
298 int status;
299
300 for (cnt = 0; plan->e_argv[cnt]; ++cnt)
301 if (plan->e_len[cnt])
302 brace_subst(plan->e_orig[cnt], &plan->e_argv[cnt],
303 entry->fts_path, plan->e_len[cnt]);
304
305 if (plan->flags == F_NEEDOK && !queryuser(plan->e_argv))
306 return (0);
307
308 /* make sure find output is interspersed correctly with subprocesses */
309 fflush(stdout);
310
| 1/*-
2 * Copyright (c) 1990, 1993
3 * The Regents of the University of California. 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, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. All advertising materials mentioning features or use of this software
17 * must display the following acknowledgement:
18 * This product includes software developed by the University of
19 * California, Berkeley and its contributors.
20 * 4. Neither the name of the University nor the names of its contributors
21 * may be used to endorse or promote products derived from this software
22 * without specific prior written permission.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 * SUCH DAMAGE.
35 */
36
37#ifndef lint
38static char sccsid[] = "@(#)function.c 8.10 (Berkeley) 5/4/95";
39#endif /* not lint */
40
41#include <sys/param.h>
42#include <sys/ucred.h>
43#include <sys/stat.h>
44#include <sys/wait.h>
45#include <sys/mount.h>
46
47#include <err.h>
48#include <errno.h>
49#include <fnmatch.h>
50#include <fts.h>
51#include <grp.h>
52#include <pwd.h>
53#include <stdio.h>
54#include <stdlib.h>
55#include <string.h>
56#include <unistd.h>
57
58#include "find.h"
59
60#define COMPARE(a, b) { \
61 switch (plan->flags) { \
62 case F_EQUAL: \
63 return (a == b); \
64 case F_LESSTHAN: \
65 return (a < b); \
66 case F_GREATER: \
67 return (a > b); \
68 default: \
69 abort(); \
70 } \
71}
72
73static PLAN *palloc __P((enum ntype, int (*) __P((PLAN *, FTSENT *))));
74
75/*
76 * find_parsenum --
77 * Parse a string of the form [+-]# and return the value.
78 */
79static long long
80find_parsenum(plan, option, vp, endch)
81 PLAN *plan;
82 char *option, *vp, *endch;
83{
84 long long value;
85 char *endchar, *str; /* Pointer to character ending conversion. */
86
87 /* Determine comparison from leading + or -. */
88 str = vp;
89 switch (*str) {
90 case '+':
91 ++str;
92 plan->flags = F_GREATER;
93 break;
94 case '-':
95 ++str;
96 plan->flags = F_LESSTHAN;
97 break;
98 default:
99 plan->flags = F_EQUAL;
100 break;
101 }
102
103 /*
104 * Convert the string with strtoq(). Note, if strtoq() returns zero
105 * and endchar points to the beginning of the string we know we have
106 * a syntax error.
107 */
108 value = strtoq(str, &endchar, 10);
109 if (value == 0 && endchar == str)
110 errx(1, "%s: %s: illegal numeric value", option, vp);
111 if (endchar[0] && (endch == NULL || endchar[0] != *endch))
112 errx(1, "%s: %s: illegal trailing character", option, vp);
113 if (endch)
114 *endch = endchar[0];
115 return (value);
116}
117
118/*
119 * The value of n for the inode times (atime, ctime, and mtime) is a range,
120 * i.e. n matches from (n - 1) to n 24 hour periods. This interacts with
121 * -n, such that "-mtime -1" would be less than 0 days, which isn't what the
122 * user wanted. Correct so that -1 is "less than 1".
123 */
124#define TIME_CORRECT(p, ttype) \
125 if ((p)->type == ttype && (p)->flags == F_LESSTHAN) \
126 ++((p)->t_data);
127
128/*
129 * -amin n functions --
130 *
131 * True if the difference between the file access time and the
132 * current time is n min periods.
133 */
134int
135f_amin(plan, entry)
136 PLAN *plan;
137 FTSENT *entry;
138{
139 extern time_t now;
140
141 COMPARE((now - entry->fts_statp->st_atime +
142 60 - 1) / 60, plan->t_data);
143}
144
145PLAN *
146c_amin(arg)
147 char *arg;
148{
149 PLAN *new;
150
151 ftsoptions &= ~FTS_NOSTAT;
152
153 new = palloc(N_AMIN, f_amin);
154 new->t_data = find_parsenum(new, "-amin", arg, NULL);
155 TIME_CORRECT(new, N_AMIN);
156 return (new);
157}
158
159
160/*
161 * -atime n functions --
162 *
163 * True if the difference between the file access time and the
164 * current time is n 24 hour periods.
165 */
166int
167f_atime(plan, entry)
168 PLAN *plan;
169 FTSENT *entry;
170{
171 extern time_t now;
172
173 COMPARE((now - entry->fts_statp->st_atime +
174 86400 - 1) / 86400, plan->t_data);
175}
176
177PLAN *
178c_atime(arg)
179 char *arg;
180{
181 PLAN *new;
182
183 ftsoptions &= ~FTS_NOSTAT;
184
185 new = palloc(N_ATIME, f_atime);
186 new->t_data = find_parsenum(new, "-atime", arg, NULL);
187 TIME_CORRECT(new, N_ATIME);
188 return (new);
189}
190
191
192/*
193 * -cmin n functions --
194 *
195 * True if the difference between the last change of file
196 * status information and the current time is n min periods.
197 */
198int
199f_cmin(plan, entry)
200 PLAN *plan;
201 FTSENT *entry;
202{
203 extern time_t now;
204
205 COMPARE((now - entry->fts_statp->st_ctime +
206 60 - 1) / 60, plan->t_data);
207}
208
209PLAN *
210c_cmin(arg)
211 char *arg;
212{
213 PLAN *new;
214
215 ftsoptions &= ~FTS_NOSTAT;
216
217 new = palloc(N_CMIN, f_cmin);
218 new->t_data = find_parsenum(new, "-cmin", arg, NULL);
219 TIME_CORRECT(new, N_CMIN);
220 return (new);
221}
222
223/*
224 * -ctime n functions --
225 *
226 * True if the difference between the last change of file
227 * status information and the current time is n 24 hour periods.
228 */
229int
230f_ctime(plan, entry)
231 PLAN *plan;
232 FTSENT *entry;
233{
234 extern time_t now;
235
236 COMPARE((now - entry->fts_statp->st_ctime +
237 86400 - 1) / 86400, plan->t_data);
238}
239
240PLAN *
241c_ctime(arg)
242 char *arg;
243{
244 PLAN *new;
245
246 ftsoptions &= ~FTS_NOSTAT;
247
248 new = palloc(N_CTIME, f_ctime);
249 new->t_data = find_parsenum(new, "-ctime", arg, NULL);
250 TIME_CORRECT(new, N_CTIME);
251 return (new);
252}
253
254
255/*
256 * -depth functions --
257 *
258 * Always true, causes descent of the directory hierarchy to be done
259 * so that all entries in a directory are acted on before the directory
260 * itself.
261 */
262int
263f_always_true(plan, entry)
264 PLAN *plan;
265 FTSENT *entry;
266{
267 return (1);
268}
269
270PLAN *
271c_depth()
272{
273 isdepth = 1;
274
275 return (palloc(N_DEPTH, f_always_true));
276}
277
278/*
279 * [-exec | -ok] utility [arg ... ] ; functions --
280 *
281 * True if the executed utility returns a zero value as exit status.
282 * The end of the primary expression is delimited by a semicolon. If
283 * "{}" occurs anywhere, it gets replaced by the current pathname.
284 * The current directory for the execution of utility is the same as
285 * the current directory when the find utility was started.
286 *
287 * The primary -ok is different in that it requests affirmation of the
288 * user before executing the utility.
289 */
290int
291f_exec(plan, entry)
292 register PLAN *plan;
293 FTSENT *entry;
294{
295 extern int dotfd;
296 register int cnt;
297 pid_t pid;
298 int status;
299
300 for (cnt = 0; plan->e_argv[cnt]; ++cnt)
301 if (plan->e_len[cnt])
302 brace_subst(plan->e_orig[cnt], &plan->e_argv[cnt],
303 entry->fts_path, plan->e_len[cnt]);
304
305 if (plan->flags == F_NEEDOK && !queryuser(plan->e_argv))
306 return (0);
307
308 /* make sure find output is interspersed correctly with subprocesses */
309 fflush(stdout);
310
|
418 case -1:
419 err(1, "fork");
420 /* NOTREACHED */
421 case 0:
422 execvp(plan->e_argv[0], plan->e_argv);
423 warn("%s", plan->e_argv[0]);
424 _exit(1);
425 }
426 pid = waitpid(pid, &status, 0);
427 return (pid != -1 && WIFEXITED(status) && !WEXITSTATUS(status));
428}
429
430/*
431 * c_execdir --
432 * build three parallel arrays, one with pointers to the strings passed
433 * on the command line, one with (possibly duplicated) pointers to the
434 * argv array, and one with integer values that are lengths of the
435 * strings, but also flags meaning that the string has to be massaged.
436 */
437PLAN *
438c_execdir(argvp)
439 char ***argvp;
440{
441 PLAN *new; /* node returned */
442 register int cnt;
443 register char **argv, **ap, *p;
444
445 ftsoptions &= ~FTS_NOSTAT;
446 isoutput = 1;
447
448 new = palloc(N_EXECDIR, f_execdir);
449
450 for (ap = argv = *argvp;; ++ap) {
451 if (!*ap)
452 errx(1,
453 "-execdir: no terminating \";\"");
454 if (**ap == ';')
455 break;
456 }
457
458 cnt = ap - *argvp + 1;
459 new->e_argv = (char **)emalloc((u_int)cnt * sizeof(char *));
460 new->e_orig = (char **)emalloc((u_int)cnt * sizeof(char *));
461 new->e_len = (int *)emalloc((u_int)cnt * sizeof(int));
462
463 for (argv = *argvp, cnt = 0; argv < ap; ++argv, ++cnt) {
464 new->e_orig[cnt] = *argv;
465 for (p = *argv; *p; ++p)
466 if (p[0] == '{' && p[1] == '}') {
467 new->e_argv[cnt] = emalloc((u_int)MAXPATHLEN);
468 new->e_len[cnt] = MAXPATHLEN;
469 break;
470 }
471 if (!*p) {
472 new->e_argv[cnt] = *argv;
473 new->e_len[cnt] = 0;
474 }
475 }
476 new->e_argv[cnt] = new->e_orig[cnt] = NULL;
477
478 *argvp = argv + 1;
479 return (new);
480}
481
482/*
483 * -follow functions --
484 *
485 * Always true, causes symbolic links to be followed on a global
486 * basis.
487 */
488PLAN *
489c_follow()
490{
491 ftsoptions &= ~FTS_PHYSICAL;
492 ftsoptions |= FTS_LOGICAL;
493
494 return (palloc(N_FOLLOW, f_always_true));
495}
496
497/*
498 * -fstype functions --
499 *
500 * True if the file is of a certain type.
501 */
502int
503f_fstype(plan, entry)
504 PLAN *plan;
505 FTSENT *entry;
506{
507 static dev_t curdev; /* need a guaranteed illegal dev value */
508 static int first = 1;
509 struct statfs sb;
510 static int val_type, val_flags;
511 char *p, save[2];
512
513 /* Only check when we cross mount point. */
514 if (first || curdev != entry->fts_statp->st_dev) {
515 curdev = entry->fts_statp->st_dev;
516
517 /*
518 * Statfs follows symlinks; find wants the link's file system,
519 * not where it points.
520 */
521 if (entry->fts_info == FTS_SL ||
522 entry->fts_info == FTS_SLNONE) {
523 if ((p = strrchr(entry->fts_accpath, '/')) != NULL)
524 ++p;
525 else
526 p = entry->fts_accpath;
527 save[0] = p[0];
528 p[0] = '.';
529 save[1] = p[1];
530 p[1] = '\0';
531
532 } else
533 p = NULL;
534
535 if (statfs(entry->fts_accpath, &sb))
536 err(1, "%s", entry->fts_accpath);
537
538 if (p) {
539 p[0] = save[0];
540 p[1] = save[1];
541 }
542
543 first = 0;
544
545 /*
546 * Further tests may need both of these values, so
547 * always copy both of them.
548 */
549 val_flags = sb.f_flags;
550 val_type = sb.f_type;
551 }
552 switch (plan->flags) {
553 case F_MTFLAG:
554 return (val_flags & plan->mt_data) != 0;
555 case F_MTTYPE:
556 return (val_type == plan->mt_data);
557 default:
558 abort();
559 }
560}
561
562#if !defined(__NetBSD__)
563PLAN *
564c_fstype(arg)
565 char *arg;
566{
567 register PLAN *new;
568 struct vfsconf vfc;
569
570 ftsoptions &= ~FTS_NOSTAT;
571
572 new = palloc(N_FSTYPE, f_fstype);
573
574 /*
575 * Check first for a filesystem name.
576 */
577 if (getvfsbyname(arg, &vfc) == 0) {
578 new->flags = F_MTTYPE;
579 new->mt_data = vfc.vfc_typenum;
580 return (new);
581 }
582
583 switch (*arg) {
584 case 'l':
585 if (!strcmp(arg, "local")) {
586 new->flags = F_MTFLAG;
587 new->mt_data = MNT_LOCAL;
588 return (new);
589 }
590 break;
591 case 'r':
592 if (!strcmp(arg, "rdonly")) {
593 new->flags = F_MTFLAG;
594 new->mt_data = MNT_RDONLY;
595 return (new);
596 }
597 break;
598 }
599 errx(1, "%s: unknown file type", arg);
600 /* NOTREACHED */
601}
602#endif
603
604/*
605 * -group gname functions --
606 *
607 * True if the file belongs to the group gname. If gname is numeric and
608 * an equivalent of the getgrnam() function does not return a valid group
609 * name, gname is taken as a group ID.
610 */
611int
612f_group(plan, entry)
613 PLAN *plan;
614 FTSENT *entry;
615{
616 return (entry->fts_statp->st_gid == plan->g_data);
617}
618
619PLAN *
620c_group(gname)
621 char *gname;
622{
623 PLAN *new;
624 struct group *g;
625 gid_t gid;
626
627 ftsoptions &= ~FTS_NOSTAT;
628
629 g = getgrnam(gname);
630 if (g == NULL) {
631 gid = atoi(gname);
632 if (gid == 0 && gname[0] != '0')
633 errx(1, "-group: %s: no such group", gname);
634 } else
635 gid = g->gr_gid;
636
637 new = palloc(N_GROUP, f_group);
638 new->g_data = gid;
639 return (new);
640}
641
642/*
643 * -inum n functions --
644 *
645 * True if the file has inode # n.
646 */
647int
648f_inum(plan, entry)
649 PLAN *plan;
650 FTSENT *entry;
651{
652 COMPARE(entry->fts_statp->st_ino, plan->i_data);
653}
654
655PLAN *
656c_inum(arg)
657 char *arg;
658{
659 PLAN *new;
660
661 ftsoptions &= ~FTS_NOSTAT;
662
663 new = palloc(N_INUM, f_inum);
664 new->i_data = find_parsenum(new, "-inum", arg, NULL);
665 return (new);
666}
667
668/*
669 * -links n functions --
670 *
671 * True if the file has n links.
672 */
673int
674f_links(plan, entry)
675 PLAN *plan;
676 FTSENT *entry;
677{
678 COMPARE(entry->fts_statp->st_nlink, plan->l_data);
679}
680
681PLAN *
682c_links(arg)
683 char *arg;
684{
685 PLAN *new;
686
687 ftsoptions &= ~FTS_NOSTAT;
688
689 new = palloc(N_LINKS, f_links);
690 new->l_data = (nlink_t)find_parsenum(new, "-links", arg, NULL);
691 return (new);
692}
693
694/*
695 * -ls functions --
696 *
697 * Always true - prints the current entry to stdout in "ls" format.
698 */
699int
700f_ls(plan, entry)
701 PLAN *plan;
702 FTSENT *entry;
703{
704 printlong(entry->fts_path, entry->fts_accpath, entry->fts_statp);
705 return (1);
706}
707
708PLAN *
709c_ls()
710{
711 ftsoptions &= ~FTS_NOSTAT;
712 isoutput = 1;
713
714 return (palloc(N_LS, f_ls));
715}
716
717/*
718 * -mtime n functions --
719 *
720 * True if the difference between the file modification time and the
721 * current time is n 24 hour periods.
722 */
723int
724f_mtime(plan, entry)
725 PLAN *plan;
726 FTSENT *entry;
727{
728 extern time_t now;
729
730 COMPARE((now - entry->fts_statp->st_mtime + 86400 - 1) /
731 86400, plan->t_data);
732}
733
734PLAN *
735c_mtime(arg)
736 char *arg;
737{
738 PLAN *new;
739
740 ftsoptions &= ~FTS_NOSTAT;
741
742 new = palloc(N_MTIME, f_mtime);
743 new->t_data = find_parsenum(new, "-mtime", arg, NULL);
744 TIME_CORRECT(new, N_MTIME);
745 return (new);
746}
747
748/*
749 * -mmin n functions --
750 *
751 * True if the difference between the file modification time and the
752 * current time is n min periods.
753 */
754int
755f_mmin(plan, entry)
756 PLAN *plan;
757 FTSENT *entry;
758{
759 extern time_t now;
760
761 COMPARE((now - entry->fts_statp->st_mtime + 60 - 1) /
762 60, plan->t_data);
763}
764
765PLAN *
766c_mmin(arg)
767 char *arg;
768{
769 PLAN *new;
770
771 ftsoptions &= ~FTS_NOSTAT;
772
773 new = palloc(N_MMIN, f_mmin);
774 new->t_data = find_parsenum(new, "-mmin", arg, NULL);
775 TIME_CORRECT(new, N_MMIN);
776 return (new);
777}
778
779
780/*
781 * -name functions --
782 *
783 * True if the basename of the filename being examined
784 * matches pattern using Pattern Matching Notation S3.14
785 */
786int
787f_name(plan, entry)
788 PLAN *plan;
789 FTSENT *entry;
790{
791 return (!fnmatch(plan->c_data, entry->fts_name, 0));
792}
793
794PLAN *
795c_name(pattern)
796 char *pattern;
797{
798 PLAN *new;
799
800 new = palloc(N_NAME, f_name);
801 new->c_data = pattern;
802 return (new);
803}
804
805/*
806 * -newer file functions --
807 *
808 * True if the current file has been modified more recently
809 * then the modification time of the file named by the pathname
810 * file.
811 */
812int
813f_newer(plan, entry)
814 PLAN *plan;
815 FTSENT *entry;
816{
817 return (entry->fts_statp->st_mtime > plan->t_data);
818}
819
820PLAN *
821c_newer(filename)
822 char *filename;
823{
824 PLAN *new;
825 struct stat sb;
826
827 ftsoptions &= ~FTS_NOSTAT;
828
829 if (stat(filename, &sb))
830 err(1, "%s", filename);
831 new = palloc(N_NEWER, f_newer);
832 new->t_data = sb.st_mtime;
833 return (new);
834}
835
836/*
837 * -nogroup functions --
838 *
839 * True if file belongs to a user ID for which the equivalent
840 * of the getgrnam() 9.2.1 [POSIX.1] function returns NULL.
841 */
842int
843f_nogroup(plan, entry)
844 PLAN *plan;
845 FTSENT *entry;
846{
847 char *group_from_gid();
848
849 return (group_from_gid(entry->fts_statp->st_gid, 1) ? 0 : 1);
850}
851
852PLAN *
853c_nogroup()
854{
855 ftsoptions &= ~FTS_NOSTAT;
856
857 return (palloc(N_NOGROUP, f_nogroup));
858}
859
860/*
861 * -nouser functions --
862 *
863 * True if file belongs to a user ID for which the equivalent
864 * of the getpwuid() 9.2.2 [POSIX.1] function returns NULL.
865 */
866int
867f_nouser(plan, entry)
868 PLAN *plan;
869 FTSENT *entry;
870{
871 char *user_from_uid();
872
873 return (user_from_uid(entry->fts_statp->st_uid, 1) ? 0 : 1);
874}
875
876PLAN *
877c_nouser()
878{
879 ftsoptions &= ~FTS_NOSTAT;
880
881 return (palloc(N_NOUSER, f_nouser));
882}
883
884/*
885 * -path functions --
886 *
887 * True if the path of the filename being examined
888 * matches pattern using Pattern Matching Notation S3.14
889 */
890int
891f_path(plan, entry)
892 PLAN *plan;
893 FTSENT *entry;
894{
895 return (!fnmatch(plan->c_data, entry->fts_path, 0));
896}
897
898PLAN *
899c_path(pattern)
900 char *pattern;
901{
902 PLAN *new;
903
904 new = palloc(N_NAME, f_path);
905 new->c_data = pattern;
906 return (new);
907}
908
909/*
910 * -perm functions --
911 *
912 * The mode argument is used to represent file mode bits. If it starts
913 * with a leading digit, it's treated as an octal mode, otherwise as a
914 * symbolic mode.
915 */
916int
917f_perm(plan, entry)
918 PLAN *plan;
919 FTSENT *entry;
920{
921 mode_t mode;
922
923 mode = entry->fts_statp->st_mode &
924 (S_ISUID|S_ISGID|S_ISTXT|S_IRWXU|S_IRWXG|S_IRWXO);
925 if (plan->flags == F_ATLEAST)
926 return ((plan->m_data | mode) == mode);
927 else
928 return (mode == plan->m_data);
929 /* NOTREACHED */
930}
931
932PLAN *
933c_perm(perm)
934 char *perm;
935{
936 PLAN *new;
937 mode_t *set;
938
939 ftsoptions &= ~FTS_NOSTAT;
940
941 new = palloc(N_PERM, f_perm);
942
943 if (*perm == '-') {
944 new->flags = F_ATLEAST;
945 ++perm;
946 }
947
948 if ((set = setmode(perm)) == NULL)
949 err(1, "-perm: %s: illegal mode string", perm);
950
951 new->m_data = getmode(set, 0);
952 return (new);
953}
954
955/*
956 * -print functions --
957 *
958 * Always true, causes the current pathame to be written to
959 * standard output.
960 */
961int
962f_print(plan, entry)
963 PLAN *plan;
964 FTSENT *entry;
965{
966 (void)puts(entry->fts_path);
967 return (1);
968}
969
970PLAN *
971c_print()
972{
973 isoutput = 1;
974
975 return (palloc(N_PRINT, f_print));
976}
977
978/*
979 * -print0 functions --
980 *
981 * Always true, causes the current pathame to be written to
982 * standard output followed by a NUL character
983 */
984int
985f_print0(plan, entry)
986 PLAN *plan;
987 FTSENT *entry;
988{
989 fputs(entry->fts_path, stdout);
990 fputc('\0', stdout);
991 return (1);
992}
993
994PLAN *
995c_print0()
996{
997 isoutput = 1;
998
999 return (palloc(N_PRINT0, f_print0));
1000}
1001
1002/*
1003 * -prune functions --
1004 *
1005 * Prune a portion of the hierarchy.
1006 */
1007int
1008f_prune(plan, entry)
1009 PLAN *plan;
1010 FTSENT *entry;
1011{
1012 extern FTS *tree;
1013
1014 if (fts_set(tree, entry, FTS_SKIP))
1015 err(1, "%s", entry->fts_path);
1016 return (1);
1017}
1018
1019PLAN *
1020c_prune()
1021{
1022 return (palloc(N_PRUNE, f_prune));
1023}
1024
1025/*
1026 * -size n[c] functions --
1027 *
1028 * True if the file size in bytes, divided by an implementation defined
1029 * value and rounded up to the next integer, is n. If n is followed by
1030 * a c, the size is in bytes.
1031 */
1032#define FIND_SIZE 512
1033static int divsize = 1;
1034
1035int
1036f_size(plan, entry)
1037 PLAN *plan;
1038 FTSENT *entry;
1039{
1040 off_t size;
1041
1042 size = divsize ? (entry->fts_statp->st_size + FIND_SIZE - 1) /
1043 FIND_SIZE : entry->fts_statp->st_size;
1044 COMPARE(size, plan->o_data);
1045}
1046
1047PLAN *
1048c_size(arg)
1049 char *arg;
1050{
1051 PLAN *new;
1052 char endch;
1053
1054 ftsoptions &= ~FTS_NOSTAT;
1055
1056 new = palloc(N_SIZE, f_size);
1057 endch = 'c';
1058 new->o_data = find_parsenum(new, "-size", arg, &endch);
1059 if (endch == 'c')
1060 divsize = 0;
1061 return (new);
1062}
1063
1064/*
1065 * -type c functions --
1066 *
1067 * True if the type of the file is c, where c is b, c, d, p, f or w
1068 * for block special file, character special file, directory, FIFO,
1069 * regular file or whiteout respectively.
1070 */
1071int
1072f_type(plan, entry)
1073 PLAN *plan;
1074 FTSENT *entry;
1075{
1076 return ((entry->fts_statp->st_mode & S_IFMT) == plan->m_data);
1077}
1078
1079PLAN *
1080c_type(typestring)
1081 char *typestring;
1082{
1083 PLAN *new;
1084 mode_t mask;
1085
1086 ftsoptions &= ~FTS_NOSTAT;
1087
1088 switch (typestring[0]) {
1089 case 'b':
1090 mask = S_IFBLK;
1091 break;
1092 case 'c':
1093 mask = S_IFCHR;
1094 break;
1095 case 'd':
1096 mask = S_IFDIR;
1097 break;
1098 case 'f':
1099 mask = S_IFREG;
1100 break;
1101 case 'l':
1102 mask = S_IFLNK;
1103 break;
1104 case 'p':
1105 mask = S_IFIFO;
1106 break;
1107 case 's':
1108 mask = S_IFSOCK;
1109 break;
1110#ifdef FTS_WHITEOUT
1111 case 'w':
1112 mask = S_IFWHT;
1113 ftsoptions |= FTS_WHITEOUT;
1114 break;
1115#endif /* FTS_WHITEOUT */
1116 default:
1117 errx(1, "-type: %s: unknown type", typestring);
1118 }
1119
1120 new = palloc(N_TYPE, f_type);
1121 new->m_data = mask;
1122 return (new);
1123}
1124
1125/*
1126 * -delete functions --
1127 *
1128 * True always. Makes it's best shot and continues on regardless.
1129 */
1130int
1131f_delete(plan, entry)
1132 PLAN *plan;
1133 FTSENT *entry;
1134{
1135 /* ignore these from fts */
1136 if (strcmp(entry->fts_accpath, ".") == 0 ||
1137 strcmp(entry->fts_accpath, "..") == 0)
1138 return (1);
1139
1140 /* sanity check */
1141 if (isdepth == 0 || /* depth off */
1142 (ftsoptions & FTS_NOSTAT) || /* not stat()ing */
1143 !(ftsoptions & FTS_PHYSICAL) || /* physical off */
1144 (ftsoptions & FTS_LOGICAL)) /* or finally, logical on */
1145 errx(1, "-delete: insecure options got turned on");
1146
1147 /* Potentially unsafe - do not accept relative paths whatsoever */
1148 if (strchr(entry->fts_accpath, '/') != NULL)
1149 errx(1, "-delete: %s: relative path potentially not safe",
1150 entry->fts_accpath);
1151
1152 /* Turn off user immutable bits if running as root */
1153 if ((entry->fts_statp->st_flags & (UF_APPEND|UF_IMMUTABLE)) &&
1154 !(entry->fts_statp->st_flags & (SF_APPEND|SF_IMMUTABLE)) &&
1155 geteuid() == 0)
1156 chflags(entry->fts_accpath,
1157 entry->fts_statp->st_flags &= ~(UF_APPEND|UF_IMMUTABLE));
1158
1159 /* rmdir directories, unlink everything else */
1160 if (S_ISDIR(entry->fts_statp->st_mode)) {
1161 if (rmdir(entry->fts_accpath) < 0 && errno != ENOTEMPTY)
1162 warn("-delete: rmdir(%s)", entry->fts_path);
1163 } else {
1164 if (unlink(entry->fts_accpath) < 0)
1165 warn("-delete: unlink(%s)", entry->fts_path);
1166 }
1167
1168 /* "succeed" */
1169 return (1);
1170}
1171
1172PLAN *
1173c_delete()
1174{
1175
1176 ftsoptions &= ~FTS_NOSTAT; /* no optimise */
1177 ftsoptions |= FTS_PHYSICAL; /* disable -follow */
1178 ftsoptions &= ~FTS_LOGICAL; /* disable -follow */
1179 isoutput = 1; /* possible output */
1180 isdepth = 1; /* -depth implied */
1181
1182 return (palloc(N_DELETE, f_delete));
1183}
1184
1185/*
1186 * -user uname functions --
1187 *
1188 * True if the file belongs to the user uname. If uname is numeric and
1189 * an equivalent of the getpwnam() S9.2.2 [POSIX.1] function does not
1190 * return a valid user name, uname is taken as a user ID.
1191 */
1192int
1193f_user(plan, entry)
1194 PLAN *plan;
1195 FTSENT *entry;
1196{
1197 return (entry->fts_statp->st_uid == plan->u_data);
1198}
1199
1200PLAN *
1201c_user(username)
1202 char *username;
1203{
1204 PLAN *new;
1205 struct passwd *p;
1206 uid_t uid;
1207
1208 ftsoptions &= ~FTS_NOSTAT;
1209
1210 p = getpwnam(username);
1211 if (p == NULL) {
1212 uid = atoi(username);
1213 if (uid == 0 && username[0] != '0')
1214 errx(1, "-user: %s: no such user", username);
1215 } else
1216 uid = p->pw_uid;
1217
1218 new = palloc(N_USER, f_user);
1219 new->u_data = uid;
1220 return (new);
1221}
1222
1223/*
1224 * -xdev functions --
1225 *
1226 * Always true, causes find not to decend past directories that have a
1227 * different device ID (st_dev, see stat() S5.6.2 [POSIX.1])
1228 */
1229PLAN *
1230c_xdev()
1231{
1232 ftsoptions |= FTS_XDEV;
1233
1234 return (palloc(N_XDEV, f_always_true));
1235}
1236
1237/*
1238 * ( expression ) functions --
1239 *
1240 * True if expression is true.
1241 */
1242int
1243f_expr(plan, entry)
1244 PLAN *plan;
1245 FTSENT *entry;
1246{
1247 register PLAN *p;
1248 register int state;
1249
1250 for (p = plan->p_data[0];
1251 p && (state = (p->eval)(p, entry)); p = p->next);
1252 return (state);
1253}
1254
1255/*
1256 * N_OPENPAREN and N_CLOSEPAREN nodes are temporary place markers. They are
1257 * eliminated during phase 2 of find_formplan() --- the '(' node is converted
1258 * to a N_EXPR node containing the expression and the ')' node is discarded.
1259 */
1260PLAN *
1261c_openparen()
1262{
1263 return (palloc(N_OPENPAREN, (int (*)())-1));
1264}
1265
1266PLAN *
1267c_closeparen()
1268{
1269 return (palloc(N_CLOSEPAREN, (int (*)())-1));
1270}
1271
1272/*
1273 * ! expression functions --
1274 *
1275 * Negation of a primary; the unary NOT operator.
1276 */
1277int
1278f_not(plan, entry)
1279 PLAN *plan;
1280 FTSENT *entry;
1281{
1282 register PLAN *p;
1283 register int state;
1284
1285 for (p = plan->p_data[0];
1286 p && (state = (p->eval)(p, entry)); p = p->next);
1287 return (!state);
1288}
1289
1290PLAN *
1291c_not()
1292{
1293 return (palloc(N_NOT, f_not));
1294}
1295
1296/*
1297 * expression -o expression functions --
1298 *
1299 * Alternation of primaries; the OR operator. The second expression is
1300 * not evaluated if the first expression is true.
1301 */
1302int
1303f_or(plan, entry)
1304 PLAN *plan;
1305 FTSENT *entry;
1306{
1307 register PLAN *p;
1308 register int state;
1309
1310 for (p = plan->p_data[0];
1311 p && (state = (p->eval)(p, entry)); p = p->next);
1312
1313 if (state)
1314 return (1);
1315
1316 for (p = plan->p_data[1];
1317 p && (state = (p->eval)(p, entry)); p = p->next);
1318 return (state);
1319}
1320
1321PLAN *
1322c_or()
1323{
1324 return (palloc(N_OR, f_or));
1325}
1326
1327static PLAN *
1328palloc(t, f)
1329 enum ntype t;
1330 int (*f) __P((PLAN *, FTSENT *));
1331{
1332 PLAN *new;
1333
1334 if ((new = malloc(sizeof(PLAN))) == NULL)
1335 err(1, NULL);
1336 new->type = t;
1337 new->eval = f;
1338 new->flags = 0;
1339 new->next = NULL;
1340 return (new);
1341}
| 418 case -1:
419 err(1, "fork");
420 /* NOTREACHED */
421 case 0:
422 execvp(plan->e_argv[0], plan->e_argv);
423 warn("%s", plan->e_argv[0]);
424 _exit(1);
425 }
426 pid = waitpid(pid, &status, 0);
427 return (pid != -1 && WIFEXITED(status) && !WEXITSTATUS(status));
428}
429
430/*
431 * c_execdir --
432 * build three parallel arrays, one with pointers to the strings passed
433 * on the command line, one with (possibly duplicated) pointers to the
434 * argv array, and one with integer values that are lengths of the
435 * strings, but also flags meaning that the string has to be massaged.
436 */
437PLAN *
438c_execdir(argvp)
439 char ***argvp;
440{
441 PLAN *new; /* node returned */
442 register int cnt;
443 register char **argv, **ap, *p;
444
445 ftsoptions &= ~FTS_NOSTAT;
446 isoutput = 1;
447
448 new = palloc(N_EXECDIR, f_execdir);
449
450 for (ap = argv = *argvp;; ++ap) {
451 if (!*ap)
452 errx(1,
453 "-execdir: no terminating \";\"");
454 if (**ap == ';')
455 break;
456 }
457
458 cnt = ap - *argvp + 1;
459 new->e_argv = (char **)emalloc((u_int)cnt * sizeof(char *));
460 new->e_orig = (char **)emalloc((u_int)cnt * sizeof(char *));
461 new->e_len = (int *)emalloc((u_int)cnt * sizeof(int));
462
463 for (argv = *argvp, cnt = 0; argv < ap; ++argv, ++cnt) {
464 new->e_orig[cnt] = *argv;
465 for (p = *argv; *p; ++p)
466 if (p[0] == '{' && p[1] == '}') {
467 new->e_argv[cnt] = emalloc((u_int)MAXPATHLEN);
468 new->e_len[cnt] = MAXPATHLEN;
469 break;
470 }
471 if (!*p) {
472 new->e_argv[cnt] = *argv;
473 new->e_len[cnt] = 0;
474 }
475 }
476 new->e_argv[cnt] = new->e_orig[cnt] = NULL;
477
478 *argvp = argv + 1;
479 return (new);
480}
481
482/*
483 * -follow functions --
484 *
485 * Always true, causes symbolic links to be followed on a global
486 * basis.
487 */
488PLAN *
489c_follow()
490{
491 ftsoptions &= ~FTS_PHYSICAL;
492 ftsoptions |= FTS_LOGICAL;
493
494 return (palloc(N_FOLLOW, f_always_true));
495}
496
497/*
498 * -fstype functions --
499 *
500 * True if the file is of a certain type.
501 */
502int
503f_fstype(plan, entry)
504 PLAN *plan;
505 FTSENT *entry;
506{
507 static dev_t curdev; /* need a guaranteed illegal dev value */
508 static int first = 1;
509 struct statfs sb;
510 static int val_type, val_flags;
511 char *p, save[2];
512
513 /* Only check when we cross mount point. */
514 if (first || curdev != entry->fts_statp->st_dev) {
515 curdev = entry->fts_statp->st_dev;
516
517 /*
518 * Statfs follows symlinks; find wants the link's file system,
519 * not where it points.
520 */
521 if (entry->fts_info == FTS_SL ||
522 entry->fts_info == FTS_SLNONE) {
523 if ((p = strrchr(entry->fts_accpath, '/')) != NULL)
524 ++p;
525 else
526 p = entry->fts_accpath;
527 save[0] = p[0];
528 p[0] = '.';
529 save[1] = p[1];
530 p[1] = '\0';
531
532 } else
533 p = NULL;
534
535 if (statfs(entry->fts_accpath, &sb))
536 err(1, "%s", entry->fts_accpath);
537
538 if (p) {
539 p[0] = save[0];
540 p[1] = save[1];
541 }
542
543 first = 0;
544
545 /*
546 * Further tests may need both of these values, so
547 * always copy both of them.
548 */
549 val_flags = sb.f_flags;
550 val_type = sb.f_type;
551 }
552 switch (plan->flags) {
553 case F_MTFLAG:
554 return (val_flags & plan->mt_data) != 0;
555 case F_MTTYPE:
556 return (val_type == plan->mt_data);
557 default:
558 abort();
559 }
560}
561
562#if !defined(__NetBSD__)
563PLAN *
564c_fstype(arg)
565 char *arg;
566{
567 register PLAN *new;
568 struct vfsconf vfc;
569
570 ftsoptions &= ~FTS_NOSTAT;
571
572 new = palloc(N_FSTYPE, f_fstype);
573
574 /*
575 * Check first for a filesystem name.
576 */
577 if (getvfsbyname(arg, &vfc) == 0) {
578 new->flags = F_MTTYPE;
579 new->mt_data = vfc.vfc_typenum;
580 return (new);
581 }
582
583 switch (*arg) {
584 case 'l':
585 if (!strcmp(arg, "local")) {
586 new->flags = F_MTFLAG;
587 new->mt_data = MNT_LOCAL;
588 return (new);
589 }
590 break;
591 case 'r':
592 if (!strcmp(arg, "rdonly")) {
593 new->flags = F_MTFLAG;
594 new->mt_data = MNT_RDONLY;
595 return (new);
596 }
597 break;
598 }
599 errx(1, "%s: unknown file type", arg);
600 /* NOTREACHED */
601}
602#endif
603
604/*
605 * -group gname functions --
606 *
607 * True if the file belongs to the group gname. If gname is numeric and
608 * an equivalent of the getgrnam() function does not return a valid group
609 * name, gname is taken as a group ID.
610 */
611int
612f_group(plan, entry)
613 PLAN *plan;
614 FTSENT *entry;
615{
616 return (entry->fts_statp->st_gid == plan->g_data);
617}
618
619PLAN *
620c_group(gname)
621 char *gname;
622{
623 PLAN *new;
624 struct group *g;
625 gid_t gid;
626
627 ftsoptions &= ~FTS_NOSTAT;
628
629 g = getgrnam(gname);
630 if (g == NULL) {
631 gid = atoi(gname);
632 if (gid == 0 && gname[0] != '0')
633 errx(1, "-group: %s: no such group", gname);
634 } else
635 gid = g->gr_gid;
636
637 new = palloc(N_GROUP, f_group);
638 new->g_data = gid;
639 return (new);
640}
641
642/*
643 * -inum n functions --
644 *
645 * True if the file has inode # n.
646 */
647int
648f_inum(plan, entry)
649 PLAN *plan;
650 FTSENT *entry;
651{
652 COMPARE(entry->fts_statp->st_ino, plan->i_data);
653}
654
655PLAN *
656c_inum(arg)
657 char *arg;
658{
659 PLAN *new;
660
661 ftsoptions &= ~FTS_NOSTAT;
662
663 new = palloc(N_INUM, f_inum);
664 new->i_data = find_parsenum(new, "-inum", arg, NULL);
665 return (new);
666}
667
668/*
669 * -links n functions --
670 *
671 * True if the file has n links.
672 */
673int
674f_links(plan, entry)
675 PLAN *plan;
676 FTSENT *entry;
677{
678 COMPARE(entry->fts_statp->st_nlink, plan->l_data);
679}
680
681PLAN *
682c_links(arg)
683 char *arg;
684{
685 PLAN *new;
686
687 ftsoptions &= ~FTS_NOSTAT;
688
689 new = palloc(N_LINKS, f_links);
690 new->l_data = (nlink_t)find_parsenum(new, "-links", arg, NULL);
691 return (new);
692}
693
694/*
695 * -ls functions --
696 *
697 * Always true - prints the current entry to stdout in "ls" format.
698 */
699int
700f_ls(plan, entry)
701 PLAN *plan;
702 FTSENT *entry;
703{
704 printlong(entry->fts_path, entry->fts_accpath, entry->fts_statp);
705 return (1);
706}
707
708PLAN *
709c_ls()
710{
711 ftsoptions &= ~FTS_NOSTAT;
712 isoutput = 1;
713
714 return (palloc(N_LS, f_ls));
715}
716
717/*
718 * -mtime n functions --
719 *
720 * True if the difference between the file modification time and the
721 * current time is n 24 hour periods.
722 */
723int
724f_mtime(plan, entry)
725 PLAN *plan;
726 FTSENT *entry;
727{
728 extern time_t now;
729
730 COMPARE((now - entry->fts_statp->st_mtime + 86400 - 1) /
731 86400, plan->t_data);
732}
733
734PLAN *
735c_mtime(arg)
736 char *arg;
737{
738 PLAN *new;
739
740 ftsoptions &= ~FTS_NOSTAT;
741
742 new = palloc(N_MTIME, f_mtime);
743 new->t_data = find_parsenum(new, "-mtime", arg, NULL);
744 TIME_CORRECT(new, N_MTIME);
745 return (new);
746}
747
748/*
749 * -mmin n functions --
750 *
751 * True if the difference between the file modification time and the
752 * current time is n min periods.
753 */
754int
755f_mmin(plan, entry)
756 PLAN *plan;
757 FTSENT *entry;
758{
759 extern time_t now;
760
761 COMPARE((now - entry->fts_statp->st_mtime + 60 - 1) /
762 60, plan->t_data);
763}
764
765PLAN *
766c_mmin(arg)
767 char *arg;
768{
769 PLAN *new;
770
771 ftsoptions &= ~FTS_NOSTAT;
772
773 new = palloc(N_MMIN, f_mmin);
774 new->t_data = find_parsenum(new, "-mmin", arg, NULL);
775 TIME_CORRECT(new, N_MMIN);
776 return (new);
777}
778
779
780/*
781 * -name functions --
782 *
783 * True if the basename of the filename being examined
784 * matches pattern using Pattern Matching Notation S3.14
785 */
786int
787f_name(plan, entry)
788 PLAN *plan;
789 FTSENT *entry;
790{
791 return (!fnmatch(plan->c_data, entry->fts_name, 0));
792}
793
794PLAN *
795c_name(pattern)
796 char *pattern;
797{
798 PLAN *new;
799
800 new = palloc(N_NAME, f_name);
801 new->c_data = pattern;
802 return (new);
803}
804
805/*
806 * -newer file functions --
807 *
808 * True if the current file has been modified more recently
809 * then the modification time of the file named by the pathname
810 * file.
811 */
812int
813f_newer(plan, entry)
814 PLAN *plan;
815 FTSENT *entry;
816{
817 return (entry->fts_statp->st_mtime > plan->t_data);
818}
819
820PLAN *
821c_newer(filename)
822 char *filename;
823{
824 PLAN *new;
825 struct stat sb;
826
827 ftsoptions &= ~FTS_NOSTAT;
828
829 if (stat(filename, &sb))
830 err(1, "%s", filename);
831 new = palloc(N_NEWER, f_newer);
832 new->t_data = sb.st_mtime;
833 return (new);
834}
835
836/*
837 * -nogroup functions --
838 *
839 * True if file belongs to a user ID for which the equivalent
840 * of the getgrnam() 9.2.1 [POSIX.1] function returns NULL.
841 */
842int
843f_nogroup(plan, entry)
844 PLAN *plan;
845 FTSENT *entry;
846{
847 char *group_from_gid();
848
849 return (group_from_gid(entry->fts_statp->st_gid, 1) ? 0 : 1);
850}
851
852PLAN *
853c_nogroup()
854{
855 ftsoptions &= ~FTS_NOSTAT;
856
857 return (palloc(N_NOGROUP, f_nogroup));
858}
859
860/*
861 * -nouser functions --
862 *
863 * True if file belongs to a user ID for which the equivalent
864 * of the getpwuid() 9.2.2 [POSIX.1] function returns NULL.
865 */
866int
867f_nouser(plan, entry)
868 PLAN *plan;
869 FTSENT *entry;
870{
871 char *user_from_uid();
872
873 return (user_from_uid(entry->fts_statp->st_uid, 1) ? 0 : 1);
874}
875
876PLAN *
877c_nouser()
878{
879 ftsoptions &= ~FTS_NOSTAT;
880
881 return (palloc(N_NOUSER, f_nouser));
882}
883
884/*
885 * -path functions --
886 *
887 * True if the path of the filename being examined
888 * matches pattern using Pattern Matching Notation S3.14
889 */
890int
891f_path(plan, entry)
892 PLAN *plan;
893 FTSENT *entry;
894{
895 return (!fnmatch(plan->c_data, entry->fts_path, 0));
896}
897
898PLAN *
899c_path(pattern)
900 char *pattern;
901{
902 PLAN *new;
903
904 new = palloc(N_NAME, f_path);
905 new->c_data = pattern;
906 return (new);
907}
908
909/*
910 * -perm functions --
911 *
912 * The mode argument is used to represent file mode bits. If it starts
913 * with a leading digit, it's treated as an octal mode, otherwise as a
914 * symbolic mode.
915 */
916int
917f_perm(plan, entry)
918 PLAN *plan;
919 FTSENT *entry;
920{
921 mode_t mode;
922
923 mode = entry->fts_statp->st_mode &
924 (S_ISUID|S_ISGID|S_ISTXT|S_IRWXU|S_IRWXG|S_IRWXO);
925 if (plan->flags == F_ATLEAST)
926 return ((plan->m_data | mode) == mode);
927 else
928 return (mode == plan->m_data);
929 /* NOTREACHED */
930}
931
932PLAN *
933c_perm(perm)
934 char *perm;
935{
936 PLAN *new;
937 mode_t *set;
938
939 ftsoptions &= ~FTS_NOSTAT;
940
941 new = palloc(N_PERM, f_perm);
942
943 if (*perm == '-') {
944 new->flags = F_ATLEAST;
945 ++perm;
946 }
947
948 if ((set = setmode(perm)) == NULL)
949 err(1, "-perm: %s: illegal mode string", perm);
950
951 new->m_data = getmode(set, 0);
952 return (new);
953}
954
955/*
956 * -print functions --
957 *
958 * Always true, causes the current pathame to be written to
959 * standard output.
960 */
961int
962f_print(plan, entry)
963 PLAN *plan;
964 FTSENT *entry;
965{
966 (void)puts(entry->fts_path);
967 return (1);
968}
969
970PLAN *
971c_print()
972{
973 isoutput = 1;
974
975 return (palloc(N_PRINT, f_print));
976}
977
978/*
979 * -print0 functions --
980 *
981 * Always true, causes the current pathame to be written to
982 * standard output followed by a NUL character
983 */
984int
985f_print0(plan, entry)
986 PLAN *plan;
987 FTSENT *entry;
988{
989 fputs(entry->fts_path, stdout);
990 fputc('\0', stdout);
991 return (1);
992}
993
994PLAN *
995c_print0()
996{
997 isoutput = 1;
998
999 return (palloc(N_PRINT0, f_print0));
1000}
1001
1002/*
1003 * -prune functions --
1004 *
1005 * Prune a portion of the hierarchy.
1006 */
1007int
1008f_prune(plan, entry)
1009 PLAN *plan;
1010 FTSENT *entry;
1011{
1012 extern FTS *tree;
1013
1014 if (fts_set(tree, entry, FTS_SKIP))
1015 err(1, "%s", entry->fts_path);
1016 return (1);
1017}
1018
1019PLAN *
1020c_prune()
1021{
1022 return (palloc(N_PRUNE, f_prune));
1023}
1024
1025/*
1026 * -size n[c] functions --
1027 *
1028 * True if the file size in bytes, divided by an implementation defined
1029 * value and rounded up to the next integer, is n. If n is followed by
1030 * a c, the size is in bytes.
1031 */
1032#define FIND_SIZE 512
1033static int divsize = 1;
1034
1035int
1036f_size(plan, entry)
1037 PLAN *plan;
1038 FTSENT *entry;
1039{
1040 off_t size;
1041
1042 size = divsize ? (entry->fts_statp->st_size + FIND_SIZE - 1) /
1043 FIND_SIZE : entry->fts_statp->st_size;
1044 COMPARE(size, plan->o_data);
1045}
1046
1047PLAN *
1048c_size(arg)
1049 char *arg;
1050{
1051 PLAN *new;
1052 char endch;
1053
1054 ftsoptions &= ~FTS_NOSTAT;
1055
1056 new = palloc(N_SIZE, f_size);
1057 endch = 'c';
1058 new->o_data = find_parsenum(new, "-size", arg, &endch);
1059 if (endch == 'c')
1060 divsize = 0;
1061 return (new);
1062}
1063
1064/*
1065 * -type c functions --
1066 *
1067 * True if the type of the file is c, where c is b, c, d, p, f or w
1068 * for block special file, character special file, directory, FIFO,
1069 * regular file or whiteout respectively.
1070 */
1071int
1072f_type(plan, entry)
1073 PLAN *plan;
1074 FTSENT *entry;
1075{
1076 return ((entry->fts_statp->st_mode & S_IFMT) == plan->m_data);
1077}
1078
1079PLAN *
1080c_type(typestring)
1081 char *typestring;
1082{
1083 PLAN *new;
1084 mode_t mask;
1085
1086 ftsoptions &= ~FTS_NOSTAT;
1087
1088 switch (typestring[0]) {
1089 case 'b':
1090 mask = S_IFBLK;
1091 break;
1092 case 'c':
1093 mask = S_IFCHR;
1094 break;
1095 case 'd':
1096 mask = S_IFDIR;
1097 break;
1098 case 'f':
1099 mask = S_IFREG;
1100 break;
1101 case 'l':
1102 mask = S_IFLNK;
1103 break;
1104 case 'p':
1105 mask = S_IFIFO;
1106 break;
1107 case 's':
1108 mask = S_IFSOCK;
1109 break;
1110#ifdef FTS_WHITEOUT
1111 case 'w':
1112 mask = S_IFWHT;
1113 ftsoptions |= FTS_WHITEOUT;
1114 break;
1115#endif /* FTS_WHITEOUT */
1116 default:
1117 errx(1, "-type: %s: unknown type", typestring);
1118 }
1119
1120 new = palloc(N_TYPE, f_type);
1121 new->m_data = mask;
1122 return (new);
1123}
1124
1125/*
1126 * -delete functions --
1127 *
1128 * True always. Makes it's best shot and continues on regardless.
1129 */
1130int
1131f_delete(plan, entry)
1132 PLAN *plan;
1133 FTSENT *entry;
1134{
1135 /* ignore these from fts */
1136 if (strcmp(entry->fts_accpath, ".") == 0 ||
1137 strcmp(entry->fts_accpath, "..") == 0)
1138 return (1);
1139
1140 /* sanity check */
1141 if (isdepth == 0 || /* depth off */
1142 (ftsoptions & FTS_NOSTAT) || /* not stat()ing */
1143 !(ftsoptions & FTS_PHYSICAL) || /* physical off */
1144 (ftsoptions & FTS_LOGICAL)) /* or finally, logical on */
1145 errx(1, "-delete: insecure options got turned on");
1146
1147 /* Potentially unsafe - do not accept relative paths whatsoever */
1148 if (strchr(entry->fts_accpath, '/') != NULL)
1149 errx(1, "-delete: %s: relative path potentially not safe",
1150 entry->fts_accpath);
1151
1152 /* Turn off user immutable bits if running as root */
1153 if ((entry->fts_statp->st_flags & (UF_APPEND|UF_IMMUTABLE)) &&
1154 !(entry->fts_statp->st_flags & (SF_APPEND|SF_IMMUTABLE)) &&
1155 geteuid() == 0)
1156 chflags(entry->fts_accpath,
1157 entry->fts_statp->st_flags &= ~(UF_APPEND|UF_IMMUTABLE));
1158
1159 /* rmdir directories, unlink everything else */
1160 if (S_ISDIR(entry->fts_statp->st_mode)) {
1161 if (rmdir(entry->fts_accpath) < 0 && errno != ENOTEMPTY)
1162 warn("-delete: rmdir(%s)", entry->fts_path);
1163 } else {
1164 if (unlink(entry->fts_accpath) < 0)
1165 warn("-delete: unlink(%s)", entry->fts_path);
1166 }
1167
1168 /* "succeed" */
1169 return (1);
1170}
1171
1172PLAN *
1173c_delete()
1174{
1175
1176 ftsoptions &= ~FTS_NOSTAT; /* no optimise */
1177 ftsoptions |= FTS_PHYSICAL; /* disable -follow */
1178 ftsoptions &= ~FTS_LOGICAL; /* disable -follow */
1179 isoutput = 1; /* possible output */
1180 isdepth = 1; /* -depth implied */
1181
1182 return (palloc(N_DELETE, f_delete));
1183}
1184
1185/*
1186 * -user uname functions --
1187 *
1188 * True if the file belongs to the user uname. If uname is numeric and
1189 * an equivalent of the getpwnam() S9.2.2 [POSIX.1] function does not
1190 * return a valid user name, uname is taken as a user ID.
1191 */
1192int
1193f_user(plan, entry)
1194 PLAN *plan;
1195 FTSENT *entry;
1196{
1197 return (entry->fts_statp->st_uid == plan->u_data);
1198}
1199
1200PLAN *
1201c_user(username)
1202 char *username;
1203{
1204 PLAN *new;
1205 struct passwd *p;
1206 uid_t uid;
1207
1208 ftsoptions &= ~FTS_NOSTAT;
1209
1210 p = getpwnam(username);
1211 if (p == NULL) {
1212 uid = atoi(username);
1213 if (uid == 0 && username[0] != '0')
1214 errx(1, "-user: %s: no such user", username);
1215 } else
1216 uid = p->pw_uid;
1217
1218 new = palloc(N_USER, f_user);
1219 new->u_data = uid;
1220 return (new);
1221}
1222
1223/*
1224 * -xdev functions --
1225 *
1226 * Always true, causes find not to decend past directories that have a
1227 * different device ID (st_dev, see stat() S5.6.2 [POSIX.1])
1228 */
1229PLAN *
1230c_xdev()
1231{
1232 ftsoptions |= FTS_XDEV;
1233
1234 return (palloc(N_XDEV, f_always_true));
1235}
1236
1237/*
1238 * ( expression ) functions --
1239 *
1240 * True if expression is true.
1241 */
1242int
1243f_expr(plan, entry)
1244 PLAN *plan;
1245 FTSENT *entry;
1246{
1247 register PLAN *p;
1248 register int state;
1249
1250 for (p = plan->p_data[0];
1251 p && (state = (p->eval)(p, entry)); p = p->next);
1252 return (state);
1253}
1254
1255/*
1256 * N_OPENPAREN and N_CLOSEPAREN nodes are temporary place markers. They are
1257 * eliminated during phase 2 of find_formplan() --- the '(' node is converted
1258 * to a N_EXPR node containing the expression and the ')' node is discarded.
1259 */
1260PLAN *
1261c_openparen()
1262{
1263 return (palloc(N_OPENPAREN, (int (*)())-1));
1264}
1265
1266PLAN *
1267c_closeparen()
1268{
1269 return (palloc(N_CLOSEPAREN, (int (*)())-1));
1270}
1271
1272/*
1273 * ! expression functions --
1274 *
1275 * Negation of a primary; the unary NOT operator.
1276 */
1277int
1278f_not(plan, entry)
1279 PLAN *plan;
1280 FTSENT *entry;
1281{
1282 register PLAN *p;
1283 register int state;
1284
1285 for (p = plan->p_data[0];
1286 p && (state = (p->eval)(p, entry)); p = p->next);
1287 return (!state);
1288}
1289
1290PLAN *
1291c_not()
1292{
1293 return (palloc(N_NOT, f_not));
1294}
1295
1296/*
1297 * expression -o expression functions --
1298 *
1299 * Alternation of primaries; the OR operator. The second expression is
1300 * not evaluated if the first expression is true.
1301 */
1302int
1303f_or(plan, entry)
1304 PLAN *plan;
1305 FTSENT *entry;
1306{
1307 register PLAN *p;
1308 register int state;
1309
1310 for (p = plan->p_data[0];
1311 p && (state = (p->eval)(p, entry)); p = p->next);
1312
1313 if (state)
1314 return (1);
1315
1316 for (p = plan->p_data[1];
1317 p && (state = (p->eval)(p, entry)); p = p->next);
1318 return (state);
1319}
1320
1321PLAN *
1322c_or()
1323{
1324 return (palloc(N_OR, f_or));
1325}
1326
1327static PLAN *
1328palloc(t, f)
1329 enum ntype t;
1330 int (*f) __P((PLAN *, FTSENT *));
1331{
1332 PLAN *new;
1333
1334 if ((new = malloc(sizeof(PLAN))) == NULL)
1335 err(1, NULL);
1336 new->type = t;
1337 new->eval = f;
1338 new->flags = 0;
1339 new->next = NULL;
1340 return (new);
1341}
|