学习操作系统需要使用C语言实现一个shell深度好文

a interesting and consider essay

一个简单的shell实现，代码是大牛写的，我只是一个搬运工，不过感觉很值得借鉴。可以和上面的英文文章结合来看会得到很多

对管道和重定向机制不了解的可以看这篇文章
对管道和重定向解释以及一些基本的LInux知识

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/wait.h>
#define CMD_LINE 1024
#define PIPE_MAX 16
#define ARG_MAX 10
typedef struct {
    char *arg[ARG_MAX];
    char *in;
    char *out;
} cmd_t;
extern int parse_token(char *buf, cmd_t cmd[]);
extern int parse(char *buf, cmd_t * cmd);
extern int test_parse(cmd_t cmd[], int len);
int main(int argc, char *argv[])
{
    char buf[CMD_LINE];
    cmd_t cmd[PIPE_MAX + 1];
    int fd[PIPE_MAX][2];
    int j, i;
    int cmd_len, pipe_len;
    pid_t pid;
    while (1) {
        printf("my_shell#");        //打印提示符
        
        fgets(buf, CMD_LINE, stdin);        //获得输入
        buf[strlen(buf) - 1] = '\0';        //去掉结尾的换行符？
        cmd_len = parse_token(buf, cmd);//解析命令
        pipe_len = cmd_len - 1;                 //
        if (pipe_len > PIPE_MAX)
            continue;
        for (i = 0; i < pipe_len; ++i)
            pipe(fd[i]);                                    //创建pipe_len个管道
        for (i = 0; i < cmd_len; ++i)        //创建cmd_len个进程
            if ((pid = fork()) == 0)            //判断是否为子进程
                break;                                          //如果是子进程，跳出for循环
        if (pid == 0) {                                 //循环中是子进程代码
            if (pipe_len) {
                if (i == 0) {                               //第一个子进程
                    close(fd[i][0]);                    //关闭管道的读取端
                    dup2(fd[i][1], 1);              //复制管理的写入端为标准输出（标准输出会写入管道）
                    close(fd[i][1]);                    //关闭管道的写入端
                    for (j = 1; j < pipe_len; ++j)
                        close(fd[j][0]),                //关闭无关进程的管道
                            close(fd[j][1]);
                } else if (i == pipe_len) { //第pipe_len个子进程
                    close(fd[i - 1][1]);            //关闭管道的写入端
                    dup2(fd[i - 1][0], 0);      //复制管理的读取端为标准输出（标准输入会读取管道）
                    close(fd[i - 1][0]);            //关闭管道的读取端
                    for (j = 0; j < pipe_len - 1; ++j)
                        close(fd[j][0]),                //关闭无关进程的管道
                            close(fd[j][1]);
                } else {                                        //其他子进程
                    dup2(fd[i - 1][0], 0);      //复制管理的读取端为标准输出（标准输入会读取管道）
                    close(fd[i][0]);                    //关闭管道的读取端
                    dup2(fd[i][1], 1);              //复制管理的写入端为标准输出（标准输出会写入管道）
                    close(fd[i][1]);                    //关闭管道的写入端
                    for (j = 0; j < pipe_len; ++j) {
                        if ((j != i - 1)                //关闭无关进程的管道
                            || (j != i))
                            close(fd[j][0]),
                                close(fd[j]
                                  [1]);
                    }
                }
            }
            if (cmd[i].in) {        //如果需要，打开输入文件并重定向
                int fd = open(cmd[i].in, O_RDONLY);
                dup2(fd, STDIN_FILENO);
                close(fd);
            }
            if (cmd[i].out) {       //如果需要，打开输出文件并重定向
                int fd =
                    open(cmd[i].out,
                     O_RDWR | O_CREAT | O_TRUNC, 0644);
                dup2(fd, STDOUT_FILENO);
                close(fd);
            }
            execvp(cmd[i].arg[0], cmd[i].arg);  //执行当前命令
            fprintf(stderr, "Failed exec\n");       //执行命令失败后才会执行之后的代码
            exit(127);
        }       //子进程代码结束
        /* parent  */
        for (i = 0; i < pipe_len; ++i)
            close(fd[i][0]), close(fd[i][1]);
        for (i = 0; i < cmd_len; ++i)
            wait(NULL);     //等待子进程结束
    }
    return 0;
}
int parse_token(char *buf, cmd_t cmd[])
{
    int n = 0;
#if 1
    char *save_p;
    char *p = strtok_r(buf, "|", &save_p);//以'|'分割命令将分割后的第一部分给p
    while (p != NULL) {
        parse(p, &cmd[n++]);
        p = strtok_r(NULL, "|", &save_p);//将之后的部分给p，每次给一部分，每调用一次给下一部分
    }
#else               //下一块语句不被执行
    cmd[n].arg[0] = "ls";
    cmd[n].arg[1] = "-l";
    cmd[n].arg[2] = NULL;
#endif
    return n;
}
int test_parse(cmd_t cmd[], int len)        //此函数未被调用
{
    int i;
    for (i = 0; i < len; ++i) {
        printf("cmd[%d]:", i);
        int j = 0;
        while (cmd[i].arg[j])
            printf(" %s", cmd[i].arg[j++]);
        if (cmd[i].in)
            printf("\tin:%s", cmd[i].in);
        if (cmd[i].out)
            printf("\tout:%s", cmd[i].out);
        printf("\n");
    }
    return 0;
}
int parse(char *buf, cmd_t * cmd)
{
    int i = 0;
    cmd->in = NULL;
    cmd->out = NULL;
    char *p = strtok(buf, " ");//以空格分割命令（此时命令已被|分割过了）
    while (p) {
        if (*p == '<') {         //如果命令以<开头，即需要做输入重定向
            if (*(p + 1))                   //这种情况是<后无空格直接跟文件名
                cmd->in = p + 1;
            else                                    //这种情况是<后有空格
                cmd->in = strtok(NULL, " ");
        } else if (*p == '>') {  //如果命令以>开头，即需要做输出重定向
            if (*(p + 1))                   //这种情况是>后无空格直接跟文件名
                cmd->out = p + 1;
            else                                    //这种情况是>后有空格
                cmd->out = strtok(NULL, " ");
        } else
            cmd->arg[i++] = p;       //这种情况是正常命令或参数
        p = strtok(NULL, " ");
    }
    cmd->arg[i] = NULL;
    return 0;
}