【从浅学到熟知Linux】进程控制下篇=＞进程程序替换与简易Shell实现（含替换原理、execve、execvp等接口详解）

在这里插入图片描述

🏠关于专栏：Linux的浅学到熟知专栏用于记录Linux系统编程、网络编程等内容。
🎯每天努力一点点，技术变化看得见

文章目录

  • 进程程序替换
    • 什么是程序替换及其原理
    • 替换函数
      • execl
      • execlp
      • execle
      • execv
      • execvp
      • execvpe
      • execve
  • 替换函数总结
  • 实现简易Shell

进程程序替换

什么是程序替换及其原理

父进程创建子进程的目的只有一个：让子进程帮助父进程完成某些任务。如果要让子进程执行与父进程不同的代码有两种方式↓↓↓

  • 通过if分支判断语句决定父子进程各自的执行代码
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>int main()
{pid_t id = fork();if(id < 0)//进程创建错误{perror("fork");exit(1);}else if(id == 0)//子进程{int cnt = 5;while(cnt){printf("child process %d is doing something different from parent process!\n");cnt--;}exit(0);}else//父进程{int status = 0;pid_t ret = waitpid(id, &status, 0);if(ret == id){printf("parent wait child process success! exitcode = %d\n", WEXITSTATUS(status));}}return 0;
}

在这里插入图片描述

  • 通过进程程序替换，让子进程执行与父进程完全不同代码

下面仅是演示代码，关于进程程序替换的详细内容将在下文介绍↓↓↓

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>int main()
{pid_t id = fork();if(id < 0){perror("fork");exit(1);}else if(id == 0){execlp("top", "top", NULL);exit(2);}else{int status = 0;pid_t ret = waitpid(id, &status, 0);if(WIFEXITED(status)){printf("wait success! exitcode = %d\n", WEXITSTATUS(status));}}return 0;
}

在这里插入图片描述
从上面可知，用fork创建子进程后可以执行的程序和父进程相同的程序（但可能执行不同的代码分支），也可以通过调用exec系列函数接口来执行另一个程序。

当程序调用exec系列函数中的一个时，该进程的用户空间的代码和数据完全被新程序替换，从新程序的启动例程开始执行。调用exec并没有创建新进程，所以调用exec前后该子进程的id并没有改变。调用了exec函数后，会对子进程的数据和代码做写入，此时会发生写时拷贝（即子进程不再与父进程共享代码和数据，而是在物理空间中拥有自己独立的代码和数据）。

在这里插入图片描述
在这里插入图片描述

★ps：CPU如何得知替换后程序的入口？Linux中形成的可执行文件是有格式的（即ELF），可执行文件的表头包含可执行程序的入口地址、页表、mm_struct（程序地址空间）等。

替换函数

下面了解一下exec系列函数->替换换函数共有7个，先看一下它们，对它们有一个大致印象↓↓↓（除了execve在2号man手册，其余均位于3号man手册）
在这里插入图片描述
在这里插入图片描述

下面给出每个exec系列函数的使用方法↓↓↓

execl

int execl(const char* path, const char* arg, ...)
execl的第一个参数需要传入可执行文件的绝对路径，例如，可以传入/usr/bin/ls。而余下参数为可变参数，传入形式就和我们使用命令行命令一样，先给出命令名称，再给出命令行参数，最终以NULL结尾，例如，“ls”、“-a”、“-l”、NULL。

★ps：execl的l表示list（列出）的意思，即需要列出每个命令行参数。

下面给出接口使用示例↓↓↓

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>int main()
{pid_t id = fork();if(id < 0){perror("fork");exit(1);}else if(id == 0){execl("/usr/bin/ls", "ls", "-a", "-l", NULL);exit(2);}else{int status = 0;pid_t ret = waitpid(id, &status, 0);if(WIFEXITED(status)){printf("Wait %d success! exitcode is %d\n", ret, WEXITSTATUS(status));}}return 0;
}

在这里插入图片描述

execlp

int execlp(const char* file, const char* arg, ...);
execlp第一个参数如果是存在于PATH环境变量中的可执行文件（如命令等），可以直接写出可执行文件名称即可，不用写绝对路径，因为execlp在执行时，会在PATH环境变量中的各个目录下查找对应的可执行文件；但如果是不存放于PATH环境变量中的各个目录下的可执行文件，则需要使用绝对路径。而余下参数为可变参数，传入形式就和我们使用命令行命令一样，先给出命令名称，再给出命令行参数，最终以NULL结尾，这与execl相同。

