Changeset 3621 in MondoRescue for branches/3.3/mindi-busybox/findutils/xargs.c

Timestamp:

Dec 20, 2016, 4:07:32 PM (7 years ago)

Author:

Bruno Cornec

Message:

New 3?3 banch for incorporation of latest busybox 1.25. Changing minor version to handle potential incompatibilities.

Location:

branches/3.3

Files:

• . (copied) (copied from branches/3.2 )
• mindi-busybox/findutils/xargs.c (modified) (16 diffs)

branches/3.3/mindi-busybox/findutils/xargs.c

@@ -54 +54 @@
 //config:     instead of whitespace, and the quotes and backslash
 //config:     are not special.
+//config:
+//config:config FEATURE_XARGS_SUPPORT_REPL_STR
+//config:   bool "Enable -I STR: string to replace"
+//config:   default y
+//config:   depends on XARGS
+//config:   help
+//config:     Support -I STR and -i[STR] options.
 
 //applet:IF_XARGS(APPLET_NOEXEC(xargs, xargs, BB_DIR_USR_BIN, BB_SUID_DROP, xargs))
@@ -60 +67 @@
 
 #include "libbb.h"
+#include "common_bufsiz.h"
 
 /* This is a NOEXEC applet. Be very careful! */
@@ -86 +94 @@
 struct globals {
     char **args;
+#if ENABLE_FEATURE_XARGS_SUPPORT_REPL_STR
+    char **argv;
+    const char *repl_str;
+    char eol_ch;
+#endif
     const char *eof_str;
     int idx;
 } FIX_ALIASING;
-#define G (*(struct globals*)&bb_common_bufsiz1)
+#define G (*(struct globals*)bb_common_bufsiz1)
 #define INIT_G() do { \
+    setup_common_bufsiz(); \
     G.eof_str = NULL; /* need to clear by hand because we are NOEXEC applet */ \
+    IF_FEATURE_XARGS_SUPPORT_REPL_STR(G.repl_str = "{}";) \
+    IF_FEATURE_XARGS_SUPPORT_REPL_STR(G.eol_ch = '\n';) \
 } while (0)
 
 
