〖 Linux 〗类 Shell 命令行模拟程序开发

整体结构分析

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

[ruice@iZbp19mmk4ewbvs0t503lkZ myshell]$ ls
makefile  mycmd  mycmd.cpp  myexec  myexec.c  test.py
[ruice@iZbp19mmk4ewbvs0t503lkZ myshell]$ ps
  PID TTY          TIME CMD
 2325 pts/3    00:00:00 ps
27028 pts/3    00:00:00 bash
[ruice@iZbp19mmk4ewbvs0t503lkZ myshell]$ 

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

然后shell读取新的一行输入，建立一个新的进程，在这个进程中运行程序并等待这个进程结束，所以要写一个shell，需要循环以下过程：

1. 获取命令行
2. 解析命令行
3. 检查是否是内建命令，是则直接执行进入下一个循环。
4. 不是则，建立一个子进程（fork）
5. 替换子进程（execvp）
6. 等待子进程退出（wait）
   根据这些思路，和我们前面学习的技术，就可以自己来实现一个shell了。
   运行gif动图演示：

代码演示

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

#define LEFT "["
#define RIGHT "]"
#define DELIM " \t"
#define LINE_SIZE 1024
#define ARGS_SIZE 32
#define EXIT_CODE 66

#define NONE       -1
#define IN_RDIR     0
#define OUT_RDIR    1
#define APPEND_RDIR 2

int lastcode = 0;
int quit = 0;
extern char **environ;
char LABLE = '$';
char commandline[LINE_SIZE];
char *argv[ARGS_SIZE];
char pwd[LINE_SIZE];
char *rdirfilename = NULL;
int rdir = NONE;

// 自定义环境变量表
char myenv[LINE_SIZE];

int splitstring(char cline[], char *_argv[]);

const char *getusername(){
	if(getenv("USER") == "root") LABLE = '#';
	return getenv("USER");
}

const char *getHostname(){
	return getenv("HOSTNAME");
}

const char* getpwd(){
	static char short_pwd[LINE_SIZE]; // 使用静态变量存储短路径
    //  提取路径中最后一个目录名
	getcwd(pwd, sizeof(pwd));
    char *last_slash = strrchr(pwd, '/');
    if (last_slash != NULL && *(last_slash + 1) != '\0') {
        strncpy(short_pwd, last_slash + 1, sizeof(short_pwd));
        return short_pwd;
    } else {
        return "/"; // 根目录返回 "/"
    }
}

void check_redir(char *cmd)
{
	// ls -al -n
	// ls -al -n >/</>> filename.txt
	char *pos = cmd;
	while(*pos) {
		if ( *pos == '>') {
			if(*(pos+1) == '>') {
				*pos++ =  '\0';
				*pos++ = '\0';
				while (isspace(*pos)) pos++;
				rdirfilename = pos;
				rdir = APPEND_RDIR;
			}
			else {
				*pos++ = '\0';
				while (isspace(*pos)) pos++;
				rdirfilename = pos;
				rdir = OUT_RDIR;
			}
			break;
		} else if (*pos == '<') {
			*pos++ = '\0';
			while (isspace(*pos)) pos++;
			rdirfilename = pos;
			rdir = IN_RDIR;
		} else {
			// do nothing;
		}
		pos++;
	}
}

void interact(char* cline, int size) {
	getpwd();// commandline -> "ls -a -l -n\0" -> "ls" "-a" "-l" "-n"
	printf(LEFT "%s@%s %s" RIGHT "%c ", getusername(), getHostname(), getpwd(), LABLE);
	char *s = fgets(cline, size, stdin);
	assert(s);
	(void)s;
	// "abcd\n\0";
	cline[strlen(cline)-1] = '\0';

	// ls -a -l > myfile.txt
	check_redir(cline);
}

int splitstring(char cline[], char *_argv[]) {
	int i = 0;
	_argv[i++] = strtok(cline, DELIM);
	while(_argv[i++] = strtok(NULL, DELIM)); // 故意写的=
	return i - 1;
} 

void NormalExcute(char *_argv[]) {
	pid_t id = fork();
	if (id < 0) {
		perror("fork");
		return;
	}
	else if (id == 0) {
		int fd = 0;

		// 后面我们做了重定向的工作， 后面我们在进程替换时不会影响吗？
		if (rdir == IN_RDIR) {
			fd = open(rdirfilename, O_RDONLY);
			dup2(fd, 0);
		} else if (rdir == OUT_RDIR) {
			fd = open(rdirfilename, O_CREAT|O_WRONLY|O_TRUNC, 0666);
			dup2(fd, 1);
		} else if (rdir == OUT_RDIR) {
			fd = open(rdirfilename, O_CREAT|O_WRONLY|O_APPEND, 0666);
			dup2(fd, 1);
		} 
		// 让子进程执行命令
		// execvpe(_argv[0], _argv, environ);
		execvp(_argv[0], _argv);
		exit(EXIT_CODE);
	} 
	else {
		int status = 0;
		pid_t rid = waitpid(id, &status, 0);
		if (rid == id) {
			lastcode = WEXITSTATUS(status);
		}
	}
}