★ps：exec系列函数中，主要带有p的，如果可执行文件存在于PATH环境变量中，均不需要使用绝对路径，只需要给出可执行文件名即可。

下面给出接口使用示例↓↓↓

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>int main()
{pid_t id = fork();if(id < 0){perror("fork");exit(1);}else if(id == 0){execlp("ls", "ls", "-a", "-l", NULL);exit(2);}else{int status = 0;pid_t ret = waitpid(id, &status, 0);if(WIFEXITED(status)){printf("Wait %d success! exitcode is %d\n", ret, WEXITSTATUS(status));}}return 0;
}

在这里插入图片描述

★ps：如果我们的exec系列函数能够执行系统命令，那如何执行我们自己编写的可执行程序呢？下面演示C语言程序调用C++程序↓↓↓

excute.cpp↓↓↓

#include <iostream>
using namespace std;int main()
{for(int i = 0; i < 5; i++){cout << "Jammingpro is coding..." << endl;}return 0;
}

execlp2.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>int main()
{pid_t id = fork();if(id < 0){perror("fork");exit(1);}else if(id == 0){execlp("./excute", "excute", NULL);exit(2);}else{int status = 0;pid_t ret = waitpid(id, &status, 0);if(WIFEXITED(status)){printf("Wait %d success! exitcode is %d\n", ret, WEXITSTATUS(status));}}return 0;
}

在这里插入图片描述

execle

int execle(const char *path, const char *arg,..., char * const envp[]);
该接口函数的第一个参数path需要使用传入可执行文件的绝对路径，紧接其后的arg与execl用法一致，传入形式就和我们使用命令行命令一样，先给出命令名称，再给出命令行参数，最终以NULL结尾。最后一个参数envp表示环境变量。

子进程默认继承父进程的环境变量，那环境变量是什么时候传给子进程的呢？环境变量也是数据，创建子进程的时候，环境变量就被子进程继承下去了。即使对代码和数据修改时发生写时拷贝，也不会影响父子进程共享同一片环境变量空间。所以发生程序替换时，环境变量信息不会被替换。如果需要对子进程的环境变量做修改可以选择execle、execvpe、execve，这3个exec系列接口。这里先通过execle接口介绍execle、execvpe、execve的两个应用场景↓↓↓

  • 希望子进程增加新增或覆盖某些环境变量

下面代码中，父进程fork创建子进程后，子进程在进行程序替换前，给自己增加了一个"Jammingpro=666"的环境变量。子进程能获取该环境变量，而父进程无法获取该环境变量。

execle_test.c↓↓↓

#include <stdio.h>
#include <stdlib.h>int main()
{char* s = getenv("Jammingpro");if(s != NULL) printf("%s\n", s);return 0;
}

execle1.c↓↓↓

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>int main()
{extern char **environ;pid_t id = fork();if(id < 0){perror("fork");exit(1);}else if(id == 0)//子进程{extern char **environ;putenv("Jammingpro=666");//给子进程新增环境变量，该语句子进程会执行execle("./execle_test", "execle_test", NULL, environ);exit(2);}else//父进程{int status = 0;pid_t ret = waitpid(id, &status, 0);char* s = getenv("Jammingpro");if(s != NULL) printf("%s", s);if(WIFEXITED(status)){printf("Wait %d success! exitcode is %d\n", ret, WEXITSTATUS(status));}}return 0;
}

在这里插入图片描述

  • 安全考虑及定制化场景

出于安全考虑，不希望子进程获取父进程的环境变量；或者因为子进程需要定制与父进程完全不一样的环境变量。可以定义一个字符指针数组，在该数组中存储子进程专属的环境变量，当使用execle、execvpe、execve将该环境变量传入时，会直接覆盖从父进程继承下来的环境变量。

下面代码中，给子进程创建专门的环境变量，子进程此时可以获取专门的环境变量"Jammingpro=666"，但无法获取父进程的环境变量PWD，因为使用exec带e的接口时，直接覆盖了子进程从父进程那里继承的环境变量。而父进程能获取从bash继承下来的环境变量，而无法获取子进程专属的环境变量。

execle_test2.c↓↓↓

