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

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;
}

1. 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.

2. 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.

Next Part: Parsing Command 🚀

In the next part, I will explain how the shell parses user input and executes commands using system functions. Stay tuned! 😊

📂 GitHub: https://github.com/Ertugrulmutlu/shell_of_mine

What do you think about this approach? Would you have handled input differently? Let me know in the comments! 👇