【应用篇】09.自主Shell命令行解释器

发布于：2025-02-10 ⋅ 阅读:(22) ⋅ 点赞:(0)

一、目标

• 要能处理普通命令
• 要能处理内建命令
• 要能帮助我们理解内建命令/本地变量/环境变量这些概念
• 要能帮助我们理解shell的运行原理

二、实现原理

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

[caryon@VM-24-10-centos ~]$ ls
code  code.c  code.cpp  code_static  linux  shared_code.cpp  shared_dir
[caryon@VM-24-10-centos ~]$ ps
  PID TTY          TIME CMD
13014 pts/0    00:00:00 bash
13288 pts/0    00:00:00 ps

用下图的时间轴来表示事件的发生次序。其中时间从左向右。shell由标识为sh的方块代表，它随着时间的流逝从左向右移动。shell从用户读入字符串"ls"。shell建立一个新的进程，然后在那个进程中运行ls程序并等待那个进程结束。
在这里插入图片描述
然后shell读取新的一行输入，建立一个新的进程，在这个进程中运行程序并等待这个进程结束。
所以要写一个shell，需要循环以下过程:

  1. 打印命令提示符
  2. 获取命令行
  3. 解析命令行
  4. 检查并执行内建命令
  5. 创建子进程执行普通命令

根据这些思路，和我们前面的学的技术，就可以自己来实现一个shell了。

三、实现

3.1 整体框架

int main()
{
	//用以命令行输入
    char command_buffer[basesize];
    //循环执行
    while(true)
    {
    	// 1. 打印命令行提示符
        PrintCommandLine(); 
        // 2. 获取用户命令
        if( !GetCommandLine(command_buffer, basesize) ) 
            continue;
        // 3. 分析命令
        ParseCommandLine(command_buffer, strlen(command_buffer)); 
		// 5. 检查并执行内建命令
        if ( CheckAndExecBuiltCommand() )
            continue;
		// 4. 执行命令
        ExecuteCommand();   
    }
    return 0;
}

3.2 打印命令行提示符

通过环境变量来获取所需要的主机名，用户名，所处路径，并将其组合成字符串输出。

//获取用户名
string GetUserName()
{
    string name = getenv("USER");
    //不存在就返回None
    return name.empty() ? "None" : name;
}
//获取主机名
string GetHostName()
{
    string hostname = getenv("HOSTNAME");
    return hostname.empty() ? "None" : hostname;
}
//获取所处路径
string GetPwd()
{
	//初始时所写，无法完成命令行中的所处路径的切换
	string pwd = getenv("HOSTNAME");
    return pwd.empty() ? "None" : pwd;
}
//组装成字符串
string MakeCommandLine()
{
    char command_line[basesize];
    snprintf(command_line, basesize, "[%s@%s %s]# ",GetUserName().c_str(), GetHostName().c_str(), GetPwd().c_str());
    return command_line;
}
//打印命令行提示符
void PrintCommandLine() 
{
    printf("%s", MakeCommandLine().c_str());
    fflush(stdout);
}

3.3 获取命令行输入

通过fgets获取用户的输入，然后去除掉’\n’。

//如果获取失败就continue，进入下一次循环
bool GetCommandLine(char command_buffer[], int size)  
{
    char *result = fgets(command_buffer, size, stdin);
    if(!result)
        return false;
    //去除\n
    command_buffer[strlen(command_buffer)-1] = 0;
    if(strlen(command_buffer) == 0) return false;
    return true;
}

3.4 分析命令

将输入的指令使用C语言中的strtok进行切割打散成指针数组，利用gargc计数，gargv进行存储。

//分析命令
void ParseCommandLine(char command_buffer[], int len) 
{
    (void)len;
    //每次都将命令行参数列表置空，命令行参数个数置0
    memset(gargv, 0, sizeof(gargv));
    gargc = 0;
    const char *sep = " ";
    gargv[gargc++] = strtok(command_buffer, sep);
    // =是刻意写的
    while(gargv[gargc++] = strtok(nullptr, sep));
    gargc--;
}

3.5 执行命令

创建子进程，让子进程调用exec系列接口去执行命令，父进程等待。

