/* exec.c --- executes a program in *this* pid, without an intervening process.
 * xscreensaver, Copyright (c) 1991-2013 Jamie Zawinski <jwz@jwz.org>
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation.  No representations are made about the suitability of this
 * software for any purpose.  It is provided "as is" without express or 
 * implied warranty.
 */


/* I don't believe what a sorry excuse for an operating system UNIX is!

   - I want to spawn a process.
   - I want to know it's pid so that I can kill it.
   - I would like to receive a message when it dies of natural causes.
   - I want the spawned process to have user-specified arguments.

   If shell metacharacters are present (wildcards, backquotes, etc), the
   only way to parse those arguments is to run a shell to do the parsing
   for you.

   And the only way to know the pid of the process is to fork() and exec()
   it in the spawned side of the fork.

   But if you're running a shell to parse your arguments, this gives you
   the pid of the *shell*, not the pid of the *process* that you're
   actually interested in, which is an *inferior* of the shell.  This also
   means that the SIGCHLD you get applies to the shell, not its inferior.
   (Why isn't that sufficient?  I don't remember any more, but it turns
   out that it isn't.)

   So, the only solution, when metacharacters are present, is to force the
   shell to exec() its inferior.  What a fucking hack!  We prepend "exec "
   to the command string, and hope it doesn't contain unquoted semicolons
   or ampersands (we don't search for them, because we don't want to
   prohibit their use in quoted strings (messages, for example) and parsing
   out the various quote characters is too much of a pain.)

   (Actually, Clint Wong <clint@jts.com> points out that process groups
   might be used to take care of this problem; this may be worth considering
   some day, except that, 1: this code works now, so why fix it, and 2: from
   what I've seen in Emacs, dealing with process groups isn't especially
   portable.)
 */

#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

#include <stdlib.h>
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif

#include <string.h>
#include <stdio.h>
#include <ctype.h>
#include <sys/stat.h>

#ifndef ESRCH
# include <errno.h>
#endif

#if defined(HAVE_SETPRIORITY) && defined(PRIO_PROCESS)
# include <sys/resource.h>	/* for setpriority() and PRIO_PROCESS */
				/* and also setrlimit() and RLIMIT_AS */
#endif

#ifdef VMS
# include <processes.h>
# include <unixio.h>		/* for close */
# include <unixlib.h>		/* for getpid */
# define pid_t int
# define fork  vfork
#endif /* VMS */

#include "exec.h"

extern const char *blurb (void);

static void nice_process (int nice_level);


#ifndef VMS

static void
exec_simple_command (const char *command)
{
  char *av[1024];
  int ac = 0;
  char *token = strtok (strdup(command), " \t");
  while (token)
    {
      av[ac++] = token;
      token = strtok(0, " \t");
    }
  av[ac] = 0;

  execvp (av[0], av);	/* shouldn't return. */
}


static void
exec_complex_command (const char *shell, const char *command)
{
  char *av[5];
  int ac = 0;
  char *command2 = (char *) malloc (strlen (command) + 10);
  const char *s;
  int got_eq = 0;
  const char *after_vars;

  /* Skip leading whitespace.
   */
  while (*command == ' ' || *command == '\t')
    command++;

  /* If the string has a series of tokens with "=" in them at them, set
     `after_vars' to point into the string after those tokens and any
     trailing whitespace.  Otherwise, after_vars == command.
   */
  after_vars = command;
  for (s = command; *s; s++)
    {
      if (*s == '=') got_eq = 1;
      else if (*s == ' ')
        {
          if (got_eq)
            {
              while (*s == ' ' || *s == '\t')
                s++;
              after_vars = s;
              got_eq = 0;
            }
          else
            break;
        }
    }

  *command2 = 0;
  strncat (command2, command, after_vars - command);
  strcat (command2, "exec ");
  strcat (command2, after_vars);

  /* We have now done these transformations:
     "foo -x -y"               ==>  "exec foo -x -y"
     "BLAT=foop      foo -x"   ==>  "BLAT=foop      exec foo -x"
     "BLAT=foop A=b  foo -x"   ==>  "BLAT=foop A=b  exec foo -x"
   */


  /* Invoke the shell as "/bin/sh -c 'exec prog -arg -arg ...'" */
  av [ac++] = (char *) shell;
  av [ac++] = "-c";
  av [ac++] = command2;
  av [ac]   = 0;

  execvp (av[0], av);	/* shouldn't return. */
}

#else  /* VMS */

static void
exec_vms_command (const char *command)
{
  system (command);
  fflush (stderr);
  fflush (stdout);
  exit (1);	/* Note that this only exits a child fork.  */
}

#endif /* !VMS */


void
exec_command (const char *shell, const char *command, int nice_level)
{
  int hairy_p;

#ifndef VMS
  nice_process (nice_level);

  hairy_p = !!strpbrk (command, "*?$&!<>[];`'\\\"=");
  /* note: = is in the above because of the sh syntax "FOO=bar cmd". */

  if (getuid() == (uid_t) 0 || geteuid() == (uid_t) 0)
    {
      /* If you're thinking of commenting this out, think again.
         If you do so, you will open a security hole.  Mail jwz
         so that he may enlighten you as to the error of your ways.
       */
      fprintf (stderr, "%s: we're still running as root!  Disaster!\n",
               blurb());
      exit (-1);
    }

  if (hairy_p)
    /* If it contains any shell metacharacters, do it the hard way,
       and fork a shell to parse the arguments for us. */
    exec_complex_command (shell, command);
  else
    /* Otherwise, we can just exec the program directly. */
    exec_simple_command (command);

#else  /* VMS */
  exec_vms_command (command);
#endif /* VMS */
}


/* Setting process priority
 */

static void
nice_process (int nice_level)
{
  if (nice_level == 0)
    return;

#if defined(HAVE_NICE)
  {
    int old_nice = nice (0);
    int n = nice_level - old_nice;
    errno = 0;
    if (nice (n) == -1 && errno != 0)
      {
	char buf [512];
	sprintf (buf, "%s: nice(%d) failed", blurb(), n);
	perror (buf);
    }
  }
#elif defined(HAVE_SETPRIORITY) && defined(PRIO_PROCESS)
  if (setpriority (PRIO_PROCESS, getpid(), nice_level) != 0)
    {
      char buf [512];
      sprintf (buf, "%s: setpriority(PRIO_PROCESS, %lu, %d) failed",
	       blurb(), (unsigned long) getpid(), nice_level);
      perror (buf);
    }
#else
  fprintf (stderr,
	   "%s: don't know how to change process priority on this system.\n",
	   blurb());

#endif
}


/* Whether the given command exists on $PATH.
   (Anything before the first space is considered to be the program name.)
 */
int
on_path_p (const char *program)
{
  int result = 0;
  struct stat st;
  char *cmd = strdup (program);
  char *token = strchr (cmd, ' ');
  char *path = 0;
  int L;

  if (token) *token = 0;
  token = 0;

  if (strchr (cmd, '/'))
    {
      result = (0 == stat (cmd, &st));
      goto DONE;
    }

  path = getenv("PATH");
  if (!path || !*path)
    goto DONE;

  L = strlen (cmd);
  path = strdup (path);
  token = strtok (path, ":");

  while (token)
    {
      char *p2 = (char *) malloc (strlen (token) + L + 3);
      strcpy (p2, token);
      strcat (p2, "/");
      strcat (p2, cmd);
      result = (0 == stat (p2, &st));
      free (p2);
      if (result)
        goto DONE;
      token = strtok (0, ":");
    }

 DONE:
  free (cmd);
  if (path) free (path);
  return result;
}

