Pipex

A Program to Handle Pipes at 42 School

---

🇬🇧 English

📖 Click to expand/collapse English version

📖 About

Pipex is a compulsory project for 42 School students. It consists of creating a program that reproduces the behavior of pipes in the shell. The program takes 4 arguments: a file1, cmd1, cmd2, file2, and behaves exactly like < file1 cmd1 | cmd2 > file2.

This project teaches:

• Process management with fork, execve, and wait
• Inter-process communication using pipes
• File descriptors redirection with dup2
• Path finding for commands in the environment
• Error handling and memory management

🧠 Skills Learned

By completing the Pipex project, students develop essential skills in C programming and Unix systems:

• Process creation and management: Using fork to create child processes and wait/waitpid to synchronize them.
• Pipes: Creating and using pipes for communication between processes.
• File redirection: Redirecting stdin and stdout using dup2.
• Command execution: Using execve to execute commands with their arguments.
• Path resolution: Searching for executable commands in the PATH environment variable.
• Error handling: Managing errors from system calls and providing appropriate messages.
• Memory management: Allocating and freeing memory for dynamic structures like arrays of strings.
• Libft usage: Leveraging a custom library for string manipulation and other utilities.
• Code organization: Structuring code into modular functions, adhering to 42 norms.

Approach

The goal was to implement a program that mimics the shell's pipe behavior without using the shell itself. This involved creating two child processes connected by a pipe, redirecting inputs and outputs appropriately, and ensuring proper synchronization and error handling.

The implementation uses fork to create children, pipe for communication, dup2 for redirection, and execve for command execution. Path finding is done by parsing the PATH variable and checking access to executables.

Features

Pipe creation and management: Handles the creation of pipes and redirection of file descriptors.

Command execution: Executes shell commands with arguments, finding them in the PATH.

Error handling: Provides clear error messages for invalid files, commands not found, etc.

Memory safety: Ensures no memory leaks and proper cleanup.

Key Components:

• Main function: Parses arguments and orchestrates the process creation.
• Child processes: One for each command, with proper redirection.
• Path finding: Searches for commands in the system's PATH.
• Error management: Uses perror and custom error functions.

📋 Table of Contents

• Features
• Installation
• Usage
• Project Structure
• Compilation
• Function Reference
• Credits

✨ Features

• Pipe simulation reproducing shell behavior
• Argument parsing for files and commands
• Process synchronization with waitpid
• Path resolution for command execution
• Error handling with appropriate messages
• Memory management without leaks
• Libft integration for utility functions

🚀 Installation

# Clone the repository
git clone https://github.com/HaruSnak/42-pipex
cd 42-pipex

💻 Usage

Compile and run the program:

make
./pipex file1 cmd1 cmd2 file2

Examples:

• ./pipex infile "ls -l" "wc -l" outfile
• ./pipex infile "grep a1" "wc -w" outfile

📂 Project Structure

42-pipex/
├── Makefile                    # Build script
├── pipex.h                     # Main header file
├── LICENSE                     # License file
├── README.md                   # This file
├── README-Template.md          # Template for README
├── includes/
│   ├── pipex.h
│   └── libft/                  # Custom library
│       ├── Makefile
│       ├── libft.h
│       └── [various .c files]
├── readme/                     # README assets
└── srcs/                       # Source files
    ├── pipex.c                 # Main file
    ├── errors.c                # Error handling
    ├── find_path.c             # Path resolution
    └── input.txt               # Test input

🔧 Compilation

Compile the project using the Makefile:

make          # Compile the program
make clean    # Remove object files
make fclean   # Remove executable and object files
make re       # Recompile everything

📚 Function Reference

Main Functions

• main - Program entry point, argument parsing
• ft_children1 - Creates first child process
• ft_children2 - Creates second child process
• ft_execve - Executes commands
• ft_errors - Error handling

Key Features

• Pipe Management: Creates and manages pipes between processes
• Redirection: Uses dup2 for input/output redirection
• Path Finding: Parses PATH to locate executables

👨‍🎓 Note

📖 Credits

• 42 School Norm: Official C Coding Standard
• Pipe Tutorial: Holidaylvr on YouTube
• Process Pipes: CodeQuoi FR

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

---

🇫🇷 Français

📖 Cliquez pour développer/réduire la version française

📖 À propos

Pipex est un projet obligatoire pour les étudiants de l'école 42. Il s'agit de créer un programme qui reproduit le comportement des pipes dans le shell. Le programme prend 4 arguments : file1, cmd1, cmd2, file2, et se comporte exactement comme < file1 cmd1 | cmd2 > file2.

Ce projet enseigne :

• La gestion des processus avec fork, execve et wait
• La communication inter-processus utilisant des pipes
• La redirection des descripteurs de fichiers avec dup2
• La recherche de chemin pour les commandes dans l'environnement
• La gestion d'erreurs et de la mémoire

🧠 Compétences acquises

