【Linux】进程替换与自定义 Shell：原理与实战

目录

一、进程程序替换

1、替换原理

2、替换函数

（1）函数解释

  ① filename / pathname

 ② 参数表传递

 ③ 环境变量表传递

（2）命名理解

 二、自定义shell命令行解释器

1、实现原理

2、实现代码

（1）获取环境变量

（2）输出命令行提示符

（3）获取用户输入的命令

（4）命令行分析

（5）检测并执行内键命令

（6）执行命令

（7）完整代码

 三、函数和进程之间的相似性

一、进程程序替换

fork（）函数创建新的子进程后，子进程如果想执行一个全新的程序呢？进程的程序替换来完成这个功能！程序替换是通过特定的接口，加载磁盘上的一个全新程序（代码和程序），加载到调用进程的地址空间中！

1、替换原理

用 fork 创建子进程后执行的是和父进程相同的程序（但有可能执行不同的代码分支），子进程往往要调用一种 exec 函数以执行另一个程序。当进程调用一种 exec 函数时，该进程的用户空间代码和数据完全被新程序替换，从新程序的启动例程开始执行。调用 exec 并不创建新进程，所以调用 exec 前后该进程的ID并未改变。exec只是用磁盘上的一个新程序替换了当前进程的正文段、数据段、堆段和栈段。

示例：

  1. #include
  2. #include
  3.  
  4. int main()
  5. {
  6.     printf("程序运行！\n");
  7.     execl("/usr/bin/ls", "ls", "-l", "-a", NULL);
  8.     printf("程序运行完毕！\n");
  9.     return 0;
  10. }
  11.  
  12. $ ./proc # 原始代码中的第二个printf函数被替换，不执行！
  13. 程序运行！
  14. total 32
  15. drwxrwxr-x  2 zyt zyt  4096 Apr 18 17:13 .
  16. drwxrwxr-x 16 zyt zyt  4096 Apr 18 17:07 ..
  17. -rw-rw-r--  1 zyt zyt    58 Apr 18 17:12 Makefile
  18. -rwxrwxr-x  1 zyt zyt 16000 Apr 18 17:13 proc
  19. -rw-rw-r--  1 zyt zyt   190 Apr 18 17:13 test.c

一旦程序替换成功，就去执行新代码了，后续的原始代码也就不存在了（被覆盖了）。

 exec* 函数只有失败返回值，没有成功返回值。所以对于exec函数不用对返回值做判断。

2、替换函数

● 这些函数如果调用成功则加载新的程序从启动代码开始执行，不再返回。

● 如果调用出错则返回-1，若成功，不返回。

  1. #include 
  2. int execl(const char *path, const char *arg, ...);
  3. int execlp(const char *file, const char *arg, ...);
  4. int execle(const char *path, const char *arg, ...,char *const envp[]);
  5. int execv(const char *path, char *const argv[]);
  6. int execvp(const char *file, char *const argv[]);
  7. int execve(const char *path, char *const argv[], char *const envp[]);
  8. int fexecve(int fd, char *const argv[], char *const envp[]);

（1）函数解释

  ① filename / pathname

pathname就是取【路径名+程序】作为参数；filename就是文件名作为参数，当指定filename作为参数时：

● 如果filename中包含“/”，则将其视为路径名。

● 否则就按照PATH环境变量，在它所指定的各目录中搜索可执行文件。【不知道PATH环境变量的话看前文：深入浅出：环境变量与进程地址空间的核心机制-CSDN博客】

 ② 参数表传递

函数execl、execlp 和 execle 要求新程序的每一个命令行参数都说明一个单独的参数。这种参数表以空指针结尾。对execl、execlp 和 execle三个函数表示命令行参数的一般方法：

char *arg(), char *argl, ..., char *argn, (char *)0

 这种语法显示的说明了最后一个命令行参数之后跟了一个空指针。如果用常量0来表示一个空指针，则必须将它强制转化成为一个指针：否则它将被解释成整形参数。如果一个整形数的长度与char*的长度不同，那么exec函数的实际参数将出错。

