基于c++实现的简易shell

代码逻辑

核心思想

解析命令行，拆解命令及其选项
创建子进程，在子进程中执行命令
如果是前台执行命令，则父进程就阻塞等待子进程中命令执行结束后回收子进程的资源
如果是后台执行命令，则父进程不进行阻塞等待，可继续向下运行，但为了防止僵尸进程的出现，需要设置一个信号函数，当后台子进程的命令执行结束后，会给父进程发送一个SIGCHLD信号，父进程的信号函数收到该信号后知道子进程执行结束了，于是执行waitpid系统函数回收子进程

小知识

僵尸进程

每个进程都有一个父进程，当该进程执行结束后，其资源需要被父进程回收，否则会占用系统资源。
父进程回收子进程的办法就是通过调用waitpid函数阻塞等待子进程的执行结束。
僵尸进程就是指当一个进程结束之后，父进程由于一些原因迟迟不回收其子进程的资源，从而导致该进程一直占用着系统资源，这时该进程就成为僵尸进程。

比如，当一个父进程由于业务原因需要一直运行，那么由他所创建的子进程结束之后，如果不进行回收就会成为一个僵尸进程，而该父进程由于业务原因也不可能阻塞等待子进程执行结束之后回收子进程，此时就需要设置信号函数来回收进程

孤儿进程

与僵尸进程对应的还有一个概念叫孤儿进程

前面我们说，每个进程都一个父进程，负责将其所创建的子进程执行结束之后回收子进程的资源，但前提是，父进程需要活到子进程执行结束的时候，因此如果该子进程执行结束之前，父进程先挂掉了，这种情况下的子进程就叫孤儿进程

但孤儿进程的危害其实并不大，尽管父进程挂掉了，但是还有祖宗收场，因此，系统会将孤儿进程挂到进程号为0，也就是init进程下，由他负责回收孤儿进程的资源

信号

信号是进程间通信的一种机制，通常用来通知进程发生了某种事件，如中断、错误或特定条件的满足。
信号可以被发送到进程以提醒其执行特定操作，例如终止、暂停或处理错误。
常见的信号包括 SIGINT（中断信号）、SIGTERM（终止信号）等。通过信号，程序可以对系统事件进行响应，提高灵活性和控制能力。

本文中的shell代码中涉及到了SIGCHLD信号的使用，该信号用于子进程结束或停止时，通知父进程其子进程的状态改变。父进程可以通过捕获此信号来调用 wait() 或 waitpid() 函数，以获取子进程的退出状态并回收资源。这有助于防止僵尸进程的产生，确保资源得到有效管理。

源码

main.cc

#include <iostream>
#include <string>
constexpr int CMDMAXSIZE = 1024;
void eval(const char *cmdline);
void shell() {
    char cmdline[CMDMAXSIZE] = {0};
    while (1) {
        std::cout << ">";
        // 读取stdin输入的命令行
        if (!fgets(cmdline, sizeof(cmdline), stdin)) {
            // 判断是否输入到文件尾
            if (feof(stdin))
                exit(0);
        }
        // 解析命令行并执行命令
        eval(cmdline);
    }
}

int main() {
    shell();
    return 0;
}

eval.cc

该文件用于解析命令后执行命令

#include <iostream>
#include <signal.h>
#include <string>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
constexpr int ARGSIZE = 1024;

//解析命令并将其存储到argv,并返回该命令是一个后台命令
int parseline(const char *command, char **argv);
// 判断是否是一个shell内置命令，如果是就直接执行，否则返回false
int inlinecommand(char **argv);
// 后台回收进程
void backprogrom(int sig);

void eval(const char *cmdline) {
    if (!cmdline)
        return;
    char *argv[ARGSIZE] = {0};
    // 解析命令并判断是否是后台命令
    int bg = parseline(cmdline, argv);
    if (bg == -1)
        return;
    // 判断是否是shell内置命令，如果是就直接执行，并返回标志
    int flag = inlinecommand(argv);
    if (flag == -1)
        return;

    pid_t pid;
    // 判断是否是shell内置命令，如果是就处理内置命令，否则说明是一个可执行文件
    if (!flag) {
        // 无论是不是后台命令，都执行可执行文件
        if ((pid = fork()) == 0) {
            if (execve(argv[0], argv, environ) < 0) {
                std::cerr << "exec failed!" << std::endl;
                _exit(1);
            }
        } else if (pid > 0) {
            if (!bg) {
                // 如果不是后台命令，父进程需要阻塞等待子进程(也就是命令行)的执行
                wait(nullptr);
            } else if (bg > 0) { //如果是后台命令，父进行不需要阻塞等待子进程执行结束
                std::cout << "pid [" << pid << "] " << argv[0] << " running..."
                          << std::endl;
                signal(SIGCHLD, backprogrom);
            }
        }
    }
}

parseline.cc

该文件负责解析命令行及其选项，并返回判断是否为后台命令

#include <sstream>
#include <string>
#include <vector>
int parseline(const char *command, char **argv) {
    std::stringstream cmdline(command);
    std::vector<std::string> argv_vec;
    std::string cmd;
    while (cmdline >> cmd) {
        argv_vec.emplace_back(cmd);
    }
    if (argv_vec.empty())
        return -1;

    int argc = 0;
    for (auto &str : argv_vec) {
        argv[argc++] = const_cast<char *>(str.c_str());
    }

    if (argv_vec[argv_vec.size() - 1] == "&") {
        argv[argc - 1] = nullptr;
        return 1;
    }

    argv[argc] = nullptr;
    return 0;
}

inlinecommand.cc

该文件用于判断输入的命令是否是shell的内置命令，如果是就直接执行之

#include <iostream>
#include <stdlib.h>
#include <string>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <unordered_set>
constexpr int CMDMAXSIZE = 1024;

static std::unordered_set<std::string> inlinecmd = {"ls", "pwd", "clear"};

int inlinecommand(char **argv) {
    std::string cmd(argv[0]);
    if (cmd == "exit") {
        exit(1);
    }
    auto it = inlinecmd.find(cmd);
    if (it != inlinecmd.end()) {
        pid_t pid = fork();
        if (pid == 0) {
            if (execvp(cmd.c_str(), argv) < 0) {
                std::cout << argv[0] << " exec error!" << std::endl;
            }
        }
        return 1;
    }
    return 0;
}

backwait.cc

该文件用于回收后台命令所在的子进程的资源

#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
/*
1. exit
库：exit 定义在 <stdlib.h> 中。
功能：exit 在程序终止时会执行以下操作：
    调用所有已注册的 atexit 函数。
    刷新标准 I/O 缓冲区，确保所有数据都被写入。
    返回控制给操作系统，返回值为 exit 的参数。
适用场景：通常用于正常退出程序。
2. _exit
库：_exit 定义在 <unistd.h> 中。
功能：_exit 直接终止进程，不执行任何清理操作：
    不调用 atexit 函数。
    不刷新 I/O 缓冲区。
    直接将控制权返回给操作系统，返回值为 _exit 的参数。
适用场景：通常在子进程中使用，如在
    fork后立即退出，以避免在父进程和子进程之间共享未刷新缓冲的数据。
*/
ssize_t sio_puts(const char s[]) { return write(STDOUT_FILENO, s, strlen(s)); }
void sio_error(const char s[]) {
    sio_puts(s);
    return _exit(1);
}

void backprogrom(int sig) {
    int olderrno = errno;
    while (waitpid(-1, nullptr, WNOHANG) > 0) {
        sio_puts("reaped child\n");
    }
    if (errno != ECHILD)
        sio_error("wait_pid error!");
    errno = olderrno;
}