Construyendo una Shell Básica en C: Comandos de Parsing y Procesos de Ejecución

Construir una cáscara desde cero en C sigue siendo una de las mejores maneras de profundizar su comprensión de cómo los sistemas operativos gestionan los procesos, manejan la entrada de usuario y ejecutan programas. Mientras que las cáscaras modernas como Bash, Zsh y Fish son increíblemente sofisticadas, su funcionalidad central se reduce a un simple bucle: leer un comando, parse, crear un nuevo proceso, y esperar a que termine.

Lo que un Shell realmente hace

En su corazón, un shell es un intérprete de línea de comandos. Proporciona una interfaz textual donde los usuarios escriben comandos, y la cáscara traduce esos comandos en acciones realizadas por el sistema operativo. Cuando escriba ls -la, la cáscara debe encontrar los ls ejecutable, crear un nuevo proceso para ejecutarlo [LT]

Construyendo una cáscara mínima te enseña sobre:

• Entrada de lectura y tokenización de entrada estándar
• Creación y gestión de procesos infantiles con fork]
• Reemplazando la imagen de memoria de un proceso con exec]
• Sincronizar a los padres y a los hijos con esperar]
• Manejo de errores comunes con gracia

Comprender estos bloques de construcción le da una visión de cómo todos los sistemas similares a Unix operan bajo la capucha, y proporciona una base sólida para aprender sobre características más avanzadas como el manejo de señales, el control de empleo y la comunicación entre procesos.

Configuración del bucle de Shell

Cada cáscara se construye alrededor de un bucle principal que repite indefinidamente hasta que el usuario solicita salir. Este bucle imprime un impulso, lee una línea de entrada, la analiza, y luego actúa en el comando analizado. La versión más simple se ve así en pseudocódigo:

while (1) {
 print_prompt();
 read_input();
 parse_input();
 execute_command();
}

En C, normalmente usa fgets] para leer entrada porque maneja límites de línea y desbordamientos de amortiguación más seguro que gets. El impulso puede ser tan simple como una cadena como mysh limitadogt; , pero los verdaderos directorios de trabajo a menudo incluyen el nombre de host

Manejo de casos de borde en la entrada

El nuevo control de la línea de control de la línea blanca es muy fácil. Un robusto shell debe manejar líneas vacías, liderar y seguir el espacio blanco, comandos extremadamente largos, y la condición de extremo (Ctrl+D). Si fgets vuelve a verificar el buffer de la línea blanca, siempre debe romperse el bump y salir con facilidad.

#define MAX_INPUT 1024

char input[MAX_INPUT];
if (fgets(input, MAX_INPUT, stdin) == NULL) {
 printf("\n");
 break; // EOF
}

// Remove trailing newline, if present
size_t len = strlen(input);
if (len > 0 && input[len-1] == '\n') {
 input[len-1] = '\0';
} else {
 // Input too long, flush remaining characters
 int ch;
 while ((ch = getchar()) != '\n' && ch != EOF);
}

Parsing Commands into Arguments

Una vez que usted tiene una cadena de entrada limpia, usted necesita dividirlo en fichas. La primera señal es el nombre de comando (por ejemplo, ls), y los tokens restantes son los argumentos a ese comando. La biblioteca estándar C proporciona strtok ] para este propósito, pero usted debe ser cuidadoso [LT]

char *args[MAX_ARGS];
int arg_count = 0;

args[arg_count] = strtok(input, " \t");
while (args[arg_count] != NULL && arg_count < MAX_ARGS - 1) {
 arg_count++;
 args[arg_count] = strtok(NULL, " \t");
}
args[arg_count] = NULL; // execvp expects a NULL-terminated array

Este tokenizer divide la entrada en espacios y pestañas. Hace no] mango citado cadenas, por lo que un comando como echo "hola mundo"] rompería incorrectamente en tres fichas en lugar de dos. Manejar citas es un valor valioso que requiere un analizador más sofisticado, pero para la más básica de ejecutar

Después de la tokenización, debe comprobar si el primer token es NULL (comando vacío). Si es así, simplemente continúe con la próxima iteración del bucle sin forjar.

