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-2023 Free Software Foundation, Inc.
   4
   5 This file is part of the libiberty library.
   6 Libiberty is free software; you can redistribute it and/or
   7 modify it under the terms of the GNU Library General Public
   8 License as published by the Free Software Foundation; either
   9 version 2 of the License, or (at your option) any later version.
  10
  11 Libiberty is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 Library General Public License for more details.
  15
  16 You should have received a copy of the GNU Library General Public
  17 License along with libiberty; see the file COPYING.LIB.  If not,
  18 write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
  19 Boston, MA 02110-1301, USA.  */
  20
  21 #include "pex-common.h"
  22
  23 #define WIN32_LEAN_AND_MEAN
  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       if (j == 0)
 374         needs_quotes = 1;
 375       /* Trailing backslashes also need to be escaped because they will be
 376          followed by the terminating quote.  */
 377       if (needs_quotes)
 378         {
 379           for (k = j - 1; k >= 0 && argv[i][k] == '\\'; k--)
 380             cmdline_len++;
 381         }
 382       cmdline_len += j;
 383       /* for leading and trailing quotes and space */
 384       cmdline_len += needs_quotes * 2 + 1;
 385     }
 386   cmdline = XNEWVEC (char, cmdline_len);
 387   p = cmdline;
 388   for (i = 0; argv[i]; i++)
 389     {
 390       needs_quotes = 0;
 391       for (j = 0; argv[i][j]; j++)
 392         {
 393           if (argv[i][j] == ' ' || argv[i][j] == '\t' || argv[i][j] == '"')
 394             {
 395               needs_quotes = 1;
 396               break;
 397             }
 398         }
 399       if (j == 0)
 400         needs_quotes = 1;
 401
 402       if (needs_quotes)
 403         {
 404           *p++ = '"';
 405         }
 406       for (j = 0; argv[i][j]; j++)
 407         {
 408           if (argv[i][j] == '"')
 409             {
 410               for (k = j - 1; k >= 0 && argv[i][k] == '\\'; k--)
 411                 *p++ = '\\';
 412               *p++ = '\\';
 413             }
 414           *p++ = argv[i][j];
 415         }
 416       if (needs_quotes)
 417         {
 418           for (k = j - 1; k >= 0 && argv[i][k] == '\\'; k--)
 419             *p++ = '\\';
 420           *p++ = '"';
 421         }
 422       *p++ = ' ';
 423     }
 424   p[-1] = '\0';
 425   return cmdline;
 426 }
 427
 428 /* We'll try the passed filename with all the known standard
 429    extensions, and then without extension.  We try no extension
 430    last so that we don't try to run some random extension-less
 431    file that might be hanging around.  We try both extension
 432    and no extension so that we don't need any fancy logic
 433    to determine if a file has extension.  */
 434 static const char *const
 435 std_suffixes[] = {
 436   ".com",
 437   ".exe",
 438   ".bat",
 439   ".cmd",
 440   "",
 441   0
 442 };
 443
 444 /* Returns the full path to PROGRAM.  If SEARCH is true, look for
 445    PROGRAM in each directory in PATH.  */
 446
 447 static char *
 448 find_executable (const char *program, BOOL search)
 449 {
 450   char *full_executable;
 451   char *e;
 452   size_t fe_len;
 453   const char *path = 0;
 454   const char *const *ext;
 455   const char *p, *q;
 456   size_t proglen = strlen (program);
 457   int has_slash = (strchr (program, '/') || strchr (program, '\\'));
 458   HANDLE h;
 459
 460   if (has_slash)
 461     search = FALSE;
 462
 463   if (search)
 464     path = getenv ("PATH");
 465   if (!path)
 466     path = "";
 467
 468   fe_len = 0;
 469   for (p = path; *p; p = q)
 470     {
 471       q = p;
 472       while (*q != ';' && *q != '\0')
 473         q++;
 474       if ((size_t)(q - p) > fe_len)
 475         fe_len = q - p;
 476       if (*q == ';')
 477         q++;
 478     }
 479   fe_len = fe_len + 1 + proglen + 5 /* space for extension */;
 480   full_executable = XNEWVEC (char, fe_len);
 481
 482   p = path;
 483   do
 484     {
 485       q = p;
 486       while (*q != ';' && *q != '\0')
 487         q++;
 488
 489       e = full_executable;
 490       memcpy (e, p, q - p);
 491       e += (q - p);
 492       if (q - p)
 493         *e++ = '\\';
 494       strcpy (e, program);
 495
 496       if (*q == ';')
 497         q++;
 498
 499       for (e = full_executable; *e; e++)
 500         if (*e == '/')
 501           *e = '\\';
 502
 503       /* At this point, e points to the terminating NUL character for
 504          full_executable.  */
 505       for (ext = std_suffixes; *ext; ext++)
 506         {
 507           /* Remove any current extension.  */
 508           *e = '\0';
 509           /* Add the new one.  */
 510           strcat (full_executable, *ext);
 511
 512           /* Attempt to open this file.  */
 513           h = CreateFile (full_executable, GENERIC_READ,
 514                           FILE_SHARE_READ | FILE_SHARE_WRITE,
 515                           0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
 516           if (h != INVALID_HANDLE_VALUE)
 517             goto found;
 518         }
 519       p = q;
 520     }
 521   while (*p);
 522   free (full_executable);
 523   return 0;
 524
 525  found:
 526   CloseHandle (h);
 527   return full_executable;
 528 }
 529
 530 /* Low-level process creation function and helper.  */
 531
 532 static int
 533 env_compare (const void *a_ptr, const void *b_ptr)
 534 {
 535   const char *a;
 536   const char *b;
 537   unsigned char c1;
 538   unsigned char c2;
 539
 540   a = *(const char **) a_ptr;
 541   b = *(const char **) b_ptr;
 542
 543   /* a and b will be of the form: VAR=VALUE
 544      We compare only the variable name part here using a case-insensitive
 545      comparison algorithm.  It might appear that in fact strcasecmp () can
 546      take the place of this whole function, and indeed it could, save for
 547      the fact that it would fail in cases such as comparing A1=foo and
 548      A=bar (because 1 is less than = in the ASCII character set).
 549      (Environment variables containing no numbers would work in such a
 550      scenario.)  */
 551
 552   do
 553     {
 554       c1 = (unsigned char) tolower (*a++);
 555       c2 = (unsigned char) tolower (*b++);
 556
 557       if (c1 == '=')
 558         c1 = '\0';
 559
 560       if (c2 == '=')
 561         c2 = '\0';
 562     }
 563   while (c1 == c2 && c1 != '\0');
 564
 565   return c1 - c2;
 566 }
 567
 568 /* Execute a Windows executable as a child process.  This will fail if the
 569  * target is not actually an executable, such as if it is a shell script. */
 570
 571 static pid_t
 572 win32_spawn (const char *executable,
 573              BOOL search,
 574              char *const *argv,
 575              char *const *env, /* array of strings of the form: VAR=VALUE */
 576              DWORD dwCreationFlags,
 577              LPSTARTUPINFO si,
 578              LPPROCESS_INFORMATION pi)
 579 {
 580   char *full_executable = NULL;
 581   char *cmdline = NULL;
 582   pid_t pid = (pid_t) -1;
 583   char **env_copy;
 584   char *env_block = NULL;
 585
 586   if (env)
 587     {
 588       int env_size;
 589
 590       /* Count the number of environment bindings supplied.  */
 591       for (env_size = 0; env[env_size]; env_size++)
 592         continue;
 593
 594       /* Assemble an environment block, if required.  This consists of
 595          VAR=VALUE strings juxtaposed (with one null character between each
 596          pair) and an additional null at the end.  */
 597       if (env_size > 0)
 598         {
 599           int var;
 600           int total_size = 1; /* 1 is for the final null.  */
 601           char *bufptr;
 602
 603           /* Windows needs the members of the block to be sorted by variable
 604              name.  */
 605           env_copy = (char **) alloca (sizeof (char *) * env_size);
 606           memcpy (env_copy, env, sizeof (char *) * env_size);
 607           qsort (env_copy, env_size, sizeof (char *), env_compare);
 608
 609           for (var = 0; var < env_size; var++)
 610             total_size += strlen (env[var]) + 1;
 611
 612           env_block = XNEWVEC (char, total_size);
 613           bufptr = env_block;
 614           for (var = 0; var < env_size; var++)
 615             bufptr = stpcpy (bufptr, env_copy[var]) + 1;
 616
 617           *bufptr = '\0';
 618         }
 619     }
 620
 621   full_executable = find_executable (executable, search);
 622   if (!full_executable)
 623     goto exit;
 624   cmdline = argv_to_cmdline (argv);
 625   if (!cmdline)
 626     goto exit;
 627
 628   /* Create the child process.  */
 629   if (CreateProcess (full_executable, cmdline,
 630                       /*lpProcessAttributes=*/NULL,
 631                       /*lpThreadAttributes=*/NULL,
 632                       /*bInheritHandles=*/TRUE,
 633                       dwCreationFlags,
 634                       (LPVOID) env_block,
 635                       /*lpCurrentDirectory=*/NULL,
 636                       si,
 637                       pi))
 638     {
 639       CloseHandle (pi->hThread);
 640       pid = (pid_t) pi->hProcess;
 641     }
 642
 643  exit:
 644   /* Clean up.  */
 645   free (env_block);
 646   free (cmdline);
 647   free (full_executable);
 648
 649   return pid;
 650 }
 651
 652 /* Spawn a script.  This simulates the Unix script execution mechanism.
 653    This function is called as a fallback if win32_spawn fails. */
 654
 655 static pid_t
 656 spawn_script (const char *executable, char *const *argv,
 657               char* const *env,
 658               DWORD dwCreationFlags,
 659               LPSTARTUPINFO si,
 660               LPPROCESS_INFORMATION pi)
 661 {
 662   pid_t pid = (pid_t) -1;
 663   int save_errno = errno;
 664   int fd = _open (executable, _O_RDONLY);
 665
 666   /* Try to open script, check header format, extract interpreter path,
 667      and spawn script using that interpretter. */
 668   if (fd >= 0)
 669     {
 670       char buf[MAX_PATH + 5];
 671       int len = _read (fd, buf, sizeof (buf) - 1);
 672       _close (fd);
 673       if (len > 3)
 674         {
 675           char *eol;
 676           buf[len] = '\0';
 677           eol = strchr (buf, '\n');
 678           if (eol && strncmp (buf, "#!", 2) == 0)
 679             {
 680
 681               /* Header format is OK. */
 682               char *executable1;
 683               int new_argc;
 684               const char **avhere;
 685
 686               /* Extract interpreter path. */
 687               do
 688                 *eol = '\0';
 689               while (*--eol == '\r' || *eol == ' ' || *eol == '\t');
 690               for (executable1 = buf + 2; *executable1 == ' ' || *executable1 == '\t'; executable1++)
 691                 continue;
 692               backslashify (executable1);
 693
 694               /* Duplicate argv, prepending the interpreter path. */
 695               new_argc = argv_to_argc (argv) + 1;
 696               avhere = XNEWVEC (const char *, new_argc + 1);
 697               *avhere = executable1;
 698               memcpy (avhere + 1, argv, new_argc * sizeof(*argv));
 699               argv = (char *const *)avhere;
 700
 701               /* Spawn the child. */
 702 #ifndef USE_MINGW_MSYS
 703               executable = strrchr (executable1, '\\') + 1;
 704               if (!executable)
 705                 executable = executable1;
 706               pid = win32_spawn (executable, TRUE, argv, env,
 707                                  dwCreationFlags, si, pi);
 708 #else
 709               if (strchr (executable1, '\\') == NULL)
 710                 pid = win32_spawn (executable1, TRUE, argv, env,
 711                                    dwCreationFlags, si, pi);
 712               else if (executable1[0] != '\\')
 713                 pid = win32_spawn (executable1, FALSE, argv, env,
 714                                    dwCreationFlags, si, pi);
 715               else
 716                 {
 717                   const char *newex = mingw_rootify (executable1);
 718                   *avhere = newex;
 719                   pid = win32_spawn (newex, FALSE, argv, env,
 720                                      dwCreationFlags, si, pi);
 721                   if (executable1 != newex)
 722                     free ((char *) newex);
 723                   if (pid == (pid_t) -1)
 724                     {
 725                       newex = msys_rootify (executable1);
 726                       if (newex != executable1)
 727                         {
 728                           *avhere = newex;
 729                           pid = win32_spawn (newex, FALSE, argv, env,
 730                                              dwCreationFlags, si, pi);
 731                           free ((char *) newex);
 732                         }
 733                     }
 734                 }
 735 #endif
 736               free (avhere);
 737             }
 738         }
 739     }
 740   if (pid == (pid_t) -1)
 741     errno = save_errno;
 742   return pid;
 743 }
 744
 745 /* Execute a child.  */
 746
 747 static pid_t
 748 pex_win32_exec_child (struct pex_obj *obj ATTRIBUTE_UNUSED, int flags,
 749                       const char *executable, char * const * argv,
 750                       char* const* env,
 751                       int in, int out, int errdes,
 752                       int toclose ATTRIBUTE_UNUSED,
 753                       const char **errmsg,
 754                       int *err)
 755 {
 756   pid_t pid;
 757   HANDLE stdin_handle;
 758   HANDLE stdout_handle;
 759   HANDLE stderr_handle;
 760   DWORD dwCreationFlags;
 761   OSVERSIONINFO version_info;
 762   STARTUPINFO si;
 763   PROCESS_INFORMATION pi;
 764   int orig_out, orig_in, orig_err = 0;
 765   BOOL separate_stderr = !(flags & PEX_STDERR_TO_STDOUT);
 766
 767   /* Ensure we have inheritable descriptors to pass to the child.  */
 768   orig_in = in;
 769   in = _dup (orig_in);
 770
 771   orig_out = out;
 772   out = _dup (orig_out);
 773
 774   if (separate_stderr)
 775     {
 776       orig_err = errdes;
 777       errdes = _dup (orig_err);
 778     }
 779
 780   stdin_handle = INVALID_HANDLE_VALUE;
 781   stdout_handle = INVALID_HANDLE_VALUE;
 782   stderr_handle = INVALID_HANDLE_VALUE;
 783
 784   stdin_handle = (HANDLE) _get_osfhandle (in);
 785   stdout_handle = (HANDLE) _get_osfhandle (out);
 786   if (separate_stderr)
 787     stderr_handle = (HANDLE) _get_osfhandle (errdes);
 788   else
 789     stderr_handle = stdout_handle;
 790
 791   /* Determine the version of Windows we are running on.  */
 792   version_info.dwOSVersionInfoSize = sizeof (version_info);
 793   GetVersionEx (&version_info);
 794   if (version_info.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS)
 795     /* On Windows 95/98/ME the CREATE_NO_WINDOW flag is not
 796        supported, so we cannot avoid creating a console window.  */
 797     dwCreationFlags = 0;
 798   else
 799     {
 800       HANDLE conout_handle;
 801
 802       /* Determine whether or not we have an associated console.  */
 803       conout_handle = CreateFile("CONOUT$",
 804                                  GENERIC_WRITE,
 805                                  FILE_SHARE_WRITE,
 806                                  /*lpSecurityAttributes=*/NULL,
 807                                  OPEN_EXISTING,
 808                                  FILE_ATTRIBUTE_NORMAL,
 809                                  /*hTemplateFile=*/NULL);
 810       if (conout_handle == INVALID_HANDLE_VALUE)
 811         /* There is no console associated with this process.  Since
 812            the child is a console process, the OS would normally
 813            create a new console Window for the child.  Since we'll be
 814            redirecting the child's standard streams, we do not need
 815            the console window.  */
 816         dwCreationFlags = CREATE_NO_WINDOW;
 817       else
 818         {
 819           /* There is a console associated with the process, so the OS
 820              will not create a new console.  And, if we use
 821              CREATE_NO_WINDOW in this situation, the child will have
 822              no associated console.  Therefore, if the child's
 823              standard streams are connected to the console, the output
 824              will be discarded.  */
 825           CloseHandle(conout_handle);
 826           dwCreationFlags = 0;
 827         }
 828     }
 829
 830   /* Since the child will be a console process, it will, by default,
 831      connect standard input/output to its console.  However, we want
 832      the child to use the handles specifically designated above.  In
 833      addition, if there is no console (such as when we are running in
 834      a Cygwin X window), then we must redirect the child's
 835      input/output, as there is no console for the child to use.  */
 836   memset (&si, 0, sizeof (si));
 837   si.cb = sizeof (si);
 838   si.dwFlags = STARTF_USESTDHANDLES;
 839   si.hStdInput = stdin_handle;
 840   si.hStdOutput = stdout_handle;
 841   si.hStdError = stderr_handle;
 842
 843   /* Create the child process.  */
 844   pid = win32_spawn (executable, (flags & PEX_SEARCH) != 0,
 845                      argv, env, dwCreationFlags, &si, &pi);
 846   if (pid == (pid_t) -1)
 847     pid = spawn_script (executable, argv, env, dwCreationFlags,
 848                         &si, &pi);
 849   if (pid == (pid_t) -1)
 850     {
 851       *err = ENOENT;
 852       *errmsg = "CreateProcess";
 853     }
 854
 855   /* If the child was created successfully, close the original file
 856      descriptors.  If the process creation fails, these are closed by
 857      pex_run_in_environment instead.  We must not close them twice as
 858      that seems to cause a Windows exception.  */
 859
 860   if (pid != (pid_t) -1)
 861     {
 862       if (orig_in != STDIN_FILENO)
 863         _close (orig_in);
 864       if (orig_out != STDOUT_FILENO)
 865         _close (orig_out);
 866       if (separate_stderr
 867           && orig_err != STDERR_FILENO)
 868         _close (orig_err);
 869     }
 870
 871   /* Close the standard input, standard output and standard error handles
 872      in the parent.  */
 873
 874   _close (in);
 875   _close (out);
 876   if (separate_stderr)
 877     _close (errdes);
 878
 879   return pid;
 880 }
 881
 882 /* Wait for a child process to complete.  MS CRTDLL doesn't return
 883    enough information in status to decide if the child exited due to a
 884    signal or not, rather it simply returns an integer with the exit
 885    code of the child; eg., if the child exited with an abort() call
 886    and didn't have a handler for SIGABRT, it simply returns with
 887    status == 3.  We fix the status code to conform to the usual WIF*
 888    macros.  Note that WIFSIGNALED will never be true under CRTDLL. */
 889
 890 static pid_t
 891 pex_win32_wait (struct pex_obj *obj ATTRIBUTE_UNUSED, pid_t pid,
 892                 int *status, struct pex_time *time, int done ATTRIBUTE_UNUSED,
 893                 const char **errmsg, int *err)
 894 {
 895   DWORD termstat;
 896   HANDLE h;
 897
 898   if (time != NULL)
 899     memset (time, 0, sizeof *time);
 900
 901   h = (HANDLE) pid;
 902
 903   /* FIXME: If done is non-zero, we should probably try to kill the
 904      process.  */
 905   if (WaitForSingleObject (h, INFINITE) != WAIT_OBJECT_0)
 906     {
 907       CloseHandle (h);
 908       *err = ECHILD;
 909       *errmsg = "WaitForSingleObject";
 910       return -1;
 911     }
 912
 913   GetExitCodeProcess (h, &termstat);
 914   CloseHandle (h);
 915
 916   /* A value of 3 indicates that the child caught a signal, but not
 917      which one.  Since only SIGABRT, SIGFPE and SIGINT do anything, we
 918      report SIGABRT.  */
 919   if (termstat == 3)
 920     *status = SIGABRT;
 921   else
 922     *status = (termstat & 0xff) << 8;
 923
 924   return 0;
 925 }
 926
 927 /* Create a pipe.  */
 928
 929 static int
 930 pex_win32_pipe (struct pex_obj *obj ATTRIBUTE_UNUSED, int *p,
 931                 int binary)
 932 {
 933   return _pipe (p, 256, (binary ? _O_BINARY : _O_TEXT) | _O_NOINHERIT);
 934 }
 935
 936 /* Get a FILE pointer to read from a file descriptor.  */
 937
 938 static FILE *
 939 pex_win32_fdopenr (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd,
 940                    int binary)
 941 {
 942   HANDLE h = (HANDLE) _get_osfhandle (fd);
 943   if (h == INVALID_HANDLE_VALUE)
 944     return NULL;
 945   if (! SetHandleInformation (h, HANDLE_FLAG_INHERIT, 0))
 946     return NULL;
 947   return fdopen (fd, binary ? "rb" : "r");
 948 }
 949
 950 static FILE *
 951 pex_win32_fdopenw (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd,
 952                    int binary)
 953 {
 954   HANDLE h = (HANDLE) _get_osfhandle (fd);
 955   if (h == INVALID_HANDLE_VALUE)
 956     return NULL;
 957   if (! SetHandleInformation (h, HANDLE_FLAG_INHERIT, 0))
 958     return NULL;
 959   return fdopen (fd, binary ? "wb" : "w");
 960 }
 961
 962 #ifdef MAIN
 963 #include <stdio.h>
 964
 965 int
 966 main (int argc ATTRIBUTE_UNUSED, char **argv)
 967 {
 968   char const *errmsg;
 969   int err;
 970   argv++;
 971   printf ("%ld\n", (long) pex_win32_exec_child (NULL, PEX_SEARCH, argv[0], argv, NULL, 0, 0, 1, 2, &errmsg, &err));
 972   exit (0);
 973 }
 974 #endif