int buildCommand(int _argc, char *_argv[])
{
	if (_argc == 2 && strcmp(_argv[0], "cd") == 0) {
		chdir(argv[1]);
		getpwd();
		sprintf(getenv("PWD"), "%s", pwd);
		return 1;
	} else if (_argc == 2 && strcmp(_argv[0], "export") == 0) {
		strcpy(myenv,_argv[1]);
		putenv(myenv);
		return 1;
	} else if (_argc == 2 && strcmp(_argv[0], "echo") == 0) {
		if (strcmp(_argv[1], "$?") == 0) {
			printf("%d\n", lastcode);
			lastcode=0;
		} else if ( *_argv[1] == '$') {
			char* val = getenv(_argv[1] + 1);
			if (val) printf("%s\n", val);
		} else {
			printf("%s\n", _argv[1]);
		}
		return 1;
	}

	// 特殊处理一下ls
	if (strcmp(_argv[0], "ls") == 0)
	{
		_argv[_argc++] = "--color";
		_argv[_argc]   = NULL;
	}
	return 0;
}
int main()
{
	printf("进入myshell\n");
	while(!quit) {
		// 1. 重定向输入输出
		rdirfilename = NULL;
		rdir = NONE;
		// 2. 交互问题，获取命令行 , 
		// ls -a -l > myfile / ls -a -l >> myfile / cat < file.txt
		interact(commandline, sizeof(commandline));
		
		// commandline -> "ls -a -l -n\0" -> "ls" "-a" "-l" "-n"
		// 3. 子串分割的问题， 解析命令行
		int argc = splitstring(commandline, argv); 

		// 4. 指令的判断
		// debug
		//for(int i = 0; argv[i]; i++) printf("[%d]: %s\n", i, argv[i]);
        //内键命令，本质就是一个shell内部的一个函数
		int n = buildCommand(argc, argv);

		// 5. 普通命令的执行
		if(!n) NormalExcute(argv);
	}
	return 0;
}

代码分析
首先，一个shell本质就是一个死循环，所以写成while(1)死循环。接下来进入如下几大步骤：

一、显示提示符：

我这里通过系统接口getenv(), 和C库中的字符串函数strrchr和strncpy实现了显示提示符

printf(LEFT "%s@%s %s" RIGHT "%c ", getusername(), getHostname(), getpwd(), LABLE);

这段代码是 myshell 的用户交互核心，负责生成并显示提示符、读取用户输入。其设计目标是模仿真实 shell 的提示符风格（如 Bash），通过获取用户信息、主机名和当前目录名，提供清晰的交互界面。

二、获取用户输入

先宏定义LINE_SIZE，再定义一个char commandline[LINE_SIZE]数组，我们平时在输入指令时或有带空格的场景（ls -a -l -i），需要将其整体当成字符串获取，用fgets来解决，注意输出指令后会按下回车键，回车也是字符，要把其去掉，否则会多输出一行，只需要把数组里最后一个字符设为’\0’即可。

#define LINE_SIZE 1024

char commandline[LINE_SIZE];
//2、获取用户输入
char *s = fgets(cline, size, stdin);
interact(commandline, sizeof(commandline));
cline[strlen(cline)-1] = '\0';

三、字符串切分 + 给ls命令添加颜色

