【SEU-OS-Lab3】东南大学操作系统专题实践三教程

小包子2025-01-242025-01-25

实验要求

实现具有管道、重定向功能的shell，能够执行一些简单的基本命令，如进程执行、列目录等

具体要求：

设计一个C语言程序，完成最基本的shell角色：给出命令行提示符、能够逐次接受命令；
- 对于命令分成三种内部命令（例如help命令、exit命令等）
- 外部命令（常见的ls、cp等，以及其他磁盘上的可执行程序HelloWrold等）
- 无效命令（不是上述二种命令）
具有支持管道的功能，即在shell中输入诸如“dir | more”能够执行dir命令并将其输出通过管道将其输入传送给more。
具有支持重定向的功能，即在shell中输入诸如“dir > direct.txt”能够执行dir命令并将结果输出到direct.txt

实验目的

通过实验了解Shell实现机制。

实验环境

WSL2
Ubuntu22.04

实验内容

基础知识

命令类型

管道命令
定义：使用管道符（|）将多个简单命令连接起来。
特点：相邻两个简单命令中，左边命令的输出作为右边命令的输入。
简单命令
包括以下三种类型：
1. 外置命令：
  定义：Linux系统中自带的可执行文件，通常是C语言编写的程序，如ls、cp等。
  执行方式：通过调用可执行文件并传入参数，使用execvp函数实现。
2. 内置命令：
  定义：Shell内部实现的命令，如cd、exit、help等。
  特点：与当前Shell进程相关，需要在Shell内部实现，不依赖外部可执行文件。
3. 重定向命令：
  定义：对输入或输出进行重定向的命令，包括输入重定向（<、<<）和输出重定向（>、>>）。
  实现方法：通过操作文件描述符，使用open、close、dup2等系统调用实现重定向。

具体介绍（记录的是我不太了解的概念）

管道命令
- 管道是数据通道，允许一个进程的输出作为另一个进程的输入。
- 实现步骤：
  1. 创建管道：使用pipe系统调用，生成两个文件描述符，分别用于读和写。
  2. 创建子进程：使用fork创建子进程，在子进程中进行重定向和命令执行。
  3. 重定向：
    - 左边命令的输出重定向到管道的写端。
    - 右边命令的输入重定向到管道的读端。
  4. 关闭管道：在进程结束前关闭管道描述符，防止阻塞。
  5. 等待子进程：在父进程中使用wait等待子进程结束。
重定向命令
1. 输入重定向
  - 符号：< 和 <<
  - 作用：
  1. cat < input.txt：将input.txt的内容作为cat命令的输入。
  2. cat << EOF：从键盘输入，直到输入EOF，作为cat命令的输入。
  - 实现代码：
  1
  2
  3
  int fd_input = open("input.txt", O_RDONLY);
  close(0);
  dup2(fd_input, 0);