对于其余的4个函数，则应先构造一个指向各参数的指针数组，然后将该数组指针地址作为这4个函数的参数（建立argv）。

 ③ 环境变量表传递

以e结尾的三个函数（execle、execve、fexecve）可以传递一个指向环境字符串指针数组的指针。在ISO C原型（国际标准化组织制定的C语言标准）之前，execle的参数是：

char *pathname, char *arg(), ..., char *argn, (char *)0, char *envp[]

从中可见，最后一个参数是指向环境字符串的各字符指针构成的数组的指针。而在ISO C原型中，所有命令行参数、空指针和envp指针都是用省略号（...）表示。 

其他四个函数，则使用调用进程中的environ变量为新程序复制现有的环境。通常，一个进程允许将其环境传播给其子进程，但有时也有这种情况，进程想为子进程指定某一个确定的环境，可以直接用putenv（）函数【添加或修改环境变量，它接受一个形式为 "name=value" 的字符串，并将其添加到当前进程的环境变量列表中】；或者通过第三方变量environ。

（2）命名理解

这7个函数的参数很难记忆。函数名的字符会给我们一些帮助。

● 字母p表示该函数取filename作为参数，并且用PATH环境变量寻找可执行文件。

● 字母l表示该函数取一个参数表，参数以可变参数列表的形式传递。 

● 字母v与字母l互斥，v表示该函数取了一个argv[]矢量，参数以字符指针数组的形式传递。

● 字母e表示该函数取envp[]数组，自己维护环境变量，而不使用当前环境。

调用示例如下：

  1. #include 
  2.  
  3. int main() {
  4.     char *const argv[] = {"ps", "-ef", NULL};
  5.     char *const envp[] = {"PATH=/bin:/usr/bin", "TERM=console", NULL};
  6.  
  7.     // 使用 execl 执行 /bin/ps 命令，需要完整路径
  8.     execl("/bin/ps", "ps", "-ef", NULL);
  9.  
  10.     // 使用 execlp 执行 ps 命令，带 p 的，可以使用环境变量 PATH，无需写全路径
  11.     execlp("ps", "ps", "-ef", NULL);
  12.  
  13.     // 使用 execle 执行 ps 命令，带 e 的，需要自己组装环境变量
  14.     execle("/bin/ps", "ps", "-ef", NULL, envp);
  15.  
  16.     // 使用 execv 执行 /bin/ps 命令，需要完整路径
  17.     execv("/bin/ps", argv);
  18.  
  19.     // 使用 execvp 执行 ps 命令，带 p 的，可以使用环境变量 PATH，无需写全路径
  20.     execvp("ps", argv);
  21.  
  22.     // 使用 execve 执行 /bin/ps 命令，带 e 的，需要自己组装环境变量
  23.     execve("/bin/ps", argv, envp);
  24.  
  25.     exit(0);
  26. }

在很多Unix的实现中，这7个函数中只有execve是内核的系统调用。另外6个只是库函数，它们最终都要调用该系统调用。这7个函数之间的关系如图：

 二、自定义shell命令行解释器

1、实现原理

考虑下面这个与shell的互动：

  1. [root@localhost epoll]# ls
  2. client.cpp  readme.md  server.cpp  utility.h
  3.  
  4. [root@localhost epoll]# ps
  5.   PID TTY      TIME     CMD
  6.  3451 pts/0    00:00:00 bash
  7.  3514 pts/0    00:00:00 ps

用下图的时间轴来表示事件的发生次序。其中时间从左向右，shell由标识为sh的方块表示，它随着时间的流逝从左向右移动。shell从用户读入字符串“ls”。shell建立一个新的进程，然后在那个进程中运行ls程序并等待那个进程结束。  然后shell读取新的一行输入，建立一个新的进程，在这个进程中运行程序并等待这个进程结束。

所以，实现一个自定义shell需要循环以下过程：

（1）获取命令行

（2）解析命令行

（3）建立一个子进程（fork）

（4）替换子进程（execvp）

（5）父进程等待子进程退出（wait）

2、实现代码

（1）获取环境变量

要实现一个自定义 Shell，环境变量的处理是关键部分。正常情况shell启动要从系统中获取环境变量，而我们自定义shell的环境变量信息要从父shell中获取。

