实用指南：苍茫命令行：linux模拟实现，书写微型bash

文章目录

• ?前言
• 2、需求分析
• 3、基本框架
• 4、核心内容
• 4.2、指令分割
• • 4.3、程序替换
• 5、特殊情况处理
• • 5.2、内建命令
  • 5.3、cd
  • 5.4、export
  • 5.5、echo
  • 5.6、重定向
• 6、源码

?前言

Linux 系统主要分为内核(kernel)和 外壳(shell)，普通用户是无法接触到内核的，因此实际在进行操作时是在和外壳程序打交道，在 shell 外壳之上存在 命令行解释器(bash)，负责接收并执行用户输入的指令，本文模拟实现的就是一个 简易版命令行解释器

?️正文
1、bash本质
在模拟实现前，先得了解 bash 的本质

bash 也是一个进程，并且是不断运行中的进程
证明：常显示的命令输入提示符就是 bash 不断打印输出的结果

输入指令后，bash 会创建子进程，并进行程序替换

bash 就是一个运行中的进程，因为进程间具有独立性，因此可以同时存在多个 bash，这也是多用户登录 Linux 可以同时使用 bash 的重要原因

2、需求分析

bash 需要帮我们完成命令解释+程序替换的任务，因此它至少要具备以下功能：

• 接收指令（字符串）
• 对指令进行分割，构成有效信息
• 创建子进程，执行进程替换
• 子进程运行结束后，父进程回收僵尸进程
• 输入特殊指令时的处理

进程相关知识都已经在前面介绍过了，本文着重介绍的是其他步骤及细节

3、基本框架

抛开指令接收、切割、替换时的细节，简易版 bash 代码基本框架如下：

#include <stdio.h>#include <stdlib.h>#include <unistd.h>#include <sys/wait.h>#include <sys/types.h>#include <string.h>#include <assert.h>//指令分割函数void split(char* argv[ARGV_SIZE], char* ps){}int main(){//这是一个始终运行的程序：bashwhile(1){//打印提示符printf("[User@myBash default]$ "); //可以自定义，跟着标准走fflush(stdout); //手动清空缓冲区//读取指令//指令分割//子进程进行程序替换pid_t id = fork();if(id == 0){//直接执行程序替换，这里使用 execvpexecvp(); //具体细节先忽略exit(168); //替换失败后返回，这个值可以自定义 [0,255]}//父进程等待子进程终止，回收僵尸进程int status = 0;waitpid(id, &status, 0); //在等待队列中阻塞if(WIFEXITED(status)){//假如程序替换失败//关于打印的错误信息：也可以自定义，格式跟着标准走if(WEXITSTATUS(status) == 168)printf("%s: Error - %s\n", argv[0],"The directive is not yet defined");}else //如果子进程被异常终止，打印相关信息printf("process run fail! [code_dump]:%d [exit_signal]:%d\n",(status >>7) &1, status & 0x7F); //子进程异常终止的情况}return 0;}

这只是简易版 bash 的基本框架，其他细节将会在后续补充完整

4、核心内容

核心内容主要为 读取、切割、替换 这三部分，逐一实现，首先从指令读取开始

4.1、指令读取
读取指令前，首先要清楚待读取命令可能有多长

• 常见命令如ls -a -l长度不超过 10
• 为了避免极端情况，这里预设命令最大长度为 1024
• 使用数组进行指令存储（缓冲区）

#
define COM_SIZE 1024
char command[COM_SIZE]
;
//缓冲区

得到缓冲区后，就得考虑什么是指令？如何读取指令？

• Linux 中的大部分指令由 指令 [选项] 构成，在 指令 和 [选择] 间有空格
• 常规的 scanf 无法正常读取指令，因为空格会触发输入缓冲区刷新
• 这里主要使用fgets逐行读取，可以读取到空格

//读取指令
//因为有空格，所以需要逐行读取
fgets(command, COM_SIZE, stdin
)
;
assert(command)
;
//不能输入空指令
(
void
)command;
//防止在 Release 版本中出错
command[strlen(command) - 1] = '\0'
;
//将最后一个字符 \n 变成 \0

注意： 可能存在读取失败的情况，assert 断言解决；因为 fgets 也会把最后的 ‘\n’ 读进去，为了避免出错，手动置为 ‘\0’

4.2、指令分割

获得指令后，就需要将指令进行分割

为何要分割指令？

• 程序替换时，需要使用 argv 表，这张表由 指令、选项、NULL 构成
• 利用指令间的空格进行分割

