Linux编写一个极简版本的Shell

简介: Linux编写一个极简版本的Shell

Linux编写一个极简版本的Shell

📟作者主页:慢热的陕西人

🌴专栏链接:Linux

📣欢迎各位大佬👍点赞🔥关注🚓收藏,🍉留言

本博客主要内容在Linux环境下,简易实现了一个Shell,顺便讲解和实现了一些内建命令


首先我们观察到:

bash的命令行提示符:[用户名@主机名 当前目录]

[mi@lavm-5wklnbmaja demo1]

所以我们无限循环去打印这个命令行提示符

#include<stdio.h>    
#include<unistd.h>                                                                                                                                            
int main()    
{    
  while(1)    
  {    
    printf("[xupt@my_machine currpath]#");    
    //这里因为我们不能加换行,所以得刷新缓冲区    
    fflush(stdout);    
    sleep(1);    
  }    
  return 0;    
}

运行效果:

①读取命令行

接下来我们就要获取命令输入的命令行参数:

我们创建一个字符数组用来专门存放用户输入的命令行

#define MAX 1024  //因为命令行最长支持到1024
char commondstr[MAX] = {0};

我们用fgets来获取命令行

fgets(commondstr, sizeof(commondstr), stdin);

我们测试一下:

结果正常,但是我们的命令重新被打印的时候多打印了一个换行符,因为fgets读取了换行符,并且存储到了commondstr中了.

[mi@lavm-5wklnbmaja demo1]$ ./myshell 
[xupt@my_machine currpath]#ls -a
ls -a

解决方案:

commondstr[strlen(commondstr) - 1] = '\0';//处理fget获取了换行符的问题

运行结果:

②父子进程框架

这个时候我们就需要用到子进程了,因为执行命令行的时候需要用到程序替换,那么如果我们用父进程的话,直接就全崩掉了。

每次输入命令,都把命令交给子进程去执行,而父进程去等待子进程就好了:

pid_t id = fork();    
    assert(id >= 0);    
    (void) id; //和上面的处理原因一样    
    if(id == 0)    
    {    
      //child    
    }    
    int status = 0;             
    waitpid(id, &status, 0);

在子进程执行之前,我们先要将用户输入进来的命令行进行拆分

③切割命令行

切割的原理很简单,我们只需要把命令行中间的空格变成\0即可。

ls -a -l ----> ls\0-a\0-l;

这个时候我们要引入一个C库提供的函数strtok,它是一个专门用来分隔字符串的函数。

我们需要封装一下这个函数来达到为我们分割命令行的目的:

注意strtok函数第二次切割的时候只需要传入NULL即可。

int split(char* commondstr, char* argv[])    
{    
  assert(commondstr);    
  assert(argv);    
  argv[0] = strtok(commondstr, SEP);    
  int i = 1;    
  while((argv[i++] = strtok(NULL, SEP)));    
//  {    
//      argv[i] = strtok(NULL, SEP);    
//      if(argv[i] == NULL) break;    
//      i++;    
//  }                                                     
  //表示切割成功    
  return 0;    
}

main函数内部这样去调用分割函数

int n = split(commondstr, argv);
    //等于0表示切割成功
    if(n != 0) continue;
    //DebugPrint(argv);

我们再设计一个函数来打印我们切割的结果,查看我们切割的结果是否正确:

void DebugPrint(char* argv[])
{
  for(int i = 0; argv[i]; ++i)
  {
    printf("%d : %s\n", i, argv[i]);
  }
}

运行结果:

④子进程借用分割的结果来替换程序

因为我们用split函数将命令行分装到argv字符串指针数组内部了,所以我们只能用带v的加载函数。

另外因为我们不能固定路径,所以我们也只能用带p的。

所以综上:我们的加载函数就选择到了execvp函数:

在子进程内部调用:

if(id == 0)    
    {    
      //child    
      execvp(argv[0], argv);    
      exit(0);    
    }

那么这时候我们在运行一下:


⑤优化:

我们看到我们在用bash提供的ls的时候,它产生的结果是带有颜色的。

但是我们自己实现的简易Shell是没有颜色的,那么这到底是为什么?

我们which ls查看一下,原来系统在ls后边面追加了一个参数--color==auto;

