1994-05-27 12:33:43 +00:00
|
|
|
/*-
|
|
|
|
* Copyright (c) 1990, 1993
|
|
|
|
* The Regents of the University of California. All rights reserved.
|
|
|
|
*
|
|
|
|
* This code is derived from software contributed to Berkeley by
|
|
|
|
* Cimarron D. Taylor of the University of California, Berkeley.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
|
|
* must display the following acknowledgement:
|
|
|
|
* This product includes software developed by the University of
|
|
|
|
* California, Berkeley and its contributors.
|
|
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef lint
|
1997-03-11 13:48:37 +00:00
|
|
|
static char sccsid[] = "@(#)function.c 8.10 (Berkeley) 5/4/95";
|
1994-05-27 12:33:43 +00:00
|
|
|
#endif /* not lint */
|
|
|
|
|
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/ucred.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <sys/wait.h>
|
|
|
|
#include <sys/mount.h>
|
|
|
|
|
|
|
|
#include <err.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <fnmatch.h>
|
|
|
|
#include <fts.h>
|
|
|
|
#include <grp.h>
|
|
|
|
#include <pwd.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
|
|
|
|
#include "find.h"
|
|
|
|
|
|
|
|
#define COMPARE(a, b) { \
|
|
|
|
switch (plan->flags) { \
|
|
|
|
case F_EQUAL: \
|
|
|
|
return (a == b); \
|
|
|
|
case F_LESSTHAN: \
|
|
|
|
return (a < b); \
|
|
|
|
case F_GREATER: \
|
|
|
|
return (a > b); \
|
|
|
|
default: \
|
|
|
|
abort(); \
|
|
|
|
} \
|
|
|
|
}
|
|
|
|
|
|
|
|
static PLAN *palloc __P((enum ntype, int (*) __P((PLAN *, FTSENT *))));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* find_parsenum --
|
|
|
|
* Parse a string of the form [+-]# and return the value.
|
|
|
|
*/
|
1996-04-07 12:58:13 +00:00
|
|
|
static long long
|
1994-05-27 12:33:43 +00:00
|
|
|
find_parsenum(plan, option, vp, endch)
|
|
|
|
PLAN *plan;
|
|
|
|
char *option, *vp, *endch;
|
|
|
|
{
|
1996-04-07 12:58:13 +00:00
|
|
|
long long value;
|
1994-05-27 12:33:43 +00:00
|
|
|
char *endchar, *str; /* Pointer to character ending conversion. */
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
/* Determine comparison from leading + or -. */
|
|
|
|
str = vp;
|
|
|
|
switch (*str) {
|
|
|
|
case '+':
|
|
|
|
++str;
|
|
|
|
plan->flags = F_GREATER;
|
|
|
|
break;
|
|
|
|
case '-':
|
|
|
|
++str;
|
|
|
|
plan->flags = F_LESSTHAN;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
plan->flags = F_EQUAL;
|
|
|
|
break;
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
/*
|
1996-04-07 12:58:13 +00:00
|
|
|
* Convert the string with strtoq(). Note, if strtoq() returns zero
|
1994-05-27 12:33:43 +00:00
|
|
|
* and endchar points to the beginning of the string we know we have
|
|
|
|
* a syntax error.
|
|
|
|
*/
|
1996-04-07 12:58:13 +00:00
|
|
|
value = strtoq(str, &endchar, 10);
|
1994-05-27 12:33:43 +00:00
|
|
|
if (value == 0 && endchar == str)
|
|
|
|
errx(1, "%s: %s: illegal numeric value", option, vp);
|
|
|
|
if (endchar[0] && (endch == NULL || endchar[0] != *endch))
|
|
|
|
errx(1, "%s: %s: illegal trailing character", option, vp);
|
|
|
|
if (endch)
|
|
|
|
*endch = endchar[0];
|
|
|
|
return (value);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The value of n for the inode times (atime, ctime, and mtime) is a range,
|
|
|
|
* i.e. n matches from (n - 1) to n 24 hour periods. This interacts with
|
|
|
|
* -n, such that "-mtime -1" would be less than 0 days, which isn't what the
|
|
|
|
* user wanted. Correct so that -1 is "less than 1".
|
|
|
|
*/
|
|
|
|
#define TIME_CORRECT(p, ttype) \
|
|
|
|
if ((p)->type == ttype && (p)->flags == F_LESSTHAN) \
|
|
|
|
++((p)->t_data);
|
|
|
|
|
1997-10-13 21:06:22 +00:00
|
|
|
/*
|
|
|
|
* -amin n functions --
|
|
|
|
*
|
|
|
|
* True if the difference between the file access time and the
|
|
|
|
* current time is n min periods.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
f_amin(plan, entry)
|
|
|
|
PLAN *plan;
|
|
|
|
FTSENT *entry;
|
|
|
|
{
|
|
|
|
extern time_t now;
|
|
|
|
|
|
|
|
COMPARE((now - entry->fts_statp->st_atime +
|
|
|
|
60 - 1) / 60, plan->t_data);
|
|
|
|
}
|
|
|
|
|
|
|
|
PLAN *
|
|
|
|
c_amin(arg)
|
|
|
|
char *arg;
|
|
|
|
{
|
|
|
|
PLAN *new;
|
|
|
|
|
|
|
|
ftsoptions &= ~FTS_NOSTAT;
|
|
|
|
|
|
|
|
new = palloc(N_AMIN, f_amin);
|
|
|
|
new->t_data = find_parsenum(new, "-amin", arg, NULL);
|
|
|
|
TIME_CORRECT(new, N_AMIN);
|
|
|
|
return (new);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
/*
|
|
|
|
* -atime n functions --
|
|
|
|
*
|
|
|
|
* True if the difference between the file access time and the
|
|
|
|
* current time is n 24 hour periods.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
f_atime(plan, entry)
|
|
|
|
PLAN *plan;
|
|
|
|
FTSENT *entry;
|
|
|
|
{
|
|
|
|
extern time_t now;
|
|
|
|
|
|
|
|
COMPARE((now - entry->fts_statp->st_atime +
|
1995-08-07 19:17:46 +00:00
|
|
|
86400 - 1) / 86400, plan->t_data);
|
1994-05-27 12:33:43 +00:00
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
PLAN *
|
|
|
|
c_atime(arg)
|
|
|
|
char *arg;
|
|
|
|
{
|
|
|
|
PLAN *new;
|
|
|
|
|
|
|
|
ftsoptions &= ~FTS_NOSTAT;
|
|
|
|
|
|
|
|
new = palloc(N_ATIME, f_atime);
|
|
|
|
new->t_data = find_parsenum(new, "-atime", arg, NULL);
|
|
|
|
TIME_CORRECT(new, N_ATIME);
|
|
|
|
return (new);
|
|
|
|
}
|
1997-10-13 21:06:22 +00:00
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* -cmin n functions --
|
|
|
|
*
|
|
|
|
* True if the difference between the last change of file
|
|
|
|
* status information and the current time is n min periods.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
f_cmin(plan, entry)
|
|
|
|
PLAN *plan;
|
|
|
|
FTSENT *entry;
|
|
|
|
{
|
|
|
|
extern time_t now;
|
|
|
|
|
|
|
|
COMPARE((now - entry->fts_statp->st_ctime +
|
|
|
|
60 - 1) / 60, plan->t_data);
|
|
|
|
}
|
|
|
|
|
|
|
|
PLAN *
|
|
|
|
c_cmin(arg)
|
|
|
|
char *arg;
|
|
|
|
{
|
|
|
|
PLAN *new;
|
|
|
|
|
|
|
|
ftsoptions &= ~FTS_NOSTAT;
|
|
|
|
|
|
|
|
new = palloc(N_CMIN, f_cmin);
|
|
|
|
new->t_data = find_parsenum(new, "-cmin", arg, NULL);
|
|
|
|
TIME_CORRECT(new, N_CMIN);
|
|
|
|
return (new);
|
|
|
|
}
|
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
/*
|
|
|
|
* -ctime n functions --
|
|
|
|
*
|
|
|
|
* True if the difference between the last change of file
|
|
|
|
* status information and the current time is n 24 hour periods.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
f_ctime(plan, entry)
|
|
|
|
PLAN *plan;
|
|
|
|
FTSENT *entry;
|
|
|
|
{
|
|
|
|
extern time_t now;
|
|
|
|
|
|
|
|
COMPARE((now - entry->fts_statp->st_ctime +
|
1995-08-07 19:17:46 +00:00
|
|
|
86400 - 1) / 86400, plan->t_data);
|
1994-05-27 12:33:43 +00:00
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
PLAN *
|
|
|
|
c_ctime(arg)
|
|
|
|
char *arg;
|
|
|
|
{
|
|
|
|
PLAN *new;
|
|
|
|
|
|
|
|
ftsoptions &= ~FTS_NOSTAT;
|
|
|
|
|
|
|
|
new = palloc(N_CTIME, f_ctime);
|
|
|
|
new->t_data = find_parsenum(new, "-ctime", arg, NULL);
|
|
|
|
TIME_CORRECT(new, N_CTIME);
|
|
|
|
return (new);
|
|
|
|
}
|
|
|
|
|
1997-10-13 21:06:22 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
/*
|
|
|
|
* -depth functions --
|
|
|
|
*
|
|
|
|
* Always true, causes descent of the directory hierarchy to be done
|
|
|
|
* so that all entries in a directory are acted on before the directory
|
|
|
|
* itself.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
f_always_true(plan, entry)
|
|
|
|
PLAN *plan;
|
|
|
|
FTSENT *entry;
|
|
|
|
{
|
|
|
|
return (1);
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
PLAN *
|
|
|
|
c_depth()
|
|
|
|
{
|
|
|
|
isdepth = 1;
|
|
|
|
|
|
|
|
return (palloc(N_DEPTH, f_always_true));
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
/*
|
|
|
|
* [-exec | -ok] utility [arg ... ] ; functions --
|
|
|
|
*
|
|
|
|
* True if the executed utility returns a zero value as exit status.
|
|
|
|
* The end of the primary expression is delimited by a semicolon. If
|
|
|
|
* "{}" occurs anywhere, it gets replaced by the current pathname.
|
|
|
|
* The current directory for the execution of utility is the same as
|
|
|
|
* the current directory when the find utility was started.
|
|
|
|
*
|
|
|
|
* The primary -ok is different in that it requests affirmation of the
|
|
|
|
* user before executing the utility.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
f_exec(plan, entry)
|
|
|
|
register PLAN *plan;
|
|
|
|
FTSENT *entry;
|
|
|
|
{
|
|
|
|
extern int dotfd;
|
|
|
|
register int cnt;
|
|
|
|
pid_t pid;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
for (cnt = 0; plan->e_argv[cnt]; ++cnt)
|
|
|
|
if (plan->e_len[cnt])
|
|
|
|
brace_subst(plan->e_orig[cnt], &plan->e_argv[cnt],
|
|
|
|
entry->fts_path, plan->e_len[cnt]);
|
|
|
|
|
|
|
|
if (plan->flags == F_NEEDOK && !queryuser(plan->e_argv))
|
|
|
|
return (0);
|
|
|
|
|
1995-09-12 23:15:33 +00:00
|
|
|
/* make sure find output is interspersed correctly with subprocesses */
|
|
|
|
fflush(stdout);
|
|
|
|
|
1998-10-13 14:52:33 +00:00
|
|
|
switch (pid = fork()) {
|
1994-05-27 12:33:43 +00:00
|
|
|
case -1:
|
|
|
|
err(1, "fork");
|
|
|
|
/* NOTREACHED */
|
|
|
|
case 0:
|
|
|
|
if (fchdir(dotfd)) {
|
|
|
|
warn("chdir");
|
|
|
|
_exit(1);
|
|
|
|
}
|
|
|
|
execvp(plan->e_argv[0], plan->e_argv);
|
|
|
|
warn("%s", plan->e_argv[0]);
|
|
|
|
_exit(1);
|
|
|
|
}
|
|
|
|
pid = waitpid(pid, &status, 0);
|
|
|
|
return (pid != -1 && WIFEXITED(status) && !WEXITSTATUS(status));
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
/*
|
|
|
|
* c_exec --
|
|
|
|
* build three parallel arrays, one with pointers to the strings passed
|
|
|
|
* on the command line, one with (possibly duplicated) pointers to the
|
|
|
|
* argv array, and one with integer values that are lengths of the
|
|
|
|
* strings, but also flags meaning that the string has to be massaged.
|
|
|
|
*/
|
|
|
|
PLAN *
|
|
|
|
c_exec(argvp, isok)
|
|
|
|
char ***argvp;
|
|
|
|
int isok;
|
|
|
|
{
|
|
|
|
PLAN *new; /* node returned */
|
|
|
|
register int cnt;
|
|
|
|
register char **argv, **ap, *p;
|
|
|
|
|
|
|
|
isoutput = 1;
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
new = palloc(N_EXEC, f_exec);
|
|
|
|
if (isok)
|
|
|
|
new->flags = F_NEEDOK;
|
|
|
|
|
|
|
|
for (ap = argv = *argvp;; ++ap) {
|
|
|
|
if (!*ap)
|
|
|
|
errx(1,
|
|
|
|
"%s: no terminating \";\"", isok ? "-ok" : "-exec");
|
|
|
|
if (**ap == ';')
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
cnt = ap - *argvp + 1;
|
|
|
|
new->e_argv = (char **)emalloc((u_int)cnt * sizeof(char *));
|
|
|
|
new->e_orig = (char **)emalloc((u_int)cnt * sizeof(char *));
|
|
|
|
new->e_len = (int *)emalloc((u_int)cnt * sizeof(int));
|
|
|
|
|
|
|
|
for (argv = *argvp, cnt = 0; argv < ap; ++argv, ++cnt) {
|
|
|
|
new->e_orig[cnt] = *argv;
|
|
|
|
for (p = *argv; *p; ++p)
|
|
|
|
if (p[0] == '{' && p[1] == '}') {
|
|
|
|
new->e_argv[cnt] = emalloc((u_int)MAXPATHLEN);
|
|
|
|
new->e_len[cnt] = MAXPATHLEN;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!*p) {
|
|
|
|
new->e_argv[cnt] = *argv;
|
|
|
|
new->e_len[cnt] = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
new->e_argv[cnt] = new->e_orig[cnt] = NULL;
|
|
|
|
|
1997-08-29 23:09:45 +00:00
|
|
|
*argvp = argv + 1;
|
|
|
|
return (new);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* -execdir utility [arg ... ] ; functions --
|
|
|
|
*
|
|
|
|
* True if the executed utility returns a zero value as exit status.
|
|
|
|
* The end of the primary expression is delimited by a semicolon. If
|
|
|
|
* "{}" occurs anywhere, it gets replaced by the unqualified pathname.
|
|
|
|
* The current directory for the execution of utility is the same as
|
|
|
|
* the directory where the file lives.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
f_execdir(plan, entry)
|
|
|
|
register PLAN *plan;
|
|
|
|
FTSENT *entry;
|
|
|
|
{
|
|
|
|
extern int dotfd;
|
|
|
|
register int cnt;
|
|
|
|
pid_t pid;
|
|
|
|
int status;
|
|
|
|
char *file;
|
|
|
|
|
|
|
|
/* XXX - if file/dir ends in '/' this will not work -- can it? */
|
|
|
|
if ((file = strrchr(entry->fts_path, '/')))
|
|
|
|
file++;
|
|
|
|
else
|
|
|
|
file = entry->fts_path;
|
|
|
|
|
|
|
|
for (cnt = 0; plan->e_argv[cnt]; ++cnt)
|
|
|
|
if (plan->e_len[cnt])
|
|
|
|
brace_subst(plan->e_orig[cnt], &plan->e_argv[cnt],
|
|
|
|
file, plan->e_len[cnt]);
|
|
|
|
|
|
|
|
/* don't mix output of command with find output */
|
|
|
|
fflush(stdout);
|
|
|
|
fflush(stderr);
|
|
|
|
|
1998-10-13 14:52:33 +00:00
|
|
|
switch (pid = fork()) {
|
1997-08-29 23:09:45 +00:00
|
|
|
case -1:
|
|
|
|
err(1, "fork");
|
|
|
|
/* NOTREACHED */
|
|
|
|
case 0:
|
|
|
|
execvp(plan->e_argv[0], plan->e_argv);
|
|
|
|
warn("%s", plan->e_argv[0]);
|
|
|
|
_exit(1);
|
|
|
|
}
|
|
|
|
pid = waitpid(pid, &status, 0);
|
|
|
|
return (pid != -1 && WIFEXITED(status) && !WEXITSTATUS(status));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* c_execdir --
|
|
|
|
* build three parallel arrays, one with pointers to the strings passed
|
|
|
|
* on the command line, one with (possibly duplicated) pointers to the
|
|
|
|
* argv array, and one with integer values that are lengths of the
|
|
|
|
* strings, but also flags meaning that the string has to be massaged.
|
|
|
|
*/
|
|
|
|
PLAN *
|
|
|
|
c_execdir(argvp)
|
|
|
|
char ***argvp;
|
|
|
|
{
|
|
|
|
PLAN *new; /* node returned */
|
|
|
|
register int cnt;
|
|
|
|
register char **argv, **ap, *p;
|
|
|
|
|
|
|
|
ftsoptions &= ~FTS_NOSTAT;
|
|
|
|
isoutput = 1;
|
|
|
|
|
|
|
|
new = palloc(N_EXECDIR, f_execdir);
|
|
|
|
|
|
|
|
for (ap = argv = *argvp;; ++ap) {
|
|
|
|
if (!*ap)
|
|
|
|
errx(1,
|
|
|
|
"-execdir: no terminating \";\"");
|
|
|
|
if (**ap == ';')
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
cnt = ap - *argvp + 1;
|
|
|
|
new->e_argv = (char **)emalloc((u_int)cnt * sizeof(char *));
|
|
|
|
new->e_orig = (char **)emalloc((u_int)cnt * sizeof(char *));
|
|
|
|
new->e_len = (int *)emalloc((u_int)cnt * sizeof(int));
|
|
|
|
|
|
|
|
for (argv = *argvp, cnt = 0; argv < ap; ++argv, ++cnt) {
|
|
|
|
new->e_orig[cnt] = *argv;
|
|
|
|
for (p = *argv; *p; ++p)
|
|
|
|
if (p[0] == '{' && p[1] == '}') {
|
|
|
|
new->e_argv[cnt] = emalloc((u_int)MAXPATHLEN);
|
|
|
|
new->e_len[cnt] = MAXPATHLEN;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!*p) {
|
|
|
|
new->e_argv[cnt] = *argv;
|
|
|
|
new->e_len[cnt] = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
new->e_argv[cnt] = new->e_orig[cnt] = NULL;
|
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
*argvp = argv + 1;
|
|
|
|
return (new);
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
/*
|
|
|
|
* -follow functions --
|
|
|
|
*
|
|
|
|
* Always true, causes symbolic links to be followed on a global
|
|
|
|
* basis.
|
|
|
|
*/
|
|
|
|
PLAN *
|
|
|
|
c_follow()
|
|
|
|
{
|
|
|
|
ftsoptions &= ~FTS_PHYSICAL;
|
|
|
|
ftsoptions |= FTS_LOGICAL;
|
|
|
|
|
|
|
|
return (palloc(N_FOLLOW, f_always_true));
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
/*
|
|
|
|
* -fstype functions --
|
|
|
|
*
|
|
|
|
* True if the file is of a certain type.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
f_fstype(plan, entry)
|
|
|
|
PLAN *plan;
|
|
|
|
FTSENT *entry;
|
|
|
|
{
|
|
|
|
static dev_t curdev; /* need a guaranteed illegal dev value */
|
|
|
|
static int first = 1;
|
|
|
|
struct statfs sb;
|
1997-03-27 02:36:26 +00:00
|
|
|
static int val_type, val_flags;
|
1994-05-27 12:33:43 +00:00
|
|
|
char *p, save[2];
|
|
|
|
|
|
|
|
/* Only check when we cross mount point. */
|
|
|
|
if (first || curdev != entry->fts_statp->st_dev) {
|
|
|
|
curdev = entry->fts_statp->st_dev;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Statfs follows symlinks; find wants the link's file system,
|
|
|
|
* not where it points.
|
|
|
|
*/
|
|
|
|
if (entry->fts_info == FTS_SL ||
|
|
|
|
entry->fts_info == FTS_SLNONE) {
|
|
|
|
if ((p = strrchr(entry->fts_accpath, '/')) != NULL)
|
|
|
|
++p;
|
|
|
|
else
|
|
|
|
p = entry->fts_accpath;
|
|
|
|
save[0] = p[0];
|
|
|
|
p[0] = '.';
|
|
|
|
save[1] = p[1];
|
|
|
|
p[1] = '\0';
|
1995-05-30 06:41:30 +00:00
|
|
|
|
|
|
|
} else
|
1994-05-27 12:33:43 +00:00
|
|
|
p = NULL;
|
|
|
|
|
|
|
|
if (statfs(entry->fts_accpath, &sb))
|
|
|
|
err(1, "%s", entry->fts_accpath);
|
|
|
|
|
|
|
|
if (p) {
|
|
|
|
p[0] = save[0];
|
|
|
|
p[1] = save[1];
|
|
|
|
}
|
|
|
|
|
|
|
|
first = 0;
|
1997-03-11 13:48:37 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Further tests may need both of these values, so
|
|
|
|
* always copy both of them.
|
|
|
|
*/
|
1997-03-27 02:36:26 +00:00
|
|
|
val_flags = sb.f_flags;
|
|
|
|
val_type = sb.f_type;
|
1994-05-27 12:33:43 +00:00
|
|
|
}
|
1997-03-11 13:48:37 +00:00
|
|
|
switch (plan->flags) {
|
1994-05-27 12:33:43 +00:00
|
|
|
case F_MTFLAG:
|
1997-03-27 02:36:26 +00:00
|
|
|
return (val_flags & plan->mt_data) != 0;
|
1994-05-27 12:33:43 +00:00
|
|
|
case F_MTTYPE:
|
1997-03-27 02:36:26 +00:00
|
|
|
return (val_type == plan->mt_data);
|
1994-05-27 12:33:43 +00:00
|
|
|
default:
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1998-01-10 21:36:34 +00:00
|
|
|
#if !defined(__NetBSD__)
|
1994-05-27 12:33:43 +00:00
|
|
|
PLAN *
|
|
|
|
c_fstype(arg)
|
|
|
|
char *arg;
|
|
|
|
{
|
|
|
|
register PLAN *new;
|
1997-03-11 13:48:37 +00:00
|
|
|
struct vfsconf vfc;
|
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
ftsoptions &= ~FTS_NOSTAT;
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
new = palloc(N_FSTYPE, f_fstype);
|
1997-03-11 13:48:37 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Check first for a filesystem name.
|
|
|
|
*/
|
|
|
|
if (getvfsbyname(arg, &vfc) == 0) {
|
|
|
|
new->flags = F_MTTYPE;
|
|
|
|
new->mt_data = vfc.vfc_typenum;
|
|
|
|
return (new);
|
|
|
|
}
|
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
switch (*arg) {
|
|
|
|
case 'l':
|
|
|
|
if (!strcmp(arg, "local")) {
|
|
|
|
new->flags = F_MTFLAG;
|
|
|
|
new->mt_data = MNT_LOCAL;
|
|
|
|
return (new);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'r':
|
|
|
|
if (!strcmp(arg, "rdonly")) {
|
|
|
|
new->flags = F_MTFLAG;
|
|
|
|
new->mt_data = MNT_RDONLY;
|
|
|
|
return (new);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
errx(1, "%s: unknown file type", arg);
|
|
|
|
/* NOTREACHED */
|
|
|
|
}
|
1998-01-10 21:36:34 +00:00
|
|
|
#endif
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
/*
|
|
|
|
* -group gname functions --
|
|
|
|
*
|
|
|
|
* True if the file belongs to the group gname. If gname is numeric and
|
|
|
|
* an equivalent of the getgrnam() function does not return a valid group
|
|
|
|
* name, gname is taken as a group ID.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
f_group(plan, entry)
|
|
|
|
PLAN *plan;
|
|
|
|
FTSENT *entry;
|
|
|
|
{
|
|
|
|
return (entry->fts_statp->st_gid == plan->g_data);
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
PLAN *
|
|
|
|
c_group(gname)
|
|
|
|
char *gname;
|
|
|
|
{
|
|
|
|
PLAN *new;
|
|
|
|
struct group *g;
|
|
|
|
gid_t gid;
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
ftsoptions &= ~FTS_NOSTAT;
|
|
|
|
|
|
|
|
g = getgrnam(gname);
|
|
|
|
if (g == NULL) {
|
|
|
|
gid = atoi(gname);
|
|
|
|
if (gid == 0 && gname[0] != '0')
|
|
|
|
errx(1, "-group: %s: no such group", gname);
|
|
|
|
} else
|
|
|
|
gid = g->gr_gid;
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
new = palloc(N_GROUP, f_group);
|
|
|
|
new->g_data = gid;
|
|
|
|
return (new);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* -inum n functions --
|
|
|
|
*
|
|
|
|
* True if the file has inode # n.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
f_inum(plan, entry)
|
|
|
|
PLAN *plan;
|
|
|
|
FTSENT *entry;
|
|
|
|
{
|
|
|
|
COMPARE(entry->fts_statp->st_ino, plan->i_data);
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
PLAN *
|
|
|
|
c_inum(arg)
|
|
|
|
char *arg;
|
|
|
|
{
|
|
|
|
PLAN *new;
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
ftsoptions &= ~FTS_NOSTAT;
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
new = palloc(N_INUM, f_inum);
|
|
|
|
new->i_data = find_parsenum(new, "-inum", arg, NULL);
|
|
|
|
return (new);
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
/*
|
|
|
|
* -links n functions --
|
|
|
|
*
|
|
|
|
* True if the file has n links.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
f_links(plan, entry)
|
|
|
|
PLAN *plan;
|
|
|
|
FTSENT *entry;
|
|
|
|
{
|
|
|
|
COMPARE(entry->fts_statp->st_nlink, plan->l_data);
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
PLAN *
|
|
|
|
c_links(arg)
|
|
|
|
char *arg;
|
|
|
|
{
|
|
|
|
PLAN *new;
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
ftsoptions &= ~FTS_NOSTAT;
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
new = palloc(N_LINKS, f_links);
|
|
|
|
new->l_data = (nlink_t)find_parsenum(new, "-links", arg, NULL);
|
|
|
|
return (new);
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
/*
|
|
|
|
* -ls functions --
|
|
|
|
*
|
|
|
|
* Always true - prints the current entry to stdout in "ls" format.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
f_ls(plan, entry)
|
|
|
|
PLAN *plan;
|
|
|
|
FTSENT *entry;
|
|
|
|
{
|
|
|
|
printlong(entry->fts_path, entry->fts_accpath, entry->fts_statp);
|
|
|
|
return (1);
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
PLAN *
|
|
|
|
c_ls()
|
|
|
|
{
|
|
|
|
ftsoptions &= ~FTS_NOSTAT;
|
|
|
|
isoutput = 1;
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
return (palloc(N_LS, f_ls));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* -mtime n functions --
|
|
|
|
*
|
|
|
|
* True if the difference between the file modification time and the
|
|
|
|
* current time is n 24 hour periods.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
f_mtime(plan, entry)
|
|
|
|
PLAN *plan;
|
|
|
|
FTSENT *entry;
|
|
|
|
{
|
|
|
|
extern time_t now;
|
|
|
|
|
1995-08-07 19:17:46 +00:00
|
|
|
COMPARE((now - entry->fts_statp->st_mtime + 86400 - 1) /
|
|
|
|
86400, plan->t_data);
|
1994-05-27 12:33:43 +00:00
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
PLAN *
|
|
|
|
c_mtime(arg)
|
|
|
|
char *arg;
|
|
|
|
{
|
|
|
|
PLAN *new;
|
|
|
|
|
|
|
|
ftsoptions &= ~FTS_NOSTAT;
|
|
|
|
|
|
|
|
new = palloc(N_MTIME, f_mtime);
|
|
|
|
new->t_data = find_parsenum(new, "-mtime", arg, NULL);
|
|
|
|
TIME_CORRECT(new, N_MTIME);
|
|
|
|
return (new);
|
|
|
|
}
|
|
|
|
|
1997-10-13 21:06:22 +00:00
|
|
|
/*
|
|
|
|
* -mmin n functions --
|
|
|
|
*
|
|
|
|
* True if the difference between the file modification time and the
|
|
|
|
* current time is n min periods.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
f_mmin(plan, entry)
|
|
|
|
PLAN *plan;
|
|
|
|
FTSENT *entry;
|
|
|
|
{
|
|
|
|
extern time_t now;
|
|
|
|
|
|
|
|
COMPARE((now - entry->fts_statp->st_mtime + 60 - 1) /
|
|
|
|
60, plan->t_data);
|
|
|
|
}
|
|
|
|
|
|
|
|
PLAN *
|
|
|
|
c_mmin(arg)
|
|
|
|
char *arg;
|
|
|
|
{
|
|
|
|
PLAN *new;
|
|
|
|
|
|
|
|
ftsoptions &= ~FTS_NOSTAT;
|
|
|
|
|
|
|
|
new = palloc(N_MMIN, f_mmin);
|
|
|
|
new->t_data = find_parsenum(new, "-mmin", arg, NULL);
|
|
|
|
TIME_CORRECT(new, N_MMIN);
|
|
|
|
return (new);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
/*
|
|
|
|
* -name functions --
|
|
|
|
*
|
|
|
|
* True if the basename of the filename being examined
|
|
|
|
* matches pattern using Pattern Matching Notation S3.14
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
f_name(plan, entry)
|
|
|
|
PLAN *plan;
|
|
|
|
FTSENT *entry;
|
|
|
|
{
|
|
|
|
return (!fnmatch(plan->c_data, entry->fts_name, 0));
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
PLAN *
|
|
|
|
c_name(pattern)
|
|
|
|
char *pattern;
|
|
|
|
{
|
|
|
|
PLAN *new;
|
|
|
|
|
|
|
|
new = palloc(N_NAME, f_name);
|
|
|
|
new->c_data = pattern;
|
|
|
|
return (new);
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
/*
|
|
|
|
* -newer file functions --
|
|
|
|
*
|
|
|
|
* True if the current file has been modified more recently
|
|
|
|
* then the modification time of the file named by the pathname
|
|
|
|
* file.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
f_newer(plan, entry)
|
|
|
|
PLAN *plan;
|
|
|
|
FTSENT *entry;
|
|
|
|
{
|
|
|
|
return (entry->fts_statp->st_mtime > plan->t_data);
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
PLAN *
|
|
|
|
c_newer(filename)
|
|
|
|
char *filename;
|
|
|
|
{
|
|
|
|
PLAN *new;
|
|
|
|
struct stat sb;
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
ftsoptions &= ~FTS_NOSTAT;
|
|
|
|
|
|
|
|
if (stat(filename, &sb))
|
|
|
|
err(1, "%s", filename);
|
|
|
|
new = palloc(N_NEWER, f_newer);
|
|
|
|
new->t_data = sb.st_mtime;
|
|
|
|
return (new);
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
/*
|
|
|
|
* -nogroup functions --
|
|
|
|
*
|
|
|
|
* True if file belongs to a user ID for which the equivalent
|
|
|
|
* of the getgrnam() 9.2.1 [POSIX.1] function returns NULL.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
f_nogroup(plan, entry)
|
|
|
|
PLAN *plan;
|
|
|
|
FTSENT *entry;
|
|
|
|
{
|
|
|
|
char *group_from_gid();
|
|
|
|
|
|
|
|
return (group_from_gid(entry->fts_statp->st_gid, 1) ? 0 : 1);
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
PLAN *
|
|
|
|
c_nogroup()
|
|
|
|
{
|
|
|
|
ftsoptions &= ~FTS_NOSTAT;
|
|
|
|
|
|
|
|
return (palloc(N_NOGROUP, f_nogroup));
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
/*
|
|
|
|
* -nouser functions --
|
|
|
|
*
|
|
|
|
* True if file belongs to a user ID for which the equivalent
|
|
|
|
* of the getpwuid() 9.2.2 [POSIX.1] function returns NULL.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
f_nouser(plan, entry)
|
|
|
|
PLAN *plan;
|
|
|
|
FTSENT *entry;
|
|
|
|
{
|
|
|
|
char *user_from_uid();
|
|
|
|
|
|
|
|
return (user_from_uid(entry->fts_statp->st_uid, 1) ? 0 : 1);
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
PLAN *
|
|
|
|
c_nouser()
|
|
|
|
{
|
|
|
|
ftsoptions &= ~FTS_NOSTAT;
|
|
|
|
|
|
|
|
return (palloc(N_NOUSER, f_nouser));
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
/*
|
|
|
|
* -path functions --
|
|
|
|
*
|
|
|
|
* True if the path of the filename being examined
|
|
|
|
* matches pattern using Pattern Matching Notation S3.14
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
f_path(plan, entry)
|
|
|
|
PLAN *plan;
|
|
|
|
FTSENT *entry;
|
|
|
|
{
|
|
|
|
return (!fnmatch(plan->c_data, entry->fts_path, 0));
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
PLAN *
|
|
|
|
c_path(pattern)
|
|
|
|
char *pattern;
|
|
|
|
{
|
|
|
|
PLAN *new;
|
|
|
|
|
|
|
|
new = palloc(N_NAME, f_path);
|
|
|
|
new->c_data = pattern;
|
|
|
|
return (new);
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
/*
|
|
|
|
* -perm functions --
|
|
|
|
*
|
|
|
|
* The mode argument is used to represent file mode bits. If it starts
|
|
|
|
* with a leading digit, it's treated as an octal mode, otherwise as a
|
|
|
|
* symbolic mode.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
f_perm(plan, entry)
|
|
|
|
PLAN *plan;
|
|
|
|
FTSENT *entry;
|
|
|
|
{
|
|
|
|
mode_t mode;
|
|
|
|
|
|
|
|
mode = entry->fts_statp->st_mode &
|
|
|
|
(S_ISUID|S_ISGID|S_ISTXT|S_IRWXU|S_IRWXG|S_IRWXO);
|
|
|
|
if (plan->flags == F_ATLEAST)
|
|
|
|
return ((plan->m_data | mode) == mode);
|
|
|
|
else
|
|
|
|
return (mode == plan->m_data);
|
|
|
|
/* NOTREACHED */
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
PLAN *
|
|
|
|
c_perm(perm)
|
|
|
|
char *perm;
|
|
|
|
{
|
|
|
|
PLAN *new;
|
|
|
|
mode_t *set;
|
|
|
|
|
|
|
|
ftsoptions &= ~FTS_NOSTAT;
|
|
|
|
|
|
|
|
new = palloc(N_PERM, f_perm);
|
|
|
|
|
|
|
|
if (*perm == '-') {
|
|
|
|
new->flags = F_ATLEAST;
|
|
|
|
++perm;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((set = setmode(perm)) == NULL)
|
|
|
|
err(1, "-perm: %s: illegal mode string", perm);
|
|
|
|
|
|
|
|
new->m_data = getmode(set, 0);
|
|
|
|
return (new);
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
/*
|
|
|
|
* -print functions --
|
|
|
|
*
|
|
|
|
* Always true, causes the current pathame to be written to
|
|
|
|
* standard output.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
f_print(plan, entry)
|
|
|
|
PLAN *plan;
|
|
|
|
FTSENT *entry;
|
|
|
|
{
|
1995-10-16 18:32:35 +00:00
|
|
|
(void)puts(entry->fts_path);
|
1994-05-27 12:33:43 +00:00
|
|
|
return (1);
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
PLAN *
|
|
|
|
c_print()
|
|
|
|
{
|
|
|
|
isoutput = 1;
|
|
|
|
|
|
|
|
return (palloc(N_PRINT, f_print));
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1995-05-09 19:02:06 +00:00
|
|
|
/*
|
|
|
|
* -print0 functions --
|
|
|
|
*
|
|
|
|
* Always true, causes the current pathame to be written to
|
|
|
|
* standard output followed by a NUL character
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
f_print0(plan, entry)
|
|
|
|
PLAN *plan;
|
|
|
|
FTSENT *entry;
|
|
|
|
{
|
|
|
|
fputs(entry->fts_path, stdout);
|
|
|
|
fputc('\0', stdout);
|
|
|
|
return (1);
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1995-05-09 19:02:06 +00:00
|
|
|
PLAN *
|
|
|
|
c_print0()
|
|
|
|
{
|
|
|
|
isoutput = 1;
|
|
|
|
|
|
|
|
return (palloc(N_PRINT0, f_print0));
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
/*
|
|
|
|
* -prune functions --
|
|
|
|
*
|
|
|
|
* Prune a portion of the hierarchy.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
f_prune(plan, entry)
|
|
|
|
PLAN *plan;
|
|
|
|
FTSENT *entry;
|
|
|
|
{
|
|
|
|
extern FTS *tree;
|
|
|
|
|
|
|
|
if (fts_set(tree, entry, FTS_SKIP))
|
|
|
|
err(1, "%s", entry->fts_path);
|
|
|
|
return (1);
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
PLAN *
|
|
|
|
c_prune()
|
|
|
|
{
|
|
|
|
return (palloc(N_PRUNE, f_prune));
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
/*
|
|
|
|
* -size n[c] functions --
|
|
|
|
*
|
|
|
|
* True if the file size in bytes, divided by an implementation defined
|
|
|
|
* value and rounded up to the next integer, is n. If n is followed by
|
|
|
|
* a c, the size is in bytes.
|
|
|
|
*/
|
|
|
|
#define FIND_SIZE 512
|
|
|
|
static int divsize = 1;
|
|
|
|
|
|
|
|
int
|
|
|
|
f_size(plan, entry)
|
|
|
|
PLAN *plan;
|
|
|
|
FTSENT *entry;
|
|
|
|
{
|
|
|
|
off_t size;
|
|
|
|
|
|
|
|
size = divsize ? (entry->fts_statp->st_size + FIND_SIZE - 1) /
|
|
|
|
FIND_SIZE : entry->fts_statp->st_size;
|
|
|
|
COMPARE(size, plan->o_data);
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
PLAN *
|
|
|
|
c_size(arg)
|
|
|
|
char *arg;
|
|
|
|
{
|
|
|
|
PLAN *new;
|
|
|
|
char endch;
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
ftsoptions &= ~FTS_NOSTAT;
|
|
|
|
|
|
|
|
new = palloc(N_SIZE, f_size);
|
|
|
|
endch = 'c';
|
|
|
|
new->o_data = find_parsenum(new, "-size", arg, &endch);
|
|
|
|
if (endch == 'c')
|
|
|
|
divsize = 0;
|
|
|
|
return (new);
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
/*
|
|
|
|
* -type c functions --
|
|
|
|
*
|
1997-03-11 13:48:37 +00:00
|
|
|
* True if the type of the file is c, where c is b, c, d, p, f or w
|
|
|
|
* for block special file, character special file, directory, FIFO,
|
|
|
|
* regular file or whiteout respectively.
|
1994-05-27 12:33:43 +00:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
f_type(plan, entry)
|
|
|
|
PLAN *plan;
|
|
|
|
FTSENT *entry;
|
|
|
|
{
|
|
|
|
return ((entry->fts_statp->st_mode & S_IFMT) == plan->m_data);
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
PLAN *
|
|
|
|
c_type(typestring)
|
|
|
|
char *typestring;
|
|
|
|
{
|
|
|
|
PLAN *new;
|
|
|
|
mode_t mask;
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
ftsoptions &= ~FTS_NOSTAT;
|
|
|
|
|
|
|
|
switch (typestring[0]) {
|
|
|
|
case 'b':
|
|
|
|
mask = S_IFBLK;
|
|
|
|
break;
|
|
|
|
case 'c':
|
|
|
|
mask = S_IFCHR;
|
|
|
|
break;
|
|
|
|
case 'd':
|
|
|
|
mask = S_IFDIR;
|
|
|
|
break;
|
|
|
|
case 'f':
|
|
|
|
mask = S_IFREG;
|
|
|
|
break;
|
|
|
|
case 'l':
|
|
|
|
mask = S_IFLNK;
|
|
|
|
break;
|
|
|
|
case 'p':
|
|
|
|
mask = S_IFIFO;
|
|
|
|
break;
|
|
|
|
case 's':
|
|
|
|
mask = S_IFSOCK;
|
|
|
|
break;
|
1997-03-11 13:48:37 +00:00
|
|
|
#ifdef FTS_WHITEOUT
|
|
|
|
case 'w':
|
|
|
|
mask = S_IFWHT;
|
|
|
|
ftsoptions |= FTS_WHITEOUT;
|
|
|
|
break;
|
|
|
|
#endif /* FTS_WHITEOUT */
|
1994-05-27 12:33:43 +00:00
|
|
|
default:
|
|
|
|
errx(1, "-type: %s: unknown type", typestring);
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
new = palloc(N_TYPE, f_type);
|
|
|
|
new->m_data = mask;
|
|
|
|
return (new);
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
Implement a -delete option to find. The code is extremely paranoid and
goes to a fair degree of trouble to enable something like this to
be safe: cd /tmp && find . -mtime +7 -delete
It removes both files and directories. It does not attempt to remove
immutable files (an earlier version I showed to a few people did a chflags
and tried to blow away even immutable files. Too risky..)
It is thought to be safe because it forces the fts(3) driven descent to
only do "minimal risk" stuff. specifically, -follow is disabled, it does
checking to see that it chdir'ed to the directory it thought it was
going to, it will *not* pass a pathname with a '/' character in it to
unlink(), so it should be totally immune to symlink tree races. If it runs
into something "fishy", it bails out rather than blunder ahead.. It's better
to do that if somebody is trying to compromise security rather than risk
giving them an opportunity. Since the unlink()/rmdir() is being called
from within the current working directory during the tree descent, there
are no fork/exec overheads or races.
As a side effect of this paranoia, you cannot do a
"find /somewhere/dir -delete", as the last argument to rmdir() is
"/somewhere/dir", and the checking won't allow it. Besides, one would use
rm -rf for that case anyway. :-)
Reviewed by: pst (some time ago, but I've removed the immutable file
deletion code that he complained about since he last saw it)
1996-10-04 12:54:07 +00:00
|
|
|
/*
|
|
|
|
* -delete functions --
|
|
|
|
*
|
|
|
|
* True always. Makes it's best shot and continues on regardless.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
f_delete(plan, entry)
|
|
|
|
PLAN *plan;
|
|
|
|
FTSENT *entry;
|
|
|
|
{
|
|
|
|
/* ignore these from fts */
|
|
|
|
if (strcmp(entry->fts_accpath, ".") == 0 ||
|
|
|
|
strcmp(entry->fts_accpath, "..") == 0)
|
|
|
|
return (1);
|
|
|
|
|
|
|
|
/* sanity check */
|
|
|
|
if (isdepth == 0 || /* depth off */
|
|
|
|
(ftsoptions & FTS_NOSTAT) || /* not stat()ing */
|
|
|
|
!(ftsoptions & FTS_PHYSICAL) || /* physical off */
|
|
|
|
(ftsoptions & FTS_LOGICAL)) /* or finally, logical on */
|
|
|
|
errx(1, "-delete: insecure options got turned on");
|
|
|
|
|
|
|
|
/* Potentially unsafe - do not accept relative paths whatsoever */
|
|
|
|
if (strchr(entry->fts_accpath, '/') != NULL)
|
|
|
|
errx(1, "-delete: %s: relative path potentially not safe",
|
|
|
|
entry->fts_accpath);
|
|
|
|
|
1996-10-05 18:21:05 +00:00
|
|
|
/* Turn off user immutable bits if running as root */
|
|
|
|
if ((entry->fts_statp->st_flags & (UF_APPEND|UF_IMMUTABLE)) &&
|
|
|
|
!(entry->fts_statp->st_flags & (SF_APPEND|SF_IMMUTABLE)) &&
|
|
|
|
geteuid() == 0)
|
|
|
|
chflags(entry->fts_accpath,
|
|
|
|
entry->fts_statp->st_flags &= ~(UF_APPEND|UF_IMMUTABLE));
|
|
|
|
|
Implement a -delete option to find. The code is extremely paranoid and
goes to a fair degree of trouble to enable something like this to
be safe: cd /tmp && find . -mtime +7 -delete
It removes both files and directories. It does not attempt to remove
immutable files (an earlier version I showed to a few people did a chflags
and tried to blow away even immutable files. Too risky..)
It is thought to be safe because it forces the fts(3) driven descent to
only do "minimal risk" stuff. specifically, -follow is disabled, it does
checking to see that it chdir'ed to the directory it thought it was
going to, it will *not* pass a pathname with a '/' character in it to
unlink(), so it should be totally immune to symlink tree races. If it runs
into something "fishy", it bails out rather than blunder ahead.. It's better
to do that if somebody is trying to compromise security rather than risk
giving them an opportunity. Since the unlink()/rmdir() is being called
from within the current working directory during the tree descent, there
are no fork/exec overheads or races.
As a side effect of this paranoia, you cannot do a
"find /somewhere/dir -delete", as the last argument to rmdir() is
"/somewhere/dir", and the checking won't allow it. Besides, one would use
rm -rf for that case anyway. :-)
Reviewed by: pst (some time ago, but I've removed the immutable file
deletion code that he complained about since he last saw it)
1996-10-04 12:54:07 +00:00
|
|
|
/* rmdir directories, unlink everything else */
|
|
|
|
if (S_ISDIR(entry->fts_statp->st_mode)) {
|
1996-10-05 23:47:07 +00:00
|
|
|
if (rmdir(entry->fts_accpath) < 0 && errno != ENOTEMPTY)
|
Implement a -delete option to find. The code is extremely paranoid and
goes to a fair degree of trouble to enable something like this to
be safe: cd /tmp && find . -mtime +7 -delete
It removes both files and directories. It does not attempt to remove
immutable files (an earlier version I showed to a few people did a chflags
and tried to blow away even immutable files. Too risky..)
It is thought to be safe because it forces the fts(3) driven descent to
only do "minimal risk" stuff. specifically, -follow is disabled, it does
checking to see that it chdir'ed to the directory it thought it was
going to, it will *not* pass a pathname with a '/' character in it to
unlink(), so it should be totally immune to symlink tree races. If it runs
into something "fishy", it bails out rather than blunder ahead.. It's better
to do that if somebody is trying to compromise security rather than risk
giving them an opportunity. Since the unlink()/rmdir() is being called
from within the current working directory during the tree descent, there
are no fork/exec overheads or races.
As a side effect of this paranoia, you cannot do a
"find /somewhere/dir -delete", as the last argument to rmdir() is
"/somewhere/dir", and the checking won't allow it. Besides, one would use
rm -rf for that case anyway. :-)
Reviewed by: pst (some time ago, but I've removed the immutable file
deletion code that he complained about since he last saw it)
1996-10-04 12:54:07 +00:00
|
|
|
warn("-delete: rmdir(%s)", entry->fts_path);
|
|
|
|
} else {
|
|
|
|
if (unlink(entry->fts_accpath) < 0)
|
|
|
|
warn("-delete: unlink(%s)", entry->fts_path);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* "succeed" */
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
|
|
|
|
PLAN *
|
|
|
|
c_delete()
|
|
|
|
{
|
|
|
|
|
|
|
|
ftsoptions &= ~FTS_NOSTAT; /* no optimise */
|
|
|
|
ftsoptions |= FTS_PHYSICAL; /* disable -follow */
|
|
|
|
ftsoptions &= ~FTS_LOGICAL; /* disable -follow */
|
|
|
|
isoutput = 1; /* possible output */
|
|
|
|
isdepth = 1; /* -depth implied */
|
|
|
|
|
|
|
|
return (palloc(N_DELETE, f_delete));
|
|
|
|
}
|
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
/*
|
|
|
|
* -user uname functions --
|
|
|
|
*
|
|
|
|
* True if the file belongs to the user uname. If uname is numeric and
|
|
|
|
* an equivalent of the getpwnam() S9.2.2 [POSIX.1] function does not
|
|
|
|
* return a valid user name, uname is taken as a user ID.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
f_user(plan, entry)
|
|
|
|
PLAN *plan;
|
|
|
|
FTSENT *entry;
|
|
|
|
{
|
|
|
|
return (entry->fts_statp->st_uid == plan->u_data);
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
PLAN *
|
|
|
|
c_user(username)
|
|
|
|
char *username;
|
|
|
|
{
|
|
|
|
PLAN *new;
|
|
|
|
struct passwd *p;
|
|
|
|
uid_t uid;
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
ftsoptions &= ~FTS_NOSTAT;
|
|
|
|
|
|
|
|
p = getpwnam(username);
|
|
|
|
if (p == NULL) {
|
|
|
|
uid = atoi(username);
|
|
|
|
if (uid == 0 && username[0] != '0')
|
|
|
|
errx(1, "-user: %s: no such user", username);
|
|
|
|
} else
|
|
|
|
uid = p->pw_uid;
|
|
|
|
|
|
|
|
new = palloc(N_USER, f_user);
|
|
|
|
new->u_data = uid;
|
|
|
|
return (new);
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
/*
|
|
|
|
* -xdev functions --
|
|
|
|
*
|
|
|
|
* Always true, causes find not to decend past directories that have a
|
|
|
|
* different device ID (st_dev, see stat() S5.6.2 [POSIX.1])
|
|
|
|
*/
|
|
|
|
PLAN *
|
|
|
|
c_xdev()
|
|
|
|
{
|
|
|
|
ftsoptions |= FTS_XDEV;
|
|
|
|
|
|
|
|
return (palloc(N_XDEV, f_always_true));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ( expression ) functions --
|
|
|
|
*
|
|
|
|
* True if expression is true.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
f_expr(plan, entry)
|
|
|
|
PLAN *plan;
|
|
|
|
FTSENT *entry;
|
|
|
|
{
|
|
|
|
register PLAN *p;
|
|
|
|
register int state;
|
|
|
|
|
|
|
|
for (p = plan->p_data[0];
|
|
|
|
p && (state = (p->eval)(p, entry)); p = p->next);
|
|
|
|
return (state);
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
/*
|
|
|
|
* N_OPENPAREN and N_CLOSEPAREN nodes are temporary place markers. They are
|
|
|
|
* eliminated during phase 2 of find_formplan() --- the '(' node is converted
|
|
|
|
* to a N_EXPR node containing the expression and the ')' node is discarded.
|
|
|
|
*/
|
|
|
|
PLAN *
|
|
|
|
c_openparen()
|
|
|
|
{
|
|
|
|
return (palloc(N_OPENPAREN, (int (*)())-1));
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
PLAN *
|
|
|
|
c_closeparen()
|
|
|
|
{
|
|
|
|
return (palloc(N_CLOSEPAREN, (int (*)())-1));
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
/*
|
|
|
|
* ! expression functions --
|
|
|
|
*
|
|
|
|
* Negation of a primary; the unary NOT operator.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
f_not(plan, entry)
|
|
|
|
PLAN *plan;
|
|
|
|
FTSENT *entry;
|
|
|
|
{
|
|
|
|
register PLAN *p;
|
|
|
|
register int state;
|
|
|
|
|
|
|
|
for (p = plan->p_data[0];
|
|
|
|
p && (state = (p->eval)(p, entry)); p = p->next);
|
|
|
|
return (!state);
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
PLAN *
|
|
|
|
c_not()
|
|
|
|
{
|
|
|
|
return (palloc(N_NOT, f_not));
|
|
|
|
}
|
1995-05-30 06:41:30 +00:00
|
|
|
|
1994-05-27 12:33:43 +00:00
|
|
|
/*
|
|
|
|
* expression -o expression functions --
|
|
|
|
*
|
|
|
|
* Alternation of primaries; the OR operator. The second expression is
|
|
|
|
* not evaluated if the first expression is true.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
f_or(plan, entry)
|
|
|
|
PLAN *plan;
|
|
|
|
FTSENT *entry;
|
|
|
|
{
|
|
|
|
register PLAN *p;
|
|
|
|
register int state;
|
|
|
|
|
|
|
|
for (p = plan->p_data[0];
|
|
|
|
p && (state = (p->eval)(p, entry)); p = p->next);
|
|
|
|
|
|
|
|
if (state)
|
|
|
|
return (1);
|
|
|
|
|
|
|
|
for (p = plan->p_data[1];
|
|
|
|
p && (state = (p->eval)(p, entry)); p = p->next);
|
|
|
|
return (state);
|
|
|
|
}
|
|
|
|
|
|
|
|
PLAN *
|
|
|
|
c_or()
|
|
|
|
{
|
|
|
|
return (palloc(N_OR, f_or));
|
|
|
|
}
|
|
|
|
|
|
|
|
static PLAN *
|
|
|
|
palloc(t, f)
|
|
|
|
enum ntype t;
|
|
|
|
int (*f) __P((PLAN *, FTSENT *));
|
|
|
|
{
|
|
|
|
PLAN *new;
|
|
|
|
|
|
|
|
if ((new = malloc(sizeof(PLAN))) == NULL)
|
|
|
|
err(1, NULL);
|
|
|
|
new->type = t;
|
|
|
|
new->eval = f;
|
|
|
|
new->flags = 0;
|
|
|
|
new->next = NULL;
|
|
|
|
return (new);
|
|
|
|
}
|