一、Shell外壳概述

在狭义上 , 我们称Linux操作系统的内核为 Linux

在广义上 , Linux发行版 == Linux内核 + 外壳程序

就比如市面上现在的redhat, centos, ubuntu等等我们耳熟能详的Linux发行版，事实上这些Linux发行版都是基于Linux操作系统的内核，然后对之加装了不同的Shell外壳，最终做出不同种类的Linux发行版。

我们作为用户，是不能直接去操作Linux内核的，为什么呢？

直接去操作Linxu内核成本是极高的，学习成本、操作成本都不低
用户直接操作Linux内核存在风险，所以Linux内核对用户设置了权限限制

所以我们有了shell外壳程序来间接帮助我们操作Linux内核。

windows操作系统的Shell外壳是一个窗口图形界面，所以我们可以通过这个窗口图形，接收来自用户的点击、拖拽等操作，从而使用windows的各个功能。

Linux操作系统的Shell外壳的名字叫bash，所以我们也可以通过bash来传达我们的操作，即用户对bash输入指令,从而使用Linux操作系统的功能。

简单的说，Shell外壳程序是对Linux内核的一层封装 , 架起了用户和Linux沟通的桥梁。

命令行解释器

在大多数Linux发行版本中，是没有图形化界面的，那么，Shell是如何帮助用户和Linux内核进行沟通的呢？答案是命令行解释器，也就是小黑框。命令行解释器就是Shell外壳在Linux系统中的具体表现。

命令行解释器上每一行都有输入指令的提示，用户输入指令和选项之后，Shell外壳接收并解析该指令，然后发送给Linux内核去处理执行，Linux内核处理之后将结果反馈给Shell外壳，Shell外壳将结果解析返还给用户。

二、描述Shell外壳原理的生动例子

从前有座山，山里有座村，村里有个老村长，而你是村长的儿子——王二狗。同时你们村还有个远近闻名的媒婆——王婆，在你们当地有非常不错的口碑，曾撮合成功了无数对男女。

你作为村长的儿子，也老大不小了，也到了该找对象的年纪。你作为一个纯情的男人，心理自然还想着你们村的如花姑娘。

但是你还是一个害羞的小男生，不方便也不敢直接去和如花姑娘直说，所以你就只得找王婆来代为传递你的信息。

这天，你找到了王婆，说你想找如花姑娘相亲，王婆说可以帮你办这件事，然后她就把你想找如花姑娘约会这件事告诉了如花姑娘。如花姑娘说不行，她说她并不认识王二狗，不想和他相亲。于是王婆就很直白的告诉你说，如花姑娘压根不想和你相亲，你还是放弃吧。

所以王婆便是沟通你和如花姑娘的桥梁，类比用户和操作系统内核之间的媒介作用。

你心想，作为一个纯情的男人，我是不会放弃的！所以这天你有找到王婆，说再帮我问问看吧，我真的很喜欢如花姑娘[大哭]。

王婆说好吧，那我再给你传达最后一次，不过不出所料，结局再次上演，如花再次拒绝，王婆又把这个残忍的事实传达给你。

这时你还是放不下，有跟王婆说能不能再再帮我问一次。王婆此时直接拒绝了，说不要再这样子了，这样如花姑娘会不堪其扰内心厌烦且痛苦的（王婆顾及如花姑娘的感受，事实上也是在保护如花姑娘，防止你亲自去找她，做出极端的事情）。

所以王婆拥有拒绝传达信息的权利，类比Shell外壳可以拒绝一些非法的请求，从而保护os。

不过故事仍然没有结束，你可是村长的儿子啊，你的一再要求，王婆肯定会考虑到村长的面子。但是王婆也得考虑到自己的口碑，不能因为这件事把招牌给砸了，毕竟还忙着给其他男女说媒呢。

所以这时王婆想到一个绝妙的对策，招一个实习生来办这件事（王婆：让我的实习生来给你办这件事吧，我溜了哦~）。

实习生办这件事，对王婆来说有两个好处，一是王婆可以跟村长交代这件事她一直在办着，只不是是她的实习生在负责，二是就算实习生办砸了这件事也没关系，反正只要不是她王婆办的，这个招牌就不会砸。

王婆可以找实习生执行难度大的任务，类比Shell外壳可以创建子进程去执行有风险的任务，从而不影响Shell外壳。

总结

Shell外壳是对Linux内核的封装，连接沟通了用户(需求)与Linux内核(执行)，这降低了用户的操作学习成本。

Shell外壳可以传达用户指令，交给操作系统内核去执行，最终把执行结果反馈给用户。

同时Shell外壳也可以直接拒绝用户，从而保护操作系统内核。

Shell外壳也可以通过创建Shell外壳程序的子进程的方式，来执行有风险的指令，从而来保护bash即Shell外壳本身。

三、C语言模拟实现Shell外壳

命令行解释器：

输出提示
获取用户输入
执行命令

核心算法：字符串切割、进程替换、环境变量调用、重定向

源代码：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <assert.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>

#define NUM 1024
#define OPT_NUM 64

#define NONE_REDIR 0
#define INPUT_REDIR 1
#define OUTPUT_REDIR 2
#define APPEND_REDIR 3