#include <stdio.h>
#include <stdlib.h>int main()
{char* s = getenv("Jammingpro");if(s != NULL) printf("%s\n", s);else printf("Don't have Jammingpro\n");s = getenv("PWD");if(s != NULL) printf("%s\n", s);else printf("Don't have PWD\n");return 0;
}

execle2.c↓↓↓

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>int main()
{extern char **environ;pid_t id = fork();if(id < 0){perror("fork");exit(1);}else if(id == 0)//子进程{char* env[] = {"Jammingpro=666", "xiaoming=888"};execle("./execle_test2", "execle_test2", NULL, env);exit(2);}else//父进程{int status = 0;pid_t ret = waitpid(id, &status, 0);char* s = getenv("Jammingpro");if(s != NULL) printf("%s\n", s);else printf("Don't have Jammingpro\n");s = getenv("PWD");if(s != NULL) printf("%s\n", s);else printf("Don't have PWD\n");if(WIFEXITED(status)){printf("Wait %d success! exitcode is %d\n", ret, WEXITSTATUS(status));}}return 0;
}

在这里插入图片描述

★ps：关于putenv与exec带e系列接口原理探索
子进程和父进程的PCB内都有一个环境变量表指针，当子进程刚创建时，子进程的环境变量表指针与父进程指向同一个位置，一旦子进程调用putenv尝试对环境表做修改，此时则会发生写时拷贝。
在这里插入图片描述
在这里插入图片描述
环境变量表是是一个字符指针数组，也就是说：环境变量表中并不会直接存储对应的环境变量，而是存储各个环境变量的存储地址。当我们使用putenv时，本质是将我们定义环境变量（字符串或char类型数组）的首地址存储到该环境变量中。如果定义一个char env[100] = "Jammingpro=666"，再执行putenv(env)，则会将env的首地址存储到环境变量表中。此时不可以修改env数组中的内容，一旦修改，则对应的环境变量会跟着发生变化。

在这里插入图片描述
putenv只是修改环境变量表中某个表项的指向。但如果我们使用的是exec带e系列函数，则会直接修改进程PCB中环境变量表指针的指向。

execv

int execv(const char *path, char *const argv[]);
该接口第一个参数需要传入可执行程序的绝对路径，第二参数需要传入命令行参数，不同的是，这里并不是使用可变参数列表的方式，而是使用字符指针数组的方式。例如，我们需要执行ls命令，则第一个参数需要传入/usr/bin/ls，第二个参数需要先定义一个字符指针数组char* opts[] = {"ls", "-a", "-l", NULL}，再将该数组作为第二参数传入。

★ps：exec系列函数中，带v的，则第二个参数需要以字符指针数组的形式传入命令行参数。

下面给出接口使用示例↓↓↓

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>int main()
{extern char **environ;pid_t id = fork();if(id < 0){perror("fork");exit(1);}else if(id == 0)//子进程{char* opts[] = {"ls", "-a", "-l", NULL};execv("/usr/bin/ls", opts);exit(2);}else//父进程{int status = 0;pid_t ret = waitpid(id, &status, 0);if(WIFEXITED(status)){printf("Wait %d success! exitcode is %d\n", ret, WEXITSTATUS(status));}}return 0;
}

在这里插入图片描述

execvp

int execvp(const char *file, char *const argv[]);
该接口第一个参数传入可执行文件，如果该可执行文件可以在PATH环境变量中找到，则不需要使用绝对路径，否则需要使用绝对路径；第二个参数需要以字符指针数组的形式传入命令行参数。

下面给出接口使用示例↓↓↓

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>int main()
{extern char **environ;pid_t id = fork();if(id < 0){perror("fork");exit(1);}else if(id == 0)//子进程{char* opts[] = {"top", NULL};execvp("top", opts);exit(2);}else//父进程{int status = 0;pid_t ret = waitpid(id, &status, 0);if(WIFEXITED(status)){printf("Wait %d success! exitcode is %d\n", ret, WEXITSTATUS(status));}}return 0;
}

在这里插入图片描述

execvpe

int execvpe(const char *file, char *const argv[],char *const envp[]);
该接口第一个参数传入可执行文件，如果该可执行文件可以在PATH环境变量中找到，则不需要使用绝对路径，否则需要使用绝对路径；第二个参数需要以字符指针数组的形式传入命令行参数；第三个参数需要传入环境变量。

