Commit | Line | Data |
---|---|---|
5a17353c DD |
1 | /* Utilities to execute a program in a subprocess (possibly linked by pipes |
2 | with other subprocesses), and wait for it. Generic MSDOS specialization. | |
b109e79a | 3 | Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2005 |
5a17353c DD |
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, | |
979c05d3 NC |
19 | write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor, |
20 | Boston, MA 02110-1301, USA. */ | |
5a17353c DD |
21 | |
22 | #include "pex-common.h" | |
23 | ||
24 | #include <stdio.h> | |
25 | #include <errno.h> | |
26 | #ifdef NEED_DECLARATION_ERRNO | |
27 | extern int errno; | |
28 | #endif | |
29 | #ifdef HAVE_STRING_H | |
30 | #include <string.h> | |
31 | #endif | |
32 | #ifdef HAVE_STDLIB_H | |
33 | #include <stdlib.h> | |
34 | #endif | |
35 | ||
36 | #include "safe-ctype.h" | |
37 | #include <process.h> | |
38 | ||
b109e79a | 39 | /* The structure we keep in obj->sysdep. */ |
5a17353c | 40 | |
b109e79a | 41 | #define PEX_MSDOS_FILE_COUNT 3 |
5a17353c | 42 | |
b109e79a ILT |
43 | #define PEX_MSDOS_FD_OFFSET 10 |
44 | ||
45 | struct pex_msdos | |
5a17353c | 46 | { |
b109e79a ILT |
47 | /* An array of file names. We refer to these using file descriptors |
48 | of 10 + array index. */ | |
49 | const char *files[PEX_MSDOS_FILE_COUNT]; | |
50 | /* Exit statuses of programs which have been run. */ | |
51 | int *statuses; | |
52 | }; | |
53 | ||
54 | static int pex_msdos_open (struct pex_obj *, const char *, int); | |
55 | static int pex_msdos_open (struct pex_obj *, const char *, int); | |
56 | static int pex_msdos_fdindex (struct pex_msdos *, int); | |
57 | static long pex_msdos_exec_child (struct pex_obj *, int, const char *, | |
58 | char * const *, int, int, int, | |
59 | const char **, int *); | |
60 | static int pex_msdos_close (struct pex_obj *, int); | |
61 | static int pex_msdos_wait (struct pex_obj *, long, int *, struct pex_time *, | |
62 | int, const char **, int *); | |
63 | static void pex_msdos_cleanup (struct pex_obj *); | |
64 | ||
65 | /* The list of functions we pass to the common routines. */ | |
66 | ||
67 | const struct pex_funcs funcs = | |
68 | { | |
69 | pex_msdos_open, | |
70 | pex_msdos_open, | |
71 | pex_msdos_exec_child, | |
72 | pex_msdos_close, | |
73 | pex_msdos_wait, | |
74 | NULL, /* pipe */ | |
75 | NULL, /* fdopenr */ | |
76 | pex_msdos_cleanup | |
77 | }; | |
78 | ||
79 | /* Return a newly initialized pex_obj structure. */ | |
80 | ||
81 | struct pex_obj * | |
82 | pex_init (int flags, const char *pname, const char *tempbase) | |
83 | { | |
84 | struct pex_obj *ret; | |
85 | int i; | |
86 | ||
87 | /* MSDOS does not support pipes. */ | |
88 | flags &= ~ PEX_USE_PIPES; | |
5a17353c | 89 | |
b109e79a | 90 | ret = pex_init_common (flags, pname, tempbase, funcs); |
5a17353c | 91 | |
abf6a75b | 92 | ret->sysdep = XNEW (struct pex_msdos); |
b109e79a ILT |
93 | for (i = 0; i < PEX_MSDOS_FILE_COUNT; ++i) |
94 | ret->files[i] = NULL; | |
95 | ret->statuses = NULL; | |
96 | ||
97 | return ret; | |
98 | } | |
99 | ||
100 | /* Open a file. FIXME: We ignore the binary argument, since we have | |
101 | no way to handle it. */ | |
102 | ||
103 | static int | |
104 | pex_msdos_open (struct pex_obj *obj, const char *name, | |
105 | int binary ATTRIBUTE_UNUSED) | |
106 | { | |
107 | struct pex_msdos *ms; | |
108 | int i; | |
109 | ||
110 | ms = (struct pex_msdos *) obj->sysdep; | |
111 | ||
112 | for (i = 0; i < PEX_MSDOS_FILE_COUNT; ++i) | |
113 | { | |
114 | if (ms->files[i] == NULL) | |
115 | { | |
116 | ms->files[i] = xstrdup (name); | |
117 | return i + PEX_MSDOS_FD_OFFSET; | |
118 | } | |
119 | } | |
120 | ||
121 | abort (); | |
122 | } | |
123 | ||
124 | /* Get the index into msdos->files associated with an open file | |
125 | descriptor. */ | |
126 | ||
127 | static int | |
128 | pex_msdos_fdindex (struct pex_msdos *ms, int fd) | |
129 | { | |
130 | fd -= PEX_MSDOS_FD_OFFSET; | |
131 | if (fd < 0 || fd >= PEX_MSDOS_FILE_COUNT || ms->files[fd] == NULL) | |
5a17353c | 132 | abort (); |
b109e79a ILT |
133 | return fd; |
134 | } | |
135 | ||
136 | ||
137 | /* Close a file. */ | |
138 | ||
139 | static int | |
140 | pex_msdos_close (struct pex_obj *obj, int fd) | |
141 | { | |
142 | struct pex_msdos *ms; | |
143 | int fdinex; | |
144 | ||
145 | ms = (struct pex_msdos *) obj->sysdep; | |
146 | fdindex = pe_msdos_fdindex (ms, fd); | |
147 | free (ms->files[fdindex]); | |
148 | ms->files[fdindex] = NULL; | |
149 | } | |
150 | ||
151 | /* Execute a child. */ | |
152 | ||
153 | static long | |
154 | pex_msdos_exec_child (struct pex_obj *obj, int flags, const char *executable, | |
155 | char * const * argv, int in, int out, | |
156 | int errdes ATTRIBUTE_UNUSED, const char **errmsg, | |
157 | int *err) | |
158 | { | |
159 | struct pex_msdos *ms; | |
160 | char *temp_base; | |
161 | int temp_base_allocated; | |
162 | char *rf; | |
163 | int inindex; | |
164 | char *infile; | |
165 | int outindex; | |
166 | char *outfile; | |
167 | char *scmd; | |
168 | FILE *argfile; | |
169 | int i; | |
170 | int status; | |
171 | ||
172 | ms = (struct pex_msdos *) obj->sysdep; | |
173 | ||
174 | /* FIXME: I don't know how to redirect stderr, so we ignore ERRDES | |
175 | and PEX_STDERR_TO_STDOUT. */ | |
176 | ||
177 | temp_base = obj->temp_base; | |
178 | if (temp_base != NULL) | |
179 | temp_base_allocated = 0; | |
180 | else | |
181 | { | |
182 | temp_base = choose_temp_base (); | |
183 | temp_base_allocated = 1; | |
184 | } | |
185 | ||
186 | rf = concat (temp_base, ".gp", NULL); | |
187 | ||
188 | if (temp_base_allocated) | |
189 | free (temp_base); | |
190 | ||
191 | if (in == STDIN_FILE_NO) | |
192 | { | |
193 | inindex = -1; | |
194 | infile = ""; | |
195 | } | |
196 | else | |
197 | { | |
198 | inindex = pex_msdos_fdindex (ms, in); | |
199 | infile = ms->files[inindex]; | |
200 | } | |
201 | ||
202 | if (out == STDOUT_FILE_NO) | |
203 | { | |
204 | outindex = -1; | |
205 | outfile = ""; | |
206 | } | |
207 | else | |
208 | { | |
209 | outindex = pex_msdos_fdindex (ms, out); | |
210 | outfile = ms->files[outindex]; | |
211 | } | |
212 | ||
abf6a75b | 213 | scmd = XNEWVEC (char, strlen (program) |
b109e79a ILT |
214 | + ((flags & PEXECUTE_SEARCH) != 0 ? 4 : 0) |
215 | + strlen (rf) | |
216 | + strlen (infile) | |
217 | + strlen (outfile) | |
218 | + 10); | |
219 | sprintf (scmd, "%s%s @%s%s%s%s%s", | |
220 | program, | |
221 | (flags & PEXECUTE_SEARCH) != 0 ? ".exe" : "", | |
222 | rf, | |
223 | inindex != -1 ? " <" : "", | |
224 | infile, | |
225 | outindex != -1 ? " >" : "", | |
226 | outfile); | |
5a17353c | 227 | |
5a17353c | 228 | argfile = fopen (rf, "w"); |
b109e79a | 229 | if (argfile == NULL) |
5a17353c | 230 | { |
b109e79a | 231 | *err = errno; |
5a17353c | 232 | free (scmd); |
b109e79a ILT |
233 | free (rf); |
234 | *errmsg = "cannot open temporary command file"; | |
5a17353c DD |
235 | return -1; |
236 | } | |
237 | ||
b109e79a | 238 | for (i = 1; argv[i] != NULL; ++i) |
5a17353c | 239 | { |
b109e79a ILT |
240 | char *p; |
241 | ||
242 | for (p = argv[i]; *p != '\0'; ++p) | |
5a17353c | 243 | { |
b109e79a ILT |
244 | if (*p == '"' || *p == '\'' || *p == '\\' || ISSPACE (*p)) |
245 | putc ('\\', argfile); | |
246 | putc (*p, argfile); | |
5a17353c | 247 | } |
b109e79a | 248 | putc ('\n', argfile); |
5a17353c | 249 | } |
5a17353c | 250 | |
b109e79a | 251 | fclose (argfile); |
5a17353c | 252 | |
b109e79a | 253 | status = system (scmd); |
5a17353c | 254 | |
b109e79a | 255 | if (status == -1) |
5a17353c | 256 | { |
b109e79a ILT |
257 | *err = errno; |
258 | remove (rf); | |
259 | free (scmd); | |
260 | free (rf); | |
261 | *errmsg = "system"; | |
5a17353c DD |
262 | return -1; |
263 | } | |
264 | ||
b109e79a ILT |
265 | remove (rf); |
266 | free (scmd); | |
267 | free (rf); | |
268 | ||
269 | /* Save the exit status for later. When we are called, obj->count | |
270 | is the number of children which have executed before this | |
271 | one. */ | |
abf6a75b | 272 | ms->statuses = XRESIZEVEC(int, ms->statuses, obj->count + 1); |
b109e79a ILT |
273 | ms->statuses[obj->count] = status; |
274 | ||
275 | return obj->count; | |
5a17353c DD |
276 | } |
277 | ||
b109e79a ILT |
278 | /* Wait for a child process to complete. Actually the child process |
279 | has already completed, and we just need to return the exit | |
280 | status. */ | |
5a17353c | 281 | |
b109e79a ILT |
282 | static int |
283 | pex_msdos_wait (struct pex_obj *obj, long pid, int *status, | |
284 | struct pex_time *time, int done ATTRIBUTE_UNUSED, | |
285 | const char **errmsg ATTRIBUTE_UNUSED, | |
286 | int *err ATTRIBUTE_UNUSED) | |
5a17353c | 287 | { |
b109e79a ILT |
288 | struct pex_msdos *ms; |
289 | ||
290 | ms = (struct pex_msdos *) obj->sysdep; | |
291 | ||
292 | if (time != NULL) | |
293 | memset (time, 0, sizeof *time); | |
294 | ||
295 | *status = ms->statuses[pid]; | |
296 | ||
297 | return 0; | |
298 | } | |
299 | ||
300 | /* Clean up the pex_msdos structure. */ | |
301 | ||
302 | static void | |
303 | pex_msdos_cleanup (struct pex_obj *obj) | |
304 | { | |
305 | struct pex_msdos *ms; | |
306 | int i; | |
307 | ||
308 | ms = (struct pex_msdos *) obj->sysdep; | |
309 | for (i = 0; i < PEX_MSDOS_FILE_COUNT; ++i) | |
310 | if (msdos->files[i] != NULL) | |
311 | free (msdos->files[i]); | |
312 | if (msdos->statuses != NULL) | |
313 | free (msdos->statuses); | |
314 | free (msdos); | |
315 | obj->sysdep = NULL; | |
5a17353c | 316 | } |