/* gspawn.c - Process launching

 *

 *  Copyright 2000 Red Hat, Inc.

 *  g_execvpe implementation based on GNU libc execvp:

 *   Copyright 1991, 92, 95, 96, 97, 98, 99 Free Software Foundation, Inc.

 *

 * GLib 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 of the

 * License, or (at your option) any later version.

 *

 * GLib 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 GLib; see the file COPYING.LIB.  If not, write

 * to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

#include "config.h"

#include <sys/time.h>

#include <sys/types.h>

#include <sys/wait.h>

#include <unistd.h>

#include <errno.h>

#include <fcntl.h>

#include <signal.h>

#include <string.h>

#include <stdlib.h>   /* for fdwalk */

#include <dirent.h>

#ifdef HAVE_SYS_SELECT_H

#include <sys/select.h>

#endif /* HAVE_SYS_SELECT_H */

#ifdef HAVE_SYS_RESOURCE_H

#include <sys/resource.h>

#endif /* HAVE_SYS_RESOURCE_H */

#include "glib.h"

#include "glibintl.h"

#include "galias.h"

static gint g_execute (const gchar  *file,

                       gchar **argv,

                       gchar **envp,

                       gboolean search_path);

static gboolean make_pipe            (gint                  p[2],

                                      GError              **error);

static gboolean fork_exec_with_pipes (gboolean              intermediate_child,

                                      const gchar          *working_directory,

                                      gchar               **argv,

                                      gchar               **envp,

                                      gboolean              close_descriptors,

                                      gboolean              search_path,

                                      gboolean              stdout_to_null,

                                      gboolean              stderr_to_null,

                                      gboolean              child_inherits_stdin,

                                      gboolean              file_and_argv_zero,

                                      GSpawnChildSetupFunc  child_setup,

                                      gpointer              user_data,

                                      GPid                 *child_pid,

                                      gint                 *standard_input,

                                      gint                 *standard_output,

                                      gint                 *standard_error,

                                      GError              **error);

GQuark

g_spawn_error_quark (void)

{

  return g_quark_from_static_string ("g-exec-error-quark");

}

/**

 * g_spawn_async:

 * @working_directory: child's current working directory, or %NULL to inherit parent's

 * @argv: child's argument vector

 * @envp: child's environment, or %NULL to inherit parent's

 * @flags: flags from #GSpawnFlags

 * @child_setup: function to run in the child just before exec()

 * @user_data: user data for @child_setup

 * @child_pid: return location for child process reference, or %NULL

 * @error: return location for error

 * 

 * See g_spawn_async_with_pipes() for a full description; this function

 * simply calls the g_spawn_async_with_pipes() without any pipes.

 *

 * You should call g_spawn_close_pid() on the returned child process

 * reference when you don't need it any more.

 * 

 * <note><para>

 * If you are writing a GTK+ application, and the program you 

 * are spawning is a graphical application, too, then you may

 * want to use gdk_spawn_on_screen() instead to ensure that 

 * the spawned program opens its windows on the right screen.

 * </para></note>

 *

 * <note><para> Note that the returned @child_pid on Windows is a

 * handle to the child process and not its identifier. Process handles

 * and process identifiers are different concepts on Windows.

 * </para></note>

 *

 * Return value: %TRUE on success, %FALSE if error is set

 **/

gboolean

g_spawn_async (const gchar          *working_directory,

               gchar               **argv,

               gchar               **envp,

               GSpawnFlags           flags,

               GSpawnChildSetupFunc  child_setup,

               gpointer              user_data,

               GPid                 *child_pid,

               GError              **error)

{

  g_return_val_if_fail (argv != NULL, FALSE);

  return g_spawn_async_with_pipes (working_directory,

                                   argv, envp,

                                   flags,

                                   child_setup,

                                   user_data,

                                   child_pid,

                                   NULL, NULL, NULL,

                                   error);

}

/* Avoids a danger in threaded situations (calling close()

 * on a file descriptor twice, and another thread has

 * re-opened it since the first close)

 */

static gint

close_and_invalidate (gint *fd)

{

  gint ret;

  if (*fd < 0)

    return -1;

  else

    {

      ret = close (*fd);

      *fd = -1;

    }

  return ret;

}

/* Some versions of OS X define READ_OK in public headers */

#undef READ_OK

