diff options
| -rw-r--r-- | butl/process | 44 | ||||
| -rw-r--r-- | butl/process.cxx | 64 |
2 files changed, 70 insertions, 38 deletions
diff --git a/butl/process b/butl/process index 52aad41..cf18acd 100644 --- a/butl/process +++ b/butl/process @@ -28,18 +28,36 @@ namespace butl struct process { - // Start another process using the specified command line. Connect the - // newly created process' stdin to out_fd. Also if connect_* are true, - // connect the created process' stdout and stderr to in_*fd. Throw - // process_error if anything goes wrong. + // Start another process using the specified command line. The default + // values to the in, out and err arguments indicate that the child + // process should inherit the parent process stdin, stdout, and stderr, + // respectively. If -1 is passed instead, then the corresponding child + // process descriptor is connected (via a pipe) to out_fd for stdin, + // in_ofd for stdout, and in_efd for stderr (see data members below). + // + // Instead of passing -1 or the default value, you can also pass your + // own descriptors. Note, however, that in this case they are not + // closed by the parent. So you should do this yourself, if required. + // For example, to redirect the child process stdout to stderr, you + // can do: + // + // process p (..., 0, 2); // - // Note that some of the exceptions (e.g., if exec() failed) can be - // thrown in the child version of us. + // Throw process_error if anything goes wrong. Note that some of the + // exceptions (e.g., if exec() failed) can be thrown in the child + // version of us. // - process (char const* args[], - bool connect_stdin = false, - bool connect_stderr = false, - bool connect_stdout = false); + process (char const* args[], int in = 0, int out = 1, int err = 2); + + // The "piping" constructor, for example: + // + // process lhs (..., 0, -1); // Redirect stdout to a pipe. + // process rhs (..., lhs); // Redirect stdin to lhs's pipe. + // + // rhs.wait (); // Wait for last first. + // lhs.wait (); + // + process (char const* args[], process& in, int out = 1, int err = 2); // Wait for the process to terminate. Return true if the process // terminated normally and with the zero exit status. Throw @@ -50,6 +68,9 @@ namespace butl ~process () {if (id != 0) wait ();} + process (const process&) = delete; + process& operator= (const process&) = delete; + #ifndef _WIN32 typedef pid_t id_type; #else @@ -57,9 +78,10 @@ namespace butl #endif id_type id; + int out_fd; // Write to this fd to send to the new process' stdin. - int in_efd; // Read from this fd to receive from the new process' stderr. int in_ofd; // Read from this fd to receive from the new process' stdout. + int in_efd; // Read from this fd to receive from the new process' stderr. }; } diff --git a/butl/process.cxx b/butl/process.cxx index 35ca26d..a456217 100644 --- a/butl/process.cxx +++ b/butl/process.cxx @@ -16,6 +16,8 @@ # include <fcntl.h> // _O_TEXT #endif +#include <cassert> + using namespace std; namespace butl @@ -23,15 +25,15 @@ namespace butl #ifndef _WIN32 process:: - process (char const* args[], bool in, bool err, bool out) + process (char const* args[], int in, int out, int err) { - int out_fd[2]; - int in_efd[2]; - int in_ofd[2]; + int out_fd[2] = {in, 0}; + int in_ofd[2] = {0, out}; + int in_efd[2] = {0, err}; - if ((in && pipe (out_fd) == -1) || - (err && pipe (in_efd) == -1) || - (out && pipe (in_ofd) == -1)) + if ((in == -1 && pipe (out_fd) == -1) || + (out == -1 && pipe (in_ofd) == -1) || + (err == -1 && pipe (in_efd) == -1)) throw process_error (errno, false); id = fork (); @@ -44,31 +46,31 @@ namespace butl // Child. If requested, close the write end of the pipe and duplicate // the read end to stdin. Then close the original read end descriptor. // - if (in) + if (in != STDIN_FILENO) { - if (close (out_fd[1]) == -1 || - dup2 (out_fd[0], STDIN_FILENO) == -1 || - close (out_fd[0]) == -1) + if ((in == -1 && close (out_fd[1]) == -1) || + dup2 (out_fd[0], STDIN_FILENO) == -1 || + (in == -1 && close (out_fd[0]) == -1)) throw process_error (errno, true); } - // Do the same for the stderr if requested. + // Do the same for the stdout if requested. // - if (err) + if (out != STDOUT_FILENO) { - if (close (in_efd[0]) == -1 || - dup2 (in_efd[1], STDERR_FILENO) == -1 || - close (in_efd[1]) == -1) + if ((out == -1 && close (in_ofd[0]) == -1) || + dup2 (in_ofd[1], STDOUT_FILENO) == -1 || + (out == -1 && close (in_ofd[1]) == -1)) throw process_error (errno, true); } - // Do the same for the stdout if requested. + // Do the same for the stderr if requested. // - if (out) + if (err != STDERR_FILENO) { - if (close (in_ofd[0]) == -1 || - dup2 (in_ofd[1], STDOUT_FILENO) == -1 || - close (in_ofd[1]) == -1) + if ((err == -1 && close (in_efd[0]) == -1) || + dup2 (in_efd[1], STDERR_FILENO) == -1 || + (err == -1 && close (in_efd[1]) == -1)) throw process_error (errno, true); } @@ -79,15 +81,23 @@ namespace butl { // Parent. Close the other ends of the pipes. // - if ((in && close (out_fd[0]) == -1) || - (err && close (in_efd[1]) == -1) || - (out && close (in_ofd[1]) == -1)) + if ((in == -1 && close (out_fd[0]) == -1) || + (out == -1 && close (in_ofd[1]) == -1) || + (err == -1 && close (in_efd[1]) == -1)) throw process_error (errno, false); } - this->out_fd = in ? out_fd[1] : 0; - this->in_efd = err ? in_efd[0] : 0; - this->in_ofd = out ? in_ofd[0] : 0; + this->out_fd = in == -1 ? out_fd[1] : -1; + this->in_ofd = out == -1 ? in_ofd[0] : -1; + this->in_efd = err == -1 ? in_efd[0] : -1; + } + + process:: + process (char const* args[], process& in, int out, int err) + : process (args, in.in_ofd, out, err) + { + assert (in.in_ofd != -1); // Should be a pipe. + close (in.in_ofd); // Close it on our side. } bool process:: |