下面给出接口使用示例（给子进程传入自定义环境变量）↓↓↓

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>int main()
{extern char **environ;pid_t id = fork();if(id < 0){perror("fork");exit(1);}else if(id == 0)//子进程{char* opts[] = {"top", NULL};char* env[] = {"Jammingpro=666"};execvpe("./execle_test", opts, env);exit(2);}else//父进程{int status = 0;pid_t ret = waitpid(id, &status, 0);if(WIFEXITED(status)){printf("Wait %d success! exitcode is %d\n", ret, WEXITSTATUS(status));}}return 0;
}

在这里插入图片描述

execve

int execve(const char *filename, char *const argv[],char *const envp[]);
该接口第一个参数需要传入可执行程序的绝对路径，第二个参数需要以指针数组的方式传入命令行参数，第三个参数需要传入环境变量。

下面给出该接口的使用方式↓↓↓

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>int main()
{extern char **environ;pid_t id = fork();if(id < 0){perror("fork");exit(1);}else if(id == 0)//子进程{char* opts[] = {"top", NULL};char* env[] = {"Jammingpro=666"};execve("./execle_test", opts, env);exit(2);}else//父进程{int status = 0;pid_t ret = waitpid(id, &status, 0);if(WIFEXITED(status)){printf("Wait %d success! exitcode is %d\n", ret, WEXITSTATUS(status));}}return 0;
}

在这里插入图片描述

替换函数总结

上面总结上面介绍的各个替换函数↓↓↓

函数名参数格式PATH中可执行程序是否需要带绝对路径是否使用当前环境变量
execl列表是是
execlp列表不是是
execle列表是不是，需自己组装环境变量
execv数组是是
execvp数组不是是
execvpe数组不是不是，需自己组装环境变量
execve数组是不是，需自己组装环境变量

上面的exec系列函数中，如果带有p的，则第一个参数的可执行文件若存在于PATH环境变量中，则只需要填写可执行文件名；如果带有v的，则需要以字符指针数组的形式传入命令行参数；如果是带e的，则需要自己组装环境变量。

上面的各个接口统称为加载器，它们为即将替换进来的可执行程序加载入参数列表、环境变量等信息。下面我们使用execvpe接口给自定义可执行程序传入命令行参数及环境变量，该可执行程序将会把命令行参数及环境变量打印至显示器↓↓↓

printInfo.c

#include <stdio.h>int main(int argc, char* argv[]; char* env[])
{printf("传入%d个命令行参数，分别是:\n", argc);int i = 0;for(; argv[i]; i++){printf("[%d]->%s\n", i, argv[i]);}printf("--------------------------------------\n");printf("环境变量分别是:\n");i = 0;for(; env[i]; i++){printf("[%d]->%s\n", i, env[i]);}return 0;
}

execvpe2.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>int main()
{extern char **environ;pid_t id = fork();if(id < 0){perror("fork");exit(1);}else if(id == 0)//子进程{char* opts[] = {"printInfo", NULL};char* env[] = {"Jammingpro=666", "xiaoming=888"};execvpe("./printInfo", opts, env);exit(2);}else//父进程{int status = 0;pid_t ret = waitpid(id, &status, 0);if(WIFEXITED(status)){printf("Wait %d success! exitcode is %d\n", ret, WEXITSTATUS(status));}}return 0;
}

在这里插入图片描述
上述各个接口中，只有execve是系统调用，其他均是对该系统调用接口的封装。这也就是为什么execve位于2号手册，而其他接口函数位于3号手册的原因。

实现简易Shell

我们来模拟实现一个Shell，这个Shell具有一些常用的简易功能。下面我们用一张图了解一下Linux中bash（Shell的一种）的执行过程↓↓↓
在这里插入图片描述

一个shell程序需要循环做的事如下：
1.获取命令行
2.解析命令行
3.创建子程序
4.替换子程序
5.父进程等待子进程退出

下面我们先来完成第一步获取命令行↓↓↓

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>#define LEFT "["
#define RIGHT "]"
#define LABLE "#"#define COM_LEN 1024	//输入命令行长度
#define PWD_LEN 128		//当前路径长度char command[COM_LEN];	//命令行缓冲区
char pwd[PWD_LEN];		//当前路径缓冲区//获取用户名
const char* getUser()
{return getenv("USER");
}//获取当前路径
const char* getPWD()
{getcwd(pwd, sizeof(pwd));return pwd;
}//获取主机名
const char* getHostName()
{return getenv("HOSTNAME");
}//输出提示信息&&获取用户输入
void getCommand()
{printf(LEFT"%s@%s %s"RIGHT""LABLE" ", getHostName(), getUser(), getPWD());char* s = fgets(command, sizeof(command), stdin);assert(s != NULL);(void)s;s[strlen(command) - 1] = '\0';printf("%s\n", command);
}int main()
{while(1){getCommand();}return 0;
}

