一、命令行解释器shell的原理

我们已经知道Linux给我们提供了一系列由exec开头的系统调用接口，可以让我们在自己所写的程序中调用各种指令或者我们自己写的其他程序：

而我们的shell命令行解释器也是接收用户输入的指令，然后执行：

那我们在自己所写的程序中执行一次指令，是不是就类似于一个只执行了一次的shell？

而如果我们自己写一个程序可以不断地接收用户输入的指令并执行，那是不是就等价于一个简易的shell？

所以，命令行解释器shell的原理其实就是一个死循环程序，它不断地接收用户输入的指令并执行对应的程序，直到用户退出shell。

二、先搭好大致的框架

1、先获取用户信息并打印出提示符

既然要模拟式下一个shell，那我们也要模拟的像点样子，我们平时在shell命令行中打印命令的时候，在命令的前面都有一个长长的提示符：

这个长长的提示符主要是提示一些用户的信息，包括用户名和主机名和当前所在的工作目录。

那我们也需要先获取一下。

这些用户名、主机名和工作目录其实都是一些环境变量，所以我们可以通过getenv系统调用获得：

而用户名这些信息，其实在系统的环境变量中都有：

所以要打印出这些信息其实并不难，我们直接在环境变量中获取就行了：

效果也是如预料之中的：

2、获取用户输入指令并分割成字符串数组

解决打印提示符的工作接下来就应该接收用户输入的命令了，需要注意的是我们平时在命令行中输入各种指令的时候，例如“ls -a -l”，都是会带一些空格的。所以我们不能直接使用scanf接收，因为scanf是默认遇到空格就结束的了，所以scanf最多只能接收到第一个ls。

所以我们就要使用另一个更适合的接口——fgets：

它的功能其实就是从一个输入流中读取数据，写入一个缓冲区中，我们可以从stdin(键盘)中读取数据，然后定义一个字符串，将数据保存到字符串中：

其结果也是符合我们的预期的：

获取完用户输入的指令之后我们要有干什么呢？

我们最后的目的是要执行指令的啊，我们先来考虑一下我们该使用哪一个程序题换接口才更方便呢？

因为我们现在是在自己写的程序里面去执行指令，而程序并不知道我们所输入的指令的路径在哪里，所以我们肯定是选择自带路径的，即带‘p’的。而可变参数列表又只适用于手动传参，所以我们可能也得选择带‘v’的。

所以最优的选择就是：

所以这就需要我们将用户输入的字符串以空格为分隔符，分割进一个字符串数组中。

而C语言也有这样的接口，能让我们对一个字符串以一个分隔符分割，然后放入到一个字符数组中，那就是strtok：

现在来回一下，这个strtok的第一次使用和后面的使用是不一样的，第一次使用我们需要传递的是字符串数组的起始位置，而之后传递就只需要传第一个NULL即可。

因为strtok一旦失败就返回NULL，所以我们可以像下面这样写：

运行结果：

3、执行指令

有了上面的准备工作，我们就终于可以来执行指令了。

我们观察到，在shell中执行一个指令后其实是执行完就退出了的：

既然是执行完就退出，那我们就肯定不能让我们的父进程执行，而是应该让子进程来执行，子进程执行完就直接退出，而父进程则负责回收子进程：

运行结果：

所以我们现在就成功的调用到了我们系统的指令了，而现在它只执行了一次，我们只需要将之前所写的逻辑放入到一个死循环中，就可以让我们自定义的shell一直运行了：

运行结果：

至此，我们自定义shell的雏型也就完成了，它可以执行很多我们系统的指令，也不会退出，已经满足了shell命令行的大部分功能了。

但还有一些指令，是现阶段的myshell不能完成的，比如我们可以试着运行一下cd命令：

我们会发现，myshell在执行完cd命令后，路径并没有发生改变，也就是说不能完成cd的任务。

这是因为像cd这样的命令，它是一个“内建命令”。

三、处理“内建命令”

1、什么是内建命令

在Linux中，有一些命令是一定要父进程来执行的，不能由子进程来执行，这些命令就被称为“内建命令”。

就拿上面所提到的“cd”命令来说，它的本质是程序的工作目录发生了改变，之后执行任何指令都是在这个工作目录下执行。那它就必定不能交给子进程来执行，因为子进程一执行就退了，所以就算子进程的工作目录改变了也没用。

所以"cd"命令一定要是父进程执行。

Linux中其实有很多的内建命令，今天我们实现的是一个简易的shell，所以我这里只实现三个：cd、export，echo。

2、cd

执行cd命令是改变当前程序的工作目录，所以我们先要来认识一个接口：

这个接口就是用来改变当前进程的工作目录的，谁调用chdir，谁的工作目录就发生改变。

所以我们要做的就是让父进程来调用这个chdir。

我们可以封装一个函数来判断当前命令是否是内建命令如果是则执行并返回1，如果不是则返回0。

然后我们在创建子进程之前先判断一下就行了：

之后我们的cd内建命令就可以正常执行了：

但是这里还有一个问题，也就是虽然我们工作目录的确是改变了，但是我们提示符里面的工作目录却并没有改变：

原因在于我们在打印提示符的时候获取的工作目录实在环境变量里获取的：

而我们这里只是改变了工作目录，并没有对环境变量做更改，所以它每一次获取到的都是一样的。

如果想要让提示符内的路径也发生改变，那我们还得要先认识一个接口：

