glib/gspawn.c

   1 /* gspawn.c - Process launching
   2  *
   3  *  Copyright 2000 Red Hat, Inc.
   4  *  g_execvpe implementation based on GNU libc execvp:
   5  *   Copyright 1991, 92, 95, 96, 97, 98, 99 Free Software Foundation, Inc.
   6  *
   7  * GLib is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public License as
   9  * published by the Free Software Foundation; either version 2 of the
  10  * License, or (at your option) any later version.
  11  *
  12  * GLib is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with GLib; see the file COPYING.LIB.  If not, write
  19  * to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 #include "config.h"
  24
  25 #include <sys/time.h>
  26 #include <sys/types.h>
  27 #include <sys/wait.h>
  28 #include <unistd.h>
  29 #include <errno.h>
  30 #include <fcntl.h>
  31 #include <signal.h>
  32 #include <string.h>
  33 #include <stdlib.h>   /* for fdwalk */
  34 #include <dirent.h>
  35
  36 #ifdef HAVE_SYS_SELECT_H
  37 #include <sys/select.h>
  38 #endif /* HAVE_SYS_SELECT_H */
  39
  40 #ifdef HAVE_SYS_RESOURCE_H
  41 #include <sys/resource.h>
  42 #endif /* HAVE_SYS_RESOURCE_H */
  43
  44 #include "gspawn.h"
  45 #include "gthread.h"
  46 #include "glib/gstdio.h"
  47
  48 #include "genviron.h"
  49 #include "gmem.h"
  50 #include "gshell.h"
  51 #include "gstring.h"
  52 #include "gstrfuncs.h"
  53 #include "gtestutils.h"
  54 #include "gutils.h"
  55 #include "glibintl.h"
  56 #include "glib-unix.h"
  57
  58 /**
  59  * SECTION:spawn
  60  * @Short_description: process launching
  61  * @Title: Spawning Processes
  62  */
  63
  64
  65
  66 static gint g_execute (const gchar  *file,
  67                        gchar **argv,
  68                        gchar **envp,
  69                        gboolean search_path,
  70                        gboolean search_path_from_envp);
  71
  72 static gboolean fork_exec_with_pipes (gboolean              intermediate_child,
  73                                       const gchar          *working_directory,
  74                                       gchar               **argv,
  75                                       gchar               **envp,
  76                                       gboolean              close_descriptors,
  77                                       gboolean              search_path,
  78                                       gboolean              search_path_from_envp,
  79                                       gboolean              stdout_to_null,
  80                                       gboolean              stderr_to_null,
  81                                       gboolean              child_inherits_stdin,
  82                                       gboolean              file_and_argv_zero,
  83                                       gboolean              cloexec_pipes,
  84                                       GSpawnChildSetupFunc  child_setup,
  85                                       gpointer              user_data,
  86                                       GPid                 *child_pid,
  87                                       gint                 *standard_input,
  88                                       gint                 *standard_output,
  89                                       gint                 *standard_error,
  90                                       GError              **error);
  91
  92 G_DEFINE_QUARK (g-exec-error-quark, g_spawn_error)
  93 G_DEFINE_QUARK (g-spawn-exit-error-quark, g_spawn_exit_error)
  94
  95 /**
  96  * g_spawn_async:
  97  * @working_directory: (allow-none): child's current working directory, or %NULL to inherit parent's
  98  * @argv: (array zero-terminated=1): child's argument vector
  99  * @envp: (array zero-terminated=1) (allow-none): child's environment, or %NULL to inherit parent's
 100  * @flags: flags from #GSpawnFlags
 101  * @child_setup: (scope async) (allow-none): function to run in the child just before exec()
 102  * @user_data: (closure): user data for @child_setup
 103  * @child_pid: (out) (allow-none): return location for child process reference, or %NULL
 104  * @error: return location for error
 105  *
 106  * See g_spawn_async_with_pipes() for a full description; this function
 107  * simply calls the g_spawn_async_with_pipes() without any pipes.
 108  *
 109  * You should call g_spawn_close_pid() on the returned child process
 110  * reference when you don't need it any more.
 111  *
 112  * If you are writing a GTK+ application, and the program you are
 113  * spawning is a graphical application, too, then you may want to
 114  * use gdk_spawn_on_screen() instead to ensure that the spawned program
 115  * opens its windows on the right screen.
 116  *
 117  * Note that the returned @child_pid on Windows is a handle to the child
 118  * process and not its identifier. Process handles and process identifiers
 119  * are different concepts on Windows.
 120  *
 121  * Returns: %TRUE on success, %FALSE if error is set
 122  **/
 123 gboolean
 124 g_spawn_async (const gchar          *working_directory,
 125                gchar               **argv,
 126                gchar               **envp,
 127                GSpawnFlags           flags,
 128                GSpawnChildSetupFunc  child_setup,
 129                gpointer              user_data,
 130                GPid                 *child_pid,
 131                GError              **error)
 132 {
 133   g_return_val_if_fail (argv != NULL, FALSE);
 134
 135   return g_spawn_async_with_pipes (working_directory,
 136                                    argv, envp,
 137                                    flags,
 138                                    child_setup,
 139                                    user_data,
 140                                    child_pid,
 141                                    NULL, NULL, NULL,
 142                                    error);
 143 }
 144
 145 /* Avoids a danger in threaded situations (calling close()
 146  * on a file descriptor twice, and another thread has
 147  * re-opened it since the first close)
 148  */
 149 static void
 150 close_and_invalidate (gint *fd)
 151 {
 152   if (*fd < 0)
 153     return;
 154   else
 155     {
 156       (void) g_close (*fd, NULL);
 157       *fd = -1;
 158     }
 159 }
 160
 161 /* Some versions of OS X define READ_OK in public headers */
 162 #undef READ_OK
 163
 164 typedef enum
 165 {
 166   READ_FAILED = 0, /* FALSE */
 167   READ_OK,
 168   READ_EOF
 169 } ReadResult;
 170
 171 static ReadResult
 172 read_data (GString *str,
 173            gint     fd,
 174            GError **error)
 175 {
 176   gssize bytes;
 177   gchar buf[4096];
 178
 179  again:
 180   bytes = read (fd, buf, 4096);
 181
 182   if (bytes == 0)
 183     return READ_EOF;
 184   else if (bytes > 0)
 185     {
 186       g_string_append_len (str, buf, bytes);
 187       return READ_OK;
 188     }
 189   else if (errno == EINTR)
 190     goto again;
 191   else
 192     {
 193       int errsv = errno;
 194
 195       g_set_error (error,
 196                    G_SPAWN_ERROR,
 197                    G_SPAWN_ERROR_READ,
 198                    _("Failed to read data from child process (%s)"),
 199                    g_strerror (errsv));
 200
 201       return READ_FAILED;
 202     }
 203 }
 204
 205 /**
 206  * g_spawn_sync:
 207  * @working_directory: (allow-none): child's current working directory, or %NULL to inherit parent's
 208  * @argv: (array zero-terminated=1): child's argument vector
 209  * @envp: (array zero-terminated=1) (allow-none): child's environment, or %NULL to inherit parent's
 210  * @flags: flags from #GSpawnFlags
 211  * @child_setup: (scope async) (allow-none): function to run in the child just before exec()
 212  * @user_data: (closure): user data for @child_setup
 213  * @standard_output: (out) (array zero-terminated=1) (element-type guint8) (allow-none): return location for child output, or %NULL
 214  * @standard_error: (out) (array zero-terminated=1) (element-type guint8) (allow-none): return location for child error messages, or %NULL
 215  * @exit_status: (out) (allow-none): return location for child exit status, as returned by waitpid(), or %NULL
 216  * @error: return location for error, or %NULL
 217  *
 218  * Executes a child synchronously (waits for the child to exit before returning).
 219  * All output from the child is stored in @standard_output and @standard_error,
 220  * if those parameters are non-%NULL. Note that you must set the
 221  * %G_SPAWN_STDOUT_TO_DEV_NULL and %G_SPAWN_STDERR_TO_DEV_NULL flags when
 222  * passing %NULL for @standard_output and @standard_error.
 223  *
 224  * If @exit_status is non-%NULL, the platform-specific exit status of
 225  * the child is stored there; see the documentation of
 226  * g_spawn_check_exit_status() for how to use and interpret this.
 227  * Note that it is invalid to pass %G_SPAWN_DO_NOT_REAP_CHILD in
 228  * @flags.
 229  *
 230  * If an error occurs, no data is returned in @standard_output,
 231  * @standard_error, or @exit_status.
 232  *
 233  * This function calls g_spawn_async_with_pipes() internally; see that
 234  * function for full details on the other parameters and details on
 235  * how these functions work on Windows.
 236  *
 237  * Returns: %TRUE on success, %FALSE if an error was set
 238  */
 239 gboolean
 240 g_spawn_sync (const gchar          *working_directory,
 241               gchar               **argv,
 242               gchar               **envp,
 243               GSpawnFlags           flags,
 244               GSpawnChildSetupFunc  child_setup,
 245               gpointer              user_data,
 246               gchar               **standard_output,
 247               gchar               **standard_error,
 248               gint                 *exit_status,
 249               GError              **error)
 250 {
 251   gint outpipe = -1;
 252   gint errpipe = -1;
 253   GPid pid;
 254   fd_set fds;
 255   gint ret;
 256   GString *outstr = NULL;
 257   GString *errstr = NULL;
 258   gboolean failed;
 259   gint status;
 260
 261   g_return_val_if_fail (argv != NULL, FALSE);
 262   g_return_val_if_fail (!(flags & G_SPAWN_DO_NOT_REAP_CHILD), FALSE);
 263   g_return_val_if_fail (standard_output == NULL ||
 264                         !(flags & G_SPAWN_STDOUT_TO_DEV_NULL), FALSE);
 265   g_return_val_if_fail (standard_error == NULL ||
 266                         !(flags & G_SPAWN_STDERR_TO_DEV_NULL), FALSE);
 267
 268   /* Just to ensure segfaults if callers try to use
 269    * these when an error is reported.
 270    */
 271   if (standard_output)
 272     *standard_output = NULL;
 273
 274   if (standard_error)
 275     *standard_error = NULL;
 276
 277   if (!fork_exec_with_pipes (FALSE,
 278                              working_directory,
 279                              argv,
 280                              envp,
 281                              !(flags & G_SPAWN_LEAVE_DESCRIPTORS_OPEN),
 282                              (flags & G_SPAWN_SEARCH_PATH) != 0,
 283                              (flags & G_SPAWN_SEARCH_PATH_FROM_ENVP) != 0,
 284                              (flags & G_SPAWN_STDOUT_TO_DEV_NULL) != 0,
 285                              (flags & G_SPAWN_STDERR_TO_DEV_NULL) != 0,
 286                              (flags & G_SPAWN_CHILD_INHERITS_STDIN) != 0,
 287                              (flags & G_SPAWN_FILE_AND_ARGV_ZERO) != 0,
 288                              (flags & G_SPAWN_CLOEXEC_PIPES) != 0,
 289                              child_setup,
 290                              user_data,
 291                              &pid,
 292                              NULL,
 293                              standard_output ? &outpipe : NULL,
 294                              standard_error ? &errpipe : NULL,
 295                              error))
 296     return FALSE;
 297
 298   /* Read data from child. */
 299
 300   failed = FALSE;
 301
 302   if (outpipe >= 0)
 303     {
 304       outstr = g_string_new (NULL);
 305     }
 306
 307   if (errpipe >= 0)
 308     {
 309       errstr = g_string_new (NULL);
 310     }
 311
 312   /* Read data until we get EOF on both pipes. */
 313   while (!failed &&
 314          (outpipe >= 0 ||
 315           errpipe >= 0))
 316     {
 317       ret = 0;
 318
 319       FD_ZERO (&fds);
 320       if (outpipe >= 0)
 321         FD_SET (outpipe, &fds);
 322       if (errpipe >= 0)
 323         FD_SET (errpipe, &fds);
 324
 325       ret = select (MAX (outpipe, errpipe) + 1,
 326                     &fds,
 327                     NULL, NULL,
 328                     NULL /* no timeout */);
 329
 330       if (ret < 0)
 331         {
 332           int errsv = errno;
 333
 334           if (errno == EINTR)
 335             continue;
 336
 337           failed = TRUE;
 338
 339           g_set_error (error,
 340                        G_SPAWN_ERROR,
 341                        G_SPAWN_ERROR_READ,
 342                        _("Unexpected error in select() reading data from a child process (%s)"),
 343                        g_strerror (errsv));
 344
 345           break;
 346         }
 347
 348       if (outpipe >= 0 && FD_ISSET (outpipe, &fds))
 349         {
 350           switch (read_data (outstr, outpipe, error))
 351             {
 352             case READ_FAILED:
 353               failed = TRUE;
 354               break;
 355             case READ_EOF:
 356               close_and_invalidate (&outpipe);
 357               outpipe = -1;
 358               break;
 359             default:
 360               break;
 361             }
 362
 363           if (failed)
 364             break;
 365         }
 366
 367       if (errpipe >= 0 && FD_ISSET (errpipe, &fds))
 368         {
 369           switch (read_data (errstr, errpipe, error))
 370             {
 371             case READ_FAILED:
 372               failed = TRUE;
 373               break;
 374             case READ_EOF:
 375               close_and_invalidate (&errpipe);
 376               errpipe = -1;
 377               break;
 378             default:
 379               break;
 380             }
 381
 382           if (failed)
 383             break;
 384         }
 385     }
 386
 387   /* These should only be open still if we had an error.  */
 388
 389   if (outpipe >= 0)
 390     close_and_invalidate (&outpipe);
 391   if (errpipe >= 0)
 392     close_and_invalidate (&errpipe);
 393
 394   /* Wait for child to exit, even if we have
 395    * an error pending.
 396    */
 397  again:
 398
 399   ret = waitpid (pid, &status, 0);
 400
 401   if (ret < 0)
 402     {
 403       if (errno == EINTR)
 404         goto again;
 405       else if (errno == ECHILD)
 406         {
 407           if (exit_status)
 408             {
 409               g_warning ("In call to g_spawn_sync(), exit status of a child process was requested but ECHILD was received by waitpid(). Most likely the process is ignoring SIGCHLD, or some other thread is invoking waitpid() with a nonpositive first argument; either behavior can break applications that use g_spawn_sync either directly or indirectly.");
 410             }
 411           else
 412             {
 413               /* We don't need the exit status. */
 414             }
 415         }
 416       else
 417         {
 418           if (!failed) /* avoid error pileups */
 419             {
 420               int errsv = errno;
 421
 422               failed = TRUE;
 423
 424               g_set_error (error,
 425                            G_SPAWN_ERROR,
 426                            G_SPAWN_ERROR_READ,
 427                            _("Unexpected error in waitpid() (%s)"),
 428                            g_strerror (errsv));
 429             }
 430         }
 431     }
 432
 433   if (failed)
 434     {
 435       if (outstr)
 436         g_string_free (outstr, TRUE);
 437       if (errstr)
 438         g_string_free (errstr, TRUE);
 439
 440       return FALSE;
 441     }
 442   else
 443     {
 444       if (exit_status)
 445         *exit_status = status;
 446
 447       if (standard_output)
 448         *standard_output = g_string_free (outstr, FALSE);
 449
 450       if (standard_error)
 451         *standard_error = g_string_free (errstr, FALSE);
 452
 453       return TRUE;
 454     }
 455 }
 456
 457 /**
 458  * g_spawn_async_with_pipes:
 459  * @working_directory: (allow-none): child's current working directory, or %NULL to inherit parent's, in the GLib file name encoding
 460  * @argv: (array zero-terminated=1): child's argument vector, in the GLib file name encoding
 461  * @envp: (array zero-terminated=1) (allow-none): child's environment, or %NULL to inherit parent's, in the GLib file name encoding
 462  * @flags: flags from #GSpawnFlags
 463  * @child_setup: (scope async) (allow-none): function to run in the child just before exec()
 464  * @user_data: (closure): user data for @child_setup
 465  * @child_pid: (out) (allow-none): return location for child process ID, or %NULL
 466  * @standard_input: (out) (allow-none): return location for file descriptor to write to child's stdin, or %NULL
 467  * @standard_output: (out) (allow-none): return location for file descriptor to read child's stdout, or %NULL
 468  * @standard_error: (out) (allow-none): return location for file descriptor to read child's stderr, or %NULL
 469  * @error: return location for error
 470  *
 471  * Executes a child program asynchronously (your program will not
 472  * block waiting for the child to exit). The child program is
 473  * specified by the only argument that must be provided, @argv.
 474  * @argv should be a %NULL-terminated array of strings, to be passed
 475  * as the argument vector for the child. The first string in @argv
 476  * is of course the name of the program to execute. By default, the
 477  * name of the program must be a full path. If @flags contains the
 478  * %G_SPAWN_SEARCH_PATH flag, the `PATH` environment variable is
 479  * used to search for the executable. If @flags contains the
 480  * %G_SPAWN_SEARCH_PATH_FROM_ENVP flag, the `PATH` variable from
 481  * @envp is used to search for the executable. If both the
 482  * %G_SPAWN_SEARCH_PATH and %G_SPAWN_SEARCH_PATH_FROM_ENVP flags
 483  * are set, the `PATH` variable from @envp takes precedence over
 484  * the environment variable.
 485  *
 486  * If the program name is not a full path and %G_SPAWN_SEARCH_PATH flag is not
 487  * used, then the program will be run from the current directory (or
 488  * @working_directory, if specified); this might be unexpected or even
 489  * dangerous in some cases when the current directory is world-writable.
 490  *
 491  * On Windows, note that all the string or string vector arguments to
 492  * this function and the other g_spawn*() functions are in UTF-8, the
 493  * GLib file name encoding. Unicode characters that are not part of
 494  * the system codepage passed in these arguments will be correctly
 495  * available in the spawned program only if it uses wide character API
 496  * to retrieve its command line. For C programs built with Microsoft's
 497  * tools it is enough to make the program have a wmain() instead of
 498  * main(). wmain() has a wide character argument vector as parameter.
 499  *
 500  * At least currently, mingw doesn't support wmain(), so if you use
 501  * mingw to develop the spawned program, it will have to call the
 502  * undocumented function __wgetmainargs() to get the wide character
 503  * argument vector and environment. See gspawn-win32-helper.c in the
 504  * GLib sources or init.c in the mingw runtime sources for a prototype
 505  * for that function. Alternatively, you can retrieve the Win32 system
 506  * level wide character command line passed to the spawned program
 507  * using the GetCommandLineW() function.
 508  *
 509  * On Windows the low-level child process creation API CreateProcess()
 510  * doesn't use argument vectors, but a command line. The C runtime
 511  * library's spawn*() family of functions (which g_spawn_async_with_pipes()
 512  * eventually calls) paste the argument vector elements together into
 513  * a command line, and the C runtime startup code does a corresponding
 514  * reconstruction of an argument vector from the command line, to be
 515  * passed to main(). Complications arise when you have argument vector
 516  * elements that contain spaces of double quotes. The spawn*() functions
 517  * don't do any quoting or escaping, but on the other hand the startup
 518  * code does do unquoting and unescaping in order to enable receiving
 519  * arguments with embedded spaces or double quotes. To work around this
 520  * asymmetry, g_spawn_async_with_pipes() will do quoting and escaping on
 521  * argument vector elements that need it before calling the C runtime
 522  * spawn() function.
 523  *
 524  * The returned @child_pid on Windows is a handle to the child
 525  * process, not its identifier. Process handles and process
 526  * identifiers are different concepts on Windows.
 527  *
 528  * @envp is a %NULL-terminated array of strings, where each string
 529  * has the form `KEY=VALUE`. This will become the child's environment.
 530  * If @envp is %NULL, the child inherits its parent's environment.
 531  *
 532  * @flags should be the bitwise OR of any flags you want to affect the
 533  * function's behaviour. The %G_SPAWN_DO_NOT_REAP_CHILD means that the
 534  * child will not automatically be reaped; you must use a child watch to
 535  * be notified about the death of the child process. Eventually you must
 536  * call g_spawn_close_pid() on the @child_pid, in order to free
 537  * resources which may be associated with the child process. (On Unix,
 538  * using a child watch is equivalent to calling waitpid() or handling
 539  * the %SIGCHLD signal manually. On Windows, calling g_spawn_close_pid()
 540  * is equivalent to calling CloseHandle() on the process handle returned
 541  * in @child_pid). See g_child_watch_add().
 542  *
 543  * %G_SPAWN_LEAVE_DESCRIPTORS_OPEN means that the parent's open file
 544  * descriptors will be inherited by the child; otherwise all descriptors
 545  * except stdin/stdout/stderr will be closed before calling exec() in
 546  * the child. %G_SPAWN_SEARCH_PATH means that @argv[0] need not be an
 547  * absolute path, it will be looked for in the `PATH` environment
 548  * variable. %G_SPAWN_SEARCH_PATH_FROM_ENVP means need not be an
 549  * absolute path, it will be looked for in the `PATH` variable from
 550  * @envp. If both %G_SPAWN_SEARCH_PATH and %G_SPAWN_SEARCH_PATH_FROM_ENVP
 551  * are used, the value from @envp takes precedence over the environment.
 552  * %G_SPAWN_STDOUT_TO_DEV_NULL means that the child's standard output
 553  * will be discarded, instead of going to the same location as the parent's
 554  * standard output. If you use this flag, @standard_output must be %NULL.
 555  * %G_SPAWN_STDERR_TO_DEV_NULL means that the child's standard error
 556  * will be discarded, instead of going to the same location as the parent's
 557  * standard error. If you use this flag, @standard_error must be %NULL.
 558  * %G_SPAWN_CHILD_INHERITS_STDIN means that the child will inherit the parent's
 559  * standard input (by default, the child's standard input is attached to
 560  * /dev/null). If you use this flag, @standard_input must be %NULL.
 561  * %G_SPAWN_FILE_AND_ARGV_ZERO means that the first element of @argv is
 562  * the file to execute, while the remaining elements are the actual
 563  * argument vector to pass to the file. Normally g_spawn_async_with_pipes()
 564  * uses @argv[0] as the file to execute, and passes all of @argv to the child.
 565  *
 566  * @child_setup and @user_data are a function and user data. On POSIX
 567  * platforms, the function is called in the child after GLib has
 568  * performed all the setup it plans to perform (including creating
 569  * pipes, closing file descriptors, etc.) but before calling exec().
 570  * That is, @child_setup is called just before calling exec() in the
 571  * child. Obviously actions taken in this function will only affect
 572  * the child, not the parent.
 573  *
 574  * On Windows, there is no separate fork() and exec() functionality.
 575  * Child processes are created and run with a single API call,
 576  * CreateProcess(). There is no sensible thing @child_setup
 577  * could be used for on Windows so it is ignored and not called.
 578  *
 579  * If non-%NULL, @child_pid will on Unix be filled with the child's
 580  * process ID. You can use the process ID to send signals to the child,
 581  * or to use g_child_watch_add() (or waitpid()) if you specified the
 582  * %G_SPAWN_DO_NOT_REAP_CHILD flag. On Windows, @child_pid will be
 583  * filled with a handle to the child process only if you specified the
 584  * %G_SPAWN_DO_NOT_REAP_CHILD flag. You can then access the child
 585  * process using the Win32 API, for example wait for its termination
 586  * with the WaitFor*() functions, or examine its exit code with
 587  * GetExitCodeProcess(). You should close the handle with CloseHandle()
 588  * or g_spawn_close_pid() when you no longer need it.
 589  *
 590  * If non-%NULL, the @standard_input, @standard_output, @standard_error
 591  * locations will be filled with file descriptors for writing to the child's
 592  * standard input or reading from its standard output or standard error.
 593  * The caller of g_spawn_async_with_pipes() must close these file descriptors
 594  * when they are no longer in use. If these parameters are %NULL, the
 595  * corresponding pipe won't be created.
 596  *
 597  * If @standard_input is NULL, the child's standard input is attached to
 598  * /dev/null unless %G_SPAWN_CHILD_INHERITS_STDIN is set.
 599  *
 600  * If @standard_error is NULL, the child's standard error goes to the same
 601  * location as the parent's standard error unless %G_SPAWN_STDERR_TO_DEV_NULL
 602  * is set.
 603  *
 604  * If @standard_output is NULL, the child's standard output goes to the same
 605  * location as the parent's standard output unless %G_SPAWN_STDOUT_TO_DEV_NULL
 606  * is set.
 607  *
 608  * @error can be %NULL to ignore errors, or non-%NULL to report errors.
 609  * If an error is set, the function returns %FALSE. Errors are reported
 610  * even if they occur in the child (for example if the executable in
 611  * @argv[0] is not found). Typically the `message` field of returned
 612  * errors should be displayed to users. Possible errors are those from
 613  * the #G_SPAWN_ERROR domain.
 614  *
 615  * If an error occurs, @child_pid, @standard_input, @standard_output,
 616  * and @standard_error will not be filled with valid values.
 617  *
 618  * If @child_pid is not %NULL and an error does not occur then the returned
 619  * process reference must be closed using g_spawn_close_pid().
 620  *
 621  * If you are writing a GTK+ application, and the program you
 622  * are spawning is a graphical application, too, then you may
 623  * want to use gdk_spawn_on_screen_with_pipes() instead to ensure that
 624  * the spawned program opens its windows on the right screen.
 625  *
 626  * Returns: %TRUE on success, %FALSE if an error was set
 627  */
 628 gboolean
 629 g_spawn_async_with_pipes (const gchar          *working_directory,
 630                           gchar               **argv,
 631                           gchar               **envp,
 632                           GSpawnFlags           flags,
 633                           GSpawnChildSetupFunc  child_setup,
 634                           gpointer              user_data,
 635                           GPid                 *child_pid,
 636                           gint                 *standard_input,
 637                           gint                 *standard_output,
 638                           gint                 *standard_error,
 639                           GError              **error)
 640 {
 641   g_return_val_if_fail (argv != NULL, FALSE);
 642   g_return_val_if_fail (standard_output == NULL ||
 643                         !(flags & G_SPAWN_STDOUT_TO_DEV_NULL), FALSE);
 644   g_return_val_if_fail (standard_error == NULL ||
 645                         !(flags & G_SPAWN_STDERR_TO_DEV_NULL), FALSE);
 646   /* can't inherit stdin if we have an input pipe. */
 647   g_return_val_if_fail (standard_input == NULL ||
 648                         !(flags & G_SPAWN_CHILD_INHERITS_STDIN), FALSE);
 649
 650   return fork_exec_with_pipes (!(flags & G_SPAWN_DO_NOT_REAP_CHILD),
 651                                working_directory,
 652                                argv,
 653                                envp,
 654                                !(flags & G_SPAWN_LEAVE_DESCRIPTORS_OPEN),
 655                                (flags & G_SPAWN_SEARCH_PATH) != 0,
 656                                (flags & G_SPAWN_SEARCH_PATH_FROM_ENVP) != 0,
 657                                (flags & G_SPAWN_STDOUT_TO_DEV_NULL) != 0,
 658                                (flags & G_SPAWN_STDERR_TO_DEV_NULL) != 0,
 659                                (flags & G_SPAWN_CHILD_INHERITS_STDIN) != 0,
 660                                (flags & G_SPAWN_FILE_AND_ARGV_ZERO) != 0,
 661                                (flags & G_SPAWN_CLOEXEC_PIPES) != 0,
 662                                child_setup,
 663                                user_data,
 664                                child_pid,
 665                                standard_input,
 666                                standard_output,
 667                                standard_error,
 668                                error);
 669 }
 670
 671 /**
 672  * g_spawn_command_line_sync:
 673  * @command_line: a command line
 674  * @standard_output: (out) (array zero-terminated=1) (element-type guint8) (allow-none): return location for child output
 675  * @standard_error: (out) (array zero-terminated=1) (element-type guint8) (allow-none): return location for child errors
 676  * @exit_status: (out) (allow-none): return location for child exit status, as returned by waitpid()
 677  * @error: return location for errors
 678  *
 679  * A simple version of g_spawn_sync() with little-used parameters
 680  * removed, taking a command line instead of an argument vector.  See
 681  * g_spawn_sync() for full details. @command_line will be parsed by
 682  * g_shell_parse_argv(). Unlike g_spawn_sync(), the %G_SPAWN_SEARCH_PATH flag
 683  * is enabled. Note that %G_SPAWN_SEARCH_PATH can have security
 684  * implications, so consider using g_spawn_sync() directly if
 685  * appropriate. Possible errors are those from g_spawn_sync() and those
 686  * from g_shell_parse_argv().
 687  *
 688  * If @exit_status is non-%NULL, the platform-specific exit status of
 689  * the child is stored there; see the documentation of
 690  * g_spawn_check_exit_status() for how to use and interpret this.
 691  *
 692  * On Windows, please note the implications of g_shell_parse_argv()
 693  * parsing @command_line. Parsing is done according to Unix shell rules, not
 694  * Windows command interpreter rules.
 695  * Space is a separator, and backslashes are
 696  * special. Thus you cannot simply pass a @command_line containing
 697  * canonical Windows paths, like "c:\\program files\\app\\app.exe", as
 698  * the backslashes will be eaten, and the space will act as a
 699  * separator. You need to enclose such paths with single quotes, like
 700  * "'c:\\program files\\app\\app.exe' 'e:\\folder\\argument.txt'".
 701  *
 702  * Returns: %TRUE on success, %FALSE if an error was set
 703  **/
 704 gboolean
 705 g_spawn_command_line_sync (const gchar  *command_line,
 706                            gchar       **standard_output,
 707                            gchar       **standard_error,
 708                            gint         *exit_status,
 709                            GError      **error)
 710 {
 711   gboolean retval;
 712   gchar **argv = NULL;
 713
 714   g_return_val_if_fail (command_line != NULL, FALSE);
 715
 716   if (!g_shell_parse_argv (command_line,
 717                            NULL, &argv,
 718                            error))
 719     return FALSE;
 720
 721   retval = g_spawn_sync (NULL,
 722                          argv,
 723                          NULL,
 724                          G_SPAWN_SEARCH_PATH,
 725                          NULL,
 726                          NULL,
 727                          standard_output,
 728                          standard_error,
 729                          exit_status,
 730                          error);
 731   g_strfreev (argv);
 732
 733   return retval;
 734 }
 735
 736 /**
 737  * g_spawn_command_line_async:
 738  * @command_line: a command line
 739  * @error: return location for errors
 740  *
 741  * A simple version of g_spawn_async() that parses a command line with
 742  * g_shell_parse_argv() and passes it to g_spawn_async(). Runs a
 743  * command line in the background. Unlike g_spawn_async(), the
 744  * %G_SPAWN_SEARCH_PATH flag is enabled, other flags are not. Note
 745  * that %G_SPAWN_SEARCH_PATH can have security implications, so
 746  * consider using g_spawn_async() directly if appropriate. Possible
 747  * errors are those from g_shell_parse_argv() and g_spawn_async().
 748  *
 749  * The same concerns on Windows apply as for g_spawn_command_line_sync().
 750  *
 751  * Returns: %TRUE on success, %FALSE if error is set
 752  **/
 753 gboolean
 754 g_spawn_command_line_async (const gchar *command_line,
 755                             GError     **error)
 756 {
 757   gboolean retval;
 758   gchar **argv = NULL;
 759
 760   g_return_val_if_fail (command_line != NULL, FALSE);
 761
 762   if (!g_shell_parse_argv (command_line,
 763                            NULL, &argv,
 764                            error))
 765     return FALSE;
 766
 767   retval = g_spawn_async (NULL,
 768                           argv,
 769                           NULL,
 770                           G_SPAWN_SEARCH_PATH,
 771                           NULL,
 772                           NULL,
 773                           NULL,
 774                           error);
 775   g_strfreev (argv);
 776
 777   return retval;
 778 }
 779
 780 /**
 781  * g_spawn_check_exit_status:
 782  * @exit_status: An exit code as returned from g_spawn_sync()
 783  * @error: a #GError
 784  *
 785  * Set @error if @exit_status indicates the child exited abnormally
 786  * (e.g. with a nonzero exit code, or via a fatal signal).
 787  *
 788  * The g_spawn_sync() and g_child_watch_add() family of APIs return an
 789  * exit status for subprocesses encoded in a platform-specific way.
 790  * On Unix, this is guaranteed to be in the same format waitpid() returns,
 791  * and on Windows it is guaranteed to be the result of GetExitCodeProcess().
 792  *
 793  * Prior to the introduction of this function in GLib 2.34, interpreting
 794  * @exit_status required use of platform-specific APIs, which is problematic
 795  * for software using GLib as a cross-platform layer.
 796  *
 797  * Additionally, many programs simply want to determine whether or not
 798  * the child exited successfully, and either propagate a #GError or
 799  * print a message to standard error. In that common case, this function
 800  * can be used. Note that the error message in @error will contain
 801  * human-readable information about the exit status.
 802  *
 803  * The @domain and @code of @error have special semantics in the case
 804  * where the process has an "exit code", as opposed to being killed by
 805  * a signal. On Unix, this happens if WIFEXITED() would be true of
 806  * @exit_status. On Windows, it is always the case.
 807  *
 808  * The special semantics are that the actual exit code will be the
 809  * code set in @error, and the domain will be %G_SPAWN_EXIT_ERROR.
 810  * This allows you to differentiate between different exit codes.
 811  *
 812  * If the process was terminated by some means other than an exit
 813  * status, the domain will be %G_SPAWN_ERROR, and the code will be
 814  * %G_SPAWN_ERROR_FAILED.
 815  *
 816  * This function just offers convenience; you can of course also check
 817  * the available platform via a macro such as %G_OS_UNIX, and use
 818  * WIFEXITED() and WEXITSTATUS() on @exit_status directly. Do not attempt
 819  * to scan or parse the error message string; it may be translated and/or
 820  * change in future versions of GLib.
 821  *
 822  * Returns: %TRUE if child exited successfully, %FALSE otherwise (and
 823  *     @error will be set)
 824  *
 825  * Since: 2.34
 826  */
 827 gboolean
 828 g_spawn_check_exit_status (gint      exit_status,
 829                            GError  **error)
 830 {
 831   gboolean ret = FALSE;
 832
 833   if (WIFEXITED (exit_status))
 834     {
 835       if (WEXITSTATUS (exit_status) != 0)
 836         {
 837           g_set_error (error, G_SPAWN_EXIT_ERROR, WEXITSTATUS (exit_status),
 838                        _("Child process exited with code %ld"),
 839                        (long) WEXITSTATUS (exit_status));
 840           goto out;
 841         }
 842     }
 843   else if (WIFSIGNALED (exit_status))
 844     {
 845       g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED,
 846                    _("Child process killed by signal %ld"),
 847                    (long) WTERMSIG (exit_status));
 848       goto out;
 849     }
 850   else if (WIFSTOPPED (exit_status))
 851     {
 852       g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED,
 853                    _("Child process stopped by signal %ld"),
 854                    (long) WSTOPSIG (exit_status));
 855       goto out;
 856     }
 857   else
 858     {
 859       g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED,
 860                    _("Child process exited abnormally"));
 861       goto out;
 862     }
 863
 864   ret = TRUE;
 865  out:
 866   return ret;
 867 }
 868
 869 static gint
 870 exec_err_to_g_error (gint en)
 871 {
 872   switch (en)
 873     {
 874 #ifdef EACCES
 875     case EACCES:
 876       return G_SPAWN_ERROR_ACCES;
 877       break;
 878 #endif
 879
 880 #ifdef EPERM
 881     case EPERM:
 882       return G_SPAWN_ERROR_PERM;
 883       break;
 884 #endif
 885
 886 #ifdef E2BIG
 887     case E2BIG:
 888       return G_SPAWN_ERROR_TOO_BIG;
 889       break;
 890 #endif
 891
 892 #ifdef ENOEXEC
 893     case ENOEXEC:
 894       return G_SPAWN_ERROR_NOEXEC;
 895       break;
 896 #endif
 897
 898 #ifdef ENAMETOOLONG
 899     case ENAMETOOLONG:
 900       return G_SPAWN_ERROR_NAMETOOLONG;
 901       break;
 902 #endif
 903
 904 #ifdef ENOENT
 905     case ENOENT:
 906       return G_SPAWN_ERROR_NOENT;
 907       break;
 908 #endif
 909
 910 #ifdef ENOMEM
 911     case ENOMEM:
 912       return G_SPAWN_ERROR_NOMEM;
 913       break;
 914 #endif
 915
 916 #ifdef ENOTDIR
 917     case ENOTDIR:
 918       return G_SPAWN_ERROR_NOTDIR;
 919       break;
 920 #endif
 921
 922 #ifdef ELOOP
 923     case ELOOP:
 924       return G_SPAWN_ERROR_LOOP;
 925       break;
 926 #endif
 927
 928 #ifdef ETXTBUSY
 929     case ETXTBUSY:
 930       return G_SPAWN_ERROR_TXTBUSY;
 931       break;
 932 #endif
 933
 934 #ifdef EIO
 935     case EIO:
 936       return G_SPAWN_ERROR_IO;
 937       break;
 938 #endif
 939
 940 #ifdef ENFILE
 941     case ENFILE:
 942       return G_SPAWN_ERROR_NFILE;
 943       break;
 944 #endif
 945
 946 #ifdef EMFILE
 947     case EMFILE:
 948       return G_SPAWN_ERROR_MFILE;
 949       break;
 950 #endif
 951
 952 #ifdef EINVAL
 953     case EINVAL:
 954       return G_SPAWN_ERROR_INVAL;
 955       break;
 956 #endif
 957
 958 #ifdef EISDIR
 959     case EISDIR:
 960       return G_SPAWN_ERROR_ISDIR;
 961       break;
 962 #endif
 963
 964 #ifdef ELIBBAD
 965     case ELIBBAD:
 966       return G_SPAWN_ERROR_LIBBAD;
 967       break;
 968 #endif
 969
 970     default:
 971       return G_SPAWN_ERROR_FAILED;
 972       break;
 973     }
 974 }
 975
 976 static gssize
 977 write_all (gint fd, gconstpointer vbuf, gsize to_write)
 978 {
 979   gchar *buf = (gchar *) vbuf;
 980
 981   while (to_write > 0)
 982     {
 983       gssize count = write (fd, buf, to_write);
 984       if (count < 0)
 985         {
 986           if (errno != EINTR)
 987             return FALSE;
 988         }
 989       else
 990         {
 991           to_write -= count;
 992           buf += count;
 993         }
 994     }
 995
 996   return TRUE;
 997 }
 998
 999 G_GNUC_NORETURN