在这里插入图片描述

下面我们需要对获取的字符串进行切割↓↓↓

★ps：下面spliteString中使用了条件编译，当编译时带上-DDEBUG，就可以输出分隔的结果

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>#define LEFT "["
#define RIGHT "]"
#define LABLE "#"
#define SEP " \t"#define COM_LEN 1024
#define ARG_LEN 64
#define PWD_LEN 128char command[COM_LEN];
char *argv[ARG_LEN];
char pwd[PWD_LEN];
int argc = 0;const char* getUser()
{return getenv("USER");
}const char* getPWD()
{getcwd(pwd, sizeof(pwd));return pwd;
}const char* getHostName()
{return getenv("HOSTNAME");
}//输出提示信息&&获取用户输入
void getCommand()
{printf(LEFT"%s@%s %s"RIGHT""LABLE" ", getHostName(), getUser(), getPWD());char* s = fgets(command, sizeof(command), stdin);assert(s != NULL);(void)s;s[strlen(command) - 1] = '\0';
}//分隔字符串
void spliteString()
{argc = 0;argv[argc++] = strtok(command, SEP);while(argv[argc++] = strtok(NULL, SEP));
#ifdef DEBUG int j = 0;for(;argv[j]; j++){printf("[%d]->%s\n", j, argv[j]);}
#endif
}int main()
{while(1){getCommand();spliteString();}return 0;
}

在这里插入图片描述

使用normalExcute创建子进程，使用程序替换的方式，让子进程执行指定程序，如果子进程替换失败则返回EXIT_CODE。父进程等待子进程，并将子进程退出码保存在exitcode中。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>#define LEFT "["
#define RIGHT "]"
#define LABLE "#"
#define SEP " \t"
#define EXIT_CODE 66#define COM_LEN 1024
#define ARG_LEN 64
#define ENV_LEN 32
#define PWD_LEN 128char command[COM_LEN];
char *argv[ARG_LEN];
char pwd[PWD_LEN];
int argc = 0;
int exitcode = 0;const char* getUser()
{return getenv("USER");
}const char* getPWD()
{getcwd(pwd, sizeof(pwd));return pwd;
}const char* getHostName()
{return getenv("HOSTNAME");
}//输出提示信息&&获取用户输入
void getCommand()
{printf(LEFT"%s@%s %s"RIGHT""LABLE" ", getHostName(), getUser(), getPWD());char* s = fgets(command, sizeof(command), stdin);assert(s != NULL);(void)s;s[strlen(command) - 1] = '\0';
}//分隔字符串
void spliteString()
{argc = 0;argv[argc++] = strtok(command, SEP);while(argv[argc++] = strtok(NULL, SEP));
#ifdef DEBUG int j = 0;for(;argv[j]; j++){printf("[%d]->%s\n", j, argv[j]);}
#endif
}void normalExcute()
{pid_t id = fork();assert(id != -1);if(id == 0){exitcode = 0;execvp(argv[0], argv);exit(EXIT_CODE);}else {int status = 0;pid_t id = waitpid(id, &status, 0);exitcode = WEXITSTATUS(status);}
}int main()
{while(1){getCommand();spliteString();normalExcute();}return 0;
}

在这里插入图片描述

截至到这里，我们已经实现了能够执行大部分命令的Shell程序。但如果我们执行cd命令，当前路径却没有改变。这是为什么呢？

在这里插入图片描述

