Pipex

Pipex is a command-line tool that emulates the shell pipeline operator (|). It allows us to chain commands together, with each one processing the output of the previous. Think of it as an assembly line for data processing. Simplify tasks like filtering, transforming, and analyzing data from various sources.

Whether we're working with log files or conducting data analysis, Pipex streamlines the entire pipeline process. Creating this project challegend and improved our understanding of Unix-like systems, focusing on process creation, file descriptors, and system calls. It's a practical tool with valuable insights into the core mechanisms of modern computing.

Key Concepts

• Process creation using fork.
• Inter-process communication with pipes.
• Redirection of standard input and output.
• Proper error handling for system calls.
• Efficient execution of commands using exec family of functions.

---

The Program

A short summary of the flow of the program.

• Reading Commands: As mentioned in the introduction, Pipex takes command-line arguments and chains these together, changing the input and output to the provided files. Below we have the formatted line that our program considers as valid. An input and output file connected by the two commands 'ls' and 'grep'.

  ./pipex file1 "ls -l" "grep keyword" file2

  • ./pipex: The name of our program
  • file1: Input file whose contents will be processed by the first command.
  • cmd1: First command (ls -l).
  • cmd2: Second command (grep keyword).
  • file2: Output file to store the result.

  Of course, it is also possible to pipe custom commands, as opposed to shell commands.

  ./pipex file1 "./custom_cmd1 arg1" "./custom_cmd2 arg2" file2

  Pipex takes these command-line arguments including the input file, two commands, and an output file. It parses these arguments to identify the necessary components.

• File Descriptors (FD):
  Pipex opens the input and output files, getting the file descriptors associated with them. It ensures that the necessary file descriptors (0 for stdin, 1 for stdout) are correctly set.

• Piping:
  Pipex sets up a pipe using the pipe() system call. It forks a child process, creating two identical copies of the program (parent and child).

• Redirection:
  The child process redirects its stdout to the write end of the pipe using the dup2() system call. The parent process redirects its stdin to the read end of the pipe in a similar manner.

• Command Execution:
  The child process executes the first command using the execve() system call, which replaces the child's program with the specified command. The output of the first command flows through the pipe to the parent process.

• Second Command Execution:
  The parent process, now receiving the output of the first command, executes the second command using execve(). This output can be further processed or directed to the specified output file.

• Cleanup:
  Pipex ensures that all file descriptors are closed, and any resources used are properly released. It waits for the child process to complete its execution using the waitpid() system call.

*A little side node for the execution of the parsed commands. The commands themselves will be altered by trying to concatenate them with any of the possible paths in the PATHS environment value or the current directory.

We then use access() on the concatenated string to check whether the calling process can access the file pathname.
If for example the parsed command is "wrongcmd" the 'os' will check if there is a valid pathname to the cmd/executable that we want to execute. In case of "wrongcmd" it is highly unlikely that it will be succesful unless there actually is an executable that is literally named "wrongcmd"

---

Remarks

I want to touch on two aspects in this version of Pipex.

Firstly, it's important to mention that multipiping and heredoc creation are not currently supported. However, do not fear that I might be slacking of. These features will be implemented in an upcoming project called 'minishell'. This future project has us recreat bash and will build upon the groundwork laid here in Pipex. More importantly it will give me a second attempt to actually approach piping in a proper way.

Secondly, as mentioned I approached input checking in a way that, upon reflection, proved to be less efficient than I had initially intended. Rather than handling these checks within the child processes, I attempted to do so prior to forking. This resulted in a somewhat less streamlined process that resulted in convoluted code to try and emulate, especially, bash error handling. In future iterations (read minishell), I plan to refine this aspect for a smoother execution.

---

Sources

• Codevault
• Medium tutorial
• Jdecorte's git README