模拟实现Bash

🌟🌟hello，各位读者大大们你们好呀🌟🌟
🚀🚀系列专栏：【Linux的学习】
📝📝本篇内容：Bash的基本认识；bash的实现；添加细节；内置命令；完整代码
⬆⬆⬆⬆上一篇：Linux多线程（下）
💖💖作者简介：轩情吖，请多多指教(>> •̀֊•́ ) ̖́-

1.Bash基本认识

什么是bash呢？其实bash本质上就是我们的命令行解释器，它其实就相等于WindowsGUI就是通过图形化界面的点击来进行访问，我们可以通过bash来和操作系统进行交互，bash把我们的命令解析给Linux内核，Linux内核又把反馈结果给bash，bash又解析给我们显示。这样做有什么好处呢？首先如果直接进行和内核进行交互的话，可能比较难，成本比较高，因此有了bash，通过bash来进行交互会更好。同时我们的bash会内核起到保护作用，作为用户和操作系统交互的中间软件层，防止对内核造成破坏，即使出问题，也只是我们的bash出问题，不会伤及核心。
我们平时所使用的命令以及跑的代码其实都是bash的子进程，这是为了保护我们的bash，不至于代码跑崩溃了，而导致bash也崩了

2.Bash实现

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
using namespace std;

char* commend_list[10]={NULL};
int main()
{
    char commend[1024];//将命令存入这个数组
    while(1)
    {
        cout<<"[lnb@VM-16-17centos 当前目录]";
        fgets(commend,1024,stdin);
        //去掉\n
        commend[strlen(commend)-1]='\0';
        //拆分命令
        commend_list[0]=strtok(commend," ");
        int i=1;
        while(commend_list[i++]=strtok(NULL," "))
        {}

        // i=0;
        // while(commend_list[i])        
        // {
        //     cout<<commend_list[i++]<<endl;
        // }
        
        //创建子进程
        pid_t ret=fork();
        if(ret>0)
        {
            //父进程,进行等待
            int status=0;
            waitpid(ret,&status,0);
            cout<<"退出信号:"<<(status&0x7f)<<",退出码:"<<((status>>8)&0xff)<<endl;
            cout<<"退出信号:"<<WTERMSIG(status)<<",退出码:"<<WEXITSTATUS(status)<<endl;
        }
        else
        {
            //子进程,进行程序替换
            execvp(commend_list[0],commend_list);
            exit(-1);
        }
    }
    return 0;
}

首先我们来剖析一下上面的代码，因为比较简单，就直接给出代码了
第一步我们先模拟打印出bash命令行解释器的提示，然后通过fgets来从标准输入里面读取命令
第二步给把我们存储命令的数组中的\n去除，然后把命令进行拆分放入一个指针数组中，在这一步中用到了一个函数strtok

第三步就是通过fork来进行父子进程分别工作，这就是前面提到的bash创建子进程来保证自身的安全
第四步就是详细编写父子进程的代码，对于父进程而言就是等待子进程结束，对于子进程而言就是使用到了进程替换，来执行对于的命令行，这样即使子进程崩溃了，也不会影响到父进程bash

3.添加细节

这个时候可以使用大部分的命令了，但是我们的ls和系统自带的ls不太一样
可以发现我们的ls下不会展示高亮，这是为什么呢？
通过查看可以发现他其实真正使用时会自带命令选项
此时我们再看另一个现象，我们使用ll

可以发现无法使用，其实这个和前一个问题是一样的

这个时候我们可以对我们的命令进行一个补充

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
using namespace std;

char* commend_list[10]={NULL};
int main()
{
    char commend[1024];//将命令存入这个数组
    while(1)
    {
        cout<<"[lnb@VM-16-17centos 当前目录]";
        fgets(commend,1024,stdin);
        //去掉\n
        commend[strlen(commend)-1]='\0';
        //拆分命令
        commend_list[0]=strtok(commend," ");
        int i=1;
        while(commend_list[i++]=strtok(NULL," "))
        {}

        // i=0;
        // while(commend_list[i])        
        // {
        //     cout<<commend_list[i++]<<endl;
        // }
        
     

        if(strcmp(commend_list[0],"ls")==0)
        {
            commend_list[i++]="--color=auto";
        }
        if(strcmp(commend_list[0],"ll")==0)
        {
            commend_list[0]="ls";
            commend_list[1]="-l";
            commend_list[2]="--color=auto";
            commend_list[3]=NULL;
        }


        //创建子进程
        pid_t ret=fork();
        if(ret>0)
        {
            //父进程,进行等待
            int status=0;
            waitpid(ret,&status,0);
            cout<<"退出信号:"<<(status&0x7f)<<",退出码:"<<((status>>8)&0xff)<<endl;
            cout<<"退出信号:"<<WTERMSIG(status)<<",退出码:"<<WEXITSTATUS(status)<<endl;
        }
        else
        {
            //子进程,进行程序替换
            execvp(commend_list[0],commend_list);
            exit(-1);
        }
    }
    return 0;
}

