Working with the Unix OS

fd[l] for writing */
i.e. where read & write are used with a normal file's fd, we can likewise use read/write with a pipe fd.
! Strategy for pipe manipulation/usage:
1. create the pipe
2. fork to create the (communicating) child, e.g. reading
3. in child: e.g., close writing end of and other preparation
4. in child: 'exec' child process (? utility)
5. in parent: close reading end of pipe
6. if a second child is to write to the pipe
create it ('fork')
make any special preparations
'exec' the child
else if parent is to write to pipe
go ahead - WRITE!
The above illustrate the need to separate 'fork' and 'exec' as two separate system calls
int fd[2];
pipe(fd);
if (fork() != 0) { /*parent*/
close(fd[0]; /* close reading end */
write to fd[l] ...
}else { /* child code */
close fd[l]; /* close write */
exec(whatever)...
}
/* overlay*/
/* reads from fd[0]; */
Processes I
'fork' generates a clone with an exact copy of "per process file table", The fd[0], fd[l] file descriptors (table
subscripts) refer to a clone's local table.
int fd[2];
pipe (fd) ;
if (fork()! = 0) { /* parent */
close (fd[0]); /* reading end */
if (fork() == 0){ /* 2nd child */
exec(foo); /* write to fd[l] */
} else /* first child */
close (fd[l]); /* close writing end */
exec(whatever)... /* overlay */
/* reads from fd[0] */
}
Standard utilities use
stdin (fd=0)
stdout (fd=l)
To make use of the unmodified utilities, we use "dup" and "dup2",
e.g.
pipe (pfd); /* int pfd[2] */
if fork() !=0) { /* parent */
close(pfd[0); /* close the reading end */
write to pfd[l]...
} else { /* child code */
close(0); /* close stdin */
close(pfd[l]); /* close writing end */
dup2(pfd[0],0); /* copy the reading end over stdin */
close(pfd[0]); /* close the original reading end */
exec(utility); /* reads from stdin fd=0 */
}
97