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