publish
[alioth/cvs.git] / windows-NT / run.c
1 /* run.c --- routines for executing subprocesses under Windows NT.
2    
3    This file is part of GNU CVS.
4
5    GNU CVS is free software; you can redistribute it and/or modify it
6    under the terms of the GNU General Public License as published by the
7    Free Software Foundation; either version 2, or (at your option) any
8    later version.
9
10    This program is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13    GNU General Public License for more details.  */
14
15 #include "cvs.h"
16
17 #define WIN32_LEAN_AND_MEAN
18 #include <windows.h>
19 #include <stdlib.h>
20 #include <process.h>
21 #include <errno.h>
22 #include <io.h>
23 #include <fcntl.h>
24
25
26
27 /*
28  * To exec a program under CVS, first call run_setup() to setup any initial
29  * arguments.  The options to run_setup are essentially like printf(). The
30  * arguments will be parsed into whitespace separated words and added to the
31  * global run_argv list.
32  * 
33  * Then, optionally call run_arg() for each additional argument that you'd like
34  * to pass to the executed program.
35  * 
36  * Finally, call run_exec() to execute the program with the specified arguments.
37  * The execvp() syscall will be used, so that the PATH is searched correctly.
38  * File redirections can be performed in the call to run_exec().
39  */
40 static char **run_argv;
41 static int run_argc;
42 static size_t run_arg_allocated;
43
44
45
46 void
47 run_arg_free_p (int argc, char **argv)
48 {
49     int i;
50     for (i = 0; i < argc; i++)
51         free (argv[i]);
52 }
53
54
55
56 /* VARARGS */
57 void
58 run_setup (const char *prog)
59 {
60     char *cp;
61     int i;
62
63     char *run_prog;
64
65     /* clean out any malloc'ed values from run_argv */
66     for (i = 0; i < run_argc; i++)
67     {
68         if (run_argv[i])
69         {
70             free (run_argv[i]);
71             run_argv[i] = (char *) 0;
72         }
73     }
74     run_argc = 0;
75
76     run_prog = xstrdup (prog);
77
78     /* put each word into run_argv, allocating it as we go */
79     for (cp = strtok (run_prog, " \t"); cp; cp = strtok ((char *) NULL, " \t"))
80         run_add_arg (cp);
81
82     free (run_prog);
83 }
84
85
86
87 /* Return a malloc'd copy of s, with double quotes around it.  */
88 static char *
89 quote (const char *s)
90 {
91     size_t s_len = 0;
92     char *copy = NULL;
93     char *scan = (char *) s;
94
95     /* scan string for extra quotes ... */
96     while (*scan)
97         if ('"' == *scan++)
98             s_len += 2;   /* one extra for the quote character */
99         else
100             s_len++;
101     /* allocate length + byte for ending zero + for double quotes around */
102     scan = copy = xmalloc(s_len + 3);
103     *scan++ = '"';
104     while (*s)
105     {
106         if ('"' == *s)
107             *scan++ = '\\';
108         *scan++ = *s++;
109     }
110     /* ending quote and closing zero */
111     *scan++ = '"';
112     *scan++ = '\0';
113     return copy;
114 }
115
116
117
118 void
119 run_add_arg_p (int *iargc, size_t *iarg_allocated, char ***iargv,
120                const char *s)
121 {
122     /* allocate more argv entries if we've run out */
123     if (*iargc >= *iarg_allocated)
124     {
125         *iarg_allocated += 50;
126         *iargv = xnrealloc (*iargv, *iarg_allocated, sizeof (char **));
127     }
128
129     if (s)
130         (*iargv)[(*iargc)++] = xstrdup (s);
131     else
132         (*iargv)[*iargc] = NULL;        /* not post-incremented on purpose! */
133 }
134
135
136
137 void
138 run_add_arg (const char *s)
139 {
140     run_add_arg_p (&run_argc, &run_arg_allocated, &run_argv, s);
141 }
142
143
144
145 int
146 run_exec (const char *stin, const char *stout, const char *sterr, int flags)
147 {
148     int shin, shout, sherr;
149     int sain, saout, saerr;     /* saved handles */
150     int mode_out, mode_err;
151     int status = -1;
152     int rerrno = 0;
153     int rval   = -1;
154     void (*old_sigint) (int);
155
156     if (trace)                  /* if in trace mode */
157     {
158         (void) fprintf (stderr, "-> system(");
159         run_print (stderr);
160         (void) fprintf (stderr, ")\n");
161     }
162
163     /* Flush standard output and standard error, or otherwise we end
164        up with strange interleavings of stuff called from CYGWIN
165        vs. CMD.  */
166
167     fflush (stderr);
168     fflush (stdout);
169
170     if (noexec && (flags & RUN_REALLY) == 0) /* if in noexec mode */
171         return (0);
172
173     /*
174      * start the engine and take off
175      */
176
177     /* make sure that we are null terminated, since we didn't calloc */
178     run_add_arg ((char *) 0);
179
180     /* setup default file descriptor numbers */
181     shin = 0;
182     shout = 1;
183     sherr = 2;
184
185     /* set the file modes for stdout and stderr */
186     mode_out = mode_err = O_WRONLY | O_CREAT;
187     mode_out |= ((flags & RUN_STDOUT_APPEND) ? O_APPEND : O_TRUNC);
188     mode_err |= ((flags & RUN_STDERR_APPEND) ? O_APPEND : O_TRUNC);
189
190     /* open the files as required, shXX are shadows of stdin... */
191     if (stin && (shin = open (stin, O_RDONLY)) == -1)
192     {
193         rerrno = errno;
194         error (0, errno, "cannot open %s for reading (prog %s)",
195                stin, run_argv[0]);
196         goto out0;
197     }
198     if (stout && (shout = open (stout, mode_out, 0666)) == -1)
199     {
200         rerrno = errno;
201         error (0, errno, "cannot open %s for writing (prog %s)",
202                stout, run_argv[0]);
203         goto out1;
204     }
205     if (sterr && (flags & RUN_COMBINED) == 0)
206     {
207         if ((sherr = open (sterr, mode_err, 0666)) == -1)
208         {
209             rerrno = errno;
210             error (0, errno, "cannot open %s for writing (prog %s)",
211                    sterr, run_argv[0]);
212             goto out2;
213         }
214     }
215     /* now save the standard handles */
216     sain = saout = saerr = -1;
217     sain  = dup( 0); /* dup stdin  */
218     saout = dup( 1); /* dup stdout */
219     saerr = dup( 2); /* dup stderr */
220
221     /* the new handles will be dup'd to the standard handles
222      * for the spawn.
223      */
224
225     if (shin != 0)
226       {
227         (void) dup2 (shin, 0);
228         (void) close (shin);
229       }
230     if (shout != 1)
231       {
232         (void) dup2 (shout, 1);
233         (void) close (shout);
234       }
235     if (flags & RUN_COMBINED)
236       (void) dup2 (1, 2);
237     else if (sherr != 2)
238       {
239         (void) dup2 (sherr, 2);
240         (void) close (sherr);
241       }
242
243     /* Ignore signals while we're running this.  */
244     old_sigint = signal (SIGINT, SIG_IGN);
245
246     /* dup'ing is done.  try to run it now */
247     rval = spawnvp ( P_WAIT, run_argv[0], run_argv);
248
249     /* Restore signal handling.  */
250     signal (SIGINT, old_sigint);
251
252     /* restore the original file handles   */
253     if (sain  != -1) {
254       (void) dup2( sain, 0);    /* re-connect stdin  */
255       (void) close( sain);
256     }
257     if (saout != -1) {
258       (void) dup2( saout, 1);   /* re-connect stdout */
259       (void) close( saout);
260     }
261     if (saerr != -1) {
262       (void) dup2( saerr, 2);   /* re-connect stderr */
263       (void) close( saerr);
264     }
265
266     /* Flush standard output and standard error, or otherwise we end
267        up with strange interleavings of stuff called from CYGWIN
268        vs. CMD.  */
269
270     fflush (stderr);
271     fflush (stdout);
272
273     /* Recognize the return code for an interrupted subprocess.  */
274     if (rval == CONTROL_C_EXIT)
275         return 2;
276     else
277         return rval;            /* end, if all went coorect */
278
279     /* error cases */
280     /* cleanup the open file descriptors */
281   out2:
282     if (stout)
283         (void) close (shout);
284   out1:
285     if (stin)
286         (void) close (shin);
287
288   out0:
289     if (rerrno)
290         errno = rerrno;
291     return (status);
292 }
293
294 void
295 run_print (FILE *fp)
296 {
297     int i;
298
299     for (i = 0; i < run_argc; i++)
300     {
301         (void) fprintf (fp, "'%s'", run_argv[i]);
302         if (i != run_argc - 1)
303             (void) fprintf (fp, " ");
304     }
305 }
306
307 static char *
308 requote (const char *cmd)
309 {
310     char *requoted = xmalloc (strlen (cmd) + 1);
311     char *p = requoted;
312
313     strcpy (requoted, cmd);
314     while ((p = strchr (p, '\'')) != NULL)
315     {
316         *p++ = '"';
317     }
318
319     return requoted;
320 }
321
322 FILE *
323 run_popen (const char *cmd, const char *mode)
324 {
325     if (trace)
326 #ifdef SERVER_SUPPORT
327         (void) fprintf (stderr, "%c-> run_popen(%s,%s)\n",
328                         (server_active) ? 'S' : ' ', cmd, mode);
329 #else
330         (void) fprintf (stderr, "-> run_popen(%s,%s)\n", cmd, mode);
331 #endif
332     if (noexec)
333         return (NULL);
334
335     /* If the command string uses single quotes, turn them into
336        double quotes.  */
337     {
338         char *requoted = requote (cmd);
339         /* Save and restore our file descriptors to work around
340            apparent bugs in _popen.  We are perhaps better off using
341            the win32 functions instead of _popen.  */
342         int old_stdin = dup (STDIN_FILENO);
343         int old_stdout = dup (STDOUT_FILENO);
344         int old_stderr = dup (STDERR_FILENO);
345
346         FILE *result = popen (requoted, mode);
347
348         dup2 (old_stdin, STDIN_FILENO);
349         dup2 (old_stdout, STDOUT_FILENO);
350         dup2 (old_stderr, STDERR_FILENO);
351         close (old_stdin);
352         close (old_stdout);
353         close (old_stderr);
354
355         free (requoted);
356         return result;
357     }
358 }
359
360
361 /* Running children with pipes connected to them.  */
362
363 /* It's kind of ridiculous the hoops we're jumping through to get
364    this working.  _pipe and dup2 and _spawnmumble work just fine, except
365    that the child inherits a file descriptor for the writing end of the
366    pipe, and thus will never receive end-of-file on it.  If you know of
367    a better way to implement the piped_child function, please let me know. 
368    
369    You can apparently specify _O_NOINHERIT when you open a file, but there's
370    apparently no fcntl function, so you can't change that bit on an existing
371    file descriptor.  */
372
373 /* Given a handle, make an inheritable duplicate of it, and close
374    the original.  */
375 static HANDLE
376 inheritable (HANDLE in)
377 {
378     HANDLE copy;
379     HANDLE self = GetCurrentProcess ();
380
381     if (! DuplicateHandle (self, in, self, &copy, 
382                            0, 1 /* fInherit */,
383                            DUPLICATE_SAME_ACCESS | DUPLICATE_CLOSE_SOURCE))
384         return INVALID_HANDLE_VALUE;
385
386     return copy;
387 }
388
389
390 /* Initialize the SECURITY_ATTRIBUTES structure *LPSA.  Set its
391    bInheritHandle flag according to INHERIT.  */
392 static void
393 init_sa (LPSECURITY_ATTRIBUTES lpsa, BOOL inherit)
394 {
395   lpsa->nLength = sizeof(*lpsa);
396   lpsa->bInheritHandle = inherit;
397   lpsa->lpSecurityDescriptor = NULL;
398 }
399
400
401 enum inherit_pipe { inherit_reading, inherit_writing };
402
403 /* Create a pipe.  Set READWRITE[0] to its reading end, and 
404    READWRITE[1] to its writing end.  If END is inherit_reading,
405    make the only the handle for the pipe's reading end inheritable.
406    If END is inherit_writing, make only the handle for the pipe's
407    writing end inheritable.  Return 0 if we succeed, -1 if we fail.
408
409    Why does inheritability matter?  Consider the case of a
410    pipe carrying data from the parent process to the child
411    process.  The child wants to read data from the parent until
412    it reaches the EOF.  Now, the only way to send an EOF on a pipe
413    is to close all the handles to its writing end.  Obviously, the 
414    parent has a handle to the writing end when it creates the child.
415    If the child inherits this handle, then it will never close it
416    (the child has no idea it's inherited it), and will thus never
417    receive an EOF on the pipe because it's holding a handle
418    to it.
419    
420    In Unix, the child process closes the pipe ends before it execs.
421    In Windows NT, you create the pipe with uninheritable handles, and then use
422    DuplicateHandle to make the appropriate ends inheritable.  */
423
424 static int
425 my_pipe (HANDLE *readwrite, enum inherit_pipe end)
426 {
427     HANDLE read, write;
428     SECURITY_ATTRIBUTES sa;
429
430     init_sa (&sa, 0);
431     if (! CreatePipe (&read, &write, &sa, 1 << 13))
432     {
433         errno = EMFILE;
434         return -1;
435     }
436     if (end == inherit_reading)
437         read = inheritable (read);
438     else
439         write = inheritable (write);
440
441     if (read == INVALID_HANDLE_VALUE
442         || write == INVALID_HANDLE_VALUE)
443     {
444         CloseHandle (read);
445         CloseHandle (write);
446         errno = EMFILE;
447         return -1;
448     }
449
450     readwrite[0] = read;
451     readwrite[1] = write;
452
453     return 0;
454 }
455
456
457 /* Initialize the STARTUPINFO structure *LPSI.  */
458 static void
459 init_si (LPSTARTUPINFO lpsi)
460 {
461   memset (lpsi, 0, sizeof (*lpsi));
462   lpsi->cb = sizeof(*lpsi);
463   lpsi->lpReserved = NULL;
464   lpsi->lpTitle = NULL;
465   lpsi->lpReserved2 = NULL;
466   lpsi->cbReserved2 = 0;
467   lpsi->lpDesktop = NULL;
468   lpsi->dwFlags = 0;
469 }
470
471
472 /* Create a child process running COMMAND with IN as its standard input,
473    and OUT as its standard output.  Return a handle to the child, or
474    INVALID_HANDLE_VALUE.  */
475 static int
476 start_child (char *command, HANDLE in, HANDLE out)
477 {
478   STARTUPINFO si;
479   PROCESS_INFORMATION pi;
480   BOOL status;
481
482   /* The STARTUPINFO structure can specify handles to pass to the
483      child as its standard input, output, and error.  */
484   init_si (&si);
485   si.hStdInput = in;
486   si.hStdOutput = out;
487   si.hStdError  = (HANDLE) _get_osfhandle (2);
488   si.dwFlags = STARTF_USESTDHANDLES;
489
490   status = CreateProcess ((LPCTSTR) NULL,
491                           (LPTSTR) command,
492                           (LPSECURITY_ATTRIBUTES) NULL, /* lpsaProcess */
493                           (LPSECURITY_ATTRIBUTES) NULL, /* lpsaThread */
494                           TRUE, /* fInheritHandles */
495                           0,    /* fdwCreate */
496                           (LPVOID) 0, /* lpvEnvironment */
497                           (LPCTSTR) 0, /* lpszCurDir */
498                           &si,  /* lpsiStartInfo */
499                           &pi); /* lppiProcInfo */
500
501   if (! status)
502   {
503       DWORD error_code = GetLastError ();
504       switch (error_code)
505       {
506       case ERROR_NOT_ENOUGH_MEMORY:
507       case ERROR_OUTOFMEMORY:
508           errno = ENOMEM; break;
509       case ERROR_BAD_EXE_FORMAT:
510           errno = ENOEXEC; break;
511       case ERROR_ACCESS_DENIED:
512           errno = EACCES; break;
513       case ERROR_NOT_READY:
514       case ERROR_FILE_NOT_FOUND:
515       case ERROR_PATH_NOT_FOUND:
516       default:
517           errno = ENOENT; break;
518       }
519       return (int) INVALID_HANDLE_VALUE;
520   }
521
522   /* The _spawn and _cwait functions in the C runtime library
523      seem to operate on raw NT handles, not PID's.  Odd, but we'll
524      deal.  */
525   return (int) pi.hProcess;
526 }
527
528
529 /* Given an array of arguments that one might pass to spawnv,
530    construct a command line that one might pass to CreateProcess.
531    Try to quote things appropriately.  */
532 static char *
533 build_command (char *const *argv)
534 {
535     int len;
536
537     /* Compute the total length the command will have.  */
538     {
539         int i;
540
541         len = 0;
542         for (i = 0; argv[i]; i++)
543         {
544             char *p;
545
546             len += 2;  /* for the double quotes */
547
548             for (p = argv[i]; *p; p++)
549             {
550                 if (*p == '"')
551                     len += 2;
552                 else
553                     len++;
554             }
555             len++;  /* for the space or the '\0'  */
556         }
557     }
558
559     {
560         /* The + 10 is in case len is 0.  */
561         char *command = (char *) malloc (len + 10);
562         int i;
563         char *p;
564
565         if (! command)
566         {
567             errno = ENOMEM;
568             return command;
569         }
570
571         p = command;
572         *p = '\0';
573         /* copy each element of argv to command, putting each command
574            in double quotes, and backslashing any quotes that appear
575            within an argument.  */
576         for (i = 0; argv[i]; i++)
577         {
578             char *a;
579             *p++ = '"';
580             for (a = argv[i]; *a; a++)
581             {
582                 if (*a == '"')
583                     *p++ = '\\', *p++ = '"';
584                 else
585                     *p++ = *a;
586             }
587             *p++ = '"';
588             *p++ = ' ';
589         }
590         if (p > command)
591             p[-1] = '\0';
592
593         return command;
594     }
595 }
596
597
598 /* Create an asynchronous child process executing ARGV,
599    with its standard input and output connected to the 
600    parent with pipes.  Set *TO to the file descriptor on
601    which one writes data for the child; set *FROM to
602    the file descriptor from which one reads data from the child.
603    Return the handle of the child process (this is what
604    _cwait and waitpid expect).  */
605 int
606 piped_child (char *const *argv, int *to, int *from, bool fix_stderr)
607 {
608   int child;
609   HANDLE pipein[2], pipeout[2];
610   char *command;
611
612   /* Turn argv into a form acceptable to CreateProcess.  */
613   command = build_command (argv);
614   if (!command)
615       return -1;
616
617   /* Create pipes for communicating with child.  Arrange for
618      the child not to inherit the ends it won't use.  */
619   if (my_pipe (pipein, inherit_reading) == -1
620       || my_pipe (pipeout, inherit_writing) == -1)
621       return -1;  
622
623   child = start_child (command, pipein[0], pipeout[1]);
624   free (command);
625   if (child == (int) INVALID_HANDLE_VALUE)
626       return -1;
627
628   /* Close the pipe ends the parent doesn't use.  */
629   CloseHandle (pipein[0]);
630   CloseHandle (pipeout[1]);
631
632   /* Given the pipe handles, turn them into file descriptors for
633      use by the caller.  */
634   if ((*to      = _open_osfhandle ((long) pipein[1],  _O_BINARY)) == -1
635       || (*from = _open_osfhandle ((long) pipeout[0], _O_BINARY)) == -1)
636       return -1;
637
638   return child;
639 }
640
641 /*
642  * dir = 0 : main proc writes to new proc, which writes to oldfd
643  * dir = 1 : main proc reads from new proc, which reads from oldfd
644  *
645  * Returns: a file descriptor.  On failure (e.g., the exec fails),
646  * then filter_stream_through_program() complains and dies.
647  */
648
649 int
650 filter_stream_through_program (int oldfd, int dir, char **prog, pid_t *pidp)
651 {
652     HANDLE pipe[2];
653     char *command;
654     int child;
655     HANDLE oldfd_handle;
656     HANDLE newfd_handle;
657     int newfd;
658
659     /* Get the OS handle associated with oldfd, to be passed to the child.  */
660     if ((oldfd_handle = (HANDLE) _get_osfhandle (oldfd)) < 0)
661         error (1, errno, "cannot _get_osfhandle");
662
663     if (dir)
664     {
665         /* insert child before parent, pipe goes child->parent.  */
666         if (my_pipe (pipe, inherit_writing) == -1)
667             error (1, errno, "cannot my_pipe");
668         if ((command = build_command (prog)) == NULL)
669             error (1, errno, "cannot build_command");
670         child = start_child (command, oldfd_handle, pipe[1]);
671         free (command);
672         if (child == (int) INVALID_HANDLE_VALUE)
673             error (1, errno, "cannot start_child");
674         close (oldfd);
675         CloseHandle (pipe[1]);
676         newfd_handle = pipe[0];
677     }
678     else
679     {
680         /* insert child after parent, pipe goes parent->child.  */
681         if (my_pipe (pipe, inherit_reading) == -1)
682             error (1, errno, "cannot my_pipe");
683         if ((command = build_command (prog)) == NULL)
684             error (1, errno, "cannot build_command");
685         child = start_child (command, pipe[0], oldfd_handle);
686         free (command);
687         if (child == (int) INVALID_HANDLE_VALUE)
688             error (1, errno, "cannot start_child");
689         close (oldfd);
690         CloseHandle (pipe[0]);
691         newfd_handle = pipe[1];
692     }
693
694     if ((newfd = _open_osfhandle ((long) newfd_handle, _O_BINARY)) == -1)
695         error (1, errno, "cannot _open_osfhandle");
696
697     if (pidp)
698         *pidp = child;
699     return newfd;    
700 }
701
702
703
704 int
705 run_piped (int *tofdp, int *fromfdp)
706 {
707     run_add_arg (NULL);
708     return piped_child (run_argv, tofdp, fromfdp, false);
709 }
710
711
712
713 /* Arrange for the file descriptor FD to not be inherited by child
714    processes.  At the moment, CVS uses this function only on pipes
715    returned by piped_child, and our implementation of piped_child
716    takes care of setting the file handles' inheritability, so this
717    can be a no-op.  */
718 void
719 close_on_exec (int fd)
720 {
721 }