Making your own Linux Shell in C (original) (raw)

Last Updated : 18 Apr, 2026

A shell acts as an interface between the user and the operating system, translating user commands into actions the system can perform. Tools like Bash do much more than just run commands, they manage processes, handle input/output redirection and support advanced features like piping. To better understand these internals, we’ll build a minimal Linux shell in C, focusing on how commands are interpreted and executed at a low level.

Parses raw user input into commands and arguments
Differentiates between built-in functions and external programs
Uses system calls like fork(), exec() and wait() for process control
Implements inter-process communication through pipes (|)
Integrates command history and line editing via GNU Readline

cust_shl1

Working of Shell (Step-by-Step)

When a user enters a command, the shell performs the following operations:

1. Input Handling

The shell first reads the user’s input using functions like readline().
If the input is not empty, it is stored in the command history so it can be reused later (e.g., using arrow keys).

2. Parsing

The entered command is broken into smaller components called tokens.
This helps the shell understand the command and its arguments.
**Example: ls -l becomes ["ls", "-l"].

3. Pipe Detection

The shell checks whether the command contains a pipe (|).
If a pipe is found, the command is split into multiple parts so that the output of one command can be passed as input to another.

4. Built-in Command Check

The shell checks if the command is a built-in function like cd, exit or echo.
If it matches a built-in command, it is executed directly by the shell without creating a new process.

5. Execution

If it is not a built-in command, the shell creates a new child process using fork().
The child process replaces itself with the required program using execvp(), which runs the actual command.

6. Waiting

The parent process waits for the child process to complete using wait().
This ensures the shell does not move to the next command until the current one finishes execution.

7. Loop Continuation

After the command execution finishes, the shell refreshes the interface by displaying the current working directory and showing the prompt again.

8. Ready for Next Command

The shell returns to an idle state, waiting for the user to enter the next command and the cycle repeats continuously.

Implementation

1. Installing Required Library

To enable input handling features like command history and line editing, install the GNU Readline library:

**Command:

sudo apt-get install libreadline-dev

**Note: Enter your system password when prompted and confirm the installation by pressing y.

2. Displaying System Information

The current working directory is displayed using getcwd().
The username of the logged-in user is retrieved using getenv("USER").

3. Input Parsing

User input is processed using strsep(), which splits the command into tokens based on spaces. Empty tokens are ignored to avoid storing unnecessary spaces and ensure clean parsing.

4. Built-in Command Handling

Built-in commands are stored in an array of strings.
Each input command is compared using strcmp().
If a match is found, the shell executes it internally.

**Special Case:

The cd command cannot be executed using execvp().
It is handled separately using the chdir() system call.

5. Executing System Commands

If the command is not built-in:

A child process is created using fork().
The command is executed using execvp() inside the child process.
The parent process waits for completion using wait() before continuing.

6. Pipe Handling

Pipes (|) are detected using strsep("|"), which splits the command into two parts:

Left side command
Right side command

Each part is parsed separately and executed using two different child processes. A pipe allows the output of the first command to become the input of the second command.

7. Pipe Implementation (Low-Level Details)

**File Descriptors: An integer array of size 2 is used to store file descriptors

**fd[0]: Read end
**fd[1]: Write end

**Creating Pipe

The pipe() system call is used to create communication between processes.

8. Process Execution in Pipes

**Child 1 (First Command)

Output is redirected to the pipe.
stdout is replaced with the write end of the pipe.
Read end is closed.
First command is executed using execvp().

**Child 2 (Second Command)

Input is taken from the pipe.
stdin is replaced with the read end of the pipe.
Write end is closed.
Second command is executed using execvp().

9. Parent Process

The parent process waits for both child processes to finish execution.
After completion, control returns to the shell for the next command.

Linux/Unix Shell Implementation in C

The following is the complete implementation of the simple shell in C, which supports built-in commands, external commands and pipe handling.