那么我们也可以对我们的简易Shell进行一些优化让他支持这样的显示:

我们只需要在代码中特判一下即可:

if(strcmp(argv[0], "ls") == 0)    
    {    
      //先找到末尾    
      int pos  = 0;    
      while(argv[pos]) pos++;    
      //追加color参数    
      argv[pos] = (char*)"--color=auto";    
      //安全处理    
      pos++;    
      argv[pos] = NULL;                                                                                                                
    }

运行效果:


⑥内建命令(重要)

(1)内建命令的概念:

—>首先我们先明确一下内建命令/内置命令的概念,就是让我们bash自己执行的命令,我们称之为内建命令/内置命令。

(2)cd命令

当我们在我们的简易Shell中切换目录时:

我们发现不论我们怎么切换目录,结果都是目录没有变化,**原因是我们是在子进程中运行这些命令行的,**进程具有独立性。其实我们切换目录是切换了子进程的目录,但是父进程也就是我们pwd显示的目录却没有任何变化,并且这里其实pwd的也是子进程的当前目录,但是因为子进程在执行完cd命令后,就被exit了。当我们再执行pwd的时候是一个新的子进程在帮我们完成这个命令,因为我们之前cd没有改变父进程的当前目录,那么新创建的子进程的目录也就变成了和父进程一样的,所以看起来我们就是没有改变当前目录一样。

所以这里的cd命令,我们要在父进程中交给一个函数chdir()来让我们的bash来执行:

代码:

//当我们输入cd命令的时候    
    if(strcmp(argv[0], "cd") == 0)    
    {    
      if(argv[1] != NULL) chdir(argv[1]);                                                                                              
      continue;    
    }

运行结果:

(3)export命令

此外不止我们的cd,包括我们当时去在bash中执行我们的export添加环境变量的时候,实际上是添加到我们的bash内部的,那么如果我们的简易Shell去把这个命令交给我们的子进程去执行了,那么就不太合适了,应该让我们的父进程自行去执行这个命令!

所以我们依旧采用内建命令的方式:

//当我们输入export命令时    
    if(strcmp(argv[0], "export") == 0)    
    {    
      //我们把这个环境变量存储在我们自己设定的数组内部    
      if(argv[1] != NULL)    
      {    
        strcpy(myenv[env_index], argv[1]);    
        //再将数组内部的环境变量放到父进程的环境变量中    
        putenv(myenv[env_index++]);    
      }    
    }

我们尝试测试一下:

最终我们找到了

但是我们的env打印的好像是子进程的环境变量,这似乎不是我们想要的,我们应该想要的是父进程的环境变量,所以我们再做一下处理:

我们自行实现一个函数去打印我们的环境变量:

void PrintEnv()
  {
      extern char **environ;
      for(int i = 0; environ[i]; ++i)
      {
        printf("%d:%s\n",i, environ[i]);
      }
  }
  //当我们查看环境变量的时候
    if(strcmp(argv[0], "env") == 0)
    {
      PrintEnv();
      continue; 
    }

运行效果:

所以其实我们之前学习的几乎所有的环境变量,相关的命令都是内建命令

我们在将echo支持成内建命令:

//当我们echo的时候
    if(strcmp(argv[0], "echo") == 0)
    {
      //先确认一下echo后面第一个跟的是$
      if(argv[1][0] == '$')
      {
        char* env_ret = getenv(argv[1] + 1);                                                                                           
        if(env_ret != NULL)
        {
          printf("%s=%s\n", argv[1] + 1, env_ret);
        }
      }
      continue;
    }

运行结果:

既然支持了环境变量的查询,我们再来顺便支持一下进程退出码的支持,也就是我们的echo $?

