从零手写 Linux 简易 Shell：内建命令、环境变量与进程替换详解

2.3 核心实现（myshell.c 优化版）

这里展示了完整的 C 语言实现，包含了环境变量管理、提示符生成、命令解析及进程控制。

#include "myshell.h"
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <ctype.h>

// 提示符相关：用户名、主机名、当前工作目录
static char username[32];
static char hostname[64];
static char cwd[256];
static char commandLine[256];

// 命令行解析相关：argv 存储命令参数，argc 为参数个数
static char* argv[64];
static int argc = 0;
static const char* sep = " ";

// 退出码：记录上一条命令的执行结果（0 成功，非 0 失败）
static int lastCode = 0;

// 环境变量相关
char** _environ;
static int envc = 0;

// -------------------------- 环境变量相关函数 --------------------------
// 初始化环境变量：从系统 environ 数组拷贝
static void InitEnv() {
    extern char** environ;
    for (envc = 0; environ[envc]; envc++) {
        _environ[envc] = environ[envc];
    }
}

// 查找环境变量：返回环境变量值
static char* GetEnv(const char* key) {
    if (key == NULL) return NULL;
    int key_len = strlen(key);
    for (int i = 0; _environ[i] != NULL; i++) {
        if (strncmp(_environ[i], key, key_len) == 0 && _environ[i][key_len] == '=') {
            return _environ[i] + key_len + 1;
        }
    }
    return NULL;
}

// 添加环境变量：用于 export 命令
static void AddEnv(const char* val) {
    _environ[envc] = (char*)malloc(strlen(val) + 1);
    strcpy(_environ[envc], val);
    _environ[++envc] = NULL;
}

// 打印所有环境变量：用于 env 命令
static void PrintAllEnv() {
    int i = 0;
    for (; _environ[i] != NULL; i++) {
        printf("%s\n", _environ[i]);
    }
}

// -------------------------- 提示符相关函数 --------------------------
static void GetUserName() {
    char* _username = getenv("USER");
    strcpy(username, (_username ? _username : "None"));
}

static void GetHostName() {
    char* _hostname = getenv("HOSTNAME");
    strcpy(hostname, (_hostname ? _hostname : "None"));
}

static void GetCmd() {
    char _cwd[256];
    getcwd(_cwd, sizeof(_cwd));
    if (strcmp(_cwd, "/") == 0) {
        strcpy(cwd, _cwd);
    } else {
        int end = strlen(_cwd) - 1;
        while (end >= 0 && _cwd[end] != '/') end--;
        strcpy(cwd, &_cwd[end + 1]);
    }
}

static void PrintPrompt() {
    GetUserName();
    GetHostName();
    GetCmd();
    printf("[%s@%s %s]# ", username, hostname, cwd);
    fflush(stdout);
}

// -------------------------- 命令读取与解析 --------------------------
static void GetCommandLine() {
    memset(commandLine, 0, sizeof(commandLine));
    if (fgets(commandLine, sizeof(commandLine), stdin) != NULL) {
        size_t len = strlen(commandLine);
        if (len > 0 && commandLine[len - 1] == '\n') {
            commandLine[len - 1] = '\0';
        }
    }
}

static void ParseCommandLine() {
    argc = 0;
    memset(argv, 0, sizeof(argv));
    if (strlen(commandLine) == 0) return;
    
    argv[argc++] = strtok(commandLine, sep);
    while ((argv[argc] = strtok(NULL, sep)) != NULL) {
        argc++;
    }
    argv[argc] = NULL; // exec 函数要求以 NULL 结尾
}

// -------------------------- 内建命令处理 --------------------------
static int CheckBuiltinAndExecute() {
    int ret = 0;
    
    // 1. cd 命令
    if (strcmp(argv[0], "cd") == 0) {
        ret = 1;
        if (argc == 2) {
            chdir(argv[1]);
        }
    }
    // 2. echo 命令
    else if (strcmp(argv[0], "echo") == 0) {
        ret = 1;
        if (argc == 2) {
            if (argv[1][0] == '$') {
                if (strcmp(argv[1], "?$") == 0) {
                    printf("%d\n", lastCode);
                    lastCode = 0;
                } else {
                    char* val = GetEnv(argv[1] + 1);
                    if (val != NULL) {
                        printf("%s\n", val);
                    } else {
                        printf("\n");
                    }
                }
            } else {
                printf("%s\n", argv[1]);
            }
        }
    }
    // 3. export 命令
    else if (strcmp(argv[0], "export") == 0) {
        ret = 1;
        if (argc == 2) {
            AddEnv(argv[1]);
        }
    }
    // 4. env 命令
    else if (strcmp(argv[0], "env") == 0) {
        ret = 1;
        PrintAllEnv();
    }
    // 5. exit 命令
    else if (strcmp(argv[0], "exit") == 0) {
        exit(0);
    }
    
    return ret;
}