Comandos incorporados

No todos los comandos deben desperdiciar un nuevo proceso. Algunos comandos, como cd y exit, deben ser ejecutados por el propio proceso de shell porque afectan el estado de la cáscara. Por ejemplo, cd [[F parent:5]] cambia el directorio de trabajo actual de la cásula;

Exit

El comando exit] termina la cáscara inmediatamente. Es el más simple incorporado para implementar: simplemente comprobar si la primera señal es igual a "exit" y romper el bucle principal. Opcionalmente, puede aceptar un argumento de estado de salida y pasarlo a la llamada del sistema.

Change Directory (cd)

El comando cd] requiere que llames chdir. El directorio objetivo es el segundo argumento. Si no se proporciona ningún argumento, puede predeterminarse al directorio de inicio del usuario (disponible a través de la ]OME] variable entorno.

if (strcmp(args[0], "cd") == 0) {
 const char *path = args[1];
 if (path == NULL) {
 path = getenv("HOME");
 if (path == NULL) {
 fprintf(stderr, "cd: HOME not set\n");
 continue;
 }
 }
 if (chdir(path) != 0) {
 perror("cd");
 }
 continue; // skip fork/exec
}

Creación de procesos con tenedor

Para cualquier comando que no sea un incorporado, su cáscara debe crear un proceso infantil para ejecutarlo. La llamada del sistema crea un nuevo proceso duplicando el proceso de llamada. El nuevo proceso se llama el niño, y el original es el padre. Después parak ambos procesos continúan ejecutando desde el mismo punto en el que se ejecuta el niño.

pid_t pid = fork();
if (pid == -1) {
 perror("fork");
 continue;
}

if (pid == 0) {
 // Child process
 // ...
} else {
 // Parent process
 // ...
}

¿Por qué Fork?

Usted podría preguntarse por qué usted necesita crear un proceso separado en absoluto. La razón es que exec, que carga un nuevo programa en memoria, reemplaza el proceso actual por completo. Si el shell llamado exec directamente, el programa de shell sería reemplazado y nunca volver a aceptar nuevos comandos.

Ejecución de un programa con Exec

[LT:15] exec] familia de funciones reemplaza el proceso actual con un nuevo programa. Hay varias variantes: execl, [FLT[4)] [exc]

if (pid == 0) {
 // Child process
 execvp(args[0], args);

 // If execvp returns, an error occurred
 perror("exec");
 exit(EXIT_FAILURE);
}

int status;
waitpid(pid, &status, 0);

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

#define MAX_INPUT 1024
#define MAX_ARGS 64

int main(void) {
 char input[MAX_INPUT];
 char *args[MAX_ARGS];
 int should_run = 1;

 while (should_run) {
 printf("mysh> ");
 fflush(stdout);

 if (fgets(input, MAX_INPUT, stdin) == NULL) {
 printf("\n");
 break;
 }

 // Remove trailing newline
 size_t len = strlen(input);
 if (len > 0 && input[len-1] == '\n') {
 input[len-1] = '\0';
 }

 // Tokenize
 int i = 0;
 args[i] = strtok(input, " \t");
 while (args[i] != NULL && i < MAX_ARGS - 1) {
 i++;
 args[i] = strtok(NULL, " \t");
 }
 args[i] = NULL;

 if (args[0] == NULL) {
 continue; // empty line
 }

 // Handle built-in commands
 if (strcmp(args[0], "exit") == 0) {
 should_run = 0;
 continue;
 }
 if (strcmp(args[0], "cd") == 0) {
 const char *path = args[1];
 if (path == NULL) {
 path = getenv("HOME");
 }
 if (chdir(path) != 0) {
 perror("cd");
 }
 continue;
 }

 // Fork and execute external command
 pid_t pid = fork();
 if (pid < 0) {
 perror("fork");
 continue;
 }

 if (pid == 0) {
 // Child
 execvp(args[0], args);
 perror("exec");
 exit(EXIT_FAILURE);
 } else {
 // Parent waits
 int status;
 waitpid(pid, &status, 0);
 }
 }

 return 0;
}