//当我们echo的时候    
    if(strcmp(argv[0], "echo") == 0)    
    {    
      //先确认一下echo后面第一个跟的是$                                                                                                
      if(argv[1][0] == '$')    
      {    
        if(argv[1][1] == '?')    
        {    
          printf("%d\n", last_exit);      
          continue;    
        }    
        else    
        {    
          char* env_ret = getenv(argv[1] + 1);    
          if(env_ret != NULL)  printf("%s=%s \n", argv[1] + 1, env_ret);    
        }    
      }  
    int status = 0;
    pid_t ret  = waitpid(id, &status, 0);
    if(ret > 0)
    {                                                                                                                                  
      last_exit = WEXITSTATUS(status);//last_exit我们放在main函数里但不要放在循环里,他要长期保留。
    }

测试结果:

⑦代码汇总:

#include<stdio.h>
#include<unistd.h>
#include<assert.h>
#include<string.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/wait.h>
//因为命令行最长支持到1024
#define MAX 1024
//限制最多切割为64段
#define ARGC 64
#define SEP " "
int split(char* commondstr, char* argv[])                                                           
{
  assert(commondstr);
  assert(argv);
  argv[0] = strtok(commondstr, SEP);
  int i = 1;
  while((argv[i++] = strtok(NULL, SEP)));
//  {
//      argv[i] = strtok(NULL, SEP);                                                                                                   
//      if(argv[i] == NULL) break;
//      i++;
//  }
  //表示切割成功
  return 0;
}
void PrintEnv()
{
  extern char **environ;
  for(int i = 0; environ[i]; ++i)
  {
    printf("%d:%s\n",i, environ[i]);
  }
}
void DebugPrint(char* argv[])
{
  for(int i = 0; argv[i]; ++i)
  {                                                                                    
    printf("%d : %s\n", i, argv[i]);
  }
}
int main()
{
  int last_exit = 0; //存储上一个进程的退出码
  int env_index = 0; //环境变量数组的下标
  char myenv[32][64];
  while(1)
  {
    //每次进来都初始化一下
    char commondstr[MAX] = {0};
    char* argv[ARGC] = {NULL};
    printf("[xupt@my_machine currpath]#");
    fflush(stdout);
    //这里因为我们不能加换行,所以得刷新缓冲区
    char* s = fgets(commondstr, sizeof(commondstr), stdin);                                                                            
    assert(s);
    (void)s;//保证在release发布的时候,因为assert去掉,而导致s没有被使用过而产生的告警,什么都没做,充当一次使用
    commondstr[strlen(commondstr) - 1] = '\0'; //解决了fgets读入换行符的问题
    int n = split(commondstr, argv);
    //等于0表示切割成功
    if(n != 0) continue;
    //DebugPrint(argv);
    //当我们输入export命令时
    if(strcmp(argv[0], "export") == 0)
    {
      //我们把这个环境变量存储在我们自己设定的数组内部
      if(argv[1] != NULL)
        strcpy(myenv[env_index], argv[1]);                                                                                             
        //再将数组内部的环境变量放到父进程的环境变量中
        putenv(myenv[env_index++]);
      }
    }
    //当我们查看环境变量的时候
    if(strcmp(argv[0], "env") == 0)
    {
      PrintEnv();
      continue; 
    }
    //当我们echo的时候
    if(strcmp(argv[0], "echo") == 0)
    {
      //先确认一下echo后面第一个跟的是$
      if(argv[1][0] == '$')
      {                                                                                                                                
        if(argv[1][1] == '?')
        {
          printf("%d\n", last_exit);  
          continue;
        }
        else
        {
          char* env_ret = getenv(argv[1] + 1);
          if(env_ret != NULL)  printf("%s=%s \n", argv[1] + 1, env_ret);
        }
      }
      continue;
    }
    //当我们输入cd命令的时候
    if(strcmp(argv[0], "cd") == 0)
    {
      if(argv[1] != NULL) chdir(argv[1]);
      continue;
    }                                                                                                                                  
    //当我们输入ls命令的时候
    if(strcmp(argv[0], "ls") == 0)
    {
      //先找到末尾
      int pos  = 0;
      while(argv[pos]) pos++;
      //追加color参数
      argv[pos] = (char*)"--color=auto";
      //安全处理
      pos++;
      argv[pos] = NULL;
    }
    pid_t id = fork();
    assert(id >= 0);
    (void) id; //和上面的处理原因一样
    if(id == 0)                                                                                                                        
    {
      //child
      execvp(argv[0], argv);
      exit(0);
    }
    int status = 0;
    pid_t ret  = waitpid(id, &status, 0);
    if(ret > 0)
    {
      last_exit = WEXITSTATUS(status);
    } 
   // printf("%s\n", commondstr);
  }                         
  return 0;
}