typedef enum

{

  READ_FAILED = 0, /* FALSE */

  READ_OK,

  READ_EOF

} ReadResult;

static ReadResult

read_data (GString *str,

           gint     fd,

           GError **error)

{

  gssize bytes;        

  gchar buf[4096];    

 again:

  bytes = read (fd, buf, 4096);

  if (bytes == 0)

    return READ_EOF;

  else if (bytes > 0)

    {

      g_string_append_len (str, buf, bytes);

      return READ_OK;

    }

  else if (bytes < 0 && errno == EINTR)

    goto again;

  else if (bytes < 0)

    {

      g_set_error (error,

                   G_SPAWN_ERROR,

                   G_SPAWN_ERROR_READ,

                   _("Failed to read data from child process (%s)"),

                   g_strerror (errno));

      return READ_FAILED;

    }

  else

    return READ_OK;

}

/**

 * g_spawn_sync:

 * @working_directory: child's current working directory, or %NULL to inherit parent's

 * @argv: child's argument vector

 * @envp: child's environment, or %NULL to inherit parent's

 * @flags: flags from #GSpawnFlags 

 * @child_setup: function to run in the child just before exec()

 * @user_data: user data for @child_setup

 * @standard_output: return location for child output, or %NULL

 * @standard_error: return location for child error messages, or %NULL

 * @exit_status: return location for child exit status, as returned by waitpid(), or %NULL

 * @error: return location for error, or %NULL

 *

 * Executes a child synchronously (waits for the child to exit before returning).

 * All output from the child is stored in @standard_output and @standard_error,

 * if those parameters are non-%NULL. Note that you must set the  

 * %G_SPAWN_STDOUT_TO_DEV_NULL and %G_SPAWN_STDERR_TO_DEV_NULL flags when

 * passing %NULL for @standard_output and @standard_error.

 * If @exit_status is non-%NULL, the exit status of the child is stored

 * there as it would be returned by waitpid(); standard UNIX macros such 

 * as WIFEXITED() and WEXITSTATUS() must be used to evaluate the exit status.

 * Note that this function call waitpid() even if @exit_status is %NULL, and

 * does not accept the %G_SPAWN_DO_NOT_REAP_CHILD flag.

 * If an error occurs, no data is returned in @standard_output, 

 * @standard_error, or @exit_status. 

 *

 * This function calls g_spawn_async_with_pipes() internally; see that

 * function for full details on the other parameters and details on

 * how these functions work on Windows.

 * 

 * Return value: %TRUE on success, %FALSE if an error was set.

 **/

gboolean

g_spawn_sync (const gchar          *working_directory,

              gchar               **argv,

              gchar               **envp,

              GSpawnFlags           flags,

              GSpawnChildSetupFunc  child_setup,

              gpointer              user_data,

              gchar               **standard_output,

              gchar               **standard_error,

              gint                 *exit_status,

              GError              **error)     

