实现自己的 shell

已于 2023-03-29 21:52:01 修改
阅读量264 收藏 2
点赞数
文章标签： linux 开源
于 2023-03-29 21:20:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_74152750/article/details/129844830
版权
文章介绍了如何构建一个自定义的Linuxshell，包括解析命令行参数以支持ls和ll的别名，处理管道、输入输出重定向和后台运行的功能。同时，讨论了如何处理CD命令以及信号屏蔽（如阻止Ctrl+C中断）。代码示例展示了如何分割命令、设置后台运行标志、检查重定向状态以及执行管道。此外，还强调了避免内存错误和使用调试工具如gdb和valgrind的重要性。
摘要由CSDN通过智能技术生成

为什么实现一个自己 shell?

你是一个 Window/Android 用户，你可以直接用图形化桌面直接双击跑一个程序，没压力吧，轻松吧。
图形化工具为我们屏蔽了底层进程调用的细节。或者你是一个 Linux 用户，你喜欢用 bash 执行 grep
命令来查找文件中的内容，喜欢用 git 来提交代码，喜欢用 ls 来查看目录内容，有时你还会去使用
将多个命令一起使用：cat cat.txt | grep "smelly cat" | wc -c。作为一个 Linux Hacker，你理应
当了解这些图形化工具背后的原理，利用它实现一些更好玩的事情。

TASK

打造一个绝无伦比的 xxx-super-shell (xxx 是你的名字)，它能实现下面这些功能：

  • 实现 管道 (也就是 |)
  • 实现 输入输出重定向(也就是 < > >>)
  • 实现 后台运行（也就是 & ）
  • 实现 cd，要求支持能切换到绝对路径，相对路径和支持 cd -
  • 屏蔽一些信号（如 ctrl + c 不能终止）
  • 界面美观
  • 开发过程记录、总结、发布在个人博客中

要求：

  • 不得出现内存泄漏，内存越界等错误
  • 学会如何使用 gdb 进行调试，使用 valgrind 等工具进行检测
知识要点
  1. 懂得如何使用 shell
  2. 理解 shell 原理
  3. Linux系统编程：进程控制
  4. gdb
  5. valgrind

直接讲解代码

分割命令
void parse_args(char* line, char** args) {
    char* token = strtok(line, " \t\r\n\a");
    args[0] = token;
    int i = 1;
    if(strcmp(args[0],"ls")==0)
        {
            args[i++]=(char*)"--color=auto";
        }
        if(strcmp(args[0],"ll")==0)
        {
            args[0]=(char*)"ls";
            args[i++]=(char*)"-l";
            args[i++]=(char*)"--color=auto";
        }
    while (token != NULL) {
        token = strtok(NULL, " \t\r\n\a");
        args[i++] = token;
    }
    COUNT=i-1;
}

这里使用了string.h库中的strtok函数（详情见man手册）来分割字符串，方便之后使用execvp函数来执行命令，这里检测如果命令是ls的话，那么就加上–color=auto，这是为了让ls的结果具有颜色显示的效果，使界面更加美观。并且将ll识别为ls -l

设置后台运行与管道的标志
void parse(char *line){
    HT=false;
    PP=false;
    for(int i=0;i<strlen(line);i++){
        if(line[i]=='&'){
            HT=true;
            line[i]=' ';
        }
        if(line[i]=='|'){
            PP=true;
        }
    }
}

这里的HT和PP都是bool类型，每次进入函数都先熄灭它们两个，如果遍历命令中出现了&或|，那就点亮它们

重定向状态获取
char *CheckRedir(char *start)
{
    char *end=start+strlen(start)-1;
 
    while(end>=start)
    {
        if(*end=='>')
        {
            if(*(end-1)=='>')
            {
                redir_status=APPEND_REDIR;
                *(end-1)='\0';
                end++;
                while(*end==' ')
                    ++end;
                break;
            }
            redir_status=OUTPUT_REDIR;
            *end='\0';
            end++;
            while(*end==' ')
                ++end;
            break;
        }
        else if(*end=='<')
        {
            redir_status=INPUT_REDIR;
            *end='\0';
            end++;
            while(*end==' ')
                ++end;
            break;
        }
        else
        {
            end--;
        }
    }
    if(end>=start)
    {
        return end;
    }
    else
    {
        return NULL;
    }
}