4.内置命令

接下来我们要讲一下内置命令，这是实现bash的重点，也是我要详细讲的。首先我们先在我们自己的bash下使用cd和export命令看一下现象

可以发现我们的cd完全没有效果，其实这就是内建命令造成的，在真正的bash实现中，这是bash自己来执行的，而我们在自己实现的过程中，是由我们的子进程来执行的，作为两个不同的进程，有独立性，并不是我们的父进程bash来执行的，因此导致了没有效果，此时我们也要进行特殊处理，使用chdir函数

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
using namespace std;

char* commend_list[10]={NULL};
int main()
{
    char commend[1024];//将命令存入这个数组
    while(1)
    {
        cout<<"[lnb@VM-16-17centos 当前目录]";
        fgets(commend,1024,stdin);
        //去掉\n
        commend[strlen(commend)-1]='\0';
        //拆分命令
        commend_list[0]=strtok(commend," ");
        int i=1;
        while(commend_list[i++]=strtok(NULL," "))
        {}

        // i=0;
        // while(commend_list[i])        
        // {
        //     cout<<commend_list[i++]<<endl;
        // }
        
     

        if(strcmp(commend_list[0],"ls")==0)
        {
            commend_list[i++]="--color=auto";
        }
        if(strcmp(commend_list[0],"ll")==0)
        {
            commend_list[0]="ls";
            commend_list[1]="-l";
            commend_list[2]="--color=auto";
            commend_list[3]=NULL;
        }
        if(strcmp(commend_list[0],"cd")==0)
        {
            if(commend_list[1]!=NULL)
            chdir(commend_list[1]);
            continue;
        }


        //创建子进程
        pid_t ret=fork();
        if(ret>0)
        {
            //父进程,进行等待
            int status=0;
            waitpid(ret,&status,0);
            cout<<"退出信号:"<<(status&0x7f)<<",退出码:"<<((status>>8)&0xff)<<endl;
            cout<<"退出信号:"<<WTERMSIG(status)<<",退出码:"<<WEXITSTATUS(status)<<endl;
        }
        else
        {
            //子进程,进行程序替换
            execvp(commend_list[0],commend_list);
            exit(-1);
        }
    }
    return 0;
}

接下来要处理的就是export，对于它，在编写这个代码的时候我也发现了很多以前没注意的问题，我们现在来讲一讲
首先是putenv这个函数，它其实是一个添加环境变量的函数，但是它仅仅是对使用它的程序有效，在程序里做的环境变量更改不会反映到外部环境，这是因为变量的值不会从子进程（你的程序）传播到父进程（shell）。通过putenv添加的环境变量通常是临时的，它们仅在当前进程及其子进程中可见。当进程结束时，这些环境变量将消失。
我这里有一段代码可以验证一下，就简单的使用一个putenv，看看外界会不会有什么变化

#include <iostream>
#include <unistd.h>
using namespace std;
int main()
{
    putenv("val=100");
    while(1);//使用循环来保证环境变量不会随着程序结束而结束

    return 0;
}

可以发现并没有影响，但是会对进程的子进程产生影响，我这边还有一个例子，可以看一下

//test.cc
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <iostream>
#include <sys/wait.h>
#include <sys/types.h>
extern char** environ;
int main(int argc,char* argv[],char *envp[])
{
  //std::cout<<(void*)envp<<std::endl;
  //std::cout<<(void*)environ<<std::endl;
  putenv("val=111111111111111111111111111111111111111111111111111");
  for(int i=0;environ[i];i++)
  {
    std:: cout<<environ[i]<<std::endl;
  }

  std::cout<<std::endl<<std::endl<<std::endl<<std::endl;
  
int ret=fork();
if(ret==0)
{
  execl("/home/lnb/linux-l/24_review/24_11_13/replace","./replace");//程序替换成我们自己写的程序来查看环境变量
}
waitpid(ret,NULL,0);//父进程负责等待子进程

while(1)
{

}


  return 0;
}

