从零开始编写 Linux 自定义 Shell：原理与 C++ 实现

这里有个小细节：我们在提示符末尾使用了 # 而不是 $，以便区分这是我们的自定义 Shell。同时，利用 getenv 获取环境变量时做了空值检查，防止程序崩溃。

2. 获取命令行参数

Shell 需要持续监听用户的输入。我们使用 fgets 安全地读取一行，并手动去除换行符。

bool GetCommandLine(char* out, int size) {
    char* c = fgets(out, size, stdin);
    if (c == NULL) return false;
    // 去掉换行符
    out[strlen(out) - 1] = 0;
    // 如果只输入了回车，返回 false 重新开始
    if (strlen(out) == 0) return false;
    return true;
}

3. 命令行解析

拿到原始字符串后，我们需要将其分割成参数数组（argv）。这里使用 C 语言的 strtok 函数，以空格为分隔符。

#define DELIM " "
#define ARGV_MAX 1024

char* g_argv[ARGV_MAX];
int g_argc = 0;

bool CommandParse(char* commandline) {
    g_argc = 0;
    g_argv[g_argc++] = strtok(commandline, DELIM);
    if (g_argv[0] == NULL) return false;
    while ((bool)(g_argv[g_argc++] = strtok(NULL, DELIM)));
    g_argc--;
    return true;
}

注意 strtok 会修改原字符串，且第一次调用需传入待分割字符串，后续调用传入 NULL。循环结束后记得回退一次 argc，因为最后一次 strtok 返回 NULL 也会触发计数。

4. 执行命令

这是核心部分。我们需要 fork 一个子进程，并在其中执行命令。

#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <errno.h>

int lastcode = 0;

void Execute() {
    pid_t id = fork();
    if (id < 0) {
        perror("fork failed:");
        exit(1);
    } else if (id == 0) {
        // 子进程：执行命令
        execvp(g_argv[0], g_argv);
        exit(1); // exec 失败才会执行到这里
    }
    // 父进程：等待子进程
    int status;
    pid_t rid = waitpid(id, &status, 0);
    if (rid > 0) {
        lastcode = WEXITSTATUS(status);
    }
}

这里选择 execvp 是因为它支持搜索 PATH 环境变量，方便执行系统命令。同时，我们在父进程中捕获了子进程的退出状态，保存给 lastcode 变量，供后续内建命令（如 echo $?）使用。

5. 内建命令

像 cd 或 echo 这样的命令不需要创建子进程，直接在当前 Shell 进程中执行效率更高。我们需要先判断命令类型。

bool IsBuiltInCommand() {
    if (!strcmp(g_argv[0], "cd")) {
        CommandCd();
        return true;
    } else if (!strcmp(g_argv[0], "echo")) {
        CommandEcho();
        return true;
    }
    return false;
}

cd 命令

cd 涉及目录切换和环境变量更新。我们需要记录旧目录到 OLDPWD，新目录到 PWD。

void CommandCd() {
    int ret;
    std::string old_dir = get_current_dir_name();
    if (g_argc == 1) {
        // cd 默认进入家目录
        std::string home = GetHome();
        if (home.empty()) exit(1);
        ret = chdir(home.c_str());
    } else {
        std::string where = g_argv[1];
        if (where == "-") {
            ret = chdir(GetOldpwd());
        } else if (where == "~") {
            ret = chdir(GetHome());
        } else {
            ret = chdir(where.c_str());
        }
    }
    if (ret == -1) {
        perror("cd");
        lastcode = 1;
    } else {
        lastcode = 0;
        setenv("PWD", get_current_dir_name(), 1);
        setenv("OLDPWD", old_dir.c_str(), 1);
    }
}

echo 命令

除了打印文本，还需要支持 $? 查看上一条命令的退出码。

void CommandEcho() {
    if (g_argc == 1) {
        printf("\n");
    } else {
        std::string opt = g_argv[1];
        if (opt == "$") {
            std::cout << lastcode << std::endl;
        } else if (opt[0] == '$') {
            std::string env_name = opt.substr(1);
            const char* env_value = getenv(env_name.c_str());
            if (env_value) std::cout << env_value << std::endl;
        } else {
            std::cout << opt << std::endl;
        }
    }
    lastcode = 0;
}

小结

至此，一个具备基本功能的自定义 Shell 就完成了。对比真实的 Shell，它还非常简陋，但核心机制已经跑通。

我们可以把进程和函数的关系类比为程序的调用：exec/exit 就像 call/return。被调用的程序执行操作后通过 exit 返回值，调用者通过 wait 获取结果。这种模式是结构化程序设计的基础，Linux 鼓励将其扩展到进程间通信中。

完整源码

#include <iostream>
#include <cstring>
#include <string>
#include <cstdlib>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <errno.h>