2. 输出重定向
  - 符号：> 和 >>
  - 作用：
  1. ps -a > output.txt：将ps -a的输出重定向到output.txt，并覆盖原文件内容。
  2. ps -a >> output.txt：将ps -a的输出以追加的形式写入output.txt。
  - 实现代码：
  1
  2
  3
  int fd_output = open("output.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);
  close(1);
  dup2(fd_output, 1);

具体实现

管道的实现：管道的核心思想是将一个命令的标准输出（STDOUT）作为另一个命令的标准输入（STDIN）。这一过程通过 pipe() 系统调用实现，创建一对文件描述符用于数据流的传递。在我的实现中，我首先通过 fork() 创建子进程，然后根据管道的数量分别设置标准输入输出，并使用 execvp() 来执行每个命令。

输入输出重定向的实现：输入重定向 < 和输出重定向 > 的实现主要依赖 open() 系统调用，它们分别用来将标准输入或标准输出重定向到指定的文件中。在处理 < 和 <<（here文档）时，我需要对输入流进行相应的修改，将标准输入从键盘重定向到文件或是终端输入。

外部命令的实现：外部命令的执行是在子进程中进行的。首先，使用 fork() 创建一个新的子进程。子进程通过 execvp() 系统调用来执行外部命令。execvp() 会用一个新的程序来替换当前进程的映像，执行指定的命令。

内部命令的实现：如 cd 和 exit，这些命令不需要通过 execvp() 执行，而直接在Shell内部处理。尤其是 cd 命令，它需要在父进程中更改工作目录，这就涉及到对进程的工作目录的理解。exit 命令则是退出Shell并结束程序运行。

流程图

以下是具体实现代码中函数的概述：

print_prompt：负责显示Shell提示符，包含用户名、主机名和当前工作目录。
tokenize_input：将用户输入的命令行分割为tokens，处理空格和引号。
parse_commands：根据管道符|将tokens分割为多个命令。
execute_commands：根据命令数量决定是执行单个命令还是处理管道命令。
execute_single_command：执行单个命令，包括内置命令和外部命令。
handle_redirection：处理命令中的输入和输出重定向。
execute_builtin_command：执行内置命令，如cd，exit和help。
display_help：显示内置命令的帮助信息。

#include <iostream>
#include <vector>
#include <string>
#include <unistd.h>
#include <fcntl.h>
#include <sys/wait.h>
#include <pwd.h>
#include <cstring>
#include <cerrno>

// 使用标准命名空间
using namespace std;

// 函数声明
void print_prompt();
bool tokenize_input(const string &input, vector<string> &tokens);
vector<vector<string>> parse_commands(const vector<string> &tokens);
bool execute_commands(const vector<vector<string>> &commands);
bool execute_single_command(vector<string> &tokens);
bool handle_redirection(vector<string> &tokens);
bool execute_builtin_command(const vector<string> &tokens);
void display_help();

// 主函数
int main() {
    string input;

    while (true) {
        // 显示Shell提示符
        print_prompt();

        // 读取用户输入
        if (!getline(cin, input)) {
            // 处理EOF (如Ctrl+D)
            cout << endl;
            break;
        }

        // 解析输入为tokens
        vector<string> tokens;
        if (!tokenize_input(input, tokens)) {
            continue; // 如果解析失败，重新显示提示符
        }

        // 如果没有输入命令，继续循环
        if (tokens.empty()) {
            continue;
        }

        // 解析tokens为多个命令（处理管道）
        vector<vector<string>> commands = parse_commands(tokens);

        // 执行解析后的命令
        if (!execute_commands(commands)) {
            break; // 如果执行命令返回false，则退出Shell
        }
    }

    return 0;
}

/**
 * @brief 显示Shell提示符，包括用户名、主机名和当前工作目录。
 */
void print_prompt() {
    char* prompt_symbol = "$";
    uid_t uid = getuid();

    if (uid == 0) { // 判断是否为根用户
        prompt_symbol = "#";
    }

    struct passwd* pwd = getpwuid(uid);
    if (pwd == nullptr) {
        cout << "$ ";
        return;
    }

    char hostname[128] = {0};
    if (gethostname(hostname, sizeof(hostname)) != 0) {
        strcpy(hostname, "unknown");
    }

    char cwd[256] = {0};
    if (getcwd(cwd, sizeof(cwd)) == nullptr) {
        strcpy(cwd, "unknown");
    }

    // 使用ANSI颜色代码美化提示符
    printf("\033[1;32m%s@%s\033[0m:\033[1;34m%s\033[0m%s ", pwd->pw_name, hostname, cwd, prompt_symbol);
    fflush(stdout); // 确保提示符立即显示
}

/**
 * @brief 将输入字符串分割为tokens，基于空格分隔。
 * @param input 用户输入的命令行
 * @param tokens 分割后的命令和参数
 * @return 成功返回true，失败返回false
 */
bool tokenize_input(const string &input, vector<string> &tokens) {
    tokens.clear();
    string token;
    bool in_quotes = false;
    char quote_char = '\0';

    for (size_t i = 0; i < input.length(); ++i) {
        char c = input[i];

        if (in_quotes) {
            if (c == quote_char) {
                in_quotes = false;
            } else {
                token += c;
            }
        } else {
            if (c == '\'' || c == '\"') {
                in_quotes = true;
                quote_char = c;
            }
            else if (isspace(c)) {
                if (!token.empty()) {
                    tokens.push_back(token);
                    token.clear();
                }
            }
            else if (c == '|' || c == '<' || c == '>') {
                if (!token.empty()) {
                    tokens.push_back(token);
                    token.clear();
                }
                // 处理双字符符号 << 和 >>
                if ((c == '<' || c == '>') && i + 1 < input.length() && input[i + 1] == c) {
                    tokens.emplace_back(string(2, c));
                    i++; // 跳过下一个字符
                } else {
                    tokens.emplace_back(string(1, c));
                }
            }
            else {
                token += c;
            }
        }
    }

    if (in_quotes) {
        cerr << "Error: Mismatched quotes in input." << endl;
        return false;
    }

    if (!token.empty()) {
        tokens.push_back(token);
    }

    return true;
}

/**
 * @brief 将tokens分割为多个命令，以处理管道。
 * @param tokens 分割后的命令和参数
 * @return 分割后的命令集合
 */
vector<vector<string>> parse_commands(const vector<string> &tokens) {
    vector<vector<string>> commands;
    vector<string> current_command;

    for (const auto &token : tokens) {
        if (token == "|") {
            if (current_command.empty()) {
                cerr << "Error: Invalid null command." << endl;
                commands.clear();
                return commands;
            }
            commands.push_back(current_command);
            current_command.clear();
        } else {
            current_command.push_back(token);
        }
    }

    if (!current_command.empty()) {
        commands.push_back(current_command);
    }

    return commands;
}

/**
 * @brief 执行解析后的命令集合，包括单个命令和带管道的命令。
 * @param commands 分割后的命令集合
 * @return 成功返回true，若执行exit命令则返回false
 */
bool execute_commands(const vector<vector<string>> &commands) {
    if (commands.empty()) {
        return true;
    }

    // 如果只有一个命令，直接执行
    if (commands.size() == 1) {
        return execute_single_command(const_cast<vector<string> &>(commands[0]));
    }

    // 处理管道命令
    size_t num_commands = commands.size();
    vector<int> pipe_fds;

    // 创建所有需要的管道
    for (size_t i = 0; i < num_commands - 1; ++i) {
        int fd[2];
        if (pipe(fd) == -1) {
            perror("pipe");
            return true;
        }
        pipe_fds.push_back(fd[0]);
        pipe_fds.push_back(fd[1]);
    }

    // 存储所有子进程的PID
    vector<pid_t> pids;

    for (size_t i = 0; i < num_commands; ++i) {
        pid_t pid = fork();
        if (pid < 0) {
            perror("fork");
            // 关闭所有打开的管道
            for (int fd : pipe_fds) {
                close(fd);
            }
            return true;
        }
        else if (pid == 0) { // 子进程
            // 如果不是第一个命令，重定向标准输入
            if (i > 0) {
                if (dup2(pipe_fds[(i - 1) * 2], STDIN_FILENO) == -1) {
                    perror("dup2");
                    exit(EXIT_FAILURE);
                }
            }

            // 如果不是最后一个命令，重定向标准输出
            if (i < num_commands - 1) {
                if (dup2(pipe_fds[i * 2 + 1], STDOUT_FILENO) == -1) {
                    perror("dup2");
                    exit(EXIT_FAILURE);
                }
            }

            // 关闭所有管道文件描述符
            for (int fd : pipe_fds) {
                close(fd);
            }

            // 执行命令
            if (!execute_single_command(const_cast<vector<string> &>(commands[i]))) {
                exit(EXIT_FAILURE);
            }

            exit(EXIT_SUCCESS);
        }
        else { // 父进程
            pids.push_back(pid);
        }
    }

    // 父进程关闭所有管道文件描述符
    for (int fd : pipe_fds) {
        close(fd);
    }

    // 父进程等待所有子进程结束
    for (pid_t pid : pids) {
        int status;
        if (waitpid(pid, &status, 0) == -1) {
            perror("waitpid");
        }
    }

    return true;
}

/**
 * @brief 执行单个命令，包括内置命令和外部命令。
 * @param tokens 命令及其参数
 * @return 若执行exit命令则返回false，其他情况返回true
 */
bool execute_single_command(vector<string> &tokens) {
    if (tokens.empty()) {
        return true;
    }

    // 检查是否为内置命令
    if (execute_builtin_command(tokens)) {
        // 如果是exit命令，返回false以退出Shell
        if (tokens[0] == "exit") {
            return false;
        }
        return true;
    }

    // 处理外部命令
    pid_t pid = fork();
    if (pid < 0) {
        perror("fork");
        return true;
    }
    else if (pid == 0) { // 子进程
        // 处理重定向
        if (!handle_redirection(tokens)) {
            exit(EXIT_FAILURE);
        }

        // 准备execvp的参数
        vector<char*> argv;
        for (auto &arg : tokens) {
            argv.push_back(const_cast<char*>(arg.c_str()));
        }
        argv.push_back(nullptr);

        // 执行外部命令
        execvp(argv[0], argv.data());
        // 如果execvp返回，说明执行失败
        perror("execvp");
        exit(EXIT_FAILURE);
    }
    else { // 父进程
        // 等待子进程结束
        int status;
        if (waitpid(pid, &status, 0) == -1) {
            perror("waitpid");
        }
    }

    return true;
}

/**
 * @brief 处理命令中的输入和输出重定向。
 * @param tokens 命令及其参数
 * @return 成功返回true，失败返回false
 */
bool handle_redirection(vector<string> &tokens) {
    for (size_t i = 0; i < tokens.size(); ++i) {
        if (tokens[i] == "<") {
            if (i + 1 >= tokens.size()) {
                cerr << "Error: No input file specified for redirection." << endl;
                return false;
            }
            // 打开输入文件
            int fd_in = open(tokens[i + 1].c_str(), O_RDONLY);
            if (fd_in == -1) {
                perror("open for input redirection");
                return false;
            }
            // 重定向标准输入
            if (dup2(fd_in, STDIN_FILENO) == -1) {
                perror("dup2 for input redirection");
                close(fd_in);
                return false;
            }
            close(fd_in);
            // 移除重定向符号和文件名
            tokens.erase(tokens.begin() + i, tokens.begin() + i + 2);
            i--; // 调整索引
        }
        else if (tokens[i] == "<<") {
            if (i + 1 >= tokens.size()) {
                cerr << "Error: No delimiter specified for here-document." << endl;
                return false;
            }
            string delimiter = tokens[i + 1];
            string input_data;
            string line;

            cout << "> ";
            fflush(stdout);
            // 读取直到遇到定界符
            while (getline(cin, line)) {
                if (line == delimiter) {
                    break;
                }
                input_data += line + "\n";
                cout << "> ";
                fflush(stdout);
            }

            // 创建管道并写入数据
            int pipe_fd[2];
            if (pipe(pipe_fd) == -1) {
                perror("pipe for here-document");
                return false;
            }

            ssize_t bytes_written = write(pipe_fd[1], input_data.c_str(), input_data.size());
            if (bytes_written == -1) {
                perror("write to pipe for here-document");
                close(pipe_fd[0]);
                close(pipe_fd[1]);
                return false;
            }
            close(pipe_fd[1]); // 关闭写端

            // 重定向标准输入到管道的读端
            if (dup2(pipe_fd[0], STDIN_FILENO) == -1) {
                perror("dup2 for here-document");
                close(pipe_fd[0]);
                return false;
            }
            close(pipe_fd[0]);

            // 移除重定向符号和定界符
            tokens.erase(tokens.begin() + i, tokens.begin() + i + 2);
            i--; // 调整索引
        }
        else if (tokens[i] == ">") {
            if (i + 1 >= tokens.size()) {
                cerr << "Error: No output file specified for redirection." << endl;
                return false;
            }
            // 打开输出文件（截断模式）
            int fd_out = open(tokens[i + 1].c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0666);
            if (fd_out == -1) {
                perror("open for output redirection");
                return false;
            }
            // 重定向标准输出
            if (dup2(fd_out, STDOUT_FILENO) == -1) {
                perror("dup2 for output redirection");
                close(fd_out);
                return false;
            }
            close(fd_out);
            // 移除重定向符号和文件名
            tokens.erase(tokens.begin() + i, tokens.begin() + i + 2);
            i--; // 调整索引
        }
        else if (tokens[i] == ">>") {
            if (i + 1 >= tokens.size()) {
                cerr << "Error: No output file specified for append redirection." << endl;
                return false;
            }
            // 打开输出文件（追加模式）
            int fd_out = open(tokens[i + 1].c_str(), O_WRONLY | O_CREAT | O_APPEND, 0666);
            if (fd_out == -1) {
                perror("open for append redirection");
                return false;
            }
            // 重定向标准输出
            if (dup2(fd_out, STDOUT_FILENO) == -1) {
                perror("dup2 for append redirection");
                close(fd_out);
                return false;
            }
            close(fd_out);
            // 移除重定向符号和文件名
            tokens.erase(tokens.begin() + i, tokens.begin() + i + 2);
            i--; // 调整索引
        }
    }
    return true;
}

/**
 * @brief 执行内置命令（如cd、exit、help）。
 * @param tokens 命令及其参数
 * @return 如果是内置命令并已执行，返回true；否则返回false
 */
bool execute_builtin_command(const vector<string> &tokens) {
    if (tokens.empty()) {
        return false;
    }

    const string &cmd = tokens[0];

    if (cmd == "cd") {
        if (tokens.size() > 2) {
            cerr << "Usage: cd [directory]" << endl;
            return true;
        }

        const char *path;
        if (tokens.size() == 1) { // 没有指定路径，切换到home目录
            struct passwd *pw = getpwuid(getuid());
            if (pw == nullptr) {
                cerr << "cd: Unable to get home directory." << endl;
                return true;
            }
            path = pw->pw_dir;
        }
        else { // 切换到指定路径
            path = tokens[1].c_str();
        }

        if (chdir(path) != 0) {
            perror("cd");
        }

        return true;
    }
    else if (cmd == "exit") {
        return true; // 主函数将处理退出
    }
    else if (cmd == "help") {
        display_help();
        return true;
    }

    return false; // 不是内置命令
}

/**
 * @brief 显示内置命令的帮助信息。
 */
void display_help() {
    struct passwd* pw = getpwuid(getuid());
    const char* username = (pw != nullptr) ? pw->pw_name : "User";

    printf("Welcome to the custom shell, %s!\n", username);
    printf("The shell supports the following built-in commands:\n");
    printf("1. cd [path]    : Change the current working directory to 'path'. If 'path' is omitted, changes to the home directory.\n");
    printf("2. exit         : Exit the shell.\n");
    printf("3. help         : Display this help message.\n");
    printf("\n");
    printf("Additionally, the shell supports:\n");
    printf("- Execution of external commands available in the system PATH.\n");
    printf("- Input redirection using '<' and '<<'.\n");
    printf("- Output redirection using '>' and '>>'.\n");
    printf("- Piping between multiple commands using '|'.\n");
}

实验结果

内部指令：

help指令
cd指令
exit指令

外部指令：

ls指令
ps指令
自行编译后的程序

管道命令：

重定向命令：

>
>>
<
<<

实验心得

在本次实验中，我深入研究了Linux下的管道、重定向以及进程控制等基本操作，结合实际编程实现了一个简易的Shell模拟器。通过编写程序实现命令行的解析、进程管理、输入输出重定向、管道传递等功能，我不仅加深了对操作系统内部机制的理解，还在实际编程中获得了很多宝贵的经验。

在实验中，最具挑战性的一部分是对管道和重定向操作的实现。管道符 | 和输入重定向 <、输出重定向 > 是Shell中最常见的操作，通过它们可以实现命令之间的数据传递与文件输入输出的灵活控制。这些操作看似简单，但在实现过程中需要注意处理子进程、文件描述符以及异常处理等细节问题。例如，处理输入重定向时，要确保读取到文件内容后关闭文件描述符，避免资源泄漏。