这里先看一下我的宏

#define INPUT_REDIR 1
#define OUTPUT_REDIR 2
#define APPEND_REDIR 3
#define NONE_REDIR 0

int redir_status=NONE_REDIR;

四种状态分别表示 重定向输入，输出，追加和无重定向工作，初始化状态为无重定向工作

这里观察命令中是否存在>>,>,<等标记从而确定重定向的状态，并返回需要重定向的文件名

找管道和执行管道（初始版/笑哭）
int has_pipe(char** args, int* pipe_position) {
    for (int i = 0; args[i] != NULL; i++) {
        if (strcmp(args[i], "|") == 0) {
            *pipe_position = i;
            return 1;
        }
    }
    return 0;
}

void run_command_with_pipe(char** args1, char** args2) {
    int pipefd[2];
    if (pipe(pipefd) == -1) {
        perror("pipe");
        exit(EXIT_FAILURE);
    }

    pid_t pid1 = fork();
    if (pid1 == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

    if (pid1 == 0) {
        close(pipefd[0]);
        dup2(pipefd[1], STDOUT_FILENO);
        close(pipefd[1]);
        execvp(args1[0], args1);
        perror("execvp");
        exit(EXIT_FAILURE);
    }

    pid_t pid2 = fork();
    if (pid2 == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

    if (pid2 == 0) {
        close(pipefd[1]);
        dup2(pipefd[0], STDIN_FILENO);
        close(pipefd[0]);
        execvp(args2[0], args2);
        perror("execvp");
        exit(EXIT_FAILURE);
    }

    close(pipefd[0]);
    close(pipefd[1]);
    waitpid(pid1, NULL, 0);
    waitpid(pid2, NULL, 0);
}
执行管道
void DoPipe(char **argv, int count)
{
    pid_t pid;
    int ret[10];
    int number=0;
    for(int i=0;i<count;i++)
    {
    if(!strcmp(argv[i],"|"))
    {
        ret[number++]=i;
    }
    }
    int cmd_count=number+1;
    char* cmd[cmd_count][10];
    for(int i=0;i<cmd_count;i++)
    {
    if(i==0)
    {
        int n=0;
        for(int j=0;j<ret[i];j++)
        {
        cmd[i][n++]=argv[j];
        }
        cmd[i][n]=NULL;
    }
    else if(i==number)
    {
        int n=0;
        for(int j=ret[i-1]+1;j<count;j++)
        {
        cmd[i][n++]=argv[j];
        }
        cmd[i][n]=NULL;
    }
    else 
    {
        int n=0;
        for(int j=ret[i-1]+1;j<ret[i];j++)
        {
        cmd[i][n++]=argv[j];
        }
        cmd[i][n]=NULL;
    }
    }
    int fd[number][2];  
    for(int i=0;i<number;i++)
    {
    pipe(fd[i]);
    }
    int i=0;
    for(i=0;i<cmd_count;i++)
    {
    pid=fork();
    if(pid==0)
    break;
    }
    if(pid==0)
    {
    if(number)
    {
        if(i==0)
        {
        dup2(fd[0][1],1); 
        close(fd[0][0]);
        for(int j=1;j<number;j++)
        {
            close(fd[j][1]);
            close(fd[j][0]);
        }
        }
        else if(i==number)
        {
        dup2(fd[i-1][0],0);
        close(fd[i-1][1]);
        for(int j=0;j<number-1;j++)
        {
            close(fd[j][1]);
            close(fd[j][0]);
        }
        }
        else
        {
        dup2(fd[i-1][0],0);
        close(fd[i-1][1]);
        dup2(fd[i][1],1);
        close(fd[i][0]);
        for(int j=0;j<number;j++)
        {
                if(j!=i&&j!=(i-1))
                {
                close(fd[j][0]);
                close(fd[j][1]);
                }
        }
        }
    }
    execvp(cmd[i][0],cmd[i]);
    perror("execvp");
    exit(1);
    }
    for(i=0;i<number;i++)
    {
        close(fd[i][0]);
        close(fd[i][1]);
    }
    for(int j=0;j<cmd_count;j++)
    wait(NULL);
}
执行命令
void run_command(char** args) {
    // int pipe_position;
    // if (has_pipe(args, &pipe_position)) {
    //     char* args1[MAX_ARGS];
    //     char* args2[MAX_ARGS];
    //     memcpy(args1, args, (pipe_position) * sizeof(char*));
    //     args1[pipe_position] = NULL;
    //     memcpy(args2, &args[pipe_position + 1], (MAX_ARGS - pipe_position - 1) * sizeof(char*));
    //     run_command_with_pipe(args1, args2);
    // } 
    if(PP){
        DoPipe(args,COUNT);
    }
    else {
        pid_t pid = fork();
        if (pid == -1) {
            perror("fork");
            exit(EXIT_FAILURE);
        }
        if (pid == 0) {
            execvp(args[0], args);
            perror("execvp");
            exit(EXIT_FAILURE);
        } else {
            wait(NULL);
        }
    }
}

这里如果PP亮着就说明有管道，就执行dopipe，没有管道就是单一命令，直接fork（），子进程execvp执行命令，父进程wait就行。另外这里注释掉的是我曾经的只能处理一个管道的代码。

主函数
int main() {
    char line[MAX_LINE];
    char* args[MAX_ARGS];
    char prior[100]={'\0'};
    args[0]="\0";
    signal(SIGINT,SIG_IGN); //屏蔽ctrl+c
    int x=dup(0),y=dup(1);
    while (1) {
        printf("[dyx-super-shell]# ");
        if (fgets(line, MAX_LINE, stdin) == NULL) {
            perror("fgets");
            exit(EXIT_FAILURE);
        }
        // line=readline(line);
        if(strcmp(line,"\n")==0||!line)
            continue;
        line[strlen(line)-1]='\0';
        // add_history(line);
        parse(line);
        char *sep=CheckRedir(line);
        parse_args(line, args);
        if (args[0] == NULL) {
            continue;
        }
        if (strcmp(args[0], "exit") == 0) {
            break;
        }
        if (strcmp(args[0], "cd") == 0)
        {
            if (args[1] && strcmp(args[1], "-") == 0)
            {
                if (prior)
                {
                    char buf[100];
                    getcwd(buf, 100);
                    printf("%s\n", prior);
                    chdir(prior);
                    strcpy(prior, buf);
                }
                else
                { 
                    printf("bash: cd: OLDPWD 未设定\n");
                }
            }
            else
            {
                getcwd(prior, 100);
                chdir(args[1]);
            }
            continue;
        }
        if(HT){
                int fd=-1;
                fd=open("/dev/null",O_WRONLY);
                dup2(fd,0);
                dup2(fd,1);
                close(fd);
        }
        if(sep!=NULL)
        {
            int fd=-1;
            switch(redir_status) {
                case INPUT_REDIR:
                    fd=open(sep,O_RDONLY);
                    dup2(fd,0);
                    close(fd);
                    break;
                case OUTPUT_REDIR:
                    fd=open(sep,O_WRONLY|O_TRUNC|O_CREAT,0666);
                    dup2(fd,1);
                    close(fd);
                    break;
                case APPEND_REDIR:
                    fd=open(sep,O_WRONLY|O_APPEND|O_CREAT,0666);
                    dup2(fd,1);
                    close(fd);
                    break;
                default:
                    printf("bug?\n");
                    break;
            }
        }
        run_command(args);
        // free(line);
        // line=NULL;
        dup2(x,0);
        dup2(y,1);
    }
    return 0;
}

讲一下重要的部分

if (strcmp(args[0], "exit") == 0) {
            break;
        }
        if (strcmp(args[0], "cd") == 0)
        {
            if (args[1] && strcmp(args[1], "-") == 0)
            {
                if (prior)
                {
                    char buf[100];
                    getcwd(buf, 100);
                    printf("%s\n", prior);
                    chdir(prior);
                    strcpy(prior, buf);
                }
                else
                { 
                    printf("bash: cd: OLDPWD 未设定\n");
                }
            }
            else
            {
                getcwd(prior, 100);
                chdir(args[1]);
            }
            continue;
        }

如果命令是exit和cd，直接执行，不需要fork，这里实现cd -就是在cd前现将此时的位置存起来，下次cd - 时直接切回来

 if(sep!=NULL)
        {
            int fd=-1;
            switch(redir_status) {
                case INPUT_REDIR:
                    fd=open(sep,O_RDONLY);
                    dup2(fd,0);
                    close(fd);
                    break;
                case OUTPUT_REDIR:
                    fd=open(sep,O_WRONLY|O_TRUNC|O_CREAT,0666);
                    dup2(fd,1);
                    close(fd);
                    break;
                case APPEND_REDIR:
                    fd=open(sep,O_WRONLY|O_APPEND|O_CREAT,0666);
                    dup2(fd,1);
                    close(fd);
                    break;
                default:
                    printf("bug?\n");
                    break;
            }
        }

这里将重定向的工作做好

if(HT){
        int fd=-1;
        fd=open("/dev/null",O_WRONLY);
        dup2(fd,0);
        dup2(fd,1);
        close(fd);
}

有后台运行就重入到dev/null

源码地址：https://github.com/mejomejo/mytask/blob/main/myshell/dyx.c

参考资料
  • man 手册.
  • MichaelKerrisk.Linux/UNIX系统编程手册[M].北京:人民邮电出版社.
  • W.RichardStevens.Stephen.UNIX环境高级编程[M].第3版.戚正伟,译.北京:人民邮电出版社.
你别过来a
关注
c++自己实现shell
05-30
模拟linux的shell，用c++实现了shell的3个功能（ls，cp，pwd）
基于C语言实现shell指令的详解
01-01
源代码来自于TI开发板在ARM上实现shell命令解析第一步：构建命令实现函数和命令表1，定义结构体 和命令表 代码如下:typedef int (*pfnCmdLine)(int argc, char *argv[]);//****************************************...
实现自己的shell
weixin_59514216的博客
08-29 642
实现自己的shell
实现自己的shell（一）
Samature的博客
10-20 261
答案：调用execvp 图8.6显示了一个程序如何运行另一个程序。比如，为了运行ls -la，一个程序调用execvp（“ls”，arglist）。这里arglist是命令行的字符串数组。内核从磁盘将程序载入内存。命令参数ls -la被传给程序，然后程序开始运行。简而言之： （1）程序调用execvp （2）内核从磁盘将程序载入 （3）内核将arglist复制到进程 （4）内核调用main（argc，argv） 下面是运行ls -l的完整程序： ...
自己实现一个shell
xuruhua的博客
04-15 804
# include&lt;unistd.h&gt;# include&lt;sys/wait.h&gt;# include&lt;stdio.h&gt;# include&lt;stdlib.h&gt;# include&lt;string.h&gt;char *argv[8];int argc=0;void do_parse(char *buf){ int i; int status;...
自己的shell
running
11-24 350
相信接触过linux过，听过的人都知道linux的源代码是公开的，那么我们是不是可以看看我们平时最常用的命令是怎么实现的吧！看其实没那重要，重要的是你要裂解，然后根据自己的理解自己实现，然后和源代码做对比，学习借鉴，取长补短，那应该是一种比较好的学习方式了吧！      那我今天就来把我自己的想法写在这里！ 在写命令之前，我们都知道，命令必须在命令解释器下，才能完美的运行起来，脱离这个平台，那
C实现Linux中Shell部分命令.zip
10-21
C语言实现Linux Shell的功能是一项有趣的编程挑战，可以深入理解操作系统的工作原理。本项目旨在用C语言实现一些基本的Shell命令，如ls、rm和echo，这些都是日常操作中最常用的。 1. **ls命令**：用于列出当前目录...
在STM32上实现的简单的shell
04-10
在STM32上实现的简单的shell。只有两个功能：1，发送指定数字，运行指定函数。2，打印数字-函数对应表。核心文件只两个，不打算更新升级 开发平台：正点原子STM32F4最小系统板，HAL库，CUBEMX
用Java实现的shell
09-13
用Java实现的shell，用Java实现的shell，用Java实现的shell用Java实现的shell用Java实现的shell用Java实现的shell用Java实现的shell用Java实现的shell用Java实现的shell用Java实现的shell
Spring Boot调用 Shell 脚本实现看门狗功能
08-19
Spring Boot 调用 Shell 脚本实现看门狗功能 概述：本文主要介绍了使用 Spring Boot 调用 Shell 脚本实现看门狗功能的方法，通过实例代码详细地展示了实现过程，具有很高的参考价值。 一、什么是看门狗功能？ ...
写一个自己的shell
无聊星期三的博客
09-04 4769
shell 什么是shell？ shell就像是在linux中的一个媒婆，我们给shell命令，shell来告诉系统我们需要做什么，为我们牵线，实现调用操作系统提供给我们的接口，shell提供了你与操作系统之间通讯的方式。 shell是操作系统最外面的一层。shell管理你与操作系统之间的交互：等待你输入，向操作系统解释你的输入，并且处理各种各样的操作系统的输出结果。 下图中红圈的东西即s...
Linux实现自己的简易shell
A-HUAN的博客
08-09 476
simpleLinuxShell 可以实现Linux shell 支持显示当前工作用户名，主机名，路径；cd切换工作路径；< >重定向；| 管道/多个管道 ；History功能 源码见 https://github.com/A-HUAN/simpleLinuxShell 启动运行(原终端用户名青蓝色 Myshell为天蓝色) cd切换路径 重定向 重定向追加 双管道 hist...
在Linux下实现自己的shell
小Z的博客
04-06 712
代码 #include &lt;stdio.h&gt; #include &lt;unistd.h&gt; #include &lt;stdlib.h&gt; #include &lt;sys/wait.h&gt; char *argv[8]; int argc = 0; void do_shell() { pid_t pid; if((pid = fork()) ...
【Linux】教你实现一个简单的、属于自己的Shell
七月.cc的博客
03-28 5014
我们在Linux中使用的shell, 一般有两个 bash 和 zsh. 我们可以通过shell, 执行各种命令. 而本篇文章的主要内容, 就是实现一个简易的shell
从头实现Linux指令（一）实现自己的shell
行走
03-11 1622
本文从零实现Linux指令系列文章，其他系列文章： 从头实现Linux指令（零）序言 从头实现Linux指令（一）实现自己的shell 文章目录shell概述开始使用 Shell 项目0 练手任务1 shell 骨架1.1 REPL1.2 内部命令1.3 外部命令1.4 读入shell脚本文件1.5 重定向1.6 并发执行命令1.7 测试与运行1.8 收获与想法 shell概述 熟悉linux的人应该都对shell有一个感性的认识，大概知道它是什么~我们还可以用一些更加精确的语言给它一个定义：命令行解释器(
学习shell的好方法——编写一个自己的shell
Number_0_0的博客
02-25 1576
shell编程和写一个shell不是一回事，但如果写一次shell，再学习shell编程就简单了。 以下是本人编写的简易的交互式Shell。 需要用到的函数有：getpwuid，gethostname，getcwd #include #include #include #include #include #include #include void GetLoginNam
简易的shell实现
学代码的咸鱼的博客
12-01 3644
理解shell基本原理和自我实现一个简单shell
怎样自己实现一个shell?(干货!!!)一定要学会!!!基本原理!!!
贵在坚持,我相信只要我努力,未来肯定是美好的!
03-24 2774
实现一个简单的shell目录:shell的概念shell的实现思路讲解1.首先我们在操作Linux的时候,就是要在键盘中输入对应的指令2.解析输入信息-命令名称.运行参数3.创建一个子进程 fork4.等待子进程退出 wait代码实现/具体讲解 目录: shell的概念 这里我们就要对shell简单的理解一下: shell就是起到让用户对于内核中的内容操作的更加方便的作用! 今天我们就要实现一个简单的shell,也就是打印出一个对应的用户,我们对其内部进行操作 shell的实现思路讲解 我们今天再这.
极简shell制作
最新发布
欢迎来到阿熊的blog~~
04-28 2065
通过我们之前所学Linux知识以及C语言的知识，到目前为止，我们完全可以独立完成简易shell的制作，那么话不多说，开始今天的话题！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值