// -------------------------- 外部命令执行 --------------------------
static void Execute() {
    pid_t id = fork();
    if (id < 0) {
        perror("fork error");
        return;
    } else if (id == 0) {
        // 子进程：程序替换
        execvp(argv[0], argv);
        exit(1);
    } else {
        // 父进程：等待子进程退出
        int status = 0;
        waitpid(id, &status, 0);
        lastCode = WEXITSTATUS(status);
    }
}

// -------------------------- Shell 主循环 --------------------------
void bash() {
    static char* env[64];
    _environ = env;
    
    InitEnv();
    
    while (1) {
        PrintPrompt();
        GetCommandLine();
        ParseCommandLine();
        
        if (argc == 0) continue;
        
        if (CheckBuiltinAndExecute()) continue;
        
        Execute();
    }
}

三. 核心功能解析

3.1 环境变量管理

环境变量是 Shell 的重要特性，本文实现了完整的环境变量生命周期管理：

• 初始化：InitEnv() 从系统 environ 数组拷贝环境变量（如 PATH、HOME），确保外部命令能通过 PATH 找到执行文件；
• 添加 / 覆盖：AddEnv() 用于 export 命令，支持新增或覆盖已有变量；
• 查找：GetEnv() 用于 echo $KEY 场景，根据键名查找值；
• 打印：PrintAllEnv() 用于 env 命令，列出所有环境变量。

3.2 内建命令实现

• cd：调用 chdir() 切换工作目录，必须内建，否则子进程切换不影响父进程；
• echo：支持打印普通字符串、退出码（$?）和环境变量（$PATH）；
• export：调用 AddEnv() 添加环境变量；
• env：调用 PrintAllEnv() 打印所有环境变量；
• exit：调用 exit(0) 退出 Shell。

3.3 外部命令执行

• 进程创建：fork() 创建子进程，隔离外部命令执行环境；
• 程序替换：execvp() 自动搜索 PATH 环境变量，无需写命令全路径；
• 进程等待：waitpid() 等待子进程退出，获取退出码并存储到 lastCode，供 echo $? 使用。

3.4 关键技术点总结

• 程序替换本质：execvp 会替换子进程的代码和数据段，加载新程序执行，进程 PID 不变；
• 内建命令必要性：修改 Shell 自身状态的命令（如 cd、export）必须内建；
• 环境变量格式：环境变量数组必须以 NULL 结尾，exec 系列函数依赖此格式；
• 命令解析细节：需处理连续空格、开头空格等异常输入，确保 argv 符合规范。

四. 思考：函数和进程之间的相似性

exec/exit 就像 call/return。

一个 C 程序由多个函数组成，函数间通过参数传递数据和返回值通信。Linux 鼓励将这种模式扩展到程序之间：

• 一个 C 程序可以 fork/exec 另一个程序，并传给它一些参数；
• 被调用的程序执行操作后，通过 exit(n) 返回值；
• 调用它的进程可以通过 wait(&ret) 获取返回值。

这种机制使得进程间的通信与控制更加结构化，类似于函数调用栈的扩展。

结语

本文实现的简易 Shell 虽不及 bash 功能强大，但覆盖了核心工作原理 —— 通过 fork 创建子进程、exec 替换程序、wait 等待结果，再配合内建命令和环境变量管理，就能完成与用户的交互。在此基础上，还可扩展更多功能：支持管道（ls | grep txt）、重定向（ls > log.txt）、后台运行（sleep 10 &）等。如果需要进一步优化，可重点关注命令解析的健壮性（如支持引号包含空格的参数）和信号处理（如 Ctrl+C 终止前台进程）。