kc3-lang/gnulib/lib/pipe-filter-ii.c

• Show log

  Commit

• Hash : 44b65c48
  Author :
  Date : 2018-05-03T23:09:42
  

  Simplify code. Drop support for Borland C++ on Windows.
  
  Reported by Gisle Vanem <gisle.vanem@gmail.com>.
  
  * lib/accept4.c: Simplify 'defined _WIN32 || defined __WIN32__' to just
  'defined _WIN32'.
  * lib/canonicalize-lgpl.c: Likewise.
  * lib/classpath.c: Likewise.
  * lib/clean-temp.c: Likewise.
  * lib/csharpexec.c: Likewise.
  * lib/ctime.c: Likewise.
  * lib/dosname.h: Likewise.
  * lib/dup2.c: Likewise.
  * lib/errno.in.h: Likewise.
  * lib/error.c: Likewise.
  * lib/euidaccess.c: Likewise.
  * lib/execute.c: Likewise.
  * lib/fcntl.in.h: Likewise.
  * lib/fcntl.c: Likewise.
  * lib/filename.h: Likewise.
  * lib/findprog.c: Likewise.
  * lib/flock.c: Likewise.
  * lib/fopen.c: Likewise.
  * lib/freopen.c: Likewise.
  * lib/fstat.c: Likewise.
  * lib/fsync.c: Likewise.
  * lib/gc-gnulib.c: Likewise.
  * lib/get-rusage-data.c: Likewise.
  * lib/getaddrinfo.c: Likewise.
  * lib/getdelim.c: Likewise.
  * lib/getdtablesize.c: Likewise.
  * lib/gethostname.c: Likewise.
  * lib/getlogin.c: Likewise.
  * lib/getlogin_r.c: Likewise.
  * lib/getopt.c: Likewise.
  * lib/getpagesize.c: Likewise.
  * lib/getpass.c: Likewise.
  * lib/getrusage.c: Likewise.
  * lib/gettimeofday.c: Likewise.
  * lib/glob.c: Likewise.
  * lib/inttypes.in.h: Likewise.
  * lib/isapipe.c: Likewise.
  * lib/javaexec.c: Likewise.
  * lib/link.c: Likewise.
  * lib/localcharset.c: Likewise.
  * lib/localename.h: Likewise.
  * lib/localename.c: Likewise.
  * lib/localtime.c: Likewise.
  * lib/lseek.c: Likewise.
  * lib/mbsinit.c: Likewise.
  * lib/mkdir.c: Likewise.
  * lib/msvc-nothrow.h: Likewise.
  * lib/nanosleep.c: Likewise.
  * lib/nl_langinfo.c: Likewise.
  * lib/nonblocking.c: Likewise.
  * lib/nproc.c: Likewise.
  * lib/open.c: Likewise.
  * lib/openpty.c: Likewise.
  * lib/pathmax.h: Likewise.
  * lib/pipe-filter-aux.c: Likewise.
  * lib/pipe-filter-gi.c: Likewise.
  * lib/pipe-filter-ii.c: Likewise.
  * lib/pipe.c: Likewise.
  * lib/pipe2.c: Likewise.
  * lib/poll.c: Likewise.
  * lib/popen.c: Likewise.
  * lib/posix_openpt.c: Likewise.
  * lib/printf-parse.c: Likewise.
  * lib/progreloc.c: Likewise.
  * lib/putenv.c: Likewise.
  * lib/read.c: Likewise.
  * lib/relocatable.c: Likewise.
  * lib/rename.c: Likewise.
  * lib/same-inode.h: Likewise.
  * lib/secure_getenv.c: Likewise.
  * lib/select.c: Likewise.
  * lib/sethostname.c: Likewise.
  * lib/setlocale.c: Likewise.
  * lib/sigaction.c: Likewise.
  * lib/sigprocmask.c: Likewise.
  * lib/sleep.c: Likewise.
  * lib/spawn-pipe.h: Likewise.
  * lib/spawn-pipe.c: Likewise.
  * lib/spawni.c: Likewise.
  * lib/stat-time.h: Likewise.
  * lib/stat-w32.c: Likewise.
  * lib/stat.c: Likewise.
  * lib/stdio.in.h: Likewise.
  * lib/stdio-impl.h: Likewise.
  * lib/stdio-read.c: Likewise.
  * lib/stdio-write.c: Likewise.
  * lib/stdlib.in.h: Likewise.
  * lib/strerror_r.c: Likewise.
  * lib/strftime-fixes.c: Likewise.
  * lib/sys_stat.in.h: Likewise.
  * lib/sys_types.in.h: Likewise.
  * lib/sys_wait.in.h : Likewise.
  * lib/system-quote.h: Likewise.
  * lib/system-quote.c: Likewise.
  * lib/tmpdir.c: Likewise.
  * lib/tzset.c: Likewise.
  * lib/uname.c: Likewise.
  * lib/unistd.in.h: Likewise.
  * lib/utime.in.h: Likewise.
  * lib/utime.c: Likewise.
  * lib/utimecmp.c: Likewise.
  * lib/utimens.c: Likewise.
  * lib/vasnprintf.c: Likewise.
  * lib/vma-iter.h: Likewise.
  * lib/vma-iter.c: Likewise.
  * lib/wait-process.c: Likewise.
  * lib/wcsftime.c: Likewise.
  * lib/wctype.in.h: Likewise.
  * lib/write.c: Likewise.
  * tests/nap.h: Likewise.
  * tests/test-cloexec.c: Likewise.
  * tests/test-dup-safer.c: Likewise.
  * tests/test-dup2.c: Likewise.
  * tests/test-dup3.c: Likewise.
  * tests/test-fcntl.c: Likewise.
  * tests/test-get-rusage-data.c: Likewise.
  * tests/test-getaddrinfo.c: Likewise.
  * tests/test-getlogin.h: Likewise.
  * tests/test-isatty.c: Likewise.
  * tests/test-localename.c: Likewise.
  * tests/test-mbrtowc-w32.c: Likewise.
  * tests/test-nonblocking.c: Likewise.
  * tests/test-nonblocking-pipe-main.c: Likewise.
  * tests/test-nonblocking-socket-main.c: Likewise.
  * tests/test-nonblocking-socket.h: Likewise.
  * tests/test-pipe.c: Likewise.
  * tests/test-pipe2.c: Likewise.
  * tests/test-poll.c: Likewise.
  * tests/test-pthread_sigmask1.c: Likewise.
  * tests/test-select.h: Likewise.
  * tests/test-sethostname2.c: Likewise.
  * tests/test-sigprocmask.c: Likewise.
  * tests/test-spawn-pipe-child.c: Likewise.
  * tests/test-stat-time.c: Likewise.
  * tests/test-system-quote-main.c: Likewise.
  * tests/test-utimens-common.h: Likewise.
  * tests/test-wcrtomb-w32.c: Likewise.
  * m4/csharpexec.m4 (gt_CSHARPEXEC): Likewise.
  * m4/getcwd.m4 (gl_FUNC_GETCWD_NULL): Likewise.
  * m4/javacomp.m4 (gt_JAVACOMP): Likewise.
  * m4/javaexec.m4 (gt_JAVAEXEC): Likewise.
  * m4/locale-ar.m4 (gt_LOCALE_AR): Likewise.
  * m4/locale-fr.m4 (gt_LOCALE_FR, gt_LOCALE_FR_UTF8): Likewise.
  * m4/locale-ja.m4 (gt_LOCALE_JA): Likewise.
  * m4/locale-tr.m4 (gt_LOCALE_TR_UTF8): Likewise.
  * m4/locale-zh.m4 (gt_LOCALE_ZH_CN): Likewise.
  * m4/malloc.m4 (gl_CHECK_MALLOC_POSIX): Likewise.
  * m4/nocrash.m4 (GL_NOCRASH): Likewise.
  * m4/pathmax.m4 (gl_PATHMAX_SNIPPET): Likewise.
  * m4/ptsname_r.m4 (gl_PREREQ_PTSNAME_R): Likewise.
  * m4/stdio_h.m4 (gl_STDIO_H): Likewise.
  * m4/tmpfile.m4 (gl_FUNC_TMPFILE): Likewise.
  * m4/unistd_h.m4 (gl_UNISTD_H): Likewise.
  

