/* Minimal /bin/sh for in-container use.

   Copyright (C) 2018 Free Software Foundation, Inc.

   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or

   modify it under the terms of the GNU Lesser General Public

   License as published by the Free Software Foundation; either

   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public

   License along with the GNU C Library; if not, see

   <http://www.gnu.org/licenses/>.  */

#define _FILE_OFFSET_BITS 64

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sched.h>

#include <sys/syscall.h>

#include <unistd.h>

#include <sys/types.h>

#include <dirent.h>

#include <string.h>

#include <sys/stat.h>

#include <sys/fcntl.h>

#include <sys/file.h>

#include <sys/wait.h>

#include <stdarg.h>

#include <sys/sysmacros.h>

#include <ctype.h>

#include <utime.h>

#include <errno.h>

#include <error.h>

#include <support/support.h>

/* Design considerations

 General rule: optimize for developer time, not run time.

 Specifically:

 * Don't worry about slow algorithms

 * Don't worry about free'ing memory

 * Don't implement anything the testsuite doesn't need.

 * Line and argument counts are limited, see below.

*/

#define MAX_ARG_COUNT 100

#define MAX_LINE_LENGTH 1000

/* Debugging is enabled via --debug, which must be the first argument.  */

static int debug_mode = 0;

#define dprintf if (debug_mode) fprintf

/* Emulate the "/bin/true" command.  Arguments are ignored.  */

static int

true_func (char **argv)

{

  return 0;

}

/* Emulate the "/bin/echo" command.  Options are ignored, arguments

   are printed to stdout.  */

static int

echo_func (char **argv)

{

  int i;

  for (i = 0; argv[i]; i++)

    {

      if (i > 0)

	putchar (' ');

      fputs (argv[i], stdout);

    }

  putchar ('\n');

  return 0;

}

/* Emulate the "/bin/cp" command.  Options are ignored.  Only copies

   one source file to one destination file.  Directory destinations

   are not supported.  */

static int

copy_func (char **argv)

{

  char *sname = argv[0];

  char *dname = argv[1];

  int sfd, dfd;

  struct stat st;

  sfd = open (sname, O_RDONLY);

  if (sfd < 0)

    {

      fprintf (stderr, "cp: unable to open %s for reading: %s\n",

	       sname, strerror (errno));

      return 1;

    }

  if (fstat (sfd, &st) < 0)

    {

      fprintf (stderr, "cp: unable to fstat %s: %s\n",

	       sname, strerror (errno));

      return 1;

    }

  dfd = open (dname, O_WRONLY | O_TRUNC | O_CREAT, 0600);

  if (dfd < 0)

    {

      fprintf (stderr, "cp: unable to open %s for writing: %s\n",

	       dname, strerror (errno));

      return 1;

    }

  if (support_copy_file_range (sfd, 0, dfd, 0, st.st_size, 0) != st.st_size)

    {

      fprintf (stderr, "cp: cannot copy file %s to %s: %s\n",

	       sname, dname, strerror (errno));

      return 1;

    }

  close (sfd);

  close (dfd);

  chmod (dname, st.st_mode & 0777);

  return 0;

}

/* This is a list of all the built-in commands we understand.  */

static struct {

  const char *name;

  int (*func) (char **argv);

} builtin_funcs[] = {

  { "true", true_func },

  { "echo", echo_func },

  { "cp", copy_func },

  { NULL, NULL }

};

/* Run one tokenized command.  argv[0] is the command.  argv is

   NULL-terminated.  */

static void

run_command_array (char **argv)

{

  int i, j;

  pid_t pid;

  int status;

  int (*builtin_func) (char **args);

  if (argv[0] == NULL)

    return;

  builtin_func = NULL;

  int new_stdin = 0;

  int new_stdout = 1;

  int new_stderr = 2;

  dprintf (stderr, "run_command_array starting\n");

  for (i = 0; argv[i]; i++)

    dprintf (stderr, "   argv [%d] `%s'\n", i, argv[i]);

  for (j = i = 0; argv[i]; i++)

    {

      if (strcmp (argv[i], "<") == 0 && argv[i + 1])

	{

	  new_stdin = open (argv[i + 1], O_WRONLY|O_CREAT|O_TRUNC, 0777);

	  ++i;

	  continue;

	}

      if (strcmp (argv[i], ">") == 0 && argv[i + 1])

	{

	  new_stdout = open (argv[i + 1], O_WRONLY|O_CREAT|O_TRUNC, 0777);

	  ++i;

	  continue;

	}

      if (strcmp (argv[i], ">>") == 0 && argv[i + 1])

	{

	  new_stdout = open (argv[i + 1], O_WRONLY|O_CREAT|O_APPEND, 0777);

	  ++i;

	  continue;

	}

      if (strcmp (argv[i], "2>") == 0 && argv[i + 1])

	{

	  new_stderr = open (argv[i + 1], O_WRONLY|O_CREAT|O_TRUNC, 0777);

	  ++i;

	  continue;

	}

      argv[j++] = argv[i];

    }

  argv[j] = NULL;

  for (i = 0; builtin_funcs[i].name != NULL; i++)

    if (strcmp (argv[0], builtin_funcs[i].name) == 0)

       builtin_func = builtin_funcs[i].func;

  dprintf (stderr, "builtin %p argv0 `%s'\n", builtin_func, argv[0]);

  pid = fork ();

  if (pid < 0)

    {

      fprintf (stderr, "sh: fork failed\n");

      exit (1);

    }

  if (pid == 0)

    {

      if (new_stdin != 0)

	{

	  dup2 (new_stdin, 0);

	  close (new_stdin);

	}

      if (new_stdout != 1)

	{

	  dup2 (new_stdout, 1);

	  close (new_stdout);

	}

      if (new_stderr != 2)

	{

	  dup2 (new_stderr, 2);

	  close (new_stdout);

	}

      if (builtin_func != NULL)

	exit (builtin_func (argv + 1));

      execvp (argv[0], argv);

      fprintf (stderr, "sh: execing %s failed: %s",

	       argv[0], strerror (errno));

      exit (1);

    }

  waitpid (pid, &status, 0);

  dprintf (stderr, "exiting run_command_array\n");

  if (WIFEXITED (status))

    {

      int rv = WEXITSTATUS (status);

      if (rv)

	exit (rv);

    }

  else

    exit (1);

}