//relpace.cc
#include <iostream>
using namespace std;
int main(int argc,char* argv[],char* envp[])
{
  for(int i=0;envp[i];i++)  
  {
    cout<<envp[i]<<endl;
  }




  return 0;
}

可以看到我们的自己的程序和子进程都打印出来了新添加的环境变量
不知道你是否有注意到我的test.cc中注释了两行代码，分别是打印对于environ和envp的值,按理来说，他们的使用和结果是相等的，但是实际测试下来并不是，它们的地址是相同的，但是打印出来的结果不同，使用envp时，程序本身不能打印出添加的val，不知道是不是系统bug造成的，因此推荐使用environ，具体见下面结果

//test.cc
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <iostream>
#include <sys/wait.h>
#include <sys/types.h>
extern char** environ;
int main(int argc,char* argv[],char *envp[])
{
  std::cout<<(void*)envp<<std::endl;//打印地址
  std::cout<<(void*)environ<<std::endl;//打印地址
  putenv("val=111111111111111111111111111111111111111111111111111");
  for(int i=0;envp[i];i++)
  {
    std:: cout<<envp[i]<<std::endl;
  }

  std::cout<<std::endl<<std::endl<<std::endl<<std::endl;//和子进程打印的结果进行分割
  
int ret=fork();
if(ret==0)
{
  execl("/home/lnb/linux-l/24_review/24_11_13/replace","./replace");//程序替换成我们自己写的程序来查看环境变量
}
waitpid(ret,NULL,0);//父进程负责等待子进程

while(1)
{

}


  return 0;
}

不知道有没有知道的小伙伴这是为什么？可以一起在评论区一起讨论一下（我查询了AI，不知道是否准确，见下图）

并且我们平时使用export来添加的环境变量或者是通过export修改的环境变量都是临时的，当关闭这个shell会话时，通过export设置的环境变量就会失效，重新打开后，bash会重新从配置文件中读取，并不会包含之前添加的环境变量，想要使环境变量永久存在，需要将它添加到配置文件中（当前用户的bash配置文件，如~/.bashrc 或 ~/.bash_profile））

接下来我们回归主题，讲一下我们自己实现bash时对于export的处理，先来看一下直接使用export的现象

因此我们要对他进行特殊处理

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
using namespace std;

extern char** environ;

char* commend_list[10]={NULL};
char  environment[20][30]={0};//用来存储用户自己的环境变量
int envir_index=0;
int main()
{
    char commend[1024];//将命令存入这个数组
    while(1)
    {
        cout<<"[lnb@VM-16-17centos 当前目录]";
        fgets(commend,1024,stdin);
        //去掉\n
        commend[strlen(commend)-1]='\0';
        //拆分命令
        commend_list[0]=strtok(commend," ");
        int i=1;
        while(commend_list[i++]=strtok(NULL," "))
        {}

        // i=0;
        // while(commend_list[i])        
        // {
        //     cout<<commend_list[i++]<<endl;
        // }
        
     

        if(strcmp(commend_list[0],"ls")==0)
        {
            commend_list[i++]="--color=auto";
        }
        if(strcmp(commend_list[0],"ll")==0)
        {
            commend_list[0]="ls";
            commend_list[1]="-l";
            commend_list[2]="--color=auto";
            commend_list[3]=NULL;
        }
        if(strcmp(commend_list[0],"cd")==0)
        {
            if(commend_list[1]!=NULL)
            chdir(commend_list[1]);
            continue;
        }

        if(strcmp(commend_list[0],"export")==0)
        {   
            //我们要对这个它添加的环境变量进行一个保存，
            //因为如果不保存会出现环境变量指针消失的问题
            //commend_list[1]中存储了我们的添加的环境变量
            //但是当我们下一回合重新读取命令的时候，他就会
            //被覆盖，因为我们的commend_list数组中的指针都是
            //从commend中出来的，这样的话就会导致结果有问题，
            //无法正常显示
            if(commend_list[1]!=NULL)
            {
                strcpy(environment[envir_index],commend_list[1]);
                putenv(environment[envir_index++]);
                continue;
            }
        }
        
        if(strcmp(commend_list[0],"env")==0)
        {
                //之所以要进行特殊处理env是因为我们要打印显示的是bash父进程本身的环境变量
                //而不是我们的子进程
            for(int i=0;environ[i];i++)
            {
                cout<<environ[i]<<endl;
            }
            continue;
        }
        //创建子进程
        pid_t ret=fork();
        if(ret>0)
        {
            //父进程,进行等待
            int status=0;
            waitpid(ret,&status,0);
            cout<<"退出信号:"<<(status&0x7f)<<",退出码:"<<((status>>8)&0xff)<<endl;
            cout<<"退出信号:"<<WTERMSIG(status)<<",退出码:"<<WEXITSTATUS(status)<<endl;
        }
        else
        {
            //子进程,进行程序替换
            execvp(commend_list[0],commend_list);
            exit(-1);
        }
    }
    return 0;
}

