• Linux - 实现一个简单的 shell

    前言

    之前我们对进程的替换，进程地址空间等等的概念进行了说明，本篇博客会基于这些知识点来 实现一个简单的 shell ，如有疑问，可以参考下述博客：
    Linux - 进程程序替换 - C/C++ 如何实现与各个语言之间的相互调用 - 替换环境变量-CSDN博客

    Linux - 进程控制（下篇）- 进程等待-CSDN博客

    Linux - 进程控制（上篇）- 进程创建 和 进程终止-CSDN博客

    Linux - 进程地址空间-CSDN博客

    Linux - 环境变量 - 常规命令 和 内建命令-CSDN博客

    因为本博客当中试下的 shell 只是非常简单的版本，全局上的变量基本只有父进程在使用，所以，很多的变量和数组都是 定义在全局当中的，其实这样是不好的，但是本篇博客的意义在于理解 Linux 当中 bash 的大概实现，而不是着手实现一个 shell。 

     简单 shell 实现

     在之前的博客当中，我们说，其实 Linux 当中的 bash（命令行解释器），本质上就是 创建子进程，创建完之后，这个子进程就是我们 在命令行当中运行命令的 可执行文件 生成的 进程。那么，为什么可以实现 bash 创建的子进程 执行其他的 可执行程序当中的代码呢？其实就是实现了 进程替换，进程替换 会替换掉 原本 进程当中 除环境变量之外的 代码和数据，所以，在替换之后，是从0 开始 执行新的程序的。

    这就是整个过程。

    而，像我们使用 "ls" "pwd" "cd" 这些命令，其实都是一个一个的可执行程序，一般是存储在 Linux 当中的 bin 目录下的，这也是 Linux 默认的 PATH 执行目录之一。

    所以，当我们在命令行当中输入 某一个系统当中存在的命令之时，或者是运行我们自己书写的程序，本质上都是 bash 创建子进程，然后把这个子进程当中代码和数据 和 新的进程（可能是命令，也可能是我们的自己编写的程序）的代码 和数据进行替换。

    然后在从 0 开始执行这个新的程序，所以，bash 就实现了一个 解析命令的作用。

    首先我们来理解在 屏幕上打印的 这些，和我们输入的命令到底是什么？

    在之前的一大串，其实本质上就是一个字符串，在这个字符串当中有 当前用户名，主机名，目录名等等信息，这些信息都是在环境变量当中有体现的：

     而后面我们输入的 "ls l -a" 这个命令，其实本质上就是我们输入了一个字符串，bash 解析 命令也是通过这个字符串来实现的。

    而bash 解析这个命令也只是把这个字符串，按照 空格 或者其他方式把这个字符串分隔为了 多个字符串，然后，再把这些个字符串 作为参数，利用 exec*()系列函数，传入到 替换的 新的程序当中，所以，怎么运行，还是靠 这个命令的 可执行程序本身。

    所以，现在我们先来解决一个问题，就是在控制台当中打印 前面一大串信息（命令行的打印）的实现：

    构建一个简单的命令行

     如果想获取到 类似 bash 的 命令行当中一样的信息，我们除了可以利用 一些系统调用接口来获取之外，其实，通过环境变量来获取也是可以的。这些 信息在环境变量当中都是有的：
     

     通过这些环境变量，就可以获取到我们想要的 信息。

     上述就是我构建的 命令行，输出：
     

    接下来是搞定 用户输入命令，我们要保存用户输入的命令，才能进行解析：

    首先，因为用户输入命令是一个字符串，在这个字符串当中，不仅仅有字符和字母，还用用于分开各个选项参数的之前的关系的空格。

    所以，我们不能用 C 当中 的 scanf（）这个函数来实现，因为 scanf（）这个函数，读取缓冲区当中的 数据之时，读到 "\n" 或者是 空格就会结束读取，而 用户在输入命令之时，不得避免的要输入空格来分隔各个选项。

    如果要是用 scanf（）函数读取多个 字符串的话，在格式化输出当中，每一个字符串都要写上 "%s" 来识别这个字符串，但是，我们不清楚用户要输入多少个字符串，所以这种方式是很挫的。虽然可以使用一些通配符来实现读取一行字符出纳，但是，有个函数可以更方便的实现读取一行字符串。所以，scanf（）明显不能满足我们的要求。

     我们期望的是，从何命令行当中获取一样的字符串。所以，可以使用  fgets（）函数来实现：
     

    其中的 stream，可以是我们打开的文件对象；其实在 Linux 当中 系统启动之时 自动会打开的 stdin ，stdout ， stderr 这三个流，所以，fgets（）函数直接从 stdin 当中读取数据就行了。

    此时我们就存储到了 用户输入的 命令字符串：
     

     因为用户输入的字符串当中，就算用户什么字符字母都没有输入，但是当用户按下回车的时候，"\n" 也是输入了，也就是说， fgets（）函数不会读取失败，最少都是要读取一个 "\n" 。

    所以，我们上述拿到的字符串是不干净的，不管用户怎么输入，在字符串当中都是有一个 "\n" 。所以，我们在读取到 commandline 字符串数组当中，那这个 "\n" 给 清楚：
     

    像上述 就把 用户输入的 字符串给优化为我们想要的命令字符串了。

    识别保存 用户输入的命令，我们把它分装成一个函数：

    命令的解析 

    现在，上述只是 从用户的输入当中保存到了用户输入的命令，但是，这个命令还是我们不是我们最终想要的命令我们还需要把这么命令做 解析，把这个字符串解析出多字符串，然后解析出的字符串才是我们想要的 命令 和 命令的参数。

    而且，在拿到 我们想要的字符串之后，我们还要向办法把这些个字符串都 存储起来，也就是，每一个字符串的地址保存在哪里呢？

    很简单，就是用 字符串指针数组来存储，数组当中一个元素存储的一个 字符串，这就类似于 main（）函数的 argv 参数，存储 外部调用 这个程序 所使用的 命令的参数一样。

    定义 字符串指针数组：
     

     关于切割，可以使用 strtok（）函数，这个函数就可以帮助我们 每一次调用，按照空格为分隔符，切割出一个子字符串。

    所以，我们可以这样写：

     此时我们就可以，测试一下，上述是否 达到 分隔字符串的目录：

    输出：
     

     发现，此时在 argc 数组当中，各个元素就存储了 用户输入的 各个命令 和 参数。

    创建子进程，进行 子进程代码 和数据替换（程序替换），实现 运行用户输入的命令的操作。

    在前言的 程序替换 这篇博客当中说了什么是程序替换，bash 在执行 用户输入的命令的时候，就是创建子进程，然后 把用户执行的命令（本质上也是一个可执行程序），把这个可执行程序当中的代码 替换到 子进程 当中，从0 开始执行；此时，子进程就在执行 用户输入的命令对应的可执行程序了。

    所以，现在我们也是要实现类似的操作。

    先是创建子进程：
     

    父进程当中的 等待的一些操作，现在先不写，先完成子进程当中的 程序替换操作：

    程序替换有 6 个库函数可以使用 ，这里使用 execvpe（）函数，因为 我们存储命令的方式就是使用 数组的方式来存储的，而且 ，我们实现的简单 shell 就是让他去完成一些 系统当中的 命令操作，所以没用 PATH 环境变量当中默认的路径就可以了。最后的 e 就是环境变量，这里我们还是自己传入（其实不用自己传也是可以的，子进程会继承父进程当中的环境变量）

     至此，子进程当中的 程序替换部分，就已经实现了，现在我们运行我们的 shell，已经可以运行 系统当中的命令了：
     

    当然，目前我们还没有写 shell 的结束方式，所以，目前是死循环在执行的。

     我们自己写的 shell 在运行之时会遇见的问题：

     当然，上述只是 实现一个简单的 程序替换，一些比较复杂的功能，比如 vim 还是会报出一下错误的；ll 也就是 ls - l 的简写也是不行的；因为我们现在实现的 shell 和 Linux 当中的  shell 差别还是蛮大的。

    但是，不重要，因为上述的简单的模块，已经可以帮助我们理解很多的 shell 当中是如何进行解析的，如果执行 用户输入的命令的···· 起码上述是能运行 系统当中的很多命令的。

    再次理解 何为内建命令 

     而且不止上述的问题，当我们使用 cd 命令移动当前位置之时，比如 cd .. 移动到上级路径：
     

    发现，当前路径没有改变。 

     当我们切换路径之时，一点用都没有。

     我们先来理解为什么不能？

    当我们想要运行一个命令的可执行程序的时候，我们上述的操作是无脑的把 子进程当中的代码进行替换，所以，实际上，我们在命令行当中运行这个 命令的 可执行文件，不是父进程再跑，而是这个子进程再跑。但是我们运行的 命令行 是父进程啊，我们在屏幕上看到的 路径 是 父进程所在路径，所以，我们在屏幕上是看不到的。

    换句话说，进程之间是具有独立性的，就算刚开始父子进程共用一个 代码 和 数据，但是一旦其中某一个 进程 对 代码和数据进行了修改，都会发生写时拷贝。那么 子进程 执行 cd 命令，跟父进程有什么关系呢？

     没有关系！！

    所以，不是cd 命令不能再我们实现的 shell 当中运行，而是 cd 是在子进程当中运行的，而 我们看到的路径是父进程的。子进程 执行菜cd命令到 上级目录，根目录··· 一直 输入cd 命令，子进程夸夸跑，但是，一次cd 命令执行完，子进程就退出了，跟父进程有什么关系呢？

    所以，我们不能单独的把这种 需要影响到 父进程的命令 无脑的使用 子进程的进程替换 来实现，换句话说，这样命令，不能让子进程去跑，而是让父进程去跑。这样的命令，称之为 -- 内建命令。

    而所有的内建命令都是在 shell 当中一个一个的函数来进行一个个命令的处理的，本质上，内建命令本质上就是一个一个的在shell 当中实现的函数。 

    实现 cd 

    要解决上述 cd 的话，就需要特殊判断，判断，如果当前用户输入的命令是 cd 命令的话，就进行特殊处理。

    怎么处理呢？其是在 系统当中是有一些系统调用函数的，比如 chdir （ ）这个函数就可以帮助我们 更改当前进程的一个工作路径。

    由上述可知，在 chdir 函数当中传入一个 路径，那么就可以更改的到这个路径当中，所以，因为用户输入的命令是一个字符串，而且已经被我们解析出了，在我们存储解析的字符串指针数组当中目的第一个元素，就是用户输入的 命令的名称。使用 strcmp（）函数判断 argv[0] 这个元素 和 "cd" 这个字符串是否是一样的，来判断当前用户输入的是不 cd 命令。

     而且，因为用户在使用 cd 命令之时，一定是 cd 加上一个 绝对路径或者是相对路径，所以，cd 的命令 解析出来的 字符串指针数组一定是一个两个元素以上的。

    其实此时使用 chdir（）函数就可以实现 修改家目录的效果：

    如上就是我们在 shell 当中自己实现的 cd 内建命令。 

    但是，我打印当前工作路径的方式是按照 PWD 这个工作目录来打印的，如果我们单独的按照 PWD 来打印的话，此时 PWD 在 自己实现的 cd命令  修改之后是不会修改的，所以，shell 打印的命令行当中 ，打印当前工作目录的 字符串 还是 保存之前的工作目录 的字符串，不是修改之后的工作目录 的字符串：
     

    此时我们查看当前的PWD环境变量：

     PWD 保存还是 发现还是 原来 父进程的工作路径。

     所以，我们在 shell 当中不能仅仅是修改 父进程的当前工作路径，还应该修改 PWD，因为我们是靠 PWD 这个环境变量来在命令行当中打印 当前 父进程（也就是shell） 的工作路径的。

    如何修改，其实在 系统当中专门有这个的调用接口： getcwd（）函数，获取当前的工作路径：

     他可以把当前的 工作路径，以字符串的形式覆盖 到 buf 这个字符串当中。

    所以，我们每一次 执行 cd 这内建命令，就要重新刷新一下 PWD 环境变量当中值。

    我们可以一个字符串数组来存储 PWD 当中的值：

    这个 pwd 数组是全局的。 

    那么我们在 getpwd（）函数当中就不能这样写了，不能直接使用 getenv（）函数来直接获取到 PWD 的值，而是要使用 getcwd（）函数来刷新一下当前 PWD 的值，刷新到 当前的工作路径：

    此时，我们在打印 命令行的 函数当中，把 getpwd（）先调用，目的是刷新一下 PWD 环境变量，然后再把 pwd 传入到 printf（）当中作为工作目录的 字符串：
     

     此时我们在实现之时就可以 实现 命令行当中 工作目录的实时打印了：
     

     其他一些内建命令实现

    1. int buildCommand(char *_argv[], int _argc)
    2. {
    3.     if(_argc == 2 && strcmp(_argv[0], "cd") == 0){
    4.         chdir(argv[1]);
    5.         getpwd();
    6.         sprintf(getenv("PWD"), "%s", pwd);
    7.         return 1;
    8.     }
    9.     else if(_argc == 2 && strcmp(_argv[0], "export") == 0){
    10.         strcpy(myenv, _argv[1]);  // 方式修改 _argv[1] 这个指针修改的到 myenv 环境变量
    11.         putenv(myenv);
    12.         return 1;
    13.     }
    14.     else if(_argc == 2 && strcmp(_argv[0], "echo") == 0){
    15.         if(strcmp(_argv[1], "$?") == 0)
    16.         {
    17.             printf("%d\n", lastcode);
    18.             lastcode=0;
    19.         }
    20.         else if(*_argv[1] == '$'){
    21.             char *val = getenv(_argv[1]+1);
    22.             if(val) printf("%s\n", val);
    23.         }
    24.         else{
    25.             printf("%s\n", _argv[1]);
    26.         }
    27.  
    28.         return 1;
    29.     }
    30.  
    31.     // 特殊处理一下ls
    32.     if(strcmp(_argv[0], "ls") == 0)
    33.     {
    34.         _argv[_argc++] = "--color";
    35.         _argv[_argc] = NULL;
    36.     }
    37.     return 0;
    38. }

    上述多了一个 strcpy （）多拷贝一次，是因为 ，系统当中添加环境变量，不是把 字符串当中的内容拷贝到 环境变量的存储空间当中，而是 把 这个字符串的首元素地址拷贝到 环境变量表当中。所以，如果我们直接使用 _argv[] 这个数组来 作为环境变量的 字符串地址的话，那么就可能会修改到 _argv[] 某一个元素之时，就会修改到这个 环境变量。

    环境变量表当中存储的不是 字符串这个字符串，而是这些个字符串的 首元素地址。

    因为，环境变量当中存储的数据是很重要的，所以，不能随便定义一个空间，就把这个空间作为这个环境变量表当中维护的空间，因为shell 当中不知道这个空间是否会被 其他人所修改，shell 要自己维护一块空间来作为存储环境变量的空间。

    总结 （shell 导入环境变量的方式）

    所以，当系统运行起来的时候，或者说我们进行登录的时候，系统就是要运行一个 shell 程序。比如在 Linux 当中就是 bash 命令行解释器。

    而 ，我们知道 各个进程的 环境变量是来自于 bash 父进程的，那么 bash 的环境变量从那里来呢？

    其实在 自己用户，当前的工作目录下，有一写配置文件，如 Linux 当中 .bash_profile 这个文件当中：

     所以，当用户登录的时候，shell 会读取当前用户目录下的 .bash_profile 这个配置文件，在个文件当中存储了环境变量导入到方式，其实 这个文件也就是一个 shell 脚本文件，进行命令解释执行之后，就创建了 当前我们所使用的 环境变量。

    完整代码：
     

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9.  
    10. #define LEFT "["
    11. #define RIGHT "]"
    12. #define LABLE "#"
    13. #define DELIM " \t"
    14. #define LINE_SIZE 1024
    15. #define ARGC_SIZE 32
    16. #define EXIT_CODE 44
    17.  
    18. int lastcode = 0;
    19. int quit = 0;
    20. extern char **environ;
    21. char commandline[LINE_SIZE];
    22. char *argv[ARGC_SIZE];
    23. char pwd[LINE_SIZE];
    24.  
    25. // 自定义环境变量表
    26. char myenv[LINE_SIZE];
    27. // 自定义本地变量表
    28.  
    29.  
    30. const char *getusername()
    31. {
    32.     return getenv("USER");
    33. }
    34.  
    35. const char *gethostname()
    36. {
    37.     return getenv("HOSTNAME");
    38. }
    39.  
    40. void getpwd()
    41. {
    42.     getcwd(pwd, sizeof(pwd));
    43. }
    44.  
    45. void interact(char *cline, int size)
    46. {
    47.     getpwd();
    48.     printf(LEFT"%s@%s %s"RIGHT""LABLE" ", getusername(), gethostname(), pwd);
    49.     char *s = fgets(cline, size, stdin);
    50.     assert(s);
    51.     (void)s;
    52.     // "abcd\n\0"
    53.     cline[strlen(cline)-1] = '\0';
    54. }
    55.  
    56. int splitstring(char cline[], char *_argv[])
    57. {
    58.     int i = 0;
    59.     argv[i++] = strtok(cline, DELIM);
    60.     while(_argv[i++] = strtok(NULL, DELIM)); // 故意写的=
    61.     return i - 1;
    62. }
    63.  
    64. void NormalExcute(char *_argv[])
    65. {
    66.     pid_t id = fork();
    67.     if(id < 0){
    68.         perror("fork");
    69.         return;
    70.     }
    71.     else if(id == 0){
    72.         //让子进程执行命令
    73.         //execvpe(_argv[0], _argv, environ);
    74.         execvp(_argv[0], _argv);
    75.         exit(EXIT_CODE);
    76.     }
    77.     else{
    78.         int status = 0;
    79.         pid_t rid = waitpid(id, &status, 0);
    80.         if(rid == id) 
    81.         {
    82.             lastcode = WEXITSTATUS(status);
    83.         }
    84.     }
    85. }
    86.  
    87. int buildCommand(char *_argv[], int _argc)
    88. {
    89.     if(_argc == 2 && strcmp(_argv[0], "cd") == 0){
    90.         chdir(argv[1]);
    91.         getpwd();
    92.         sprintf(getenv("PWD"), "%s", pwd);
    93.         return 1;
    94.     }
    95.     else if(_argc == 2 && strcmp(_argv[0], "export") == 0){
    96.         strcpy(myenv, _argv[1]);
    97.         putenv(myenv);
    98.         return 1;
    99.     }
    100.     else if(_argc == 2 && strcmp(_argv[0], "echo") == 0){
    101.         if(strcmp(_argv[1], "$?") == 0)
    102.         {
    103.             printf("%d\n", lastcode);
    104.             lastcode=0;
    105.         }
    106.         else if(*_argv[1] == '$'){
    107.             char *val = getenv(_argv[1]+1);
    108.             if(val) printf("%s\n", val);
    109.         }
    110.         else{
    111.             printf("%s\n", _argv[1]);
    112.         }
    113.  
    114.         return 1;
    115.     }
    116.  
    117.     // 特殊处理一下ls
    118.     if(strcmp(_argv[0], "ls") == 0)
    119.     {
    120.         _argv[_argc++] = "--color";
    121.         _argv[_argc] = NULL;
    122.     }
    123.     return 0;
    124. }
    125.  
    126. int main()
    127. {
    128.     while(!quit){
    129.         // 1.
    130.         // 2. 交互问题,获取命令行, ls -a -l > myfile / ls -a -l >> myfile / cat < file.txt
    131.         interact(commandline, sizeof(commandline));
    132.  
    133.         // commandline -> "ls -a -l -n\0" -> "ls" "-a" "-l" "-n"
    134.         // 3. 子串分割的问题，解析命令行
    135.         int argc = splitstring(commandline, argv);
    136.         if(argc == 0) continue;
    137.  
    138.         // 4. 指令的判断 
    139.         // debug
    140.         //for(int i = 0; argv[i]; i++) printf("[%d]: %s\n", i, argv[i]);
    141.         //内键命令，本质就是一个shell内部的一个函数
    142.         int n = buildCommand(argv, argc);
    143.  
    144.         // 5. 普通命令的执行
    145.         if(!n) NormalExcute(argv);
    146.     }
    147.     return 0;
    148. }

  • 相关阅读:
    LeetCode刷题之HOT100之岛屿数量
    CF1000F One Occurrence
    逐次变分模态分解(Sequential Variational Mode Decomposition，SVMD)（附代码）
    java若依框架代码生成工具使用(前后端分离版)
    Adobe官方清理工具Adobe Creative Cloud Cleaner Tool使用教程
    客户流失？来看看大厂如何基于spark+机器学习构建千万数据规模上的用户留存模型 ⛵
    A-Level经济，A*有救了
    Shell脚本学习指南（四）——管道的神奇魔力
    Mysql主从复制数据架构全面解读
    基于VUE3+Layui从头搭建通用后台管理系统（前端篇）十一：通用表单组件封装实现
  • 原文地址：https://blog.csdn.net/chihiro1122/article/details/134281223