libiberty/pex-win32.c

   1 /* Utilities to execute a program in a subprocess (possibly linked by pipes
   2    with other subprocesses), and wait for it.  Generic Win32 specialization.
   3    Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006
   4    Free Software Foundation, Inc.
   5
   6 This file is part of the libiberty library.
   7 Libiberty is free software; you can redistribute it and/or
   8 modify it under the terms of the GNU Library General Public
   9 License as published by the Free Software Foundation; either
  10 version 2 of the License, or (at your option) any later version.
  11
  12 Libiberty is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 Library General Public License for more details.
  16
  17 You should have received a copy of the GNU Library General Public
  18 License along with libiberty; see the file COPYING.LIB.  If not,
  19 write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
  20 Boston, MA 02110-1301, USA.  */
  21
  22 #include "pex-common.h"
  23
  24 #include <windows.h>
  25
  26 #ifdef HAVE_STDLIB_H
  27 #include <stdlib.h>
  28 #endif
  29 #ifdef HAVE_STRING_H
  30 #include <string.h>
  31 #endif
  32 #ifdef HAVE_UNISTD_H
  33 #include <unistd.h>
  34 #endif
  35 #ifdef HAVE_SYS_WAIT_H
  36 #include <sys/wait.h>
  37 #endif
  38
  39 #include <assert.h>
  40 #include <process.h>
  41 #include <io.h>
  42 #include <fcntl.h>
  43 #include <signal.h>
  44 #include <sys/stat.h>
  45 #include <errno.h>
  46 #include <ctype.h>
  47
  48 /* mingw32 headers may not define the following.  */
  49
  50 #ifndef _P_WAIT
  51 #  define _P_WAIT       0
  52 #  define _P_NOWAIT     1
  53 #  define _P_OVERLAY    2
  54 #  define _P_NOWAITO    3
  55 #  define _P_DETACH     4
  56
  57 #  define WAIT_CHILD            0
  58 #  define WAIT_GRANDCHILD       1
  59 #endif
  60
  61 #define MINGW_NAME "Minimalist GNU for Windows"
  62 #define MINGW_NAME_LEN (sizeof(MINGW_NAME) - 1)
  63
  64 extern char *stpcpy (char *dst, const char *src);
  65
  66 /* Ensure that the executable pathname uses Win32 backslashes. This
  67    is not necessary on NT, but on W9x, forward slashes causes
  68    failure of spawn* and exec* functions (and probably any function
  69    that calls CreateProcess) *iff* the executable pathname (argv[0])
  70    is a quoted string.  And quoting is necessary in case a pathname
  71    contains embedded white space.  You can't win.  */
  72 static void
  73 backslashify (char *s)
  74 {
  75   while ((s = strchr (s, '/')) != NULL)
  76     *s = '\\';
  77   return;
  78 }
  79
  80 static int pex_win32_open_read (struct pex_obj *, const char *, int);
  81 static int pex_win32_open_write (struct pex_obj *, const char *, int, int);
  82 static pid_t pex_win32_exec_child (struct pex_obj *, int, const char *,
  83                                   char * const *, char * const *,
  84                                   int, int, int, int,
  85                                   const char **, int *);
  86 static int pex_win32_close (struct pex_obj *, int);
  87 static pid_t pex_win32_wait (struct pex_obj *, pid_t, int *,
  88                            struct pex_time *, int, const char **, int *);
  89 static int pex_win32_pipe (struct pex_obj *, int *, int);
  90 static FILE *pex_win32_fdopenr (struct pex_obj *, int, int);
  91 static FILE *pex_win32_fdopenw (struct pex_obj *, int, int);
  92
  93 /* The list of functions we pass to the common routines.  */
  94
  95 const struct pex_funcs funcs =
  96 {
  97   pex_win32_open_read,
  98   pex_win32_open_write,
  99   pex_win32_exec_child,
 100   pex_win32_close,
 101   pex_win32_wait,
 102   pex_win32_pipe,
 103   pex_win32_fdopenr,
 104   pex_win32_fdopenw,
 105   NULL /* cleanup */
 106 };
 107
 108 /* Return a newly initialized pex_obj structure.  */
 109
 110 struct pex_obj *
 111 pex_init (int flags, const char *pname, const char *tempbase)
 112 {
 113   return pex_init_common (flags, pname, tempbase, &funcs);
 114 }
 115
 116 /* Open a file for reading.  */
 117
 118 static int
 119 pex_win32_open_read (struct pex_obj *obj ATTRIBUTE_UNUSED, const char *name,
 120                      int binary)
 121 {
 122   return _open (name, _O_RDONLY | (binary ? _O_BINARY : _O_TEXT));
 123 }
 124
 125 /* Open a file for writing.  */
 126
 127 static int
 128 pex_win32_open_write (struct pex_obj *obj ATTRIBUTE_UNUSED, const char *name,
 129                       int binary, int append)
 130 {
 131   /* Note that we can't use O_EXCL here because gcc may have already
 132      created the temporary file via make_temp_file.  */
 133   if (append)
 134     return -1;
 135   return _open (name,
 136                 (_O_WRONLY | _O_CREAT | _O_TRUNC
 137                  | (binary ? _O_BINARY : _O_TEXT)),
 138                 _S_IREAD | _S_IWRITE);
 139 }
 140
 141 /* Close a file.  */
 142
 143 static int
 144 pex_win32_close (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd)
 145 {
 146   return _close (fd);
 147 }
 148
 149 #ifdef USE_MINGW_MSYS
 150 static const char *mingw_keys[] = {"SOFTWARE", "Microsoft", "Windows", "CurrentVersion", "Uninstall", NULL};
 151
 152 /* Tack the executable on the end of a (possibly slash terminated) buffer
 153    and convert everything to \. */
 154 static const char *
 155 tack_on_executable (char *buf, const char *executable)
 156 {
 157   char *p = strchr (buf, '\0');
 158   if (p > buf && (p[-1] == '\\' || p[-1] == '/'))
 159     p[-1] = '\0';
 160   backslashify (strcat (buf, executable));
 161   return buf;
 162 }
 163
 164 /* Walk down a registry hierarchy until the end.  Return the key. */
 165 static HKEY
 166 openkey (HKEY hStart, const char *keys[])
 167 {
 168   HKEY hKey, hTmp;
 169   for (hKey = hStart; *keys; keys++)
 170     {
 171       LONG res;
 172       hTmp = hKey;
 173       res = RegOpenKey (hTmp, *keys, &hKey);
 174
 175       if (hTmp != HKEY_LOCAL_MACHINE)
 176         RegCloseKey (hTmp);
 177
 178       if (res != ERROR_SUCCESS)
 179         return NULL;
 180     }
 181   return hKey;
 182 }
 183
 184 /* Return the "mingw root" as derived from the mingw uninstall information. */
 185 static const char *
 186 mingw_rootify (const char *executable)
 187 {
 188   HKEY hKey, hTmp;
 189   DWORD maxlen;
 190   char *namebuf, *foundbuf;
 191   DWORD i;
 192   LONG res;
 193
 194   /* Open the uninstall "directory". */
 195   hKey = openkey (HKEY_LOCAL_MACHINE, mingw_keys);
 196
 197   /* Not found. */
 198   if (!hKey)
 199     return executable;
 200
 201   /* Need to enumerate all of the keys here looking for one the most recent
 202      one for MinGW. */
 203   if (RegQueryInfoKey (hKey, NULL, NULL, NULL, NULL, &maxlen, NULL, NULL,
 204                        NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
 205     {
 206       RegCloseKey (hKey);
 207       return executable;
 208     }
 209   namebuf = XNEWVEC (char, ++maxlen);
 210   foundbuf = XNEWVEC (char, maxlen);
 211   foundbuf[0] = '\0';
 212   if (!namebuf || !foundbuf)
 213     {
 214       RegCloseKey (hKey);
 215       free (namebuf);
 216       free (foundbuf);
 217       return executable;
 218     }
 219
 220   /* Look through all of the keys for one that begins with Minimal GNU...
 221      Try to get the latest version by doing a string compare although that
 222      string never really works with version number sorting. */
 223   for (i = 0; RegEnumKey (hKey, i, namebuf, maxlen) == ERROR_SUCCESS; i++)
 224     {
 225       int match = strcasecmp (namebuf, MINGW_NAME);
 226       if (match < 0)
 227         continue;
 228       if (match > 0 && strncasecmp (namebuf, MINGW_NAME, MINGW_NAME_LEN) > 0)
 229         continue;
 230       if (strcasecmp (namebuf, foundbuf) > 0)
 231         strcpy (foundbuf, namebuf);
 232     }
 233   free (namebuf);
 234
 235   /* If foundbuf is empty, we didn't find anything.  Punt. */
 236   if (!foundbuf[0])
 237     {
 238       free (foundbuf);
 239       RegCloseKey (hKey);
 240       return executable;
 241     }
 242
 243   /* Open the key that we wanted */
 244   res = RegOpenKey (hKey, foundbuf, &hTmp);
 245   RegCloseKey (hKey);
 246   free (foundbuf);
 247
 248   /* Don't know why this would fail, but you gotta check */
 249   if (res != ERROR_SUCCESS)
 250     return executable;
 251
 252   maxlen = 0;
 253   /* Get the length of the value pointed to by InstallLocation */
 254   if (RegQueryValueEx (hTmp, "InstallLocation", 0, NULL, NULL,
 255                        &maxlen) != ERROR_SUCCESS || maxlen == 0)
 256     {
 257       RegCloseKey (hTmp);
 258       return executable;
 259     }
 260
 261   /* Allocate space for the install location */
 262   foundbuf = XNEWVEC (char, maxlen + strlen (executable));
 263   if (!foundbuf)
 264     {
 265       free (foundbuf);
 266       RegCloseKey (hTmp);
 267     }
 268
 269   /* Read the install location into the buffer */
 270   res = RegQueryValueEx (hTmp, "InstallLocation", 0, NULL, (LPBYTE) foundbuf,
 271                          &maxlen);
 272   RegCloseKey (hTmp);
 273   if (res != ERROR_SUCCESS)
 274     {
 275       free (foundbuf);
 276       return executable;
 277     }
 278
 279   /* Concatenate the install location and the executable, turn all slashes
 280      to backslashes, and return that. */
 281   return tack_on_executable (foundbuf, executable);
 282 }
 283
 284 /* Read the install location of msys from it's installation file and
 285    rootify the executable based on that. */
 286 static const char *
 287 msys_rootify (const char *executable)
 288 {
 289   size_t bufsize = 64;
 290   size_t execlen = strlen (executable) + 1;
 291   char *buf;
 292   DWORD res = 0;
 293   for (;;)
 294     {
 295       buf = XNEWVEC (char, bufsize + execlen);
 296       if (!buf)
 297         break;
 298       res = GetPrivateProfileString ("InstallSettings", "InstallPath", NULL,
 299                                      buf, bufsize, "msys.ini");
 300       if (!res)
 301         break;
 302       if (strlen (buf) < bufsize)
 303         break;
 304       res = 0;
 305       free (buf);
 306       bufsize *= 2;
 307       if (bufsize > 65536)
 308         {
 309           buf = NULL;
 310           break;
 311         }
 312     }
 313
 314   if (res)
 315     return tack_on_executable (buf, executable);
 316
 317   /* failed */
 318   free (buf);
 319   return executable;
 320 }
 321 #endif
 322
 323 /* Return the number of arguments in an argv array, not including the null
 324    terminating argument. */
 325
 326 static int
 327 argv_to_argc (char *const *argv)
 328 {
 329   char *const *i = argv;
 330   while (*i)
 331     i++;
 332   return i - argv;
 333 }
 334
 335 /* Return a Windows command-line from ARGV.  It is the caller's
 336    responsibility to free the string returned.  */
 337
 338 static char *
 339 argv_to_cmdline (char *const *argv)
 340 {
 341   char *cmdline;
 342   char *p;
 343   size_t cmdline_len;
 344   int i, j, k;
 345   int needs_quotes;
 346
 347   cmdline_len = 0;
 348   for (i = 0; argv[i]; i++)
 349     {
 350       /* We only quote arguments that contain spaces, \t or " characters to
 351          prevent wasting 2 chars per argument of the CreateProcess 32k char
 352          limit.  We need only escape embedded double-quotes and immediately
 353          preceeding backslash characters.  A sequence of backslach characters
 354          that is not follwed by a double quote character will not be
 355          escaped.  */
 356       needs_quotes = 0;
 357       for (j = 0; argv[i][j]; j++)
 358         {
 359           if (argv[i][j] == ' ' || argv[i][j] == '\t' || argv[i][j] == '"')
 360             {
 361               needs_quotes = 1;
 362             }
 363
 364           if (argv[i][j] == '"')
 365             {
 366               /* Escape preceeding backslashes.  */
 367               for (k = j - 1; k >= 0 && argv[i][k] == '\\'; k--)
 368                 cmdline_len++;
 369               /* Escape the qote character.  */
 370               cmdline_len++;
 371             }
 372         }
 373       /* Trailing backslashes also need to be escaped because they will be
 374          followed by the terminating quote.  */
 375       if (needs_quotes)
 376         {
 377           for (k = j - 1; k >= 0 && argv[i][k] == '\\'; k--)
 378             cmdline_len++;
 379         }
 380       cmdline_len += j;
 381       /* for leading and trailing quotes and space */
 382       cmdline_len += needs_quotes * 2 + 1;
 383     }
 384   cmdline = XNEWVEC (char, cmdline_len);
 385   p = cmdline;
 386   for (i = 0; argv[i]; i++)
 387     {
 388       needs_quotes = 0;
 389       for (j = 0; argv[i][j]; j++)
 390         {
 391           if (argv[i][j] == ' ' || argv[i][j] == '\t' || argv[i][j] == '"')
 392             {
 393               needs_quotes = 1;
 394               break;
 395             }
 396         }
 397
 398       if (needs_quotes)
 399         {
 400           *p++ = '"';
 401         }
 402       for (j = 0; argv[i][j]; j++)
 403         {
 404           if (argv[i][j] == '"')
 405             {
 406               for (k = j - 1; k >= 0 && argv[i][k] == '\\'; k--)
 407                 *p++ = '\\';
 408               *p++ = '\\';
 409             }
 410           *p++ = argv[i][j];
 411         }
 412       if (needs_quotes)
 413         {
 414           for (k = j - 1; k >= 0 && argv[i][k] == '\\'; k--)
 415             *p++ = '\\';
 416           *p++ = '"';
 417         }
 418       *p++ = ' ';
 419     }
 420   p[-1] = '\0';
 421   return cmdline;
 422 }
 423
 424 /* We'll try the passed filename with all the known standard
 425    extensions, and then without extension.  We try no extension
 426    last so that we don't try to run some random extension-less
 427    file that might be hanging around.  We try both extension
 428    and no extension so that we don't need any fancy logic
 429    to determine if a file has extension.  */
 430 static const char *const
 431 std_suffixes[] = {
 432   ".com",
 433   ".exe",
 434   ".bat",
 435   ".cmd",
 436   "",
 437   0
 438 };
 439
 440 /* Returns the full path to PROGRAM.  If SEARCH is true, look for
 441    PROGRAM in each directory in PATH.  */
 442
 443 static char *
 444 find_executable (const char *program, BOOL search)
 445 {
 446   char *full_executable;
 447   char *e;
 448   size_t fe_len;
 449   const char *path = 0;
 450   const char *const *ext;
 451   const char *p, *q;
 452   size_t proglen = strlen (program);
 453   int has_slash = (strchr (program, '/') || strchr (program, '\\'));
 454   HANDLE h;
 455
 456   if (has_slash)
 457     search = FALSE;
 458
 459   if (search)
 460     path = getenv ("PATH");
 461   if (!path)
 462     path = "";
 463
 464   fe_len = 0;
 465   for (p = path; *p; p = q)
 466     {
 467       q = p;
 468       while (*q != ';' && *q != '\0')
 469         q++;
 470       if ((size_t)(q - p) > fe_len)
 471         fe_len = q - p;
 472       if (*q == ';')
 473         q++;
 474     }
 475   fe_len = fe_len + 1 + proglen + 5 /* space for extension */;
 476   full_executable = XNEWVEC (char, fe_len);
 477
 478   p = path;
 479   do
 480     {
 481       q = p;
 482       while (*q != ';' && *q != '\0')
 483         q++;
 484
 485       e = full_executable;
 486       memcpy (e, p, q - p);
 487       e += (q - p);
 488       if (q - p)
 489         *e++ = '\\';
 490       strcpy (e, program);
 491
 492       if (*q == ';')
 493         q++;
 494
 495       for (e = full_executable; *e; e++)
 496         if (*e == '/')
 497           *e = '\\';
 498
 499       /* At this point, e points to the terminating NUL character for
 500          full_executable.  */
 501       for (ext = std_suffixes; *ext; ext++)
 502         {
 503           /* Remove any current extension.  */
 504           *e = '\0';
 505           /* Add the new one.  */
 506           strcat (full_executable, *ext);
 507
 508           /* Attempt to open this file.  */
 509           h = CreateFile (full_executable, GENERIC_READ,
 510                           FILE_SHARE_READ | FILE_SHARE_WRITE,
 511                           0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
 512           if (h != INVALID_HANDLE_VALUE)
 513             goto found;
 514         }
 515       p = q;
 516     }
 517   while (*p);
 518   free (full_executable);
 519   return 0;
 520
 521  found:
 522   CloseHandle (h);
 523   return full_executable;
 524 }
 525
 526 /* Low-level process creation function and helper.  */
 527
 528 static int
 529 env_compare (const void *a_ptr, const void *b_ptr)
 530 {
 531   const char *a;
 532   const char *b;
 533   unsigned char c1;
 534   unsigned char c2;
 535
 536   a = *(const char **) a_ptr;
 537   b = *(const char **) b_ptr;
 538
 539   /* a and b will be of the form: VAR=VALUE
 540      We compare only the variable name part here using a case-insensitive
 541      comparison algorithm.  It might appear that in fact strcasecmp () can
 542      take the place of this whole function, and indeed it could, save for
 543      the fact that it would fail in cases such as comparing A1=foo and
 544      A=bar (because 1 is less than = in the ASCII character set).
 545      (Environment variables containing no numbers would work in such a
 546      scenario.)  */
 547
 548   do
 549     {
 550       c1 = (unsigned char) tolower (*a++);
 551       c2 = (unsigned char) tolower (*b++);
 552
 553       if (c1 == '=')
 554         c1 = '\0';
 555
 556       if (c2 == '=')
 557         c2 = '\0';
 558     }
 559   while (c1 == c2 && c1 != '\0');
 560
 561   return c1 - c2;
 562 }
 563
 564 /* Execute a Windows executable as a child process.  This will fail if the
 565  * target is not actually an executable, such as if it is a shell script. */
 566
 567 static pid_t
 568 win32_spawn (const char *executable,
 569              BOOL search,
 570              char *const *argv,
 571              char *const *env, /* array of strings of the form: VAR=VALUE */
 572              DWORD dwCreationFlags,
 573              LPSTARTUPINFO si,
 574              LPPROCESS_INFORMATION pi)
 575 {
 576   char *full_executable;
 577   char *cmdline;
 578   char **env_copy;
 579   char *env_block = NULL;
 580
 581   full_executable = NULL;
 582   cmdline = NULL;
 583
 584   if (env)
 585     {
 586       int env_size;
 587
 588       /* Count the number of environment bindings supplied.  */
 589       for (env_size = 0; env[env_size]; env_size++)
 590         continue;
 591
 592       /* Assemble an environment block, if required.  This consists of
 593          VAR=VALUE strings juxtaposed (with one null character between each
 594          pair) and an additional null at the end.  */
 595       if (env_size > 0)
 596         {
 597           int var;
 598           int total_size = 1; /* 1 is for the final null.  */
 599           char *bufptr;
 600
 601           /* Windows needs the members of the block to be sorted by variable
 602              name.  */
 603           env_copy = (char **) alloca (sizeof (char *) * env_size);
 604           memcpy (env_copy, env, sizeof (char *) * env_size);
 605           qsort (env_copy, env_size, sizeof (char *), env_compare);
 606
 607           for (var = 0; var < env_size; var++)
 608             total_size += strlen (env[var]) + 1;
 609
 610           env_block = XNEWVEC (char, total_size);
 611           bufptr = env_block;
 612           for (var = 0; var < env_size; var++)
 613             bufptr = stpcpy (bufptr, env_copy[var]) + 1;
 614
 615           *bufptr = '\0';
 616         }
 617     }
 618
 619   full_executable = find_executable (executable, search);
 620   if (!full_executable)
 621     goto error;
 622   cmdline = argv_to_cmdline (argv);
 623   if (!cmdline)
 624     goto error;
 625
 626   /* Create the child process.  */
 627   if (!CreateProcess (full_executable, cmdline,
 628                       /*lpProcessAttributes=*/NULL,
 629                       /*lpThreadAttributes=*/NULL,
 630                       /*bInheritHandles=*/TRUE,
 631                       dwCreationFlags,
 632                       (LPVOID) env_block,
 633                       /*lpCurrentDirectory=*/NULL,
 634                       si,
 635                       pi))
 636     {
 637       free (env_block);
 638
 639       free (full_executable);
 640
 641       return (pid_t) -1;
 642     }
 643
 644   /* Clean up.  */
 645   CloseHandle (pi->hThread);
 646   free (full_executable);
 647   free (env_block);
 648
 649   return (pid_t) pi->hProcess;
 650
 651  error:
 652   free (env_block);
 653   free (cmdline);
 654   free (full_executable);
 655
 656   return (pid_t) -1;
 657 }
 658
 659 /* Spawn a script.  This simulates the Unix script execution mechanism.
 660    This function is called as a fallback if win32_spawn fails. */
 661
 662 static pid_t
 663 spawn_script (const char *executable, char *const *argv,
 664               char* const *env,
 665               DWORD dwCreationFlags,
 666               LPSTARTUPINFO si,
 667               LPPROCESS_INFORMATION pi)
 668 {
 669   pid_t pid = (pid_t) -1;
 670   int save_errno = errno;
 671   int fd = _open (executable, _O_RDONLY);
 672
 673   /* Try to open script, check header format, extract interpreter path,
 674      and spawn script using that interpretter. */
 675   if (fd >= 0)
 676     {
 677       char buf[MAX_PATH + 5];
 678       int len = _read (fd, buf, sizeof (buf) - 1);
 679       _close (fd);
 680       if (len > 3)
 681         {
 682           char *eol;
 683           buf[len] = '\0';
 684           eol = strchr (buf, '\n');
 685           if (eol && strncmp (buf, "#!", 2) == 0)
 686             {
 687
 688               /* Header format is OK. */
 689               char *executable1;
 690               int new_argc;
 691               const char **avhere;
 692
 693               /* Extract interpreter path. */
 694               do
 695                 *eol = '\0';
 696               while (*--eol == '\r' || *eol == ' ' || *eol == '\t');
 697               for (executable1 = buf + 2; *executable1 == ' ' || *executable1 == '\t'; executable1++)
 698                 continue;
 699               backslashify (executable1);
 700
 701               /* Duplicate argv, prepending the interpreter path. */
 702               new_argc = argv_to_argc (argv) + 1;
 703               avhere = XNEWVEC (const char *, new_argc + 1);
 704               *avhere = executable1;
 705               memcpy (avhere + 1, argv, new_argc * sizeof(*argv));
 706               argv = (char *const *)avhere;
 707
 708               /* Spawn the child. */
 709 #ifndef USE_MINGW_MSYS
 710               executable = strrchr (executable1, '\\') + 1;
 711               if (!executable)
 712                 executable = executable1;
 713               pid = win32_spawn (executable, TRUE, argv, env,
 714                                  dwCreationFlags, si, pi);
 715 #else
 716               if (strchr (executable1, '\\') == NULL)
 717                 pid = win32_spawn (executable1, TRUE, argv, env,
 718                                    dwCreationFlags, si, pi);
 719               else if (executable1[0] != '\\')
 720                 pid = win32_spawn (executable1, FALSE, argv, env,
 721                                    dwCreationFlags, si, pi);
 722               else
 723                 {
 724                   const char *newex = mingw_rootify (executable1);
 725                   *avhere = newex;
 726                   pid = win32_spawn (newex, FALSE, argv, env,
 727                                      dwCreationFlags, si, pi);
 728                   if (executable1 != newex)
 729                     free ((char *) newex);
 730                   if (pid == (pid_t) -1)
 731                     {
 732                       newex = msys_rootify (executable1);
 733                       if (newex != executable1)
 734                         {
 735                           *avhere = newex;
 736                           pid = win32_spawn (newex, FALSE, argv, env,
 737                                              dwCreationFlags, si, pi);
 738                           free ((char *) newex);
 739                         }
 740                     }
 741                 }
 742 #endif
 743               free (avhere);
 744             }
 745         }
 746     }
 747   if (pid == (pid_t) -1)
 748     errno = save_errno;
 749   return pid;
 750 }
 751
 752 /* Execute a child.  */
 753
 754 static pid_t
 755 pex_win32_exec_child (struct pex_obj *obj ATTRIBUTE_UNUSED, int flags,
 756                       const char *executable, char * const * argv,
 757                       char* const* env,
 758                       int in, int out, int errdes,
 759                       int toclose ATTRIBUTE_UNUSED,
 760                       const char **errmsg,
 761                       int *err)
 762 {
 763   pid_t pid;
 764   HANDLE stdin_handle;
 765   HANDLE stdout_handle;
 766   HANDLE stderr_handle;
 767   DWORD dwCreationFlags;
 768   OSVERSIONINFO version_info;
 769   STARTUPINFO si;
 770   PROCESS_INFORMATION pi;
 771   int orig_out, orig_in, orig_err;
 772   BOOL separate_stderr = !(flags & PEX_STDERR_TO_STDOUT);
 773
 774   /* Ensure we have inheritable descriptors to pass to the child.  */
 775   orig_in = in;
 776   in = _dup (orig_in);
 777
 778   orig_out = out;
 779   out = _dup (orig_out);
 780
 781   if (separate_stderr)
 782     {
 783       orig_err = errdes;
 784       errdes = _dup (orig_err);
 785     }
 786
 787   stdin_handle = INVALID_HANDLE_VALUE;
 788   stdout_handle = INVALID_HANDLE_VALUE;
 789   stderr_handle = INVALID_HANDLE_VALUE;
 790
 791   stdin_handle = (HANDLE) _get_osfhandle (in);
 792   stdout_handle = (HANDLE) _get_osfhandle (out);
 793   if (separate_stderr)
 794     stderr_handle = (HANDLE) _get_osfhandle (errdes);
 795   else
 796     stderr_handle = stdout_handle;
 797
 798   /* Determine the version of Windows we are running on.  */
 799   version_info.dwOSVersionInfoSize = sizeof (version_info);
 800   GetVersionEx (&version_info);
 801   if (version_info.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS)
 802     /* On Windows 95/98/ME the CREATE_NO_WINDOW flag is not
 803        supported, so we cannot avoid creating a console window.  */
 804     dwCreationFlags = 0;
 805   else
 806     {
 807       HANDLE conout_handle;
 808
 809       /* Determine whether or not we have an associated console.  */
 810       conout_handle = CreateFile("CONOUT$",
 811                                  GENERIC_WRITE,
 812                                  FILE_SHARE_WRITE,
 813                                  /*lpSecurityAttributes=*/NULL,
 814                                  OPEN_EXISTING,
 815                                  FILE_ATTRIBUTE_NORMAL,
 816                                  /*hTemplateFile=*/NULL);
 817       if (conout_handle == INVALID_HANDLE_VALUE)
 818         /* There is no console associated with this process.  Since
 819            the child is a console process, the OS would normally
 820            create a new console Window for the child.  Since we'll be
 821            redirecting the child's standard streams, we do not need
 822            the console window.  */
 823         dwCreationFlags = CREATE_NO_WINDOW;
 824       else
 825         {
 826           /* There is a console associated with the process, so the OS
 827              will not create a new console.  And, if we use
 828              CREATE_NO_WINDOW in this situation, the child will have
 829              no associated console.  Therefore, if the child's
 830              standard streams are connected to the console, the output
 831              will be discarded.  */
 832           CloseHandle(conout_handle);
 833           dwCreationFlags = 0;
 834         }
 835     }
 836
 837   /* Since the child will be a console process, it will, by default,
 838      connect standard input/output to its console.  However, we want
 839      the child to use the handles specifically designated above.  In
 840      addition, if there is no console (such as when we are running in
 841      a Cygwin X window), then we must redirect the child's
 842      input/output, as there is no console for the child to use.  */
 843   memset (&si, 0, sizeof (si));
 844   si.cb = sizeof (si);
 845   si.dwFlags = STARTF_USESTDHANDLES;
 846   si.hStdInput = stdin_handle;
 847   si.hStdOutput = stdout_handle;
 848   si.hStdError = stderr_handle;
 849
 850   /* Create the child process.  */
 851   pid = win32_spawn (executable, (flags & PEX_SEARCH) != 0,
 852                      argv, env, dwCreationFlags, &si, &pi);
 853   if (pid == (pid_t) -1)
 854     pid = spawn_script (executable, argv, env, dwCreationFlags,
 855                         &si, &pi);
 856   if (pid == (pid_t) -1)
 857     {
 858       *err = ENOENT;
 859       *errmsg = "CreateProcess";
 860     }
 861
 862   /* If the child was created successfully, close the original file
 863      descriptors.  If the process creation fails, these are closed by
 864      pex_run_in_environment instead.  We must not close them twice as
 865      that seems to cause a Windows exception.  */
 866
 867   if (pid != (pid_t) -1)
 868     {
 869       if (orig_in != STDIN_FILENO)
 870         _close (orig_in);
 871       if (orig_out != STDOUT_FILENO)
 872         _close (orig_out);
 873       if (separate_stderr
 874           && orig_err != STDERR_FILENO)
 875         _close (orig_err);
 876     }
 877
 878   /* Close the standard input, standard output and standard error handles
 879      in the parent.  */
 880
 881   _close (in);
 882   _close (out);
 883   if (separate_stderr)
 884     _close (errdes);
 885
 886   return pid;
 887 }
 888
 889 /* Wait for a child process to complete.  MS CRTDLL doesn't return
 890    enough information in status to decide if the child exited due to a
 891    signal or not, rather it simply returns an integer with the exit
 892    code of the child; eg., if the child exited with an abort() call
 893    and didn't have a handler for SIGABRT, it simply returns with
 894    status == 3.  We fix the status code to conform to the usual WIF*
 895    macros.  Note that WIFSIGNALED will never be true under CRTDLL. */
 896
 897 static pid_t
 898 pex_win32_wait (struct pex_obj *obj ATTRIBUTE_UNUSED, pid_t pid,
 899                 int *status, struct pex_time *time, int done ATTRIBUTE_UNUSED,
 900                 const char **errmsg, int *err)
 901 {
 902   DWORD termstat;
 903   HANDLE h;
 904
 905   if (time != NULL)
 906     memset (time, 0, sizeof *time);
 907
 908   h = (HANDLE) pid;
 909
 910   /* FIXME: If done is non-zero, we should probably try to kill the
 911      process.  */
 912   if (WaitForSingleObject (h, INFINITE) != WAIT_OBJECT_0)
 913     {
 914       CloseHandle (h);
 915       *err = ECHILD;
 916       *errmsg = "WaitForSingleObject";
 917       return -1;
 918     }
 919
 920   GetExitCodeProcess (h, &termstat);
 921   CloseHandle (h);
 922
 923   /* A value of 3 indicates that the child caught a signal, but not
 924      which one.  Since only SIGABRT, SIGFPE and SIGINT do anything, we
 925      report SIGABRT.  */
 926   if (termstat == 3)
 927     *status = SIGABRT;
 928   else
 929     *status = (termstat & 0xff) << 8;
 930
 931   return 0;
 932 }
 933
 934 /* Create a pipe.  */
 935
 936 static int
 937 pex_win32_pipe (struct pex_obj *obj ATTRIBUTE_UNUSED, int *p,
 938                 int binary)
 939 {
 940   return _pipe (p, 256, (binary ? _O_BINARY : _O_TEXT) | _O_NOINHERIT);
 941 }
 942
 943 /* Get a FILE pointer to read from a file descriptor.  */
 944
 945 static FILE *
 946 pex_win32_fdopenr (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd,
 947                    int binary)
 948 {
 949   HANDLE h = (HANDLE) _get_osfhandle (fd);
 950   if (h == INVALID_HANDLE_VALUE)
 951     return NULL;
 952   if (! SetHandleInformation (h, HANDLE_FLAG_INHERIT, 0))
 953     return NULL;
 954   return fdopen (fd, binary ? "rb" : "r");
 955 }
 956
 957 static FILE *
 958 pex_win32_fdopenw (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd,
 959                    int binary)
 960 {
 961   HANDLE h = (HANDLE) _get_osfhandle (fd);
 962   if (h == INVALID_HANDLE_VALUE)
 963     return NULL;
 964   if (! SetHandleInformation (h, HANDLE_FLAG_INHERIT, 0))
 965     return NULL;
 966   return fdopen (fd, binary ? "wb" : "w");
 967 }
 968
 969 #ifdef MAIN
 970 #include <stdio.h>
 971
 972 int
 973 main (int argc ATTRIBUTE_UNUSED, char **argv)
 974 {
 975   char const *errmsg;
 976   int err;
 977   argv++;
 978   printf ("%ld\n", (long) pex_win32_exec_child (NULL, PEX_SEARCH, argv[0], argv, NULL, 0, 0, 1, 2, &errmsg, &err));
 979   exit (0);
 980 }
 981 #endif