usr/src/lib/libast/common/misc/cmdarg.c

   1 /***********************************************************************
   2 *                                                                      *
   3 *               This software is part of the ast package               *
   4 *          Copyright (c) 1985-2010 AT&T Intellectual Property          *
   5 *                      and is licensed under the                       *
   6 *                  Common Public License, Version 1.0                  *
   7 *                    by AT&T Intellectual Property                     *
   8 *                                                                      *
   9 *                A copy of the License is available at                 *
  10 *            http://www.opensource.org/licenses/cpl1.0.txt             *
  11 *         (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9)         *
  12 *                                                                      *
  13 *              Information and Software Systems Research               *
  14 *                            AT&T Research                             *
  15 *                           Florham Park NJ                            *
  16 *                                                                      *
  17 *                 Glenn Fowler <gsf@research.att.com>                  *
  18 *                  David Korn <dgk@research.att.com>                   *
  19 *                   Phong Vo <kpv@research.att.com>                    *
  20 *                                                                      *
  21 ***********************************************************************/
  22 #pragma prototyped
  23 /*
  24  * Glenn Fowler
  25  * AT&T Research
  26  *
  27  * xargs/tw command arg list support
  28  */
  29
  30 #include <ast.h>
  31 #include <ctype.h>
  32 #include <error.h>
  33 #include <proc.h>
  34
  35 #include "cmdarg.h"
  36
  37 #ifndef ARG_MAX
  38 #define ARG_MAX         (64*1024)
  39 #endif
  40 #ifndef EXIT_QUIT
  41 #define EXIT_QUIT       255
  42 #endif
  43
  44 static const char*      echo[] = { "echo", 0 };
  45
  46 /*
  47  * open a cmdarg stream
  48  * initialize the command for execution
  49  * argv[-1] is reserved for procrun(PROC_ARGMOD)
  50  */
  51
  52 Cmdarg_t*
  53 cmdopen(char** argv, int argmax, int size, const char* argpat, int flags)
  54 {
  55         register Cmdarg_t*      cmd;
  56         register int            n;
  57         register char**         p;
  58         register char*          s;
  59         char*                   sh;
  60         int                     c;
  61         int                     m;
  62         int                     argc;
  63         long                    x;
  64
  65         char**                  post = 0;
  66
  67         n = sizeof(char**);
  68         if (*argv)
  69         {
  70                 for (p = argv + 1; *p; p++)
  71                 {
  72                         if ((flags & CMD_POST) && argpat && streq(*p, argpat))
  73                         {
  74                                 *p = 0;
  75                                 post = p + 1;
  76                                 argpat = 0;
  77                         }
  78                         else
  79                                 n += strlen(*p) + 1;
  80                 }
  81                 argc = p - argv;
  82         }
  83         else
  84                 argc = 0;
  85         for (p = environ; *p; p++)
  86                 n += sizeof(char**) + strlen(*p) + 1;
  87         if ((x = strtol(astconf("ARG_MAX", NiL, NiL), NiL, 0)) <= 0)
  88                 x = ARG_MAX;
  89         if (size <= 0 || size > x)
  90                 size = x;
  91         sh = pathshell();
  92         m = n + (argc + 4) * sizeof(char**) + strlen(sh) + 1;
  93         m = roundof(m, sizeof(char**));
  94         if (size < m)
  95         {
  96                 error(2, "size must be at least %d", m);
  97                 return 0;
  98         }
  99         if ((m = x / 10) > 2048)
 100                 m = 2048;
 101         if (size > (x - m))
 102                 size = x - m;
 103         n = size - n;
 104         m = ((flags & CMD_INSERT) && argpat) ? (strlen(argpat) + 1) : 0;
 105         if (!(cmd = newof(0, Cmdarg_t, 1, n + m)))
 106         {
 107                 error(ERROR_SYSTEM|2, "out of space");
 108                 return 0;
 109         }
 110         c = n / sizeof(char**);
 111         if (argmax <= 0 || argmax > c)
 112                 argmax = c;
 113         s = cmd->buf;
 114         if (!argv[0])
 115         {
 116                 argv = (char**)echo;
 117                 cmd->echo = 1;
 118         }
 119         else if (streq(argv[0], echo[0]))
 120         {
 121                 cmd->echo = 1;
 122                 flags &= ~CMD_NEWLINE;
 123         }
 124         else if (!(flags & CMD_CHECKED))
 125         {
 126                 if (!pathpath(s, argv[0], NiL, PATH_REGULAR|PATH_EXECUTE))
 127                 {
 128                         if (!(flags & CMD_SILENT))
 129                         {
 130                                 error(ERROR_SYSTEM|2, "%s: command not found", argv[0]);
 131                                 exit(EXIT_NOTFOUND);
 132                         }
 133                         free(cmd);
 134                         return 0;
 135                 }
 136                 argv[0] = s;
 137         }
 138         s += strlen(s) + 1;
 139         if (m)
 140         {
 141                 cmd->insert = strcpy(s, argpat);
 142                 cmd->insertlen = m - 1;
 143                 s += m;
 144         }
 145         s += sizeof(char**) - (s - cmd->buf) % sizeof(char**);
 146         p = (char**)s;
 147         n -= strlen(*p++ = sh) + 1;
 148         cmd->argv = p;
 149         while (*p = *argv++)
 150                 p++;
 151         if (m)
 152         {
 153                 argmax = 1;
 154                 *p++ = 0;
 155                 cmd->insertarg = p;
 156                 argv = cmd->argv;
 157                 c = *cmd->insert;
 158                 while (s = *argv)
 159                 {
 160                         while ((s = strchr(s, c)) && strncmp(cmd->insert, s, cmd->insertlen))
 161                                 s++;
 162                         *p++ = s ? *argv : (char*)0;
 163                         argv++;
 164                 }
 165                 *p++ = 0;
 166         }
 167         cmd->firstarg = cmd->nextarg = p;
 168         cmd->laststr = cmd->nextstr = cmd->buf + n;
 169         cmd->argmax = argmax;
 170         cmd->flags = flags;
 171         cmd->offset = ((cmd->postarg = post) ? (argc - (post - argv)) : 0) + 3;
 172         return cmd;
 173 }
 174
 175 /*
 176  * flush outstanding command file args
 177  */
 178
 179 int
 180 cmdflush(register Cmdarg_t* cmd)
 181 {
 182         register char*  s;
 183         register char** p;
 184         register int    n;
 185
 186         if (cmd->flags & CMD_EMPTY)
 187                 cmd->flags &= ~CMD_EMPTY;
 188         else if (cmd->nextarg <= cmd->firstarg)
 189                 return 0;
 190         if ((cmd->flags & CMD_MINIMUM) && cmd->argcount < cmd->argmax)
 191         {
 192                 if (!(cmd->flags & CMD_SILENT))
 193                         error(2, "%d arg command would be too long", cmd->argcount);
 194                 return -1;
 195         }
 196         cmd->total.args += cmd->argcount;
 197         cmd->total.commands++;
 198         cmd->argcount = 0;
 199         if (p = cmd->postarg)
 200                 while (*cmd->nextarg++ = *p++);
 201         else
 202                 *cmd->nextarg = 0;
 203         if (s = cmd->insert)
 204         {
 205                 char*   a;
 206                 char*   b;
 207                 char*   e;
 208                 char*   t;
 209                 char*   u;
 210                 int     c;
 211                 int     m;
 212
 213                 a = cmd->firstarg[0];
 214                 b = (char*)&cmd->nextarg[1];
 215                 e = cmd->nextstr;
 216                 c = *s;
 217                 m = cmd->insertlen;
 218                 for (n = 1; cmd->argv[n]; n++)
 219                         if (t = cmd->insertarg[n])
 220                         {
 221                                 cmd->argv[n] = b;
 222                                 for (;;)
 223                                 {
 224                                         if (!(u = strchr(t, c)))
 225                                         {
 226                                                 b += sfsprintf(b, e - b, "%s", t);
 227                                                 break;
 228                                         }
 229                                         if (!strncmp(s, u, m))
 230                                         {
 231                                                 b += sfsprintf(b, e - b, "%-.*s%s", u - t, t, a);
 232                                                 t = u + m;
 233                                         }
 234                                         else if (b >= e)
 235                                                 break;
 236                                         else
 237                                         {
 238                                                 *b++ = *u++;
 239                                                 t = u;
 240                                         }
 241                                 }
 242                                 if (b < e)
 243                                         *b++ = 0;
 244                         }
 245                 if (b >= e)
 246                 {
 247                         if (!(cmd->flags & CMD_SILENT))
 248                                 error(2, "%s: command too large after insert", a);
 249                         return -1;
 250                 }
 251         }
 252         cmd->nextarg = cmd->firstarg;
 253         cmd->nextstr = cmd->laststr;
 254         if (cmd->flags & (CMD_QUERY|CMD_TRACE))
 255         {
 256                 p = cmd->argv;
 257                 sfprintf(sfstderr, "+ %s", *p);
 258                 while (s = *++p)
 259                         sfprintf(sfstderr, " %s", s);
 260                 if (!(cmd->flags & CMD_QUERY))
 261                         sfprintf(sfstderr, "\n");
 262                 else if (astquery(1, "? "))
 263                         return 0;
 264         }
 265         if (cmd->echo)
 266         {
 267                 n = (cmd->flags & CMD_NEWLINE) ? '\n' : ' ';
 268                 for (p = cmd->argv + 1; s = *p++;)
 269                         sfputr(sfstdout, s, *p ? n : '\n');
 270                 n = 0;
 271         }
 272         else if ((n = procrun(*cmd->argv, cmd->argv, PROC_ARGMOD|PROC_IGNOREPATH)) == -1)
 273         {
 274                 if (!(cmd->flags & CMD_SILENT))
 275                 {
 276                         error(ERROR_SYSTEM|2, "%s: command exec error", *cmd->argv);
 277                         exit(EXIT_NOTFOUND - 1);
 278                 }
 279                 return -1;
 280         }
 281         else if (n >= EXIT_NOTFOUND - 1)
 282         {
 283                 if (!(cmd->flags & CMD_SILENT))
 284                         exit(n);
 285         }
 286         else if (!(cmd->flags & CMD_IGNORE))
 287         {
 288                 if (n == EXIT_QUIT && !(cmd->flags & CMD_SILENT))
 289                         exit(2);
 290                 if (n)
 291                         error_info.errors++;
 292         }
 293         return n;
 294 }
 295
 296 /*
 297  * add file to the command arg list
 298  */
 299
 300 int
 301 cmdarg(register Cmdarg_t* cmd, const char* file, register int len)
 302 {
 303         int     i;
 304         int     r;
 305
 306         r = 0;
 307         if (len)
 308         {
 309                 while ((cmd->nextstr -= len + 1) < (char*)(cmd->nextarg + cmd->offset))
 310                 {
 311                         if (cmd->nextarg == cmd->firstarg)
 312                         {
 313                                 error(2, "%s: path too long for exec args", file);
 314                                 return -1;
 315                         }
 316                         if (i = cmdflush(cmd))
 317                         {
 318                                 if (r < i)
 319                                         r = i;
 320                                 if (!(cmd->flags & CMD_IGNORE))
 321                                         return r;
 322                         }
 323                 }
 324                 *cmd->nextarg++ = cmd->nextstr;
 325                 memcpy(cmd->nextstr, file, len);
 326                 cmd->nextstr[len] = 0;
 327                 cmd->argcount++;
 328                 if (cmd->argcount >= cmd->argmax && (i = cmdflush(cmd)) > r)
 329                         r = i;
 330         }
 331         return r;
 332 }
 333
 334 /*
 335  * close a cmdarg stream
 336  */
 337
 338 int
 339 cmdclose(Cmdarg_t* cmd)
 340 {
 341         int     n;
 342
 343         if ((cmd->flags & CMD_EXACT) && cmd->argcount < cmd->argmax)
 344         {
 345                 if (!(cmd->flags & CMD_SILENT))
 346                         error(2, "only %d arguments for last command", cmd->argcount);
 347                 return -1;
 348         }
 349         cmd->flags &= ~CMD_MINIMUM;
 350         n = cmdflush(cmd);
 351         free(cmd);
 352         return n;
 353 }