"minishell" is a project at 42 Madrid that involves creating a simple shell that replicates basic functionalities of bash. This project introduces command parsing, process management, signal handling, and teaches how to implement a command-line interpreter in a systematic way.
The goal is to implement a shell program that can execute commands, manage environment variables, handle redirections and pipes, and provide a user-friendly interactive experience similar to bash.
- Understanding and implementing command-line parsing and tokenization
- Learning about process creation and management with fork() and execve()
- Managing pipes and redirections for inter-process communication
- Implementing built-in shell commands
- Handling signals (SIGINT, SIGQUIT, EOF)
- Managing environment variables and shell variables
- Implementing command history functionality
- Handling quotes and special characters properly
minishell
Description: A minimal shell implementation that mimics bash behavior
Usage: ./minishell or ./minishell -c "command"
Behavior: Reads and executes commands interactively or from arguments
int main(int argc, char **argv, char **envp);The implementation of minishell requires creating processes and handling signals. For this, several system calls are used:
The main system calls and functions are:
fork()➜ Creates a child process to execute commands.
pid_t pid = fork();execve()➜ Replaces the current process with a new program.
execve(cmd_path, cmd_args, envp);pipe()➜ Creates a pipe for communication between processes.
int pipefd[2];
pipe(pipefd);dup2()➜ Duplicates file descriptors for redirection.
dup2(fd, STDIN_FILENO);signal()/sigaction()➜ Sets up signal handlers for Ctrl-C, Ctrl-, etc.
signal(SIGINT, signal_handler);readline()➜ Reads a line from the terminal with line editing capabilities.
char *line = readline("minishell> ");add_history()➜ Adds a command to the history list.
add_history(line);These functions are essential for implementing minishell, as they allow command execution, process management, and user interaction.
Features and Behavior
- Prompt: Displays custom prompt with
user@hostname:path (git_branch) $ - Command execution: Supports absolute paths, relative paths, and PATH resolution
- History: Full command history navigation with up/down arrows
- Signals: Proper handling of:
Ctrl-C: Interrupts current command (SIGINT)Ctrl-D: Exits shell when line is empty (EOF)Ctrl-\: Does nothing in interactive mode (SIGQUIT)
Environment Variables:
$VAR- Environment variable expansion$?- Exit status of last command$0- Shell name$$- Shell process ID$_- Last argument of previous command
Redirections:
<- Input redirection>- Output redirection (truncate)>>- Output redirection (append)<<- Heredoc (read until delimiter)
Pipes:
|- Connect output of one command to input of another
Quotes:
'single quotes'- Preserve literal value of all characters"double quotes"- Preserve literal value except$and\
echo [-n]- Print arguments to stdoutcd [path]- Change working directorypwd- Print working directoryexport [var=value]- Set environment variablesunset [var]- Unset environment variablesenv- Display environment variablesexit [n]- Exit shell with status code
./minishell -c "command"
# Executes command and exits📥 Download & Compilation
# Clone the repository
git clone https://github.com/ravazque/minishell.git
cd minishell
# Compile the program
make
# Clean object files
make clean
# Clean everything including executable
make fclean
# Recompile everything
make re
# Run the program
./minishell📁 Project Structure
minishell/
├──┬ include/
│ ├── colors.h # Color definitions for terminal output
│ └── minishell.h # Main header with prototypes and structures
├──┬ src/
│ ├── minishell.c # Main entry point
│ ├──┬ aux_libft/ # Custom library functions
│ │ ├── include/ # Library headers
│ │ └── src/ # Library implementations
│ ├──┬ aux_minishell/ # Auxiliary minishell functions
│ │ ├── error.c # Error handling
│ │ ├── init.c # Initialization routines
│ │ ├── loop.c # Main shell loop
│ │ ├── mshlvl.c # Shell level management
│ │ └── underscore.c # $_ variable handling
│ ├──┬ built_ins/ # Built-in commands
│ │ ├── builtin_echo.c # echo command
│ │ ├── builtin_exit.c # exit command
│ │ ├── builtin_pwd.c # pwd command
│ │ ├── builtin_unset.c # unset command
│ │ ├── builtins_core.c # Core built-in dispatcher
│ │ ├── builtins_utils.c # Built-in utilities
│ │ ├──┬ builtin_cd/ # cd command implementation
│ │ │ ├── builtin_cd.c # Main cd logic
│ │ │ ├── builtin_cd_path.c # Path resolution
│ │ │ └── builtin_cd_utils.c # cd utilities
│ │ ├──┬ builtin_env/ # env command implementation
│ │ │ ├── builtin_env.c # Main env logic
│ │ │ ├── builtin_env_cmd.c # env command parsing
│ │ │ ├── builtin_env_exec.c # env execution
│ │ │ ├── builtin_env_fork.c # env fork handling
│ │ │ └── builtins_setenv.c # Environment variable setter
│ │ └──┬ builtin_export/ # export command implementation
│ │ ├── builtin_export.c # Main export logic
│ │ ├── builtin_export_print.c # Print exported variables
│ │ ├── builtin_export_set.c # Set exported variables
│ │ ├── builtin_export_utils.c # Export utilities
│ │ └── builtin_export_validate.c # Export validation
│ ├──┬ cleaner/ # Memory cleanup functions
│ │ ├── cleanup_exec.c # Execution cleanup
│ │ ├── cleanup.c # General cleanup
│ │ └── free_structs.c # Structure deallocation
│ ├──┬ execution/ # Command execution
│ │ ├──┬ executor/ # Main executor
│ │ │ ├── exec_empty.c # Funcions for empty commands
│ │ │ ├── exec_child.c # Child process execution
│ │ │ ├── exec_env.c # Environment for execution
│ │ │ ├── exec_path.c # Path resolution
│ │ │ ├── exec_pipes.c # Pipe management
│ │ │ ├── exec_single.c # Single command execution
│ │ │ ├── exec_utils.c # Execution utilities
│ │ │ ├── exec_wait.c # Process wait handling
│ │ │ └── executor.c # Main executor logic
│ │ ├──┬ heredocs/ # Heredoc implementation
│ │ │ ├── heredocs_collect.c # Line collection
│ │ │ ├── heredocs.c # Main heredoc logic
│ │ │ └── heredocs_handler.c # Heredoc handlers
│ │ └──┬ redirs/ # Redirection handling
│ │ └── redirections.c # Redirection setup
│ ├──┬ fork_bomb/ # Fork bomb detection
│ │ ├── fork_bomb.c # Fork bomb handler
│ │ └── fork_bomb_utils.c # Detection utilities
│ ├──┬ parse/ # Input parsing
│ │ ├── parse.c # Main parser
│ │ ├── parse_assign.c # Assignment parsing
│ │ ├── parse_utils.c # Parser utilities
│ │ ├──┬ expand/ # Variable expansion
│ │ │ ├── expand.c # Main expander
│ │ │ ├── expand_extract.c # Variable extraction
│ │ │ ├── expand_redirs.c # Redirection expansion
│ │ │ ├── expand_str.c # String expansion
│ │ │ ├── expand_tilde.c # Tilde expansion
│ │ │ ├── expand_utils.c # Expansion utilities
│ │ │ ├── expand_vars.c # Variable expansion
│ │ │ └──┬ expand_split/ # Word splitting
│ │ │ ├── expand_split.c # Main word splitter
│ │ │ ├── expand_split_add.c # Add split tokens
│ │ │ ├── expand_split_count.c # Count split words
│ │ │ ├── expand_split_helpers.c # Split helpers
│ │ │ ├── expand_split_utils.c # Split utilities
│ │ │ └── expand_split_word.c # Word extraction
│ │ ├──┬ lexer/ # Lexical analysis
│ │ │ ├── lexer.c # Main lexer
│ │ │ ├── lexer_classify.c # Token classification
│ │ │ ├── lexer_cmd_create.c # Command creation
│ │ │ ├── lexer_pipe_split.c # Pipe splitting
│ │ │ ├── lexer_pipe_valid.c # Pipe validation
│ │ │ ├── lexer_quotes.c # Quote handling
│ │ │ ├── lexer_redir.c # Redirection tokens
│ │ │ ├── lexer_redir_proc.c # Redirection processing
│ │ │ ├── lexer_token.c # Token creation
│ │ │ ├── lexer_token_arr.c # Token array conversion
│ │ │ └── lexer_utils.c # Lexer utilities
│ │ └──┬ tokenizer/ # Tokenization
│ │ ├── tokenizer.c # Main tokenizer
│ │ ├── tokenizer_handlers.c # Character handlers
│ │ ├── tokenizer_helpers.c # Helper functions
│ │ ├── tokenizer_parts.c # Token parts handling
│ │ └── tokenizer_utils.c # Tokenizer utilities
│ ├──┬ prompt/ # Prompt generation
│ │ ├── prompt.c # Main prompt builder
│ │ ├── prompt_git.c # Git branch detection
│ │ ├── prompt_path.c # Path formatting
│ │ └── prompt_utils.c # Prompt utilities
│ └──┬ signals/ # Signal handling
│ ├── signals.c # Main signal setup
│ └── signal_handlers.c # Signal handlers
├── Makefile # Compilation rules
└── README.md # Project documentation
The minishell project teaches advanced system programming and shell implementation concepts:
- Process Management: Understanding fork(), execve(), and wait() system calls
- Command Parsing: Learning to tokenize and parse complex command-line syntax
- Signal Handling: Proper management of SIGINT, SIGQUIT, and EOF signals
- File Descriptor Management: Deep knowledge of redirections and pipes
- Environment Management: Manipulating and maintaining environment variables
- Error Handling: Robust error checking and proper exit codes
- Memory Management: Preventing leaks in a complex interactive program
- Language: C (C90 standard)
- Compiler: cc with flags
-Wall -Wextra -Werror - System Calls: fork(), execve(), pipe(), dup2(), waitpid(), signal()
- External Functions: readline(), add_history() (GNU Readline library)
- Platform: UNIX-like systems (Linux, macOS)
- Memory Management: Proper cleanup of all allocated memory and file descriptors
- Process Handling: Parent-child process synchronization and signal propagation
- Exit Codes: Proper exit status propagation and
$?handling
Note
This project serves as a comprehensive introduction to shell programming and demonstrates proficiency in process management parsing, and inter-process communication concepts.