在这里面我们要格外的注意对于export的处理以及和env的处理，我们一般用户自定义的环境变量，在bash中要用户自己来维护，在使用putenv时，应注意内存管理问题，避免释放传递给它的字符串的内存空间，也不要进行覆盖，否则会出bug。对于我们的env同样也要做特处理，因为我们需要的是mybash的环境变量
其实我们的大部分环境变量的命令都是内建命令

5.完整代码

在下面的完整代码中，我也加入了echo等其他部分的命令的处理，也进行了注释，相信大家也能看得懂

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
using namespace std;

extern char** environ;

static int ret_code=0;//用来记录上一个进程的退出码

char* commend_list[10]={NULL};
char  environment[20][30]={0};//用来存储用户自己的环境变量
int envir_index=0;
int main()
{
    char commend[1024];//将命令存入这个数组
    while(1)
    {
        cout<<"[lnb@VM-16-17centos 当前目录]";
        fgets(commend,1024,stdin);
        //去掉\n
        commend[strlen(commend)-1]='\0';
        //拆分命令
        commend_list[0]=strtok(commend," ");
        int i=1;
        while(commend_list[i++]=strtok(NULL," "))
        {}

        // i=0;
        // while(commend_list[i])        
        // {
        //     cout<<commend_list[i++]<<endl;
        // }
        
     

        if(strcmp(commend_list[0],"ls")==0)
        {
            commend_list[i++]="--color=auto";
        }
        if(strcmp(commend_list[0],"ll")==0)
        {
            commend_list[0]="ls";
            commend_list[1]="-l";
            commend_list[2]="--color=auto";
            commend_list[3]=NULL;
        }
        if(strcmp(commend_list[0],"cd")==0)
        {
            if(commend_list[1]!=NULL)
            chdir(commend_list[1]);
            continue;
        }

        if(strcmp(commend_list[0],"export")==0)
        {   
            //我们要对这个它添加的环境变量进行一个保存，
            //因为如果不保存会出现环境变量指针消失的问题
            //commend_list[1]中存储了我们的添加的环境变量
            //但是当我们下一回合重新读取命令的时候，他就会
            //被覆盖，因为我们的commend_list数组中的指针都是
            //从commend中出来的，这样的话就会导致结果有问题，
            //无法正常显示
            if(commend_list[1]!=NULL)
            {
                strcpy(environment[envir_index],commend_list[1]);
                putenv(environment[envir_index++]);
                continue;
            }
        }
        
        if(strcmp(commend_list[0],"env")==0)
        {
                //之所以要进行特殊处理env是因为我们要打印显示的是bash父进程本身的环境变量
                //而不是我们的子进程
            for(int i=0;environ[i];i++)
            {
                cout<<environ[i]<<endl;
            }
            continue;
        }

        if(strcmp(commend_list[0],"echo")==0&&(*(commend_list[1]))=='$')//对于查看环境变量值的处理
        {
            if(commend_list[1][1]=='?')//第一个命令选项中第二个字符
            {
                cout<<ret_code<<endl;
                continue;
            }
            const char* str=NULL;
            str=getenv(commend_list[1]+1);//此处的commend_list[1]的值为char*，指向第一个命令选项，+1后指向$后面
            printf("%s:%s\n",commend_list[1]+1,str);
            continue;
        }


        //创建子进程
        pid_t ret=fork();
        if(ret>0)
        {
            //父进程,进行等待
            int status=0;
            waitpid(ret,&status,0);
            cout<<"退出信号:"<<(status&0x7f)<<",退出码:"<<((status>>8)&0xff)<<endl;
            cout<<"退出信号:"<<WTERMSIG(status)<<",退出码:"<<WEXITSTATUS(status)<<endl;
            ret_code=((status>>8)&0xff);
        }
        else
        {
            //子进程,进行程序替换
            execvp(commend_list[0],commend_list);
            exit(-1);
        }
    }
    return 0;
}

🌸🌸模拟实现bash的知识大概就讲到这里啦，博主后续会继续更新更多Linux的相关知识，干货满满，如果觉得博主写的还不错的话，希望各位小伙伴不要吝啬手中的三连哦！你们的支持是博主坚持创作的动力！💪💪