Construindo uma Concha Básica em C: Processando Comandos e executando Processos

Bloqueamento vs. Não Bloqueamento

A chamada simples [[FLT: 0]] waitpid[[[ FLT: 1]] acima bloqueia o pai até que o filho saia. Este é o comportamento correto para um processo de primeiro plano. Se você adicionar mais tarde suporte para processos de fundo (executando um comando com [[ FLT: 2]]]&[[ FLT: 3]], você definiria a opção [[ FLT: 4] WNOHANG[[[[ FLT: 5]]] para evitar bloqueios, e você precisaria gerenciar uma lista de PIDs infantis para colhe- los mais tarde.

Juntando a Concha Plena

Aqui está uma shell completa e mínima que integra todas as peças discutidas até agora. Ela lida com a entrada ]exit e cd[ built-ins, análise de entrada usando strtok[[, garfos para comandos externos, e espera que a criança termine. Para clareza, a verificação de erros está incluída, mas mantida concisa.

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

Este código é uma shell completa e funcional. Copie- o para um ficheiro chamado myshell.c[, compile- o com gcc - o myshell myshell.c, e execute- o. Você verá uma linha de comandos onde poderá escrever comandos como ls[, pwd[, echo hello, e cd /tmp[]. O comando exit] termina a shell.

Dicas de Depuração e Pilhas Comuns

Mesmo com esta pequena quantidade de código, várias coisas podem dar errado. Aqui estão os problemas mais frequentes e como corrigi-los:

Comando Não Encontrado

Se você digitar um comando que não existe (por exemplo, ]] foobar, execvp[ retorna e o filho imprime "exec: Nenhum arquivo ou diretório" antes de sair. Este é o comportamento correto, mas você pode querer imprimir uma mensagem amigável. Você pode verificar errno[ depois execvp[] não consegue distinguir entre "arquivo não encontrado" e "permissão negada".

Falta a Nova Linha ou Entrada Truncada

Se o seu prompt aparecer sem esperar pela entrada, a causa provável é os caracteres restantes no buffer de entrada de uma chamada anterior. Verifique sempre se [[FLT: 0]] fgets[[ FLT: 1]] consumiu a linha inteira (ou seja, que o último caractere antes do terminador nulo é uma nova linha). Se não for, anule a entrada restante como mostrado anteriormente.

Processos de Zombies

Se você se esquecer de chamar aguarde (ou waitpid[, processos infantis que terminam se tornam zumbis até que você os colhe. A concha no exemplo chama waitpid, então zumbis não devem aparecer. No entanto, se você adicionar mais tarde processos de fundo e não conseguir colhe- los, o acúmulo de zumbi pode se tornar um problema. A solução é instalar um SIGCHLD[] manipulador que chama waitpid com WOHANG[[] para limpar crianças completadas.

Estendendo a Shell

Uma vez que você tenha a shell básica funcionando, você pode adicionar recursos que a aproximam de uma shell do mundo real. Cada recurso ensina mais sobre o sistema operacional.

Redirecionamento de entrada/saída

Suportando >, <[, e >>] requer que você analise a linha de comando para estes operadores, abra os arquivos apropriados usando ]]aberto[, e use dup2[[] para redirecionar a entrada padrão ou saída antes de chamar execvp[[. Isto é feito no processo infantil entre ]fork[[ e exec.

Tubos

A entrada de um comando na entrada de outro (]cmd1 , cmd2[ ])) está mais envolvida. Você precisa criar um tubo com pipe[ , bifurcar dois processos filhos, redirecionar a saída de uma criança para o final de gravação do tubo e a entrada do outro para o final lido, e esperar que ambos terminem.

Controle de tarefas

A adição de execução de fundo (&] no final de um comando) e a capacidade de trazer trabalhos para o primeiro plano requerem a gestão de uma tabela de tarefas, o tratamento SIGTSTP, SIGCONT[[], e [SIGCHLD[[, e o uso [tcsetpgrp[[] para gerir a propriedade de terminal.

Histórico de Comandos

A implementação de um mecanismo de histórico simples (setas para cima/para baixo para recordar comandos anteriores) envolve a captura de entrada usando o modo terminal bruto (via tcgetattr[] e tcsetatttr) ou usando a biblioteca de leitura , que fornece esta funcionalidade fora da caixa.