当子进程被创建后，由子进程执行cd命令，则修改环境变量PWD时，子进程会发生写时拷贝，保证父子进程的独立性。因而，子进程的PWD改变，不会影响父进程。像这样的命令需要使用内建命令的方式解决，即遇到这类命令时，不让子进程执行，而是由父进程自己执行对应的函数。下面通过设置buildExcute函数，不能交由子进程执行的命令进行了特殊处理↓↓↓

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>#define LEFT "["
#define RIGHT "]"
#define LABLE "#"
#define SEP " \t"
#define EXIT_CODE 66#define COM_LEN 1024
#define ARG_LEN 64
#define ENV_LEN 32
#define PWD_LEN 128char *env[ENV_LEN];
char command[COM_LEN];
char *argv[ARG_LEN];
char pwd[PWD_LEN];
int argc = 0;
int envNum = 0;
int exitcode = 0;const char* getUser()
{return getenv("USER");
}const char* getPWD()
{getcwd(pwd, sizeof(pwd));return pwd;
}const char* getHostName()
{return getenv("HOSTNAME");
}//输出提示信息&&获取用户输入
void getCommand()
{printf(LEFT"%s@%s %s"RIGHT""LABLE" ", getHostName(), getUser(), getPWD());char* s = fgets(command, sizeof(command), stdin);assert(s != NULL);(void)s;s[strlen(command) - 1] = '\0';
}//分隔字符串
void spliteString()
{argc = 0;argv[argc++] = strtok(command, SEP);while(argv[argc++] = strtok(NULL, SEP));
#ifdef DEBUG int j = 0;for(;argv[j]; j++){printf("[%d]->%s\n", j, argv[j]);}
#endif
}void normalExcute()
{pid_t id = fork();assert(id != -1);if(id == 0){exitcode = 0;execvp(argv[0], argv);exit(EXIT_CODE);}else {int status = 0;pid_t id = waitpid(id, &status, 0);exitcode = WEXITSTATUS(status);}
}int buildExcute()
{if(argc == 3 && strcmp(argv[0], "cd") == 0){int ret = chdir(argv[1]);if(ret != -1) exitcode = 0;else exitcode = EXIT_CODE;return 1;}else if(argc == 3 && strcmp(argv[0], "export") == 0){env[envNum] = (char*)malloc(sizeof(argv[1]) + 1);strcpy(env[envNum], argv[1]);int ret = putenv(env[envNum++]);if(ret == 0) exitcode = 0;else exitcode = EXIT_CODE;return 1;}else if(argc == 3 && strcmp(argv[0], "echo") == 0){if(strcmp(argv[1], "$?") == 0) printf("%d\n", exitcode);else printf("%s\n", argv[1]);return 1;}else if(strcmp(argv[0], "ls") == 0){argv[argc - 1] = (char*)"--color=auto";argv[argc] = NULL;}return 0;
}int main()
{while(1){getCommand();spliteString();int ret = buildExcute();if(!ret) normalExcute();}return 0;
}

至此，能执行大部分命令的Shell程序就大功告成了。但该程序并没有所有内建命令做处理。
在这里插入图片描述

★ps：当我们登录Linux的时候，就要启动一个shell进程，该进程会从用户home目录的.bash_profile中获取环境变量，从而读入环境变量。从上面的自定义实现shell程序中可知，export导入环境变量仅在当前shell进程有效。如果需要设置永久性环境变量，需要修改系统的环境变量配置文件。

★ps：现象：程序替换成功后，exec系列函数后的代码不会被执行；若替换失败，则继续向下执行。这也解释了exec系列函数为什么只有失败返回值，而没有正确返回值。一旦正确，后序代码不会执行，该正确返回值也无法使用。
在这里插入图片描述

🎈欢迎进入从浅学到熟知Linux专栏，查看更多文章。
如果上述内容有任何问题，欢迎在下方留言区指正b(￣▽￣)d

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/822146.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

宝剑锋从磨砺出，透视雀巢咖啡品牌焕新与产品升级的想象力

宝剑锋从磨砺出，透视雀巢咖啡品牌焕新与产品升级的想象力

自1989年进入中国市场以来&#xff0c;陪伴着国内咖啡行业由启蒙期走向兴盛期的雀巢咖啡&#xff0c;始终坚持以消费者高品质、个性化需求为本位&#xff0c;在保有独特性的基础上持续创新&#xff0c;实现了从无到有的攻克与突破。 近日&#xff0c;深耕中国三十六载的雀巢咖…
阅读更多...
康耐视visionpro-CogCreateLinePerpendicularTool操作操作工具详细说明

康耐视visionpro-CogCreateLinePerpendicularTool操作操作工具详细说明

CogCreateLinePerpendicularTool]功能说明&#xff1a; 创建点到线的垂线 CogCreateLinePerpendicularTool操作说明&#xff1a; ①.打开工具栏&#xff0c;双击或点击扇标拖拽添加CogCreateLinePerpendicularTool ②.添加输入源&#xff1a;右键“链接到”或以连线拖 拽的方式…
阅读更多...
Java代码基础算法练习-圆的面积-2024.04.17

