The Big Programming Thread - Page 267

#include <unistd.h>
#include <sys/wait.h>

// This program runs the following command: ls -ltr | wc -l

int main()
{
	pid_t pid1;
	char *argvv[2][3] = { { "ls", "-ltr", 0}, { "wc", "-l", 0 } }; // commands to run
	int status;

	int fd[2];
	pipe(fd);
	pid1 = fork();
	
	if(pid1 == 0) /* Child executing */
	{
		close(fd[0]); // Child will not be reading, close this pipe
		close(1);
		dup(fd[1]);
		close(fd[1]);
		execvp(argvv[0][0], argvv[0]); // Run the command
	}
	else /* Parent executing */
	{             
		wait(&status); // Wait until child is finished running
		close(fd[1]);  // Parent will not be writing, close this pipe
		close(0);
		dup(fd[0]);
		close(fd[0]);
		execvp(argvv[1][0], argvv[1]); // Run the command
	}

   return 0;
}

#include <unistd.h>
#include <sys/wait.h>

// This program runs the following command: ls -ltr | head | wc -l

int main()
{
	int pid;
	char *argvv[3][3] = { { "ls", "-ltr", 0}, {"head", 0, 0 }, { "wc", "-l", 0 } }; // commands to run
	int status;

	int pipe1[2];
	int pipe2[2];
	pipe(pipe1);
	pipe(pipe2);
	
	pid = fork();
	if(pid == 0) /* Child executing */
	{
		pid = fork();
		if(pid == 0) /* Child's child executing */
		{
			close(pipe1[0]); // Child will not be reading, close this pipe
			close(1);
			dup(pipe1[1]);
			close(pipe1[1]);
			execvp(argvv[0][0], argvv[0]); // Run the command
		}
		else
		{
			wait(&status); // Wait until child is finished running
			close(pipe1[1]); // Child will not be reading, close this pipe
			close(0);
			dup(pipe1[0]);
			close(pipe1[0]);
			
			close(pipe2[0]); // Child will not be reading, close this pipe
			close(1);
			dup(pipe2[1]);
			close(pipe2[1]);
			execvp(argvv[1][0], argvv[1]); // Run the command
		}
	}
	else /* Parent executing */
	{             
		wait(&status); // Wait until child is finished running
		close(pipe2[1]);  // Parent will not be writing, close this pipe
		close(0);
		dup(pipe2[0]);
		close(pipe2[0]);
		execvp(argvv[2][0], argvv[2]); // Run the command
	}

   return 0;
}

#include <unistd.h>
#include <sys/wait.h>

// This program runs the following command: ls -ltr | wc -l

int main()
{
  // this variable will store the pid of the currently executing process, more on this later
  pid_t pid1;
  // these are your program arguments (you could actually pass these into main instead of creating
  // them here)
  char *argvv[2][3] = { { "ls", "-ltr", 0}, { "wc", "-l", 0 } }; // commands to run
  // this variable will be used to store the result code of the child process
  int status;

  // this is used to store our endpoints for the pipe
  int fd[2];
  // this fills fd with 2 file descriptors, fd[0] is the read end and fd[1] is the write end.
  // any data you write to fd[1] can be read at fd[0]
  pipe(fd);
  // this causes a new process to be created that is a copy of the current process. This new
  // process receives the same file descriptors as the currently running process, and begins its
  // execution at the same point we are currently at.
  pid1 = fork();
  
  // since the child process begins its execution at the same point, we need to check whether we
  // are in the child process or the parent process in order to decide what to do. fork() returns
  // different pid results in each process, which allows us to check this with the following if
  // statement:
  if(pid1 == 0) /* Child executing */
  {
    // fd[0], as you'll recall, is the read end of our pipe. since this process will be executing
    // the first command in our chain (ls -ltr), it has no need for reading. Thus, we can safely
    // close that file descriptor in our pipe-created array
    close(fd[0]); // Child will not be reading, close this pipe
    // With this process, we want to pipe all of our output to the next command in the chain
    // (wc -l). This means we don't want to send the output to STDOUT (the normal destination).
    // Because of this, we should close STDOUT (which at process start will be at index 1 of the
    // file descriptor table).
    close(1);
    // Now we need to replace STDOUT with our actual destination (the pipe write end). dup() will
    // copy the given file descriptor into the lowest available position in the file descriptor
    // table. Since we just opened up position 1 (STDOUT), this call will copy our write end of
    // the pipe into stdout.
    dup(fd[1]);
    // Now that we have a copy of fd[1] in the actual file descriptor table, we no longer need it
    // open in our pipe-created array, so we close it to clean up.
    close(fd[1]);
    // This will run the given command with the given arguments in the current process (meaning
    // that it uses all the file descriptors we setup). Since we set the STDOUT position to our
    // pipe instead of the standard file descriptor, anything this program outputs will go to
    // our pipe.
    execvp(argvv[0][0], argvv[0]); // Run the command
  }
  else /* Parent executing */
  {
    // Keep in mind that anything in this else will be running in a separate process from anything
    // executing in the if above! This runs in the original (parent) process, and has its own
    // variables, file descriptors, etc. (although they start from the same initialization point).

    // First, we wait for the child process to finish executing. We don't want to start the next
    // command in the chain until the output is completely in the pipe (although you could; this
    // is how this particular implementation chose to do it).
    wait(&status); // Wait until child is finished running
    // Since we are going to be running the final command in the pipe, any ouput we have will go
    // to the regular destination (STDOUT). As such, we have no need for the write end of the
    // pipe-created array.
    close(fd[1]);  // Parent will not be writing, close this pipe
    // The process we will be executing will be reading data from the pipe (the previous process's
    // output) instead of from the normal location (STDIN). Because of this, we need to replace
    // STDIN with the pipe's read end. First we close STDIN...
    close(0);
    // Then we dup our read end into its position in the table, as above.
    dup(fd[0]);
    // Again, we have copied this file descriptor, so we no longer need to keep the original open.
    close(fd[0]);
    // Execute the `wc -l` command. It uses the file descriptors we setup and thus reads from the
    // pipe instead of stdin.
    execvp(argvv[1][0], argvv[1]); // Run the command
  }
  
  // this will never actually be reached because the current process image is replaced by execvp,
  // but your compiler will probably complain otherwise! (oh, and execvp can return if it errors,
  // like if it can't find the thing you're trying to execute).
  return 0;
}