这个接口的作用就是将当前进程所在的绝对路径获取，并放入一个缓冲区内。

所以我们可以创建一个全局的cwd，每次改变path的时候，就获取一次当前进程的绝对路径，然后将获取到的路径放入cwd中，然后再将cwd导入到系统的环境变量表中：

做完这些工作之后，我们提示符里面的路径就也会发生改变了：

为什么cwd一定要用全局变量呢？这是因为环境变量的获取一定要有一个源头，如果cwd只是局部变量，那么子进程一退出，局部变量就被销毁了。那我们之后再查询env的时候，就查不到对应的环境变量了。

4、export

就像上面所说到的，环境变量在查询的时候一定要有一个“源头”，所以我们要导出的环境变量就一定不能存储在一个临时的空间里面。

所以我们要为我们写的myshell创建一个全局的环境变量表：

然后我们在导入环境变量的同时，把要导入的环境变量加入到我们创建的环境变量表中即可：

这样，我们导的环境变量就不会消失了，而且也能导入多个：

3、echo

这个echo就有很多情况要分了，如果echo后面跟的是“$+一个环境变量”，我们需要去环境变量表中查询出这个环境变量然后打印出来，如果后面跟的是一个字符串，那我们直接打印出这个字符串即可，而如果我们后面跟的是“$?”，那我们要打印的是最近一个程序结束时的退出码，这个也是我们等下需要特殊处理的东西。

打印字符串或者打印环境变量其实很好处理，如果是字符串那我们就直接打印好了，如果是环境变量那我们就用getenv获取后再打印出来：

运行结果：

对于退出码我们可以创建一个全局的变量latcode，默认设为0，然后在每次子进程结束后，父进程使用waitpid回收子进程的状态时将lastcode赋值即可：

运行结果：

四、整体代码

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

char enval[100][100];
int env_num = 0;
int lastcode = 0; // 记录最近一个进程退出是的退出码，默认为0

char cwd[1024]; 
const char* getUserName() {
  const char *username = getenv("USER");
  if (username) {
    return username;
  }
  return "none";
}

const char* getHostName() {
  const char* hostname = getenv("HOSTNAME");
  if (hostname) {
    return hostname;
  }
  return "none";
}

const char* getPwd() {
  const char* pwd = getenv("PWD");
  if (pwd) {
    return pwd;
  }
  return "none";
}
// 处理内建命令
// 成功执行返回1，失败返回0
int dobuildin(char *argv[]) {
  if (strcmp(argv[0], "cd") == 0) {
    char *path = NULL;
    if (NULL == argv[0]) {
      // 如果后面没有跟路径，就让路径默认为'.'即当前目录
      path = ".";
    } else {
      path = argv[1];
    }


    chdir(path);
    // 获取当前进程的绝对路径
    char temp[1024];
    getcwd(temp, sizeof(temp));
    // 将temp写入cwd中
    sprintf(cwd, "PWD=%s", temp);
    // 将cwd中的环境变量导入到系统的环境变量表中
    putenv(cwd);
    return 1;
    } else if (strcmp(argv[0], "export") == 0) {
    if (argv[1] == NULL) {
      return 1;
    }
    strcpy(enval[env_num], argv[1]);
    putenv(enval[env_num]); // 注意这里要导入的是enval[env_num]，而不能是argv[1]
    env_num++;
    return 1;
    } else if (strcmp(argv[0], "echo") == 0) {
      if (argv[1] == NULL) {
        printf("\n");
        return 1;
      }
      if (argv[1][0] == '$' && strlen(argv[1]) > 1) {
        if (argv[1][1] == '?') {
          // 打印上一个进程的退出码
          printf("%d\n", lastcode);
          // 因为内建命令执行时总是成功的，所以这里直接将lastcode设成0就行
          lastcode = 0; 
          
        } else {
          // 打印环境变量
          char *val = argv[1] + 1;
          char *reval = getenv(val);
          if (reval == NULL) {
            printf("\n");
            return 1;
          }
          printf("%s\n", reval);
        }
      } else {
        // 表示是字符串
        printf("%s\n", argv[1]);
      }
      return 1;
    }
  return 0;

}

int main() {
  char usercommand[1024];
  while (1) {
  char *argv[100] = { NULL };
  int argc = 0;
  printf("[%s@%s %s]￥ ", getUserName(), getHostName(), getPwd());
  char *r = fgets(usercommand, sizeof(usercommand), stdin);
  if (NULL == r || strlen(usercommand) == 0) {
    continue;
  }
  usercommand[strlen(usercommand) - 1] = '\0';

  // 分割用户输入的指令
  argv[argc++] = strtok(usercommand, " ");
  while (argv[argc++] = strtok(NULL, " "));

  // 检查是否是内建命令并执行
  int res = dobuildin(argv);
  if (res) {
    continue; // 如果成功执行就不用再往后执行了
  }
  
  

  // 执行指令
  pid_t id = fork();
  if (0 == id) {
    // child
    int n = execvp(argv[0], argv);
    if (-1 == n) {
      printf("-myShell: %s: command not found\n", argv[0]);
    }
    exit(1);
  } else {
    // father
    int status = 0;
    pid_t rid = waitpid(id, &status, 0);
    if (rid > 0) {
      lastcode = WEXITSTATUS(status);
    } else {
      return -1;
    }
  }
  }
  return 0;
}