2014-04-02 Richard Biener <rguenther@suse.de>
[official-gcc.git] / libiberty / pex-win32.c
blobeae72c51dc0a2662db01b16c43abdf20590ac027
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.
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.
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.
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. */
22 #include "pex-common.h"
24 #include <windows.h>
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
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>
48 /* mingw32 headers may not define the following. */
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
57 # define WAIT_CHILD 0
58 # define WAIT_GRANDCHILD 1
59 #endif
61 #define MINGW_NAME "Minimalist GNU for Windows"
62 #define MINGW_NAME_LEN (sizeof(MINGW_NAME) - 1)
64 extern char *stpcpy (char *dst, const char *src);
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)
75 while ((s = strchr (s, '/')) != NULL)
76 *s = '\\';
77 return;
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);
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);
93 /* The list of functions we pass to the common routines. */
95 const struct pex_funcs funcs =
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 */
108 /* Return a newly initialized pex_obj structure. */
110 struct pex_obj *
111 pex_init (int flags, const char *pname, const char *tempbase)
113 return pex_init_common (flags, pname, tempbase, &funcs);
116 /* Open a file for reading. */
118 static int
119 pex_win32_open_read (struct pex_obj *obj ATTRIBUTE_UNUSED, const char *name,
120 int binary)
122 return _open (name, _O_RDONLY | (binary ? _O_BINARY : _O_TEXT));
125 /* Open a file for writing. */
127 static int
128 pex_win32_open_write (struct pex_obj *obj ATTRIBUTE_UNUSED, const char *name,
129 int binary)
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 return _open (name,
134 (_O_WRONLY | _O_CREAT | _O_TRUNC
135 | (binary ? _O_BINARY : _O_TEXT)),
136 _S_IREAD | _S_IWRITE);
139 /* Close a file. */
141 static int
142 pex_win32_close (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd)
144 return _close (fd);
147 #ifdef USE_MINGW_MSYS
148 static const char *mingw_keys[] = {"SOFTWARE", "Microsoft", "Windows", "CurrentVersion", "Uninstall", NULL};
150 /* Tack the executable on the end of a (possibly slash terminated) buffer
151 and convert everything to \. */
152 static const char *
153 tack_on_executable (char *buf, const char *executable)
155 char *p = strchr (buf, '\0');
156 if (p > buf && (p[-1] == '\\' || p[-1] == '/'))
157 p[-1] = '\0';
158 backslashify (strcat (buf, executable));
159 return buf;
162 /* Walk down a registry hierarchy until the end. Return the key. */
163 static HKEY
164 openkey (HKEY hStart, const char *keys[])
166 HKEY hKey, hTmp;
167 for (hKey = hStart; *keys; keys++)
169 LONG res;
170 hTmp = hKey;
171 res = RegOpenKey (hTmp, *keys, &hKey);
173 if (hTmp != HKEY_LOCAL_MACHINE)
174 RegCloseKey (hTmp);
176 if (res != ERROR_SUCCESS)
177 return NULL;
179 return hKey;
182 /* Return the "mingw root" as derived from the mingw uninstall information. */
183 static const char *
184 mingw_rootify (const char *executable)
186 HKEY hKey, hTmp;
187 DWORD maxlen;
188 char *namebuf, *foundbuf;
189 DWORD i;
190 LONG res;
192 /* Open the uninstall "directory". */
193 hKey = openkey (HKEY_LOCAL_MACHINE, mingw_keys);
195 /* Not found. */
196 if (!hKey)
197 return executable;
199 /* Need to enumerate all of the keys here looking for one the most recent
200 one for MinGW. */
201 if (RegQueryInfoKey (hKey, NULL, NULL, NULL, NULL, &maxlen, NULL, NULL,
202 NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
204 RegCloseKey (hKey);
205 return executable;
207 namebuf = XNEWVEC (char, ++maxlen);
208 foundbuf = XNEWVEC (char, maxlen);
209 foundbuf[0] = '\0';
210 if (!namebuf || !foundbuf)
212 RegCloseKey (hKey);
213 free (namebuf);
214 free (foundbuf);
215 return executable;
218 /* Look through all of the keys for one that begins with Minimal GNU...
219 Try to get the latest version by doing a string compare although that
220 string never really works with version number sorting. */
221 for (i = 0; RegEnumKey (hKey, i, namebuf, maxlen) == ERROR_SUCCESS; i++)
223 int match = strcasecmp (namebuf, MINGW_NAME);
224 if (match < 0)
225 continue;
226 if (match > 0 && strncasecmp (namebuf, MINGW_NAME, MINGW_NAME_LEN) > 0)
227 continue;
228 if (strcasecmp (namebuf, foundbuf) > 0)
229 strcpy (foundbuf, namebuf);
231 free (namebuf);
233 /* If foundbuf is empty, we didn't find anything. Punt. */
234 if (!foundbuf[0])
236 free (foundbuf);
237 RegCloseKey (hKey);
238 return executable;
241 /* Open the key that we wanted */
242 res = RegOpenKey (hKey, foundbuf, &hTmp);
243 RegCloseKey (hKey);
244 free (foundbuf);
246 /* Don't know why this would fail, but you gotta check */
247 if (res != ERROR_SUCCESS)
248 return executable;
250 maxlen = 0;
251 /* Get the length of the value pointed to by InstallLocation */
252 if (RegQueryValueEx (hTmp, "InstallLocation", 0, NULL, NULL,
253 &maxlen) != ERROR_SUCCESS || maxlen == 0)
255 RegCloseKey (hTmp);
256 return executable;
259 /* Allocate space for the install location */
260 foundbuf = XNEWVEC (char, maxlen + strlen (executable));
261 if (!foundbuf)
263 free (foundbuf);
264 RegCloseKey (hTmp);
267 /* Read the install location into the buffer */
268 res = RegQueryValueEx (hTmp, "InstallLocation", 0, NULL, (LPBYTE) foundbuf,
269 &maxlen);
270 RegCloseKey (hTmp);
271 if (res != ERROR_SUCCESS)
273 free (foundbuf);
274 return executable;
277 /* Concatenate the install location and the executable, turn all slashes
278 to backslashes, and return that. */
279 return tack_on_executable (foundbuf, executable);
282 /* Read the install location of msys from it's installation file and
283 rootify the executable based on that. */
284 static const char *
285 msys_rootify (const char *executable)
287 size_t bufsize = 64;
288 size_t execlen = strlen (executable) + 1;
289 char *buf;
290 DWORD res = 0;
291 for (;;)
293 buf = XNEWVEC (char, bufsize + execlen);
294 if (!buf)
295 break;
296 res = GetPrivateProfileString ("InstallSettings", "InstallPath", NULL,
297 buf, bufsize, "msys.ini");
298 if (!res)
299 break;
300 if (strlen (buf) < bufsize)
301 break;
302 res = 0;
303 free (buf);
304 bufsize *= 2;
305 if (bufsize > 65536)
307 buf = NULL;
308 break;
312 if (res)
313 return tack_on_executable (buf, executable);
315 /* failed */
316 free (buf);
317 return executable;
319 #endif
321 /* Return the number of arguments in an argv array, not including the null
322 terminating argument. */
324 static int
325 argv_to_argc (char *const *argv)
327 char *const *i = argv;
328 while (*i)
329 i++;
330 return i - argv;
333 /* Return a Windows command-line from ARGV. It is the caller's
334 responsibility to free the string returned. */
336 static char *
337 argv_to_cmdline (char *const *argv)
339 char *cmdline;
340 char *p;
341 size_t cmdline_len;
342 int i, j, k;
344 cmdline_len = 0;
345 for (i = 0; argv[i]; i++)
347 /* We quote every last argument. This simplifies the problem;
348 we need only escape embedded double-quotes and immediately
349 preceeding backslash characters. A sequence of backslach characters
350 that is not follwed by a double quote character will not be
351 escaped. */
352 for (j = 0; argv[i][j]; j++)
354 if (argv[i][j] == '"')
356 /* Escape preceeding backslashes. */
357 for (k = j - 1; k >= 0 && argv[i][k] == '\\'; k--)
358 cmdline_len++;
359 /* Escape the qote character. */
360 cmdline_len++;
363 /* Trailing backslashes also need to be escaped because they will be
364 followed by the terminating quote. */
365 for (k = j - 1; k >= 0 && argv[i][k] == '\\'; k--)
366 cmdline_len++;
367 cmdline_len += j;
368 cmdline_len += 3; /* for leading and trailing quotes and space */
370 cmdline = XNEWVEC (char, cmdline_len);
371 p = cmdline;
372 for (i = 0; argv[i]; i++)
374 *p++ = '"';
375 for (j = 0; argv[i][j]; j++)
377 if (argv[i][j] == '"')
379 for (k = j - 1; k >= 0 && argv[i][k] == '\\'; k--)
380 *p++ = '\\';
381 *p++ = '\\';
383 *p++ = argv[i][j];
385 for (k = j - 1; k >= 0 && argv[i][k] == '\\'; k--)
386 *p++ = '\\';
387 *p++ = '"';
388 *p++ = ' ';
390 p[-1] = '\0';
391 return cmdline;
394 /* We'll try the passed filename with all the known standard
395 extensions, and then without extension. We try no extension
396 last so that we don't try to run some random extension-less
397 file that might be hanging around. We try both extension
398 and no extension so that we don't need any fancy logic
399 to determine if a file has extension. */
400 static const char *const
401 std_suffixes[] = {
402 ".com",
403 ".exe",
404 ".bat",
405 ".cmd",
410 /* Returns the full path to PROGRAM. If SEARCH is true, look for
411 PROGRAM in each directory in PATH. */
413 static char *
414 find_executable (const char *program, BOOL search)
416 char *full_executable;
417 char *e;
418 size_t fe_len;
419 const char *path = 0;
420 const char *const *ext;
421 const char *p, *q;
422 size_t proglen = strlen (program);
423 int has_slash = (strchr (program, '/') || strchr (program, '\\'));
424 HANDLE h;
426 if (has_slash)
427 search = FALSE;
429 if (search)
430 path = getenv ("PATH");
431 if (!path)
432 path = "";
434 fe_len = 0;
435 for (p = path; *p; p = q)
437 q = p;
438 while (*q != ';' && *q != '\0')
439 q++;
440 if ((size_t)(q - p) > fe_len)
441 fe_len = q - p;
442 if (*q == ';')
443 q++;
445 fe_len = fe_len + 1 + proglen + 5 /* space for extension */;
446 full_executable = XNEWVEC (char, fe_len);
448 p = path;
451 q = p;
452 while (*q != ';' && *q != '\0')
453 q++;
455 e = full_executable;
456 memcpy (e, p, q - p);
457 e += (q - p);
458 if (q - p)
459 *e++ = '\\';
460 strcpy (e, program);
462 if (*q == ';')
463 q++;
465 for (e = full_executable; *e; e++)
466 if (*e == '/')
467 *e = '\\';
469 /* At this point, e points to the terminating NUL character for
470 full_executable. */
471 for (ext = std_suffixes; *ext; ext++)
473 /* Remove any current extension. */
474 *e = '\0';
475 /* Add the new one. */
476 strcat (full_executable, *ext);
478 /* Attempt to open this file. */
479 h = CreateFile (full_executable, GENERIC_READ,
480 FILE_SHARE_READ | FILE_SHARE_WRITE,
481 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
482 if (h != INVALID_HANDLE_VALUE)
483 goto found;
485 p = q;
487 while (*p);
488 free (full_executable);
489 return 0;
491 found:
492 CloseHandle (h);
493 return full_executable;
496 /* Low-level process creation function and helper. */
498 static int
499 env_compare (const void *a_ptr, const void *b_ptr)
501 const char *a;
502 const char *b;
503 unsigned char c1;
504 unsigned char c2;
506 a = *(const char **) a_ptr;
507 b = *(const char **) b_ptr;
509 /* a and b will be of the form: VAR=VALUE
510 We compare only the variable name part here using a case-insensitive
511 comparison algorithm. It might appear that in fact strcasecmp () can
512 take the place of this whole function, and indeed it could, save for
513 the fact that it would fail in cases such as comparing A1=foo and
514 A=bar (because 1 is less than = in the ASCII character set).
515 (Environment variables containing no numbers would work in such a
516 scenario.) */
520 c1 = (unsigned char) tolower (*a++);
521 c2 = (unsigned char) tolower (*b++);
523 if (c1 == '=')
524 c1 = '\0';
526 if (c2 == '=')
527 c2 = '\0';
529 while (c1 == c2 && c1 != '\0');
531 return c1 - c2;
534 /* Execute a Windows executable as a child process. This will fail if the
535 * target is not actually an executable, such as if it is a shell script. */
537 static pid_t
538 win32_spawn (const char *executable,
539 BOOL search,
540 char *const *argv,
541 char *const *env, /* array of strings of the form: VAR=VALUE */
542 DWORD dwCreationFlags,
543 LPSTARTUPINFO si,
544 LPPROCESS_INFORMATION pi)
546 char *full_executable;
547 char *cmdline;
548 char **env_copy;
549 char *env_block = NULL;
551 full_executable = NULL;
552 cmdline = NULL;
554 if (env)
556 int env_size;
558 /* Count the number of environment bindings supplied. */
559 for (env_size = 0; env[env_size]; env_size++)
560 continue;
562 /* Assemble an environment block, if required. This consists of
563 VAR=VALUE strings juxtaposed (with one null character between each
564 pair) and an additional null at the end. */
565 if (env_size > 0)
567 int var;
568 int total_size = 1; /* 1 is for the final null. */
569 char *bufptr;
571 /* Windows needs the members of the block to be sorted by variable
572 name. */
573 env_copy = (char **) alloca (sizeof (char *) * env_size);
574 memcpy (env_copy, env, sizeof (char *) * env_size);
575 qsort (env_copy, env_size, sizeof (char *), env_compare);
577 for (var = 0; var < env_size; var++)
578 total_size += strlen (env[var]) + 1;
580 env_block = XNEWVEC (char, total_size);
581 bufptr = env_block;
582 for (var = 0; var < env_size; var++)
583 bufptr = stpcpy (bufptr, env_copy[var]) + 1;
585 *bufptr = '\0';
589 full_executable = find_executable (executable, search);
590 if (!full_executable)
591 goto error;
592 cmdline = argv_to_cmdline (argv);
593 if (!cmdline)
594 goto error;
596 /* Create the child process. */
597 if (!CreateProcess (full_executable, cmdline,
598 /*lpProcessAttributes=*/NULL,
599 /*lpThreadAttributes=*/NULL,
600 /*bInheritHandles=*/TRUE,
601 dwCreationFlags,
602 (LPVOID) env_block,
603 /*lpCurrentDirectory=*/NULL,
605 pi))
607 free (env_block);
609 free (full_executable);
611 return (pid_t) -1;
614 /* Clean up. */
615 CloseHandle (pi->hThread);
616 free (full_executable);
617 free (env_block);
619 return (pid_t) pi->hProcess;
621 error:
622 free (env_block);
623 free (cmdline);
624 free (full_executable);
626 return (pid_t) -1;
629 /* Spawn a script. This simulates the Unix script execution mechanism.
630 This function is called as a fallback if win32_spawn fails. */
632 static pid_t
633 spawn_script (const char *executable, char *const *argv,
634 char* const *env,
635 DWORD dwCreationFlags,
636 LPSTARTUPINFO si,
637 LPPROCESS_INFORMATION pi)
639 pid_t pid = (pid_t) -1;
640 int save_errno = errno;
641 int fd = _open (executable, _O_RDONLY);
643 /* Try to open script, check header format, extract interpreter path,
644 and spawn script using that interpretter. */
645 if (fd >= 0)
647 char buf[MAX_PATH + 5];
648 int len = _read (fd, buf, sizeof (buf) - 1);
649 _close (fd);
650 if (len > 3)
652 char *eol;
653 buf[len] = '\0';
654 eol = strchr (buf, '\n');
655 if (eol && strncmp (buf, "#!", 2) == 0)
658 /* Header format is OK. */
659 char *executable1;
660 int new_argc;
661 const char **avhere;
663 /* Extract interpreter path. */
665 *eol = '\0';
666 while (*--eol == '\r' || *eol == ' ' || *eol == '\t');
667 for (executable1 = buf + 2; *executable1 == ' ' || *executable1 == '\t'; executable1++)
668 continue;
669 backslashify (executable1);
671 /* Duplicate argv, prepending the interpreter path. */
672 new_argc = argv_to_argc (argv) + 1;
673 avhere = XNEWVEC (const char *, new_argc + 1);
674 *avhere = executable1;
675 memcpy (avhere + 1, argv, new_argc * sizeof(*argv));
676 argv = (char *const *)avhere;
678 /* Spawn the child. */
679 #ifndef USE_MINGW_MSYS
680 executable = strrchr (executable1, '\\') + 1;
681 if (!executable)
682 executable = executable1;
683 pid = win32_spawn (executable, TRUE, argv, env,
684 dwCreationFlags, si, pi);
685 #else
686 if (strchr (executable1, '\\') == NULL)
687 pid = win32_spawn (executable1, TRUE, argv, env,
688 dwCreationFlags, si, pi);
689 else if (executable1[0] != '\\')
690 pid = win32_spawn (executable1, FALSE, argv, env,
691 dwCreationFlags, si, pi);
692 else
694 const char *newex = mingw_rootify (executable1);
695 *avhere = newex;
696 pid = win32_spawn (newex, FALSE, argv, env,
697 dwCreationFlags, si, pi);
698 if (executable1 != newex)
699 free ((char *) newex);
700 if (pid == (pid_t) -1)
702 newex = msys_rootify (executable1);
703 if (newex != executable1)
705 *avhere = newex;
706 pid = win32_spawn (newex, FALSE, argv, env,
707 dwCreationFlags, si, pi);
708 free ((char *) newex);
712 #endif
713 free (avhere);
717 if (pid == (pid_t) -1)
718 errno = save_errno;
719 return pid;
722 /* Execute a child. */
724 static pid_t
725 pex_win32_exec_child (struct pex_obj *obj ATTRIBUTE_UNUSED, int flags,
726 const char *executable, char * const * argv,
727 char* const* env,
728 int in, int out, int errdes,
729 int toclose ATTRIBUTE_UNUSED,
730 const char **errmsg,
731 int *err)
733 pid_t pid;
734 HANDLE stdin_handle;
735 HANDLE stdout_handle;
736 HANDLE stderr_handle;
737 DWORD dwCreationFlags;
738 OSVERSIONINFO version_info;
739 STARTUPINFO si;
740 PROCESS_INFORMATION pi;
741 int orig_out, orig_in, orig_err;
742 BOOL separate_stderr = !(flags & PEX_STDERR_TO_STDOUT);
744 /* Ensure we have inheritable descriptors to pass to the child. */
745 orig_in = in;
746 in = _dup (orig_in);
748 orig_out = out;
749 out = _dup (orig_out);
751 if (separate_stderr)
753 orig_err = errdes;
754 errdes = _dup (orig_err);
757 stdin_handle = INVALID_HANDLE_VALUE;
758 stdout_handle = INVALID_HANDLE_VALUE;
759 stderr_handle = INVALID_HANDLE_VALUE;
761 stdin_handle = (HANDLE) _get_osfhandle (in);
762 stdout_handle = (HANDLE) _get_osfhandle (out);
763 if (separate_stderr)
764 stderr_handle = (HANDLE) _get_osfhandle (errdes);
765 else
766 stderr_handle = stdout_handle;
768 /* Determine the version of Windows we are running on. */
769 version_info.dwOSVersionInfoSize = sizeof (version_info);
770 GetVersionEx (&version_info);
771 if (version_info.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS)
772 /* On Windows 95/98/ME the CREATE_NO_WINDOW flag is not
773 supported, so we cannot avoid creating a console window. */
774 dwCreationFlags = 0;
775 else
777 HANDLE conout_handle;
779 /* Determine whether or not we have an associated console. */
780 conout_handle = CreateFile("CONOUT$",
781 GENERIC_WRITE,
782 FILE_SHARE_WRITE,
783 /*lpSecurityAttributes=*/NULL,
784 OPEN_EXISTING,
785 FILE_ATTRIBUTE_NORMAL,
786 /*hTemplateFile=*/NULL);
787 if (conout_handle == INVALID_HANDLE_VALUE)
788 /* There is no console associated with this process. Since
789 the child is a console process, the OS would normally
790 create a new console Window for the child. Since we'll be
791 redirecting the child's standard streams, we do not need
792 the console window. */
793 dwCreationFlags = CREATE_NO_WINDOW;
794 else
796 /* There is a console associated with the process, so the OS
797 will not create a new console. And, if we use
798 CREATE_NO_WINDOW in this situation, the child will have
799 no associated console. Therefore, if the child's
800 standard streams are connected to the console, the output
801 will be discarded. */
802 CloseHandle(conout_handle);
803 dwCreationFlags = 0;
807 /* Since the child will be a console process, it will, by default,
808 connect standard input/output to its console. However, we want
809 the child to use the handles specifically designated above. In
810 addition, if there is no console (such as when we are running in
811 a Cygwin X window), then we must redirect the child's
812 input/output, as there is no console for the child to use. */
813 memset (&si, 0, sizeof (si));
814 si.cb = sizeof (si);
815 si.dwFlags = STARTF_USESTDHANDLES;
816 si.hStdInput = stdin_handle;
817 si.hStdOutput = stdout_handle;
818 si.hStdError = stderr_handle;
820 /* Create the child process. */
821 pid = win32_spawn (executable, (flags & PEX_SEARCH) != 0,
822 argv, env, dwCreationFlags, &si, &pi);
823 if (pid == (pid_t) -1)
824 pid = spawn_script (executable, argv, env, dwCreationFlags,
825 &si, &pi);
826 if (pid == (pid_t) -1)
828 *err = ENOENT;
829 *errmsg = "CreateProcess";
832 /* If the child was created successfully, close the original file
833 descriptors. If the process creation fails, these are closed by
834 pex_run_in_environment instead. We must not close them twice as
835 that seems to cause a Windows exception. */
837 if (pid != (pid_t) -1)
839 if (orig_in != STDIN_FILENO)
840 _close (orig_in);
841 if (orig_out != STDOUT_FILENO)
842 _close (orig_out);
843 if (separate_stderr
844 && orig_err != STDERR_FILENO)
845 _close (orig_err);
848 /* Close the standard input, standard output and standard error handles
849 in the parent. */
851 _close (in);
852 _close (out);
853 if (separate_stderr)
854 _close (errdes);
856 return pid;
859 /* Wait for a child process to complete. MS CRTDLL doesn't return
860 enough information in status to decide if the child exited due to a
861 signal or not, rather it simply returns an integer with the exit
862 code of the child; eg., if the child exited with an abort() call
863 and didn't have a handler for SIGABRT, it simply returns with
864 status == 3. We fix the status code to conform to the usual WIF*
865 macros. Note that WIFSIGNALED will never be true under CRTDLL. */
867 static pid_t
868 pex_win32_wait (struct pex_obj *obj ATTRIBUTE_UNUSED, pid_t pid,
869 int *status, struct pex_time *time, int done ATTRIBUTE_UNUSED,
870 const char **errmsg, int *err)
872 DWORD termstat;
873 HANDLE h;
875 if (time != NULL)
876 memset (time, 0, sizeof *time);
878 h = (HANDLE) pid;
880 /* FIXME: If done is non-zero, we should probably try to kill the
881 process. */
882 if (WaitForSingleObject (h, INFINITE) != WAIT_OBJECT_0)
884 CloseHandle (h);
885 *err = ECHILD;
886 *errmsg = "WaitForSingleObject";
887 return -1;
890 GetExitCodeProcess (h, &termstat);
891 CloseHandle (h);
893 /* A value of 3 indicates that the child caught a signal, but not
894 which one. Since only SIGABRT, SIGFPE and SIGINT do anything, we
895 report SIGABRT. */
896 if (termstat == 3)
897 *status = SIGABRT;
898 else
899 *status = (termstat & 0xff) << 8;
901 return 0;
904 /* Create a pipe. */
906 static int
907 pex_win32_pipe (struct pex_obj *obj ATTRIBUTE_UNUSED, int *p,
908 int binary)
910 return _pipe (p, 256, (binary ? _O_BINARY : _O_TEXT) | _O_NOINHERIT);
913 /* Get a FILE pointer to read from a file descriptor. */
915 static FILE *
916 pex_win32_fdopenr (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd,
917 int binary)
919 HANDLE h = (HANDLE) _get_osfhandle (fd);
920 if (h == INVALID_HANDLE_VALUE)
921 return NULL;
922 if (! SetHandleInformation (h, HANDLE_FLAG_INHERIT, 0))
923 return NULL;
924 return fdopen (fd, binary ? "rb" : "r");
927 static FILE *
928 pex_win32_fdopenw (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd,
929 int binary)
931 HANDLE h = (HANDLE) _get_osfhandle (fd);
932 if (h == INVALID_HANDLE_VALUE)
933 return NULL;
934 if (! SetHandleInformation (h, HANDLE_FLAG_INHERIT, 0))
935 return NULL;
936 return fdopen (fd, binary ? "wb" : "w");
939 #ifdef MAIN
940 #include <stdio.h>
943 main (int argc ATTRIBUTE_UNUSED, char **argv)
945 char const *errmsg;
946 int err;
947 argv++;
948 printf ("%ld\n", (long) pex_win32_exec_child (NULL, PEX_SEARCH, argv[0], argv, NULL, 0, 0, 1, 2, &errmsg, &err));
949 exit (0);
951 #endif