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., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  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 #ifdef HAVE_UNISTD_H
  72 /* for sysconf() */
  73 #include <unistd.h>
  74 #endif
  75
  76 /* COMPAT:  SYSV version defaults size (and has a max value of) to 470.
  77    We try to make it as large as possible. */
  78 #if !defined(ARG_MAX) && defined(_SC_ARG_MAX)
  79 #define ARG_MAX sysconf (_SC_ARG_MAX)
  80 #endif
  81 #ifndef ARG_MAX
  82 #define ARG_MAX NCARGS
  83 #endif
  84
  85
  86
  87 #include <xalloc.h>
  88 #include <error.h>
  89
  90 #include "buildcmd.h"
  91
  92 static char *mbstrstr PARAMS ((const char *haystack, const char *needle));
  93
  94 /* Replace all instances of `replace_pat' in ARG with `linebuf',
  95    and add the resulting string to the list of arguments for the command
  96    to execute.
  97    ARGLEN is the length of ARG, not including the null.
  98    LBLEN is the length of LINEBUF, not including the null.
  99    PFXLEN is the length of PREFIX.  Substitution is not performed on
 100    the prefix.   The prefix is used if the argument contains replace_pat.
 101
 102    COMPAT: insertions on the SYSV version are limited to 255 chars per line,
 103    and a max of 5 occurrences of replace_pat in the initial-arguments.
 104    Those restrictions do not exist here.  */
 105
 106 void
 107 bc_do_insert (const struct buildcmd_control *ctl,
 108               struct buildcmd_state *state,
 109               char *arg, size_t arglen,
 110               const char *prefix, size_t pfxlen,
 111               const char *linebuf, size_t lblen,
 112               int initial_args)
 113 {
 114   /* Temporary copy of each arg with the replace pattern replaced by the
 115      real arg.  */
 116   static char *insertbuf;
 117   char *p;
 118   int bytes_left = ctl->arg_max - 1;    /* Bytes left on the command line.  */
 119   int need_prefix;
 120
 121   if (!insertbuf)
 122     insertbuf = (char *) xmalloc (ctl->arg_max + 1);
 123   p = insertbuf;
 124
 125   need_prefix = 0;
 126   do
 127     {
 128       size_t len;               /* Length in ARG before `replace_pat'.  */
 129       char *s = mbstrstr (arg, ctl->replace_pat);
 130       if (s)
 131         {
 132           need_prefix = 1;
 133           len = s - arg;
 134         }
 135       else
 136         {
 137           len = arglen;
 138         }
 139
 140       bytes_left -= len;
 141       if (bytes_left <= 0)
 142         break;
 143
 144       strncpy (p, arg, len);
 145       p += len;
 146       arg += len;
 147       arglen -= len;
 148
 149       if (s)
 150         {
 151           bytes_left -= lblen;
 152           if (bytes_left <= 0)
 153             break;
 154           strcpy (p, linebuf);
 155           arg += ctl->rplen;
 156           arglen -= ctl->rplen;
 157           p += lblen;
 158         }
 159     }
 160   while (*arg);
 161   if (*arg)
 162     error (1, 0, _("command too long"));
 163   *p++ = '\0';
 164
 165   if (!need_prefix)
 166     {
 167       prefix = NULL;
 168       pfxlen = 0;
 169     }
 170
 171   bc_push_arg (ctl, state,
 172                insertbuf, p - insertbuf,
 173                prefix, pfxlen,
 174                initial_args);
 175 }
 176
 177 static
 178 void do_exec(const struct buildcmd_control *ctl,
 179              struct buildcmd_state *state)
 180 {
 181   (ctl->exec_callback)(ctl, state);
 182 }
 183
 184
 185 /* Add ARG to the end of the list of arguments `cmd_argv' to pass
 186    to the command.
 187    LEN is the length of ARG, including the terminating null.
 188    If this brings the list up to its maximum size, execute the command.  */
 189
 190 void
 191 bc_push_arg (const struct buildcmd_control *ctl,
 192              struct buildcmd_state *state,
 193              const char *arg, size_t len,
 194              const char *prefix, size_t pfxlen,
 195              int initial_args)
 196 {
 197   state->todo = 1;
 198   if (arg)
 199     {
 200       if (state->cmd_argv_chars + len > ctl->arg_max)
 201         {
 202           if (initial_args || state->cmd_argc == ctl->initial_argc)
 203             error (1, 0, _("can not fit single argument within argument list size limit"));
 204           /* option -i (replace_pat) implies -x (exit_if_size_exceeded) */
 205           if (ctl->replace_pat
 206               || (ctl->exit_if_size_exceeded &&
 207                   (ctl->lines_per_exec || ctl->args_per_exec)))
 208             error (1, 0, _("argument list too long"));
 209           do_exec (ctl, state);
 210         }
 211       if (!initial_args && ctl->args_per_exec &&
 212           state->cmd_argc - ctl->initial_argc == ctl->args_per_exec)
 213         do_exec (ctl, state);
 214     }
 215
 216   if (state->cmd_argc >= state->cmd_argv_alloc)
 217     {
 218       if (!state->cmd_argv)
 219         {
 220           state->cmd_argv_alloc = 64;
 221           state->cmd_argv = (char **) xmalloc (sizeof (char *) * state->cmd_argv_alloc);
 222         }
 223       else
 224         {
 225           state->cmd_argv_alloc *= 2;
 226           state->cmd_argv = (char **) xrealloc (state->cmd_argv,
 227                                          sizeof (char *) * state->cmd_argv_alloc);
 228         }
 229     }
 230
 231   if (!arg)
 232     state->cmd_argv[state->cmd_argc++] = NULL;
 233   else
 234     {
 235       state->cmd_argv[state->cmd_argc++] = state->argbuf + state->cmd_argv_chars;
 236       if (prefix)
 237         {
 238           strcpy (state->argbuf + state->cmd_argv_chars, prefix);
 239           state->cmd_argv_chars += pfxlen;
 240         }
 241
 242       strcpy (state->argbuf + state->cmd_argv_chars, arg);
 243       state->cmd_argv_chars += len;
 244
 245       /* If we have now collected enough arguments,
 246        * do the exec immediately.  This must be
 247        * conditional on arg!=NULL, since do_exec()
 248        * actually calls bc_push_arg(ctl, state, NULL, 0, false).
 249        */
 250       if (!initial_args
 251           && ctl->args_per_exec
 252           && (state->cmd_argc - ctl->initial_argc) == ctl->args_per_exec)
 253         do_exec (ctl, state);
 254     }
 255
 256   /* If this is an initial argument, set the high-water mark. */
 257   if (initial_args)
 258     {
 259       state->cmd_initial_argv_chars = state->cmd_argv_chars;
 260     }
 261 }
 262
 263
 264 /* Finds the first occurrence of the substring NEEDLE in the string
 265    HAYSTACK.  Both strings can be multibyte strings.  */
 266
 267 static char *
 268 mbstrstr (const char *haystack, const char *needle)
 269 {
 270 #if DO_MULTIBYTE
 271   if (MB_CUR_MAX > 1)
 272     {
 273       size_t hlen = strlen (haystack);
 274       size_t nlen = strlen (needle);
 275       mbstate_t mbstate;
 276       size_t step;
 277
 278       memset (&mbstate, 0, sizeof (mbstate_t));
 279       while (hlen >= nlen)
 280         {
 281           if (memcmp (haystack, needle, nlen) == 0)
 282             return (char *) haystack;
 283           step = mbrlen (haystack, hlen, &mbstate);
 284           if (step <= 0)
 285             break;
 286           haystack += step;
 287           hlen -= step;
 288         }
 289       return NULL;
 290     }
 291 #endif
 292   return strstr (haystack, needle);
 293 }
 294
 295
 296 long
 297 bc_get_arg_max(void)
 298 {
 299   long val;
 300 #ifdef _SC_ARG_MAX
 301   val = sysconf(_SC_ARG_MAX);
 302 #else
 303   val = -1;
 304 #endif
 305
 306   if (val > 0)
 307     return val;
 308
 309   /* either _SC_ARG_MAX was not available or
 310    * there is no particular limit.
 311    */
 312 #ifdef ARG_MAX
 313   val = ARG_MAX;
 314 #endif
 315
 316   if (val > 0)
 317     return val;
 318
 319   /* The value returned by this function bounds the
 320    * value applied as the ceiling for the -s option.
 321    * Hence it the system won't tell us what its limit
 322    * is, we allow the user to specify more or less
 323    * whatever value they like.
 324    */
 325   return LONG_MAX;
 326 }
 327
 328
 329 static int cb_exec_noop(const struct buildcmd_control *ctl,
 330                          struct buildcmd_state *state)
 331 {
 332   /* does nothing. */
 333   (void) ctl;
 334   (void) state;
 335
 336   return 0;
 337 }
 338
 339 void
 340 bc_init_controlinfo(struct buildcmd_control *ctl)
 341 {
 342   ctl->exit_if_size_exceeded = 0;
 343   ctl->arg_max = bc_get_arg_max() - 2048; /* a la xargs */
 344   ctl->rplen = 0u;
 345   ctl->replace_pat = NULL;
 346   ctl->initial_argc = 0;
 347   ctl->exec_callback = cb_exec_noop;
 348   ctl->lines_per_exec = 0;
 349   ctl->args_per_exec = 0;
 350 }
 351
 352 void
 353 bc_init_state(const struct buildcmd_control *ctl,
 354               struct buildcmd_state *state,
 355               void *context)
 356 {
 357   state->cmd_argc = 0;
 358   state->cmd_argv_chars = 0;
 359   state->cmd_argv = NULL;
 360   state->cmd_argv_alloc = 0;
 361   state->argbuf = (char *) xmalloc (ctl->arg_max + 1);
 362   state->cmd_argv_chars = state->cmd_initial_argv_chars = 0;
 363   state->todo = 0;
 364   state->usercontext = context;
 365 }
 366
 367 void
 368 bc_clear_args(const struct buildcmd_control *ctl,
 369               struct buildcmd_state *state)
 370 {
 371   state->cmd_argc = ctl->initial_argc;
 372   state->cmd_argv_chars = state->cmd_initial_argv_chars;
 373   state->todo = 0;
 374 }
 375