glib/gspawn-win32.c

   1 /* gspawn-win32.c - Process launching on Win32
   2  *
   3  *  Copyright 2000 Red Hat, Inc.
   4  *  Copyright 2003 Tor Lillqvist
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public License
  17  * along with this library; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 /*
  21  * Implementation details on Win32.
  22  *
  23  * - There is no way to set the no-inherit flag for
  24  *   a "file descriptor" in the MS C runtime. The flag is there,
  25  *   and the dospawn() function uses it, but unfortunately
  26  *   this flag can only be set when opening the file.
  27  * - As there is no fork(), we cannot reliably change directory
  28  *   before starting the child process. (There might be several threads
  29  *   running, and the current directory is common for all threads.)
  30  *
  31  * Thus, we must in many cases use a helper program to handle closing
  32  * of (inherited) file descriptors and changing of directory. The
  33  * helper process is also needed if the standard input, standard
  34  * output, or standard error of the process to be run are supposed to
  35  * be redirected somewhere.
  36  *
  37  * The structure of the source code in this file is a mess, I know.
  38  */
  39
  40 /* Define this to get some logging all the time */
  41 /* #define G_SPAWN_WIN32_DEBUG */
  42
  43 #include "config.h"
  44
  45 #include "glib.h"
  46 #include "glib-private.h"
  47 #include "gprintfint.h"
  48 #include "glibintl.h"
  49 #include "gspawn-private.h"
  50 #include "gthread.h"
  51
  52 #include <string.h>
  53 #include <stdlib.h>
  54 #include <stdio.h>
  55
  56 #include <windows.h>
  57 #include <errno.h>
  58 #include <fcntl.h>
  59 #include <io.h>
  60 #include <process.h>
  61 #include <direct.h>
  62 #include <wchar.h>
  63
  64 #ifndef GSPAWN_HELPER
  65 #ifdef G_SPAWN_WIN32_DEBUG
  66   static int debug = 1;
  67   #define SETUP_DEBUG() /* empty */
  68 #else
  69   static int debug = -1;
  70   #define SETUP_DEBUG()                                 \
  71     G_STMT_START                                        \
  72       {                                                 \
  73         if (debug == -1)                                \
  74           {                                             \
  75             if (g_getenv ("G_SPAWN_WIN32_DEBUG") != NULL)       \
  76               debug = 1;                                \
  77             else                                        \
  78               debug = 0;                                \
  79           }                                             \
  80       }                                                 \
  81     G_STMT_END
  82 #endif
  83 #endif
  84
  85 enum
  86 {
  87   CHILD_NO_ERROR,
  88   CHILD_CHDIR_FAILED,
  89   CHILD_SPAWN_FAILED,
  90   CHILD_SPAWN_NOENT,
  91 };
  92
  93 enum {
  94   ARG_CHILD_ERR_REPORT = 1,
  95   ARG_HELPER_SYNC,
  96   ARG_STDIN,
  97   ARG_STDOUT,
  98   ARG_STDERR,
  99   ARG_WORKING_DIRECTORY,
 100   ARG_CLOSE_DESCRIPTORS,
 101   ARG_USE_PATH,
 102   ARG_WAIT,
 103   ARG_PROGRAM,
 104   ARG_COUNT = ARG_PROGRAM
 105 };
 106
 107 static int
 108 reopen_noninherited (int fd,
 109                      int mode)
 110 {
 111   HANDLE filehandle;
 112
 113   DuplicateHandle (GetCurrentProcess (), (LPHANDLE) _get_osfhandle (fd),
 114                    GetCurrentProcess (), &filehandle,
 115                    0, FALSE, DUPLICATE_SAME_ACCESS);
 116   close (fd);
 117   return _open_osfhandle ((gintptr) filehandle, mode | _O_NOINHERIT);
 118 }
 119
 120 #ifndef GSPAWN_HELPER
 121
 122 #ifdef _WIN64
 123 #define HELPER_PROCESS "gspawn-win64-helper"
 124 #else
 125 #define HELPER_PROCESS "gspawn-win32-helper"
 126 #endif
 127
 128 /* This logic has a copy for wchar_t in gspawn-win32-helper.c, protect_wargv() */
 129 static gchar *
 130 protect_argv_string (const gchar *string)
 131 {
 132   const gchar *p = string;
 133   gchar *retval, *q;
 134   gint len = 0;
 135   gint pre_bslash = 0;
 136   gboolean need_dblquotes = FALSE;
 137   while (*p)
 138     {
 139       if (*p == ' ' || *p == '\t')
 140         need_dblquotes = TRUE;
 141       /* estimate max len, assuming that all escapable characters will be escaped */
 142       if (*p == '"' || *p == '\\')
 143         len += 2;
 144       else
 145         len += 1;
 146       p++;
 147     }
 148
 149   q = retval = g_malloc (len + need_dblquotes*2 + 1);
 150   p = string;
 151
 152   if (need_dblquotes)
 153     *q++ = '"';
 154   /* Only quotes and backslashes preceding quotes are escaped:
 155    * see "Parsing C Command-Line Arguments" at
 156    * https://docs.microsoft.com/en-us/cpp/c-language/parsing-c-command-line-arguments
 157    */
 158   while (*p)
 159     {
 160       if (*p == '"')
 161         {
 162           /* Add backslash for escaping quote itself */
 163           *q++ = '\\';
 164           /* Add backslash for every preceding backslash for escaping it */
 165           for (;pre_bslash > 0; --pre_bslash)
 166             *q++ = '\\';
 167         }
 168
 169       /* Count length of continuous sequence of preceding backslashes. */
 170       if (*p == '\\')
 171         ++pre_bslash;
 172       else
 173         pre_bslash = 0;
 174
 175       *q++ = *p;
 176       p++;
 177     }
 178
 179   if (need_dblquotes)
 180     {
 181       /* Add backslash for every preceding backslash for escaping it,
 182        * do NOT escape quote itself.
 183        */
 184       for (;pre_bslash > 0; --pre_bslash)
 185         *q++ = '\\';
 186       *q++ = '"';
 187     }
 188   *q++ = '\0';
 189
 190   return retval;
 191 }
 192
 193 static gint
 194 protect_argv (const gchar * const   *argv,
 195               gchar               ***new_argv)
 196 {
 197   gint i;
 198   gint argc = 0;
 199
 200   while (argv[argc])
 201     ++argc;
 202   *new_argv = g_new (gchar *, argc+1);
 203
 204   /* Quote each argv element if necessary, so that it will get
 205    * reconstructed correctly in the C runtime startup code.  Note that
 206    * the unquoting algorithm in the C runtime is really weird, and
 207    * rather different than what Unix shells do. See stdargv.c in the C
 208    * runtime sources (in the Platform SDK, in src/crt).
 209    *
 210    * Note that a new_argv[0] constructed by this function should
 211    * *not* be passed as the filename argument to a spawn* or exec*
 212    * family function. That argument should be the real file name
 213    * without any quoting.
 214    */
 215   for (i = 0; i < argc; i++)
 216     (*new_argv)[i] = protect_argv_string (argv[i]);
 217
 218   (*new_argv)[argc] = NULL;
 219
 220   return argc;
 221 }
 222
 223 G_DEFINE_QUARK (g-exec-error-quark, g_spawn_error)
 224 G_DEFINE_QUARK (g-spawn-exit-error-quark, g_spawn_exit_error)
 225
 226 gboolean
 227 g_spawn_async (const gchar          *working_directory,
 228                gchar               **argv,
 229                gchar               **envp,
 230                GSpawnFlags           flags,
 231                GSpawnChildSetupFunc  child_setup,
 232                gpointer              user_data,
 233                GPid                 *child_pid,
 234                GError              **error)
 235 {
 236   g_return_val_if_fail (argv != NULL, FALSE);
 237
 238   return g_spawn_async_with_pipes (working_directory,
 239                                    argv, envp,
 240                                    flags,
 241                                    child_setup,
 242                                    user_data,
 243                                    child_pid,
 244                                    NULL, NULL, NULL,
 245                                    error);
 246 }
 247
 248 /* Avoids a danger in threaded situations (calling close()
 249  * on a file descriptor twice, and another thread has
 250  * re-opened it since the first close)
 251  */
 252 static void
 253 close_and_invalidate (gint *fd)
 254 {
 255   if (*fd < 0)
 256     return;
 257
 258   close (*fd);
 259   *fd = -1;
 260 }
 261
 262 typedef enum
 263 {
 264   READ_FAILED = 0, /* FALSE */
 265   READ_OK,
 266   READ_EOF
 267 } ReadResult;
 268
 269 static ReadResult
 270 read_data (GString     *str,
 271            GIOChannel  *iochannel,
 272            GError     **error)
 273 {
 274   GIOStatus giostatus;
 275   gsize bytes;
 276   gchar buf[4096];
 277
 278  again:
 279
 280   giostatus = g_io_channel_read_chars (iochannel, buf, sizeof (buf), &bytes, NULL);
 281
 282   if (bytes == 0)
 283     return READ_EOF;
 284   else if (bytes > 0)
 285     {
 286       g_string_append_len (str, buf, bytes);
 287       return READ_OK;
 288     }
 289   else if (giostatus == G_IO_STATUS_AGAIN)
 290     goto again;
 291   else if (giostatus == G_IO_STATUS_ERROR)
 292     {
 293       g_set_error_literal (error, G_SPAWN_ERROR, G_SPAWN_ERROR_READ,
 294                            _("Failed to read data from child process"));
 295
 296       return READ_FAILED;
 297     }
 298   else
 299     return READ_OK;
 300 }
 301
 302 static gboolean
 303 make_pipe (gint     p[2],
 304            GError **error)
 305 {
 306   if (_pipe (p, 4096, _O_BINARY) < 0)
 307     {
 308       int errsv = errno;
 309
 310       g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED,
 311                    _("Failed to create pipe for communicating with child process (%s)"),
 312                    g_strerror (errsv));
 313       return FALSE;
 314     }
 315   else
 316     return TRUE;
 317 }
 318
 319 /* The helper process writes a status report back to us, through a
 320  * pipe, consisting of two ints.
 321  */
 322 static gboolean
 323 read_helper_report (int      fd,
 324                     gintptr  report[2],
 325                     GError **error)
 326 {
 327   gint bytes = 0;
 328
 329   while (bytes < sizeof(gintptr)*2)
 330     {
 331       gint chunk;
 332       int errsv;
 333
 334       if (debug)
 335         g_print ("%s:read_helper_report: read %" G_GSIZE_FORMAT "...\n",
 336                  __FILE__,
 337                  sizeof(gintptr)*2 - bytes);
 338
 339       chunk = read (fd, ((gchar*)report) + bytes,
 340                     sizeof(gintptr)*2 - bytes);
 341       errsv = errno;
 342
 343       if (debug)
 344         g_print ("...got %d bytes\n", chunk);
 345
 346       if (chunk < 0)
 347         {
 348           /* Some weird shit happened, bail out */
 349           g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED,
 350                        _("Failed to read from child pipe (%s)"),
 351                        g_strerror (errsv));
 352
 353           return FALSE;
 354         }
 355       else if (chunk == 0)
 356         {
 357           g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED,
 358                        _("Failed to read from child pipe (%s)"),
 359                        "EOF");
 360           break; /* EOF */
 361         }
 362       else
 363         bytes += chunk;
 364     }
 365
 366   if (bytes < sizeof(gintptr)*2)
 367     return FALSE;
 368
 369   return TRUE;
 370 }
 371
 372 static void
 373 set_child_error (gintptr      report[2],
 374                  const gchar *working_directory,
 375                  GError     **error)
 376 {
 377   switch (report[0])
 378     {
 379     case CHILD_CHDIR_FAILED:
 380       g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_CHDIR,
 381                    _("Failed to change to directory “%s” (%s)"),
 382                    working_directory,
 383                    g_strerror (report[1]));
 384       break;
 385     case CHILD_SPAWN_FAILED:
 386       g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED,
 387                    _("Failed to execute child process (%s)"),
 388                    g_strerror (report[1]));
 389       break;
 390     case CHILD_SPAWN_NOENT:
 391       g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_NOENT,
 392                    _("Failed to execute child process (%s)"),
 393                    g_strerror (report[1]));
 394       break;
 395     default:
 396       g_assert_not_reached ();
 397     }
 398 }
 399
 400 static gboolean
 401 utf8_charv_to_wcharv (const gchar * const   *utf8_charv,
 402                       wchar_t             ***wcharv,
 403                       int                   *error_index,
 404                       GError               **error)
 405 {
 406   wchar_t **retval = NULL;
 407
 408   *wcharv = NULL;
 409   if (utf8_charv != NULL)
 410     {
 411       int n = 0, i;
 412
 413       while (utf8_charv[n])
 414         n++;
 415       retval = g_new (wchar_t *, n + 1);
 416
 417       for (i = 0; i < n; i++)
 418         {
 419           retval[i] = g_utf8_to_utf16 (utf8_charv[i], -1, NULL, NULL, error);
 420           if (retval[i] == NULL)
 421             {
 422               if (error_index)
 423                 *error_index = i;
 424               while (i)
 425                 g_free (retval[--i]);
 426               g_free (retval);
 427               return FALSE;
 428             }
 429         }
 430
 431       retval[n] = NULL;
 432     }
 433   *wcharv = retval;
 434   return TRUE;
 435 }
 436
 437 static gboolean
 438 do_spawn_directly (gint                 *exit_status,
 439                    gboolean              do_return_handle,
 440                    GSpawnFlags           flags,
 441                    const gchar * const  *argv,
 442                    const gchar * const  *envp,
 443                    const gchar * const  *protected_argv,
 444                    GPid                 *child_pid,
 445                    GError              **error)
 446 {
 447   const int mode = (exit_status == NULL) ? P_NOWAIT : P_WAIT;
 448   const gchar * const *new_argv;
 449   gintptr rc = -1;
 450   int errsv;
 451   GError *conv_error = NULL;
 452   gint conv_error_index;
 453   wchar_t *wargv0, **wargv, **wenvp;
 454
 455   new_argv = (flags & G_SPAWN_FILE_AND_ARGV_ZERO) ? protected_argv + 1 : protected_argv;
 456
 457   wargv0 = g_utf8_to_utf16 (argv[0], -1, NULL, NULL, &conv_error);
 458   if (wargv0 == NULL)
 459     {
 460       g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED,
 461                    _("Invalid program name: %s"),
 462                    conv_error->message);
 463       g_error_free (conv_error);
 464
 465       return FALSE;
 466     }
 467
 468   if (!utf8_charv_to_wcharv (new_argv, &wargv, &conv_error_index, &conv_error))
 469     {
 470       g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED,
 471                    _("Invalid string in argument vector at %d: %s"),
 472                    conv_error_index, conv_error->message);
 473       g_error_free (conv_error);
 474       g_free (wargv0);
 475
 476       return FALSE;
 477     }
 478
 479   if (!utf8_charv_to_wcharv (envp, &wenvp, NULL, &conv_error))
 480     {
 481       g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED,
 482                    _("Invalid string in environment: %s"),
 483                    conv_error->message);
 484       g_error_free (conv_error);
 485       g_free (wargv0);
 486       g_strfreev ((gchar **) wargv);
 487
 488       return FALSE;
 489     }
 490
 491   if (flags & G_SPAWN_SEARCH_PATH)
 492     if (wenvp != NULL)
 493       rc = _wspawnvpe (mode, wargv0, (const wchar_t **) wargv, (const wchar_t **) wenvp);
 494     else
 495       rc = _wspawnvp (mode, wargv0, (const wchar_t **) wargv);
 496   else
 497     if (wenvp != NULL)
 498       rc = _wspawnve (mode, wargv0, (const wchar_t **) wargv, (const wchar_t **) wenvp);
 499     else
 500       rc = _wspawnv (mode, wargv0, (const wchar_t **) wargv);
 501
 502   errsv = errno;
 503
 504   g_free (wargv0);
 505   g_strfreev ((gchar **) wargv);
 506   g_strfreev ((gchar **) wenvp);
 507
 508   if (rc == -1 && errsv != 0)
 509     {
 510       g_set_error (error, G_SPAWN_ERROR, _g_spawn_exec_err_to_g_error (errsv),
 511                    _("Failed to execute child process (%s)"),
 512                    g_strerror (errsv));
 513       return FALSE;
 514     }
 515
 516   if (exit_status == NULL)
 517     {
 518       if (child_pid && do_return_handle)
 519         *child_pid = (GPid) rc;
 520       else
 521         {
 522           CloseHandle ((HANDLE) rc);
 523           if (child_pid)
 524             *child_pid = 0;
 525         }
 526     }
 527   else
 528     *exit_status = rc;
 529
 530   return TRUE;
 531 }
 532
 533 static gboolean
 534 fork_exec (gint                  *exit_status,
 535            gboolean               do_return_handle,
 536            const gchar           *working_directory,
 537            const gchar * const   *argv,
 538            const gchar * const   *envp,
 539            GSpawnFlags            flags,
 540            GSpawnChildSetupFunc   child_setup,
 541            gpointer               user_data,
 542            GPid                  *child_pid,
 543            gint                  *stdin_pipe_out,
 544            gint                  *stdout_pipe_out,
 545            gint                  *stderr_pipe_out,
 546            gint                   stdin_fd,
 547            gint                   stdout_fd,
 548            gint                   stderr_fd,
 549            gint                  *err_report,
 550            GError               **error)
 551 {
 552   char **protected_argv;
 553   char args[ARG_COUNT][10];
 554   char **new_argv;
 555   int i;
 556   gintptr rc = -1;
 557   int errsv;
 558   int argc;
 559   int child_err_report_pipe[2] = { -1, -1 };
 560   int helper_sync_pipe[2] = { -1, -1 };
 561   gintptr helper_report[2];
 562   static gboolean warned_about_child_setup = FALSE;
 563   GError *conv_error = NULL;
 564   gint conv_error_index;
 565   gchar *helper_process;
 566   wchar_t *whelper, **wargv, **wenvp;
 567   gchar *glib_dll_directory;
 568   int stdin_pipe[2] = { -1, -1 };
 569   int stdout_pipe[2] = { -1, -1 };
 570   int stderr_pipe[2] = { -1, -1 };
 571
 572   g_assert (stdin_pipe_out == NULL || stdin_fd < 0);
 573   g_assert (stdout_pipe_out == NULL || stdout_fd < 0);
 574   g_assert (stderr_pipe_out == NULL || stderr_fd < 0);
 575
 576   if (child_setup && !warned_about_child_setup)
 577     {
 578       warned_about_child_setup = TRUE;
 579       g_warning ("passing a child setup function to the g_spawn functions is pointless on Windows and it is ignored");
 580     }
 581
 582   if (stdin_pipe_out != NULL)
 583     {
 584       if (!make_pipe (stdin_pipe, error))
 585         goto cleanup_and_fail;
 586       stdin_fd = stdin_pipe[0];
 587     }
 588
 589   if (stdout_pipe_out != NULL)
 590     {
 591       if (!make_pipe (stdout_pipe, error))
 592         goto cleanup_and_fail;
 593       stdout_fd = stdout_pipe[1];
 594     }
 595
 596   if (stderr_pipe_out != NULL)
 597     {
 598       if (!make_pipe (stderr_pipe, error))
 599         goto cleanup_and_fail;
 600       stderr_fd = stderr_pipe[1];
 601     }
 602
 603   argc = protect_argv (argv, &protected_argv);
 604
 605   if (stdin_fd == -1 && stdout_fd == -1 && stderr_fd == -1 &&
 606       (flags & G_SPAWN_CHILD_INHERITS_STDIN) &&
 607       !(flags & G_SPAWN_STDOUT_TO_DEV_NULL) &&
 608       !(flags & G_SPAWN_STDERR_TO_DEV_NULL) &&
 609       (working_directory == NULL || !*working_directory) &&
 610       (flags & G_SPAWN_LEAVE_DESCRIPTORS_OPEN))
 611     {
 612       /* We can do without the helper process */
 613       gboolean retval =
 614         do_spawn_directly (exit_status, do_return_handle, flags,
 615                            argv, envp, (const gchar * const *) protected_argv,
 616                            child_pid, error);
 617       g_strfreev (protected_argv);
 618       return retval;
 619     }
 620
 621   if (!make_pipe (child_err_report_pipe, error))
 622     goto cleanup_and_fail;
 623
 624   if (!make_pipe (helper_sync_pipe, error))
 625     goto cleanup_and_fail;
 626
 627   new_argv = g_new (char *, argc + 1 + ARG_COUNT);
 628   if (GetConsoleWindow () != NULL)
 629     helper_process = HELPER_PROCESS "-console.exe";
 630   else
 631     helper_process = HELPER_PROCESS ".exe";
 632
 633   glib_dll_directory = _glib_get_dll_directory ();
 634   if (glib_dll_directory != NULL)
 635     {
 636       helper_process = g_build_filename (glib_dll_directory, helper_process, NULL);
 637       g_free (glib_dll_directory);
 638     }
 639   else
 640     helper_process = g_strdup (helper_process);
 641
 642   new_argv[0] = protect_argv_string (helper_process);
 643
 644   _g_sprintf (args[ARG_CHILD_ERR_REPORT], "%d", child_err_report_pipe[1]);
 645   new_argv[ARG_CHILD_ERR_REPORT] = args[ARG_CHILD_ERR_REPORT];
 646
 647   /* Make the read end of the child error report pipe
 648    * noninherited. Otherwise it will needlessly be inherited by the
 649    * helper process, and the started actual user process. As such that
 650    * shouldn't harm, but it is unnecessary.
 651    */
 652   child_err_report_pipe[0] = reopen_noninherited (child_err_report_pipe[0], _O_RDONLY);
 653
 654   if (flags & G_SPAWN_FILE_AND_ARGV_ZERO)
 655     {
 656       /* Overload ARG_CHILD_ERR_REPORT to also encode the
 657        * G_SPAWN_FILE_AND_ARGV_ZERO functionality.
 658        */
 659       strcat (args[ARG_CHILD_ERR_REPORT], "#");
 660     }
 661
 662   _g_sprintf (args[ARG_HELPER_SYNC], "%d", helper_sync_pipe[0]);
 663   new_argv[ARG_HELPER_SYNC] = args[ARG_HELPER_SYNC];
 664
 665   /* Make the write end of the sync pipe noninherited. Otherwise the
 666    * helper process will inherit it, and thus if this process happens
 667    * to crash before writing the sync byte to the pipe, the helper
 668    * process won't read but won't get any EOF either, as it has the
 669    * write end open itself.
 670    */
 671   helper_sync_pipe[1] = reopen_noninherited (helper_sync_pipe[1], _O_WRONLY);
 672
 673   if (stdin_fd != -1)
 674     {
 675       _g_sprintf (args[ARG_STDIN], "%d", stdin_fd);
 676       new_argv[ARG_STDIN] = args[ARG_STDIN];
 677     }
 678   else if (flags & G_SPAWN_CHILD_INHERITS_STDIN)
 679     {
 680       /* Let stdin be alone */
 681       new_argv[ARG_STDIN] = "-";
 682     }
 683   else
 684     {
 685       /* Keep process from blocking on a read of stdin */
 686       new_argv[ARG_STDIN] = "z";
 687     }
 688
 689   if (stdout_fd != -1)
 690     {
 691       _g_sprintf (args[ARG_STDOUT], "%d", stdout_fd);
 692       new_argv[ARG_STDOUT] = args[ARG_STDOUT];
 693     }
 694   else if (flags & G_SPAWN_STDOUT_TO_DEV_NULL)
 695     {
 696       new_argv[ARG_STDOUT] = "z";
 697     }
 698   else
 699     {
 700       new_argv[ARG_STDOUT] = "-";
 701     }
 702
 703   if (stderr_fd != -1)
 704     {
 705       _g_sprintf (args[ARG_STDERR], "%d", stderr_fd);
 706       new_argv[ARG_STDERR] = args[ARG_STDERR];
 707     }
 708   else if (flags & G_SPAWN_STDERR_TO_DEV_NULL)
 709     {
 710       new_argv[ARG_STDERR] = "z";
 711     }
 712   else
 713     {
 714       new_argv[ARG_STDERR] = "-";
 715     }
 716
 717   if (working_directory && *working_directory)
 718     new_argv[ARG_WORKING_DIRECTORY] = protect_argv_string (working_directory);
 719   else
 720     new_argv[ARG_WORKING_DIRECTORY] = g_strdup ("-");
 721
 722   if (!(flags & G_SPAWN_LEAVE_DESCRIPTORS_OPEN))
 723     new_argv[ARG_CLOSE_DESCRIPTORS] = "y";
 724   else
 725     new_argv[ARG_CLOSE_DESCRIPTORS] = "-";
 726
 727   if (flags & G_SPAWN_SEARCH_PATH)
 728     new_argv[ARG_USE_PATH] = "y";
 729   else
 730     new_argv[ARG_USE_PATH] = "-";
 731
 732   if (exit_status == NULL)
 733     new_argv[ARG_WAIT] = "-";
 734   else
 735     new_argv[ARG_WAIT] = "w";
 736
 737   for (i = 0; i <= argc; i++)
 738     new_argv[ARG_PROGRAM + i] = protected_argv[i];
 739
 740   SETUP_DEBUG();
 741
 742   if (debug)
 743     {
 744       g_print ("calling %s with argv:\n", helper_process);
 745       for (i = 0; i < argc + 1 + ARG_COUNT; i++)
 746         g_print ("argv[%d]: %s\n", i, (new_argv[i] ? new_argv[i] : "NULL"));
 747     }
 748
 749   if (!utf8_charv_to_wcharv ((const gchar * const *) new_argv, &wargv, &conv_error_index, &conv_error))
 750     {
 751       if (conv_error_index == ARG_WORKING_DIRECTORY)
 752         g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_CHDIR,
 753                      _("Invalid working directory: %s"),
 754                      conv_error->message);
 755       else
 756         g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED,
 757                      _("Invalid string in argument vector at %d: %s"),
 758                      conv_error_index - ARG_PROGRAM, conv_error->message);
 759       g_error_free (conv_error);
 760       g_strfreev (protected_argv);
 761       g_free (new_argv[0]);
 762       g_free (new_argv[ARG_WORKING_DIRECTORY]);
 763       g_free (new_argv);
 764       g_free (helper_process);
 765
 766       goto cleanup_and_fail;
 767     }
 768
 769   if (!utf8_charv_to_wcharv (envp, &wenvp, NULL, &conv_error))
 770     {
 771       g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED,
 772                    _("Invalid string in environment: %s"),
 773                    conv_error->message);
 774       g_error_free (conv_error);
 775       g_strfreev (protected_argv);
 776       g_free (new_argv[0]);
 777       g_free (new_argv[ARG_WORKING_DIRECTORY]);
 778       g_free (new_argv);
 779       g_free (helper_process);
 780       g_strfreev ((gchar **) wargv);
 781
 782       goto cleanup_and_fail;
 783     }
 784
 785   whelper = g_utf8_to_utf16 (helper_process, -1, NULL, NULL, NULL);
 786   g_free (helper_process);
 787
 788   if (wenvp != NULL)
 789     rc = _wspawnvpe (P_NOWAIT, whelper, (const wchar_t **) wargv, (const wchar_t **) wenvp);
 790   else
 791     rc = _wspawnvp (P_NOWAIT, whelper, (const wchar_t **) wargv);
 792
 793   errsv = errno;
 794
 795   g_free (whelper);
 796   g_strfreev ((gchar **) wargv);
 797   g_strfreev ((gchar **) wenvp);
 798
 799   /* Close the other process's ends of the pipes in this process,
 800    * otherwise the reader will never get EOF.
 801    */
 802   close_and_invalidate (&child_err_report_pipe[1]);
 803   close_and_invalidate (&helper_sync_pipe[0]);
 804
 805   g_strfreev (protected_argv);
 806
 807   g_free (new_argv[0]);
 808   g_free (new_argv[ARG_WORKING_DIRECTORY]);
 809   g_free (new_argv);
 810
 811   /* Check if gspawn-win32-helper couldn't be run */
 812   if (rc == -1 && errsv != 0)
 813     {
 814       g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED,
 815                    _("Failed to execute helper program (%s)"),
 816                    g_strerror (errsv));
 817       goto cleanup_and_fail;
 818     }
 819
 820   if (exit_status != NULL)
 821     {
 822       /* Synchronous case. Pass helper's report pipe back to caller,
 823        * which takes care of reading it after the grandchild has
 824        * finished.
 825        */
 826       g_assert (err_report != NULL);
 827       *err_report = child_err_report_pipe[0];
 828       write (helper_sync_pipe[1], " ", 1);
 829       close_and_invalidate (&helper_sync_pipe[1]);
 830     }
 831   else
 832     {
 833       /* Asynchronous case. We read the helper's report right away. */
 834       if (!read_helper_report (child_err_report_pipe[0], helper_report, error))
 835         goto cleanup_and_fail;
 836
 837       close_and_invalidate (&child_err_report_pipe[0]);
 838
 839       switch (helper_report[0])
 840         {
 841         case CHILD_NO_ERROR:
 842           if (child_pid && do_return_handle)
 843             {
 844               /* rc is our HANDLE for gspawn-win32-helper. It has
 845                * told us the HANDLE of its child. Duplicate that into
 846                * a HANDLE valid in this process.
 847                */
 848               if (!DuplicateHandle ((HANDLE) rc, (HANDLE) helper_report[1],
 849                                     GetCurrentProcess (), (LPHANDLE) child_pid,
 850                                     0, TRUE, DUPLICATE_SAME_ACCESS))
 851                 {
 852                   char *emsg = g_win32_error_message (GetLastError ());
 853                   g_print("%s\n", emsg);
 854                   *child_pid = 0;
 855                 }
 856             }
 857           else if (child_pid)
 858             *child_pid = 0;
 859           write (helper_sync_pipe[1], " ", 1);
 860           close_and_invalidate (&helper_sync_pipe[1]);
 861           break;
 862
 863         default:
 864           write (helper_sync_pipe[1], " ", 1);
 865           close_and_invalidate (&helper_sync_pipe[1]);
 866           set_child_error (helper_report, working_directory, error);
 867           goto cleanup_and_fail;
 868         }
 869     }
 870
 871   /* Success against all odds! return the information */
 872
 873   if (rc != -1)
 874     CloseHandle ((HANDLE) rc);
 875
 876   /* Close the other process's ends of the pipes in this process,
 877    * otherwise the reader will never get EOF.
 878    */
 879   close_and_invalidate (&stdin_pipe[0]);
 880   close_and_invalidate (&stdout_pipe[1]);
 881   close_and_invalidate (&stderr_pipe[1]);
 882
 883   if (stdin_pipe_out != NULL)
 884     *stdin_pipe_out = stdin_pipe[1];
 885   if (stdout_pipe_out != NULL)
 886     *stdout_pipe_out = stdout_pipe[0];
 887   if (stderr_pipe_out != NULL)
 888     *stderr_pipe_out = stderr_pipe[0];
 889
 890   return TRUE;
 891
 892  cleanup_and_fail:
 893
 894   if (rc != -1)
 895     CloseHandle ((HANDLE) rc);
 896   if (child_err_report_pipe[0] != -1)
 897     close (child_err_report_pipe[0]);
 898   if (child_err_report_pipe[1] != -1)
 899     close (child_err_report_pipe[1]);
 900   if (helper_sync_pipe[0] != -1)
 901     close (helper_sync_pipe[0]);
 902   if (helper_sync_pipe[1] != -1)
 903     close (helper_sync_pipe[1]);
 904
 905   if (stdin_pipe[0] != -1)
 906     close (stdin_pipe[0]);
 907   if (stdin_pipe[1] != -1)
 908     close (stdin_pipe[1]);
 909   if (stdout_pipe[0] != -1)
 910     close (stdout_pipe[0]);
 911   if (stdout_pipe[1] != -1)
 912     close (stdout_pipe[1]);
 913   if (stderr_pipe[0] != -1)
 914     close (stderr_pipe[0]);
 915   if (stderr_pipe[1] != -1)
 916     close (stderr_pipe[1]);
 917
 918   return FALSE;
 919 }
 920
 921 gboolean
 922 g_spawn_sync (const gchar          *working_directory,
 923               gchar               **argv,
 924               gchar               **envp,
 925               GSpawnFlags           flags,
 926               GSpawnChildSetupFunc  child_setup,
 927               gpointer              user_data,
 928               gchar               **standard_output,
 929               gchar               **standard_error,
 930               gint                 *exit_status,
 931               GError              **error)
 932 {
 933   gint outpipe = -1;
 934   gint errpipe = -1;
 935   gint reportpipe = -1;
 936   GIOChannel *outchannel = NULL;
 937   GIOChannel *errchannel = NULL;
 938   GPollFD outfd, errfd;
 939   GPollFD fds[2];
 940   gint nfds;
 941   gint outindex = -1;
 942   gint errindex = -1;
 943   gint ret;
 944   GString *outstr = NULL;
 945   GString *errstr = NULL;
 946   gboolean failed;
 947   gint status;
 948
 949   g_return_val_if_fail (argv != NULL, FALSE);
 950   g_return_val_if_fail (!(flags & G_SPAWN_DO_NOT_REAP_CHILD), FALSE);
 951   g_return_val_if_fail (standard_output == NULL ||
 952                         !(flags & G_SPAWN_STDOUT_TO_DEV_NULL), FALSE);
 953   g_return_val_if_fail (standard_error == NULL ||
 954                         !(flags & G_SPAWN_STDERR_TO_DEV_NULL), FALSE);
 955
 956   /* Just to ensure segfaults if callers try to use
 957    * these when an error is reported.
 958    */
 959   if (standard_output)
 960     *standard_output = NULL;
 961
 962   if (standard_error)
 963     *standard_error = NULL;
 964
 965   if (!fork_exec (&status,
 966                   FALSE,
 967                   working_directory,
 968                   (const gchar * const *) argv,
 969                   (const gchar * const *) envp,
 970                   flags,
 971                   child_setup,
 972                   user_data,
 973                   NULL,
 974                   NULL,
 975                   standard_output ? &outpipe : NULL,
 976                   standard_error ? &errpipe : NULL,
 977                   -1,
 978                   -1,
 979                   -1,
 980                   &reportpipe,
 981                   error))
 982     return FALSE;
 983
 984   /* Read data from child. */
 985
 986   failed = FALSE;
 987
 988   if (outpipe >= 0)
 989     {
 990       outstr = g_string_new (NULL);
 991       outchannel = g_io_channel_win32_new_fd (outpipe);
 992       g_io_channel_set_encoding (outchannel, NULL, NULL);
 993       g_io_channel_set_buffered (outchannel, FALSE);
 994       g_io_channel_win32_make_pollfd (outchannel,
 995                                       G_IO_IN | G_IO_ERR | G_IO_HUP,
 996                                       &outfd);
 997       if (debug)
 998         g_print ("outfd=%p\n", (HANDLE) outfd.fd);
 999     }
1000
1001   if (errpipe >= 0)
1002     {
1003       errstr = g_string_new (NULL);
1004       errchannel = g_io_channel_win32_new_fd (errpipe);
1005       g_io_channel_set_encoding (errchannel, NULL, NULL);
1006       g_io_channel_set_buffered (errchannel, FALSE);
1007       g_io_channel_win32_make_pollfd (errchannel,
1008                                       G_IO_IN | G_IO_ERR | G_IO_HUP,
1009                                       &errfd);
1010       if (debug)
1011         g_print ("errfd=%p\n", (HANDLE) errfd.fd);
1012     }
1013
1014   /* Read data until we get EOF on all pipes. */
1015   while (!failed && (outpipe >= 0 || errpipe >= 0))
1016     {
1017       nfds = 0;
1018       if (outpipe >= 0)
1019         {
1020           fds[nfds] = outfd;
1021           outindex = nfds;
1022           nfds++;
1023         }
1024       if (errpipe >= 0)
1025         {
1026           fds[nfds] = errfd;
1027           errindex = nfds;
1028           nfds++;
1029         }
1030
1031       if (debug)
1032         g_print ("g_spawn_sync: calling g_io_channel_win32_poll, nfds=%d\n",
1033                  nfds);
1034
1035       ret = g_io_channel_win32_poll (fds, nfds, -1);
1036
1037       if (ret < 0)
1038         {
1039           failed = TRUE;
1040
1041           g_set_error_literal (error, G_SPAWN_ERROR, G_SPAWN_ERROR_READ,
1042                                _("Unexpected error in g_io_channel_win32_poll() reading data from a child process"));
1043
1044           break;
1045         }
1046
1047       if (outpipe >= 0 && (fds[outindex].revents & G_IO_IN))
1048         {
1049           switch (read_data (outstr, outchannel, error))
1050             {
1051             case READ_FAILED:
1052               if (debug)
1053                 g_print ("g_spawn_sync: outchannel: READ_FAILED\n");
1054               failed = TRUE;
1055               break;
1056             case READ_EOF:
1057               if (debug)
1058                 g_print ("g_spawn_sync: outchannel: READ_EOF\n");
1059               g_io_channel_unref (outchannel);
1060               outchannel = NULL;
1061               close_and_invalidate (&outpipe);
1062               break;
1063             default:
1064               if (debug)
1065                 g_print ("g_spawn_sync: outchannel: OK\n");
1066               break;
1067             }
1068
1069           if (failed)
1070             break;
1071         }
1072
1073       if (errpipe >= 0 && (fds[errindex].revents & G_IO_IN))
1074         {
1075           switch (read_data (errstr, errchannel, error))
1076             {
1077             case READ_FAILED:
1078               if (debug)
1079                 g_print ("g_spawn_sync: errchannel: READ_FAILED\n");
1080               failed = TRUE;
1081               break;
1082             case READ_EOF:
1083               if (debug)
1084                 g_print ("g_spawn_sync: errchannel: READ_EOF\n");
1085               g_io_channel_unref (errchannel);
1086               errchannel = NULL;
1087               close_and_invalidate (&errpipe);
1088               break;
1089             default:
1090               if (debug)
1091                 g_print ("g_spawn_sync: errchannel: OK\n");
1092               break;
1093             }
1094
1095           if (failed)
1096             break;
1097         }
1098     }
1099
1100   if (reportpipe == -1)
1101     {
1102       /* No helper process, exit status of actual spawned process
1103        * already available.
1104        */
1105       if (exit_status)
1106         *exit_status = status;
1107     }
1108   else
1109     {
1110       /* Helper process was involved. Read its report now after the
1111        * grandchild has finished.
1112        */
1113       gintptr helper_report[2];
1114
1115       if (!read_helper_report (reportpipe, helper_report, error))
1116         failed = TRUE;
1117       else
1118         {
1119           switch (helper_report[0])
1120             {
1121             case CHILD_NO_ERROR:
1122               if (exit_status)
1123                 *exit_status = helper_report[1];
1124               break;
1125             default:
1126               set_child_error (helper_report, working_directory, error);
1127               failed = TRUE;
1128               break;
1129             }
1130         }
1131       close_and_invalidate (&reportpipe);
1132     }
1133
1134
1135   /* These should only be open still if we had an error.  */
1136
1137   if (outchannel != NULL)
1138     g_io_channel_unref (outchannel);
1139   if (errchannel != NULL)
1140     g_io_channel_unref (errchannel);
1141   if (outpipe >= 0)
1142     close_and_invalidate (&outpipe);
1143   if (errpipe >= 0)
1144     close_and_invalidate (&errpipe);
1145
1146   if (failed)
1147     {
1148       if (outstr)
1149         g_string_free (outstr, TRUE);
1150       if (errstr)
1151         g_string_free (errstr, TRUE);
1152
1153       return FALSE;
1154     }
1155   else
1156     {
1157       if (standard_output)
1158         *standard_output = g_string_free (outstr, FALSE);
1159
1160       if (standard_error)
1161         *standard_error = g_string_free (errstr, FALSE);
1162
1163       return TRUE;
1164     }
1165 }
1166
1167 gboolean
1168 g_spawn_async_with_pipes (const gchar          *working_directory,
1169                           gchar               **argv,
1170                           gchar               **envp,
1171                           GSpawnFlags           flags,
1172                           GSpawnChildSetupFunc  child_setup,
1173                           gpointer              user_data,
1174                           GPid                 *child_pid,
1175                           gint                 *standard_input,
1176                           gint                 *standard_output,
1177                           gint                 *standard_error,
1178                           GError              **error)
1179 {
1180   g_return_val_if_fail (argv != NULL, FALSE);
1181   g_return_val_if_fail (standard_output == NULL ||
1182                         !(flags & G_SPAWN_STDOUT_TO_DEV_NULL), FALSE);
1183   g_return_val_if_fail (standard_error == NULL ||
1184                         !(flags & G_SPAWN_STDERR_TO_DEV_NULL), FALSE);
1185   /* can't inherit stdin if we have an input pipe. */
1186   g_return_val_if_fail (standard_input == NULL ||
1187                         !(flags & G_SPAWN_CHILD_INHERITS_STDIN), FALSE);
1188
1189   return fork_exec (NULL,
1190                     (flags & G_SPAWN_DO_NOT_REAP_CHILD),
1191                     working_directory,
1192                     (const gchar * const *) argv,
1193                     (const gchar * const *) envp,
1194                     flags,
1195                     child_setup,
1196                     user_data,
1197                     child_pid,
1198                     standard_input,
1199                     standard_output,
1200                     standard_error,
1201                     -1,
1202                     -1,
1203                     -1,
1204                     NULL,
1205                     error);
1206 }
1207
1208 gboolean
1209 g_spawn_async_with_fds (const gchar          *working_directory,
1210                         gchar               **argv,
1211                         gchar               **envp,
1212                         GSpawnFlags           flags,
1213                         GSpawnChildSetupFunc  child_setup,
1214                         gpointer              user_data,
1215                         GPid                 *child_pid,
1216                         gint                  stdin_fd,
1217                         gint                  stdout_fd,
1218                         gint                  stderr_fd,
1219                         GError              **error)
1220 {
1221   g_return_val_if_fail (argv != NULL, FALSE);
1222   g_return_val_if_fail (stdin_fd == -1 ||
1223                         !(flags & G_SPAWN_STDOUT_TO_DEV_NULL), FALSE);
1224   g_return_val_if_fail (stderr_fd == -1 ||
1225                         !(flags & G_SPAWN_STDERR_TO_DEV_NULL), FALSE);
1226   /* can't inherit stdin if we have an input pipe. */
1227   g_return_val_if_fail (stdin_fd == -1 ||
1228                         !(flags & G_SPAWN_CHILD_INHERITS_STDIN), FALSE);
1229
1230   return fork_exec (NULL,
1231                     (flags & G_SPAWN_DO_NOT_REAP_CHILD),
1232                     working_directory,
1233                     (const gchar * const *) argv,
1234                     (const gchar * const *) envp,
1235                     flags,
1236                     child_setup,
1237                     user_data,
1238                     child_pid,
1239                     NULL,
1240                     NULL,
1241                     NULL,
1242                     stdin_fd,
1243                     stdout_fd,
1244                     stderr_fd,
1245                     NULL,
1246                     error);
1247
1248 }
1249
1250 gboolean
1251 g_spawn_async_with_pipes_and_fds (const gchar           *working_directory,
1252                                   const gchar * const   *argv,
1253                                   const gchar * const   *envp,
1254                                   GSpawnFlags            flags,
1255                                   GSpawnChildSetupFunc   child_setup,
1256                                   gpointer               user_data,
1257                                   gint                   stdin_fd,
1258                                   gint                   stdout_fd,
1259                                   gint                   stderr_fd,
1260                                   const gint            *source_fds,
1261                                   const gint            *target_fds,
1262                                   gsize                  n_fds,
1263                                   GPid                  *child_pid_out,
1264                                   gint                  *stdin_pipe_out,
1265                                   gint                  *stdout_pipe_out,
1266                                   gint                  *stderr_pipe_out,
1267                                   GError               **error)
1268 {
1269   g_return_val_if_fail (argv != NULL, FALSE);
1270   g_return_val_if_fail (stdout_pipe_out == NULL ||
1271                         !(flags & G_SPAWN_STDOUT_TO_DEV_NULL), FALSE);
1272   g_return_val_if_fail (stderr_pipe_out == NULL ||
1273                         !(flags & G_SPAWN_STDERR_TO_DEV_NULL), FALSE);
1274   /* can't inherit stdin if we have an input pipe. */
1275   g_return_val_if_fail (stdin_pipe_out == NULL ||
1276                         !(flags & G_SPAWN_CHILD_INHERITS_STDIN), FALSE);
1277   /* can’t use pipes and stdin/stdout/stderr FDs */
1278   g_return_val_if_fail (stdin_pipe_out == NULL || stdin_fd < 0, FALSE);
1279   g_return_val_if_fail (stdout_pipe_out == NULL || stdout_fd < 0, FALSE);
1280   g_return_val_if_fail (stderr_pipe_out == NULL || stderr_fd < 0, FALSE);
1281
1282   /* source_fds/target_fds isn’t supported on Windows at the moment. */
1283   if (n_fds != 0)
1284     {
1285       g_set_error_literal (error, G_SPAWN_ERROR, G_SPAWN_ERROR_INVAL,
1286                            "FD redirection is not supported on Windows at the moment");
1287       return FALSE;
1288     }
1289
1290   return fork_exec (NULL,
1291                     (flags & G_SPAWN_DO_NOT_REAP_CHILD),
1292                     working_directory,
1293                     argv,
1294                     envp,
1295                     flags,
1296                     child_setup,
1297                     user_data,
1298                     child_pid_out,
1299                     stdin_pipe_out,
1300                     stdout_pipe_out,
1301                     stderr_pipe_out,
1302                     stdin_fd,
1303                     stdout_fd,
1304                     stderr_fd,
1305                     NULL,
1306                     error);
1307 }
1308
1309 gboolean
1310 g_spawn_command_line_sync (const gchar  *command_line,
1311                            gchar       **standard_output,
1312                            gchar       **standard_error,
1313                            gint         *exit_status,
1314                            GError      **error)
1315 {
1316   gboolean retval;
1317   gchar **argv = 0;
1318
1319   g_return_val_if_fail (command_line != NULL, FALSE);
1320
1321   if (!g_shell_parse_argv (command_line,
1322                            NULL, &argv,
1323                            error))
1324     return FALSE;
1325
1326   retval = g_spawn_sync (NULL,
1327                          argv,
1328                          NULL,
1329                          G_SPAWN_SEARCH_PATH,
1330                          NULL,
1331                          NULL,
1332                          standard_output,
1333                          standard_error,
1334                          exit_status,
1335                          error);
1336   g_strfreev (argv);
1337
1338   return retval;
1339 }
1340
1341 gboolean
1342 g_spawn_command_line_async (const gchar *command_line,
1343                             GError     **error)
1344 {
1345   gboolean retval;
1346   gchar **argv = 0;
1347
1348   g_return_val_if_fail (command_line != NULL, FALSE);
1349
1350   if (!g_shell_parse_argv (command_line,
1351                            NULL, &argv,
1352                            error))
1353     return FALSE;
1354
1355   retval = g_spawn_async (NULL,
1356                           argv,
1357                           NULL,
1358                           G_SPAWN_SEARCH_PATH,
1359                           NULL,
1360                           NULL,
1361                           NULL,
1362                           error);
1363   g_strfreev (argv);
1364
1365   return retval;
1366 }
1367
1368 void
1369 g_spawn_close_pid (GPid pid)
1370 {
1371     CloseHandle (pid);
1372 }
1373
1374 gboolean
1375 g_spawn_check_exit_status (gint      exit_status,
1376                            GError  **error)
1377 {
1378   gboolean ret = FALSE;
1379
1380   if (exit_status != 0)
1381     {
1382       g_set_error (error, G_SPAWN_EXIT_ERROR, exit_status,
1383                    _("Child process exited with code %ld"),
1384                    (long) exit_status);
1385       goto out;
1386     }
1387
1388   ret = TRUE;
1389  out:
1390   return ret;
1391 }
1392
1393 #ifdef G_OS_WIN32
1394
1395 /* Binary compatibility versions. Not for newly compiled code. */
1396
1397 _GLIB_EXTERN gboolean g_spawn_async_utf8              (const gchar           *working_directory,
1398                                                        gchar                **argv,
1399                                                        gchar                **envp,
1400                                                        GSpawnFlags            flags,
1401                                                        GSpawnChildSetupFunc   child_setup,
1402                                                        gpointer               user_data,
1403                                                        GPid                  *child_pid,
1404                                                        GError               **error);
1405 _GLIB_EXTERN gboolean g_spawn_async_with_pipes_utf8   (const gchar           *working_directory,
1406                                                        gchar                **argv,
1407                                                        gchar                **envp,
1408                                                        GSpawnFlags            flags,
1409                                                        GSpawnChildSetupFunc   child_setup,
1410                                                        gpointer               user_data,
1411                                                        GPid                  *child_pid,
1412                                                        gint                  *standard_input,
1413                                                        gint                  *standard_output,
1414                                                        gint                  *standard_error,
1415                                                        GError               **error);
1416 _GLIB_EXTERN gboolean g_spawn_sync_utf8               (const gchar           *working_directory,
1417                                                        gchar                **argv,
1418                                                        gchar                **envp,
1419                                                        GSpawnFlags            flags,
1420                                                        GSpawnChildSetupFunc   child_setup,
1421                                                        gpointer               user_data,
1422                                                        gchar                **standard_output,
1423                                                        gchar                **standard_error,
1424                                                        gint                  *exit_status,
1425                                                        GError               **error);
1426 _GLIB_EXTERN gboolean g_spawn_command_line_sync_utf8  (const gchar           *command_line,
1427                                                        gchar                **standard_output,
1428                                                        gchar                **standard_error,
1429                                                        gint                  *exit_status,
1430                                                        GError               **error);
1431 _GLIB_EXTERN gboolean g_spawn_command_line_async_utf8 (const gchar           *command_line,
1432                                                        GError               **error);
1433
1434 gboolean
1435 g_spawn_async_utf8 (const gchar          *working_directory,
1436                     gchar               **argv,
1437                     gchar               **envp,
1438                     GSpawnFlags           flags,
1439                     GSpawnChildSetupFunc  child_setup,
1440                     gpointer              user_data,
1441                     GPid                 *child_pid,
1442                     GError              **error)
1443 {
1444   return g_spawn_async (working_directory,
1445                         argv,
1446                         envp,
1447                         flags,
1448                         child_setup,
1449                         user_data,
1450                         child_pid,
1451                         error);
1452 }
1453
1454 gboolean
1455 g_spawn_async_with_pipes_utf8 (const gchar          *working_directory,
1456                                gchar               **argv,
1457                                gchar               **envp,
1458                                GSpawnFlags           flags,
1459                                GSpawnChildSetupFunc  child_setup,
1460                                gpointer              user_data,
1461                                GPid                 *child_pid,
1462                                gint                 *standard_input,
1463                                gint                 *standard_output,
1464                                gint                 *standard_error,
1465                                GError              **error)
1466 {
1467   return g_spawn_async_with_pipes (working_directory,
1468                                    argv,
1469                                    envp,
1470                                    flags,
1471                                    child_setup,
1472                                    user_data,
1473                                    child_pid,
1474                                    standard_input,
1475                                    standard_output,
1476                                    standard_error,
1477                                    error);
1478 }
1479
1480 gboolean
1481 g_spawn_sync_utf8 (const gchar          *working_directory,
1482                    gchar               **argv,
1483                    gchar               **envp,
1484                    GSpawnFlags           flags,
1485                    GSpawnChildSetupFunc  child_setup,
1486                    gpointer              user_data,
1487                    gchar               **standard_output,
1488                    gchar               **standard_error,
1489                    gint                 *exit_status,
1490                    GError              **error)
1491 {
1492   return g_spawn_sync (working_directory,
1493                        argv,
1494                        envp,
1495                        flags,
1496                        child_setup,
1497                        user_data,
1498                        standard_output,
1499                        standard_error,
1500                        exit_status,
1501                        error);
1502 }
1503
1504 gboolean
1505 g_spawn_command_line_sync_utf8 (const gchar  *command_line,
1506                                 gchar       **standard_output,
1507                                 gchar       **standard_error,
1508                                 gint         *exit_status,
1509                                 GError      **error)
1510 {
1511   return g_spawn_command_line_sync (command_line,
1512                                     standard_output,
1513                                     standard_error,
1514                                     exit_status,
1515                                     error);
1516 }
1517
1518 gboolean
1519 g_spawn_command_line_async_utf8 (const gchar *command_line,
1520                                  GError     **error)
1521 {
1522   return g_spawn_command_line_async (command_line, error);
1523 }
1524
1525 #endif /* G_OS_WIN32 */
1526
1527 #endif /* !GSPAWN_HELPER */