手动获取：在 C 中可以通过 extern char **environ 访问继承的环境变量。将父Shell的环境变量逐条复制到g_env中，然后将g_env中的变量添加到当前进程的环境变量表。【注意：（这里使用了putenv() 函数）此后g_env[i]的内存由系统管理，不能再手动free！Unix/Linux系统提供的全局变量，指向当前进程的环境变量表，】

  1. // 环境变量表
  2. #define MAX_ENVS 1024
  3. char *g_env[MAX_ENVS];
  4. int g_envs = 0;
  5.  
  6. // 从父shell1获取环境变量表，本来是要从配置文件获取的
  7. void InitEnv()
  8. {
  9.     extern char **environ;
  10.     memset(g_env, 0, sizeof(g_env)); // 初始化
  11.     g_envs = 0;
  12.  
  13.     // 1.获取环境变量
  14.     for(int i = 0; environ[i]; i++)
  15.     {
  16.         // (1)申请空间
  17.         g_env[i] = (char*)malloc(strlen(environ[i])+1);
  18.         // (2)拷贝到我们的环境变量表
  19.         strcpy(g_env[i], environ[i]);
  20.         g_envs++;
  21.     }
  22.     // 测试：添加了一个新的环境变量
  23.     g_env[g_envs++] = (char*)"HAHA=for_test";
  24.     g_env[g_envs] = NULL; // 表的最后一个成员必须是NULL
  25.  
  26.     // 2.获取到的环境变量导入shell的表中
  27.     for(int i = 0; g_env[i]; i++)
  28.     {
  29.         putenv(g_env[i]);
  30.     }
  31. }

（2）输出命令行提示符

提示符格式：[用户名@主机名:当前目录的基名]# 

① MakeCommandline() 中使用 snprintf() 格式化提示符：【format：格式化字符串，用于指定如何格式化后续的参数】【...：可变参数列表，根据 format 的要求提供相应的值】

int snprintf(char *str, size_t size, const char *format, ...);

② PrintCommandline() 打印命令行提示符：fflush用来确保提示符立即显示（尤其在无换行符时）。

  1. #define COMMAND_SIZE 1024
  2. #define HOSTNAME_MAX 1024
  3. #define FORMAT "[%s@%s:%s]# "
  4.  
  5. // shell定义的全局变量
  6.  
  7. char cwd[1019];
  8. char cwdenv[1024]; 
  9.  
  10. const char *GetUserName()
  11. {
  12.     const char * name = getenv("USER");
  13.     return name == NULL ? "None" : name;
  14. }
  15.  
  16. const char *GetHostName()
  17. {
  18.     char hostname[HOSTNAME_MAX];
  19.     return (gethostname(hostname, HOSTNAME_MAX) == -1) ? "None" : hostname;
  20. }
  21.  
  22. const char *GetPwd()
  23. {
  24.     //const char * pwd = getenv("PWD");
  25.     const char *pwd = getcwd(cwd, sizeof(cwd)); // 通过系统调用获取
  26.     if(pwd != NULL)
  27.     {   // 把自己的环境变量导给进程
  28.         snprintf(cwdenv, sizeof(cwdenv), "PWD=%s", cwd);
  29.         putenv(cwdenv);
  30.     }
  31.     return pwd == NULL ? "None" : pwd;
  32. }
  33.  
  34. // 对路径做包装，只显示当前位置
  35. std::string DirName(const char *pwd)
  36. {
  37. #define SLASH "/"
  38.     std::string dir = pwd;
  39.     if(dir == SLASH) return SLASH;
  40.     auto pos = dir.rfind(SLASH);
  41.     if(pos == std::string::npos) return "BUG";
  42.     return dir.substr(pos+1);
  43. }
  44.  
  45. // 制作命令行提示符
  46. void MakeCommandline(char cmd_prompt[], int size)
  47. {
  48.     // 设置式化输入
  49.     snprintf(cmd_prompt, size, FORMAT, GetUserName(), GetHostName(), DirName(GetPwd()).c_str());
  50.     //snprintf(cmd_prompt, size, FORMAT, GetUserName(), GetHostName(), GetPwd());
  51. }
  52.  
  53. // 打印命令行提示符
  54. void PrintCommandline()
  55. {
  56.     char prompt[COMMAND_SIZE];
  57.     MakeCommandline(prompt, COMMAND_SIZE);
  58.     printf("%s", prompt);
  59.     fflush(stdout);
  60. }