如何分割指令？

• C语言 提供了字符串分割函数 strtok，可以直接使用
• 当然也可以手动实现分割

指令分割后呢？

• 将分割好的指令段，依次存入 argv 表中，供后续程序替换使用
• argv 表实际为一个指针数组，可以存储字符串
• 如 command 一样，表 argv 也需要考虑大小，这里设置为 64，实际使用时也就分割为四五个指令段

#
define ARGV_SIZE 64
//指令分割
//将连续的指令分割为 argv 表
char* argv[ARGV_SIZE]
;
//指针数组
split(argv, command)
;

利用strtok实现指令分割函数 split()

#
define DEF_CHAR " " //预设分割项，需为字符串
void split(
char* argv[ARGV_SIZE]
,
char* ps)
{
assert(argv && ps)
;
//调用 C语言 中的 strtok 函数分割字符串
int pos = 0
;
argv[pos++] = strtok(ps, DEF_CHAR)
;
//有空格就分割
while(argv[pos++] = strtok(NULL
, DEF_CHAR)
)
;
//不断分割
argv[pos] = NULL
;
//确保安全
}

注意： 指令分割结束后，需要在添加 argv 表结尾 NULL

4.3、程序替换

获得实际可用的 argv 表后，就可以开始子进程程序替换操作了

这里使用的是函数 execvp，理由：

• v 表示 vector，正好和我们的argv表对应
• p 为 path，可以根据 argv[0]（指令），在 PATH 中寻找该程序并替换
• 当然也可以使用execve系统级替换函数

//子进程进行程序替换
pid_t id = fork(
)
;
if(id == 0
)
{
//直接执行程序替换，这里使用 execvp
execvp(argv[0]
, argv)
;
exit(168
)
;
//替换失败后返回
}

注意： 程序替换成功后，exit(168) 语句不会执行

5、特殊情况处理

对特殊情况进行处理，使 myBash 更加完善

5.1、ls 显示高亮
系统中的 bash 在面对ls等文件显示指令时，不仅会显示内容，还会将特殊文件做颜色高亮处理，比如在我的环境下，可执行文件显示为绿色

实现原理

• 在指令结尾加上 --color=auto 语句，即可实现高亮

处理这个问题很简单，在指令分割结束后，判断是否为 ls，如果是，就在argv表后尾插入语句--color=auto即可

//特殊处理
//颜色高亮处理，识别是否为 ls 指令
if(strcmp(argv[0]
, "ls"
) == 0
)
{
int pos = 0
;
while(argv[pos++]
)
;
//找到尾
argv[pos - 1] = (
char*
)"--color=auto"
;
//添加此字段
argv[pos] = NULL
;
//结新尾
}

注意：

• 因为 argv 表中的元素类型为 char*，所以在尾插语句时，需要进行类型转换
• 尾插语句后，需要再次添加结尾，确保安全

5.2、内建命令

内建命令是比较特殊的命令，不同于普通命令直接进行程序替换，内建命令需要进行特殊处理，比如 cd 命令调用系统级接口 chdir 让 父进程(myBash) 进行目录间的移动

5.3、cd

首先实现不同目录间的切换

切换的本质：令当前 bash 移动至另一个目录下，不能直接使用 子进程 ，因为需要移动的是 父进程(bash)

对于当前的 myBash 来说，cd 没有丝毫效果，因为此时 指令会被拆分后交给子进程处理，这个方向本身就是错误的

特殊情况特殊处理，同ls高亮一样，对指令进行识别，如果识别到cd命令，就直接调用chdir函数令当前进程myBash移动至指定目录即可（不必再创建子进程进行替换）

//目录间移动处理
if(strcmp(argv[0]
, "cd"
) == 0
)
{
//直接调用接口，然后 continue 不再执行后续代码
if(strcmp(argv[1]
, "~"
) == 0
)
chdir("/home"
)
;
//回到家目录
else
if(strcmp(argv[1]
, "-"
) == 0
)
chdir(getenv("OLDPWD"
)
)
;
else
if(argv[1]
)
chdir(argv[1]
)
;
//argv[1] 中就是路径
continue
;
//终止此次循环
}

特殊情况特殊处理，同 ls 高亮一样，对指令进行识别，如果识别到 cd 命令，就直接调用chdir函数令当前进程myBash 移动至指定目录即可（不必再创建子进程进行替换）

