lib/buildcmd.c

   1 /* buildcmd.c -- build command lines from a list of arguments.
   2    Copyright (C) 1990, 91, 92, 93, 94, 2000, 2003, 2005 Free Software Foundation, Inc.
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 2, or (at your option)
   7    any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, write to the Free Software
  16    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
  17    USA.
  18 */
  19
  20 #include <config.h>
  21
  22 # ifndef PARAMS
  23 #  if defined PROTOTYPES || (defined __STDC__ && __STDC__)
  24 #   define PARAMS(Args) Args
  25 #  else
  26 #   define PARAMS(Args) ()
  27 #  endif
  28 # endif
  29
  30 #if defined(HAVE_STRING_H) || defined(STDC_HEADERS)
  31 #include <string.h>
  32 #endif
  33
  34
  35 #if DO_MULTIBYTE
  36 # if HAVE_MBRLEN
  37 #  include <wchar.h>
  38 # else
  39    /* Simulate mbrlen with mblen as best we can.  */
  40 #  define mbstate_t int
  41 #  define mbrlen(s, n, ps) mblen (s, n)
  42 # endif
  43 #endif
  44
  45 #ifdef HAVE_LOCALE_H
  46 #include <locale.h>
  47 #endif
  48 #if ENABLE_NLS
  49 # include <libintl.h>
  50 # define _(Text) gettext (Text)
  51 #else
  52 # define _(Text) Text
  53 #define textdomain(Domain)
  54 #define bindtextdomain(Package, Directory)
  55 #endif
  56 #ifdef gettext_noop
  57 # define N_(String) gettext_noop (String)
  58 #else
  59 /* See locate.c for explanation as to why not use (String) */
  60 # define N_(String) String
  61 #endif
  62
  63 #ifndef _POSIX_SOURCE
  64 #include <sys/param.h>
  65 #endif
  66
  67 #ifdef HAVE_LIMITS_H
  68 #include <limits.h>
  69 #endif
  70
  71 /* The presence of unistd.h is assumed by gnulib these days, so we
  72  * might as well assume it too.
  73  */
  74 /* for sysconf() */
  75 #include <unistd.h>
  76
  77 #include <assert.h>
  78
  79 /* COMPAT:  SYSV version defaults size (and has a max value of) to 470.
  80    We try to make it as large as possible. */
  81 #if !defined(ARG_MAX) && defined(_SC_ARG_MAX)
  82 #define ARG_MAX sysconf (_SC_ARG_MAX)
  83 #endif
  84 #ifndef ARG_MAX
  85 #define ARG_MAX NCARGS
  86 #endif
  87
  88
  89
  90 #include <xalloc.h>
  91 #include <error.h>
  92 #include <openat.h>
  93
  94 #include "buildcmd.h"
  95
  96
  97 extern char **environ;
  98
  99
 100 static char *mbstrstr PARAMS ((const char *haystack, const char *needle));
 101
 102 /* Replace all instances of `replace_pat' in ARG with `linebuf',
 103    and add the resulting string to the list of arguments for the command
 104    to execute.
 105    ARGLEN is the length of ARG, not including the null.
 106    LBLEN is the length of LINEBUF, not including the null.
 107    PFXLEN is the length of PREFIX.  Substitution is not performed on
 108    the prefix.   The prefix is used if the argument contains replace_pat.
 109
 110    COMPAT: insertions on the SYSV version are limited to 255 chars per line,
 111    and a max of 5 occurrences of replace_pat in the initial-arguments.
 112    Those restrictions do not exist here.  */
 113
 114 void
 115 bc_do_insert (const struct buildcmd_control *ctl,
 116               struct buildcmd_state *state,
 117               char *arg, size_t arglen,
 118               const char *prefix, size_t pfxlen,
 119               const char *linebuf, size_t lblen,
 120               int initial_args)
 121 {
 122   /* Temporary copy of each arg with the replace pattern replaced by the
 123      real arg.  */
 124   static char *insertbuf;
 125   char *p;
 126   size_t bytes_left = ctl->arg_max - 1;    /* Bytes left on the command line.  */
 127
 128   /* XXX: on systems lacking an upper limit for exec args, ctl->arg_max
 129    *      may have been set to LONG_MAX (see bc_get_arg_max()).  Hence
 130    *      this xmalloc call may be a bad idea, especially since we are
 131    *      adding 1 to it...
 132    */
 133   if (!insertbuf)
 134     insertbuf = (char *) xmalloc (ctl->arg_max + 1);
 135   p = insertbuf;
 136
 137   do
 138     {
 139       size_t len;               /* Length in ARG before `replace_pat'.  */
 140       char *s = mbstrstr (arg, ctl->replace_pat);
 141       if (s)
 142         {
 143           len = s - arg;
 144         }
 145       else
 146         {
 147           len = arglen;
 148         }
 149
 150       if (bytes_left <= len)
 151         break;
 152       else
 153         bytes_left -= len;
 154
 155       strncpy (p, arg, len);
 156       p += len;
 157       arg += len;
 158       arglen -= len;
 159
 160       if (s)
 161         {
 162           if (bytes_left <= (lblen + pfxlen))
 163             break;
 164           else
 165             bytes_left -= (lblen + pfxlen);
 166
 167           if (prefix)
 168             {
 169               strcpy (p, prefix);
 170               p += pfxlen;
 171             }
 172           strcpy (p, linebuf);
 173           p += lblen;
 174
 175           arg += ctl->rplen;
 176           arglen -= ctl->rplen;
 177         }
 178     }
 179   while (*arg);
 180   if (*arg)
 181     error (1, 0, _("command too long"));
 182   *p++ = '\0';
 183
 184   bc_push_arg (ctl, state,
 185                insertbuf, p - insertbuf,
 186                NULL, 0,
 187                initial_args);
 188 }
 189
 190 static
 191 void do_exec(const struct buildcmd_control *ctl,
 192              struct buildcmd_state *state)
 193 {
 194   (ctl->exec_callback)(ctl, state);
 195 }
 196
 197
 198 /* Return nonzero if there would not be enough room for an additional
 199  * argument.  We check the total number of arguments only, not the space
 200  * occupied by those arguments.
 201  *
 202  * If we return zero, there still may not be enough room for the next
 203  * argument, depending on its length.
 204  */
 205 static int
 206 bc_argc_limit_reached(int initial_args,
 207                       const struct buildcmd_control *ctl,
 208                       struct buildcmd_state *state)
 209 {
 210   /* Check to see if we about to exceed a limit set by xargs' -n option */
 211   if (!initial_args && ctl->args_per_exec &&
 212       ( (state->cmd_argc - ctl->initial_argc) == ctl->args_per_exec))
 213     return 1;
 214
 215   /* We deliberately use an equality test here rather than >= in order
 216    * to force a software failure if the code is modified in such a way
 217    * that it fails to call this function for every new argument.
 218    */
 219   return state->cmd_argc == ctl->max_arg_count;
 220 }
 221
 222
 223 /* Add ARG to the end of the list of arguments `cmd_argv' to pass
 224    to the command.
 225    LEN is the length of ARG, including the terminating null.
 226    If this brings the list up to its maximum size, execute the command.
 227 */
 228
 229 void
 230 bc_push_arg (const struct buildcmd_control *ctl,
 231              struct buildcmd_state *state,
 232              const char *arg, size_t len,
 233              const char *prefix, size_t pfxlen,
 234              int initial_args)
 235 {
 236   if (!initial_args)
 237     {
 238       state->todo = 1;
 239     }
 240
 241   if (arg)
 242     {
 243       if (state->cmd_argv_chars + len > ctl->arg_max)
 244         {
 245           if (initial_args || state->cmd_argc == ctl->initial_argc)
 246             error (1, 0, _("can not fit single argument within argument list size limit"));
 247           /* xargs option -i (replace_pat) implies -x (exit_if_size_exceeded) */
 248           if (ctl->replace_pat
 249               || (ctl->exit_if_size_exceeded &&
 250                   (ctl->lines_per_exec || ctl->args_per_exec)))
 251             error (1, 0, _("argument list too long"));
 252           do_exec (ctl, state);
 253         }
 254
 255       if (bc_argc_limit_reached(initial_args, ctl, state))
 256         do_exec (ctl, state);
 257     }
 258
 259   if (state->cmd_argc >= state->cmd_argv_alloc)
 260     {
 261       if (!state->cmd_argv)
 262         {
 263           state->cmd_argv_alloc = 64;
 264           state->cmd_argv = (char **) xmalloc (sizeof (char *) * state->cmd_argv_alloc);
 265         }
 266       else
 267         {
 268           state->cmd_argv_alloc *= 2;
 269           state->cmd_argv = (char **) xrealloc (state->cmd_argv,
 270                                          sizeof (char *) * state->cmd_argv_alloc);
 271         }
 272     }
 273
 274   if (!arg)
 275     state->cmd_argv[state->cmd_argc++] = NULL;
 276   else
 277     {
 278       state->cmd_argv[state->cmd_argc++] = state->argbuf + state->cmd_argv_chars;
 279       if (prefix)
 280         {
 281           strcpy (state->argbuf + state->cmd_argv_chars, prefix);
 282           state->cmd_argv_chars += pfxlen;
 283         }
 284
 285       strcpy (state->argbuf + state->cmd_argv_chars, arg);
 286       state->cmd_argv_chars += len;
 287
 288       /* If we have now collected enough arguments,
 289        * do the exec immediately.  This must be
 290        * conditional on arg!=NULL, since do_exec()
 291        * actually calls bc_push_arg(ctl, state, NULL, 0, false).
 292        */
 293       if (bc_argc_limit_reached(initial_args, ctl, state))
 294         do_exec (ctl, state);
 295     }
 296
 297   /* If this is an initial argument, set the high-water mark. */
 298   if (initial_args)
 299     {
 300       state->cmd_initial_argv_chars = state->cmd_argv_chars;
 301     }
 302 }
 303
 304
 305 /* Finds the first occurrence of the substring NEEDLE in the string
 306    HAYSTACK.  Both strings can be multibyte strings.  */
 307
 308 static char *
 309 mbstrstr (const char *haystack, const char *needle)
 310 {
 311 #if DO_MULTIBYTE
 312   if (MB_CUR_MAX > 1)
 313     {
 314       size_t hlen = strlen (haystack);
 315       size_t nlen = strlen (needle);
 316       mbstate_t mbstate;
 317       size_t step;
 318
 319       memset (&mbstate, 0, sizeof (mbstate_t));
 320       while (hlen >= nlen)
 321         {
 322           if (memcmp (haystack, needle, nlen) == 0)
 323             return (char *) haystack;
 324           step = mbrlen (haystack, hlen, &mbstate);
 325           if (step <= 0)
 326             break;
 327           haystack += step;
 328           hlen -= step;
 329         }
 330       return NULL;
 331     }
 332 #endif
 333   return strstr (haystack, needle);
 334 }
 335
 336 static size_t
 337 get_line_max(void)
 338 {
 339   long val;
 340 #ifdef _SC_LINE_MAX
 341   val = sysconf(_SC_LINE_MAX);
 342 #else
 343   val = -1;
 344 #endif
 345
 346   if (val > 0)
 347     return val;
 348
 349   /* either _SC_LINE_MAX was not available or
 350    * there is no particular limit.
 351    */
 352 #ifdef LINE_MAX
 353   val = LINE_MAX;
 354 #endif
 355
 356   if (val > 0)
 357     return val;
 358
 359   return 2048L;                 /* a reasonable guess. */
 360 }
 361
 362
 363 size_t
 364 bc_get_arg_max(void)
 365 {
 366   long val;
 367
 368   /* We may resort to using LONG_MAX, so check it fits. */
 369   /* XXX: better to do a compile-time check */
 370   assert( (~(size_t)0) >= LONG_MAX);
 371
 372 #ifdef _SC_ARG_MAX
 373   val = sysconf(_SC_ARG_MAX);
 374 #else
 375   val = -1;
 376 #endif
 377
 378   if (val > 0)
 379     return val;
 380
 381   /* either _SC_ARG_MAX was not available or
 382    * there is no particular limit.
 383    */
 384 #ifdef ARG_MAX
 385   val = ARG_MAX;
 386 #endif
 387
 388   if (val > 0)
 389     return val;
 390
 391   /* The value returned by this function bounds the
 392    * value applied as the ceiling for the -s option.
 393    * Hence it the system won't tell us what its limit
 394    * is, we allow the user to specify more or less
 395    * whatever value they like.
 396    */
 397   return LONG_MAX;
 398 }
 399
 400
 401 static int cb_exec_noop(const struct buildcmd_control *ctl,
 402                          struct buildcmd_state *state)
 403 {
 404   /* does nothing. */
 405   (void) ctl;
 406   (void) state;
 407
 408   return 0;
 409 }
 410
 411
 412 /* Return how much of ARG_MAX is used by the environment.  */
 413 size_t
 414 bc_size_of_environment (void)
 415 {
 416   size_t len = 0u;
 417   char **envp = environ;
 418
 419   while (*envp)
 420     len += strlen (*envp++) + 1;
 421
 422   return len;
 423 }
 424
 425
 426 enum BC_INIT_STATUS
 427 bc_init_controlinfo(struct buildcmd_control *ctl)
 428 {
 429   size_t size_of_environment = bc_size_of_environment();
 430   size_t arg_max;
 431
 432   ctl->posix_arg_size_min = get_line_max();
 433   arg_max = bc_get_arg_max();
 434
 435   /* POSIX.2 requires subtracting 2048.  */
 436   assert(arg_max > 2048u);      /* XXX: this is an external condition, should not check it with assert. */
 437   ctl->posix_arg_size_max = (arg_max - 2048);
 438
 439   ctl->exit_if_size_exceeded = 0;
 440
 441   /* Take the size of the environment into account.  */
 442   if (size_of_environment > ctl->posix_arg_size_max)
 443     {
 444       return BC_INIT_ENV_TOO_BIG;
 445     }
 446   else
 447     {
 448 #warning the next line is probably a bug.
 449       ctl->posix_arg_size_max - size_of_environment;
 450     }
 451
 452   /* need to subtract 2 on the following line - for Linux/PPC */
 453   ctl->max_arg_count = (ctl->posix_arg_size_max / sizeof(char*)) - 2u;
 454   assert(ctl->max_arg_count > 0);
 455   ctl->rplen = 0u;
 456   ctl->replace_pat = NULL;
 457   ctl->initial_argc = 0;
 458   ctl->exec_callback = cb_exec_noop;
 459   ctl->lines_per_exec = 0;
 460   ctl->args_per_exec = 0;
 461
 462   /* Set the initial value of arg_max to the largest value we can
 463    * tolerate.
 464    */
 465   ctl->arg_max = ctl->posix_arg_size_max;
 466
 467   return BC_INIT_OK;
 468 }
 469
 470 void
 471 bc_use_sensible_arg_max(struct buildcmd_control *ctl)
 472 {
 473   size_t env_size = bc_size_of_environment();
 474   const size_t arg_size = (128u * 1024u) + env_size;
 475
 476   /* Check against the upper and lower limits. */
 477   if (arg_size > ctl->posix_arg_size_max)
 478     ctl->arg_max = ctl->posix_arg_size_max - env_size;
 479   else if (arg_size < ctl->posix_arg_size_min)
 480     ctl->arg_max = ctl->posix_arg_size_min;
 481   else
 482     ctl->arg_max = arg_size;
 483 }
 484
 485
 486
 487
 488 void
 489 bc_init_state(const struct buildcmd_control *ctl,
 490               struct buildcmd_state *state,
 491               void *context)
 492 {
 493   state->cmd_argc = 0;
 494   state->cmd_argv_chars = 0;
 495   state->cmd_argv = NULL;
 496   state->cmd_argv_alloc = 0;
 497
 498   /* XXX: the following memory allocation is inadvisable on systems
 499    * with no ARG_MAX, because ctl->arg_max may actually be close to
 500    * LONG_MAX.   Adding one to it is safe though because earlier we
 501    * subtracted 2048.
 502    */
 503   assert(ctl->arg_max <= (LONG_MAX - 2048L));
 504   state->argbuf = (char *) xmalloc (ctl->arg_max + 1u);
 505
 506   state->cmd_argv_chars = state->cmd_initial_argv_chars = 0;
 507   state->todo = 0;
 508   state->dirfd = -1;
 509   state->usercontext = context;
 510 }
 511
 512 void
 513 bc_clear_args(const struct buildcmd_control *ctl,
 514               struct buildcmd_state *state)
 515 {
 516   state->cmd_argc = ctl->initial_argc;
 517   state->cmd_argv_chars = state->cmd_initial_argv_chars;
 518   state->todo = 0;
 519   state->dirfd = -1;
 520 }
 521