//config: Support the 'find -exec' option for executing commands based upon
//config: the files matched.
//config:
+//config:config FEATURE_FIND_EXEC_PLUS
+//config: bool "Enable -exec ... {} +"
+//config: default y
+//config: depends on FEATURE_FIND_EXEC
+//config: help
+//config: Support the 'find -exec ... {} +' option for executing commands
+//config: for all matched files at once.
+//config: Without this option, -exec + is a synonym for -exec ;
+//config: (IOW: it works correctly, but without expected speedup)
+//config:
//config:config FEATURE_FIND_USER
//config: bool "Enable -user: username/uid matching"
//config: default y
//kbuild:lib-$(CONFIG_FIND) += find.o
//usage:#define find_trivial_usage
-//usage: "[PATH]... [OPTIONS] [ACTIONS]"
+//usage: "[-HL] [PATH]... [OPTIONS] [ACTIONS]"
//usage:#define find_full_usage "\n\n"
//usage: "Search for files and perform actions on them.\n"
//usage: "First failed action stops processing of current file.\n"
//usage: "Defaults: PATH is current directory, action is '-print'\n"
-//usage: "\nOptions:"
-//usage: "\n -follow Follow symlinks"
+//usage: "\n -L,-follow Follow symlinks"
+//usage: "\n -H ...on command line only"
//usage: IF_FEATURE_FIND_XDEV(
//usage: "\n -xdev Don't descend directories on other filesystems"
//usage: )
//usage: "\n -iname PATTERN Case insensitive -name"
//usage: IF_FEATURE_FIND_PATH(
//usage: "\n -path PATTERN Match path to PATTERN"
+//usage: "\n -ipath PATTERN Case insensitive -path"
//usage: )
//usage: IF_FEATURE_FIND_REGEX(
//usage: "\n -regex PATTERN Match path to regex PATTERN"
//usage: "\n -exec CMD ARG ; Run CMD with all instances of {} replaced by"
//usage: "\n file name. Fails if CMD exits with nonzero"
//usage: )
+//usage: IF_FEATURE_FIND_EXEC_PLUS(
+//usage: "\n -exec CMD ARG + Run CMD with {} replaced by list of file names"
+//usage: )
//usage: IF_FEATURE_FIND_DELETE(
//usage: "\n -delete Delete current file/directory. Turns on -depth option"
//usage: )
#include <fnmatch.h>
#include "libbb.h"
+#include "common_bufsiz.h"
#if ENABLE_FEATURE_FIND_REGEX
-#include "xregex.h"
+# include "xregex.h"
+#endif
+/* GNUism: */
+#ifndef FNM_CASEFOLD
+# define FNM_CASEFOLD 0
+#endif
+
+#if 1
+# define dbg(...) ((void)0)
+#else
+# define dbg(...) bb_error_msg(__VA_ARGS__)
#endif
+
/* This is a NOEXEC applet. Be very careful! */
ACTS(print)
ACTS(name, const char *pattern; bool iname;)
-IF_FEATURE_FIND_PATH( ACTS(path, const char *pattern;))
+IF_FEATURE_FIND_PATH( ACTS(path, const char *pattern; bool ipath;))
IF_FEATURE_FIND_REGEX( ACTS(regex, regex_t compiled_pattern;))
IF_FEATURE_FIND_PRINT0( ACTS(print0))
IF_FEATURE_FIND_TYPE( ACTS(type, int type_mask;))
IF_FEATURE_FIND_PAREN( ACTS(paren, action ***subexpr;))
IF_FEATURE_FIND_PRUNE( ACTS(prune))
IF_FEATURE_FIND_DELETE( ACTS(delete))
-IF_FEATURE_FIND_EXEC( ACTS(exec, char **exec_argv; unsigned *subst_count; int exec_argc;))
+IF_FEATURE_FIND_EXEC( ACTS(exec,
+ char **exec_argv; /* -exec ARGS */
+ unsigned *subst_count;
+ int exec_argc; /* count of ARGS */
+ IF_FEATURE_FIND_EXEC_PLUS(
+ /*
+ * filelist is NULL if "exec ;"
+ * non-NULL if "exec +"
+ */
+ char **filelist;
+ int filelist_idx;
+ int file_len;
+ )
+ ))
IF_FEATURE_FIND_GROUP( ACTS(group, gid_t gid;))
IF_FEATURE_FIND_LINKS( ACTS(links, char links_char; int links_count;))
smallint need_print;
smallint xdev_on;
recurse_flags_t recurse_flags;
+ IF_FEATURE_FIND_EXEC_PLUS(unsigned max_argv_len;)
} FIX_ALIASING;
-#define G (*(struct globals*)&bb_common_bufsiz1)
+#define G (*(struct globals*)bb_common_bufsiz1)
#define INIT_G() do { \
- struct G_sizecheck { \
- char G_sizecheck[sizeof(G) > COMMON_BUFSIZE ? -1 : 1]; \
- }; \
+ setup_common_bufsiz(); \
+ BUILD_BUG_ON(sizeof(G) > COMMON_BUFSIZE); \
/* we have to zero it out because of NOEXEC */ \
memset(&G, 0, sizeof(G)); \
IF_FEATURE_FIND_MAXDEPTH(G.minmaxdepth[1] = INT_MAX;) \
+ IF_FEATURE_FIND_EXEC_PLUS(G.max_argv_len = bb_arg_max() - 2048;) \
G.need_print = 1; \
G.recurse_flags = ACTION_RECURSE; \
} while (0)
-#if ENABLE_FEATURE_FIND_EXEC
-static unsigned count_subst(const char *str)
-{
- unsigned count = 0;
- while ((str = strstr(str, "{}")) != NULL) {
- count++;
- str++;
- }
- return count;
-}
-
-
-static char* subst(const char *src, unsigned count, const char* filename)
-{
- char *buf, *dst, *end;
- size_t flen = strlen(filename);
- /* we replace each '{}' with filename: growth by strlen-2 */
- buf = dst = xmalloc(strlen(src) + count*(flen-2) + 1);
- while ((end = strstr(src, "{}"))) {
- memcpy(dst, src, end - src);
- dst += end - src;
- src = end + 2;
- memcpy(dst, filename, flen);
- dst += flen;
- }
- strcpy(dst, src);
- return buf;
-}
-#endif
-
/* Return values of ACTFs ('action functions') are a bit mask:
* bit 1=1: prune (use SKIP constant for setting it)
* bit 0=1: matched successfully (TRUE)
#if ENABLE_FEATURE_FIND_NOT
if (ap->invert) rc ^= TRUE;
#endif
+ dbg("grp %d action %d rc:0x%x", cur_group, cur_action, rc);
if (rc & TRUE) /* current group failed, try next */
break;
}
}
+ dbg("returning:0x%x", rc ^ TRUE);
return rc ^ TRUE; /* restore TRUE bit */
}
+#if !FNM_CASEFOLD
+static char *strcpy_upcase(char *dst, const char *src)
+{
+ char *d = dst;
+ while (1) {
+ unsigned char ch = *src++;
+ if (ch >= 'a' && ch <= 'z')
+ ch -= ('a' - 'A');
+ *d++ = ch;
+ if (ch == '\0')
+ break;
+ }
+ return dst;
+}
+#endif
ACTF(name)
{
* but somewhere between 4.1.20 and 4.4.0 GNU find stopped using it.
* find -name '*foo' should match .foo too:
*/
+#if FNM_CASEFOLD
return fnmatch(ap->pattern, tmp, (ap->iname ? FNM_CASEFOLD : 0)) == 0;
+#else
+ if (ap->iname)
+ tmp = strcpy_upcase(alloca(strlen(tmp) + 1), tmp);
+ return fnmatch(ap->pattern, tmp, 0) == 0;
+#endif
}
#if ENABLE_FEATURE_FIND_PATH
ACTF(path)
{
+# if FNM_CASEFOLD
+ return fnmatch(ap->pattern, fileName, (ap->ipath ? FNM_CASEFOLD : 0)) == 0;
+# else
+ if (ap->ipath)
+ fileName = strcpy_upcase(alloca(strlen(fileName) + 1), fileName);
return fnmatch(ap->pattern, fileName, 0) == 0;
+# endif
}
#endif
#if ENABLE_FEATURE_FIND_REGEX
#if ENABLE_FEATURE_FIND_PERM
ACTF(perm)
{
- /* -perm +mode: at least one of perm_mask bits are set */
- if (ap->perm_char == '+')
+ /* -perm [+/]mode: at least one of perm_mask bits are set */
+ if (ap->perm_char == '+' || ap->perm_char == '/')
return (statbuf->st_mode & ap->perm_mask) != 0;
/* -perm -mode: all of perm_mask are set */
if (ap->perm_char == '-')
}
#endif
#if ENABLE_FEATURE_FIND_EXEC
-ACTF(exec)
+static int do_exec(action_exec *ap, const char *fileName)
{
int i, rc;
-#if ENABLE_USE_PORTABLE_CODE
- char **argv = alloca(sizeof(char*) * (ap->exec_argc + 1));
-#else /* gcc 4.3.1 generates smaller code: */
- char *argv[ap->exec_argc + 1];
-#endif
- for (i = 0; i < ap->exec_argc; i++)
- argv[i] = subst(ap->exec_argv[i], ap->subst_count[i], fileName);
- argv[i] = NULL; /* terminate the list */
+# if ENABLE_FEATURE_FIND_EXEC_PLUS
+ int size = ap->exec_argc + ap->filelist_idx + 1;
+# else
+ int size = ap->exec_argc + 1;
+# endif
+# if ENABLE_USE_PORTABLE_CODE
+ char **argv = alloca(sizeof(char*) * size);
+# else /* gcc 4.3.1 generates smaller code: */
+ char *argv[size];
+# endif
+ char **pp = argv;
+
+ for (i = 0; i < ap->exec_argc; i++) {
+ const char *arg = ap->exec_argv[i];
+
+# if ENABLE_FEATURE_FIND_EXEC_PLUS
+ if (ap->filelist) {
+ /* Handling "-exec +"
+ * Only one exec_argv[i] has substitution in it.
+ * Expand that one exec_argv[i] into file list.
+ */
+ if (ap->subst_count[i] == 0) {
+ *pp++ = xstrdup(arg);
+ } else {
+ int j = 0;
+ while (ap->filelist[j]) {
+ /* 2nd arg here should be ap->subst_count[i], but it is always 1: */
+ *pp++ = xmalloc_substitute_string(arg, 1, "{}", ap->filelist[j]);
+ free(ap->filelist[j]);
+ j++;
+ }
+ }
+ } else
+# endif
+ {
+ /* Handling "-exec ;" */
+ *pp++ = xmalloc_substitute_string(arg, ap->subst_count[i], "{}", fileName);
+ }
+ }
+ *pp = NULL; /* terminate the list */
+
+# if ENABLE_FEATURE_FIND_EXEC_PLUS
+ if (ap->filelist) {
+ ap->filelist[0] = NULL;
+ ap->filelist_idx = 0;
+ ap->file_len = 0;
+ }
+# endif
rc = spawn_and_wait(argv);
if (rc < 0)
free(argv[i++]);
return rc == 0; /* return 1 if exitcode 0 */
}
+ACTF(exec)
+{
+# if ENABLE_FEATURE_FIND_EXEC_PLUS
+ if (ap->filelist) {
+ int rc;
+
+ ap->filelist = xrealloc_vector(ap->filelist, 8, ap->filelist_idx);
+ ap->filelist[ap->filelist_idx++] = xstrdup(fileName);
+ ap->file_len += strlen(fileName) + sizeof(char*) + 1;
+ /* If we have lots of files already, exec the command */
+ rc = 1;
+ if (ap->file_len >= G.max_argv_len)
+ rc = do_exec(ap, NULL);
+ return rc;
+ }
+# endif
+ return do_exec(ap, fileName);
+}
+# if ENABLE_FEATURE_FIND_EXEC_PLUS
+static int flush_exec_plus(void)
+{
+ action *ap;
+ action **app;
+ action ***appp = G.actions;
+ while ((app = *appp++) != NULL) {
+ while ((ap = *app++) != NULL) {
+ if (ap->f == (action_fp)func_exec) {
+ action_exec *ae = (void*)ap;
+ if (ae->filelist_idx != 0) {
+ int rc = do_exec(ae, NULL);
+# if ENABLE_FEATURE_FIND_NOT
+ if (ap->invert) rc = !rc;
+# endif
+ if (rc == 0)
+ return 1;
+ }
+ }
+ }
+ }
+ return 0;
+}
+# endif
#endif
#if ENABLE_FEATURE_FIND_USER
ACTF(user)
{
int rc;
if (S_ISDIR(statbuf->st_mode)) {
- rc = rmdir(fileName);
+ /* "find . -delete" skips rmdir(".") */
+ rc = 0;
+ if (NOT_LONE_CHAR(fileName, '.'))
+ rc = rmdir(fileName);
} else {
rc = unlink(fileName);
}
int depth IF_NOT_FEATURE_FIND_MAXDEPTH(UNUSED_PARAM))
{
int r;
+ int same_fs = 1;
+
+#if ENABLE_FEATURE_FIND_XDEV
+ if (S_ISDIR(statbuf->st_mode) && G.xdev_count) {
+ int i;
+ for (i = 0; i < G.xdev_count; i++) {
+ if (G.xdev_dev[i] == statbuf->st_dev)
+ goto found;
+ }
+ //bb_error_msg("'%s': not same fs", fileName);
+ same_fs = 0;
+ found: ;
+ }
+#endif
#if ENABLE_FEATURE_FIND_MAXDEPTH
- if (depth < G.minmaxdepth[0])
- return TRUE; /* skip this, continue recursing */
+ if (depth < G.minmaxdepth[0]) {
+ if (same_fs)
+ return TRUE; /* skip this, continue recursing */
+ return SKIP; /* stop recursing */
+ }
if (depth > G.minmaxdepth[1])
return SKIP; /* stop recursing */
#endif
return SKIP;
}
#endif
-#if ENABLE_FEATURE_FIND_XDEV
/* -xdev stops on mountpoints, but AFTER mountpoit itself
* is processed as usual */
- if (S_ISDIR(statbuf->st_mode)) {
- if (G.xdev_count) {
- int i;
- for (i = 0; i < G.xdev_count; i++) {
- if (G.xdev_dev[i] == statbuf->st_dev)
- goto found;
- }
- return SKIP;
- found: ;
- }
+ if (!same_fs) {
+ return SKIP;
}
-#endif
/* Cannot return 0: our caller, recursive_action(),
* will perror() and skip dirs (if called on dir) */
mask = S_IFSOCK;
if (mask == 0 || type[1] != '\0')
- bb_error_msg_and_die(bb_msg_invalid_arg, type, "-type");
+ bb_error_msg_and_die(bb_msg_invalid_arg_to, type, "-type");
return mask;
}
}
#endif
+/* Say no to GCCism */
+#define USE_NESTED_FUNCTION 0
+
+#if !USE_NESTED_FUNCTION
+struct pp_locals {
+ action*** appp;
+ unsigned cur_group;
+ unsigned cur_action;
+ IF_FEATURE_FIND_NOT( bool invert_flag; )
+};
+static action* alloc_action(struct pp_locals *ppl, int sizeof_struct, action_fp f)
+{
+ action *ap = xzalloc(sizeof_struct);
+ action **app;
+ action ***group = &ppl->appp[ppl->cur_group];
+ *group = app = xrealloc(*group, (ppl->cur_action+2) * sizeof(ppl->appp[0][0]));
+ app[ppl->cur_action++] = ap;
+ app[ppl->cur_action] = NULL;
+ ap->f = f;
+ IF_FEATURE_FIND_NOT( ap->invert = ppl->invert_flag; )
+ IF_FEATURE_FIND_NOT( ppl->invert_flag = 0; )
+ return ap;
+}
+#endif
+
static action*** parse_params(char **argv)
{
enum {
PARM_name ,
PARM_iname ,
IF_FEATURE_FIND_PATH( PARM_path ,)
+#if ENABLE_DESKTOP
+ /* -wholename is a synonym for -path */
+ /* We support it because Linux kernel's "make tags" uses it */
+ IF_FEATURE_FIND_PATH( PARM_wholename ,)
+#endif
+ IF_FEATURE_FIND_PATH( PARM_ipath ,)
IF_FEATURE_FIND_REGEX( PARM_regex ,)
IF_FEATURE_FIND_TYPE( PARM_type ,)
IF_FEATURE_FIND_PERM( PARM_perm ,)
IF_FEATURE_FIND_EXEC( "-exec\0" )
IF_FEATURE_FIND_PAREN( "(\0" )
/* All options/actions starting from here require argument */
- "-name\0"
- "-iname\0"
+ "-name\0"
+ "-iname\0"
IF_FEATURE_FIND_PATH( "-path\0" )
+#if ENABLE_DESKTOP
+ IF_FEATURE_FIND_PATH( "-wholename\0")
+#endif
+ IF_FEATURE_FIND_PATH( "-ipath\0" )
IF_FEATURE_FIND_REGEX( "-regex\0" )
IF_FEATURE_FIND_TYPE( "-type\0" )
IF_FEATURE_FIND_PERM( "-perm\0" )
IF_FEATURE_FIND_MAXDEPTH("-mindepth\0""-maxdepth\0")
;
+#if !USE_NESTED_FUNCTION
+ struct pp_locals ppl;
+#define appp (ppl.appp )
+#define cur_group (ppl.cur_group )
+#define cur_action (ppl.cur_action )
+#define invert_flag (ppl.invert_flag)
+#define ALLOC_ACTION(name) (action_##name*)alloc_action(&ppl, sizeof(action_##name), (action_fp) func_##name)
+#else
action*** appp;
- unsigned cur_group = 0;
- unsigned cur_action = 0;
- IF_FEATURE_FIND_NOT( bool invert_flag = 0; )
+ unsigned cur_group;
+ unsigned cur_action;
+ IF_FEATURE_FIND_NOT( bool invert_flag; )
/* This is the only place in busybox where we use nested function.
* So far more standard alternatives were bigger. */
action* alloc_action(int sizeof_struct, action_fp f)
{
action *ap;
- appp[cur_group] = xrealloc(appp[cur_group], (cur_action+2) * sizeof(*appp));
+ appp[cur_group] = xrealloc(appp[cur_group], (cur_action+2) * sizeof(appp[0][0]));
appp[cur_group][cur_action++] = ap = xzalloc(sizeof_struct);
appp[cur_group][cur_action] = NULL;
ap->f = f;
IF_FEATURE_FIND_NOT( invert_flag = 0; )
return ap;
}
-
#define ALLOC_ACTION(name) (action_##name*)alloc_action(sizeof(action_##name), (action_fp) func_##name)
+#endif
+ cur_group = 0;
+ cur_action = 0;
+ IF_FEATURE_FIND_NOT( invert_flag = 0; )
appp = xzalloc(2 * sizeof(appp[0])); /* appp[0],[1] == NULL */
while (*argv) {
int parm = index_in_strings(params, arg);
const char *arg1 = argv[1];
+ dbg("arg:'%s' arg1:'%s' parm:%d PARM_type:%d", arg, arg1, parm, PARM_type);
+
if (parm >= PARM_name) {
/* All options/actions starting from -name require argument */
if (!arg1)
* expression is reached.
*/
/* Options */
+ if (parm == OPT_FOLLOW) {
+ dbg("follow enabled: %d", __LINE__);
+ G.recurse_flags |= ACTION_FOLLOWLINKS | ACTION_DANGLING_OK;
+ }
#if ENABLE_FEATURE_FIND_XDEV
- if (parm == OPT_XDEV) {
+ else if (parm == OPT_XDEV) {
+ dbg("%d", __LINE__);
G.xdev_on = 1;
}
#endif
#if ENABLE_FEATURE_FIND_MAXDEPTH
else if (parm == OPT_MINDEPTH || parm == OPT_MINDEPTH + 1) {
+ dbg("%d", __LINE__);
G.minmaxdepth[parm - OPT_MINDEPTH] = xatoi_positive(arg1);
}
#endif
#if ENABLE_FEATURE_FIND_DEPTH
else if (parm == OPT_DEPTH) {
+ dbg("%d", __LINE__);
G.recurse_flags |= ACTION_DEPTHFIRST;
}
#endif
*/
/* Operators */
else if (parm == PARM_a IF_DESKTOP(|| parm == PARM_and)) {
+ dbg("%d", __LINE__);
/* no further special handling required */
}
else if (parm == PARM_o IF_DESKTOP(|| parm == PARM_or)) {
+ dbg("%d", __LINE__);
/* start new OR group */
cur_group++;
- appp = xrealloc(appp, (cur_group+2) * sizeof(*appp));
+ appp = xrealloc(appp, (cur_group+2) * sizeof(appp[0]));
/*appp[cur_group] = NULL; - already NULL */
appp[cur_group+1] = NULL;
cur_action = 0;
else if (parm == PARM_char_not IF_DESKTOP(|| parm == PARM_not)) {
/* also handles "find ! ! -name 'foo*'" */
invert_flag ^= 1;
+ dbg("invert_flag:%d", invert_flag);
}
#endif
/* Actions */
else if (parm == PARM_print) {
+ dbg("%d", __LINE__);
G.need_print = 0;
(void) ALLOC_ACTION(print);
}
#if ENABLE_FEATURE_FIND_PRINT0
else if (parm == PARM_print0) {
+ dbg("%d", __LINE__);
G.need_print = 0;
(void) ALLOC_ACTION(print0);
}
#endif
#if ENABLE_FEATURE_FIND_PRUNE
else if (parm == PARM_prune) {
+ dbg("%d", __LINE__);
(void) ALLOC_ACTION(prune);
}
#endif
#if ENABLE_FEATURE_FIND_DELETE
else if (parm == PARM_delete) {
+ dbg("%d", __LINE__);
G.need_print = 0;
G.recurse_flags |= ACTION_DEPTHFIRST;
(void) ALLOC_ACTION(delete);
else if (parm == PARM_exec) {
int i;
action_exec *ap;
+ IF_FEATURE_FIND_EXEC_PLUS(int all_subst = 0;)
+ dbg("%d", __LINE__);
G.need_print = 0;
ap = ALLOC_ACTION(exec);
ap->exec_argv = ++argv; /* first arg after -exec */
// executes "echo Foo >FILENAME<",
// find -exec echo Foo ">{}<" "+"
// executes "echo Foo FILENAME1 FILENAME2 FILENAME3...".
- // TODO (so far we treat "+" just like ";")
if ((argv[0][0] == ';' || argv[0][0] == '+')
&& argv[0][1] == '\0'
) {
+# if ENABLE_FEATURE_FIND_EXEC_PLUS
+ if (argv[0][0] == '+')
+ ap->filelist = xzalloc(sizeof(ap->filelist[0]));
+# endif
break;
}
argv++;
bb_error_msg_and_die(bb_msg_requires_arg, arg);
ap->subst_count = xmalloc(ap->exec_argc * sizeof(int));
i = ap->exec_argc;
- while (i--)
- ap->subst_count[i] = count_subst(ap->exec_argv[i]);
+ while (i--) {
+ ap->subst_count[i] = count_strstr(ap->exec_argv[i], "{}");
+ IF_FEATURE_FIND_EXEC_PLUS(all_subst += ap->subst_count[i];)
+ }
+# if ENABLE_FEATURE_FIND_EXEC_PLUS
+ /*
+ * coreutils expects {} to appear only once in "-exec +"
+ */
+ if (all_subst != 1 && ap->filelist)
+ bb_error_msg_and_die("only one '{}' allowed for -exec +");
+# endif
}
#endif
#if ENABLE_FEATURE_FIND_PAREN
char **endarg;
unsigned nested = 1;
+ dbg("%d", __LINE__);
endarg = argv;
while (1) {
if (!*++endarg)
#endif
else if (parm == PARM_name || parm == PARM_iname) {
action_name *ap;
+ dbg("%d", __LINE__);
ap = ALLOC_ACTION(name);
ap->pattern = arg1;
ap->iname = (parm == PARM_iname);
}
#if ENABLE_FEATURE_FIND_PATH
- else if (parm == PARM_path) {
+ else if (parm == PARM_path IF_DESKTOP(|| parm == PARM_wholename) || parm == PARM_ipath) {
action_path *ap;
+ dbg("%d", __LINE__);
ap = ALLOC_ACTION(path);
ap->pattern = arg1;
+ ap->ipath = (parm == PARM_ipath);
}
#endif
#if ENABLE_FEATURE_FIND_REGEX
else if (parm == PARM_regex) {
action_regex *ap;
+ dbg("%d", __LINE__);
ap = ALLOC_ACTION(regex);
xregcomp(&ap->compiled_pattern, arg1, 0 /*cflags*/);
}
action_type *ap;
ap = ALLOC_ACTION(type);
ap->type_mask = find_type(arg1);
+ dbg("created:type mask:%x", ap->type_mask);
}
#endif
#if ENABLE_FEATURE_FIND_PERM
/* -perm BITS File's mode bits are exactly BITS (octal or symbolic).
* Symbolic modes use mode 0 as a point of departure.
* -perm -BITS All of the BITS are set in file's mode.
- * -perm +BITS At least one of the BITS is set in file's mode.
+ * -perm [+/]BITS At least one of the BITS is set in file's mode.
*/
else if (parm == PARM_perm) {
action_perm *ap;
+ dbg("%d", __LINE__);
ap = ALLOC_ACTION(perm);
ap->perm_char = arg1[0];
- arg1 = plus_minus_num(arg1);
+ arg1 = (arg1[0] == '/' ? arg1+1 : plus_minus_num(arg1));
/*ap->perm_mask = 0; - ALLOC_ACTION did it */
- if (!bb_parse_mode(arg1, &ap->perm_mask))
+ ap->perm_mask = bb_parse_mode(arg1, ap->perm_mask);
+ if (ap->perm_mask == (mode_t)-1)
bb_error_msg_and_die("invalid mode '%s'", arg1);
}
#endif
#if ENABLE_FEATURE_FIND_MTIME
else if (parm == PARM_mtime) {
action_mtime *ap;
+ dbg("%d", __LINE__);
ap = ALLOC_ACTION(mtime);
ap->mtime_char = arg1[0];
ap->mtime_days = xatoul(plus_minus_num(arg1));
#if ENABLE_FEATURE_FIND_MMIN
else if (parm == PARM_mmin) {
action_mmin *ap;
+ dbg("%d", __LINE__);
ap = ALLOC_ACTION(mmin);
ap->mmin_char = arg1[0];
ap->mmin_mins = xatoul(plus_minus_num(arg1));
else if (parm == PARM_newer) {
struct stat stat_newer;
action_newer *ap;
+ dbg("%d", __LINE__);
ap = ALLOC_ACTION(newer);
xstat(arg1, &stat_newer);
ap->newer_mtime = stat_newer.st_mtime;
#if ENABLE_FEATURE_FIND_INUM
else if (parm == PARM_inum) {
action_inum *ap;
+ dbg("%d", __LINE__);
ap = ALLOC_ACTION(inum);
ap->inode_num = xatoul(arg1);
}
#if ENABLE_FEATURE_FIND_USER
else if (parm == PARM_user) {
action_user *ap;
+ dbg("%d", __LINE__);
ap = ALLOC_ACTION(user);
ap->uid = bb_strtou(arg1, NULL, 10);
if (errno)
#if ENABLE_FEATURE_FIND_GROUP
else if (parm == PARM_group) {
action_group *ap;
+ dbg("%d", __LINE__);
ap = ALLOC_ACTION(group);
ap->gid = bb_strtou(arg1, NULL, 10);
if (errno)
{ "", 0 }
};
action_size *ap;
+ dbg("%d", __LINE__);
ap = ALLOC_ACTION(size);
ap->size_char = arg1[0];
ap->size = XATOU_SFX(plus_minus_num(arg1), find_suffixes);
#if ENABLE_FEATURE_FIND_CONTEXT
else if (parm == PARM_context) {
action_context *ap;
+ dbg("%d", __LINE__);
ap = ALLOC_ACTION(context);
/*ap->context = NULL; - ALLOC_ACTION did it */
/* SELinux headers erroneously declare non-const parameter */
#if ENABLE_FEATURE_FIND_LINKS
else if (parm == PARM_links) {
action_links *ap;
+ dbg("%d", __LINE__);
ap = ALLOC_ACTION(links);
ap->links_char = arg1[0];
ap->links_count = xatoul(plus_minus_num(arg1));
}
argv++;
}
+ dbg("exiting %s", __func__);
return appp;
#undef ALLOC_ACTION
+#undef appp
+#undef cur_action
+#undef invert_flag
}
int find_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
int find_main(int argc UNUSED_PARAM, char **argv)
{
int i, firstopt, status = EXIT_SUCCESS;
+ char **past_HLP, *saved;
INIT_G();
- argv++;
+ /* "find -type f" + getopt("+HLP") => disaster.
+ * Need to avoid getopt running into a non-HLP option.
+ * Do this by temporarily storing NULL there:
+ */
+ past_HLP = argv;
+ for (;;) {
+ saved = *++past_HLP;
+ if (!saved)
+ break;
+ if (saved[0] != '-')
+ break;
+ if (!saved[1])
+ break; /* it is "-" */
+ if ((saved+1)[strspn(saved+1, "HLP")] != '\0')
+ break;
+ }
+ *past_HLP = NULL;
+ /* "+": stop on first non-option */
+ i = getopt32(argv, "+HLP");
+ if (i & (1<<0))
+ G.recurse_flags |= ACTION_FOLLOWLINKS_L0 | ACTION_DANGLING_OK;
+ if (i & (1<<1))
+ G.recurse_flags |= ACTION_FOLLOWLINKS | ACTION_DANGLING_OK;
+ /* -P is default and is ignored */
+ argv = past_HLP; /* same result as "argv += optind;" */
+ *past_HLP = saved;
+
for (firstopt = 0; argv[firstopt]; firstopt++) {
if (argv[firstopt][0] == '-')
break;
NULL, /* user data */
0) /* depth */
) {
- status = EXIT_FAILURE;
+ status |= EXIT_FAILURE;
}
}
+ IF_FEATURE_FIND_EXEC_PLUS(status |= flush_exec_plus();)
return status;
}
projects / oweals / busybox.git / blobdiff