#define CMDLINE_MAX 1024
#define FORMAT "[%s@%s %s]# "
#define DELIM " "
#define SLASH "/"

#define ARGV_MAX 1024
char* g_argv[ARGV_MAX];
int g_argc = 0;

int lastcode = 0;

void InitEnv() {
    extern char** environ;
    // 初始化环境变量表
    for (int i = 0; environ[i]; i++) {
        putenv(environ[i]);
    }
}

const char* GetPwd() {
    const char* pwd = getenv("PWD");
    return pwd == NULL ? "None" : pwd;
}

const char* GetOldpwd() {
    const char* oldpwd = getenv("OLDPWD");
    return oldpwd == NULL ? "None" : oldpwd;
}

const char* GetHome() {
    const char* home = getenv("HOME");
    return home == NULL ? "None" : home;
}

const char* GetHostName() {
    const char* hostname = getenv("HOSTNAME");
    return hostname == NULL ? "None" : hostname;
}

const char* GetUser() {
    const char* user = getenv("USER");
    return user == NULL ? "None" : user;
}

std::string GetPwdDir(const char* pwd) {
    std::string dir = pwd;
    if (dir == SLASH) return SLASH;
    auto pos = dir.rfind(SLASH);
    if (pos == std::string::npos) return "BUG";
    return dir.substr(pos + 1);
}

void MakeCommandPrompt(char* out, int size) {
    snprintf(out, size, FORMAT, GetUser(), GetHostName(), GetPwdDir(GetPwd()).c_str());
}

void PrintCommandPrompt() {
    char prompt[CMDLINE_MAX];
    MakeCommandPrompt(prompt, CMDLINE_MAX);
    printf("%s", prompt);
    fflush(stdout);
}

bool GetCommandLine(char* out, int size) {
    char* c = fgets(out, size, stdin);
    if (c == NULL) return false;
    out[strlen(out) - 1] = 0;
    if (strlen(out) == 0) return false;
    return true;
}

bool CommandParse(char* commandline) {
    g_argc = 0;
    g_argv[g_argc++] = strtok(commandline, DELIM);
    if (g_argv[0] == NULL) return false;
    while ((bool)(g_argv[g_argc++] = strtok(nullptr, DELIM)));
    g_argc--;
    return true;
}

void Execute() {
    pid_t id = fork();
    if (id < 0) {
        perror("fork failed:");
        exit(1);
    } else if (id == 0) {
        execvp(g_argv[0], g_argv);
        exit(1);
    }
    int status;
    pid_t rid = waitpid(id, &status, 0);
    if (rid > 0) {
        lastcode = WEXITSTATUS(status);
    }
}

void CommandCd() {
    int ret;
    std::string old_dir = get_current_dir_name();
    if (g_argc == 1) {
        std::string home = GetHome();
        if (home.empty()) exit(1);
        ret = chdir(home.c_str());
    } else {
        std::string where = g_argv[1];
        if (where == "-") {
            ret = chdir(GetOldpwd());
        } else if (where == "~") {
            ret = chdir(GetHome());
        } else {
            ret = chdir(where.c_str());
        }
    }
    if (ret == -1) {
        perror("cd");
        lastcode = 1;
    } else {
        lastcode = 0;
        setenv("PWD", get_current_dir_name(), 1);
        setenv("OLDPWD", old_dir.c_str(), 1);
    }
}

void CommandEcho() {
    if (g_argc == 1) {
        printf("\n");
    } else {
        std::string opt = g_argv[1];
        if (opt == "$") {
            std::cout << lastcode << std::endl;
        } else if (opt[0] == '$') {
            std::string env_name = opt.substr(1);
            const char* env_value = getenv(env_name.c_str());
            if (env_value) std::cout << env_value << std::endl;
        } else {
            std::cout << opt << std::endl;
        }
    }
    lastcode = 0;
}

bool IsBuiltInCommand() {
    if (!strcmp(g_argv[0], "cd")) {
        CommandCd();
        return true;
    } else if (!strcmp(g_argv[0], "echo")) {
        CommandEcho();
        return true;
    }
    return false;
}

int main() {
    InitEnv();
    while (true) {
        PrintCommandPrompt();
        char commandline[CMDLINE_MAX];
        if (!GetCommandLine(commandline, CMDLINE_MAX)) continue;
        if (!CommandParse(commandline)) continue;
        if (IsBuiltInCommand()) continue;
        Execute();
    }
    return 0;
}

通过这个项目，我们不仅复习了进程控制（fork/exec/wait），还深入理解了环境变量和 Shell 的工作机制。实际开发中，Shell 的处理要复杂得多（信号处理、作业控制等），但这个基础框架足以让我们窥见操作系统交互的本质。