merge from gcc
[external/binutils.git] / libiberty / pex-win32.c
1 /* Utilities to execute a program in a subprocess (possibly linked by pipes
2    with other subprocesses), and wait for it.  Generic Win32 specialization.
3    Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003
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., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA.  */
21
22 #include "pex-common.h"
23
24 #ifdef HAVE_STRING_H
25 #include <string.h>
26 #endif
27 #ifdef HAVE_UNISTD_H
28 #include <unistd.h>
29 #endif
30 #ifdef HAVE_SYS_WAIT_H
31 #include <sys/wait.h>
32 #endif
33
34 #include <process.h>
35 #include <io.h>
36 #include <fcntl.h>
37 #include <signal.h>
38
39 /* mingw32 headers may not define the following.  */
40
41 #ifndef _P_WAIT
42 #  define _P_WAIT       0
43 #  define _P_NOWAIT     1
44 #  define _P_OVERLAY    2
45 #  define _P_NOWAITO    3
46 #  define _P_DETACH     4
47
48 #  define WAIT_CHILD            0
49 #  define WAIT_GRANDCHILD       1
50 #endif
51
52 /* This is a kludge to get around the Microsoft C spawn functions' propensity
53    to remove the outermost set of double quotes from all arguments.  */
54
55 static const char * const *
56 fix_argv (argvec)
57      char **argvec;
58 {
59   int i;
60
61   for (i = 1; argvec[i] != 0; i++)
62     {
63       int len, j;
64       char *temp, *newtemp;
65
66       temp = argvec[i];
67       len = strlen (temp);
68       for (j = 0; j < len; j++)
69         {
70           if (temp[j] == '"')
71             {
72               newtemp = xmalloc (len + 2);
73               strncpy (newtemp, temp, j);
74               newtemp [j] = '\\';
75               strncpy (&newtemp [j+1], &temp [j], len-j);
76               newtemp [len+1] = 0;
77               temp = newtemp;
78               len++;
79               j++;
80             }
81         }
82
83         argvec[i] = temp;
84       }
85
86   for (i = 0; argvec[i] != 0; i++)
87     {
88       if (strpbrk (argvec[i], " \t"))
89         {
90           int len, trailing_backslash;
91           char *temp;
92
93           len = strlen (argvec[i]);
94           trailing_backslash = 0;
95
96           /* There is an added complication when an arg with embedded white
97              space ends in a backslash (such as in the case of -iprefix arg
98              passed to cpp). The resulting quoted strings gets misinterpreted
99              by the command interpreter -- it thinks that the ending quote
100              is escaped by the trailing backslash and things get confused. 
101              We handle this case by escaping the trailing backslash, provided
102              it was not escaped in the first place.  */
103           if (len > 1 
104               && argvec[i][len-1] == '\\' 
105               && argvec[i][len-2] != '\\')
106             {
107               trailing_backslash = 1;
108               ++len;                    /* to escape the final backslash. */
109             }
110
111           len += 2;                     /* and for the enclosing quotes. */
112
113           temp = xmalloc (len + 1);
114           temp[0] = '"';
115           strcpy (temp + 1, argvec[i]);
116           if (trailing_backslash)
117             temp[len-2] = '\\';
118           temp[len-1] = '"';
119           temp[len] = '\0';
120
121           argvec[i] = temp;
122         }
123     }
124
125   return (const char * const *) argvec;
126 }
127
128 /* Win32 supports pipes */
129 int
130 pexecute (program, argv, this_pname, temp_base, errmsg_fmt, errmsg_arg, flags)
131      const char *program;
132      char * const *argv;
133      const char *this_pname;
134      const char *temp_base;
135      char **errmsg_fmt, **errmsg_arg;
136      int flags;
137 {
138   int pid;
139   int pdes[2], org_stdin, org_stdout;
140   int input_desc, output_desc;
141   int retries, sleep_interval;
142
143   /* Pipe waiting from last process, to be used as input for the next one.
144      Value is STDIN_FILE_NO if no pipe is waiting
145      (i.e. the next command is the first of a group).  */
146   static int last_pipe_input;
147
148   /* If this is the first process, initialize.  */
149   if (flags & PEXECUTE_FIRST)
150     last_pipe_input = STDIN_FILE_NO;
151
152   input_desc = last_pipe_input;
153
154   /* If this isn't the last process, make a pipe for its output,
155      and record it as waiting to be the input to the next process.  */
156   if (! (flags & PEXECUTE_LAST))
157     {
158       if (_pipe (pdes, 256, O_BINARY) < 0)
159         {
160           *errmsg_fmt = "pipe";
161           *errmsg_arg = NULL;
162           return -1;
163         }
164       output_desc = pdes[WRITE_PORT];
165       last_pipe_input = pdes[READ_PORT];
166     }
167   else
168     {
169       /* Last process.  */
170       output_desc = STDOUT_FILE_NO;
171       last_pipe_input = STDIN_FILE_NO;
172     }
173
174   if (input_desc != STDIN_FILE_NO)
175     {
176       org_stdin = dup (STDIN_FILE_NO);
177       dup2 (input_desc, STDIN_FILE_NO);
178       close (input_desc); 
179     }
180
181   if (output_desc != STDOUT_FILE_NO)
182     {
183       org_stdout = dup (STDOUT_FILE_NO);
184       dup2 (output_desc, STDOUT_FILE_NO);
185       close (output_desc);
186     }
187
188   pid = (flags & PEXECUTE_SEARCH ? _spawnvp : _spawnv)
189     (_P_NOWAIT, program, fix_argv(argv));
190
191   if (input_desc != STDIN_FILE_NO)
192     {
193       dup2 (org_stdin, STDIN_FILE_NO);
194       close (org_stdin);
195     }
196
197   if (output_desc != STDOUT_FILE_NO)
198     {
199       dup2 (org_stdout, STDOUT_FILE_NO);
200       close (org_stdout);
201     }
202
203   if (pid == -1)
204     {
205       *errmsg_fmt = install_error_msg;
206       *errmsg_arg = program;
207       return -1;
208     }
209
210   return pid;
211 }
212
213 /* MS CRTDLL doesn't return enough information in status to decide if the
214    child exited due to a signal or not, rather it simply returns an
215    integer with the exit code of the child; eg., if the child exited with 
216    an abort() call and didn't have a handler for SIGABRT, it simply returns
217    with status = 3. We fix the status code to conform to the usual WIF*
218    macros. Note that WIFSIGNALED will never be true under CRTDLL. */
219
220 int
221 pwait (pid, status, flags)
222      int pid;
223      int *status;
224      int flags;
225 {
226   int termstat;
227
228   pid = _cwait (&termstat, pid, WAIT_CHILD);
229
230   /* ??? Here's an opportunity to canonicalize the values in STATUS.
231      Needed?  */
232
233   /* cwait returns the child process exit code in termstat.
234      A value of 3 indicates that the child caught a signal, but not
235      which one.  Since only SIGABRT, SIGFPE and SIGINT do anything, we
236      report SIGABRT.  */
237   if (termstat == 3)
238     *status = SIGABRT;
239   else
240     *status = (((termstat) & 0xff) << 8);
241
242   return pid;
243 }