Java代码基础算法练习-圆的面积-2024.04.17

任务描述&#xff1a; 已知半径r&#xff0c;求一个圆的面积(保留两位小数)&#xff0c;其中 0 < r < 5&#xff0c;PI 3.14&#xff0c;圆面积公式: PI * r * r 任务要求&#xff1a; 代码示例&#xff1a; package April_2024;import java.util.Scanner;// 已知半径…
阅读更多...
【前端】1. HTML【万字长文】

【前端】1. HTML【万字长文】

HTML 基础 HTML 结构 认识 HTML 标签 HTML 代码是由 “标签” 构成的. 形如: <body>hello</body>标签名 (body) 放到 < > 中大部分标签成对出现. <body> 为开始标签, </body> 为结束标签.少数标签只有开始标签, 称为 “单标签”.开始标签和…
阅读更多...
Linux-时间同步服务器

Linux-时间同步服务器

1. (问答题) 一.配置server主机要求如下&#xff1a; 1.server主机的主机名称为 ntp_server.example.com 编写脚本文件 #!/bin/bash hostnamectl hostname ntp_server.example.com cd /etc/NetworkManager/system-connections/ rm -fr * cat > eth0.nmconnection <&…
阅读更多...
【编译原理】02词法分析（1）

【编译原理】02词法分析（1）

接上篇 &#xff1a;【编译原理】01引论 词法分析是编译过程中将字符流转换成为符号流的一个工作阶段&#xff0c;是编译的第一步工作&#xff0c;其后续工作是语法分析。 词法分析的输入是源代码&#xff1b; 词法分析的输出是符号流&#xff1b; 词法分析需要识别词法错误&am…
阅读更多...
STM32 软件I2C方式读取MT6701磁编码器获取角度例程

STM32 软件I2C方式读取MT6701磁编码器获取角度例程

STM32 软件I2C方式读取MT6701磁编码器获取角度例程 &#x1f4cd;相关篇《STM32 软件I2C方式读取AS5600磁编码器获取角度例程》&#x1f33f;《Arduino通过I2C驱动MT6701磁编码器并读取角度数据》&#x1f530;MT6701芯片和AS5600从软件读取对比&#xff0c;只是读取的寄存器和…
阅读更多...
代码随想录算法训练营第56天| 583. 两个字符串的删除操作|72. 编辑距离|编辑距离总结篇

代码随想录算法训练营第56天| 583. 两个字符串的删除操作|72. 编辑距离|编辑距离总结篇

代码随想录算法训练营第56天| 583. 两个字符串的删除操作|72. 编辑距离|编辑距离总结篇 详细布置 583. 两个字符串的删除操作 本题和动态规划&#xff1a;115.不同的子序列 相比&#xff0c;其实就是两个字符串都可以删除了&#xff0c;情况虽说复杂一些&#xff0c;但整体思…
阅读更多...
【Redis 神秘大陆】009 案例实践进阶

【Redis 神秘大陆】009 案例实践进阶

九、案例实践&进阶方案 9.1 本地缓存组件选型 使用缓存组件时需要重点关注集群方式、集群、缓存命中率。 需要关注集群组建方式、缓存统计&#xff1b;还需要考虑缓存开发语言对缓存的影响&#xff0c;如对于JAVA开发的缓存需要考虑GC的影响&#xff1b;最后还要特别关注…
阅读更多...
SQL优化——核心概念

SQL优化——核心概念

文章目录 1、基数(数据分布)2、选择性3、直方图&#xff08;HISTOGRAM&#xff09;4、回表&#xff08;TABLE ACCESS BY INDEX ROWID&#xff09;5、集群因子&#xff08;CLUSTERING FACTOR&#xff09;6、表与表之间关系 1、基数(数据分布) 某个列唯一键&#xff08;Distinct…
阅读更多...
springboot整合dubbo实现RPC服务远程调用

springboot整合dubbo实现RPC服务远程调用

一、dubbo简介 1.什么是dubbo Apache Dubbo是一款微服务开发框架&#xff0c;他提供了RPC通信与微服务治理两大关键能力。有着远程发现与通信的能力&#xff0c;可以实现服务注册、负载均衡、流量调度等服务治理诉求。 2.dubbo基本工作原理 Contaniner:容器Provider&#xf…
阅读更多...
[AI]-(第0期)：认知深度学习

