Have start_command() create a pipe to read the stderr of the child.
authorJohannes Sixt <johannes.sixt@telecom.at>
Fri, 19 Oct 2007 19:47:58 +0000 (21:47 +0200)
committerShawn O. Pearce <spearce@spearce.org>
Sun, 21 Oct 2007 05:30:40 +0000 (01:30 -0400)
This adds another stanza that allocates a pipe that is connected to the
child's stderr and that the caller can read from. In order to request this
pipe, the caller sets cmd->err to -1.

The implementation is not exactly modeled after the stdout case: For stdout
the caller can supply an existing file descriptor, but this facility is
nowhere needed in the stderr case. Additionally, the caller is required to
close cmd->err.

Signed-off-by: Johannes Sixt <johannes.sixt@telecom.at>
Signed-off-by: Shawn O. Pearce <spearce@spearce.org>
run-command.c
run-command.h

index 7e779d3..d00c03b 100644 (file)
@@ -17,8 +17,8 @@ static inline void dup_devnull(int to)
 
 int start_command(struct child_process *cmd)
 {
 
 int start_command(struct child_process *cmd)
 {
-       int need_in, need_out;
-       int fdin[2], fdout[2];
+       int need_in, need_out, need_err;
+       int fdin[2], fdout[2], fderr[2];
 
        need_in = !cmd->no_stdin && cmd->in < 0;
        if (need_in) {
 
        need_in = !cmd->no_stdin && cmd->in < 0;
        if (need_in) {
@@ -41,12 +41,26 @@ int start_command(struct child_process *cmd)
                cmd->close_out = 1;
        }
 
                cmd->close_out = 1;
        }
 
+       need_err = cmd->err < 0;
+       if (need_err) {
+               if (pipe(fderr) < 0) {
+                       if (need_in)
+                               close_pair(fdin);
+                       if (need_out)
+                               close_pair(fdout);
+                       return -ERR_RUN_COMMAND_PIPE;
+               }
+               cmd->err = fderr[0];
+       }
+
        cmd->pid = fork();
        if (cmd->pid < 0) {
                if (need_in)
                        close_pair(fdin);
                if (need_out)
                        close_pair(fdout);
        cmd->pid = fork();
        if (cmd->pid < 0) {
                if (need_in)
                        close_pair(fdin);
                if (need_out)
                        close_pair(fdout);
+               if (need_err)
+                       close_pair(fderr);
                return -ERR_RUN_COMMAND_FORK;
        }
 
                return -ERR_RUN_COMMAND_FORK;
        }
 
@@ -73,6 +87,11 @@ int start_command(struct child_process *cmd)
                        close(cmd->out);
                }
 
                        close(cmd->out);
                }
 
+               if (need_err) {
+                       dup2(fderr[1], 2);
+                       close_pair(fderr);
+               }
+
                if (cmd->dir && chdir(cmd->dir))
                        die("exec %s: cd to %s failed (%s)", cmd->argv[0],
                            cmd->dir, strerror(errno));
                if (cmd->dir && chdir(cmd->dir))
                        die("exec %s: cd to %s failed (%s)", cmd->argv[0],
                            cmd->dir, strerror(errno));
@@ -102,6 +121,9 @@ int start_command(struct child_process *cmd)
        else if (cmd->out > 1)
                close(cmd->out);
 
        else if (cmd->out > 1)
                close(cmd->out);
 
+       if (need_err)
+               close(fderr[1]);
+
        return 0;
 }
 
        return 0;
 }
 
index 7958eb1..35b9fb6 100644 (file)
@@ -16,6 +16,7 @@ struct child_process {
        pid_t pid;
        int in;
        int out;
        pid_t pid;
        int in;
        int out;
+       int err;
        const char *dir;
        const char *const *env;
        unsigned close_in:1;
        const char *dir;
        const char *const *env;
        unsigned close_in:1;