到这本篇博客的内容就到此结束了。
如果觉得本篇博客内容对你有所帮助的话,可以点赞,收藏,顺便关注一下!
如果文章内容有错误,欢迎在评论区指正

相关文章
|
2月前
|
Ubuntu Linux
Ubuntu 23.04 用上 Linux 6.2 内核,预计下放到 22.04 LTS 版本
Linux 6.2 带来了多项内容更新,修复了 AMD 锐龙处理器设备在启用 fTPM 后的运行卡顿问题,还增强了文件系统。
|
2月前
|
Ubuntu Linux
Ubuntu24.04LTS默认采用Linux 6.8内核,实验性版本可通过PPA获得
IT之家提醒,当下的 Ubuntu 23.10 也是一个“短期支持版本”,该版本将在今年 7 月终止支持,而今年 4 月推出的 Ubuntu 24.04 LTS 长期支持版本将获得 5 年的更新支持。
|
27天前
|
存储 安全 Unix
七、Linux Shell 与脚本基础
别再一遍遍地敲重复的命令了,把它们写进Shell脚本,就能一键搞定。脚本本质上就是个存着一堆命令的文本文件,但要让它“活”起来,有几个关键点:文件开头最好用#!/usr/bin/env bash来指定解释器,并用chmod +x给它执行权限。执行时也有讲究:./script.sh是在一个新“房间”(子Shell)里跑,不影响你;而source script.sh是在当前“房间”里跑,适合用来加载环境变量和配置文件。
306 9
|
27天前
|
存储 Shell Linux
八、Linux Shell 脚本:变量与字符串
Shell脚本里的变量就像一个个贴着标签的“箱子”。装东西(赋值)时,=两边千万不能有空格。用单引号''装进去的东西会原封不动,用双引号""则会让里面的$变量先“变身”再装箱。默认箱子只能在当前“房间”(Shell进程)用,想让隔壁房间(子进程)也能看到,就得给箱子盖个export的“出口”戳。此外,Shell还自带了$?(上条命令的成绩单)和$1(别人递进来的第一个包裹)等许多特殊箱子,非常有用。
168 2
|
1月前
|
算法 Linux Shell
Linux实用技能:打包压缩、热键、Shell与权限管理
本文详解Linux打包压缩技巧、常用命令与原理,涵盖.zip与.tgz格式操作、跨系统传文件方法、Shell运行机制及权限管理,助你高效使用Linux系统。
Linux实用技能:打包压缩、热键、Shell与权限管理
|
3月前
|
Web App开发 缓存 安全
Linux一键清理系统垃圾:释放30GB空间的Shell脚本实战​
这篇博客介绍了一个实用的Linux系统盘清理脚本,主要功能包括: 安全权限检查和旧内核清理,保留当前使用内核 7天以上日志文件清理和系统日志压缩 浏览器缓存(Chrome/Firefox)、APT缓存、临时文件清理 智能清理Snap旧版本和Docker无用数据 提供磁盘空间使用前后对比和大文件查找功能 脚本采用交互式设计确保安全性,适合定期维护开发环境、服务器和个人电脑。文章详细解析了脚本的关键功能代码,并给出了使用建议。完整脚本已开源,用户可根据需求自定义调整清理策略。
342 1
|
2月前
|
Ubuntu 安全 小程序
linux|ubuntu.v18.10版本即将发布,linux桌面让您动心
如果你使用闭源系统,那永远也就别想了!有了这样的需求,也许最终将linux带到人类大众通用市场的是我们中国!
68 0
|
2月前
|
Web App开发 Ubuntu Linux
又该换Linux版本了!
如果你经常用谷歌搜索,使用终端输入命令,推荐你使用Fedora而不是Ubuntu。 如果你不是一个技术用户或程序员,仍推荐使用Ubuntu,还不动手去试试,别忘了将你的体验留在评论区哦~
|
3月前
|
Linux Docker Windows
windows docker安装报错适用于 Linux 的 Windows 子系统必须更新到最新版本才能继续。可通过运行 “wsl.exe --update” 进行更新。
适用于 Linux 的 Windows 子系统需更新至最新版本(如 wsl.2.4.11.0.x64.msi)以解决 2025 年 Windows 更新后可能出现的兼容性问题。用户可通过运行 “wsl.exe --update” 或访问提供的链接下载升级包进行更新。
1101 0