C `

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <sys/wait.h>

#define MAX_INPUT 1024 // Maximum length of user input #define MAX_ARGS 64 // Maximum number of arguments

// Function to print banner void printBanner() { printf("\n**********************************************\n\n"); printf(" ********** My Shell ************\n\n"); printf(" "Focus beats talent when talent doesn’t focus." \n\n"); printf("**********************************************\n\n"); }

// Function to print the current working directory void printDir() { char cwd[1024];

// Get current working directory
// If it fails, print error and return
if (getcwd(cwd, sizeof(cwd)) == NULL) {
    perror("getcwd failed");  // Print system error message
    return;                    // Exit function safely
}

// Display current directory path
printf("\nDir: %s", cwd);

}

// Function to take input from the user void takeInput(char *input) { printf("\n>>> "); // Prompt if (fgets(input, MAX_INPUT, stdin) == NULL) { // If input fails (e.g., Ctrl+D), exit shell printf("\nExiting...\n"); exit(0); } // Remove trailing newline character input[strcspn(input, "\n")] = 0; }

// Function to split input into command + arguments void parseInput(char *input, char **args) { int i = 0;

// Tokenize input based on space
args[i] = strtok(input, " ");

// Continue splitting until NULL or max args reached
while (args[i] != NULL && i < MAX_ARGS - 1) {
    i++;
    args[i] = strtok(NULL, " ");
}

}

// Function to handle built-in shell commands int handleBuiltIn(char **args) { if (args[0] == NULL) return 1; // Empty command

// Exit command
if (strcmp(args[0], "exit") == 0) {
    printf("Exiting shell...\n");
    exit(0);
}

// Change directory command
if (strcmp(args[0], "cd") == 0) {
    if (args[1] == NULL) {
        printf("Expected argument to \"cd\"\n");
    } else {
        // Change directory and handle error
        if (chdir(args[1]) != 0) {
            perror("cd failed");
        }
    }
    return 1;
}

// Help command
if (strcmp(args[0], "help") == 0) {
    printf("\nSimple Shell Help\n");
    printf("Built-in commands:\n");
    printf("  cd <dir>\n  exit\n  help\n");
    printf("Supports pipes: ls | grep txt\n");
    return 1;
}

return 0; // Not a built-in command

}

// Function to execute a normal (non-piped) command void executeCommand(char **args) { pid_t pid = fork(); // Create a child process

if (pid == 0) {
    // Child process executes command
    if (execvp(args[0], args) < 0) {
        perror("Command failed"); // If execution fails
    }
    exit(1);
} else {
    // Parent process waits for child to finish
    wait(NULL);
}

}

// Function to execute two commands connected by a pipe void executePiped(char **args1, char **args2) { int pipefd[2]; pipe(pipefd); // Create pipe

pid_t p1 = fork();

if (p1 == 0) {
    // First child process (left command)
    dup2(pipefd[1], STDOUT_FILENO); // Redirect stdout to pipe write end
    close(pipefd[0]); // Close unused read end
    close(pipefd[1]);

    execvp(args1[0], args1); // Execute first command
    perror("Pipe cmd1 failed");
    exit(1);
}

pid_t p2 = fork();

if (p2 == 0) {
    // Second child process (right command)
    dup2(pipefd[0], STDIN_FILENO); // Redirect stdin to pipe read end
    close(pipefd[1]); // Close unused write end
    close(pipefd[0]);

    execvp(args2[0], args2); // Execute second command
    perror("Pipe cmd2 failed");
    exit(1);
}

// Parent process closes both ends of pipe
close(pipefd[0]);
close(pipefd[1]);

// Wait for both child processes to complete
wait(NULL);
wait(NULL);

}

// Function to detect and split input around a pipe '|' int parsePipe(char *input, char **left, char **right) { char *pipePos = strchr(input, '|'); // Find pipe symbol

if (!pipePos) return 0; // No pipe found

*pipePos = '\0'; // Split string at pipe
pipePos++;       // Move to right side

// Skip leading spaces in right command
while (*pipePos == ' ') pipePos++;

*left = input;    // Left command
*right = pipePos; // Right command

return 1; // Pipe exists

}

int main() { char input[MAX_INPUT]; char *args1[MAX_ARGS], *args2[MAX_ARGS];

    printBanner();  // Added banner here (runs once)

while (1) {
    printDir();        // Show current directory
    takeInput(input);  // Get user input

    if (strlen(input) == 0) continue; // Ignore empty input

    char *left, *right;

    // Check if input contains a pipe
    if (parsePipe(input, &left, &right)) {
        parseInput(left, args1);   // Parse left command
        parseInput(right, args2);  // Parse right command

        executePiped(args1, args2); // Execute piped commands
    } else {
        parseInput(input, args1); // Parse normal command

        // Handle built-in commands first
        if (handleBuiltIn(args1)) continue;

        executeCommand(args1); // Execute external command
    }
}

return 0;

}

**Compilation:

gcc custome_shell.c -lreadline

**Execution:

./a.out

Output:

cust_shl-int cust_shl_run