bool ExecuteCommand()   // 4. 执行命令
{
    // 让子进程进行执行
    pid_t id = fork();
    if(id < 0) return false;
    if(id == 0)
    {
        //子进程
        // 1. 执行命令
        execvp(gargv[0], gargv);
        // 2. 退出
        exit(0);
    }
    //父进程
    int status = 0;
    pid_t rid = waitpid(id, &status, 0);
    return false;
}

3.6 检查并执行内建命令

当我们执行cd命令时，我们发现时无效的，这是因为每个进程都有自己的当前路径，我们的cd想改变的是当前shell的工作路径，这就需要shell自己去执行。这样的命令我们称之为内建命令。

常见的内建命令：
• cd
• export
• env
• echo

我们通过枚举的方式将内建命令实现：

3.6.1 cd

//获取所处路径
const int basesize = 1024;
char pwd[basesize];
string GetPwd()
{
	//这里需要将pwd的获取重写，以达到能够获取当前工作路径的目的 
    if(nullptr == getcwd(pwd, sizeof(pwd))) return "None";
    snprintf(pwdenv, sizeof(pwdenv),"PWD=%s", pwd);
    return pwd;
}

if(strcmp(gargv[0], "cd") == 0)
{
   // 内建命令
   if(gargc == 2)
   {
   	   //更改当前工作目录
       chdir(gargv[1]);
   }
}

3.6.2 export

const int argvnum = 64;
// 全局的命令行参数表
char *gargv[argvnum];
int gargc = 0;

// 作为一个shell，获取环境变量应该从系统的配置来
// 我们就直接从父shell中获取环境变量
void InitEnv()
{
    extern char **environ;
    int index = 0;
    while(environ[index])
    {
        genv[index] = (char*)malloc(strlen(environ[index])+1);
        strncpy(genv[index], environ[index], strlen(environ[index])+1);
        index++;
    }
    genv[index] = nullptr;
}

//导入环境变量
void AddEnv(const char *item)
{
    int index = 0;
    while(genv[index])
        index++;
        
    genv[index] = (char*)malloc(strlen(item)+1);
    strncpy(genv[index], item, strlen(item)+1);
    genv[++index] = nullptr;
}

if(strcmp(gargv[0], "export") == 0)
{
   	if(gargc == 2)
   	{
   		AddEnv(gargv[1]);
   	}
}

3.6.3 env

if(strcmp(gargv[0], "env") == 0)
{
   for(int i = 0; genv[i]; i++)
   {
       printf("%s\n", genv[i]);
   }
}

3.6.4 echo

if(strcmp(gargv[0], "echo") == 0)
{
   if(gargc == 2)
   {
       // echo $?
       // echo $PATH
       // echo hello
       if(gargv[1][0] == '$')
       {
           if(gargv[1][1] == '?')
           {
               printf("%d\n", lastcode);
           }
       }
       else
       {
           printf("%s\n", gargv[1]);
       }
   }
}

四、源码

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

using namespace std;

const int basesize = 1024;
const int argvnum = 64;
const int envnum = 64;
// 全局的命令行参数表
char *gargv[argvnum];
int gargc = 0;

// 全局的变量
int lastcode = 0;

// 我的系统的环境变量
char *genv[envnum];

// 全局的当前shell工作路径 
char pwd[basesize];
char pwdenv[basesize];

string GetUserName()
{
    string name = getenv("USER");
    return name.empty() ? "None" : name;
}

string GetHostName()
{
    string hostname = getenv("HOSTNAME");
    return hostname.empty() ? "None" : hostname;
}

string GetPwd()
{
    if(nullptr == getcwd(pwd, sizeof(pwd))) return "None";
    snprintf(pwdenv, sizeof(pwdenv),"PWD=%s", pwd);
    putenv(pwdenv); 
    return pwd;
}

string LastDir()
{
    string curr = GetPwd();
    if(curr == "/" || curr == "None") return curr;
    size_t pos = curr.rfind("/");
    if(pos == std::string::npos) return curr;
    return curr.substr(pos+1);
}

