Cómo crear un shell simple en c?
Este tutorial lo guiará a través de las etapas de crear un shell simple independiente en C. Después de completar este tutorial, debe comprender mejor los diversos procesos y funciones involucradas, así como una forma clara de codificar por sí mismo por usted.
¿Cuál es la vida básica del caparazón??
Durante su vida útil, un shell realiza tres tareas principales.
- Inicializar: En esta etapa, un shell típico leerá y ejecutará su conjunto de archivos de configuración. Estos alteran el comportamiento del caparazón.
- Interpretar: El shell luego lee comandos de "stdin" y los ejecuta.
- Terminar: Después de la ejecución de sus comandos, el shell realiza cualquiera de los comandos de cierre, libera cualquier memoria y termina.
Estas etapas son generales y pueden ser aplicables a una amplia gama de programas, pero las utilizaremos como base para nuestro shell. Nuestro shell será tan básico que no habrá archivos de configuración y ningún comando de cierre. Entonces, simplemente ejecutaremos la función de bucle y luego saldremos. Sin embargo, es esencial recordar que la vida útil del programa es más que simplemente bucle.
Cómo crear un shell simple en c?
Crearemos un shell básico en C que demostrará los fundamentos de cómo funciona. Debido a que su objetivo es la demostración en lugar de la integridad o incluso la aptitud para uso casual, tiene una serie de limitaciones, incluidas
- Todos los comandos deben escribirse en una línea.
- Se debe utilizar el espacio en blanco para separar los argumentos.
- No habrá cotizaciones o escapadas en blanco.
- No hay tuberías ni redirios.
- Los únicos empotrados son 'CD', 'Ayuda' y 'Salir'.
Ahora eche un vistazo a un programa C que está construyendo un shell simple.
#incluir#incluir
#incluir
#incluir
#incluir
#incluir
int komal_cd (char ** args);
int komal_help (char ** args);
int komal_exit (char ** args);
char *built_in_string [] =
"cd",
"ayuda",
"salida"
;
int (*built_in_function []) (char **) =
& komal_cd,
& komal_help,
& komal_exit
;
int komal_builtins ()
return sizeof (built_in_string) / sizeof (char *);
int komal_cd (char ** args)
if (args [1] == nulo)
fprintf (stderr, "Komal: argumento esperado a" CD "\ n");
demás
if (chdir (args [1]) != 0)
Perror ("Komal");
regresar 1;
int komal_help (char ** args)
int i;
printf ("Esta es una construcción de shell C simple por Komal Batool \ n");
printf ("Escriba nombres y argumentos de programa, y presione Enter.\norte");
printf ("Los siguientes están integrados: \ n");
para (i = 0; i < komal_builtins(); i++)
printf (" %s \ n", built_in_string [i]);
printf ("Use el comando MAN para obtener información sobre otros programas.\norte");
regresar 1;
int komal_exit (char ** args)
regresar 0;
int komal_launch (char ** args)
pid_t pid;
estado int;
pid = horqu ();
if (pid == 0)
if (execvp (args [0], args) == -1)
Perror ("Komal");
salida (exit_failure);
else if (pid < 0)
Perror ("Komal");
demás
hacer
Waitpid (PID y estado, Wuntraced);
mientras (!Esposaxited (estado) && !Wifsignaled (estado));
regresar 1;
int komal_execute (char ** args)
int i;
if (args [0] == nulo)
regresar 1;
para (i = 0; i < komal_builtins(); i++)
if (strcmp (args [0], built_in_string [i]) == 0)
return (*built_in_function [i]) (args);
return komal_launch (args);
char *komal_read_line (void)
#ifdef komal_use_std_getline
char *line = null;
ssize_t bufsize = 0;
if (getline (& line y bufsize, stdin) == -1)
if (FEOF (Stdin))
salir (exit_success);
demás
perror ("komal: getline \ n");
salida (exit_failure);
Linea de retorno;
#demás
#define komal_rl_bufsize 1024
int bufSize = komal_rl_bufsize;
INT POSICIÓN = 0;
char * buffer = malloc (sizeOf (char) * bufsize);
int c;
si (!buffer)
fprintf (stderr, "komal: error de asignación \ n");
salida (exit_failure);
mientras (1)
c = getchar ();
if (c == eof)
salir (exit_success);
más si (c == '\ n')
buffer [posición] = '\ 0';
buffer de retorno;
demás
búfer [posición] = c;
posición ++;
if (posición> = bufsize)
bufSize += komal_rl_bufsize;
buffer = REALLOC (buffer, bufsize);
si (!buffer)
fprintf (stderr, "komal: error de asignación \ n");
salida (exit_failure);
#terminara si
#define komal_tok_bufsize 64
#define komal_tok_delim "\ t \ r \ n \ a"
char ** komal_split_line (línea char *)
int bufSize = komal_tok_bufsize, posición = 0;
char ** tokens = malloc (bufsize *sizeof (char *));
char *token, ** tokens_backup;
si (!tokens)
fprintf (stderr, "komal: error de asignación \ n");
salida (exit_failure);
token = strtok (línea, komal_tok_delim);
mientras (token != Nulo)
tokens [posición] = token;
posición ++;
if (posición> = bufsize)
bufSize += komal_tok_bufsize;
tokens_backup = tokens;
tokens = reasLoc (tokens, bufSize * sizeof (char *));
si (!tokens)
gratis (tokens_backup);
fprintf (stderr, "komal: error de asignación \ n");
salida (exit_failure);
token = strtok (null, komal_tok_delim);
tokens [posición] = nulo;
tokens de regreso;
Void Komal_loop (Void)
Línea char *;
char ** args;
estado int;
hacer
printf (">");
línea = komal_read_line ();
args = komal_split_line (línea);
status = komal_execute (args);
Línea libre);
gratis (args);
while (status);
int main (int argc, char ** argv)
komal_loop ();
return exit_success;
Descripción del código
El código anterior es una implementación simple de un shell de línea de comandos escrito en c. El caparazón se nombra "Komal", y puede ejecutar comandos incorporados como "CD", "Ayuda" y "Salir", así como comandos externos. La función principal del programa es el "Komal_loop" función, que boques continuamente, leyendo la entrada del usuario a través del usuario "Komal_read_line" función, dividir la entrada en argumentos individuales utilizando el "Komal_split_line" función y ejecutar el comando utilizando el "Komal_Execute" función.
El "Komal_Execute" Comprobaciones de funciones si el comando es un comando incorporado, y si es así, ejecuta la función incorporada correspondiente. Si el comando no es un comando incorporado, ejecuta un comando externo al bifurcarse un proceso infantil y llamando al "ExecVP" Llamada del sistema para reemplazar el espacio de memoria del proceso infantil con el programa deseado.
El "Komal_CD", "Komal_help", y "Komal_exit" Las funciones son las tres funciones integradas que el usuario puede ejecutar. "Komal_CD" Cambia el directorio de trabajo actual, "Komal_help" proporciona información sobre el shell y sus comandos incorporados, y "Komal_exit" sale del caparazón.
Producción
Conclusión
La construcción de un shell simple en C implica comprender cómo analizar y ejecutar comandos, manejar la entrada y salida del usuario, y administrar procesos utilizando llamadas de sistema como la bifurcación y execVP. El proceso de crear un shell requiere una comprensión profunda del lenguaje de programación C y el sistema operativo UNIX. Sin embargo, con la ayuda de los pasos y el ejemplo proporcionados en la guía anterior, se puede crear un shell básico que pueda manejar la entrada del usuario y ejecutar comandos.