char commandLine[NUM];
char* myArgv[OPT_NUM];
int lastCode = 0;
int lastSig = 0;

int redirType = NONE_REDIR;
char* redirFile = NULL;

// 跳过空格
void skip_space(char* start)
{
    while (isspace(*start))
    {
        ++start;
    }
}

// 检查命令行是否是输入输出重定向
void command_check(char* commands)
{
    assert(commands);
    char* start = commands;
    char* end = commands + strlen(commands);

    while (start < end)
    {
        if (*start == '>')
        {
            *start = 0;
            ++start;
            if (*start == '>')
            {
                // 追加输出重定向
                // "ls -a -l >> test.txt"
                redirType = APPEND_REDIR;
                ++start;
            }
            else
            {
                // 覆盖输出重定向
                // "ls -a -l > test.txt"
                redirType = OUTPUT_REDIR;
            }
            skip_space(start);
            redirFile = start;
            break;
        }
        else if (*start == '<')
        {
            // 输入重定向
            // "cat < test.txt"
            *start = 0;
            ++start;
            skip_space(start);
            redirType = INPUT_REDIR;
            redirFile = start;
            break;
        }
        else 
        {
            ++start;
        }
    }
}

int main()
{
    while (1)
    {
        redirType = NONE_REDIR;
        redirFile = NULL;

        // 输入提示符
        char* pwd = getenv("PWD");
        char* token = strtok(pwd, "/");
        char* dir = token;
        while (token != NULL)
        {
            dir = token;
            token = strtok(NULL, "/");
        }

        char* user = getenv("USER");
        if (strcmp(user, "root") == 0)
        {
            printf("[%s@%s %s]# ", user, getenv("HOSTNAME"), dir);
        }
        else
        {
            printf("[%s@%s %s]$ ", user, getenv("HOSTNAME"), dir);
        }
        fflush(stdout);

        // 获取用户输入
        fgets(commandLine, sizeof(commandLine) - 1, stdin);
        commandLine[strlen(commandLine) - 1] = 0;
        command_check(commandLine);

        // 字符串切割
        myArgv[0] = strtok(commandLine, " ");
        int i = 1;

        // 添加、更改参数
        if (myArgv[0] != NULL && strcmp(myArgv[0], "ls") == 0)
        {
            myArgv[i++] = (char*)"--color=auto";
        }
        if (myArgv[0] != NULL && strcmp(myArgv[0], "ll") == 0)
        {
            myArgv[0] = (char*)"ls";
            myArgv[i++] = (char*)"-l";
            myArgv[i++] = (char*)"--color=auto";
        }

        // 存储参数
        while (myArgv[i++] = strtok(NULL, " "))
        {}

        // 如果是 cd 指令，无需创建子进程
        // 让 shell 执行对应的命令，本质是是执行系统接口    
        // 这种不需要子进程执行，而是让 shell 自己执行的命令，叫做内置/内建命令
        if (myArgv[0] != NULL && strcmp(myArgv[0], "cd") == 0)
        {
            if (myArgv[1] != NULL)
            {
                chdir(myArgv[1]);   // 跳转目录
                char tmp_path[1024] = {0};
                getcwd(tmp_path, sizeof(tmp_path) - 1);     // 将当前工作目录存入tmp_path中
                setenv("PWD", tmp_path, 1);     // 修改环境变量
            }
            else
            {
                chdir(getenv("HOME"));
                setenv("PWD", getenv("HOME"), 1);
            }
            continue;
        }
        if (myArgv[0] != NULL && myArgv[1] != NULL && strcmp(myArgv[0], "echo") == 0)
        {
            if (strcmp(myArgv[1], "$?") == 0)
            {
                // 查看上一条指令的退出码、退出信号
                printf("last exit code: %d, last exit sig: %d\n", lastCode, lastSig);
            }
            else
            {
                printf("%s\n", myArgv[1]);
            }
            continue;
        }

        // 执行命令
        pid_t id = fork();
        if (id == 0)
        {
            // 命令由子进程执行，重定向的工作由子进程完成
            // 父进程给子进程提供信息重定向
            int fd = 0;
            switch (redirType)
            {
            case NONE_REDIR:
                break;
            case INPUT_REDIR:
                fd = open(redirFile, O_RDONLY);
                if (fd < 0)
                {
                    perror("open");
                    exit(errno);
                }
                dup2(fd, 0);
                break;
            case OUTPUT_REDIR:
            case APPEND_REDIR:
                umask(0);
                int flags = O_WRONLY | O_CREAT;
                if (redirType == APPEND_REDIR)
                {
                    flags |= O_APPEND;
                }
                else
                {
                    flags |= O_TRUNC;
                }
                fd = open(redirFile, flags, 0666);
                if (fd < 0)
                {
                    perror("open");
                    exit(errno);
                }
                dup2(fd, 1);
                break;
            default:
                printf("bug\n");
                break;
            }
            execvp(myArgv[0], myArgv);
            exit(1);
        }

        // 父进程
        int status = 0;
        pid_t ret = waitpid(id, &status, 0);
        assert(ret > 0);
        lastCode = (status >> 8) & 0xFF;
        lastSig = status & 0x7F;
    }

    return 0;
}