（3）获取用户输入的命令

GetCommandline() 从标准输入读取一行用户输入的命令。

fgets() 是一个在 C 语言中用于从文件流中读取字符串的函数，属于标准库 中的函数。它能够从指定的文件流中读取一行数据，并将其存储到目标缓冲区中，同时可以限制读取的最大字符数，从而避免缓冲区溢出。

char* fgets(char* str, int size, FILE* stream);

但 fgets() 会保留输入中的换行符，所以调用后要清理换行符。

  1. // 获取用户输入命令
  2. bool GetCommandline(char *out, int size)
  3. {
  4.     // 从标准输入流获取命令，其实就是字符串
  5.     char* c = fgets(out, size, stdin);
  6.  
  7.     if(c == NULL) return 1;
  8.     out[strlen(out)-1] = '\0'; // 清理\n, 至少会按一次回车，所以不会出错
  9.  
  10.     if(strlen(out) == 0) return false;// 什么都没输入
  11.     return true;
  12. }

（4）命令行分析

函数实现：命令行字符串的解析，将用户输入的命令行（如 "ls -a -l"）拆分为 参数数组 g_argv，并记录参数个数 g_argc。

strtok() 是一个在 C 语言中用于字符串分割的函数，属于标准库 中的函数。它可以根据指定的分隔符将字符串分割成多个子字符串，并且在多次调用中逐个返回这些子字符串。

char* strtok(char* str, const char* delim);

在第一次调用时，str 是指向要分割的原始字符串的指针。 在后续调用中，str 应该传入 NULL，表示继续分割上一次调用后剩余的部分。

  1. // 全局的命令行参数表
  2. #define MAXARGC 128
  3. char *g_argv[MAXARGC];
  4. int g_argc = 0;
  5.  
  6. // 3. 命令行分析
  7. bool CommandParse(char *commandline)
  8. {
  9.     // "ls -a -l" -> "ls" "-a" "-l"
  10.     // 字符串切割 strtok()函数
  11. #define SEP " "
  12.     g_argc = 0;
  13.     // 第一次调用：传入要分割的字符串和分隔符
  14.     g_argv[g_argc++] = strtok(commandline, SEP);
  15.     // 后续调用：传入 NULL 和分隔符，继续分割同一字符串
  16.     while(g_argv[g_argc++] = strtok(NULL, SEP));
  17.     g_argc--; // 修正参数计数，因为while 循环中 g_argc++ 在赋值后执行的
  18.     return g_argc > 0 ? true : false;
  19. }

（5）检测并执行内键命令

CheckAndExecBuiltin() 检查是否为内建命令。CD() 实现目录切换（cd 命令），Echo() 实现 echo 命令。

chdir() 是一个在 C 语言中用于更改当前工作目录的函数，属于标准库 中的函数（在 POSIX 系统中）。它允许程序动态地改变当前进程的工作目录。

  1. // 最后一个程序退出码
  2. int lastcode = 0;
  3.  
  4. // 全局的命令行参数表
  5. #define MAXARGC 128
  6. char *g_argv[MAXARGC];
  7. int g_argc = 0;
  8.  
  9. // 内键命令
  10. bool CD()
  11. {
  12.  
  13.     if(g_argc == 1) // 只有一个cd时
  14.     {
  15.         std::string home = GetHome();
  16.          if(home.empty()) return true;
  17.         chdir(home.c_str()); // 切换路径
  18.      }
  19.     else
  20.     {
  21.         std::string where = g_argv[1]; // 目标路径
  22.         if(where == "-")
  23.         {}
  24.         else if(where == "~")
  25.         {}
  26.         else
  27.         {
  28.             chdir(where.c_str());
  29.         }
  30.     }
  31.     return true;
  32. }
  33.  
  34. bool Echo()
  35. {
  36.     if(g_argc == 2)
  37.     {
  38.         //
  39.         std::string opt = g_argv[1];
  40.         if(opt == "$?") // eg1: echo $? 打印退出码
  41.         {
  42.             std::cout << lastcode << std::endl;
  43.             lastcode = 0;
  44.             return true;
  45.         }
  46.         if(opt[0] == '$') // eg2: echo $PATH 打印环境变量
  47.         {
  48.             std::string env_name = opt.substr(1);
  49.             const char * env_value = getenv(env_name.c_str()); // 获取环境变量的值
  50.             if(env_value) 
  51.                 std::cout << env_value << std::endl;
  52.         }
  53.     }
  54.     return false;
  55. }
  56.  
  57. // 4. 检测并执行内键命令
  58. bool CheckAndExecBuiltin()
  59. {
  60.     std::string cmd = g_argv[0];
  61.     if(cmd == "cd")
  62.     {
  63.        return CD();
  64.     }
  65.     else if(cmd == "echo")
  66.     {
  67.        return Echo();
  68.     }
  69.     return false;
  70. }