下面我们需要把获取到的一整个字符串(“ls -a -l -i”）拆分成(“ls” “-a” “-l” “-i”），因为后续要一个一个或以数组的形式把这一个个命令传给替换函数。这里我们利用strtok函数（把一串字符串按照分隔符来切割）来解决，先定义一个_argv指针数组，把下表0的位置利用strtok截取到以空格和tab" \t"两个字符各自为分隔符的位置，这就让下表0为ls了，提取成功了，接下来截取剩下的，利用while语句，注意如果第一个已经截取了，那么strtok截取剩下的字符串的函数的第一个参数要设为NULL。

我们利用which指令看下正常的ls里的内容：

• 这里面的–color=auto就是能够让ls命令有颜色的选项，并且利用alias将其取别名为ls指令，我们需要给自己写的ls指令加上–color=auto这个选项，首先利用strcmp函数判断当_argv数组下标0程序名的位置和"ls"是一样的，那么就在数组下标1处添加–color=auto即可。

#define DELIM " \t"

int splitstring(char cline[], char *_argv[]) {
	int i = 0;
	_argv[i++] = strtok(cline, DELIM);
	while(_argv[i++] = strtok(NULL, DELIM)); // 故意写的=
	return i - 1;
} 

if (strcmp(_argv[0], "ls") == 0)
	{
		_argv[_argc++] = "--color";
		_argv[_argc]   = NULL;
	}

4、内建命令

内建命令1：

理想状态下，使用cd …可以回退上级目录,模拟程序可以实现:

• 如果exec*执行，发生了程序替换，只影响子进程，最多只是让子进程进行程序路径切换，但是子进程是一运行就完毕的进程！那么路径切换就没有意义了，所以我们在shell中更希望父进程的路径shell本身发生变化， 而不是让子进程路径发生变化。
• 如果有些行为，是必须让父进程shell执行的，不想让子进程执行，在这样的场景下是绝对不能创建子进程。所以只能是父进程自己实现对应的代码，这种由shell自己执行的命令，我们称之为内建（内置 build -in）命令。

为了解决上述路径切换的问题，我们需要用到chdir函数，其作用是更改工作路径，哪个进程调用此函数，那么它的工作路径就要发生变化。

• 这里我们手写一个chdir函数的使用，内部调用系统的chdir，接下来利用strcmp函数判断当_argv[0]的位置为"cd"指令时，路径就是_argv[1]，并加上 if(!n)，目的是不进行后续的创建进程。

//4、内建命令完成路径切换
if (_argc == 2 && strcmp(_argv[0], "cd") == 0) {
		chdir(argv[1]);
		getpwd();
		sprintf(getenv("PWD"), "%s", pwd);
		return 1;
	} 
	if(!n) NormalExcute(argv);

内建命令2：

当用户登录系统启动shell进程时，其环境变量来源于系统初始化配置及用户目录下的.bash_profile等配置文件，这些变量以逻辑地址映射形式存储于进程内存中供运行时读取。

代码功能分析

1. 数据结构与变量

char myenv[LINE_SIZE]; // 定义全局字符数组，用于存储环境变量字符串

作用：作为临时缓冲区，存储 export 命令的参数（如 “NAME=VALUE”）。
特点：
全局作用域，生命周期贯穿程序运行始终。
固定大小（LINE_SIZE），限制环境变量字符串的最大长度。

2. export 命令处理逻辑

else if (_argc == 2 && strcmp(_argv[0], "export") == 0) {
    strcpy(myenv, _argv[1]); // 将参数复制到全局数组
    putenv(myenv); // 将字符串添加到环境变量表
    return 1; // 表示命令处理成功
}

流程：

• 检查参数是否为 export 且参数数量正确（2 个参数）。
• 将第二个参数（如 “ss=11”）复制到全局数组 myenv。
• 调用 putenv 将 myenv 中的字符串添加到环境变量表。
• 返回 1 表示内置命令处理完成，无需执行外部程序。

5、创建进程，执行 && 6、程序替换

• 这里的目的是让子进程去执行程序替换，而不是让自己本身去执行，所以要创建进程，创建的过程都是基操
• 程序替换函数这里要选择execvp最为方便，因为我们输入的命令行参数全部被打散到了_argv数组里头，何不利用起来呢，此外执行的程序名字就是此数组的下标0位置
  //5、创建进程，执行

void NormalExcute(char *_argv[]) {
	pid_t id = fork();
	if (id < 0) {
		perror("fork");
		return;
	}
	else if (id == 0) {
		int fd = 0;

		// 后面我们做了重定向的工作， 后面我们在进程替换时不会影响吗？
		if (rdir == IN_RDIR) {
			fd = open(rdirfilename, O_RDONLY);
			dup2(fd, 0);
		} else if (rdir == OUT_RDIR) {
			fd = open(rdirfilename, O_CREAT|O_WRONLY|O_TRUNC, 0666);
			dup2(fd, 1);
		} else if (rdir == OUT_RDIR) {
			fd = open(rdirfilename, O_CREAT|O_WRONLY|O_APPEND, 0666);
			dup2(fd, 1);
		} 
		// 让子进程执行命令
		// execvpe(_argv[0], _argv, environ);
		execvp(_argv[0], _argv);
		exit(EXIT_CODE);
	} 
	else {
		int status = 0;
		pid_t rid = waitpid(id, &status, 0);
		if (rid == id) {
			lastcode = WEXITSTATUS(status);
		}
	}