Download

• lib/pipe-filter-ii.c

• /* Filtering of data through a subprocess.
     Copyright (C) 2001-2003, 2008-2018 Free Software Foundation, Inc.
     Written by Bruno Haible <bruno@clisp.org>, 2009.
  
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 3 of the License, or
     (at your option) any later version.
  
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
  
     You should have received a copy of the GNU General Public License
     along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  
  #include <config.h>
  
  #include "pipe-filter.h"
  
  #include <errno.h>
  #include <fcntl.h>
  #include <stdbool.h>
  #include <stdint.h>
  #include <stdlib.h>
  #include <unistd.h>
  #if defined _WIN32 && ! defined __CYGWIN__
  # include <windows.h>
  #elif defined __KLIBC__
  # define INCL_DOS
  # include <os2.h>
  
  /* Simple implementation of Win32 APIs */
  
  # define WINAPI
  
  typedef struct _HANDLE
  {
    TID tid;
    HEV hevDone;
    unsigned int WINAPI (*start) (void *);
    void *arg;
  } *HANDLE;
  
  typedef ULONG DWORD;
  
  static void
  start_wrapper (void *arg)
  {
    HANDLE h = (HANDLE) arg;
  
    h->start (h->arg);
  
    DosPostEventSem (h->hevDone);
    _endthread ();
  }
  
  static HANDLE
  _beginthreadex (void *s, unsigned n, unsigned int WINAPI (*start) (void *),
                  void *arg, unsigned fl, unsigned *th)
  {
    HANDLE h;
  
    h = malloc (sizeof (*h));
    if (!h)
      return NULL;
  
    if (DosCreateEventSem (NULL, &h->hevDone, 0, FALSE))
      goto exit_free;
  
    h->start = start;
    h->arg = arg;
  
    h->tid = _beginthread (start_wrapper, NULL, n, (void *) h);
    if (h->tid == -1)
      goto exit_close_event_sem;
  
    return h;
  
   exit_close_event_sem:
    DosCloseEventSem (h->hevDone);
  
   exit_free:
    free (h);
  
    return NULL;
  }
  
  static BOOL
  CloseHandle (HANDLE h)
  {
    DosCloseEventSem (h->hevDone);
    free (h);
  }
  
  # define _endthreadex(x) return (x)
  # define TerminateThread(h, e) DosKillThread (h->tid)
  
  # define GetLastError()  -1
  
  # ifndef ERROR_NO_DATA
  #  define ERROR_NO_DATA 232
  # endif
  
  # define INFINITE SEM_INDEFINITE_WAIT
  # define WAIT_OBJECT_0  0
  
  static DWORD
  WaitForSingleObject (HANDLE h, DWORD ms)
  {
    return DosWaitEventSem (h->hevDone, ms) == 0 ? WAIT_OBJECT_0 : (DWORD) -1;
  }
  
  static DWORD
  WaitForMultipleObjects (DWORD nCount, const HANDLE *pHandles, BOOL bWaitAll,
                          DWORD ms)
  {
    HMUX hmux;
    PSEMRECORD psr;
    ULONG ulUser;
    ULONG rc = (ULONG) -1;
    DWORD i;
  
    psr = malloc (sizeof (*psr) * nCount);
    if (!psr)
      goto exit_return;
  
    for (i = 0; i < nCount; ++i)
      {
        psr[i].hsemCur = (HSEM) pHandles[i]->hevDone;
        psr[i].ulUser  = WAIT_OBJECT_0 + i;
      }
  
    if (DosCreateMuxWaitSem (NULL, &hmux, nCount, psr,
                             bWaitAll ? DCMW_WAIT_ALL : DCMW_WAIT_ANY))
      goto exit_free;
  
    rc = DosWaitMuxWaitSem (hmux, ms, &ulUser);
    DosCloseMuxWaitSem (hmux);
  
   exit_free:
    free (psr);
  
   exit_return:
    if (rc)
      return (DWORD) -1;
  
    return ulUser;
  }
  #else
  # include <signal.h>
  # include <sys/select.h>
  #endif
  
  #include "error.h"
  #include "spawn-pipe.h"
  #include "wait-process.h"
  #include "gettext.h"
  
  #define _(str) gettext (str)
  
  #include "pipe-filter-aux.h"
  
  #if (defined _WIN32 && ! defined __CYGWIN__) || defined __KLIBC__
  
  struct locals
  {
    /* Arguments passed to pipe_filter_ii_execute.  */
    prepare_write_fn prepare_write;
    done_write_fn done_write;
    prepare_read_fn prepare_read;
    done_read_fn done_read;
  
    /* Management of the subprocess.  */
    void *private_data;
    int fd[2];
  
    /* Status of the writer part.  */
    volatile bool writer_terminated;
    volatile int writer_errno;
    /* Status of the reader part.  */
    volatile bool reader_terminated;
    volatile int reader_errno;
  };
  
  static unsigned int WINAPI
  writer_thread_func (void *thread_arg)
  {
    struct locals *l = (struct locals *) thread_arg;
  
    for (;;)
      {
        size_t bufsize;
        const void *buf = l->prepare_write (&bufsize, l->private_data);
        if (buf != NULL)
          {
            ssize_t nwritten =
              write (l->fd[1], buf, bufsize > SSIZE_MAX ? SSIZE_MAX : bufsize);
            if (nwritten < 0)
              {
                /* Don't assume that the gnulib modules 'write' and 'sigpipe' are
                   used.  */
                if (GetLastError () == ERROR_NO_DATA)
                  errno = EPIPE;
                l->writer_errno = errno;
                break;
              }
            else if (nwritten > 0)
              l->done_write ((void *) buf, nwritten, l->private_data);
          }
        else
          break;
      }
  
    l->writer_terminated = true;
    _endthreadex (0); /* calls ExitThread (0) */
    abort ();
  }
  
  static unsigned int WINAPI
  reader_thread_func (void *thread_arg)
  {
    struct locals *l = (struct locals *) thread_arg;
  
    for (;;)
      {
        size_t bufsize;
        void *buf = l->prepare_read (&bufsize, l->private_data);
        if (!(buf != NULL && bufsize > 0))
          /* prepare_read returned wrong values.  */
          abort ();
        {
          ssize_t nread =
            read (l->fd[0], buf, bufsize > SSIZE_MAX ? SSIZE_MAX : bufsize);
          if (nread < 0)
            {
              l->reader_errno = errno;
              break;
            }
          else if (nread > 0)
            l->done_read (buf, nread, l->private_data);
          else /* nread == 0 */
            break;
        }
      }
  
    l->reader_terminated = true;
    _endthreadex (0); /* calls ExitThread (0) */
    abort ();
  }
  
  #endif
  
  int
  pipe_filter_ii_execute (const char *progname,
                          const char *prog_path, const char **prog_argv,
                          bool null_stderr, bool exit_on_error,
                          prepare_write_fn prepare_write,
                          done_write_fn done_write,
                          prepare_read_fn prepare_read,
                          done_read_fn done_read,
                          void *private_data)
  {
    pid_t child;
    int fd[2];
  #if !((defined _WIN32 && ! defined __CYGWIN__) || defined __KLIBC__)
    struct sigaction orig_sigpipe_action;
  #endif
  
    /* Open a bidirectional pipe to a subprocess.  */
    child = create_pipe_bidi (progname, prog_path, (char **) prog_argv,
                              null_stderr, true, exit_on_error,
                              fd);
    if (child == -1)
      return -1;
  
  #if (defined _WIN32 && ! defined __CYGWIN__) || defined __KLIBC__
    /* Native Windows API.  */
    /* Pipes have a non-blocking mode, see function SetNamedPipeHandleState and
       the article "Named Pipe Type, Read, and Wait Modes", but Microsoft's
       documentation discourages its use.  So don't use it.
       Asynchronous I/O is also not suitable because it notifies the caller only
       about completion of the I/O request, not about intermediate progress.
       So do the writing and the reading in separate threads.  */
    {
      struct locals l;
      HANDLE handles[2];
      #define writer_thread_handle handles[0]
      #define reader_thread_handle handles[1]
      bool writer_cleaned_up;
      bool reader_cleaned_up;
  
      l.prepare_write = prepare_write;
      l.done_write = done_write;
      l.prepare_read = prepare_read;
      l.done_read = done_read;
      l.private_data = private_data;
      l.fd[0] = fd[0];
      l.fd[1] = fd[1];
      l.writer_terminated = false;
      l.writer_errno = 0;
      l.reader_terminated = false;
      l.reader_errno = 0;
  
      writer_thread_handle =
        (HANDLE) _beginthreadex (NULL, 100000, writer_thread_func, &l, 0, NULL);
      reader_thread_handle =
        (HANDLE) _beginthreadex (NULL, 100000, reader_thread_func, &l, 0, NULL);
      if (writer_thread_handle == NULL || reader_thread_handle == NULL)
        {
          if (exit_on_error)
            error (EXIT_FAILURE, 0, _("creation of threads failed"));
          if (reader_thread_handle != NULL)
            CloseHandle (reader_thread_handle);
          if (writer_thread_handle != NULL)
            CloseHandle (writer_thread_handle);
          goto fail;
        }
      writer_cleaned_up = false;
      reader_cleaned_up = false;
      for (;;)
        {
          DWORD ret;
  
          /* Here !(writer_cleaned_up && reader_cleaned_up).  */
          if (writer_cleaned_up)
            ret = WaitForSingleObject (reader_thread_handle, INFINITE);
          else if (reader_cleaned_up)
            ret = WaitForSingleObject (writer_thread_handle, INFINITE);
          else
            ret = WaitForMultipleObjects (2, handles, FALSE, INFINITE);
          if (!(ret == WAIT_OBJECT_0 + 0 || ret == WAIT_OBJECT_0 + 1))
            abort ();
  
          if (l.writer_terminated)
            {
              /* The writer thread has just terminated.  */
              l.writer_terminated = false;
              CloseHandle (writer_thread_handle);
              if (l.writer_errno)
                {
                  if (exit_on_error)
                    error (EXIT_FAILURE, l.writer_errno,
                           _("write to %s subprocess failed"), progname);
                  if (!reader_cleaned_up)
                    {
                      TerminateThread (reader_thread_handle, 1);
                      CloseHandle (reader_thread_handle);
                    }
                  goto fail;
                }
              /* Tell the child there is nothing more the parent will send.  */
              close (fd[1]);
              writer_cleaned_up = true;
            }
          if (l.reader_terminated)
            {
              /* The reader thread has just terminated.  */
              l.reader_terminated = false;
              CloseHandle (reader_thread_handle);
              if (l.reader_errno)
                {
                  if (exit_on_error)
                    error (EXIT_FAILURE, l.reader_errno,
                           _("read from %s subprocess failed"), progname);
                  if (!writer_cleaned_up)
                    {
                      TerminateThread (writer_thread_handle, 1);
                      CloseHandle (writer_thread_handle);
                    }
                  goto fail;
                }
              reader_cleaned_up = true;
            }
          if (writer_cleaned_up && reader_cleaned_up)
            break;
        }
    }
  #else
    /* When we write to the child process and it has just terminated,
       we don't want to die from a SIGPIPE signal.  So set the SIGPIPE
       handler to SIG_IGN, and handle EPIPE error codes in write().  */
    {
      struct sigaction sigpipe_action;
  
      sigpipe_action.sa_handler = SIG_IGN;
      sigpipe_action.sa_flags = 0;
      sigemptyset (&sigpipe_action.sa_mask);
      if (sigaction (SIGPIPE, &sigpipe_action, &orig_sigpipe_action) < 0)
        abort ();
    }
  
    {
  # if HAVE_SELECT
      fd_set readfds;  /* All bits except fd[0] are always cleared.  */
      fd_set writefds; /* All bits except fd[1] are always cleared.  */
  # endif
      bool done_writing;
  
      /* Enable non-blocking I/O.  This permits the read() and write() calls
         to return -1/EAGAIN without blocking; this is important for polling
         if HAVE_SELECT is not defined.  It also permits the read() and write()
         calls to return after partial reads/writes; this is important if
         HAVE_SELECT is defined, because select() only says that some data
         can be read or written, not how many.  Without non-blocking I/O,
         Linux 2.2.17 and BSD systems prefer to block instead of returning
         with partial results.  */
      {
        int fcntl_flags;
  
        if ((fcntl_flags = fcntl (fd[1], F_GETFL, 0)) < 0
            || fcntl (fd[1], F_SETFL, fcntl_flags | O_NONBLOCK) == -1
            || (fcntl_flags = fcntl (fd[0], F_GETFL, 0)) < 0
            || fcntl (fd[0], F_SETFL, fcntl_flags | O_NONBLOCK) == -1)
          {
            if (exit_on_error)
              error (EXIT_FAILURE, errno,
                     _("cannot set up nonblocking I/O to %s subprocess"),
                     progname);
            goto fail;
          }
      }
  
  # if HAVE_SELECT
      FD_ZERO (&readfds);
      FD_ZERO (&writefds);
  # endif
      done_writing = false;
      for (;;)
        {
  # if HAVE_SELECT
          int n, retval;
  
          FD_SET (fd[0], &readfds);
          n = fd[0] + 1;
          if (!done_writing)
            {
              FD_SET (fd[1], &writefds);
              if (n <= fd[1])
                n = fd[1] + 1;
            }
  
          /* Do EINTR handling here instead of in pipe-filter-aux.h,
             because select() cannot be referred to from an inline
             function on AIX 7.1.  */
          do
            retval = select (n, &readfds, (!done_writing ? &writefds : NULL),
                             NULL, NULL);
          while (retval < 0 && errno == EINTR);
          n = retval;
  
          if (n < 0)
            {
              if (exit_on_error)
                error (EXIT_FAILURE, errno,
                       _("communication with %s subprocess failed"), progname);
              goto fail;
            }
          if (!done_writing && FD_ISSET (fd[1], &writefds))
            goto try_write;
          if (FD_ISSET (fd[0], &readfds))
            goto try_read;
          /* How could select() return if none of the two descriptors is ready?  */
          abort ();
  # endif
  
          /* Attempt to write.  */
  # if HAVE_SELECT
        try_write:
  # endif
          if (!done_writing)
            {
              size_t bufsize;
              const void *buf = prepare_write (&bufsize, private_data);
              if (buf != NULL)
                {
                  /* Writing to a pipe in non-blocking mode is tricky: The
                     write() call may fail with EAGAIN, simply because sufficient
                     space is not available in the pipe. See POSIX:2008
                     <http://pubs.opengroup.org/onlinepubs/9699919799/functions/write.html>.
                     This happens actually on AIX and IRIX, when bufsize >= 8192
                     (even though PIPE_BUF and pathconf ("/", _PC_PIPE_BUF) are
                     both 32768).  */
                  size_t attempt_to_write =
                    (bufsize > SSIZE_MAX ? SSIZE_MAX : bufsize);
                  for (;;)
                    {
                      ssize_t nwritten = write (fd[1], buf, attempt_to_write);
                      if (nwritten < 0)
                        {
                          if (errno == EAGAIN)
                            {
                              attempt_to_write = attempt_to_write / 2;
                              if (attempt_to_write == 0)
                                break;
                            }
                          else if (!IS_EAGAIN (errno))
                            {
                              if (exit_on_error)
                                error (EXIT_FAILURE, errno,
                                       _("write to %s subprocess failed"),
                                       progname);
                              goto fail;
                            }
                        }
                      else
                        {
                          if (nwritten > 0)
                            done_write ((void *) buf, nwritten, private_data);
                          break;
                        }
                    }
                }
              else
                {
                  /* Tell the child there is nothing more the parent will send.  */
                  close (fd[1]);
                  done_writing = true;
                }
            }
  # if HAVE_SELECT
          continue;
  # endif
  
          /* Attempt to read.  */
  # if HAVE_SELECT
        try_read:
  # endif
          {
            size_t bufsize;
            void *buf = prepare_read (&bufsize, private_data);
            if (!(buf != NULL && bufsize > 0))
              /* prepare_read returned wrong values.  */
              abort ();
            {
              ssize_t nread =
                read (fd[0], buf, bufsize > SSIZE_MAX ? SSIZE_MAX : bufsize);
              if (nread < 0)
                {
                  if (!IS_EAGAIN (errno))
                    {
                      if (exit_on_error)
                        error (EXIT_FAILURE, errno,
                               _("read from %s subprocess failed"), progname);
                      goto fail;
                    }
                }
              else if (nread > 0)
                done_read (buf, nread, private_data);
              else /* nread == 0 */
                {
                  if (done_writing)
                    break;
                }
            }
          }
  # if HAVE_SELECT
          continue;
  # endif
        }
    }
  
    /* Restore SIGPIPE signal handler.  */
    if (sigaction (SIGPIPE, &orig_sigpipe_action, NULL) < 0)
      abort ();
  #endif
  
    close (fd[0]);
  
    /* Remove zombie process from process list.  */
    {
      int exitstatus =
        wait_subprocess (child, progname, false, null_stderr,
                         true, exit_on_error, NULL);
      if (exitstatus != 0 && exit_on_error)
        error (EXIT_FAILURE, 0, _("%s subprocess terminated with exit code %d"),
               progname, exitstatus);
      return exitstatus;
    }
  
   fail:
    {
      int saved_errno = errno;
      close (fd[1]);
  #if !((defined _WIN32 && ! defined __CYGWIN__) || defined __KLIBC__)
      if (sigaction (SIGPIPE, &orig_sigpipe_action, NULL) < 0)
        abort ();
  #endif
      close (fd[0]);
      wait_subprocess (child, progname, true, true, true, false, NULL);
      errno = saved_errno;
      return -1;
    }
  }
  

Download