[42 Cursus] A C program that mimics the behavior of shell pipes (|), allowing you to execute commands in a pipeline with input and output redirection.
This project was designed to enhance skills in process management, file handling, and C programming.

Keywords

• Pipes
• Process Management
• File Descriptors
• Error Handling
• Input/Output Redirection
• Shell Commands
• Forking
• System Calls

• Overview
• Features
• Bonus Features
• Functions Allowed
• How It Works
  • Basic Functionality Tests
  • Error Handling Tests
  • Bonus Functionality Tests
• What I Learned
• Installation
• Author
• Acknowledgments

The pipex project is a C program that simulates the behavior of shell pipes (|). It takes four arguments: two file names and two shell commands. The program executes the commands in a pipeline, redirecting the input and output as specified. This project was created to deepen understanding of Unix process management, file handling, and error handling in C.

• Pipeline Execution: Execute shell commands in a pipeline, similar to the | operator in Unix shells.
• Input/Output Redirection: Redirect input from a file and output to another file using file descriptors.
• Error Handling: Gracefully handle errors, ensuring no unexpected crashes or memory leaks.
• Basic Command Support: Support for shell commands with arguments.
• Memory Management: clean and efficient.

• Multiple Pipes: Handle more than two commands in a pipeline (e.g., cmd1 | cmd2 | cmd3).
• Here Document: Support for << and >> redirection when the first parameter is here_doc.
• Advanced Error Handling: Improved error messages and handling for edge cases.

The following functions are authorized for use in the pipex project. Each function is briefly described to explain its purpose and relevance to the project.

• open(): Opens a file and returns a file descriptor. Used to read from or write to files.
• close(): Closes a file descriptor, freeing up resources.
• unlink(): Deletes a file from the filesystem. Useful for cleaning up temporary files.

• fork(): Creates a new process by duplicating the calling process. Used to execute commands in child processes.
• execve(): Replaces the current process image with a new one. Used to execute shell commands.
• wait(): Waits for a child process to terminate. Useful for synchronizing parent and child processes.
• waitpid(): Waits for a specific child process to terminate. Provides more control than wait().

• pipe(): Creates a pipe, which is a unidirectional data channel for inter-process communication. Used to connect commands in a pipeline.
• dup(): Duplicates a file descriptor. Useful for redirecting input/output.
• dup2(): Duplicates a file descriptor and assigns it to a specified file descriptor number. Used to redirect input/output to/from pipes.

• malloc(): Allocates memory on the heap. Used for dynamic memory allocation.
• free(): Deallocates memory previously allocated by malloc(). Prevents memory leaks.

• perror(): Prints an error message to stderr based on the current value of errno. Useful for debugging.
• strerror(): Returns a string describing the error code stored in errno. Useful for generating custom error messages.

• read(): Reads data from a file descriptor into a buffer. Used to read input from files or pipes.
• write(): Writes data from a buffer to a file descriptor. Used to write output to files or pipes.

• exit(): Terminates the program with a specified status code. Used to handle errors or normal termination.
• access(): Checks if a file exists or if the program has permission to access it. Useful for error handling.

The program takes four arguments: two file names and two shell commands. It executes the commands in a pipeline, redirecting the input and output as specified.

./pipex infile "ls -l" "wc -l" outfile

This behaves the same as the following shell command:

< infile ls -l | wc -l > outfile

1. time: Use time to measure the execution time of commands, especially when using sleep. This helps verify if commands are executed concurrently.
2. env: Use env to check if the environment variables (e.g., PATH) are correctly passed to the commands.
3. env -i: Use env -i to test how your program handles commands without environment variables.
4. echo $?: Use echo $? to capture and verify the exit status of commands.
5. which ls: Use which command to search the path of the commands, and to use absolute commands in our pipex.
6. cp /usr/bin/ls .: use this command to copy an original command to our current directory, to test relative paths in our pipex.
7. unset PATH or export PATH="": use one of these commands to test our pipex behaviour without PATH
8. valgrind --trace-children=yes --track-fds=yes: Use these flags to track if your are managing the children processes and fds correctly

• Process Management: Using fork(), execve(), and waitpid() to manage processes.
• File Descriptors: Working with open(), close(), dup(), and dup2() to handle input/output redirection.
• Pipes: Creating and managing pipes with pipe() to connect processes.
• Error Handling: Ensuring robust error management to avoid crashes and memory leaks.
• C Programming: Writing clean, efficient, and maintainable C code.

• A C compiler
• Standard libraries.

1. Clone this repository:

   git clone https://github.com/yourusername/pipex.git
   cd pipex

2. Initialize and update the libraries as submodules:

   git submodule update --init --recursive

3. Compile the project using the provided Makefile:

   make

4. Run the program with the required arguments:

   ./pipex infile "cmd1" "cmd2" outfile

For bonus features, use the bonus rule in the Makefile:

make bonus

This project is part of the 42 Cursus, a rigorous programming curriculum that emphasizes hands-on learning and problem-solving. Special thanks to the 42 team for providing this challenging and rewarding project!