//目录间移动处理
if(strcmp(argv[0]
, "cd"
) == 0
)
{
//直接调用接口，然后 continue 不再执行后续代码
if(strcmp(argv[1]
, "~"
) == 0
)
chdir("/home"
)
;
//回到家目录
else
if(strcmp(argv[1]
, "-"
) == 0
)
chdir(getenv("OLDPWD"
)
)
;
else
if(argv[1]
)
chdir(argv[1]
)
;
//argv[1] 中就是路径
continue
;
//终止此次循环
}

注意：

• 如果路径为空，不进行操作；
• 如果路径为 ~，回到家目录；
• cd - 指令依赖于 OLDPWD 这个环境变量，直接拿来用即可

5.4、export

export 添加环境变量，添加的是父进程 myBash 的环境变量，而非子进程，需要特殊处理

解决方法：

• 先将待添加的环境变量拷贝至缓冲区
• 再从缓冲区中读取，并调用 putenv 函数添加至环境变量表

为何不能直接通过 putenv 添加至环境变量表中？

• argv[1] 中的内容是不断变化的，不能直接使用
• 一般用户自定义的环境变量，在 bash 中需要用户自己维护
• 最好的方案就是使用缓冲区进行环境变量的拷贝放置，因为缓冲区中的内容不易变

错误体现：直接使用 putenv(argv[1])，导致第一次添加可能成功，但第二次添加后，第一次的环境变量会被覆盖

正确解法是借助缓冲区 myEnv

#
define COM_SIZE 1024
#
define ARGV_SIZE 64
char myEnv[ARGV_SIZE][COM_SIZE]
;
//二维数组
int env_pos = 0
;
//专门维护此缓冲区

注意： 此缓冲区定义在循环之外

char myEnv[COM_SIZE][ARGV_SIZE]
;
//大小与前面有关
int env_pos = 0
;
//专门维护缓冲区
//这是一个始终运行的程序：bash
while(1
)
{
//…… 省略部分代码
//环境变量相关
if(strcmp(argv[0]
, "export"
) == 0
)
{
if(argv[1]
)
{
strcpy(myEnv[env_pos]
, argv[1]
)
;
putenv(myEnv[env_pos++]
)
;
}
continue
;
//一样需要提前结束循环
}
}

除了export需要特殊处理外，env 查看环境变量表也需要特殊处理，因为此时的 env 查看的是 父进程(myBash) 的环境变量表，因此不需要将指令交给 子进程 处理

//注意：此函数实现于主函数外
void showEnv(
)
{
extern
char** environ;
//使用当前进行的环境变量表
int pos = 0
;
for(
; environ[pos]
;
printf("%s\n"
, environ[pos++]
)
)
;
}
//环境变量表
if(strcmp(argv[0]
, "env"
) == 0
)
{
showEnv(
)
;
//调用函数，打印父进程的环境变量表
continue
;
//提前结束本次循环
}

完善后，env 指令显示的才是正确进程的环境变量表

5.5、echo

echo 命令也属于内建命令，其能实现很多功能，比如：查看环境变量、查看最近一个进程的退出码、输出重定向等，其中前两个实现比较简单，最后一个需要 基础IO 相关知识，后续更新补上

查看环境变量

echo 指令查看环境变量时，指令为 echo $ 环境变量，可以先判断 argv[1][0] 是否为 $，如果是，就直接根据 argv[1][1] 获取环境变量信息并打印即可

代码实现如下

//echo 相关
//只有 echo $ 才做特殊处理（环境变量+退出码）
if(strcmp(argv[0]
, "echo"
) == 0 && argv[1][0] == '$'
)
{
if(argv[1] && argv[1][0] == '$'
)
printf("%s\n"
, getenv(argv[1] + 1
)
)
;
continue
;
}

echo 还能查看退出码：echo $?，对上述程序进行改造即可实现

退出码从何而来？

• 很简单，父进程在等待子进程结束后，可以轻而易举的获取其退出码
• 将退出码保存在一个全局变量中，供echo $?指令使用即可

int exit_code = 0
;
//保存退出码的全局变量

代码实现：

//echo 相关
//只有 echo $ 才做特殊处理（环境变量+退出码）
if(strcmp(argv[0],
"echo"
) == 0 && argv[1][0] == '$'
)
{
if(argv[1] && argv[1][0] == '$'
)
{
if(argv[1][1] == '?'
)
printf("%d\n", exit_code)
;
else
printf("%s\n", getenv(argv[1] + 1
))
;
}
continue
;
}

5.6、重定向

重定向的本质：关闭默认输出/输入流，打开新的文件流，从其中写入/读取数据

重定向的三种情况：

