Designing a Fully Functional Shell in C for System Programming Tasks

Interactive and Batch Modes

A custom shell generally operates in two modes: interactive (command-line) and batch (file-driven). Supporting both is crucial.

Interactive Mode

In this mode, your shell displays a prompt and waits for user input. It's the standard mode users expect.

• Use printf() or write() to show the prompt.
• Use fgets() or getline() to read user input.
• Tokenize input using strtok() or similar logic.

After reading input, your shell should parse the command and its arguments, then fork a new process to execute the command using the fork() and execvp() system calls.

Batch Mode

Batch mode allows you to run commands from a file without user interaction. This is useful for automated testing.

• Open the file using fopen() or open().
• Read each line, echo it to stdout, and execute it just like in interactive mode.
• Do not display a prompt in this mode.

Batch mode tests your shell's ability to handle multiple commands autonomously. Be sure to check for invalid file paths or empty files.

Parsing and Executing Commands

Once input is captured, split it into individual commands and arguments.

Example approach:

char *args[MAX_ARGS]; char *token = strtok(input, " "); int i = 0; while (token != NULL) { args[i++] = token; token = strtok(NULL, " "); } args[i] = NULL;

Once parsed, use fork() to create a new process and execvp() to execute the command. Always handle the child process termination with wait() or waitpid().

Advanced Shell Features: Going Beyond Basics

To fully replicate shell behavior, you’ll need to support advanced features like I/O redirection, pipelines, and built-in commands. This part is typically more difficult and more rewarding.

Implementing Redirection and Pipelines

Redirection and pipelining give your shell real-world functionality. Mastering them requires understanding file descriptors and process management.

Input and Output Redirection

I/O redirection allows you to control where a command reads from or writes to.

• command > output.txt redirects stdout to a file.
• command < input.txt redirects stdin from a file.

Implementation tips:

• Use open() to open the file.
• Use dup2() to redirect STDIN_FILENO or STDOUT_FILENO.
• Ensure close() is called to prevent leaks.

int fd = open("output.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644); dup2(fd, STDOUT_FILENO); close(fd);

Always parse for < and > characters in the command before forking the process.

Handling Pipelines

Pipelines (|) allow the output of one command to become the input of another.

• Use pipe() to create a file descriptor array.
• Fork two or more child processes.
• Redirect stdin and stdout using dup2() accordingly.

Limit the depth of pipelining to two pipes (three commands) if that's specified in the assignment.

Command Chaining with Semicolons

Commands can be chained using ;, and they should run sequentially regardless of success.

Split the input string by ;, and execute each command block one by one. Use wait() to ensure one finishes before the next begins.

Built-In Commands: Special Cases That Require Care

Built-in commands are not executed via exec() and should be handled within the shell process. These commands often form the basis of the individual portion of your assignment.

Handling Shell Internals

Each built-in command has unique behavior. Implementing them correctly means bypassing the standard fork() + exec() model.

cd - Change Directory

Use the chdir() system call to change the current working directory.

if (args[1]) { chdir(args[1]); } else { chdir(getenv("HOME")); }

Errors should print appropriate messages without crashing the shell.

exit - Terminate Shell

Simply call exit(0) after all commands on the line have executed.

Special care: If exit is part of a semicolon chain, it must not terminate the shell prematurely.

path - Manage Executable Paths

Maintain an internal list of executable paths. You may use a dynamic array or linked list.

Commands:

• path: Show all paths.
• path + ./bin: Add a path.
• path - ./bin: Remove a path.

Use getenv("PATH") to initialize and setenv() to modify the path.

Shell History Management

Command history allows you to track and re-execute past inputs.

Storing and Clearing History

Use a ring buffer or array of size 20 to store recent commands. Implement:

• myhistory: List commands.
• myhistory -c: Clear history.

Re-Executing Commands

Allow re-execution with myhistory -e N. Fetch the Nth command and process it through the shell loop again.

Ensure that bounds are checked and invalid indices are handled gracefully.

Command Aliases (If Required)

Alias support allows shortcutting longer commands.

Syntax:

• alias lslist='ls -l /etc'
• alias -r lslist: Remove one alias.
• alias -c: Clear all aliases.

Maintain a dictionary or hash map for aliases. Expand them before parsing for execution.

Defensive Programming and Best Practices

Now that your shell works, how do you ensure it never crashes, leaks memory, or behaves unpredictably? This section is critical, especially for high-stakes submissions.

Error Handling and Signal Control

Defensive Error Handling

Always check system call return values.

• fork() should not return -1
• open() failures must show descriptive errors
• malloc() should be validated

Print error messages to stderr using fprintf(stderr, "error\n"); or similar.

Signal Management

Use signal() to override how the shell reacts to interrupts like SIGINT (Ctrl+C).

Child processes should be in separate process groups using setpgid().

To manage foreground terminal control, use tcsetpgrp() so only child processes are affected by terminal signals. This prevents the shell itself from being stopped or terminated by mistake.

Memory and Resource Management

• Always free() dynamically allocated memory.
• Always close() open file descriptors.
• Prevent zombie processes by waitpid()ing for every child.

Input Validations

Command Lengths and Arguments

Limit input size to 512 characters but handle cases where more are provided gracefully. Either trim or display a warning.

Empty and Malformed Input

Empty inputs like multiple semicolons or white spaces should be ignored without errors.

prompt> ;;;

# Should produce no output or error

Final Thoughts: Testing, Collaboration, and Submission

Once your shell is functional and stable, don’t stop there. Shell assignments are graded not just on correctness but also on robustness, documentation, and teamwork.

Testing Across Multiple Cases

Test for:

• Redirection with non-existent files
• Pipelining invalid commands
• Commands with unusual spacing
• Semicolon chains with empty commands
• Built-ins with missing arguments

Build test scripts to validate functionality quickly and repeatedly.

Team Collaboration

In group-based assignments, clearly delegate sections:

• One handles shell engine
• Others build individual commands like cd, exit, etc.
• Another integrates signal handling

Use GitLab/GitHub for version control and merge responsibly.

Submission Requirements

• A working Makefile with clean rule
• README with team structure and known bugs
• Code comments explaining all logic
• Commit your individual contributions under your ID

Assignments like these are often tested on specific machines (e.g., Linux CELL nodes). Ensure your code compiles and runs there.