{

  gint outpipe = -1;

  gint errpipe = -1;

  GPid pid;

  fd_set fds;

  gint ret;

  GString *outstr = NULL;

  GString *errstr = NULL;

  gboolean failed;

  gint status;

  g_return_val_if_fail (argv != NULL, FALSE);

  g_return_val_if_fail (!(flags & G_SPAWN_DO_NOT_REAP_CHILD), FALSE);

  g_return_val_if_fail (standard_output == NULL ||

                        !(flags & G_SPAWN_STDOUT_TO_DEV_NULL), FALSE);

  g_return_val_if_fail (standard_error == NULL ||

                        !(flags & G_SPAWN_STDERR_TO_DEV_NULL), FALSE);

  /* Just to ensure segfaults if callers try to use

   * these when an error is reported.

   */

  if (standard_output)

    *standard_output = NULL;

  if (standard_error)

    *standard_error = NULL;

  if (!fork_exec_with_pipes (FALSE,

                             working_directory,

                             argv,

                             envp,

                             !(flags & G_SPAWN_LEAVE_DESCRIPTORS_OPEN),

                             (flags & G_SPAWN_SEARCH_PATH) != 0,

                             (flags & G_SPAWN_STDOUT_TO_DEV_NULL) != 0,

                             (flags & G_SPAWN_STDERR_TO_DEV_NULL) != 0,

                             (flags & G_SPAWN_CHILD_INHERITS_STDIN) != 0,

                             (flags & G_SPAWN_FILE_AND_ARGV_ZERO) != 0,

                             child_setup,

                             user_data,

                             &pid,

                             NULL,

                             standard_output ? &outpipe : NULL,

                             standard_error ? &errpipe : NULL,

                             error))

    return FALSE;

  /* Read data from child. */

  failed = FALSE;

  if (outpipe >= 0)

    {

      outstr = g_string_new (NULL);

    }

  if (errpipe >= 0)

    {

      errstr = g_string_new (NULL);

    }

  /* Read data until we get EOF on both pipes. */

  while (!failed &&

         (outpipe >= 0 ||

          errpipe >= 0))

    {

      ret = 0;

      FD_ZERO (&fds);

      if (outpipe >= 0)

        FD_SET (outpipe, &fds);

      if (errpipe >= 0)

        FD_SET (errpipe, &fds);

      ret = select (MAX (outpipe, errpipe) + 1,

                    &fds,

                    NULL, NULL,

                    NULL /* no timeout */);

      if (ret < 0 && errno != EINTR)

        {

          failed = TRUE;

          g_set_error (error,

                       G_SPAWN_ERROR,

                       G_SPAWN_ERROR_READ,

                       _("Unexpected error in select() reading data from a child process (%s)"),

                       g_strerror (errno));

          break;

        }

      if (outpipe >= 0 && FD_ISSET (outpipe, &fds))

        {

          switch (read_data (outstr, outpipe, error))

            {

            case READ_FAILED:

              failed = TRUE;

              break;

            case READ_EOF:

              close_and_invalidate (&outpipe);

              outpipe = -1;

              break;

            default:

              break;

            }

          if (failed)

            break;

        }

      if (errpipe >= 0 && FD_ISSET (errpipe, &fds))

        {

          switch (read_data (errstr, errpipe, error))

            {

            case READ_FAILED:

              failed = TRUE;

              break;

            case READ_EOF:

              close_and_invalidate (&errpipe);

              errpipe = -1;

              break;

            default:

              break;

            }

          if (failed)

            break;

        }

    }

  /* These should only be open still if we had an error.  */

  if (outpipe >= 0)

    close_and_invalidate (&outpipe);

  if (errpipe >= 0)

    close_and_invalidate (&errpipe);

  /* Wait for child to exit, even if we have

   * an error pending.

   */

 again:

  ret = waitpid (pid, &status, 0);

  if (ret < 0)

    {

      if (errno == EINTR)

        goto again;

      else if (errno == ECHILD)

        {

          if (exit_status)

            {

              g_warning ("In call to g_spawn_sync(), exit status of a child process was requested but SIGCHLD action was set to SIG_IGN and ECHILD was received by waitpid(), so exit status can't be returned. This is a bug in the program calling g_spawn_sync(); either don't request the exit status, or don't set the SIGCHLD action.");

            }

          else

            {

              /* We don't need the exit status. */

            }

        }

      else

        {

          if (!failed) /* avoid error pileups */

            {

              failed = TRUE;

              g_set_error (error,

                           G_SPAWN_ERROR,

                           G_SPAWN_ERROR_READ,

                           _("Unexpected error in waitpid() (%s)"),

                           g_strerror (errno));

            }

        }

    }

  if (failed)

    {

      if (outstr)

        g_string_free (outstr, TRUE);

      if (errstr)

        g_string_free (errstr, TRUE);

      return FALSE;

    }

  else

    {

      if (exit_status)

        *exit_status = status;

      if (standard_output)        

        *standard_output = g_string_free (outstr, FALSE);

      if (standard_error)

        *standard_error = g_string_free (errstr, FALSE);

      return TRUE;

    }

}

