lib/windows-spawn.c

   1 /* Auxiliary functions for the creation of subprocesses.  Native Windows API.
   2    Copyright (C) 2001, 2003-2020 Free Software Foundation, Inc.
   3    Written by Bruno Haible <bruno@clisp.org>, 2003.
   4
   5    This program is free software: you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 3 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  17
  18 #include <config.h>
  19
  20 /* Specification.  */
  21 #include "windows-spawn.h"
  22
  23 /* Get declarations of the native Windows API functions.  */
  24 #define WIN32_LEAN_AND_MEAN
  25 #include <windows.h>
  26
  27 #include <stdbool.h>
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <errno.h>
  32
  33 /* Get _get_osfhandle().  */
  34 #if GNULIB_MSVC_NOTHROW
  35 # include "msvc-nothrow.h"
  36 #else
  37 # include <io.h>
  38 #endif
  39 #include <process.h>
  40
  41 #include "findprog.h"
  42
  43 /* Don't assume that UNICODE is not defined.  */
  44 #undef STARTUPINFO
  45 #define STARTUPINFO STARTUPINFOA
  46 #undef CreateProcess
  47 #define CreateProcess CreateProcessA
  48
  49 #define SHELL_SPECIAL_CHARS "\"\\ \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037*?"
  50 #define SHELL_SPACE_CHARS " \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
  51
  52 /* Returns the length of a quoted argument string.  */
  53 static size_t
  54 quoted_arg_length (const char *string)
  55 {
  56   bool quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
  57   size_t length;
  58   unsigned int backslashes;
  59   const char *s;
  60
  61   length = 0;
  62   backslashes = 0;
  63   if (quote_around)
  64     length++;
  65   for (s = string; *s != '\0'; s++)
  66     {
  67       char c = *s;
  68       if (c == '"')
  69         length += backslashes + 1;
  70       length++;
  71       if (c == '\\')
  72         backslashes++;
  73       else
  74         backslashes = 0;
  75     }
  76   if (quote_around)
  77     length += backslashes + 1;
  78
  79   return length;
  80 }
  81
  82 /* Produces a quoted argument string.
  83    Stores exactly quoted_arg_length (STRING) + 1 bytes, including the final
  84    NUL byte, at MEM.
  85    Returns a pointer past the stored quoted argument string.  */
  86 static char *
  87 quoted_arg_string (const char *string, char *mem)
  88 {
  89   bool quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
  90   char *p;
  91   unsigned int backslashes;
  92   const char *s;
  93
  94   p = mem;
  95   backslashes = 0;
  96   if (quote_around)
  97     *p++ = '"';
  98   for (s = string; *s != '\0'; s++)
  99     {
 100       char c = *s;
 101       if (c == '"')
 102         {
 103           unsigned int j;
 104           for (j = backslashes + 1; j > 0; j--)
 105             *p++ = '\\';
 106         }
 107       *p++ = c;
 108       if (c == '\\')
 109         backslashes++;
 110       else
 111         backslashes = 0;
 112     }
 113   if (quote_around)
 114     {
 115       unsigned int j;
 116       for (j = backslashes; j > 0; j--)
 117         *p++ = '\\';
 118       *p++ = '"';
 119     }
 120   *p++ = '\0';
 121
 122   return p;
 123 }
 124
 125 const char **
 126 prepare_spawn (const char * const *argv, char **mem_to_free)
 127 {
 128   size_t argc;
 129   const char **new_argv;
 130   size_t i;
 131
 132   /* Count number of arguments.  */
 133   for (argc = 0; argv[argc] != NULL; argc++)
 134     ;
 135
 136   /* Allocate new argument vector.  */
 137   new_argv = (const char **) malloc ((1 + argc + 1) * sizeof (const char *));
 138
 139   /* Add an element upfront that can be used when argv[0] turns out to be a
 140      script, not a program.
 141      On Unix, this would be "/bin/sh". On native Windows, "sh" is actually
 142      "sh.exe".  We have to omit the directory part and rely on the search in
 143      PATH, because the mingw "mount points" are not visible inside Windows
 144      CreateProcess().  */
 145   new_argv[0] = "sh.exe";
 146
 147   /* Put quoted arguments into the new argument vector.  */
 148   size_t needed_size = 0;
 149   for (i = 0; i < argc; i++)
 150     {
 151       const char *string = argv[i];
 152       size_t length;
 153
 154       if (string[0] == '\0')
 155         length = strlen ("\"\"");
 156       else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
 157         length = quoted_arg_length (string);
 158       else
 159         length = strlen (string);
 160       needed_size += length + 1;
 161     }
 162
 163   char *mem;
 164   if (needed_size == 0)
 165     mem = NULL;
 166   else
 167     {
 168       mem = (char *) malloc (needed_size);
 169       if (mem == NULL)
 170         {
 171           /* Memory allocation failure.  */
 172           free (new_argv);
 173           errno = ENOMEM;
 174           return NULL;
 175         }
 176     }
 177   *mem_to_free = mem;
 178
 179   for (i = 0; i < argc; i++)
 180     {
 181       const char *string = argv[i];
 182
 183       new_argv[1 + i] = mem;
 184       if (string[0] == '\0')
 185         {
 186           size_t length = strlen ("\"\"");
 187           memcpy (mem, "\"\"", length + 1);
 188           mem += length + 1;
 189         }
 190       else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
 191         {
 192           mem = quoted_arg_string (string, mem);
 193         }
 194       else
 195         {
 196           size_t length = strlen (string);
 197           memcpy (mem, string, length + 1);
 198           mem += length + 1;
 199         }
 200     }
 201   new_argv[1 + argc] = NULL;
 202
 203   return new_argv;
 204 }
 205
 206 char *
 207 compose_command (const char * const *argv)
 208 {
 209   /* Just concatenate the argv[] strings, separated by spaces.  */
 210   char *command;
 211
 212   /* Determine the size of the needed block of memory.  */
 213   size_t total_size = 0;
 214   const char * const *ap;
 215   const char *p;
 216   for (ap = argv; (p = *ap) != NULL; ap++)
 217     total_size += strlen (p) + 1;
 218   size_t command_size = (total_size > 0 ? total_size : 1);
 219
 220   /* Allocate the block of memory.  */
 221   command = (char *) malloc (command_size);
 222   if (command == NULL)
 223     {
 224       errno = ENOMEM;
 225       return NULL;
 226     }
 227
 228   /* Fill it.  */
 229   if (total_size > 0)
 230     {
 231       char *cp = command;
 232       for (ap = argv; (p = *ap) != NULL; ap++)
 233         {
 234           size_t size = strlen (p) + 1;
 235           memcpy (cp, p, size - 1);
 236           cp += size;
 237           cp[-1] = ' ';
 238         }
 239       cp[-1] = '\0';
 240     }
 241   else
 242     *command = '\0';
 243
 244   return command;
 245 }
 246
 247 char *
 248 compose_envblock (const char * const *envp)
 249 {
 250   /* This is a bit hairy, because we don't have a lock that would prevent other
 251      threads from making modifications in ENVP.  So, just make sure we don't
 252      crash; but if other threads are making modifications, part of the result
 253      may be wrong.  */
 254  retry:
 255   {
 256     /* Guess the size of the needed block of memory.
 257        The guess will be exact if other threads don't make modifications.  */
 258     size_t total_size = 0;
 259     const char * const *ep;
 260     const char *p;
 261     for (ep = envp; (p = *ep) != NULL; ep++)
 262       total_size += strlen (p) + 1;
 263     size_t envblock_size = total_size;
 264
 265     /* Allocate the block of memory.  */
 266     char *envblock = (char *) malloc (envblock_size + 1);
 267     if (envblock == NULL)
 268       {
 269         errno = ENOMEM;
 270         return NULL;
 271       }
 272     size_t envblock_used = 0;
 273     for (ep = envp; (p = *ep) != NULL; ep++)
 274       {
 275         size_t size = strlen (p) + 1;
 276         if (envblock_used + size > envblock_size)
 277           {
 278             /* Other threads did modifications.  Need more memory.  */
 279             envblock_size += envblock_size / 2;
 280             if (envblock_used + size > envblock_size)
 281               envblock_size = envblock_used + size;
 282
 283             char *new_envblock = (char *) realloc (envblock, envblock_size + 1);
 284             if (new_envblock == NULL)
 285               {
 286                 free (envblock);
 287                 errno = ENOMEM;
 288                 return NULL;
 289               }
 290             envblock = new_envblock;
 291           }
 292         memcpy (envblock + envblock_used, p, size);
 293         envblock_used += size;
 294         if (envblock[envblock_used - 1] != '\0')
 295           {
 296             /* Other threads did modifications.  Restart.  */
 297             free (envblock);
 298             goto retry;
 299           }
 300       }
 301     envblock[envblock_used] = '\0';
 302     return envblock;
 303   }
 304 }
 305
 306 int
 307 init_inheritable_handles (struct inheritable_handles *inh_handles,
 308                           bool duplicate)
 309 {
 310   /* Determine the minimal count of handles we need to care about.  */
 311   size_t handles_count;
 312   {
 313     /* _getmaxstdio
 314        <https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/getmaxstdio>
 315        Default value is 512.  */
 316     unsigned int fdmax = _getmaxstdio ();
 317     if (fdmax < 3)
 318       fdmax = 3;
 319     for (; fdmax > 3; fdmax--)
 320       {
 321         unsigned int fd = fdmax - 1;
 322         /* _get_osfhandle
 323            <https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/get-osfhandle>  */
 324         HANDLE handle = (HANDLE) _get_osfhandle (fd);
 325         if (handle != INVALID_HANDLE_VALUE)
 326           {
 327             DWORD hflags;
 328             /* GetHandleInformation
 329                <https://docs.microsoft.com/en-us/windows/win32/api/handleapi/nf-handleapi-gethandleinformation>  */
 330             if (GetHandleInformation (handle, &hflags))
 331               {
 332                 if ((hflags & HANDLE_FLAG_INHERIT) != 0)
 333                   /* fd denotes an inheritable descriptor.  */
 334                   break;
 335               }
 336           }
 337       }
 338     handles_count = fdmax;
 339   }
 340   /* Note: handles_count >= 3.  */
 341
 342   /* Allocate the arrays.  */
 343   size_t handles_allocated = handles_count;
 344   HANDLE *handles_array =
 345     (HANDLE *) malloc (handles_allocated * sizeof (HANDLE));
 346   if (handles_array == NULL)
 347     {
 348       errno = ENOMEM;
 349       return -1;
 350     }
 351   unsigned char *flags_array =
 352     (unsigned char *) malloc (handles_allocated * sizeof (unsigned char));
 353   if (flags_array == NULL)
 354     {
 355       free (handles_array);
 356       errno = ENOMEM;
 357       return -1;
 358     }
 359
 360   /* Fill in the two arrays.  */
 361   {
 362     HANDLE curr_process = (duplicate ? GetCurrentProcess () : INVALID_HANDLE_VALUE);
 363     unsigned int fd;
 364     for (fd = 0; fd < handles_count; fd++)
 365       {
 366         handles_array[fd] = INVALID_HANDLE_VALUE;
 367         /* _get_osfhandle
 368            <https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/get-osfhandle>  */
 369         HANDLE handle = (HANDLE) _get_osfhandle (fd);
 370         if (handle != INVALID_HANDLE_VALUE)
 371           {
 372             DWORD hflags;
 373             /* GetHandleInformation
 374                <https://docs.microsoft.com/en-us/windows/win32/api/handleapi/nf-handleapi-gethandleinformation>  */
 375             if (GetHandleInformation (handle, &hflags))
 376               {
 377                 if ((hflags & HANDLE_FLAG_INHERIT) != 0)
 378                   {
 379                     /* fd denotes an inheritable descriptor.  */
 380                     if (duplicate)
 381                       {
 382                         if (!DuplicateHandle (curr_process, handle,
 383                                               curr_process, &handles_array[fd],
 384                                               0, TRUE, DUPLICATE_SAME_ACCESS))
 385                           {
 386                             unsigned int i;
 387                             for (i = 0; i < fd; i++)
 388                               if (handles_array[i] != INVALID_HANDLE_VALUE)
 389                                 CloseHandle (handles_array[i]);
 390                             free (flags_array);
 391                             free (handles_array);
 392                             errno = EBADF; /* arbitrary */
 393                             return -1;
 394                           }
 395                       }
 396                     else
 397                       handles_array[fd] = handle;
 398
 399                     flags_array[fd] = 0;
 400                   }
 401               }
 402           }
 403       }
 404   }
 405
 406   /* Return the result.  */
 407   inh_handles->count = handles_count;
 408   inh_handles->allocated = handles_allocated;
 409   inh_handles->handles = handles_array;
 410   inh_handles->flags = flags_array;
 411   return 0;
 412 }
 413
 414 int
 415 compose_handles_block (const struct inheritable_handles *inh_handles,
 416                        STARTUPINFO *sinfo)
 417 {
 418   /* STARTUPINFO
 419      <https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/ns-processthreadsapi-startupinfoa>  */
 420   sinfo->dwFlags = STARTF_USESTDHANDLES;
 421   sinfo->hStdInput  = inh_handles->handles[0];
 422   sinfo->hStdOutput = inh_handles->handles[1];
 423   sinfo->hStdError  = inh_handles->handles[2];
 424
 425   /* On newer versions of Windows, more file descriptors / handles than the
 426      first three can be passed.
 427      The format is as follows: Let N be an exclusive upper bound for the file
 428      descriptors to be passed. Two arrays are constructed in memory:
 429        - flags[0..N-1], of element type 'unsigned char',
 430        - handles[0..N-1], of element type 'HANDLE' or 'intptr_t'.
 431      For used entries, handles[i] is the handle, and flags[i] is a set of flags,
 432      a combination of:
 433         1 for open file descriptors,
 434        64 for handles of type FILE_TYPE_CHAR,
 435         8 for handles of type FILE_TYPE_PIPE,
 436        32 for O_APPEND.
 437      For unused entries - this may include any of the first three, since they
 438      are already passed above -, handles[i] is INVALID_HANDLE_VALUE and flags[i]
 439      is zero.
 440      lpReserved2 now is a pointer to the concatenation (without padding) of:
 441        - an 'unsigned int' whose value is N,
 442        - the contents of the flags[0..N-1] array,
 443        - the contents of the handles[0..N-1] array.
 444      cbReserved2 is the size (in bytes) of the object at lpReserved2.  */
 445
 446   size_t handles_count = inh_handles->count;
 447
 448   sinfo->cbReserved2 =
 449     sizeof (unsigned int)
 450     + handles_count * sizeof (unsigned char)
 451     + handles_count * sizeof (HANDLE);
 452   /* Add some padding, so that we can work with a properly aligned HANDLE
 453      array.  */
 454   char *hblock = (char *) malloc (sinfo->cbReserved2 + (sizeof (HANDLE) - 1));
 455   if (hblock == NULL)
 456     {
 457       errno = ENOMEM;
 458       return -1;
 459     }
 460   unsigned char *flags = (unsigned char *) (hblock + sizeof (unsigned int));
 461   char *handles = (char *) (flags + handles_count);
 462   HANDLE *handles_aligned =
 463     (HANDLE *) (((uintptr_t) handles + (sizeof (HANDLE) - 1))
 464                 & - (uintptr_t) sizeof (HANDLE));
 465
 466   * (unsigned int *) hblock = handles_count;
 467   {
 468     unsigned int fd;
 469     for (fd = 0; fd < handles_count; fd++)
 470       {
 471         handles_aligned[fd] = INVALID_HANDLE_VALUE;
 472         flags[fd] = 0;
 473
 474         HANDLE handle = inh_handles->handles[fd];
 475         if (handle != INVALID_HANDLE_VALUE
 476             /* The first three are possibly already passed above.
 477                But they need to passed here as well, if they have some flags.  */
 478             && (fd >= 3 || inh_handles->flags[fd] != 0))
 479           {
 480             DWORD hflags;
 481             /* GetHandleInformation
 482                <https://docs.microsoft.com/en-us/windows/win32/api/handleapi/nf-handleapi-gethandleinformation>  */
 483             if (GetHandleInformation (handle, &hflags))
 484               {
 485                 if ((hflags & HANDLE_FLAG_INHERIT) != 0)
 486                   {
 487                     /* fd denotes an inheritable descriptor.  */
 488                     handles_aligned[fd] = handle;
 489                     /* On Microsoft Windows, it would be sufficient to set
 490                        flags[fd] = 1.  But on ReactOS or Wine, adding the bit
 491                        that indicates the handle type may be necessary.  So,
 492                        just do it everywhere.  */
 493                     flags[fd] = 1 | inh_handles->flags[fd];
 494                     switch (GetFileType (handle))
 495                       {
 496                       case FILE_TYPE_CHAR:
 497                         flags[fd] |= 64;
 498                         break;
 499                       case FILE_TYPE_PIPE:
 500                         flags[fd] |= 8;
 501                         break;
 502                       default:
 503                         break;
 504                       }
 505                   }
 506                 else
 507                   /* We shouldn't have any non-inheritable handles in
 508                      inh_handles->handles.  */
 509                   abort ();
 510               }
 511           }
 512       }
 513   }
 514   if (handles != (char *) handles_aligned)
 515     memmove (handles, (char *) handles_aligned, handles_count * sizeof (HANDLE));
 516
 517   sinfo->lpReserved2 = (BYTE *) hblock;
 518
 519   return 0;
 520 }
 521
 522 void
 523 free_inheritable_handles (struct inheritable_handles *inh_handles)
 524 {
 525   free (inh_handles->flags);
 526   free (inh_handles->handles);
 527 }
 528
 529 int
 530 convert_CreateProcess_error (DWORD error)
 531 {
 532   /* Some of these errors probably cannot happen.  But who knows...  */
 533   switch (error)
 534     {
 535     case ERROR_FILE_NOT_FOUND:
 536     case ERROR_PATH_NOT_FOUND:
 537     case ERROR_BAD_PATHNAME:
 538     case ERROR_BAD_NET_NAME:
 539     case ERROR_INVALID_NAME:
 540     case ERROR_DIRECTORY:
 541       return ENOENT;
 542       break;
 543
 544     case ERROR_ACCESS_DENIED:
 545     case ERROR_SHARING_VIOLATION:
 546       return EACCES;
 547       break;
 548
 549     case ERROR_OUTOFMEMORY:
 550       return ENOMEM;
 551       break;
 552
 553     case ERROR_BUFFER_OVERFLOW:
 554     case ERROR_FILENAME_EXCED_RANGE:
 555       return ENAMETOOLONG;
 556       break;
 557
 558     case ERROR_BAD_FORMAT:
 559     case ERROR_BAD_EXE_FORMAT:
 560       return ENOEXEC;
 561       break;
 562
 563     default:
 564       return EINVAL;
 565       break;
 566     }
 567 }
 568
 569 intptr_t
 570 spawnpvech (int mode,
 571             const char *progname, const char * const *argv,
 572             const char * const *envp,
 573             const char *currdir,
 574             HANDLE stdin_handle, HANDLE stdout_handle, HANDLE stderr_handle)
 575 {
 576   /* Validate the arguments.  */
 577   if (!(mode == P_WAIT
 578         || mode == P_NOWAIT
 579         || mode == P_DETACH
 580         || mode == P_OVERLAY)
 581       || progname == NULL || argv == NULL)
 582     {
 583       errno = EINVAL;
 584       return -1;
 585     }
 586
 587   /* Implement the 'p' letter: search for PROGNAME in getenv ("PATH").  */
 588   const char *resolved_progname =
 589     find_in_given_path (progname, getenv ("PATH"), NULL, false);
 590   if (resolved_progname == NULL)
 591     return -1;
 592
 593   /* Compose the command.  */
 594   char *command = compose_command (argv);
 595   if (command == NULL)
 596     goto out_of_memory_1;
 597
 598   /* Copy *ENVP into a contiguous block of memory.  */
 599   char *envblock;
 600   if (envp == NULL)
 601     envblock = NULL;
 602   else
 603     {
 604       envblock = compose_envblock (envp);
 605       if (envblock == NULL)
 606         goto out_of_memory_2;
 607     }
 608
 609   /* Collect the inheritable handles.  */
 610   struct inheritable_handles inh_handles;
 611   if (init_inheritable_handles (&inh_handles, false) < 0)
 612     {
 613       int saved_errno = errno;
 614       if (envblock != NULL)
 615         free (envblock);
 616       free (command);
 617       if (resolved_progname != progname)
 618         free ((char *) resolved_progname);
 619       errno = saved_errno;
 620       return -1;
 621     }
 622   inh_handles.handles[0] = stdin_handle;  inh_handles.flags[0] = 0;
 623   inh_handles.handles[1] = stdout_handle; inh_handles.flags[1] = 0;
 624   inh_handles.handles[2] = stderr_handle; inh_handles.flags[2] = 0;
 625
 626   /* CreateProcess
 627      <https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-createprocessa>  */
 628   /* <https://docs.microsoft.com/en-us/windows/win32/procthread/process-creation-flags>  */
 629   DWORD process_creation_flags = (mode == P_DETACH ? DETACHED_PROCESS : 0);
 630   /* STARTUPINFO
 631      <https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/ns-processthreadsapi-startupinfoa>  */
 632   STARTUPINFO sinfo;
 633   sinfo.cb = sizeof (STARTUPINFO);
 634   sinfo.lpReserved = NULL;
 635   sinfo.lpDesktop = NULL;
 636   sinfo.lpTitle = NULL;
 637   if (compose_handles_block (&inh_handles, &sinfo) < 0)
 638     {
 639       int saved_errno = errno;
 640       free_inheritable_handles (&inh_handles);
 641       if (envblock != NULL)
 642         free (envblock);
 643       free (command);
 644       if (resolved_progname != progname)
 645         free ((char *) resolved_progname);
 646       errno = saved_errno;
 647       return -1;
 648     }
 649
 650   PROCESS_INFORMATION pinfo;
 651   if (!CreateProcess (resolved_progname, command, NULL, NULL, TRUE,
 652                       process_creation_flags, envblock, currdir, &sinfo,
 653                       &pinfo))
 654     {
 655       DWORD error = GetLastError ();
 656
 657       free (sinfo.lpReserved2);
 658       free_inheritable_handles (&inh_handles);
 659       if (envblock != NULL)
 660         free (envblock);
 661       free (command);
 662       if (resolved_progname != progname)
 663         free ((char *) resolved_progname);
 664
 665       errno = convert_CreateProcess_error (error);
 666       return -1;
 667     }
 668
 669   if (pinfo.hThread)
 670     CloseHandle (pinfo.hThread);
 671   free (sinfo.lpReserved2);
 672   free_inheritable_handles (&inh_handles);
 673   if (envblock != NULL)
 674     free (envblock);
 675   free (command);
 676   if (resolved_progname != progname)
 677     free ((char *) resolved_progname);
 678
 679   switch (mode)
 680     {
 681     case P_WAIT:
 682       {
 683         /* Wait until it terminates.  Then get its exit status code.  */
 684         switch (WaitForSingleObject (pinfo.hProcess, INFINITE))
 685           {
 686           case WAIT_OBJECT_0:
 687             break;
 688           case WAIT_FAILED:
 689             errno = ECHILD;
 690             return -1;
 691           default:
 692             abort ();
 693           }
 694
 695         DWORD exit_code;
 696         if (!GetExitCodeProcess (pinfo.hProcess, &exit_code))
 697           {
 698             errno = ECHILD;
 699             return -1;
 700           }
 701         CloseHandle (pinfo.hProcess);
 702         return exit_code;
 703       }
 704
 705     case P_NOWAIT:
 706       /* Return pinfo.hProcess, not pinfo.dwProcessId.  */
 707       return (intptr_t) pinfo.hProcess;
 708
 709     case P_DETACH:
 710     case P_OVERLAY:
 711       CloseHandle (pinfo.hProcess);
 712       return 0;
 713
 714     default:
 715       /* Already checked above.  */
 716       abort ();
 717     }
 718
 719   /*NOTREACHED*/
 720  out_of_memory_2:
 721   free (command);
 722  out_of_memory_1:
 723   if (resolved_progname != progname)
 724     free ((char *) resolved_progname);
 725   errno = ENOMEM;
 726   return -1;
 727 }