• echo 字符串 > 文件 向文件中写入数据，写入前会先清空内容
• echo 字符串 >> 文件 向文件中追加数据，追加前不会先清空内容
• 可执行程序 < 文件 从文件中读取数据给可执行程序

所以实现重定向的关键在于判断指令中是否含有 >、>>、< 这三个字符，如果有，就具体问题具体分析，完成重定向

具体实现步骤：

• 判断字符串中是否含有目标字符，如果有，就置当前位置为 '\0‘，其后半部分不参与指令分割
• 后半部分就是文件名，在打开文件时需要使用
• 根据不同的字符，设置不同的标记位，用于判断打开文件的方式（只写、追加、只读）
• 判断是否需要进行重定向，如果需要，在子进程创建后，打开目标文件，并调用 dup2 函数进行标准流的替换

open 函数的打开选项

O_RDONLY //只读
O_WRONLY | O_CREAT | O_TRUNC //只写
O_WRONLY | O_CREAT | O_APPEND //追加

标准流交换函数 dup2

//给参数1传打开文件后的文件描述符，给参数2传递待关闭的标准流
//读取：关闭0号流
//写入、追加：关闭1号流
int dup2(
int oldfd,
int newfd)
;

下面是具体代码实现

//在读取指令后，就进行判断：是否需要重定向
//重定向
//在获取指令后进行判断
//如果成立，则获取目标文件名 filename
char *filename = checkDir(command)
;

//枚举类型，用于判断不同的文件打开方式
enum redir
{
REDIR_INPUT = 0
, //读取
REDIR_OUTPUT, //写入
REDIR_APPEND, //追加
REDIR_NONE //空
}redir_type = REDIR_NONE;
//创建对象 redir_type，默认为 NONE
//检查是否出现重定向符
char* checkDir(
char* command)
{
//从右往左遍历，遇到 > >> < 就置为 '\0'
size_t end = strlen(command)
;
//与返回值相匹配
char* ps = command + end;
//为了避免出现无符号-1，这里采取错位的方法
while(end != 0
)
{
if(command[end - 1] == '>'
)
{
if(command[end - 2] == '>'
)
{
command[end - 2] = '\0'
;
redir_type = REDIR_APPEND;
return ps;
}
command[end - 1] = '\0'
;
redir_type = REDIR_OUTPUT;
return ps;
}
else
if(command[end - 1] == '<'
)
{
command[end - 1] = '\0'
;
redir_type = REDIR_INPUT;
return ps;
}
//如果不是空格，就可以更新 ps指向
if(*(command + end - 1
) != ' '
)
ps = command + end - 1
;
end--
;
}
return NULL
;
//如果没有重定向符，就返回空
}

//子进程进行程序替换
pid_t id = fork(
)
;
if(id == 0
)
{
//判断是否需要进行重定向
if(redir_type == REDIR_INPUT)
{
int fd = open(filename, O_RDONLY)
;
dup2(fd, 0
)
;
//更改输入，读取文件 filename
}
else
if(redir_type == REDIR_OUTPUT)
{
int fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666
)
;
dup2(fd, 1
)
;
//写入
}
else
if(redir_type == REDIR_APPEND)
{
int fd = open(filename, O_WRONLY | O_CREAT | O_APPEND, 0666
)
;
dup2(fd, 1
)
;
//追加
}
//直接执行程序替换，这里使用 execvp
execvp(argv[0]
, argv)
;
exit(168
)
;
//替换失败后返回
}

具体效果(A.txt 为空，B.txt 已存在内容，程序 a.out 可以读取字符串并输出)：

注意： 当前实现的重定向只是最简单的标准流替换，实际重定向更加复杂

6、源码

本次实现的myBash如下所示，拷贝编译运行后，即可使用