/**

 * g_spawn_async_with_pipes:

 * @working_directory: child's current working directory, or %NULL to inherit parent's, in the GLib file name encoding

 * @argv: child's argument vector, in the GLib file name encoding

 * @envp: child's environment, or %NULL to inherit parent's, in the GLib file name encoding

 * @flags: flags from #GSpawnFlags

 * @child_setup: function to run in the child just before exec()

 * @user_data: user data for @child_setup

 * @child_pid: return location for child process ID, or %NULL

 * @standard_input: return location for file descriptor to write to child's stdin, or %NULL

 * @standard_output: return location for file descriptor to read child's stdout, or %NULL

 * @standard_error: return location for file descriptor to read child's stderr, or %NULL

 * @error: return location for error

 *

 * Executes a child program asynchronously (your program will not

 * block waiting for the child to exit). The child program is

 * specified by the only argument that must be provided, @argv. @argv

 * should be a %NULL-terminated array of strings, to be passed as the

 * argument vector for the child. The first string in @argv is of

 * course the name of the program to execute. By default, the name of

 * the program must be a full path; the <envar>PATH</envar> shell variable 

 * will only be searched if you pass the %G_SPAWN_SEARCH_PATH flag.

 *

 * On Windows, note that all the string or string vector arguments to

 * this function and the other g_spawn*() functions are in UTF-8, the

 * GLib file name encoding. Unicode characters that are not part of

 * the system codepage passed in these arguments will be correctly

 * available in the spawned program only if it uses wide character API

 * to retrieve its command line. For C programs built with Microsoft's

 * tools it is enough to make the program have a wmain() instead of

 * main(). wmain() has a wide character argument vector as parameter.

 *

 * At least currently, mingw doesn't support wmain(), so if you use

 * mingw to develop the spawned program, it will have to call the

 * undocumented function __wgetmainargs() to get the wide character

 * argument vector and environment. See gspawn-win32-helper.c in the

 * GLib sources or init.c in the mingw runtime sources for a prototype

 * for that function. Alternatively, you can retrieve the Win32 system

 * level wide character command line passed to the spawned program

 * using the GetCommandLineW() function.

 *

 * On Windows the low-level child process creation API

 * <function>CreateProcess()</function> doesn't use argument vectors,

 * but a command line. The C runtime library's

 * <function>spawn*()</function> family of functions (which

 * g_spawn_async_with_pipes() eventually calls) paste the argument

 * vector elements together into a command line, and the C runtime startup code

 * does a corresponding reconstruction of an argument vector from the

 * command line, to be passed to main(). Complications arise when you have

 * argument vector elements that contain spaces of double quotes. The

 * <function>spawn*()</function> functions don't do any quoting or

 * escaping, but on the other hand the startup code does do unquoting

 * and unescaping in order to enable receiving arguments with embedded

 * spaces or double quotes. To work around this asymmetry,

 * g_spawn_async_with_pipes() will do quoting and escaping on argument

 * vector elements that need it before calling the C runtime

 * spawn() function.

 *

 * The returned @child_pid on Windows is a handle to the child

 * process, not its identifier. Process handles and process

 * identifiers are different concepts on Windows.

 *

 * @envp is a %NULL-terminated array of strings, where each string

 * has the form <literal>KEY=VALUE</literal>. This will become

 * the child's environment. If @envp is %NULL, the child inherits its

 * parent's environment.

 *

 * @flags should be the bitwise OR of any flags you want to affect the

 * function's behaviour. The %G_SPAWN_DO_NOT_REAP_CHILD means that 

 * the child will not automatically be reaped; you must use a

 * #GChildWatch source to be notified about the death of the child 

 * process. Eventually you must call g_spawn_close_pid() on the

 * @child_pid, in order to free resources which may be associated

 * with the child process. (On Unix, using a #GChildWatch source is

 * equivalent to calling waitpid() or handling the %SIGCHLD signal 

 * manually. On Windows, calling g_spawn_close_pid() is equivalent

 * to calling CloseHandle() on the process handle returned in 

 * @child_pid).

 *

 * %G_SPAWN_LEAVE_DESCRIPTORS_OPEN means that the parent's open file

 * descriptors will be inherited by the child; otherwise all

 * descriptors except stdin/stdout/stderr will be closed before

 * calling exec() in the child. %G_SPAWN_SEARCH_PATH 

 * means that <literal>argv[0]</literal> need not be an absolute path, it

 * will be looked for in the user's <envar>PATH</envar>. 

 * %G_SPAWN_STDOUT_TO_DEV_NULL means that the child's standard output will 

 * be discarded, instead of going to the same location as the parent's 

 * standard output. If you use this flag, @standard_output must be %NULL.

 * %G_SPAWN_STDERR_TO_DEV_NULL means that the child's standard error

 * will be discarded, instead of going to the same location as the parent's

 * standard error. If you use this flag, @standard_error must be %NULL.