En complétant le projet Pipex, les étudiants développent des compétences essentielles en programmation C et systèmes Unix :

• Création et gestion de processus : Utilisation de fork pour créer des processus enfants et wait/waitpid pour les synchroniser.
• Pipes : Création et utilisation de pipes pour la communication entre processus.
• Redirection de fichiers : Redirection de stdin et stdout en utilisant dup2.
• Exécution de commandes : Utilisation d'execve pour exécuter des commandes avec leurs arguments.
• Résolution de chemin : Recherche de commandes exécutables dans la variable d'environnement PATH.
• Gestion d'erreurs : Gestion des erreurs des appels système et fourniture de messages appropriés.
• Gestion de la mémoire : Allocation et libération de mémoire pour des structures dynamiques comme des tableaux de chaînes.
• Utilisation de Libft : Exploitation d'une bibliothèque personnalisée pour la manipulation de chaînes et autres utilitaires.
• Organisation du code : Structuration du code en fonctions modulaires, en respectant les normes 42.

Approche

L'objectif était d'implémenter un programme qui imite le comportement des pipes du shell sans utiliser le shell lui-même. Cela impliquait de créer deux processus enfants connectés par un pipe, de rediriger les entrées et sorties de manière appropriée, et d'assurer une synchronisation et une gestion d'erreurs correctes.

L'implémentation utilise fork pour créer des enfants, pipe pour la communication, dup2 pour la redirection, et execve pour l'exécution de commandes. La recherche de chemin se fait en analysant la variable PATH et en vérifiant l'accès aux exécutables.

Fonctionnalités

Création et gestion de pipes : Gère la création de pipes et la redirection des descripteurs de fichiers.

Exécution de commandes : Exécute des commandes shell avec arguments, en les trouvant dans le PATH.

Gestion d'erreurs : Fournit des messages d'erreur clairs pour les fichiers invalides, commandes non trouvées, etc.

Sécurité mémoire : Assure l'absence de fuites mémoire et un nettoyage correct.

Composants clés :

• Fonction principale : Analyse les arguments et orchestre la création de processus.
• Processus enfants : Un pour chaque commande, avec redirection appropriée.
• Recherche de chemin : Recherche les commandes dans le PATH du système.
• Gestion d'erreurs : Utilise perror et des fonctions d'erreur personnalisées.

📋 Table des matières

• Caractéristiques
• Installation
• Utilisation
• Structure du projet
• Compilation
• Référence des fonctions
• Crédits

✨ Caractéristiques

• Simulation de pipes reproduisant le comportement du shell
• Analyse d'arguments pour fichiers et commandes
• Synchronisation de processus avec waitpid
• Résolution de chemin pour l'exécution de commandes
• Gestion d'erreurs avec messages appropriés
• Gestion de la mémoire sans fuites
• Intégration de Libft pour les fonctions utilitaires

🚀 Installation

# Cloner le dépôt
git clone https://github.com/HaruSnak/42-pipex
cd 42-pipex

💻 Utilisation

Compilez et lancez le programme :

make
./pipex file1 cmd1 cmd2 file2

Exemples :

• ./pipex infile "ls -l" "wc -l" outfile
• ./pipex infile "grep a1" "wc -w" outfile

📂 Structure du projet

42-pipex/
├── Makefile                    # Script de build
├── pipex.h                     # Fichier d'en-tête principal
├── LICENSE                     # Fichier de licence
├── README.md                   # Ce fichier
├── README-Template.md          # Template pour README
├── includes/
│   ├── pipex.h
│   └── libft/                  # Bibliothèque personnalisée
│       ├── Makefile
│       ├── libft.h
│       └── [divers fichiers .c]
├── readme/                     # Ressources README
└── srcs/                       # Fichiers sources
    ├── pipex.c                 # Fichier principal
    ├── errors.c                # Gestion d'erreurs
    ├── find_path.c             # Résolution de chemin
    └── input.txt               # Entrée de test

🔧 Compilation

Compilez le projet en utilisant le Makefile :

make          # Compiler le programme
make clean    # Supprimer les fichiers objets
make fclean   # Supprimer l'exécutable et les fichiers objets
make re       # Recompiler tout

📚 Référence des fonctions

Fonctions principales

• main - Point d'entrée du programme, analyse des arguments
• ft_children1 - Crée le premier processus enfant
• ft_children2 - Crée le deuxième processus enfant
• ft_execve - Exécute les commandes
• ft_errors - Gestion d'erreurs

Fonctionnalités clés

• Gestion de pipes : Crée et gère les pipes entre processus
• Redirection : Utilise dup2 pour la redirection entrée/sortie
• Recherche de chemin : Analyse PATH pour localiser les exécutables

👨‍🎓 Note

📖 Crédits

• Norme 42 : Standard C officiel
• Tutoriel Pipe : Holidaylvr sur YouTube
• Pipes de processus : CodeQuoi FR

📄 Licence

Ce projet est sous licence MIT - voir le fichier LICENSE pour plus de détails.

---