string MakeCommandLine()
{
    char command_line[basesize];
    snprintf(command_line, basesize, "[%s@%s %s]# ",GetUserName().c_str(), GetHostName().c_str(), LastDir().c_str());
    return command_line;
}

void PrintCommandLine() 
{
    printf("%s", MakeCommandLine().c_str());
    fflush(stdout);
}

bool GetCommandLine(char command_buffer[], int size)  
{
    char *result = fgets(command_buffer, size, stdin);
    if(!result)
    {
        return false;
    }
    command_buffer[strlen(command_buffer)-1] = 0;
    if(strlen(command_buffer) == 0) return false;
    return true;
}

void ParseCommandLine(char command_buffer[], int len)
{
    (void)len;
    memset(gargv, 0, sizeof(gargv));
    gargc = 0;
    const char *sep = " ";
    gargv[gargc++] = strtok(command_buffer, sep);
    while((bool)(gargv[gargc++] = strtok(nullptr, sep)));
    gargc--;
}
bool ExecuteCommand()  
{
    // 让子进程进行执行
    pid_t id = fork();
    if(id < 0) return false;
    if(id == 0)
    {
        //子进程
        // 1. 执行命令
        execvpe(gargv[0], gargv, genv);
        // 2. 退出
        exit(1);
    }
    int status = 0;
    pid_t rid = waitpid(id, &status, 0);
    if(rid > 0)
    {
        if(WIFEXITED(status))
        {
            lastcode = WEXITSTATUS(status);
        }
        else
        {
            lastcode = 100;
        }
        return true;
    }
    return false;
}
void AddEnv(const char *item)
{
    int index = 0;
    while(genv[index])
    {
        index++;
    }

    genv[index] = (char*)malloc(strlen(item)+1);
    strncpy(genv[index], item, strlen(item)+1);
    genv[++index] = nullptr;
}
// shell自己执行命令，本质是shell调用自己的函数
bool CheckAndExecBuiltCommand()
{
    if(strcmp(gargv[0], "cd") == 0)
    {
        // 内建命令
        if(gargc == 2)
        {
            chdir(gargv[1]);
            lastcode = 0;
        }
        else
        {
            lastcode = 1;
        }
        return true;
    }
    else if(strcmp(gargv[0], "export") == 0)
    {
        // export也是内建命令
        if(gargc == 2)
        {
            AddEnv(gargv[1]);
            lastcode = 0;
        }
        else
        {
            lastcode = 2;
        }
        return true;
    }
    else if(strcmp(gargv[0], "env") == 0)
    {
        for(int i = 0; genv[i]; i++)
        {
            printf("%s\n", genv[i]);
        }
        lastcode = 0;
        return true;
    }
    else if(strcmp(gargv[0], "echo") == 0)
    {
        if(gargc == 2)
        {
            // echo $?
            // echo $PATH
            // echo hello
            if(gargv[1][0] == '$')
            {
                if(gargv[1][1] == '?')
                {
                    printf("%d\n", lastcode);
                    lastcode = 0;
                }
            }
            else
            {
                printf("%s\n", gargv[1]);
                lastcode = 0;
            }
        }
        else
        {
            lastcode = 3;
        }
        return true;
    }
    return false;
}

// 作为一个shell，获取环境变量应该从系统的配置来
// 我们今天就直接从父shell中获取环境变量
void InitEnv()
{
    extern char **environ;
    int index = 0;
    while(environ[index])
    {
        genv[index] = (char*)malloc(strlen(environ[index])+1);
        strncpy(genv[index], environ[index], strlen(environ[index])+1);
        index++;
    }
    genv[index] = nullptr;
}

int main()
{
    InitEnv();
    char command_buffer[basesize];
    while(true)
    {
        PrintCommandLine(); // 1. 命令行提示符
        if( !GetCommandLine(command_buffer, basesize) )   // 2. 获取用户命令
        {
            continue;
        }
        ParseCommandLine(command_buffer, strlen(command_buffer)); // 3. 分析命令

        if ( CheckAndExecBuiltCommand() )
        {
            continue;
        }

        ExecuteCommand();   // 4. 执行命令
    }
    return 0;
}

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布