In the bonus part our objective is to handle multiple pipes and support redirection with here_doc:

• Handling Multiple pipes:

  • the program must support an arbitrary number of commands.
  • Create multiple child processes, each handling a pair of commands connected by a pipe.

• Supporting Here Document redirection:

  • Integrate the ‘here_doc’ function to read input until a limiter word is encountered.
  • When the first argument is “here_doc”, the program should behave accordingly, with the output of the commands being appended to a file

How to achieve this (code side):

• Handling Multiple Pipes:

  • Before Handling the multiple pipes we should redirect our input and output file file, so the we should open the first arguments as input_file and the last one as output_file, the redirect the input one to be the stdin, then running our process for each command:
    • The process function is responsible for creating a child process, setting up a pipe, and executing a command in that child process. This function is called for each command (cmd1, cmd2, ..., cmdn) except the last one.
    • Inside process:
      • A pipe is created using the pipe function.
      • The process forks using the fork function. If the process is the child (pid == 0), it sets up the pipe for output (STDOUT_FILENO) and executes the command using the execute function.
      • If the process is the parent, it sets up the pipe for input (STDIN_FILENO) and waits for the child process to finish executing.
    • The main function (main) iterates through the command arguments and calls process for each command except the last one. The output of each command is piped to the input of the next command.

• Supporting Here Document Redirection:

  • The here_doc function is responsible for reading input until a limiter word is encountered and then writing this input to a pipe.
  • to know that the user want to use a here_doc , we need to check if the first argument is exactly the word “here_doc”, if its the case we will treat that the second argument an limiter , so as always we need first to redirect the files we’ll work with :
    • first we need to open the last argument as our output_file and redirect it to be the stdout, then :
      • Inside here_doc function:
        • A pipe is created using the pipe function.
        • The process forks using the fork function. If the process is the child, it reads input until the limiter word is encountered using get_next_line and writes this input to the write side of pipe.
        • If the process is the parent, it sets up the read side of pipe for input (STDIN_FILENO).
      • In the main function (main), if the first argument is "here_doc", it calls the here_doc function to handle the input redirection.

• then after finishing we’ll see that the last command doesnt need to pipe so we dont include it for the previous process and we first redirect the output_file to stdout and run our last command with the output in file_out.