（6）执行命令

Execute() 实现了 Shell 中外部命令的执行，核心是通过 fork() 创建子进程，并在子进程中调用 execvp 执行目标命令（自定义shell），父进程则等待子进程结束并记录其退出状态。

  1. // 5.执行命令
  2. int Execute()
  3. {
  4.     pid_t id = fork();
  5.     if(id == 0)
  6.     {
  7.         // child, 程序替换
  8.         execvp(g_argv[0], g_argv);
  9.         exit(1);
  10.     }
  11.     // father
  12.     int status = 0;
  13.     pid_t rid = waitpid(id, &status, 0);
  14.     if(rid > 0)
  15.     {
  16.         lastcode = WEXITSTATUS(status);
  17.     }
  18.     return 1;
  19. }

（7）完整代码

  1. #include
  2. #include
  3. #include
  4. #include
  5. #include
  6. #include
  7. #include
  8.  
  9. #define COMMAND_SIZE 1024
  10. #define HOSTNAME_MAX 1024
  11. #define FORMAT "[%s@%s:%s]# "
  12.  
  13. // shell定义的全局变量
  14.  
  15. // 全局的命令行参数表
  16. #define MAXARGC 128
  17. char *g_argv[MAXARGC];
  18. int g_argc = 0;
  19.  
  20. char cwd[1019];
  21. char cwdenv[1024]; 
  22.  
  23. // 环境变量表
  24. #define MAX_ENVS 1024
  25. char *g_env[MAX_ENVS];
  26. int g_envs = 0;
  27.  
  28. // 最后一个程序退出码
  29. int lastcode = 0;
  30.  
  31. const char *GetUserName()
  32. {
  33.     const char * name = getenv("USER");
  34.     return name == NULL ? "None" : name;
  35. }
  36.  
  37. const char *GetHostName()
  38. {
  39.     char hostname[HOSTNAME_MAX];
  40.     return (gethostname(hostname, HOSTNAME_MAX) == -1) ? "None" : hostname;
  41. }
  42.  
  43. const char *GetPwd()
  44. {
  45.     //const char * pwd = getenv("PWD");
  46.     const char *pwd = getcwd(cwd, sizeof(cwd)); // 通过系统调用获取
  47.     if(pwd != NULL)
  48.     {   // 把自己的环境变量导给进程
  49.         snprintf(cwdenv, sizeof(cwdenv), "PWD=%s", cwd);
  50.         putenv(cwdenv);
  51.     }
  52.     return pwd == NULL ? "None" : pwd;
  53. }
  54.  
  55. const char *GetHome()
  56. {
  57.     const char *home = getenv("HOME");
  58.     return home == "" ? NULL : home;
  59. }
  60.  
  61. // 对路径做包装
  62. std::string DirName(const char *pwd)
  63. {
  64. #define SLASH "/"
  65.     std::string dir = pwd;
  66.     if(dir == SLASH) return SLASH;
  67.     auto pos = dir.rfind(SLASH);
  68.     if(pos == std::string::npos) return "BUG";
  69.     return dir.substr(pos+1);
  70. }
  71.  
  72. // 制作命令行提示符
  73. void MakeCommandline(char cmd_prompt[], int size)
  74. {
  75.     // 设置式化输入
  76.     snprintf(cmd_prompt, size, FORMAT, GetUserName(), GetHostName(), DirName(GetPwd()).c_str());
  77.     //snprintf(cmd_prompt, size, FORMAT, GetUserName(), GetHostName(), GetPwd());
  78. }
  79.  
  80. // 打印命令行提示符
  81. void PrintCommandline()
  82. {
  83.     char prompt[COMMAND_SIZE];
  84.     MakeCommandline(prompt, COMMAND_SIZE);
  85.     printf("%s", prompt);
  86.     fflush(stdout);
  87. }
  88.  
  89. // 获取用户输入命令
  90. bool GetCommandline(char *out, int size)
  91. {
  92.     // 从标准输入流获取命令，其实就是字符串
  93.     char* c = fgets(out, size, stdin);
  94.  
  95.     if(c == NULL) return 1;
  96.     out[strlen(out)-1] = '\0'; // 清理\n, 至少会按一次回车，所以不会出错
  97.  
  98.     if(strlen(out) == 0) return false;// 什么都没输入
  99.     return true;
  100. }
  101.  
  102. // 3. 命令行分析
  103. bool CommandParse(char *commandline)
  104. {
  105.     // "ls -a -l" -> "ls" "-a" "-l"
  106.     // 字符串切割 strtok()函数
  107. #define SEP " "
  108.     g_argc = 0;
  109.     // 第一次调用：传入要分割的字符串和分隔符
  110.     g_argv[g_argc++] = strtok(commandline, SEP);
  111.     // 后续调用：传入 NULL 和分隔符，继续分割同一字符串
  112.     while(g_argv[g_argc++] = strtok(NULL, SEP));
  113.     g_argc--;
  114.     return g_argc > 0 ? true : false;
  115. }
  116.  
  117. void PrintArray()
  118. {
  119.     for(int i = 0; g_argv[i]; i++)
  120.     {
  121.         printf("argv[%d]->%s\n", i, g_argv[i]);
  122.     }
  123.     printf("%d\n",g_argc);
  124. }
  125.  
  126. // 从父shell1获取环境变量表，本来是要从配置文件获取的
  127. void InitEnv()
  128. {
  129.     extern char **environ;
  130.     memset(g_env, 0, sizeof(g_env)); // 初始化
  131.     g_envs = 0;
  132.  
  133.     // 1.获取环境变量
  134.     for(int i = 0; environ[i]; i++)
  135.     {
  136.         // (1)申请空间
  137.         g_env[i] = (char*)malloc(strlen(environ[i])+1);
  138.         // (2)拷贝到我们的环境变量表
  139.         strcpy(g_env[i], environ[i]);
  140.         g_envs++;
  141.     }
  142.     // 测试：添加了一个新的环境变量
  143.     g_env[g_envs++] = (char*)"HAHA=for_test";
  144.     g_env[g_envs] = NULL; // 表的最后一个成员必须是NULL
  145.  
  146.     // 2.获取到的环境变量导入shell的表中
  147.     for(int i = 0; g_env[i]; i++)
  148.     {
  149.         putenv(g_env[i]);
  150.     }
  151. }
  152.  
  153. // 内键命令
  154. bool CD()
  155. {
  156.  
  157.     if(g_argc == 1) // 只有一个cd时
  158.     {
  159.         std::string home = GetHome();
  160.          if(home.empty()) return true;
  161.         chdir(home.c_str());
  162.      }
  163.     else
  164.     {
  165.         std::string where = g_argv[1];
  166.         if(where == "-")
  167.         {}
  168.         else if(where == "~")
  169.         {}
  170.         else
  171.         {
  172.             chdir(where.c_str());
  173.         }
  174.     }
  175.     return true;
  176. }
  177.  
  178. bool Echo()
  179. {
  180.     if(g_argc == 2)
  181.     {
  182.         //
  183.         std::string opt = g_argv[1];
  184.         if(opt == "$?") // eg1: echo $?
  185.         {
  186.             std::cout << lastcode << std::endl;
  187.             lastcode = 0;
  188.             return true;
  189.         }
  190.         if(opt[0] == '$') // eg2: echo $PATH
  191.         {
  192.             std::string env_name = opt.substr(1);
  193.             const char * env_value = getenv(env_name.c_str()); // 获取环境变量的值
  194.             if(env_value) 
  195.                 std::cout << env_value << std::endl;
  196.         }
  197.     }
  198.     return false;
  199. }
  200.  
  201. // 4. 检测并执行内键命令
  202. bool CheckAndExecBuiltin()
  203. {
  204.     std::string cmd = g_argv[0];
  205.     if(cmd == "cd")
  206.     {
  207.        return CD();
  208.     }
  209.     else if(cmd == "echo")
  210.     {
  211.        return Echo();
  212.     }
  213.     return false;
  214. }
  215.  
  216. // 5.执行命令
  217. int Execute()
  218. {
  219.     pid_t id = fork();
  220.     if(id == 0)
  221.     {
  222.         // child, 程序替换
  223.         execvp(g_argv[0], g_argv);
  224.         exit(1);
  225.     }
  226.     // father
  227.     int status = 0;
  228.     pid_t rid = waitpid(id, &status, 0);
  229.     if(rid > 0)
  230.     {
  231.         lastcode = WEXITSTATUS(status);
  232.     }
  233.     return 1;
  234. }
  235. // 释放通过malloc分配的环境变量内存
  236. void FreeEnvMemory1()
  237. {
  238.     for(int i = 0; i < g_envs; i++) {
  239.         if(g_env[i] != NULL) {
  240.             free(g_env[i]);  // 释放每个环境变量字符串
  241.             g_env[i] = NULL; // 置空指针
  242.         }
  243.     }
  244.     g_envs = 0;  // 重置计数器
  245. }
  246.  
  247. void FreeEnvMemory() {
  248.     if (!g_used_putenv) {
  249.         // 未调用 putenv，可以安全释放
  250.         for (int i = 0; i < g_envs; i++) {
  251.             free(g_env[i]);
  252.             g_env[i] = NULL;
  253.         }
  254.     } else {
  255.         // 调用过 putenv，只能释放数组指针（不释放字符串内存）
  256.         for (int i = 0; i < g_envs; i++) {
  257.             g_env[i] = NULL;  // 仅置空指针
  258.         }
  259.     }
  260.     g_envs = 0;
  261. }
  262.  
  263. int main()
  264. {
  265.     // shell启动要从系统中获取环境变量，而我们的环境变量信息要从父shell中获取
  266.     InitEnv();
  267.     // 当然是循环啦！
  268.     while(true)
  269.     {
  270.         // 1、输出命令行提示符
  271.         PrintCommandline();
  272.  
  273.         // 2. 获取输入的命令
  274.         char commandline[COMMAND_SIZE];
  275.         if(!GetCommandline(commandline, COMMAND_SIZE))
  276.             continue;
  277.         //printf("%s\n", commandline);
  278.  
  279.         // 3. 命令行分析, 字符串拆分成多个元素
  280.         if(!CommandParse(commandline)) continue;
  281.         //PrintArray();
  282.  
  283.         // 4.检测并执行内建命令
  284.         if(CheckAndExecBuiltin()) continue;
  285.  
  286.         // 5. 执行命令
  287.         Execute();
  288.     }
  289.     // 释放空间
  290.     FreeEnvMemory();
  291.     return 0;
  292. }

 三、函数和进程之间的相似性

一个C程序有很多函数组成。一个函数可以调用另一个函数，同时传递给它一些参数。被调用的函数执行一定的操作，然后返回一个值。每个函数都有他的局部变量，不同的函数通过 call/return 系统进行通信。这种通过参数和返回值在拥有私有数据的函数间通信的模式是结构化程序设计的基础。Linux 鼓励将这种应用于程序之内的模式扩展到程序之间。如下图：

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

注：本文转载自blog.csdn.net的忧伤的大鼻嘎的文章"https://blog.csdn.net/2401_83431652/article/details/147336365"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！