1 /* Filtering of data through a subprocess.
2 Copyright (C) 2001-2003, 2008-2016 Free Software Foundation, Inc.
3 Written by Paolo Bonzini <bonzini@gnu.org>, 2009,
4 and Bruno Haible <bruno@clisp.org>, 2009.
6 This program is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "pipe-filter.h"
29 #if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
33 # include <sys/select.h>
37 #include "spawn-pipe.h"
38 #include "wait-process.h"
42 #define _(str) gettext (str)
44 #include "pipe-filter-aux.h"
48 /* Arguments passed to pipe_filter_gi_create. */
52 prepare_read_fn prepare_read;
53 done_read_fn done_read;
56 /* Management of the subprocess. */
62 /* Status of the writer part. */
63 volatile bool writer_terminated;
65 /* Status of the reader part. */
66 volatile bool reader_terminated;
67 volatile int reader_errno;
69 #if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
70 CRITICAL_SECTION lock; /* protects the volatile fields */
71 HANDLE reader_thread_handle;
73 struct sigaction orig_sigpipe_action;
74 fd_set readfds; /* All bits except fd[0] are always cleared. */
75 fd_set writefds; /* All bits except fd[1] are always cleared. */
80 /* Platform dependent functions. */
82 /* Perform additional initializations.
83 Return 0 if successful, -1 upon failure. */
84 static int filter_init (struct pipe_filter_gi *filter);
86 /* Write count bytes starting at buf, while at the same time invoking the
87 read iterator (the functions prepare_read/done_read) when needed. */
88 static void filter_loop (struct pipe_filter_gi *filter,
89 const char *wbuf, size_t count);
91 /* Perform cleanup actions at the end.
92 finish_reading is true if there was no error, or false if some error
94 static void filter_cleanup (struct pipe_filter_gi *filter,
98 #if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
99 /* Native Windows API. */
101 static unsigned int WINAPI
102 reader_thread_func (void *thread_arg)
104 struct pipe_filter_gi *filter = (struct pipe_filter_gi *) thread_arg;
109 void *buf = filter->prepare_read (&bufsize, filter->private_data);
110 if (!(buf != NULL && bufsize > 0))
111 /* prepare_read returned wrong values. */
115 read (filter->fd[0], buf, bufsize > SSIZE_MAX ? SSIZE_MAX : bufsize);
116 EnterCriticalSection (&filter->lock);
117 /* If the writer already encountered an error, terminate. */
118 if (filter->writer_terminated)
122 filter->reader_errno = errno;
126 filter->done_read (buf, nread, filter->private_data);
127 else /* nread == 0 */
129 LeaveCriticalSection (&filter->lock);
133 filter->reader_terminated = true;
134 LeaveCriticalSection (&filter->lock);
135 _endthreadex (0); /* calls ExitThread (0) */
140 filter_init (struct pipe_filter_gi *filter)
142 InitializeCriticalSection (&filter->lock);
143 EnterCriticalSection (&filter->lock);
145 filter->reader_thread_handle =
146 (HANDLE) _beginthreadex (NULL, 100000, reader_thread_func, filter,
149 if (filter->reader_thread_handle == NULL)
151 if (filter->exit_on_error)
152 error (EXIT_FAILURE, 0, _("creation of reading thread failed"));
160 filter_loop (struct pipe_filter_gi *filter, const char *wbuf, size_t count)
162 if (!filter->writer_terminated)
168 /* Allow the reader thread to continue. */
169 LeaveCriticalSection (&filter->lock);
172 write (filter->fd[1], wbuf, count > SSIZE_MAX ? SSIZE_MAX : count);
174 /* Get the lock back from the reader thread. */
175 EnterCriticalSection (&filter->lock);
179 /* Don't assume that the gnulib modules 'write' and 'sigpipe' are
181 if (GetLastError () == ERROR_NO_DATA)
183 filter->writer_errno = errno;
184 filter->writer_terminated = true;
187 else if (nwritten > 0)
194 else /* nwritten == 0 */
196 filter->writer_terminated = true;
204 filter_cleanup (struct pipe_filter_gi *filter, bool finish_reading)
208 LeaveCriticalSection (&filter->lock);
209 WaitForSingleObject (filter->reader_thread_handle, INFINITE);
212 TerminateThread (filter->reader_thread_handle, 1);
214 CloseHandle (filter->reader_thread_handle);
215 DeleteCriticalSection (&filter->lock);
222 filter_init (struct pipe_filter_gi *filter)
224 #if !((defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__)
225 /* When we write to the child process and it has just terminated,
226 we don't want to die from a SIGPIPE signal. So set the SIGPIPE
227 handler to SIG_IGN, and handle EPIPE error codes in write(). */
229 struct sigaction sigpipe_action;
231 sigpipe_action.sa_handler = SIG_IGN;
232 sigpipe_action.sa_flags = 0;
233 sigemptyset (&sigpipe_action.sa_mask);
234 if (sigaction (SIGPIPE, &sigpipe_action, &filter->orig_sigpipe_action) < 0)
239 /* Enable non-blocking I/O. This permits the read() and write() calls
240 to return -1/EAGAIN without blocking; this is important for polling
241 if HAVE_SELECT is not defined. It also permits the read() and write()
242 calls to return after partial reads/writes; this is important if
243 HAVE_SELECT is defined, because select() only says that some data
244 can be read or written, not how many. Without non-blocking I/O,
245 Linux 2.2.17 and BSD systems prefer to block instead of returning
246 with partial results. */
250 if ((fcntl_flags = fcntl (filter->fd[1], F_GETFL, 0)) < 0
251 || fcntl (filter->fd[1], F_SETFL, fcntl_flags | O_NONBLOCK) == -1
252 || (fcntl_flags = fcntl (filter->fd[0], F_GETFL, 0)) < 0
253 || fcntl (filter->fd[0], F_SETFL, fcntl_flags | O_NONBLOCK) == -1)
255 if (filter->exit_on_error)
256 error (EXIT_FAILURE, errno,
257 _("cannot set up nonblocking I/O to %s subprocess"),
263 FD_ZERO (&filter->readfds);
264 FD_ZERO (&filter->writefds);
270 filter_loop (struct pipe_filter_gi *filter, const char *wbuf, size_t count)
272 /* This function is used in two situations:
273 - in order to write some data to the subprocess
274 [done_writing = false],
275 - in order to read the remaining data after everything was written
276 [done_writing = true]. In this case buf is NULL and count is
278 bool done_writing = (wbuf == NULL);
282 if (filter->writer_terminated || filter->reader_terminated)
283 /* pipe_filter_gi_write was called when it should not be. */
288 if (filter->reader_terminated)
292 /* Loop, trying to write the given buffer or reading, whichever is
296 /* Here filter->writer_terminated is false. When it becomes true, this
297 loop is terminated. */
298 /* Whereas filter->reader_terminated is initially false but may become
299 true during this loop. */
300 /* Here, if !done_writing, count > 0. When count becomes 0, this loop
302 /* Here, if done_writing, filter->reader_terminated is false. When
303 filter->reader_terminated becomes true, this loop is terminated. */
307 /* See whether reading or writing is possible. */
309 if (!filter->reader_terminated)
311 FD_SET (filter->fd[0], &filter->readfds);
312 n = filter->fd[0] + 1;
316 FD_SET (filter->fd[1], &filter->writefds);
317 if (n <= filter->fd[1])
318 n = filter->fd[1] + 1;
320 /* Do EINTR handling here instead of in pipe-filter-aux.h,
321 because select() cannot be referred to from an inline
322 function on AIX 7.1. */
325 (!filter->reader_terminated ? &filter->readfds : NULL),
326 (!done_writing ? &filter->writefds : NULL),
328 while (retval < 0 && errno == EINTR);
333 if (filter->exit_on_error)
334 error (EXIT_FAILURE, errno,
335 _("communication with %s subprocess failed"),
337 filter->writer_errno = errno;
338 filter->writer_terminated = true;
342 if (!done_writing && FD_ISSET (filter->fd[1], &filter->writefds))
344 if (!filter->reader_terminated
345 && FD_ISSET (filter->fd[0], &filter->readfds))
347 /* How could select() return if none of the two descriptors is ready? */
351 /* Attempt to write. */
358 write (filter->fd[1], wbuf, count > SSIZE_MAX ? SSIZE_MAX : count);
361 if (!IS_EAGAIN (errno))
363 if (filter->exit_on_error)
364 error (EXIT_FAILURE, errno,
365 _("write to %s subprocess failed"),
367 filter->writer_errno = errno;
368 filter->writer_terminated = true;
372 else if (nwritten > 0)
384 /* Attempt to read. */
388 if (!filter->reader_terminated)
391 void *buf = filter->prepare_read (&bufsize, filter->private_data);
392 if (!(buf != NULL && bufsize > 0))
393 /* prepare_read returned wrong values. */
397 read (filter->fd[0], buf,
398 bufsize > SSIZE_MAX ? SSIZE_MAX : bufsize);
401 if (!IS_EAGAIN (errno))
403 if (filter->exit_on_error)
404 error (EXIT_FAILURE, errno,
405 _("read from %s subprocess failed"),
407 filter->reader_errno = errno;
408 filter->reader_terminated = true;
413 filter->done_read (buf, nread, filter->private_data);
414 else /* nread == 0 */
416 filter->reader_terminated = true;
429 filter_cleanup (struct pipe_filter_gi *filter, bool finish_reading)
432 /* A select loop, with done_writing = true. */
433 filter_loop (filter, NULL, 0);
435 if (sigaction (SIGPIPE, &filter->orig_sigpipe_action, NULL) < 0)
442 /* Terminate the child process. Do nothing if it already exited. */
444 filter_terminate (struct pipe_filter_gi *filter)
448 /* Tell the child there is nothing more the parent will send. */
449 close (filter->fd[1]);
450 filter_cleanup (filter, !filter->reader_terminated);
451 close (filter->fd[0]);
453 wait_subprocess (filter->child, filter->progname, true,
454 filter->null_stderr, true, filter->exit_on_error,
456 if (filter->exitstatus != 0 && filter->exit_on_error)
457 error (EXIT_FAILURE, 0,
458 _("subprocess %s terminated with exit code %d"),
459 filter->progname, filter->exitstatus);
460 filter->exited = true;
464 /* After filter_terminate:
465 Return 0 upon success, or (only if exit_on_error is false):
466 - -1 with errno set upon failure,
467 - the positive exit code of the subprocess if that failed. */
469 filter_retcode (struct pipe_filter_gi *filter)
471 if (filter->writer_errno != 0)
473 errno = filter->writer_errno;
476 else if (filter->reader_errno != 0)
478 errno = filter->reader_errno;
482 return filter->exitstatus;
485 struct pipe_filter_gi *
486 pipe_filter_gi_create (const char *progname,
487 const char *prog_path, const char **prog_argv,
488 bool null_stderr, bool exit_on_error,
489 prepare_read_fn prepare_read,
490 done_read_fn done_read,
493 struct pipe_filter_gi *filter;
496 (struct pipe_filter_gi *) xmalloc (sizeof (struct pipe_filter_gi));
498 /* Open a bidirectional pipe to a subprocess. */
499 filter->child = create_pipe_bidi (progname, prog_path, (char **) prog_argv,
500 null_stderr, true, exit_on_error,
502 filter->progname = progname;
503 filter->null_stderr = null_stderr;
504 filter->exit_on_error = exit_on_error;
505 filter->prepare_read = prepare_read;
506 filter->done_read = done_read;
507 filter->private_data = private_data;
508 filter->exited = false;
509 filter->exitstatus = 0;
510 filter->writer_terminated = false;
511 filter->writer_errno = 0;
512 filter->reader_terminated = false;
513 filter->reader_errno = 0;
515 if (filter->child == -1)
517 /* Child process could not be created.
518 Arrange for filter_retcode (filter) to be the current errno. */
519 filter->writer_errno = errno;
520 filter->writer_terminated = true;
521 filter->exited = true;
523 else if (filter_init (filter) < 0)
524 filter_terminate (filter);
530 pipe_filter_gi_write (struct pipe_filter_gi *filter,
531 const void *buf, size_t size)
534 /* Invalid argument. */
538 return filter_retcode (filter);
542 filter_loop (filter, buf, size);
543 if (filter->writer_terminated || filter->reader_terminated)
545 filter_terminate (filter);
546 return filter_retcode (filter);
553 pipe_filter_gi_close (struct pipe_filter_gi *filter)
558 filter_terminate (filter);
559 ret = filter_retcode (filter);