-/*
- * This function has special algorithm.
- * Don't use fork and include to main!
- */
 static int xargs_exec(void)
 {
@@ -113 +125 @@
     }
     if (status >= 0x180) {
-        bb_error_msg("%s: terminated by signal %d",
+        bb_error_msg("'%s' terminated by signal %d",
             G.args[0], status - 0x180);
         return 125;
@@ -142 +154 @@
  * If reading discovers that last chars do not form the complete
  * parameter, the pointer to the first such "tail character" is returned.
- * (buf has extra byte at the end to accomodate terminating NUL
+ * (buf has extra byte at the end to accommodate terminating NUL
  * of "tail characters" string).
  * Otherwise, the returned pointer points to NUL byte.
@@ -302 +314 @@
         }
         *p++ = c;
-        if (c == '\0') {   /* word's delimiter or EOF detected */
+        if (c == '\0') {   /* NUL or EOF detected */
             /* A full word is loaded */
             store_param(s);
@@ -324 +336 @@
 #endif /* FEATURE_XARGS_SUPPORT_ZERO_TERM */
 
+#if ENABLE_FEATURE_XARGS_SUPPORT_REPL_STR
+/*
+ * Used if -I<repl> was specified.
+ * In this mode, words aren't appended to PROG ARGS.
+ * Instead, entire input line is read, then <repl> string
+ * in every PROG and ARG is replaced with the line:
+ *  echo -e "ho ho\nhi" | xargs -I_ cmd __ _
+ * results in "cmd 'ho hoho ho' 'ho ho'"; "cmd 'hihi' 'hi'".
+ * -n MAX_ARGS seems to be ignored.
+ * Tested with GNU findutils 4.5.10.
+ */
+//FIXME: n_max_chars is not handled the same way as in GNU findutils.
+//FIXME: quoting is not implemented.
+static char* FAST_FUNC process_stdin_with_replace(int n_max_chars, int n_max_arg UNUSED_PARAM, char *buf)
+{
+    int i;
+    char *end, *p;
+
+    /* Free strings from last invocation, if any */
+    for (i = 0; G.args && G.args[i]; i++)
+        if (G.args[i] != G.argv[i])
+            free(G.args[i]);
+
+    end = buf + n_max_chars;
+    p = buf;
+
+    while (1) {
+        int c = getchar();
+        if (c == EOF || c == G.eol_ch) {
+            if (p == buf)
+                goto ret; /* empty line */
+            c = '\0';
+        }
+        *p++ = c;
+        if (c == '\0') {   /* EOL or EOF detected */
+            i = 0;
+            while (G.argv[i]) {
+                char *arg = G.argv[i];
+                int count = count_strstr(arg, G.repl_str);
+                if (count != 0)
+                    arg = xmalloc_substitute_string(arg, count, G.repl_str, buf);
+                store_param(arg);
+                dbg_msg("args[]:'%s'", arg);
+                i++;
+            }
+            p = buf;
+            goto ret;
+        }
+        if (p == end) {
+            goto ret;
+        }
+    }
+ ret:
+    *p = '\0';
+    /* store_param(NULL) - caller will do it */
+    dbg_msg("return:'%s'", buf);
+    return buf;
+}
+#endif
+
 #if ENABLE_FEATURE_XARGS_SUPPORT_CONFIRMATION
 /* Prompt the user for a response, and
-   if the user responds affirmatively, return true;
-   otherwise, return false. Uses "/dev/tty", not stdin. */
+ * if user responds affirmatively, return true;
+ * otherwise, return false. Uses "/dev/tty", not stdin.
+ */
 static int xargs_ask_confirmation(void)
 {
@@ -361 +434 @@
 //usage:     "\n    -n N    Pass no more than N args to PROG"
 //usage:     "\n    -s N    Pass command line of no more than N bytes"
+//usage:    IF_FEATURE_XARGS_SUPPORT_REPL_STR(
+//usage:     "\n    -I STR  Replace STR within PROG ARGS with input line"
+//usage:    )
 //usage:    IF_FEATURE_XARGS_SUPPORT_TERMOPT(
 //usage:     "\n    -x  Exit if size is exceeded"
@@ -379 +455 @@
     IF_FEATURE_XARGS_SUPPORT_TERMOPT(     OPTBIT_TERMINATE  ,)
     IF_FEATURE_XARGS_SUPPORT_ZERO_TERM(   OPTBIT_ZEROTERM   ,)
+    IF_FEATURE_XARGS_SUPPORT_REPL_STR(    OPTBIT_REPLSTR    ,)
+    IF_FEATURE_XARGS_SUPPORT_REPL_STR(    OPTBIT_REPLSTR1   ,)
 
     OPT_VERBOSE     = 1 << OPTBIT_VERBOSE    ,
@@ -389 +467 @@
     OPT_TERMINATE   = IF_FEATURE_XARGS_SUPPORT_TERMOPT(     (1 << OPTBIT_TERMINATE  )) + 0,
     OPT_ZEROTERM    = IF_FEATURE_XARGS_SUPPORT_ZERO_TERM(   (1 << OPTBIT_ZEROTERM   )) + 0,
+    OPT_REPLSTR     = IF_FEATURE_XARGS_SUPPORT_REPL_STR(    (1 << OPTBIT_REPLSTR    )) + 0,
+    OPT_REPLSTR1    = IF_FEATURE_XARGS_SUPPORT_REPL_STR(    (1 << OPTBIT_REPLSTR1   )) + 0,
 };
 #define OPTION_STR "+trn:s:e::E:" \
     IF_FEATURE_XARGS_SUPPORT_CONFIRMATION("p") \
     IF_FEATURE_XARGS_SUPPORT_TERMOPT(     "x") \
-    IF_FEATURE_XARGS_SUPPORT_ZERO_TERM(   "0")
+    IF_FEATURE_XARGS_SUPPORT_ZERO_TERM(   "0") \
+    IF_FEATURE_XARGS_SUPPORT_REPL_STR(    "I:i::")
 
 int xargs_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
@@ -406 +487 @@
     int n_max_chars;
     int n_max_arg;
-#if ENABLE_FEATURE_XARGS_SUPPORT_ZERO_TERM
+#if ENABLE_FEATURE_XARGS_SUPPORT_ZERO_TERM \
+ || ENABLE_FEATURE_XARGS_SUPPORT_REPL_STR
     char* FAST_FUNC (*read_args)(int, int, char*) = process_stdin;
 #else
@@ -420 +502 @@
         ;
 #endif
-    opt = getopt32(argv, OPTION_STR, &max_args, &max_chars, &G.eof_str, &G.eof_str);
+    opt = getopt32(argv, OPTION_STR,
+        &max_args, &max_chars, &G.eof_str, &G.eof_str
+        IF_FEATURE_XARGS_SUPPORT_REPL_STR(, &G.repl_str, &G.repl_str)
+    );
 
     /* -E ""? You may wonder why not just omit -E?
@@ -428 +513 @@
         G.eof_str = NULL;
 
-    if (opt & OPT_ZEROTERM)
-        IF_FEATURE_XARGS_SUPPORT_ZERO_TERM(read_args = process0_stdin);
+    if (opt & OPT_ZEROTERM) {
+        IF_FEATURE_XARGS_SUPPORT_ZERO_TERM(read_args = process0_stdin;)
+        IF_FEATURE_XARGS_SUPPORT_REPL_STR(G.eol_ch = '\0';)
+    }
 
     argv += optind;
@@ -439 +526 @@
     }
 
-    /* -s NUM default. fileutils-4.4.2 uses 128k, but I heasitate
-     * to use such a big value - first need to change code to use
-     * growable buffer instead of fixed one.
-     */
-    n_max_chars = 32 * 1024;
-    /* Make smaller if system does not allow our default value.
+    /*
      * The Open Group Base Specifications Issue 6:
      * "The xargs utility shall limit the command line length such that
@@ -452 +534 @@
      * shall not exceed {ARG_MAX}-2048 bytes".
      */
-    {
-        long arg_max = 0;
-#if defined _SC_ARG_MAX
-        arg_max = sysconf(_SC_ARG_MAX) - 2048;
-#elif defined ARG_MAX
-        arg_max = ARG_MAX - 2048;
-#endif
-        if (arg_max > 0 && n_max_chars > arg_max)
-            n_max_chars = arg_max;
-    }
+    n_max_chars = bb_arg_max();
+    if (n_max_chars > 32 * 1024)
+        n_max_chars = 32 * 1024;
+    /*
+     * POSIX suggests substracting 2048 bytes from sysconf(_SC_ARG_MAX)
+     * so that the process may safely modify its environment.
+     */
+    n_max_chars -= 2048;
+
     if (opt & OPT_UPTO_SIZE) {
         n_max_chars = xatou_range(max_chars, 1, INT_MAX);
@@ -487 +568 @@
     }
 
-    /* Allocate pointers for execvp */
-    /* We can statically allocate (argc + n_max_arg + 1) elements
-     * and do not bother with resizing args[], but on 64-bit machines
-     * this results in args[] vector which is ~8 times bigger
-     * than n_max_chars! That is, with n_max_chars == 20k,
-     * args[] will take 160k (!), which will most likely be
-     * almost entirely unused.
-     */
-    /* See store_param() for matching 256-step growth logic */
-    G.args = xmalloc(sizeof(G.args[0]) * ((argc + 0xff) & ~0xff));
-
-    /* Store the command to be executed, part 1 */
-    for (i = 0; argv[i]; i++)
-        G.args[i] = argv[i];
+#if ENABLE_FEATURE_XARGS_SUPPORT_REPL_STR
+    if (opt & (OPT_REPLSTR | OPT_REPLSTR1)) {
+        /*
+         * -I<str>:
+         * Unmodified args are kept in G.argv[i],
+         * G.args[i] receives malloced G.argv[i] with <str> replaced
+         * with input line. Setting this up:
+         */
+        G.args = NULL;
+        G.argv = argv;
+        argc = 0;
+        read_args = process_stdin_with_replace;
+        /* Make -I imply -r. GNU findutils seems to do the same: */
+        /* (otherwise "echo -n | xargs -I% echo %" would SEGV) */
+        opt |= OPT_NO_EMPTY;
+    } else
+#endif
+    {
+        /* Allocate pointers for execvp.
+         * We can statically allocate (argc + n_max_arg + 1) elements
+         * and do not bother with resizing args[], but on 64-bit machines
+         * this results in args[] vector which is ~8 times bigger
+         * than n_max_chars! That is, with n_max_chars == 20k,
+         * args[] will take 160k (!), which will most likely be
+         * almost entirely unused.
+         *
+         * See store_param() for matching 256-step growth logic
+         */
+        G.args = xmalloc(sizeof(G.args[0]) * ((argc + 0xff) & ~0xff));
+        /* Store the command to be executed, part 1 */
+        for (i = 0; argv[i]; i++)
+            G.args[i] = argv[i];
+    }
 
     while (1) {