/* Run one command-as-a-string, by tokenizing it.  Limited to

   MAX_ARG_COUNT arguments.  Simple substitution is done of $1 to $9

   (as whole separate tokens) from iargs[].  Quoted strings work if

   the quotes wrap whole tokens; i.e. "foo bar" but not foo" bar".  */

static void

run_command_string (const char *cmdline, const char **iargs)

{

  char *args[MAX_ARG_COUNT+1];

  int ap = 0;

  const char *start, *end;

  int nargs;

  for (nargs = 0; iargs[nargs] != NULL; ++nargs)

    ;

  dprintf (stderr, "run_command_string starting: '%s'\n", cmdline);

  while (ap < MAX_ARG_COUNT)

    {

      /* If the argument is quoted, this is the quote character, else NUL.  */

      int in_quote = 0;

      /* Skip whitespace up to the next token.  */

      while (*cmdline && isspace (*cmdline))

	cmdline ++;

      if (*cmdline == 0)

	break;

      start = cmdline;

      /* Check for quoted argument.  */

      in_quote = (*cmdline == '\'' || *cmdline == '"') ? *cmdline : 0;

      /* Skip to end of token; either by whitespace or matching quote.  */

      dprintf (stderr, "in_quote %d\n", in_quote);

      while (*cmdline

	     && (!isspace (*cmdline) || in_quote))

	{

	  if (*cmdline == in_quote

	      && cmdline != start)

	    in_quote = 0;

	  dprintf (stderr, "[%c]%d ", *cmdline, in_quote);

	  cmdline ++;

	}

      dprintf (stderr, "\n");

      /* Allocate space for this token and store it in args[].  */

      end = cmdline;

      dprintf (stderr, "start<%s> end<%s>\n", start, end);

      args[ap] = (char *) xmalloc (end - start + 1);

      memcpy (args[ap], start, end - start);

      args[ap][end - start] = 0;

      /* Strip off quotes, if found.  */

      dprintf (stderr, "args[%d] = <%s>\n", ap, args[ap]);

      if (args[ap][0] == '\''

	  && args[ap][strlen (args[ap])-1] == '\'')

	{

	  args[ap][strlen (args[ap])-1] = 0;

	  args[ap] ++;

	}

      else if (args[ap][0] == '"'

	  && args[ap][strlen (args[ap])-1] == '"')

	{

	  args[ap][strlen (args[ap])-1] = 0;

	  args[ap] ++;

	}

      /* Replace positional parameters like $4.  */

      else if (args[ap][0] == '$'

	       && isdigit (args[ap][1])

	       && args[ap][2] == 0)

	{

	  int a = args[ap][1] - '1';

	  if (0 <= a && a < nargs)

	    args[ap] = strdup (iargs[a]);

	}

      ap ++;

      if (*cmdline == 0)

	break;

    }

  /* Lastly, NULL terminate the array and run it.  */

  args[ap] = NULL;

  run_command_array (args);

}

/* Run a script by reading lines and passing them to the above

   function.  */

static void

run_script (const char *filename, const char **args)

{

  char line[MAX_LINE_LENGTH + 1];

  dprintf (stderr, "run_script starting: '%s'\n", filename);

  FILE *f = fopen (filename, "r");

  if (f == NULL)

    {

      fprintf (stderr, "sh: %s: %s\n", filename, strerror (errno));

      exit (1);

    }

  while (fgets (line, sizeof (line), f) != NULL)

    {

      if (line[0] == '#')

	{

	  dprintf (stderr, "comment: %s\n", line);

	  continue;

	}

      run_command_string (line, args);

    }

  fclose (f);

}

int

main (int argc, const char **argv)

{

  int i;

  if (strcmp (argv[1], "--debug") == 0)

    {

      debug_mode = 1;

      --argc;

      ++argv;

    }

  dprintf (stderr, "container-sh starting:\n");

  for (i = 0; i < argc; i++)

    dprintf (stderr, "  argv[%d] is `%s'\n", i, argv[i]);

  if (strcmp (argv[1], "-c") == 0)

    run_command_string (argv[2], argv+3);

  else

    run_script (argv[1], argv+2);

  dprintf (stderr, "normal exit 0\n");

  return 0;

}