1 /* Filtering of data through a subprocess.
2 Copyright (C) 2001-2003, 2008-2013 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;
321 (!filter->reader_terminated ? &filter->readfds : NULL),
322 (!done_writing ? &filter->writefds : NULL),
327 if (filter->exit_on_error)
328 error (EXIT_FAILURE, errno,
329 _("communication with %s subprocess failed"),
331 filter->writer_errno = errno;
332 filter->writer_terminated = true;
336 if (!done_writing && FD_ISSET (filter->fd[1], &filter->writefds))
338 if (!filter->reader_terminated
339 && FD_ISSET (filter->fd[0], &filter->readfds))
341 /* How could select() return if none of the two descriptors is ready? */
345 /* Attempt to write. */
352 write (filter->fd[1], wbuf, count > SSIZE_MAX ? SSIZE_MAX : count);
355 if (!IS_EAGAIN (errno))
357 if (filter->exit_on_error)
358 error (EXIT_FAILURE, errno,
359 _("write to %s subprocess failed"),
361 filter->writer_errno = errno;
362 filter->writer_terminated = true;
366 else if (nwritten > 0)
378 /* Attempt to read. */
382 if (!filter->reader_terminated)
385 void *buf = filter->prepare_read (&bufsize, filter->private_data);
386 if (!(buf != NULL && bufsize > 0))
387 /* prepare_read returned wrong values. */
391 read (filter->fd[0], buf,
392 bufsize > SSIZE_MAX ? SSIZE_MAX : bufsize);
395 if (!IS_EAGAIN (errno))
397 if (filter->exit_on_error)
398 error (EXIT_FAILURE, errno,
399 _("read from %s subprocess failed"),
401 filter->reader_errno = errno;
402 filter->reader_terminated = true;
407 filter->done_read (buf, nread, filter->private_data);
408 else /* nread == 0 */
410 filter->reader_terminated = true;
423 filter_cleanup (struct pipe_filter_gi *filter, bool finish_reading)
426 /* A select loop, with done_writing = true. */
427 filter_loop (filter, NULL, 0);
429 if (sigaction (SIGPIPE, &filter->orig_sigpipe_action, NULL) < 0)
436 /* Terminate the child process. Do nothing if it already exited. */
438 filter_terminate (struct pipe_filter_gi *filter)
442 /* Tell the child there is nothing more the parent will send. */
443 close (filter->fd[1]);
444 filter_cleanup (filter, !filter->reader_terminated);
445 close (filter->fd[0]);
447 wait_subprocess (filter->child, filter->progname, true,
448 filter->null_stderr, true, filter->exit_on_error,
450 if (filter->exitstatus != 0 && filter->exit_on_error)
451 error (EXIT_FAILURE, 0,
452 _("subprocess %s terminated with exit code %d"),
453 filter->progname, filter->exitstatus);
454 filter->exited = true;
458 /* After filter_terminate:
459 Return 0 upon success, or (only if exit_on_error is false):
460 - -1 with errno set upon failure,
461 - the positive exit code of the subprocess if that failed. */
463 filter_retcode (struct pipe_filter_gi *filter)
465 if (filter->writer_errno != 0)
467 errno = filter->writer_errno;
470 else if (filter->reader_errno != 0)
472 errno = filter->reader_errno;
476 return filter->exitstatus;
479 struct pipe_filter_gi *
480 pipe_filter_gi_create (const char *progname,
481 const char *prog_path, const char **prog_argv,
482 bool null_stderr, bool exit_on_error,
483 prepare_read_fn prepare_read,
484 done_read_fn done_read,
487 struct pipe_filter_gi *filter;
490 (struct pipe_filter_gi *) xmalloc (sizeof (struct pipe_filter_gi));
492 /* Open a bidirectional pipe to a subprocess. */
493 filter->child = create_pipe_bidi (progname, prog_path, (char **) prog_argv,
494 null_stderr, true, exit_on_error,
496 filter->progname = progname;
497 filter->null_stderr = null_stderr;
498 filter->exit_on_error = exit_on_error;
499 filter->prepare_read = prepare_read;
500 filter->done_read = done_read;
501 filter->private_data = private_data;
502 filter->exited = false;
503 filter->exitstatus = 0;
504 filter->writer_terminated = false;
505 filter->writer_errno = 0;
506 filter->reader_terminated = false;
507 filter->reader_errno = 0;
509 if (filter->child == -1)
511 /* Child process could not be created.
512 Arrange for filter_retcode (filter) to be the current errno. */
513 filter->writer_errno = errno;
514 filter->writer_terminated = true;
515 filter->exited = true;
517 else if (filter_init (filter) < 0)
518 filter_terminate (filter);
524 pipe_filter_gi_write (struct pipe_filter_gi *filter,
525 const void *buf, size_t size)
528 /* Invalid argument. */
532 return filter_retcode (filter);
536 filter_loop (filter, buf, size);
537 if (filter->writer_terminated || filter->reader_terminated)
539 filter_terminate (filter);
540 return filter_retcode (filter);
547 pipe_filter_gi_close (struct pipe_filter_gi *filter)
552 filter_terminate (filter);
553 ret = filter_retcode (filter);