Crea il Tuo Bash: Guida Passo-Passo

Una shell è un'interfaccia utente testuale per un sistema operativo. Agisce come un interprete di comandi, leggendo l'input dell'utente, analizzandolo e invocando le funzioni appropriate del sistema operativo per eseguire i comandi richiesti. Le shell moderne offrono funzionalità avanzate come il completamento automatico dei comandi, la gestione della cronologia dei comandi, il piping e la redirezione dell'input/output, e la programmazione di script. Creare una shell da zero è un ottimo modo per comprendere a fondo il funzionamento interno dei sistemi operativi.

Questo diagramma mostra il flusso di interazione tra l'utente, la shell e il sistema operativo.

Prima di iniziare a programmare, definiamo i requisiti minimi che la nostra shell dovrà soddisfare:

1. Lettura dei comandi: La shell deve essere in grado di leggere l'input dell'utente da linea di comando.
2. Analisi dei comandi: La shell deve essere in grado di parsare il comando in token, identificando il comando stesso e i suoi argomenti.
3. Esecuzione dei comandi: La shell deve essere in grado di invocare il comando specificato, utilizzando le chiamate di sistema appropriate (ad esempio execve su sistemi Unix).
4. Gestione degli errori: La shell deve gestire gli errori in modo appropriato, segnalando all'utente eventuali problemi riscontrati durante l'analisi o l'esecuzione dei comandi. Considereremo anche alcune funzionalità aggiuntive, come la gestione della cronologia dei comandi e il supporto per il piping, per rendere la nostra shell più funzionale.

Inizieremo implementando la funzionalità di lettura dei comandi. Utilizzeremo la funzione readline dalla libreria GNU Readline, che offre funzionalità avanzate come il completamento automatico e la gestione della cronologia. Ecco un esempio di codice C:

#include <stdio.h>
#include <stdlib.h>
#include <readline/readline.h>
#include <readline/history.h>

int main() {
    char *line;

    // Loop principale della shell
    while (1) {
        // Legge una linea di input dall'utente
        line = readline("miobash> ");

        // Controlla se la lettura ha avuto successo
        if (!line) {
            printf("Exiting...\n");
            break; // Esce dal loop se readline restituisce NULL (es. EOF)
        }

        // Aggiunge la linea alla cronologia
        add_history(line);

        // Stampa la linea letta (per debug)
        printf("Hai inserito: %s\n", line);

        // Libera la memoria allocata da readline
        free(line);
    }

    return 0;
}

Questo codice legge l'input dell'utente utilizzando readline, lo aggiunge alla cronologia e lo stampa sullo schermo. È necessario compilare questo codice con la libreria Readline (-lreadline).

Il passo successivo è analizzare il comando inserito dall'utente e dividerlo in token (parole). Possiamo usare la funzione strtok per dividere la stringa in base a spazi. Ecco un esempio:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {
    char command[] = "ls -l /home";
    char *token;

    // Ottiene il primo token
    token = strtok(command, " ");

    // Loop attraverso gli altri token
    while (token != NULL) {
        printf("Token: %s\n", token);
        token = strtok(NULL, " "); // Ottiene il token successivo
    }

    return 0;
}

Questo codice divide la stringa command in token separati da spazi e li stampa. Tuttavia, strtok modifica la stringa originale. Per evitare questo, si potrebbe copiare la stringa prima di tokenizzarla. Una soluzione più robusta consisterebbe nell'utilizzare strsep (se disponibile) o implementare una funzione di tokenizzazione personalizzata che non modifichi la stringa originale e che gestisca correttamente le virgolette e i caratteri di escape.

Ora dobbiamo eseguire il comando. Useremo la funzione fork per creare un nuovo processo figlio e la funzione execve per sostituire il processo figlio con il comando specificato. Ecco un esempio:

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

int main() {
    pid_t pid;
    char *args[] = {"/bin/ls", "-l", "/home", NULL}; // Comando e argomenti

    // Crea un nuovo processo figlio
    pid = fork();

    if (pid == 0) {
        // Siamo nel processo figlio
        // Esegue il comando specificato
        execve(args[0], args, NULL);
        perror("execve"); // Se execve fallisce, stampa l'errore
        exit(1);
    } else if (pid > 0) {
        // Siamo nel processo padre
        int status;
        waitpid(pid, &status, 0); // Aspetta che il processo figlio termini
        printf("Il processo figlio è terminato.\n");
    } else {
        // Fork fallisce
        perror("fork");
        return 1;
    }

    return 0;
}

Questo codice crea un processo figlio che esegue il comando ls -l /home. Il processo padre aspetta che il figlio termini. La funzione execve richiede il percorso completo dell'eseguibile e un array di argomenti terminato da NULL.