Posted on Feb 14

How I Built a Simple Shell in C – A Beginner's Guide to System Programming (1/3)

#cli #c #systemprogramming #memorymanagement

Part 1: Reading User Input in a Custom Shell (C Programming)

In this part of my custom shell project, I will explain how to read user input dynamically in C. Handling user input properly is crucial in a shell environment, as commands can vary in length. Instead of using fixed-size buffers, I implemented a dynamic memory allocation approach for better flexibility.

Understanding the read_command Function

The function read_command() is responsible for:
✅ Reading input from the user dynamically
✅ Handling memory allocation & reallocation to avoid buffer overflow
✅ Ensuring proper termination of the input string

Breaking Down the Code

#ifndef READ_COMMAND_H #define READ_COMMAND_H #include <stdio.h> #include <stdlib.h> #include <string.h> #define INT_BUFFER_SIZE 32 // Initial buffer size char *read_command(); #endif

Header Guard (#ifndef READ_COMMAND_H): Prevents multiple inclusions.
Constant Definition (INT_BUFFER_SIZE): Sets an initial buffer size for input storage.

Implementation of read_command()

char *read_command() { char *command = malloc(INT_BUFFER_SIZE * sizeof(char)); if (!command) { perror("Memory allocation failed"); exit(EXIT_FAILURE); }

Memory Allocation (malloc): Initially allocates INT_BUFFER_SIZE bytes for storing user input.
Error Handling: If malloc fails, the program prints an error and exits.

int size = INT_BUFFER_SIZE; int length = 0; int c;

size: Keeps track of the current buffer size.
length: Tracks the actual number of characters read.
c: Stores the input character retrieved from getchar().

Handling Dynamic Input Growth

while ((c = getchar()) != '\n' && c != EOF) { if (length >= (size - 1)) { size *= 2; // Double the buffer size when needed char *new_command = realloc(command, (size + 1)); if (!new_command) { free(command); perror("Memory reallocation failed"); exit(EXIT_FAILURE); } command = new_command; } command[length++] = c; }

Expanding Memory Dynamically (realloc)
- If input exceeds the allocated size, the buffer is doubled (size *= 2).
- realloc attempts to resize the buffer; if it fails, memory is freed, and an error is displayed.
Storing Characters
- Each character from getchar() is stored sequentially in command[length++]

Finalizing the Input

command[length] = '\0'; // Null-terminate the string return command;

Null-Termination (\0): Ensures that the string is properly terminated so it can be processed as a valid C string.
**Returning the Input: **The function returns the dynamically allocated string for further use.

Why This Approach?

📌 Avoids Buffer Overflow: Unlike scanf or gets, this method expands dynamically as needed.
📌 Efficient Memory Management: realloc optimizes memory allocation instead of pre-allocating a large chunk.
📌 Better Flexibility: Can handle long commands without arbitrary limitations.