1 /* Process handling for Windows.
2 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3 2006 Free Software Foundation, Inc.
4 This file is part of GNU Make.
5
6 GNU Make is free software; you can redistribute it and/or modify it under the
7 terms of the GNU General Public License as published by the Free Software
8 Foundation; either version 2, or (at your option) any later version.
9
10 GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
11 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
12 A PARTICULAR PURPOSE. See the GNU General Public License for more details.
13
14 You should have received a copy of the GNU General Public License along with
15 GNU Make; see the file COPYING. If not, write to the Free Software
16 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. */
17
18 #include <stdlib.h>
19 #include <stdio.h>
20 #include <process.h> /* for msvc _beginthreadex, _endthreadex */
21 #include <signal.h>
22 #include <windows.h>
23
24 #include "sub_proc.h"
25 #include "proc.h"
26 #include "w32err.h"
27 #include "config.h"
28 #include "debug.h"
29
30 static char *make_command_line(char *shell_name, char *exec_path, char **argv);
31
32 typedef struct sub_process_t {
33 intptr_t sv_stdin[2];
34 intptr_t sv_stdout[2];
35 intptr_t sv_stderr[2];
36 int using_pipes;
37 char *inp;
38 DWORD incnt;
39 char * volatile outp;
40 volatile DWORD outcnt;
41 char * volatile errp;
42 volatile DWORD errcnt;
43 intptr_t pid;
44 int exit_code;
45 int signal;
46 long last_err;
47 long lerrno;
48 } sub_process;
49
50 /* keep track of children so we can implement a waitpid-like routine */
51 static sub_process *proc_array[MAXIMUM_WAIT_OBJECTS];
52 static int proc_index = 0;
53 static int fake_exits_pending = 0;
54
55 /*
56 * When a process has been waited for, adjust the wait state
57 * array so that we don't wait for it again
58 */
59 static void
process_adjust_wait_state(sub_process * pproc)60 process_adjust_wait_state(sub_process* pproc)
61 {
62 int i;
63
64 if (!proc_index)
65 return;
66
67 for (i = 0; i < proc_index; i++)
68 if (proc_array[i]->pid == pproc->pid)
69 break;
70
71 if (i < proc_index) {
72 proc_index--;
73 if (i != proc_index)
74 memmove(&proc_array[i], &proc_array[i+1],
75 (proc_index-i) * sizeof(sub_process*));
76 proc_array[proc_index] = NULL;
77 }
78 }
79
80 /*
81 * Waits for any of the registered child processes to finish.
82 */
83 static sub_process *
process_wait_for_any_private(void)84 process_wait_for_any_private(void)
85 {
86 HANDLE handles[MAXIMUM_WAIT_OBJECTS];
87 DWORD retval, which;
88 int i;
89
90 if (!proc_index)
91 return NULL;
92
93 /* build array of handles to wait for */
94 for (i = 0; i < proc_index; i++) {
95 handles[i] = (HANDLE) proc_array[i]->pid;
96
97 if (fake_exits_pending && proc_array[i]->exit_code)
98 break;
99 }
100
101 /* wait for someone to exit */
102 if (!fake_exits_pending) {
103 retval = WaitForMultipleObjects(proc_index, handles, FALSE, INFINITE);
104 which = retval - WAIT_OBJECT_0;
105 } else {
106 fake_exits_pending--;
107 retval = !WAIT_FAILED;
108 which = i;
109 }
110
111 /* return pointer to process */
112 if (retval != WAIT_FAILED) {
113 sub_process* pproc = proc_array[which];
114 process_adjust_wait_state(pproc);
115 return pproc;
116 } else
117 return NULL;
118 }
119
120 /*
121 * Terminate a process.
122 */
123 BOOL
process_kill(HANDLE proc,int signal)124 process_kill(HANDLE proc, int signal)
125 {
126 sub_process* pproc = (sub_process*) proc;
127 pproc->signal = signal;
128 return (TerminateProcess((HANDLE) pproc->pid, signal));
129 }
130
131 /*
132 * Use this function to register processes you wish to wait for by
133 * calling process_file_io(NULL) or process_wait_any(). This must be done
134 * because it is possible for callers of this library to reuse the same
135 * handle for multiple processes launches :-(
136 */
137 void
process_register(HANDLE proc)138 process_register(HANDLE proc)
139 {
140 if (proc_index < MAXIMUM_WAIT_OBJECTS)
141 proc_array[proc_index++] = (sub_process *) proc;
142 }
143
144 /*
145 * Return the number of processes that we are still waiting for.
146 */
147 int
process_used_slots(void)148 process_used_slots(void)
149 {
150 return proc_index;
151 }
152
153 /*
154 * Public function which works kind of like waitpid(). Wait for any
155 * of the children to die and return results. To call this function,
156 * you must do 1 of things:
157 *
158 * x = process_easy(...);
159 *
160 * or
161 *
162 * x = process_init_fd();
163 * process_register(x);
164 *
165 * or
166 *
167 * x = process_init();
168 * process_register(x);
169 *
170 * You must NOT then call process_pipe_io() because this function is
171 * not capable of handling automatic notification of any child
172 * death.
173 */
174
175 HANDLE
process_wait_for_any(void)176 process_wait_for_any(void)
177 {
178 sub_process* pproc = process_wait_for_any_private();
179
180 if (!pproc)
181 return NULL;
182 else {
183 /*
184 * Ouch! can't tell caller if this fails directly. Caller
185 * will have to use process_last_err()
186 */
187 (void) process_file_io(pproc);
188 return ((HANDLE) pproc);
189 }
190 }
191
192 long
process_signal(HANDLE proc)193 process_signal(HANDLE proc)
194 {
195 if (proc == INVALID_HANDLE_VALUE) return 0;
196 return (((sub_process *)proc)->signal);
197 }
198
199 long
process_last_err(HANDLE proc)200 process_last_err(HANDLE proc)
201 {
202 if (proc == INVALID_HANDLE_VALUE) return ERROR_INVALID_HANDLE;
203 return (((sub_process *)proc)->last_err);
204 }
205
206 long
process_exit_code(HANDLE proc)207 process_exit_code(HANDLE proc)
208 {
209 if (proc == INVALID_HANDLE_VALUE) return EXIT_FAILURE;
210 return (((sub_process *)proc)->exit_code);
211 }
212
213 /*
214 2006-02:
215 All the following functions are currently unused.
216 All of them would crash gmake if called with argument INVALID_HANDLE_VALUE.
217 Hence whoever wants to use one of this functions must invent and implement
218 a reasonable error handling for this function.
219
220 char *
221 process_outbuf(HANDLE proc)
222 {
223 return (((sub_process *)proc)->outp);
224 }
225
226 char *
227 process_errbuf(HANDLE proc)
228 {
229 return (((sub_process *)proc)->errp);
230 }
231
232 int
233 process_outcnt(HANDLE proc)
234 {
235 return (((sub_process *)proc)->outcnt);
236 }
237
238 int
239 process_errcnt(HANDLE proc)
240 {
241 return (((sub_process *)proc)->errcnt);
242 }
243
244 void
245 process_pipes(HANDLE proc, int pipes[3])
246 {
247 pipes[0] = ((sub_process *)proc)->sv_stdin[0];
248 pipes[1] = ((sub_process *)proc)->sv_stdout[0];
249 pipes[2] = ((sub_process *)proc)->sv_stderr[0];
250 return;
251 }
252 */
253
254 HANDLE
process_init()255 process_init()
256 {
257 sub_process *pproc;
258 /*
259 * open file descriptors for attaching stdin/stdout/sterr
260 */
261 HANDLE stdin_pipes[2];
262 HANDLE stdout_pipes[2];
263 HANDLE stderr_pipes[2];
264 SECURITY_ATTRIBUTES inherit;
265 BYTE sd[SECURITY_DESCRIPTOR_MIN_LENGTH];
266
267 pproc = malloc(sizeof(*pproc));
268 memset(pproc, 0, sizeof(*pproc));
269
270 /* We can't use NULL for lpSecurityDescriptor because that
271 uses the default security descriptor of the calling process.
272 Instead we use a security descriptor with no DACL. This
273 allows nonrestricted access to the associated objects. */
274
275 if (!InitializeSecurityDescriptor((PSECURITY_DESCRIPTOR)(&sd),
276 SECURITY_DESCRIPTOR_REVISION)) {
277 pproc->last_err = GetLastError();
278 pproc->lerrno = E_SCALL;
279 return((HANDLE)pproc);
280 }
281
282 inherit.nLength = sizeof(inherit);
283 inherit.lpSecurityDescriptor = (PSECURITY_DESCRIPTOR)(&sd);
284 inherit.bInheritHandle = TRUE;
285
286 // By convention, parent gets pipe[0], and child gets pipe[1]
287 // This means the READ side of stdin pipe goes into pipe[1]
288 // and the WRITE side of the stdout and stderr pipes go into pipe[1]
289 if (CreatePipe( &stdin_pipes[1], &stdin_pipes[0], &inherit, 0) == FALSE ||
290 CreatePipe( &stdout_pipes[0], &stdout_pipes[1], &inherit, 0) == FALSE ||
291 CreatePipe( &stderr_pipes[0], &stderr_pipes[1], &inherit, 0) == FALSE) {
292
293 pproc->last_err = GetLastError();
294 pproc->lerrno = E_SCALL;
295 return((HANDLE)pproc);
296 }
297
298 //
299 // Mark the parent sides of the pipes as non-inheritable
300 //
301 if (SetHandleInformation(stdin_pipes[0],
302 HANDLE_FLAG_INHERIT, 0) == FALSE ||
303 SetHandleInformation(stdout_pipes[0],
304 HANDLE_FLAG_INHERIT, 0) == FALSE ||
305 SetHandleInformation(stderr_pipes[0],
306 HANDLE_FLAG_INHERIT, 0) == FALSE) {
307
308 pproc->last_err = GetLastError();
309 pproc->lerrno = E_SCALL;
310 return((HANDLE)pproc);
311 }
312 pproc->sv_stdin[0] = (intptr_t) stdin_pipes[0];
313 pproc->sv_stdin[1] = (intptr_t) stdin_pipes[1];
314 pproc->sv_stdout[0] = (intptr_t) stdout_pipes[0];
315 pproc->sv_stdout[1] = (intptr_t) stdout_pipes[1];
316 pproc->sv_stderr[0] = (intptr_t) stderr_pipes[0];
317 pproc->sv_stderr[1] = (intptr_t) stderr_pipes[1];
318
319 pproc->using_pipes = 1;
320
321 pproc->lerrno = 0;
322
323 return((HANDLE)pproc);
324 }
325
326
327 HANDLE
process_init_fd(HANDLE stdinh,HANDLE stdouth,HANDLE stderrh)328 process_init_fd(HANDLE stdinh, HANDLE stdouth, HANDLE stderrh)
329 {
330 sub_process *pproc;
331
332 pproc = malloc(sizeof(*pproc));
333 memset(pproc, 0, sizeof(*pproc));
334
335 /*
336 * Just pass the provided file handles to the 'child side' of the
337 * pipe, bypassing pipes altogether.
338 */
339 pproc->sv_stdin[1] = (intptr_t) stdinh;
340 pproc->sv_stdout[1] = (intptr_t) stdouth;
341 pproc->sv_stderr[1] = (intptr_t) stderrh;
342
343 pproc->last_err = pproc->lerrno = 0;
344
345 return((HANDLE)pproc);
346 }
347
348
349 static HANDLE
find_file(char * exec_path,LPOFSTRUCT file_info)350 find_file(char *exec_path, LPOFSTRUCT file_info)
351 {
352 HANDLE exec_handle;
353 char *fname;
354 char *ext;
355
356 fname = malloc(strlen(exec_path) + 5);
357 strcpy(fname, exec_path);
358 ext = fname + strlen(fname);
359
360 strcpy(ext, ".exe");
361 if ((exec_handle = (HANDLE)(intptr_t)OpenFile(fname, file_info,
362 OF_READ | OF_SHARE_COMPAT)) != (HANDLE)HFILE_ERROR) {
363 free(fname);
364 return(exec_handle);
365 }
366
367 strcpy(ext, ".cmd");
368 if ((exec_handle = (HANDLE)(intptr_t)OpenFile(fname, file_info,
369 OF_READ | OF_SHARE_COMPAT)) != (HANDLE)HFILE_ERROR) {
370 free(fname);
371 return(exec_handle);
372 }
373
374 strcpy(ext, ".bat");
375 if ((exec_handle = (HANDLE)(intptr_t)OpenFile(fname, file_info,
376 OF_READ | OF_SHARE_COMPAT)) != (HANDLE)HFILE_ERROR) {
377 free(fname);
378 return(exec_handle);
379 }
380
381 /* should .com come before this case? */
382 if ((exec_handle = (HANDLE)(intptr_t)OpenFile(exec_path, file_info,
383 OF_READ | OF_SHARE_COMPAT)) != (HANDLE)HFILE_ERROR) {
384 free(fname);
385 return(exec_handle);
386 }
387
388 strcpy(ext, ".com");
389 if ((exec_handle = (HANDLE)(intptr_t)OpenFile(fname, file_info,
390 OF_READ | OF_SHARE_COMPAT)) != (HANDLE)HFILE_ERROR) {
391 free(fname);
392 return(exec_handle);
393 }
394
395 free(fname);
396 return(exec_handle);
397 }
398
399
400 /*
401 * Description: Create the child process to be helped
402 *
403 * Returns: success <=> 0
404 *
405 * Notes/Dependencies:
406 */
407 long
process_begin(HANDLE proc,char ** argv,char ** envp,char * exec_path,char * as_user)408 process_begin(
409 HANDLE proc,
410 char **argv,
411 char **envp,
412 char *exec_path,
413 char *as_user)
414 {
415 sub_process *pproc = (sub_process *)proc;
416 char *shell_name = 0;
417 int file_not_found=0;
418 HANDLE exec_handle;
419 char buf[256];
420 DWORD bytes_returned;
421 DWORD flags;
422 char *command_line;
423 STARTUPINFO startInfo;
424 PROCESS_INFORMATION procInfo;
425 char *envblk=NULL;
426 OFSTRUCT file_info;
427
428
429 /*
430 * Shell script detection... if the exec_path starts with #! then
431 * we want to exec shell-script-name exec-path, not just exec-path
432 * NT doesn't recognize #!/bin/sh or #!/etc/Tivoli/bin/perl. We do not
433 * hard-code the path to the shell or perl or whatever: Instead, we
434 * assume it's in the path somewhere (generally, the NT tools
435 * bin directory)
436 * We use OpenFile here because it is capable of searching the Path.
437 */
438
439 exec_handle = find_file(exec_path, &file_info);
440
441 /*
442 * If we couldn't open the file, just assume that Windows32 will be able
443 * to find and execute it.
444 */
445 if (exec_handle == (HANDLE)HFILE_ERROR) {
446 file_not_found++;
447 }
448 else {
449 /* Attempt to read the first line of the file */
450 if (ReadFile( exec_handle,
451 buf, sizeof(buf) - 1, /* leave room for trailing NULL */
452 &bytes_returned, 0) == FALSE || bytes_returned < 2) {
453
454 pproc->last_err = GetLastError();
455 pproc->lerrno = E_IO;
456 CloseHandle(exec_handle);
457 return(-1);
458 }
459 if (buf[0] == '#' && buf[1] == '!') {
460 /*
461 * This is a shell script... Change the command line from
462 * exec_path args to shell_name exec_path args
463 */
464 char *p;
465
466 /* Make sure buf is NULL terminated */
467 buf[bytes_returned] = 0;
468 /*
469 * Depending on the file system type, etc. the first line
470 * of the shell script may end with newline or newline-carriage-return
471 * Whatever it ends with, cut it off.
472 */
473 p= strchr(buf, '\n');
474 if (p)
475 *p = 0;
476 p = strchr(buf, '\r');
477 if (p)
478 *p = 0;
479
480 /*
481 * Find base name of shell
482 */
483 shell_name = strrchr( buf, '/');
484 if (shell_name) {
485 shell_name++;
486 } else {
487 shell_name = &buf[2];/* skipping "#!" */
488 }
489
490 }
491 CloseHandle(exec_handle);
492 }
493
494 flags = 0;
495
496 if (file_not_found)
497 command_line = make_command_line( shell_name, exec_path, argv);
498 else
499 command_line = make_command_line( shell_name, file_info.szPathName,
500 argv);
501
502 if ( command_line == NULL ) {
503 pproc->last_err = 0;
504 pproc->lerrno = E_NO_MEM;
505 return(-1);
506 }
507
508 if (envp) {
509 if (arr2envblk(envp, &envblk) ==FALSE) {
510 pproc->last_err = 0;
511 pproc->lerrno = E_NO_MEM;
512 free( command_line );
513 return(-1);
514 }
515 }
516
517 if ((shell_name) || (file_not_found)) {
518 exec_path = 0; /* Search for the program in %Path% */
519 } else {
520 exec_path = file_info.szPathName;
521 }
522
523 /*
524 * Set up inherited stdin, stdout, stderr for child
525 */
526 GetStartupInfo(&startInfo);
527 startInfo.dwFlags = STARTF_USESTDHANDLES;
528 startInfo.lpReserved = 0;
529 startInfo.cbReserved2 = 0;
530 startInfo.lpReserved2 = 0;
531 startInfo.lpTitle = shell_name ? shell_name : exec_path;
532 startInfo.hStdInput = (HANDLE)pproc->sv_stdin[1];
533 startInfo.hStdOutput = (HANDLE)pproc->sv_stdout[1];
534 startInfo.hStdError = (HANDLE)pproc->sv_stderr[1];
535
536 if (as_user) {
537 if (envblk) free(envblk);
538 return -1;
539 } else {
540 DB (DB_JOBS, ("CreateProcess(%s,%s,...)\n",
541 exec_path ? exec_path : "NULL",
542 command_line ? command_line : "NULL"));
543 if (CreateProcess(
544 exec_path,
545 command_line,
546 NULL,
547 0, /* default security attributes for thread */
548 TRUE, /* inherit handles (e.g. helper pipes, oserv socket) */
549 flags,
550 envblk,
551 0, /* default starting directory */
552 &startInfo,
553 &procInfo) == FALSE) {
554
555 pproc->last_err = GetLastError();
556 pproc->lerrno = E_FORK;
557 fprintf(stderr, "process_begin: CreateProcess(%s, %s, ...) failed.\n",
558 exec_path ? exec_path : "NULL", command_line);
559 if (envblk) free(envblk);
560 free( command_line );
561 return(-1);
562 }
563 }
564
565 pproc->pid = (intptr_t)procInfo.hProcess;
566 /* Close the thread handle -- we'll just watch the process */
567 CloseHandle(procInfo.hThread);
568
569 /* Close the halves of the pipes we don't need */
570 CloseHandle((HANDLE)pproc->sv_stdin[1]);
571 CloseHandle((HANDLE)pproc->sv_stdout[1]);
572 CloseHandle((HANDLE)pproc->sv_stderr[1]);
573 pproc->sv_stdin[1] = 0;
574 pproc->sv_stdout[1] = 0;
575 pproc->sv_stderr[1] = 0;
576
577 free( command_line );
578 if (envblk) free(envblk);
579 pproc->lerrno=0;
580 return 0;
581 }
582
583
584
585 static DWORD
proc_stdin_thread(sub_process * pproc)586 proc_stdin_thread(sub_process *pproc)
587 {
588 DWORD in_done;
589 for (;;) {
590 if (WriteFile( (HANDLE) pproc->sv_stdin[0], pproc->inp, pproc->incnt,
591 &in_done, NULL) == FALSE)
592 _endthreadex(0);
593 // This if should never be true for anonymous pipes, but gives
594 // us a chance to change I/O mechanisms later
595 if (in_done < pproc->incnt) {
596 pproc->incnt -= in_done;
597 pproc->inp += in_done;
598 } else {
599 _endthreadex(0);
600 }
601 }
602 return 0; // for compiler warnings only.. not reached
603 }
604
605 static DWORD
proc_stdout_thread(sub_process * pproc)606 proc_stdout_thread(sub_process *pproc)
607 {
608 DWORD bufsize = 1024;
609 char c;
610 DWORD nread;
611 pproc->outp = malloc(bufsize);
612 if (pproc->outp == NULL)
613 _endthreadex(0);
614 pproc->outcnt = 0;
615
616 for (;;) {
617 if (ReadFile( (HANDLE)pproc->sv_stdout[0], &c, 1, &nread, NULL)
618 == FALSE) {
619 /* map_windows32_error_to_string(GetLastError());*/
620 _endthreadex(0);
621 }
622 if (nread == 0)
623 _endthreadex(0);
624 if (pproc->outcnt + nread > bufsize) {
625 bufsize += nread + 512;
626 pproc->outp = realloc(pproc->outp, bufsize);
627 if (pproc->outp == NULL) {
628 pproc->outcnt = 0;
629 _endthreadex(0);
630 }
631 }
632 pproc->outp[pproc->outcnt++] = c;
633 }
634 return 0;
635 }
636
637 static DWORD
proc_stderr_thread(sub_process * pproc)638 proc_stderr_thread(sub_process *pproc)
639 {
640 DWORD bufsize = 1024;
641 char c;
642 DWORD nread;
643 pproc->errp = malloc(bufsize);
644 if (pproc->errp == NULL)
645 _endthreadex(0);
646 pproc->errcnt = 0;
647
648 for (;;) {
649 if (ReadFile( (HANDLE)pproc->sv_stderr[0], &c, 1, &nread, NULL) == FALSE) {
650 map_windows32_error_to_string(GetLastError());
651 _endthreadex(0);
652 }
653 if (nread == 0)
654 _endthreadex(0);
655 if (pproc->errcnt + nread > bufsize) {
656 bufsize += nread + 512;
657 pproc->errp = realloc(pproc->errp, bufsize);
658 if (pproc->errp == NULL) {
659 pproc->errcnt = 0;
660 _endthreadex(0);
661 }
662 }
663 pproc->errp[pproc->errcnt++] = c;
664 }
665 return 0;
666 }
667
668
669 /*
670 * Purpose: collects output from child process and returns results
671 *
672 * Description:
673 *
674 * Returns:
675 *
676 * Notes/Dependencies:
677 */
678 long
process_pipe_io(HANDLE proc,char * stdin_data,int stdin_data_len)679 process_pipe_io(
680 HANDLE proc,
681 char *stdin_data,
682 int stdin_data_len)
683 {
684 sub_process *pproc = (sub_process *)proc;
685 bool_t stdin_eof = FALSE, stdout_eof = FALSE, stderr_eof = FALSE;
686 HANDLE childhand = (HANDLE) pproc->pid;
687 HANDLE tStdin = NULL, tStdout = NULL, tStderr = NULL;
688 unsigned int dwStdin, dwStdout, dwStderr;
689 HANDLE wait_list[4];
690 DWORD wait_count;
691 DWORD wait_return;
692 HANDLE ready_hand;
693 bool_t child_dead = FALSE;
694 BOOL GetExitCodeResult;
695
696 /*
697 * Create stdin thread, if needed
698 */
699 pproc->inp = stdin_data;
700 pproc->incnt = stdin_data_len;
701 if (!pproc->inp) {
702 stdin_eof = TRUE;
703 CloseHandle((HANDLE)pproc->sv_stdin[0]);
704 pproc->sv_stdin[0] = 0;
705 } else {
706 tStdin = (HANDLE) _beginthreadex( 0, 1024,
707 (unsigned (__stdcall *) (void *))proc_stdin_thread,
708 pproc, 0, &dwStdin);
709 if (tStdin == 0) {
710 pproc->last_err = GetLastError();
711 pproc->lerrno = E_SCALL;
712 goto done;
713 }
714 }
715
716 /*
717 * Assume child will produce stdout and stderr
718 */
719 tStdout = (HANDLE) _beginthreadex( 0, 1024,
720 (unsigned (__stdcall *) (void *))proc_stdout_thread, pproc, 0,
721 &dwStdout);
722 tStderr = (HANDLE) _beginthreadex( 0, 1024,
723 (unsigned (__stdcall *) (void *))proc_stderr_thread, pproc, 0,
724 &dwStderr);
725
726 if (tStdout == 0 || tStderr == 0) {
727
728 pproc->last_err = GetLastError();
729 pproc->lerrno = E_SCALL;
730 goto done;
731 }
732
733
734 /*
735 * Wait for all I/O to finish and for the child process to exit
736 */
737
738 while (!stdin_eof || !stdout_eof || !stderr_eof || !child_dead) {
739 wait_count = 0;
740 if (!stdin_eof) {
741 wait_list[wait_count++] = tStdin;
742 }
743 if (!stdout_eof) {
744 wait_list[wait_count++] = tStdout;
745 }
746 if (!stderr_eof) {
747 wait_list[wait_count++] = tStderr;
748 }
749 if (!child_dead) {
750 wait_list[wait_count++] = childhand;
751 }
752
753 wait_return = WaitForMultipleObjects(wait_count, wait_list,
754 FALSE, /* don't wait for all: one ready will do */
755 child_dead? 1000 :INFINITE); /* after the child dies, subthreads have
756 one second to collect all remaining output */
757
758 if (wait_return == WAIT_FAILED) {
759 /* map_windows32_error_to_string(GetLastError());*/
760 pproc->last_err = GetLastError();
761 pproc->lerrno = E_SCALL;
762 goto done;
763 }
764
765 ready_hand = wait_list[wait_return - WAIT_OBJECT_0];
766
767 if (ready_hand == tStdin) {
768 CloseHandle((HANDLE)pproc->sv_stdin[0]);
769 pproc->sv_stdin[0] = 0;
770 CloseHandle(tStdin);
771 tStdin = 0;
772 stdin_eof = TRUE;
773
774 } else if (ready_hand == tStdout) {
775
776 CloseHandle((HANDLE)pproc->sv_stdout[0]);
777 pproc->sv_stdout[0] = 0;
778 CloseHandle(tStdout);
779 tStdout = 0;
780 stdout_eof = TRUE;
781
782 } else if (ready_hand == tStderr) {
783
784 CloseHandle((HANDLE)pproc->sv_stderr[0]);
785 pproc->sv_stderr[0] = 0;
786 CloseHandle(tStderr);
787 tStderr = 0;
788 stderr_eof = TRUE;
789
790 } else if (ready_hand == childhand) {
791
792 DWORD ierr;
793 GetExitCodeResult = GetExitCodeProcess(childhand, &ierr);
794 if (ierr == CONTROL_C_EXIT) {
795 pproc->signal = SIGINT;
796 } else {
797 pproc->exit_code = ierr;
798 }
799 if (GetExitCodeResult == FALSE) {
800 pproc->last_err = GetLastError();
801 pproc->lerrno = E_SCALL;
802 goto done;
803 }
804 child_dead = TRUE;
805
806 } else {
807
808 /* ?? Got back a handle we didn't query ?? */
809 pproc->last_err = 0;
810 pproc->lerrno = E_FAIL;
811 goto done;
812 }
813 }
814
815 done:
816 if (tStdin != 0)
817 CloseHandle(tStdin);
818 if (tStdout != 0)
819 CloseHandle(tStdout);
820 if (tStderr != 0)
821 CloseHandle(tStderr);
822
823 if (pproc->lerrno)
824 return(-1);
825 else
826 return(0);
827
828 }
829
830 /*
831 * Purpose: collects output from child process and returns results
832 *
833 * Description:
834 *
835 * Returns:
836 *
837 * Notes/Dependencies:
838 */
839 long
process_file_io(HANDLE proc)840 process_file_io(
841 HANDLE proc)
842 {
843 sub_process *pproc;
844 HANDLE childhand;
845 DWORD wait_return;
846 BOOL GetExitCodeResult;
847 DWORD ierr;
848
849 if (proc == NULL)
850 pproc = process_wait_for_any_private();
851 else
852 pproc = (sub_process *)proc;
853
854 /* some sort of internal error */
855 if (!pproc)
856 return -1;
857
858 childhand = (HANDLE) pproc->pid;
859
860 /*
861 * This function is poorly named, and could also be used just to wait
862 * for child death if you're doing your own pipe I/O. If that is
863 * the case, close the pipe handles here.
864 */
865 if (pproc->sv_stdin[0]) {
866 CloseHandle((HANDLE)pproc->sv_stdin[0]);
867 pproc->sv_stdin[0] = 0;
868 }
869 if (pproc->sv_stdout[0]) {
870 CloseHandle((HANDLE)pproc->sv_stdout[0]);
871 pproc->sv_stdout[0] = 0;
872 }
873 if (pproc->sv_stderr[0]) {
874 CloseHandle((HANDLE)pproc->sv_stderr[0]);
875 pproc->sv_stderr[0] = 0;
876 }
877
878 /*
879 * Wait for the child process to exit
880 */
881
882 wait_return = WaitForSingleObject(childhand, INFINITE);
883
884 if (wait_return != WAIT_OBJECT_0) {
885 /* map_windows32_error_to_string(GetLastError());*/
886 pproc->last_err = GetLastError();
887 pproc->lerrno = E_SCALL;
888 goto done2;
889 }
890
891 GetExitCodeResult = GetExitCodeProcess(childhand, &ierr);
892 if (ierr == CONTROL_C_EXIT) {
893 pproc->signal = SIGINT;
894 } else {
895 pproc->exit_code = ierr;
896 }
897 if (GetExitCodeResult == FALSE) {
898 pproc->last_err = GetLastError();
899 pproc->lerrno = E_SCALL;
900 }
901
902 done2:
903 if (pproc->lerrno)
904 return(-1);
905 else
906 return(0);
907
908 }
909
910 /*
911 * Description: Clean up any leftover handles, etc. It is up to the
912 * caller to manage and free the input, ouput, and stderr buffers.
913 */
914 void
process_cleanup(HANDLE proc)915 process_cleanup(
916 HANDLE proc)
917 {
918 sub_process *pproc = (sub_process *)proc;
919 int i;
920
921 if (pproc->using_pipes) {
922 for (i= 0; i <= 1; i++) {
923 if ((HANDLE)pproc->sv_stdin[i])
924 CloseHandle((HANDLE)pproc->sv_stdin[i]);
925 if ((HANDLE)pproc->sv_stdout[i])
926 CloseHandle((HANDLE)pproc->sv_stdout[i]);
927 if ((HANDLE)pproc->sv_stderr[i])
928 CloseHandle((HANDLE)pproc->sv_stderr[i]);
929 }
930 }
931 if ((HANDLE)pproc->pid)
932 CloseHandle((HANDLE)pproc->pid);
933
934 free(pproc);
935 }
936
937
938 /*
939 * Description:
940 * Create a command line buffer to pass to CreateProcess
941 *
942 * Returns: the buffer or NULL for failure
943 * Shell case: sh_name a:/full/path/to/script argv[1] argv[2] ...
944 * Otherwise: argv[0] argv[1] argv[2] ...
945 *
946 * Notes/Dependencies:
947 * CreateProcess does not take an argv, so this command creates a
948 * command line for the executable.
949 */
950
951 static char *
make_command_line(char * shell_name,char * full_exec_path,char ** argv)952 make_command_line( char *shell_name, char *full_exec_path, char **argv)
953 {
954 int argc = 0;
955 char** argvi;
956 int* enclose_in_quotes = NULL;
957 int* enclose_in_quotes_i;
958 unsigned int bytes_required = 0;
959 char* command_line;
960 char* command_line_i;
961 int cygwin_mode = 0; /* HAVE_CYGWIN_SHELL */
962 int have_sh = 0; /* HAVE_CYGWIN_SHELL */
963
964 #ifdef HAVE_CYGWIN_SHELL
965 have_sh = (shell_name != NULL || strstr(full_exec_path, "sh.exe"));
966 cygwin_mode = 1;
967 #endif
968
969 if (shell_name && full_exec_path) {
970 bytes_required
971 = strlen(shell_name) + 1 + strlen(full_exec_path);
972 /*
973 * Skip argv[0] if any, when shell_name is given.
974 */
975 if (*argv) argv++;
976 /*
977 * Add one for the intervening space.
978 */
979 if (*argv) bytes_required++;
980 }
981
982 argvi = argv;
983 while (*(argvi++)) argc++;
984
985 if (argc) {
986 enclose_in_quotes = (int*) calloc(1, argc * sizeof(int));
987
988 if (!enclose_in_quotes) {
989 return NULL;
990 }
991 }
992
993 /* We have to make one pass through each argv[i] to see if we need
994 * to enclose it in ", so we might as well figure out how much
995 * memory we'll need on the same pass.
996 */
997
998 argvi = argv;
999 enclose_in_quotes_i = enclose_in_quotes;
1000 while(*argvi) {
1001 char* p = *argvi;
1002 unsigned int backslash_count = 0;
1003
1004 /*
1005 * We have to enclose empty arguments in ".
1006 */
1007 if (!(*p)) *enclose_in_quotes_i = 1;
1008
1009 while(*p) {
1010 switch (*p) {
1011 case '\"':
1012 /*
1013 * We have to insert a backslash for each "
1014 * and each \ that precedes the ".
1015 */
1016 bytes_required += (backslash_count + 1);
1017 backslash_count = 0;
1018 break;
1019
1020 #if !defined(HAVE_MKS_SHELL) && !defined(HAVE_CYGWIN_SHELL)
1021 case '\\':
1022 backslash_count++;
1023 break;
1024 #endif
1025 /*
1026 * At one time we set *enclose_in_quotes_i for '*' or '?' to suppress
1027 * wildcard expansion in programs linked with MSVC's SETARGV.OBJ so
1028 * that argv in always equals argv out. This was removed. Say you have
1029 * such a program named glob.exe. You enter
1030 * glob '*'
1031 * at the sh command prompt. Obviously the intent is to make glob do the
1032 * wildcarding instead of sh. If we set *enclose_in_quotes_i for '*' or '?',
1033 * then the command line that glob would see would be
1034 * glob "*"
1035 * and the _setargv in SETARGV.OBJ would _not_ expand the *.
1036 */
1037 case ' ':
1038 case '\t':
1039 *enclose_in_quotes_i = 1;
1040 /* fall through */
1041
1042 default:
1043 backslash_count = 0;
1044 break;
1045 }
1046
1047 /*
1048 * Add one for each character in argv[i].
1049 */
1050 bytes_required++;
1051
1052 p++;
1053 }
1054
1055 if (*enclose_in_quotes_i) {
1056 /*
1057 * Add one for each enclosing ",
1058 * and one for each \ that precedes the
1059 * closing ".
1060 */
1061 bytes_required += (backslash_count + 2);
1062 }
1063
1064 /*
1065 * Add one for the intervening space.
1066 */
1067 if (*(++argvi)) bytes_required++;
1068 enclose_in_quotes_i++;
1069 }
1070
1071 /*
1072 * Add one for the terminating NULL.
1073 */
1074 bytes_required++;
1075
1076 command_line = (char*) malloc(bytes_required);
1077
1078 if (!command_line) {
1079 if (enclose_in_quotes) free(enclose_in_quotes);
1080 return NULL;
1081 }
1082
1083 command_line_i = command_line;
1084
1085 if (shell_name && full_exec_path) {
1086 while(*shell_name) {
1087 *(command_line_i++) = *(shell_name++);
1088 }
1089
1090 *(command_line_i++) = ' ';
1091
1092 while(*full_exec_path) {
1093 *(command_line_i++) = *(full_exec_path++);
1094 }
1095
1096 if (*argv) {
1097 *(command_line_i++) = ' ';
1098 }
1099 }
1100
1101 argvi = argv;
1102 enclose_in_quotes_i = enclose_in_quotes;
1103
1104 while(*argvi) {
1105 char* p = *argvi;
1106 unsigned int backslash_count = 0;
1107
1108 if (*enclose_in_quotes_i) {
1109 *(command_line_i++) = '\"';
1110 }
1111
1112 while(*p) {
1113 if (*p == '\"') {
1114 if (cygwin_mode && have_sh) { /* HAVE_CYGWIN_SHELL */
1115 /* instead of a \", cygwin likes "" */
1116 *(command_line_i++) = '\"';
1117 } else {
1118
1119 /*
1120 * We have to insert a backslash for the "
1121 * and each \ that precedes the ".
1122 */
1123 backslash_count++;
1124
1125 while(backslash_count) {
1126 *(command_line_i++) = '\\';
1127 backslash_count--;
1128 };
1129 }
1130 #if !defined(HAVE_MKS_SHELL) && !defined(HAVE_CYGWIN_SHELL)
1131 } else if (*p == '\\') {
1132 backslash_count++;
1133 } else {
1134 backslash_count = 0;
1135 #endif
1136 }
1137
1138 /*
1139 * Copy the character.
1140 */
1141 *(command_line_i++) = *(p++);
1142 }
1143
1144 if (*enclose_in_quotes_i) {
1145 #if !defined(HAVE_MKS_SHELL) && !defined(HAVE_CYGWIN_SHELL)
1146 /*
1147 * Add one \ for each \ that precedes the
1148 * closing ".
1149 */
1150 while(backslash_count--) {
1151 *(command_line_i++) = '\\';
1152 };
1153 #endif
1154 *(command_line_i++) = '\"';
1155 }
1156
1157 /*
1158 * Append an intervening space.
1159 */
1160 if (*(++argvi)) {
1161 *(command_line_i++) = ' ';
1162 }
1163
1164 enclose_in_quotes_i++;
1165 }
1166
1167 /*
1168 * Append the terminating NULL.
1169 */
1170 *command_line_i = '\0';
1171
1172 if (enclose_in_quotes) free(enclose_in_quotes);
1173 return command_line;
1174 }
1175
1176 /*
1177 * Description: Given an argv and optional envp, launch the process
1178 * using the default stdin, stdout, and stderr handles.
1179 * Also, register process so that process_wait_for_any_private()
1180 * can be used via process_file_io(NULL) or
1181 * process_wait_for_any().
1182 *
1183 * Returns:
1184 *
1185 * Notes/Dependencies:
1186 */
1187 HANDLE
process_easy(char ** argv,char ** envp)1188 process_easy(
1189 char **argv,
1190 char **envp)
1191 {
1192 HANDLE hIn;
1193 HANDLE hOut;
1194 HANDLE hErr;
1195 HANDLE hProcess;
1196
1197 if (proc_index >= MAXIMUM_WAIT_OBJECTS) {
1198 DB (DB_JOBS, ("process_easy: All process slots used up\n"));
1199 return INVALID_HANDLE_VALUE;
1200 }
1201 if (DuplicateHandle(GetCurrentProcess(),
1202 GetStdHandle(STD_INPUT_HANDLE),
1203 GetCurrentProcess(),
1204 &hIn,
1205 0,
1206 TRUE,
1207 DUPLICATE_SAME_ACCESS) == FALSE) {
1208 fprintf(stderr,
1209 "process_easy: DuplicateHandle(In) failed (e=%ld)\n",
1210 GetLastError());
1211 return INVALID_HANDLE_VALUE;
1212 }
1213 if (DuplicateHandle(GetCurrentProcess(),
1214 GetStdHandle(STD_OUTPUT_HANDLE),
1215 GetCurrentProcess(),
1216 &hOut,
1217 0,
1218 TRUE,
1219 DUPLICATE_SAME_ACCESS) == FALSE) {
1220 fprintf(stderr,
1221 "process_easy: DuplicateHandle(Out) failed (e=%ld)\n",
1222 GetLastError());
1223 return INVALID_HANDLE_VALUE;
1224 }
1225 if (DuplicateHandle(GetCurrentProcess(),
1226 GetStdHandle(STD_ERROR_HANDLE),
1227 GetCurrentProcess(),
1228 &hErr,
1229 0,
1230 TRUE,
1231 DUPLICATE_SAME_ACCESS) == FALSE) {
1232 fprintf(stderr,
1233 "process_easy: DuplicateHandle(Err) failed (e=%ld)\n",
1234 GetLastError());
1235 return INVALID_HANDLE_VALUE;
1236 }
1237
1238 hProcess = process_init_fd(hIn, hOut, hErr);
1239
1240 if (process_begin(hProcess, argv, envp, argv[0], NULL)) {
1241 fake_exits_pending++;
1242 /* process_begin() failed: make a note of that. */
1243 if (!((sub_process*) hProcess)->last_err)
1244 ((sub_process*) hProcess)->last_err = -1;
1245 ((sub_process*) hProcess)->exit_code = process_last_err(hProcess);
1246
1247 /* close up unused handles */
1248 CloseHandle(hIn);
1249 CloseHandle(hOut);
1250 CloseHandle(hErr);
1251 }
1252
1253 process_register(hProcess);
1254
1255 return hProcess;
1256 }
1257