[AI]-(第0期)：认知深度学习

深度学习是一种人工智能&#xff08;AI&#xff09;方法&#xff0c;用于教计算机以受人脑启发的方式处理数据。 深度学习模型可以识别图片、文本、声音和其他数据中的复杂模式&#xff0c;从而生成准确的见解和预测。 您可以使用深度学习方法自动执行通常需要人工智能完成的…
阅读更多...
【C++】set 类 和 map 类

【C++】set 类 和 map 类

1. 关联式容器 关联式容器也是用来存储数据的&#xff0c;与序列式容器不同的是&#xff0c;其里面存储的是<key, value>结构的 键值对&#xff0c;在数据检索时比序列式容器效率更高 2. 键值对 用来表示具有一一对应关系的一种结构&#xff0c;该结构中一般只包含…
阅读更多...
Pytorch(GPU版本)简介、安装与测试运行

Pytorch(GPU版本)简介、安装与测试运行

目录 Pytorch简介Pytorch安装查看CUDA版本Pytorch命令安装Pytorch测试运行Pytorch简介 PyTorch是一个开源的Python机器学习库，基于Torch，用于自然语言处理等应用程序。PyTorch既可以看作加入了GPU支持的numpy，同时也可以看成一个拥有自动求导功能的强大的深度神经网络。 2…
阅读更多...
Linux进阶篇：Centos7安装与配置mysql（rpm安装方式）

Linux进阶篇：Centos7安装与配置mysql（rpm安装方式）

Linux服务搭建篇&#xff1a;Centos7安装与配置mysql&#xff08;rpm安装方式&#xff09; MySQL是一个开源的关系型数据库管理系统&#xff0c;由瑞典MySQL AB公司开发&#xff0c;现在属于Oracle公司。MySQL是最流行的关系型数据库管理系统之一&#xff0c;在WEB应用方面&am…
阅读更多...
【架构-14】数据库性能优化方式

【架构-14】数据库性能优化方式

数据库出现性能瓶颈对外的表现为&#xff1a; 大量请求阻塞SQL操作变慢存储出现问题 为解决上述出现的问题&#xff0c;因此推出了一系列的数据库性能优化方式。 数据库性能优化是提高数据库系统性能和响应时间的关键任务。以下是一些常见的 数据库性能优化方式&#xff1a; …
阅读更多...
锂电池充放电管理-单片机通用

锂电池充放电管理-单片机通用

锂电池充放电管理-单片机通用 一、锂电池充放电检测的原理二、power.c的实现三、power.h的实现四、锂电池检测和充电电路 一、锂电池充放电检测的原理 ①两节锂电池通过电阻分压检测ADC&#xff0c;再根据电压划分电量等级&#xff1b;②充电使用的是锂电池充电IC方案&#xf…
阅读更多...
【问题解决分享】银河麒麟高级服务器操作系统oom分析

【问题解决分享】银河麒麟高级服务器操作系统oom分析

1.问题现象描述 服务器数据库被oomkill掉&#xff0c;但是mem查看只占用了不到60%。 2.问题分析 2.1.oom现象分析 从下面的日志信息&#xff0c;可以看到chmod进程是在内核采用GFP_KERNEL|__GFP_COMP分配order3也就是2的3次方&#xff0c;8个连续页的时候&#xff0c;因进入…
阅读更多...
Hadoop大数据处理技术-安装配置篇

Hadoop大数据处理技术-安装配置篇

2024/4/16 ​Hadoop学习前的准备 1&#xff09;首先安装虚拟机 VMWare 虚拟机&#xff1a;因为它不是一个硬件 而是用软件做出来的 模拟真机 所以叫做虚拟机 但实际上它里面也可以安装Linux和Windows 实际它的实现 虚拟机中想要实现某个操作时 将需求发给Windows 调用Windo…
阅读更多...
十大排序——7.希尔排序

十大排序——7.希尔排序

下面我们来看一下希尔排序 目录 1.介绍 2.代码实现 3.总结与思考 1.介绍 希尔排序是插入排序的一种优化&#xff0c;可以理解为是一种分组的插入排序。 希尔排序的要点&#xff1a; 简单来说&#xff0c;就是分组实现插入&#xff0c;每组元素的间隙称为gap&#xff0c;…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站