Meredith Montgomery <mmontgomery@levado.to> writes:

[...]

> My exercise, therefore, needs another fork if I intend for the parent
> process to exec cat because cat won't wait for the child and so the
> child might lose its parent and, therefore, losing rights to talk to the
> terminal. Forking again before running cat allows the parent to wait
> for both cat and less, keeping both programs with the right to talk to
> the terminal. So it seems I may conclude that for a situation such as
>
> cat --> less
>
> we really need three processes, one for cat, one for less and one parent
> for waiting for both to avoid any of them from losing the right to talk
> to the terminal (assuming any of them might try to). In general, a
> pipeline of n processes requires at least n+1 processes.

This happens to be true when creating pipelines from the shell as
there's always a shell process involved. But in general, it's not
true. You're just creating the pipeline in the wrong way. There are 3
kinds of processes in a pipeline

1. The first process if there's more than one. Stdin of the first
process refers to the terminal and stdout refers to a pipe.

2. n intermediate processes, n >= 0. Stdin of an intermediate process is
the most recently create pipe. Stdout is a newly created pipe.

3. The last process reads from the most recently created pipe if there's
more than one process, otherwise from the terminal. It writes to the
terminal.

Assuming there are only well-behaved commands in the pipeline, ie
commands which actually process all of their stdin input, the initial
process needs to run the last command to ensure that everythings works
as it should:

Example:

----
#include <unistd.h>

static void exec_cmd(int in_fd, char *cmd)
{ if (in_fd != -1) {
dup2(in_fd, 0);
close(in_fd);
}

execlp("sh", "/bin/sh", "-c", cmd, (void *)0);
}

static int start_cmd(int in_fd, char *cmd)
{ int fds[2];

pipe(fds);

if (fork()) {
close(in_fd);
close(fds[1]);

return *fds;
}

dup2(fds[1], 1);
close(*fds);
close(fds[1]);

exec_cmd(in_fd, cmd);
}

int main(int argc, char **argv)
{ char *cmd, *next;
int fd;

fd = -1;
++argv;

cmd = *argv;
while (next = *++argv) {
fd = start_cmd(fd, cmd);
cmd = next;
}

exec_cmd(fd, cmd);
} ----

This shell commands as arguments an runs them in a pipeline, eg

../a.out 'cat /var/log/syslog' 'sed "s/Mar/Ram/"' less