support/shell-container.c

   1 /* Minimal /bin/sh for in-container use.
   2    Copyright (C) 2018-2023 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <https://www.gnu.org/licenses/>.  */
  18
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22 #include <sched.h>
  23 #include <sys/syscall.h>
  24 #include <unistd.h>
  25 #include <sys/types.h>
  26 #include <dirent.h>
  27 #include <string.h>
  28 #include <sys/stat.h>
  29 #include <sys/fcntl.h>
  30 #include <sys/file.h>
  31 #include <sys/wait.h>
  32 #include <stdarg.h>
  33 #include <sys/sysmacros.h>
  34 #include <ctype.h>
  35 #include <utime.h>
  36 #include <errno.h>
  37 #include <error.h>
  38
  39 #include <support/support.h>
  40 #include <support/timespec.h>
  41
  42 /* Design considerations
  43
  44  General rule: optimize for developer time, not run time.
  45
  46  Specifically:
  47
  48  * Don't worry about slow algorithms
  49  * Don't worry about free'ing memory
  50  * Don't implement anything the testsuite doesn't need.
  51  * Line and argument counts are limited, see below.
  52
  53 */
  54
  55 #define MAX_ARG_COUNT 100
  56 #define MAX_LINE_LENGTH 1000
  57
  58 /* Debugging is enabled via --debug, which must be the first argument.  */
  59 static int debug_mode = 0;
  60 #define dprintf if (debug_mode) fprintf
  61
  62 /* Emulate the "/bin/true" command.  Arguments are ignored.  */
  63 static int
  64 true_func (char **argv)
  65 {
  66   return 0;
  67 }
  68
  69 /* Emulate the "/bin/echo" command.  Options are ignored, arguments
  70    are printed to stdout.  */
  71 static int
  72 echo_func (char **argv)
  73 {
  74   int i;
  75
  76   for (i = 0; argv[i]; i++)
  77     {
  78       if (i > 0)
  79         putchar (' ');
  80       fputs (argv[i], stdout);
  81     }
  82   putchar ('\n');
  83
  84   return 0;
  85 }
  86
  87 /* Emulate the "/bin/cp" command.  Options are ignored.  Only copies
  88    one source file to one destination file.  Directory destinations
  89    are not supported.  */
  90 static int
  91 copy_func (char **argv)
  92 {
  93   char *sname = argv[0];
  94   char *dname = argv[1];
  95   int sfd = -1, dfd = -1;
  96   struct stat st;
  97   int ret = 1;
  98
  99   sfd = open (sname, O_RDONLY);
 100   if (sfd < 0)
 101     {
 102       fprintf (stderr, "cp: unable to open %s for reading: %s\n",
 103                sname, strerror (errno));
 104       return 1;
 105     }
 106
 107   if (fstat (sfd, &st) < 0)
 108     {
 109       fprintf (stderr, "cp: unable to fstat %s: %s\n",
 110                sname, strerror (errno));
 111       goto out;
 112     }
 113
 114   dfd = open (dname, O_WRONLY | O_TRUNC | O_CREAT, 0600);
 115   if (dfd < 0)
 116     {
 117       fprintf (stderr, "cp: unable to open %s for writing: %s\n",
 118                dname, strerror (errno));
 119       goto out;
 120     }
 121
 122   if (support_copy_file_range (sfd, 0, dfd, 0, st.st_size, 0) != st.st_size)
 123     {
 124       fprintf (stderr, "cp: cannot copy file %s to %s: %s\n",
 125                sname, dname, strerror (errno));
 126       goto out;
 127     }
 128
 129   ret = 0;
 130   chmod (dname, st.st_mode & 0777);
 131
 132 out:
 133   if (sfd >= 0)
 134     close (sfd);
 135   if (dfd >= 0)
 136     close (dfd);
 137
 138   return ret;
 139
 140 }
 141
 142 /* Emulate the 'exit' builtin.  The exit value is optional.  */
 143 static int
 144 exit_func (char **argv)
 145 {
 146   int exit_val = 0;
 147
 148   if (argv[0] != 0)
 149     exit_val = atoi (argv[0]) & 0xff;
 150   exit (exit_val);
 151   return 0;
 152 }
 153
 154 /* Emulate the "/bin/kill" command.  Options are ignored.  */
 155 static int
 156 kill_func (char **argv)
 157 {
 158   int signum = SIGTERM;
 159   int i;
 160
 161   for (i = 0; argv[i]; i++)
 162     {
 163       pid_t pid;
 164       if (strcmp (argv[i], "$$") == 0)
 165         pid = getpid ();
 166       else
 167         pid = atoi (argv[i]);
 168       kill (pid, signum);
 169     }
 170   return 0;
 171 }
 172
 173 /* Emulate the "/bin/sleep" command.  No suffix support.  Options are
 174    ignored.  */
 175 static int
 176 sleep_func (char **argv)
 177 {
 178   if (argv[0] == NULL)
 179     {
 180       fprintf (stderr, "sleep: missing operand\n");
 181       return 1;
 182     }
 183   char *endptr = NULL;
 184   double sec = strtod (argv[0], &endptr);
 185   if (endptr == argv[0] || errno == ERANGE || sec < 0)
 186     {
 187       fprintf (stderr, "sleep: invalid time interval '%s'\n", argv[0]);
 188       return 1;
 189     }
 190   struct timespec ts = dtotimespec (sec);
 191   if (nanosleep (&ts, NULL) < 0)
 192     {
 193       fprintf (stderr, "sleep: failed to nanosleep: %s\n", strerror (errno));
 194       return 1;
 195     }
 196   return 0;
 197 }
 198
 199 /* This is a list of all the built-in commands we understand.  */
 200 static struct {
 201   const char *name;
 202   int (*func) (char **argv);
 203 } builtin_funcs[] = {
 204   { "true", true_func },
 205   { "echo", echo_func },
 206   { "cp", copy_func },
 207   { "exit", exit_func },
 208   { "kill", kill_func },
 209   { "sleep", sleep_func },
 210   { NULL, NULL }
 211 };
 212
 213 /* Run one tokenized command.  argv[0] is the command.  argv is
 214    NULL-terminated.  */
 215 static void
 216 run_command_array (char **argv)
 217 {
 218   int i, j;
 219   pid_t pid;
 220   int status;
 221   int (*builtin_func) (char **args);
 222
 223   if (argv[0] == NULL)
 224     return;
 225
 226   builtin_func = NULL;
 227
 228   int new_stdin = 0;
 229   int new_stdout = 1;
 230   int new_stderr = 2;
 231
 232   dprintf (stderr, "run_command_array starting\n");
 233   for (i = 0; argv[i]; i++)
 234     dprintf (stderr, "   argv [%d] `%s'\n", i, argv[i]);
 235
 236   for (j = i = 0; argv[i]; i++)
 237     {
 238       if (strcmp (argv[i], "<") == 0 && argv[i + 1])
 239         {
 240           new_stdin = open (argv[i + 1], O_WRONLY|O_CREAT|O_TRUNC, 0777);
 241           ++i;
 242           continue;
 243         }
 244       if (strcmp (argv[i], ">") == 0 && argv[i + 1])
 245         {
 246           new_stdout = open (argv[i + 1], O_WRONLY|O_CREAT|O_TRUNC, 0777);
 247           ++i;
 248           continue;
 249         }
 250       if (strcmp (argv[i], ">>") == 0 && argv[i + 1])
 251         {
 252           new_stdout = open (argv[i + 1], O_WRONLY|O_CREAT|O_APPEND, 0777);
 253           ++i;
 254           continue;
 255         }
 256       if (strcmp (argv[i], "2>") == 0 && argv[i + 1])
 257         {
 258           new_stderr = open (argv[i + 1], O_WRONLY|O_CREAT|O_TRUNC, 0777);
 259           ++i;
 260           continue;
 261         }
 262       argv[j++] = argv[i];
 263     }
 264   argv[j] = NULL;
 265
 266
 267   for (i = 0; builtin_funcs[i].name != NULL; i++)
 268     if (strcmp (argv[0], builtin_funcs[i].name) == 0)
 269        builtin_func = builtin_funcs[i].func;
 270
 271   dprintf (stderr, "builtin %p argv0 `%s'\n", builtin_func, argv[0]);
 272
 273   pid = fork ();
 274   if (pid < 0)
 275     {
 276       fprintf (stderr, "sh: fork failed\n");
 277       exit (1);
 278     }
 279
 280   if (pid == 0)
 281     {
 282       if (new_stdin != 0)
 283         {
 284           dup2 (new_stdin, 0);
 285           close (new_stdin);
 286         }
 287       if (new_stdout != 1)
 288         {
 289           dup2 (new_stdout, 1);
 290           close (new_stdout);
 291         }
 292       if (new_stderr != 2)
 293         {
 294           dup2 (new_stderr, 2);
 295           close (new_stderr);
 296         }
 297
 298       if (builtin_func != NULL)
 299         exit (builtin_func (argv + 1));
 300
 301       execvp (argv[0], argv);
 302
 303       fprintf (stderr, "sh: execing %s failed: %s",
 304                argv[0], strerror (errno));
 305       exit (127);
 306     }
 307
 308   waitpid (pid, &status, 0);
 309
 310   dprintf (stderr, "exiting run_command_array\n");
 311
 312   if (WIFEXITED (status))
 313     {
 314       int rv = WEXITSTATUS (status);
 315       if (rv)
 316         exit (rv);
 317     }
 318   else if (WIFSIGNALED (status))
 319     {
 320       int sig = WTERMSIG (status);
 321       raise (sig);
 322     }
 323   else
 324     exit (1);
 325 }
 326
 327 /* Run one command-as-a-string, by tokenizing it.  Limited to
 328    MAX_ARG_COUNT arguments.  Simple substitution is done of $1 to $9
 329    (as whole separate tokens) from iargs[].  Quoted strings work if
 330    the quotes wrap whole tokens; i.e. "foo bar" but not foo" bar".  */
 331 static void
 332 run_command_string (const char *cmdline, const char **iargs)
 333 {
 334   char *args[MAX_ARG_COUNT+1];
 335   int ap = 0;
 336   const char *start, *end;
 337   int nargs;
 338
 339   for (nargs = 0; iargs[nargs] != NULL; ++nargs)
 340     ;
 341
 342   dprintf (stderr, "run_command_string starting: '%s'\n", cmdline);
 343
 344   while (ap < MAX_ARG_COUNT)
 345     {
 346       /* If the argument is quoted, this is the quote character, else NUL.  */
 347       int in_quote = 0;
 348
 349       /* Skip whitespace up to the next token.  */
 350       while (*cmdline && isspace (*cmdline))
 351         cmdline ++;
 352       if (*cmdline == 0)
 353         break;
 354
 355       start = cmdline;
 356       /* Check for quoted argument.  */
 357       in_quote = (*cmdline == '\'' || *cmdline == '"') ? *cmdline : 0;
 358
 359       /* Skip to end of token; either by whitespace or matching quote.  */
 360       dprintf (stderr, "in_quote %d\n", in_quote);
 361       while (*cmdline
 362              && (!isspace (*cmdline) || in_quote))
 363         {
 364           if (*cmdline == in_quote
 365               && cmdline != start)
 366             in_quote = 0;
 367           dprintf (stderr, "[%c]%d ", *cmdline, in_quote);
 368           cmdline ++;
 369         }
 370       dprintf (stderr, "\n");
 371
 372       /* Allocate space for this token and store it in args[].  */
 373       end = cmdline;
 374       dprintf (stderr, "start<%s> end<%s>\n", start, end);
 375       args[ap] = (char *) xmalloc (end - start + 1);
 376       memcpy (args[ap], start, end - start);
 377       args[ap][end - start] = 0;
 378
 379       /* Strip off quotes, if found.  */
 380       dprintf (stderr, "args[%d] = <%s>\n", ap, args[ap]);
 381       if (args[ap][0] == '\''
 382           && args[ap][strlen (args[ap])-1] == '\'')
 383         {
 384           args[ap][strlen (args[ap])-1] = 0;
 385           args[ap] ++;
 386         }
 387
 388       else if (args[ap][0] == '"'
 389           && args[ap][strlen (args[ap])-1] == '"')
 390         {
 391           args[ap][strlen (args[ap])-1] = 0;
 392           args[ap] ++;
 393         }
 394
 395       /* Replace positional parameters like $4.  */
 396       else if (args[ap][0] == '$'
 397                && isdigit (args[ap][1])
 398                && args[ap][2] == 0)
 399         {
 400           int a = args[ap][1] - '1';
 401           if (0 <= a && a < nargs)
 402             args[ap] = strdup (iargs[a]);
 403         }
 404
 405       ap ++;
 406
 407       if (*cmdline == 0)
 408         break;
 409     }
 410
 411   /* Lastly, NULL terminate the array and run it.  */
 412   args[ap] = NULL;
 413   run_command_array (args);
 414 }
 415
 416 /* Run a script by reading lines and passing them to the above
 417    function.  */
 418 static void
 419 run_script (const char *filename, const char **args)
 420 {
 421   char line[MAX_LINE_LENGTH + 1];
 422   dprintf (stderr, "run_script starting: '%s'\n", filename);
 423   FILE *f = fopen (filename, "r");
 424   if (f == NULL)
 425     {
 426       fprintf (stderr, "sh: %s: %s\n", filename, strerror (errno));
 427       exit (1);
 428     }
 429   while (fgets (line, sizeof (line), f) != NULL)
 430     {
 431       if (line[0] == '#')
 432         {
 433           dprintf (stderr, "comment: %s\n", line);
 434           continue;
 435         }
 436       run_command_string (line, args);
 437     }
 438   fclose (f);
 439 }
 440
 441 int
 442 main (int argc, const char **argv)
 443 {
 444   int i;
 445
 446   if (strcmp (argv[1], "--debug") == 0)
 447     {
 448       debug_mode = 1;
 449       --argc;
 450       ++argv;
 451     }
 452
 453   dprintf (stderr, "container-sh starting:\n");
 454   for (i = 0; i < argc; i++)
 455     dprintf (stderr, "  argv[%d] is `%s'\n", i, argv[i]);
 456
 457   if (strcmp (argv[1], "-c") == 0)
 458     {
 459       if (strcmp (argv[2], "--") == 0)
 460                 run_command_string (argv[3], argv+4);
 461       else
 462                 run_command_string (argv[2], argv+3);
 463     }
 464   else
 465     run_script (argv[1], argv+2);
 466
 467   dprintf (stderr, "normal exit 0\n");
 468   return 0;
 469 }