• The pipe system call takes an uninitialized array of two integers (let’s call this array fds) and populates it with two file descriptors such that everything written to fds[1] can be read from fds[0].

int pipe(int fds[]); // fds array should be of length 2, return -1 on error, 0 otherwise

• pipe is particularly useful for allowing parent processes to communicate with forked child processes. (Recall that fork clones the caller’s virtual address space and duplicates all open file descriptors as well).
• Using pipe, fork, dup2, execvp, close, and waitpid, we can implement the subprocess function, which relies on the following record definition and is implemented to the following prototype:

typedef struct {
  pid_t pid;
  int infd;
} subprocess_t;
subprocess_t subprocess(const char *command);

• The subprocess created by subprocess executes the provided command (guaranteed to be a '\0'-terminated C string) by calling "/bin/sh -c command". Rather than waiting for command to finish, the implementation returns a subprocess_t with the command process’s pid and a single file descriptor. In particular, arbitrary data can be published to the return value’s infd with the understanding that it’ll be read by command's standard input.

• The following client program and test run illustrate precisely how subprocess should work:

int main(int argc, char *argv[]) {
  subprocess_t sp = subprocess("/usr/bin/sort");
  const char *words[] = {
    "felicity", "umbrage", "susurration", "halcyon",
    "pulchritude", "ablution", "somnolent", "indefatigable"
  };      
  for (size_t i = 0; i < sizeof(words)/sizeof(words[0]); i++) { 
    dprintf(sp.infd, "%s\n", words[i]);
  }
  close(sp.infd); // effectively sends cntl-D to child process
  int status;
  pid_t pid = waitpid(sp.pid, &status, 0);
  return pid == sp.pid && WIFEXITED(status) ? WEXITSTATUS(status) : -1;
}

• The output of the above program, given a properly implemented subprocess routine, should look like so:

myth22> ./subprocess-test
ablution
felicity
halcyon
indefatigable
pulchritude
somnolent
susurration
umbrage

• Here is the implementation of subprocess (where I omit error checking so that the meat of the implementation is clear):

subprocess_t subprocess(const char *command) {
  int fds[2];
  pipe(fds);
  subprocess_t process = { fork(), fds[1] };
  if (process.pid == 0) {
    close(fds[1]);
    dup2(fds[0], STDIN_FILENO);
    close(fds[0]);
    char *argv[] = {"/bin/sh", "-c", (char *) command, NULL};
    execvp(argv[0], argv);
  }
  close(fds[0]);
  return process;
}

• Note that the write end of the pipe is embedded into the subprocess_t. That way, the parent knows where to publish text so that it flows to the other end of the pipe, across the parent process/child process boundary.
• Further note that the child process reassociates the read end of the pipe with its own standard input (using dup2).
• Once the dup2 reassociation has been made, the child process can close both ends of its copy of the pipe.
• The parent doesn't need the read end of the pipe, so it too can close its own copy of fds[0].
• Full implementation is right here.