1000 static void
1001 write_err_and_exit (gint fd, gint msg)
1002 {
1003   gint en = errno;
1004
1005   write_all (fd, &msg, sizeof(msg));
1006   write_all (fd, &en, sizeof(en));
1007
1008   _exit (1);
1009 }
1010
1011 static int
1012 set_cloexec (void *data, gint fd)
1013 {
1014   if (fd >= GPOINTER_TO_INT (data))
1015     fcntl (fd, F_SETFD, FD_CLOEXEC);
1016
1017   return 0;
1018 }
1019
1020 #ifndef HAVE_FDWALK
1021 static int
1022 fdwalk (int (*cb)(void *data, int fd), void *data)
1023 {
1024   gint open_max;
1025   gint fd;
1026   gint res = 0;
1027
1028 #ifdef HAVE_SYS_RESOURCE_H
1029   struct rlimit rl;
1030 #endif
1031
1032 #ifdef __linux__
1033   DIR *d;
1034
1035   if ((d = opendir("/proc/self/fd"))) {
1036       struct dirent *de;
1037
1038       while ((de = readdir(d))) {
1039           glong l;
1040           gchar *e = NULL;
1041
1042           if (de->d_name[0] == '.')
1043               continue;
1044
1045           errno = 0;
1046           l = strtol(de->d_name, &e, 10);
1047           if (errno != 0 || !e || *e)
1048               continue;
1049
1050           fd = (gint) l;
1051
1052           if ((glong) fd != l)
1053               continue;
1054
1055           if (fd == dirfd(d))
1056               continue;
1057
1058           if ((res = cb (data, fd)) != 0)
1059               break;
1060         }
1061
1062       closedir(d);
1063       return res;
1064   }
1065
1066   /* If /proc is not mounted or not accessible we fall back to the old
1067    * rlimit trick */
1068
1069 #endif
1070
1071 #ifdef HAVE_SYS_RESOURCE_H
1072
1073   if (getrlimit(RLIMIT_NOFILE, &rl) == 0 && rl.rlim_max != RLIM_INFINITY)
1074       open_max = rl.rlim_max;
1075   else
1076 #endif
1077       open_max = sysconf (_SC_OPEN_MAX);
1078
1079   for (fd = 0; fd < open_max; fd++)
1080       if ((res = cb (data, fd)) != 0)
1081           break;
1082
1083   return res;
1084 }
1085 #endif
1086
1087 static gint
1088 sane_dup2 (gint fd1, gint fd2)
1089 {
1090   gint ret;
1091
1092  retry:
1093   ret = dup2 (fd1, fd2);
1094   if (ret < 0 && errno == EINTR)
1095     goto retry;
1096
1097   return ret;
1098 }
1099
1100 static gint
1101 sane_open (const char *path, gint mode)
1102 {
1103   gint ret;
1104
1105  retry:
1106   ret = open (path, mode);
1107   if (ret < 0 && errno == EINTR)
1108     goto retry;
1109
1110   return ret;
1111 }
1112
1113 enum
1114 {
1115   CHILD_CHDIR_FAILED,
1116   CHILD_EXEC_FAILED,
1117   CHILD_DUP2_FAILED,
1118   CHILD_FORK_FAILED
1119 };
1120
1121 static void
1122 do_exec (gint                  child_err_report_fd,
1123          gint                  stdin_fd,
1124          gint                  stdout_fd,
1125          gint                  stderr_fd,
1126          const gchar          *working_directory,
1127          gchar               **argv,
1128          gchar               **envp,
1129          gboolean              close_descriptors,
1130          gboolean              search_path,
1131          gboolean              search_path_from_envp,
1132          gboolean              stdout_to_null,
1133          gboolean              stderr_to_null,
1134          gboolean              child_inherits_stdin,
1135          gboolean              file_and_argv_zero,
1136          GSpawnChildSetupFunc  child_setup,
1137          gpointer              user_data)
1138 {
1139   if (working_directory && chdir (working_directory) < 0)
1140     write_err_and_exit (child_err_report_fd,
1141                         CHILD_CHDIR_FAILED);
1142
1143   /* Close all file descriptors but stdin stdout and stderr as
1144    * soon as we exec. Note that this includes
1145    * child_err_report_fd, which keeps the parent from blocking
1146    * forever on the other end of that pipe.
1147    */
1148   if (close_descriptors)
1149     {
1150       fdwalk (set_cloexec, GINT_TO_POINTER(3));
1151     }
1152   else
1153     {
1154       /* We need to do child_err_report_fd anyway */
1155       set_cloexec (GINT_TO_POINTER(0), child_err_report_fd);
1156     }
1157
1158   /* Redirect pipes as required */
1159
1160   if (stdin_fd >= 0)
1161     {
1162       /* dup2 can't actually fail here I don't think */
1163
1164       if (sane_dup2 (stdin_fd, 0) < 0)
1165         write_err_and_exit (child_err_report_fd,
1166                             CHILD_DUP2_FAILED);
1167
1168       /* ignore this if it doesn't work */
1169       close_and_invalidate (&stdin_fd);
1170     }
1171   else if (!child_inherits_stdin)
1172     {
1173       /* Keep process from blocking on a read of stdin */
1174       gint read_null = open ("/dev/null", O_RDONLY);
1175       g_assert (read_null != -1);
1176       sane_dup2 (read_null, 0);
1177       close_and_invalidate (&read_null);
1178     }
1179
1180   if (stdout_fd >= 0)
1181     {
1182       /* dup2 can't actually fail here I don't think */
1183
1184       if (sane_dup2 (stdout_fd, 1) < 0)
1185         write_err_and_exit (child_err_report_fd,
1186                             CHILD_DUP2_FAILED);
1187
1188       /* ignore this if it doesn't work */
1189       close_and_invalidate (&stdout_fd);
1190     }
1191   else if (stdout_to_null)
1192     {
1193       gint write_null = sane_open ("/dev/null", O_WRONLY);
1194       g_assert (write_null != -1);
1195       sane_dup2 (write_null, 1);
1196       close_and_invalidate (&write_null);
1197     }
1198
1199   if (stderr_fd >= 0)
1200     {
1201       /* dup2 can't actually fail here I don't think */
1202
1203       if (sane_dup2 (stderr_fd, 2) < 0)
1204         write_err_and_exit (child_err_report_fd,
1205                             CHILD_DUP2_FAILED);
1206
1207       /* ignore this if it doesn't work */
1208       close_and_invalidate (&stderr_fd);
1209     }
1210   else if (stderr_to_null)
1211     {
1212       gint write_null = sane_open ("/dev/null", O_WRONLY);
1213       sane_dup2 (write_null, 2);
1214       close_and_invalidate (&write_null);
1215     }
1216
1217   /* Call user function just before we exec */
1218   if (child_setup)
1219     {
1220       (* child_setup) (user_data);
1221     }
1222
1223   g_execute (argv[0],
1224              file_and_argv_zero ? argv + 1 : argv,
1225              envp, search_path, search_path_from_envp);
1226
1227   /* Exec failed */
1228   write_err_and_exit (child_err_report_fd,
1229                       CHILD_EXEC_FAILED);
1230 }
1231
1232 static gboolean
1233 read_ints (int      fd,
1234            gint*    buf,
1235            gint     n_ints_in_buf,
1236            gint    *n_ints_read,
1237            GError **error)
1238 {
1239   gsize bytes = 0;
1240
1241   while (TRUE)
1242     {
1243       gssize chunk;
1244
1245       if (bytes >= sizeof(gint)*2)
1246         break; /* give up, who knows what happened, should not be
1247                 * possible.
1248                 */
1249
1250     again:
1251       chunk = read (fd,
1252                     ((gchar*)buf) + bytes,
1253                     sizeof(gint) * n_ints_in_buf - bytes);
1254       if (chunk < 0 && errno == EINTR)
1255         goto again;
1256
1257       if (chunk < 0)
1258         {
1259           int errsv = errno;
1260
1261           /* Some weird shit happened, bail out */
1262           g_set_error (error,
1263                        G_SPAWN_ERROR,
1264                        G_SPAWN_ERROR_FAILED,
1265                        _("Failed to read from child pipe (%s)"),
1266                        g_strerror (errsv));
1267
1268           return FALSE;
1269         }
1270       else if (chunk == 0)
1271         break; /* EOF */
1272       else /* chunk > 0 */
1273         bytes += chunk;
1274     }
1275
1276   *n_ints_read = (gint)(bytes / sizeof(gint));
1277
1278   return TRUE;
1279 }
1280
1281 static gboolean
1282 fork_exec_with_pipes (gboolean              intermediate_child,
1283                       const gchar          *working_directory,
1284                       gchar               **argv,
1285                       gchar               **envp,
1286                       gboolean              close_descriptors,
1287                       gboolean              search_path,
1288                       gboolean              search_path_from_envp,
1289                       gboolean              stdout_to_null,
1290                       gboolean              stderr_to_null,
1291                       gboolean              child_inherits_stdin,
1292                       gboolean              file_and_argv_zero,
1293                       gboolean              cloexec_pipes,
1294                       GSpawnChildSetupFunc  child_setup,
1295                       gpointer              user_data,
1296                       GPid                 *child_pid,
1297                       gint                 *standard_input,
1298                       gint                 *standard_output,
1299                       gint                 *standard_error,
1300                       GError              **error)
1301 {
1302   GPid pid = -1;
1303   gint stdin_pipe[2] = { -1, -1 };
1304   gint stdout_pipe[2] = { -1, -1 };
1305   gint stderr_pipe[2] = { -1, -1 };
1306   gint child_err_report_pipe[2] = { -1, -1 };
1307   gint child_pid_report_pipe[2] = { -1, -1 };
1308   guint pipe_flags = cloexec_pipes ? FD_CLOEXEC : 0;
1309   gint status;
1310
1311   if (!g_unix_open_pipe (child_err_report_pipe, pipe_flags, error))
1312     return FALSE;
1313
1314   if (intermediate_child && !g_unix_open_pipe (child_pid_report_pipe, pipe_flags, error))
1315     goto cleanup_and_fail;
1316
1317   if (standard_input && !g_unix_open_pipe (stdin_pipe, pipe_flags, error))
1318     goto cleanup_and_fail;
1319
1320   if (standard_output && !g_unix_open_pipe (stdout_pipe, pipe_flags, error))
1321     goto cleanup_and_fail;
1322
1323   if (standard_error && !g_unix_open_pipe (stderr_pipe, FD_CLOEXEC, error))
1324     goto cleanup_and_fail;
1325
1326   pid = fork ();
1327
1328   if (pid < 0)
1329     {
1330       int errsv = errno;
1331
1332       g_set_error (error,
1333                    G_SPAWN_ERROR,
1334                    G_SPAWN_ERROR_FORK,
1335                    _("Failed to fork (%s)"),
1336                    g_strerror (errsv));
1337
1338       goto cleanup_and_fail;
1339     }
1340   else if (pid == 0)
1341     {
1342       /* Immediate child. This may or may not be the child that
1343        * actually execs the new process.
1344        */
1345
1346       /* Reset some signal handlers that we may use */
1347       signal (SIGCHLD, SIG_DFL);
1348       signal (SIGINT, SIG_DFL);
1349       signal (SIGTERM, SIG_DFL);
1350       signal (SIGHUP, SIG_DFL);
1351
1352       /* Be sure we crash if the parent exits
1353        * and we write to the err_report_pipe
1354        */
1355       signal (SIGPIPE, SIG_DFL);
1356
1357       /* Close the parent's end of the pipes;
1358        * not needed in the close_descriptors case,
1359        * though
1360        */
1361       close_and_invalidate (&child_err_report_pipe[0]);
1362       close_and_invalidate (&child_pid_report_pipe[0]);
1363       close_and_invalidate (&stdin_pipe[1]);
1364       close_and_invalidate (&stdout_pipe[0]);
1365       close_and_invalidate (&stderr_pipe[0]);
1366
1367       if (intermediate_child)
1368         {
1369           /* We need to fork an intermediate child that launches the
1370            * final child. The purpose of the intermediate child
1371            * is to exit, so we can waitpid() it immediately.
1372            * Then the grandchild will not become a zombie.
1373            */
1374           GPid grandchild_pid;
1375
1376           grandchild_pid = fork ();
1377
1378           if (grandchild_pid < 0)
1379             {
1380               /* report -1 as child PID */
1381               write_all (child_pid_report_pipe[1], &grandchild_pid,
1382                          sizeof(grandchild_pid));
1383
1384               write_err_and_exit (child_err_report_pipe[1],
1385                                   CHILD_FORK_FAILED);
1386             }
1387           else if (grandchild_pid == 0)
1388             {
1389               close_and_invalidate (&child_pid_report_pipe[1]);
1390               do_exec (child_err_report_pipe[1],
1391                        stdin_pipe[0],
1392                        stdout_pipe[1],
1393                        stderr_pipe[1],
1394                        working_directory,
1395                        argv,
1396                        envp,
1397                        close_descriptors,
1398                        search_path,
1399                        search_path_from_envp,
1400                        stdout_to_null,
1401                        stderr_to_null,
1402                        child_inherits_stdin,
1403                        file_and_argv_zero,
1404                        child_setup,
1405                        user_data);
1406             }
1407           else
1408             {
1409               write_all (child_pid_report_pipe[1], &grandchild_pid, sizeof(grandchild_pid));
1410               close_and_invalidate (&child_pid_report_pipe[1]);
1411
1412               _exit (0);
1413             }
1414         }
1415       else
1416         {
1417           /* Just run the child.
1418            */
1419
1420           do_exec (child_err_report_pipe[1],
1421                    stdin_pipe[0],
1422                    stdout_pipe[1],
1423                    stderr_pipe[1],
1424                    working_directory,
1425                    argv,
1426                    envp,
1427                    close_descriptors,
1428                    search_path,
1429                    search_path_from_envp,
1430                    stdout_to_null,
1431                    stderr_to_null,
1432                    child_inherits_stdin,
1433                    file_and_argv_zero,
1434                    child_setup,
1435                    user_data);
1436         }
1437     }
1438   else
1439     {
1440       /* Parent */
1441
1442       gint buf[2];
1443       gint n_ints = 0;
1444
1445       /* Close the uncared-about ends of the pipes */
1446       close_and_invalidate (&child_err_report_pipe[1]);
1447       close_and_invalidate (&child_pid_report_pipe[1]);
1448       close_and_invalidate (&stdin_pipe[0]);
1449       close_and_invalidate (&stdout_pipe[1]);
1450       close_and_invalidate (&stderr_pipe[1]);
1451
1452       /* If we had an intermediate child, reap it */
1453       if (intermediate_child)
1454         {
1455         wait_again:
1456           if (waitpid (pid, &status, 0) < 0)
1457             {
1458               if (errno == EINTR)
1459                 goto wait_again;
1460               else if (errno == ECHILD)
1461                 ; /* do nothing, child already reaped */
1462               else
1463                 g_warning ("waitpid() should not fail in "
1464                            "'fork_exec_with_pipes'");
1465             }
1466         }
1467
1468
1469       if (!read_ints (child_err_report_pipe[0],
1470                       buf, 2, &n_ints,
1471                       error))
1472         goto cleanup_and_fail;
1473
1474       if (n_ints >= 2)
1475         {
1476           /* Error from the child. */
1477
1478           switch (buf[0])
1479             {
1480             case CHILD_CHDIR_FAILED:
1481               g_set_error (error,
1482                            G_SPAWN_ERROR,
1483                            G_SPAWN_ERROR_CHDIR,
1484                            _("Failed to change to directory '%s' (%s)"),
1485                            working_directory,
1486                            g_strerror (buf[1]));
1487
1488               break;
1489
1490             case CHILD_EXEC_FAILED:
1491               g_set_error (error,
1492                            G_SPAWN_ERROR,
1493                            exec_err_to_g_error (buf[1]),
1494                            _("Failed to execute child process \"%s\" (%s)"),
1495                            argv[0],
1496                            g_strerror (buf[1]));
1497
1498               break;
1499
1500             case CHILD_DUP2_FAILED:
1501               g_set_error (error,
1502                            G_SPAWN_ERROR,
1503                            G_SPAWN_ERROR_FAILED,
1504                            _("Failed to redirect output or input of child process (%s)"),
1505                            g_strerror (buf[1]));
1506
1507               break;
1508
1509             case CHILD_FORK_FAILED:
1510               g_set_error (error,
1511                            G_SPAWN_ERROR,
1512                            G_SPAWN_ERROR_FORK,
1513                            _("Failed to fork child process (%s)"),
1514                            g_strerror (buf[1]));
1515               break;
1516
1517             default:
1518               g_set_error (error,
1519                            G_SPAWN_ERROR,
1520                            G_SPAWN_ERROR_FAILED,
1521                            _("Unknown error executing child process \"%s\""),
1522                            argv[0]);
1523               break;
1524             }
1525
1526           goto cleanup_and_fail;
1527         }
1528
1529       /* Get child pid from intermediate child pipe. */
1530       if (intermediate_child)
1531         {
1532           n_ints = 0;
1533
1534           if (!read_ints (child_pid_report_pipe[0],
1535                           buf, 1, &n_ints, error))
1536             goto cleanup_and_fail;
1537
1538           if (n_ints < 1)
1539             {
1540               int errsv = errno;
1541
1542               g_set_error (error,
1543                            G_SPAWN_ERROR,
1544                            G_SPAWN_ERROR_FAILED,
1545                            _("Failed to read enough data from child pid pipe (%s)"),
1546                            g_strerror (errsv));
1547               goto cleanup_and_fail;
1548             }
1549           else
1550             {
1551               /* we have the child pid */
1552               pid = buf[0];
1553             }
1554         }
1555
1556       /* Success against all odds! return the information */
1557       close_and_invalidate (&child_err_report_pipe[0]);
1558       close_and_invalidate (&child_pid_report_pipe[0]);
1559
1560       if (child_pid)
1561         *child_pid = pid;
1562
1563       if (standard_input)
1564         *standard_input = stdin_pipe[1];
1565       if (standard_output)
1566         *standard_output = stdout_pipe[0];
1567       if (standard_error)
1568         *standard_error = stderr_pipe[0];
1569
1570       return TRUE;
1571     }
1572
1573  cleanup_and_fail:
1574
1575   /* There was an error from the Child, reap the child to avoid it being
1576      a zombie.
1577    */
1578
1579   if (pid > 0)
1580   {
1581     wait_failed:
1582      if (waitpid (pid, NULL, 0) < 0)
1583        {
1584           if (errno == EINTR)
1585             goto wait_failed;
1586           else if (errno == ECHILD)
1587             ; /* do nothing, child already reaped */
1588           else
1589             g_warning ("waitpid() should not fail in "
1590                        "'fork_exec_with_pipes'");
1591        }
1592    }
1593
1594   close_and_invalidate (&child_err_report_pipe[0]);
1595   close_and_invalidate (&child_err_report_pipe[1]);
1596   close_and_invalidate (&child_pid_report_pipe[0]);
1597   close_and_invalidate (&child_pid_report_pipe[1]);
1598   close_and_invalidate (&stdin_pipe[0]);
1599   close_and_invalidate (&stdin_pipe[1]);
1600   close_and_invalidate (&stdout_pipe[0]);
1601   close_and_invalidate (&stdout_pipe[1]);
1602   close_and_invalidate (&stderr_pipe[0]);
1603   close_and_invalidate (&stderr_pipe[1]);
1604
1605   return FALSE;
1606 }
1607
1608 /* Based on execvp from GNU C Library */
1609
1610 static void
1611 script_execute (const gchar *file,
1612                 gchar      **argv,
1613                 gchar      **envp)
1614 {
1615   /* Count the arguments.  */
1616   int argc = 0;
1617   while (argv[argc])
1618     ++argc;
1619
1620   /* Construct an argument list for the shell.  */
1621   {
1622     gchar **new_argv;
1623
1624     new_argv = g_new0 (gchar*, argc + 2); /* /bin/sh and NULL */
1625
1626     new_argv[0] = (char *) "/bin/sh";
1627     new_argv[1] = (char *) file;
1628     while (argc > 0)
1629       {
1630         new_argv[argc + 1] = argv[argc];
1631         --argc;
1632       }
1633
1634     /* Execute the shell. */
1635     if (envp)
1636       execve (new_argv[0], new_argv, envp);
1637     else
1638       execv (new_argv[0], new_argv);
1639
1640     g_free (new_argv);
1641   }
1642 }
1643
1644 static gchar*
1645 my_strchrnul (const gchar *str, gchar c)
1646 {
1647   gchar *p = (gchar*) str;
1648   while (*p && (*p != c))
1649     ++p;
1650
1651   return p;
1652 }
1653
1654 static gint
1655 g_execute (const gchar *file,
1656            gchar      **argv,
1657            gchar      **envp,
1658            gboolean     search_path,
1659            gboolean     search_path_from_envp)
1660 {
1661   if (*file == '\0')
1662     {
1663       /* We check the simple case first. */
1664       errno = ENOENT;
1665       return -1;
1666     }
1667
1668   if (!(search_path || search_path_from_envp) || strchr (file, '/') != NULL)
1669     {
1670       /* Don't search when it contains a slash. */
1671       if (envp)
1672         execve (file, argv, envp);
1673       else
1674         execv (file, argv);
1675
1676       if (errno == ENOEXEC)
1677         script_execute (file, argv, envp);
1678     }
1679   else
1680     {
1681       gboolean got_eacces = 0;
1682       const gchar *path, *p;
1683       gchar *name, *freeme;
1684       gsize len;
1685       gsize pathlen;
1686
1687       path = NULL;
1688       if (search_path_from_envp)
1689         path = g_environ_getenv (envp, "PATH");
1690       if (search_path && path == NULL)
1691         path = g_getenv ("PATH");
1692
1693       if (path == NULL)
1694         {
1695           /* There is no 'PATH' in the environment.  The default
1696            * search path in libc is the current directory followed by
1697            * the path 'confstr' returns for '_CS_PATH'.
1698            */
1699
1700           /* In GLib we put . last, for security, and don't use the
1701            * unportable confstr(); UNIX98 does not actually specify
1702            * what to search if PATH is unset. POSIX may, dunno.
1703            */
1704
1705           path = "/bin:/usr/bin:.";
1706         }
1707
1708       len = strlen (file) + 1;
1709       pathlen = strlen (path);
1710       freeme = name = g_malloc (pathlen + len + 1);
1711
1712       /* Copy the file name at the top, including '\0'  */
1713       memcpy (name + pathlen + 1, file, len);
1714       name = name + pathlen;
1715       /* And add the slash before the filename  */
1716       *name = '/';
1717
1718       p = path;
1719       do
1720         {
1721           char *startp;
1722
1723           path = p;
1724           p = my_strchrnul (path, ':');
1725
1726           if (p == path)
1727             /* Two adjacent colons, or a colon at the beginning or the end
1728              * of 'PATH' means to search the current directory.
1729              */
1730             startp = name + 1;
1731           else
1732             startp = memcpy (name - (p - path), path, p - path);
1733
1734           /* Try to execute this name.  If it works, execv will not return.  */
1735           if (envp)
1736             execve (startp, argv, envp);
1737           else
1738             execv (startp, argv);
1739
1740           if (errno == ENOEXEC)
1741             script_execute (startp, argv, envp);
1742
1743           switch (errno)
1744             {
1745             case EACCES:
1746               /* Record the we got a 'Permission denied' error.  If we end
1747                * up finding no executable we can use, we want to diagnose
1748                * that we did find one but were denied access.
1749                */
1750               got_eacces = TRUE;
1751
1752               /* FALL THRU */
1753
1754             case ENOENT:
1755 #ifdef ESTALE
1756             case ESTALE:
1757 #endif
1758 #ifdef ENOTDIR
1759             case ENOTDIR:
1760 #endif
1761               /* Those errors indicate the file is missing or not executable
1762                * by us, in which case we want to just try the next path
1763                * directory.
1764                */
1765               break;
1766
1767             case ENODEV:
1768             case ETIMEDOUT:
1769               /* Some strange filesystems like AFS return even
1770                * stranger error numbers.  They cannot reasonably mean anything
1771                * else so ignore those, too.
1772                */
1773               break;
1774
1775             default:
1776               /* Some other error means we found an executable file, but
1777                * something went wrong executing it; return the error to our
1778                * caller.
1779                */
1780               g_free (freeme);
1781               return -1;
1782             }
1783         }
1784       while (*p++ != '\0');
1785
1786       /* We tried every element and none of them worked.  */
1787       if (got_eacces)
1788         /* At least one failure was due to permissions, so report that
1789          * error.
1790          */
1791         errno = EACCES;
1792
1793       g_free (freeme);
1794     }
1795
1796   /* Return the error from the last attempt (probably ENOENT).  */
1797   return -1;
1798 }
1799
1800 /**
1801  * g_spawn_close_pid:
1802  * @pid: The process reference to close
1803  *
1804  * On some platforms, notably Windows, the #GPid type represents a resource
1805  * which must be closed to prevent resource leaking. g_spawn_close_pid()
1806  * is provided for this purpose. It should be used on all platforms, even
1807  * though it doesn't do anything under UNIX.
1808  **/
1809 void
1810 g_spawn_close_pid (GPid pid)
1811 {
1812 }