gcc/
[official-gcc.git] / libiberty / pex-win32.c
blob66d2f1157c730ae99e62a2e2b4be20437c43af52
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, 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, int append)
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);
141 /* Close a file. */
143 static int
144 pex_win32_close (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd)
146 return _close (fd);
149 #ifdef USE_MINGW_MSYS
150 static const char *mingw_keys[] = {"SOFTWARE", "Microsoft", "Windows", "CurrentVersion", "Uninstall", NULL};
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)
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;
164 /* Walk down a registry hierarchy until the end. Return the key. */
165 static HKEY
166 openkey (HKEY hStart, const char *keys[])
168 HKEY hKey, hTmp;
169 for (hKey = hStart; *keys; keys++)
171 LONG res;
172 hTmp = hKey;
173 res = RegOpenKey (hTmp, *keys, &hKey);
175 if (hTmp != HKEY_LOCAL_MACHINE)
176 RegCloseKey (hTmp);
178 if (res != ERROR_SUCCESS)
179 return NULL;
181 return hKey;
184 /* Return the "mingw root" as derived from the mingw uninstall information. */
185 static const char *
186 mingw_rootify (const char *executable)
188 HKEY hKey, hTmp;
189 DWORD maxlen;
190 char *namebuf, *foundbuf;
191 DWORD i;
192 LONG res;
194 /* Open the uninstall "directory". */
195 hKey = openkey (HKEY_LOCAL_MACHINE, mingw_keys);
197 /* Not found. */
198 if (!hKey)
199 return executable;
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)
206 RegCloseKey (hKey);
207 return executable;
209 namebuf = XNEWVEC (char, ++maxlen);
210 foundbuf = XNEWVEC (char, maxlen);
211 foundbuf[0] = '\0';
212 if (!namebuf || !foundbuf)
214 RegCloseKey (hKey);
215 free (namebuf);
216 free (foundbuf);
217 return executable;
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++)
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);
233 free (namebuf);
235 /* If foundbuf is empty, we didn't find anything. Punt. */
236 if (!foundbuf[0])
238 free (foundbuf);
239 RegCloseKey (hKey);
240 return executable;
243 /* Open the key that we wanted */
244 res = RegOpenKey (hKey, foundbuf, &hTmp);
245 RegCloseKey (hKey);
246 free (foundbuf);
248 /* Don't know why this would fail, but you gotta check */
249 if (res != ERROR_SUCCESS)
250 return executable;
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)
257 RegCloseKey (hTmp);
258 return executable;
261 /* Allocate space for the install location */
262 foundbuf = XNEWVEC (char, maxlen + strlen (executable));
263 if (!foundbuf)
265 free (foundbuf);
266 RegCloseKey (hTmp);
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)
275 free (foundbuf);
276 return executable;
279 /* Concatenate the install location and the executable, turn all slashes
280 to backslashes, and return that. */
281 return tack_on_executable (foundbuf, executable);
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)
289 size_t bufsize = 64;
290 size_t execlen = strlen (executable) + 1;
291 char *buf;
292 DWORD res = 0;
293 for (;;)
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)
309 buf = NULL;
310 break;
314 if (res)
315 return tack_on_executable (buf, executable);
317 /* failed */
318 free (buf);
319 return executable;
321 #endif
323 /* Return the number of arguments in an argv array, not including the null
324 terminating argument. */
326 static int
327 argv_to_argc (char *const *argv)
329 char *const *i = argv;
330 while (*i)
331 i++;
332 return i - argv;
335 /* Return a Windows command-line from ARGV. It is the caller's
336 responsibility to free the string returned. */
338 static char *
339 argv_to_cmdline (char *const *argv)
341 char *cmdline;
342 char *p;
343 size_t cmdline_len;
344 int i, j, k;
345 int needs_quotes;
347 cmdline_len = 0;
348 for (i = 0; argv[i]; i++)
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++)
359 if (argv[i][j] == ' ' || argv[i][j] == '\t' || argv[i][j] == '"')
361 needs_quotes = 1;
364 if (argv[i][j] == '"')
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++;
373 /* Trailing backslashes also need to be escaped because they will be
374 followed by the terminating quote. */
375 if (needs_quotes)
377 for (k = j - 1; k >= 0 && argv[i][k] == '\\'; k--)
378 cmdline_len++;
380 cmdline_len += j;
381 /* for leading and trailing quotes and space */
382 cmdline_len += needs_quotes * 2 + 1;
384 cmdline = XNEWVEC (char, cmdline_len);
385 p = cmdline;
386 for (i = 0; argv[i]; i++)
388 needs_quotes = 0;
389 for (j = 0; argv[i][j]; j++)
391 if (argv[i][j] == ' ' || argv[i][j] == '\t' || argv[i][j] == '"')
393 needs_quotes = 1;
394 break;
398 if (needs_quotes)
400 *p++ = '"';
402 for (j = 0; argv[i][j]; j++)
404 if (argv[i][j] == '"')
406 for (k = j - 1; k >= 0 && argv[i][k] == '\\'; k--)
407 *p++ = '\\';
408 *p++ = '\\';
410 *p++ = argv[i][j];
412 if (needs_quotes)
414 for (k = j - 1; k >= 0 && argv[i][k] == '\\'; k--)
415 *p++ = '\\';
416 *p++ = '"';
418 *p++ = ' ';
420 p[-1] = '\0';
421 return cmdline;
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",
440 /* Returns the full path to PROGRAM. If SEARCH is true, look for
441 PROGRAM in each directory in PATH. */
443 static char *
444 find_executable (const char *program, BOOL search)
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;
456 if (has_slash)
457 search = FALSE;
459 if (search)
460 path = getenv ("PATH");
461 if (!path)
462 path = "";
464 fe_len = 0;
465 for (p = path; *p; p = q)
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++;
475 fe_len = fe_len + 1 + proglen + 5 /* space for extension */;
476 full_executable = XNEWVEC (char, fe_len);
478 p = path;
481 q = p;
482 while (*q != ';' && *q != '\0')
483 q++;
485 e = full_executable;
486 memcpy (e, p, q - p);
487 e += (q - p);
488 if (q - p)
489 *e++ = '\\';
490 strcpy (e, program);
492 if (*q == ';')
493 q++;
495 for (e = full_executable; *e; e++)
496 if (*e == '/')
497 *e = '\\';
499 /* At this point, e points to the terminating NUL character for
500 full_executable. */
501 for (ext = std_suffixes; *ext; ext++)
503 /* Remove any current extension. */
504 *e = '\0';
505 /* Add the new one. */
506 strcat (full_executable, *ext);
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;
515 p = q;
517 while (*p);
518 free (full_executable);
519 return 0;
521 found:
522 CloseHandle (h);
523 return full_executable;
526 /* Low-level process creation function and helper. */
528 static int
529 env_compare (const void *a_ptr, const void *b_ptr)
531 const char *a;
532 const char *b;
533 unsigned char c1;
534 unsigned char c2;
536 a = *(const char **) a_ptr;
537 b = *(const char **) b_ptr;
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.) */
550 c1 = (unsigned char) tolower (*a++);
551 c2 = (unsigned char) tolower (*b++);
553 if (c1 == '=')
554 c1 = '\0';
556 if (c2 == '=')
557 c2 = '\0';
559 while (c1 == c2 && c1 != '\0');
561 return c1 - c2;
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. */
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)
576 char *full_executable;
577 char *cmdline;
578 char **env_copy;
579 char *env_block = NULL;
581 full_executable = NULL;
582 cmdline = NULL;
584 if (env)
586 int env_size;
588 /* Count the number of environment bindings supplied. */
589 for (env_size = 0; env[env_size]; env_size++)
590 continue;
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)
597 int var;
598 int total_size = 1; /* 1 is for the final null. */
599 char *bufptr;
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);
607 for (var = 0; var < env_size; var++)
608 total_size += strlen (env[var]) + 1;
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;
615 *bufptr = '\0';
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;
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,
635 pi))
637 free (env_block);
639 free (full_executable);
641 return (pid_t) -1;
644 /* Clean up. */
645 CloseHandle (pi->hThread);
646 free (full_executable);
647 free (env_block);
649 return (pid_t) pi->hProcess;
651 error:
652 free (env_block);
653 free (cmdline);
654 free (full_executable);
656 return (pid_t) -1;
659 /* Spawn a script. This simulates the Unix script execution mechanism.
660 This function is called as a fallback if win32_spawn fails. */
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)
669 pid_t pid = (pid_t) -1;
670 int save_errno = errno;
671 int fd = _open (executable, _O_RDONLY);
673 /* Try to open script, check header format, extract interpreter path,
674 and spawn script using that interpretter. */
675 if (fd >= 0)
677 char buf[MAX_PATH + 5];
678 int len = _read (fd, buf, sizeof (buf) - 1);
679 _close (fd);
680 if (len > 3)
682 char *eol;
683 buf[len] = '\0';
684 eol = strchr (buf, '\n');
685 if (eol && strncmp (buf, "#!", 2) == 0)
688 /* Header format is OK. */
689 char *executable1;
690 int new_argc;
691 const char **avhere;
693 /* Extract interpreter path. */
695 *eol = '\0';
696 while (*--eol == '\r' || *eol == ' ' || *eol == '\t');
697 for (executable1 = buf + 2; *executable1 == ' ' || *executable1 == '\t'; executable1++)
698 continue;
699 backslashify (executable1);
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;
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
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)
732 newex = msys_rootify (executable1);
733 if (newex != executable1)
735 *avhere = newex;
736 pid = win32_spawn (newex, FALSE, argv, env,
737 dwCreationFlags, si, pi);
738 free ((char *) newex);
742 #endif
743 free (avhere);
747 if (pid == (pid_t) -1)
748 errno = save_errno;
749 return pid;
752 /* Execute a child. */
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)
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);
774 /* Ensure we have inheritable descriptors to pass to the child. */
775 orig_in = in;
776 in = _dup (orig_in);
778 orig_out = out;
779 out = _dup (orig_out);
781 if (separate_stderr)
783 orig_err = errdes;
784 errdes = _dup (orig_err);
787 stdin_handle = INVALID_HANDLE_VALUE;
788 stdout_handle = INVALID_HANDLE_VALUE;
789 stderr_handle = INVALID_HANDLE_VALUE;
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;
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
807 HANDLE conout_handle;
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
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;
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;
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)
858 *err = ENOENT;
859 *errmsg = "CreateProcess";
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. */
867 if (pid != (pid_t) -1)
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);
878 /* Close the standard input, standard output and standard error handles
879 in the parent. */
881 _close (in);
882 _close (out);
883 if (separate_stderr)
884 _close (errdes);
886 return pid;
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. */
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)
902 DWORD termstat;
903 HANDLE h;
905 if (time != NULL)
906 memset (time, 0, sizeof *time);
908 h = (HANDLE) pid;
910 /* FIXME: If done is non-zero, we should probably try to kill the
911 process. */
912 if (WaitForSingleObject (h, INFINITE) != WAIT_OBJECT_0)
914 CloseHandle (h);
915 *err = ECHILD;
916 *errmsg = "WaitForSingleObject";
917 return -1;
920 GetExitCodeProcess (h, &termstat);
921 CloseHandle (h);
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;
931 return 0;
934 /* Create a pipe. */
936 static int
937 pex_win32_pipe (struct pex_obj *obj ATTRIBUTE_UNUSED, int *p,
938 int binary)
940 return _pipe (p, 256, (binary ? _O_BINARY : _O_TEXT) | _O_NOINHERIT);
943 /* Get a FILE pointer to read from a file descriptor. */
945 static FILE *
946 pex_win32_fdopenr (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd,
947 int binary)
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");
957 static FILE *
958 pex_win32_fdopenw (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd,
959 int binary)
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");
969 #ifdef MAIN
970 #include <stdio.h>
973 main (int argc ATTRIBUTE_UNUSED, char **argv)
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);
981 #endif