#include <stdio.h>#include <stdlib.h>#include <unistd.h>#include <sys/wait.h>#include <sys/types.h>#include <string.h>#include <assert.h>#include <sys/stat.h>#include <fcntl.h>#define COM_SIZE 1024#define ARGV_SIZE 64#define DEF_CHAR " "void split(char* argv[ARGV_SIZE], char* ps){assert(argv &&ps);//调用 C语言 中的 strtok 函数分割字符串int pos = 0;argv[pos++] = strtok(ps, DEF_CHAR); //有空格就分割while(argv[pos++] = strtok(NULL, DEF_CHAR)); //不断分割argv[pos] = NULL; //确保安全}void showEnv(){extern char** environ; //使用当前进行的环境变量表int pos = 0;for(; environ[pos]; printf("%s\n", environ[pos++]));}//枚举类型，用于判断不同的文件打开方式enum redir{REDIR_INPUT = 0,REDIR_OUTPUT,REDIR_APPEND,REDIR_NONE}redir_type = REDIR_NONE; //创建对象 redir_type，默认为 NONE//检查是否出现重定向符char* checkDir(char* command){//从右往左遍历，遇到 >>>< 就置为 '\0'size_t end = strlen(command); //与返回值相匹配char* ps = command + end; //为了避免出现无符号-1，这里采取错位的方法while(end != 0){if(command[end - 1] == '>'){if(command[end - 2] == '>'){command[end - 2] = '\0';redir_type = REDIR_APPEND;return ps;}command[end - 1] = '\0';redir_type = REDIR_OUTPUT;return ps;}else if(command[end - 1] == '<'){command[end - 1] = '\0';redir_type = REDIR_INPUT;return ps;}//如果不是空格，就可以更新 ps指向if(*(command + end - 1) != ' ')ps = command + end - 1;end--;}return NULL; //如果没有重定向符，就返回空}int main(){char myEnv[COM_SIZE][ARGV_SIZE]; //大小与前面有关int env_pos = 0; //专门维护缓冲区int exit_code = 0; //保存退出码的全局变量//这是一个始终运行的程序：bashwhile(1){char command[COM_SIZE]; //存放指令的数组（缓冲区）//打印提示符printf("[User@myBash default]$ ");fflush(stdout);//读取指令//因为有空格，所以需要逐行读取fgets(command, COM_SIZE, stdin);assert(command); //不能输入空指令(void)command; //防止在 Release 版本中出错command[strlen(command) - 1] = '\0'; //将最后一个字符 \n 变成 \0//重定向//在获取指令后进行判断//如果成立，则获取目标文件名 filenamechar *filename = checkDir(command);//指令分割//将连续的指令分割为 argv 表char* argv[ARGV_SIZE];split(argv, command);//特殊处理//颜色高亮处理，识别是否为 ls 指令if(strcmp(argv[0],"ls") == 0){int pos = 0;while(argv[pos++]); //找到尾argv[pos - 1] = (char*)"--color=auto"; //添加此字段argv[pos] = NULL; //结尾}//目录间移动处理if(strcmp(argv[0],"cd") == 0){//直接调用接口，然后 continue 不再执行后续代码if(strcmp(argv[1],"~") == 0)chdir("/home"); //回到家目录else if(strcmp(argv[1],"-") == 0)chdir(getenv("OLDPWD"));else if(argv[1])chdir(argv[1]); //argv[1] 中就是路径continue; //终止此次循环}//环境变量相关if(strcmp(argv[0],"export") == 0){if(argv[1]){strcpy(myEnv[env_pos], argv[1]);putenv(myEnv[env_pos++]);}continue; //一样需要提前结束循环}//环境变量表if(strcmp(argv[0],"env") == 0){showEnv(); //调用函数，打印父进程的环境变量表continue; //提前结束本次循环}//echo 相关//只有 echo $ 才做特殊处理（环境变量+退出码）if(strcmp(argv[0],"echo") == 0 && argv[1][0] == '$'){if(argv[1] && argv[1][0] == '$'){if(argv[1][1] == '?')printf("%d\n", exit_code);elseprintf("%s\n", getenv(argv[1] + 1));}continue;}//子进程进行程序替换pid_t id = fork();if(id == 0){//判断是否需要进行重定向if(redir_type == REDIR_INPUT){int fd = open(filename, O_RDONLY);dup2(fd, 0); //更改输入，读取文件 filename}else if(redir_type == REDIR_OUTPUT){int fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);dup2(fd, 1); //写入}else if(redir_type == REDIR_APPEND){int fd = open(filename, O_WRONLY | O_CREAT | O_APPEND, 0666);dup2(fd, 1); //追加}//直接执行程序替换，这里使用 execvpexecvp(argv[0], argv);exit(168); //替换失败后返回}//父进程等待子进程终止int status = 0;waitpid(id, &status, 0); //在等待队列中阻塞exit_code = WEXITSTATUS(status);if(WIFEXITED(status)){//假如程序替换失败if(exit_code == 168)printf("%s: Error - %s\n", argv[0],"The directive is not yet defined");}elseprintf("process run fail! [code_dump]:%d [exit_signal]:%d\n",(status >>7) &1, status & 0x7F); //子进程异常终止的情况}return 0;}