Home | History | Annotate | Download | only in libiberty 
      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
    982