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