实现自己的 shell

已于 2023-03-29 22:40:08 修改
阅读量190 收藏 2
点赞数 2
分类专栏： ZMR.c 文章标签： linux c语言 经验分享
于 2023-03-29 22:13:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74056357/article/details/129845755
版权

目录

TASK

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

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

要求：

  • 不得出现内存泄漏，内存越界等错误
  • 学会如何使用 gdb 进行调试，使用 valgrind 等工具进行检测

Example

xxx@xxx ~ $ ./xxx-super-shell
xxx@xxx ~ $ echo ABCDEF
xxx@xxx ~ $ echo ABCDEF > ./1.txt
xxx@xxx ~ $ cat 1.txt
xxx@xxx ~ $ ls -t >> 1.txt
xxx@xxx ~ $ ls -a -l | grep abc | wc -l > 2.txt
xxx@xxx ~ $ python < ./1.py | wc -c
xxx@xxx ~ $ mkdir test_dir
xxx@xxx ~/test_dir $ cd test_dir
xxx@xxx ~ $ cd -
xxx@xxx ~/test_dir $ cd -
xxx@xxx ~ $ ./xxx-super-shell # shell 中嵌套 shell
xxx@xxx ~ $ exit
xxx@xxx ~ $ exit

注：
示例请参考 Bash、Zsh 命令

代码

main

int main()
{
    //屏蔽信号
    signal(SIGINT, SIG_IGN);//用户在终端上按下 Ctrl-C 键触发的中断信号
    signal(SIGHUP, SIG_IGN);//由终端关闭或会话结束时触发的挂起信号
    while (1)
    {
        memset(has, 0, sizeof(has_));
        prompt(); // 打印提示符$
        getcwd(path, MAX_PATH_LENGTH);
        char cmd[MAX_COMMAND_LENGTH]; // 存一整行命令
        fgets(cmd, MAX_COMMAND_LENGTH, stdin);
        Split_command(cmd);
        has_(cmd);
        parse_command(argv, argc);
        printf("\n");
    }
}

打印提示符

void prompt(void)
{
    // 打印提示符和当前路径
    printf("zmr-super-shell:%s$ ", getcwd(path, MAX_PATH_LENGTH));
    fflush(stdout); // 清空标准输出缓冲区，确保之前的输出内容被立即写入到输出设备中，如果不清空缓冲区，可能会导致输出的内容不及时或不完整
}

分割命令 strtok()

void Split_command(char *cmd)
{
    argv[0] = strtok(cmd, SEP);
    int i = 1;
    while (argv[i] = strtok(NULL, SEP))
    {
        i++;
    }
    argc = i;          // 命令数
    argv[argc] = NULL; // argv[argc-1]存最后一个命令
}

看看有啥命令参数

void has_(char *cmd)
{
    if (argv[0] == NULL)
    {
        return;
    }

    // 内部命令
    if (strcmp(argv[0], "cd") == 0)
    {
        has[cd_]++;
    }
    else if (strcmp(argv[0], "echo") == 0)
    {
        has[echo_]++;
    }
    else if (strcmp(argv[0], "exit") == 0)
    {
        has[exit_]++;
    }

    // 外部命令
    int i;
    for (i = 0; i < argc; i++)
    {
        if (strcmp(argv[i], ">") == 0)
        {
            has[output]++;
        }
        if (strcmp(argv[i], ">>") == 0)
        {
            has[append_output]++;
        }
        if (strcmp(argv[i], "<") == 0)
        {
            has[input]++;
        }
        if (strcmp(argv[i], "&") == 0)
        {
            has[Background_running]++;
        }
        if (strcmp(argv[i], "&") == 0)
        {
            has[pipeline]++;
        }
        if (strcmp(argv[i], "ls") == 0)
        {
            has[ls_]++;
        }
    }
}

解析命令

  • 根据有的东东(><>>|cd&)来调用相应的函数
void parse_command(char *argv[], int argc)
{
    // 内部
    if (has[cd_])
    {
        mycd(argv);
    }
    if (has[echo_])
    {
        // 好像不需要？
    }
    if (has[exit_])
    {
        exit(0);
    }

    // 外部
    if (has[output])
    {
        myOutRe(argv);
    }
    if (has[append_output])
    {
        myOutRePlus(argv);
    }
    if (has[input])
    {
        myInRe(argv);
    }
    if (has[pipeline])
    {
        myPipe(argv, argc);
    }
    if (has[ls_])
    {
        myls(argv);
    }
}

cd

void mycd(char *argv[])
{
    // 处理 cd - 命令，切换到上一个工作路径
    if (strcmp(argv[1], "-") == 0)
    {
                                 // getenv()函数是一个C标准库中的函数，用于获取环境变量列表中相应变量的值
        chdir(getenv("OLDPWD")); // 将当前工作目录更改为之前的工作目录。使用了getenv()获取OLDPWD的值，然后将其作为参数传递给chdir()
                                 // “OLDPWD”，它是一个Shell内置环境变量，表示之前的工作目录
        getcwd(path, MAX_PATH_LENGTH);
        printf("%s\n", path); // 要先把切换后的路径打印一下
    }
    // 处理 cd 命令没有参数或cd ~ 的情况，切换到用户主目录
    else if (strcmp(argv[1], "~") == 0 || argv[1] == NULL)
    {
        chdir(getenv("HOME"));
        getcwd(path, MAX_PATH_LENGTH);
    }
    // 处理普通 cd 命令，切换到指定路径
    else
    {
        chdir(argv[1]);
        getcwd(path, MAX_PATH_LENGTH);
    }

    return;
}

>

void myOutRe(char *argv[])
{
    char file_name[MAX];
    char *arg[MAX_ARGS];
    int i;
    for (i = 0; i < argc; i++)
    {
        arg[i] = argv[i];
        if (strcmp(argv[i], ">") == 0)
        {
            strcpy(file_name, argv[i + 1]); // 第i+1个就是文件名了
            arg[i] = NULL;                  // 把第i个存的>给置为NULL
            break;
        }
    }

    int cmd_num = i;                                              // arg中的命令个数,ls -a > 1.txt记的命令个数是2
    int fdout = dup(1);                                           // 让标准输出获取一个新的文件描述符，（ 标准输入、标准输出和标准错误输出默认分别使用文件描述符 0、1 和 2 ）
    int fd = open(file_name, O_WRONLY | O_CREAT | O_TRUNC, 0666); // 函数调用打开了一个文件名为file_name的文件，打开模式为只写模式（O_WRONLY），如果文件不存在则创建这个文件（O_CREAT），如果文件已经存在则将其长度截断为零（O_TRUNC），文件权限设置为 0666
    dup2(fd, 1);                                                  // 将文件描述符 fd 复制到标准输出的文件描述符 1 中，实现了标准输出的重定向。此时，所有输出到标准输出的内容都会被重定向到打开的文件中

    pid_t pid = fork();
    if (pid < 0)
    {
        perror("fork()");
        exit(1);
    }
    else if (pid == 0)
    {
        if (has[pipeline])
        { // 有管道时
            myPipe(arg, cmd_num);
        }
        else
        {
            execvp(arg[0], arg);
            perror("execvp()");
            exit(1);
        }
    }
    else
    {
        waitpid(pid, NULL, 0); // 等待指定进程 pid 结束，并在子进程完成后立即返回。其中，status 参数被设置为 NULL，表示不关心子进程的退出状态，而 options 参数被设置为 0，表示没有特殊选项。
    }

    dup2(fdout, 1); // 将标准输出文件描述符恢复到原来的设置，以确保后续输出能够正常显示在终端上
    close(fd);
}

>>

void myOutRePlus(char *argv[])
{
    char file_name[MAX];
    char *arg[MAX_ARGS];
    int i;
    for (i = 0; i < argc; i++)
    {
        arg[i] = argv[i];
        if (strcmp(argv[i], ">>") == 0)
        {
            strcpy(file_name, argv[i + 1]);
            arg[i] = NULL;
            break;
        }
    }

    int cmd_num = i;
    int fdout = dup(1);
    int fd = open(file_name, O_WRONLY | O_CREAT | O_APPEND, 0666); // O_APPEND ：在写入文件时将数据追加到文件末尾
    dup2(fd, 1);

    pid_t pid = fork();
    if (pid < 0)
    {
        perror("fork()");
        exit(1);
    }
    else if (pid == 0)
    {
        if (has[pipeline])
        { // 有管道时
            myPipe(arg, cmd_num);
        }
        else
        {
            execvp(arg[0], arg);
            perror("execvp()");
            exit(1);
        }
    }
    else
    {
        waitpid(pid, NULL, 0);
    }

    dup2(fdout, 1);
    close(fd);
}

<

void myInRe(char *argv[])
{
    char file_name[MAX];
    char *arg[MAX_ARGS];
    int i;
    for (i = 0; i < argc; i++)
    {
        arg[i] = argv[i];
        if (strcmp(argv[i], ">>") == 0)
        {
            strcpy(file_name, argv[i + 1]);
            arg[i] = NULL;
            break;
        }
    }

    int cmd_num = i;
    int fdin = dup(0);                        // 标准输入使用文件描述符 0
    int fd = open(file_name, O_RDONLY, 0666); // O_RDONLY ：表示以只读模式打开文件
    dup2(fd, 0);

    pid_t pid = fork();
    if (pid < 0)
    {
        perror("fork()");
        exit(1);
    }
    else if (pid == 0)
    {
        if (has[pipeline])
        { // 有管道时
            myPipe(arg, cmd_num);
        }
        else
        {
            execvp(arg[0], arg);
            perror("execvp()");
            exit(1);
        }
    }
    else
    {
        waitpid(pid, NULL, 0);
    }

    dup2(fdin, 0);
    close(fd);
}

管道 |

思路

该函数实现了管道命令的功能。它将命令分割成多个子命令，并创建对应的子进程。子进程中对管道的读写端进行操作，连接多个子进程，实现管道的功能。具体解析如下：

  1. 首先统计命令中的管道数量和子命令数量，分别置于变量pipe_num和cmd_num之中。

  2. 以二维数组cmd[cmd_num][MAX_ARGS]的形式存储分割后的子命令。分割规则如下：

    • 对于第一个子命令，从argv[0]开始读取，一直到第一个“|”为止。

    • 对于中间的子命令，从前一个“|”之后的一个命令开始读取，一直到下一个“|”为止。

    • 对于最后一个子命令，从最后一个“|”之后的一个命令开始读取，一直到argv[argc-1]为止。

  3. 根据管道数量创建对应数量的管道，并将管道的读写端分别存储在fd[pipe_num][2]数组中。

  4. 创建多个子进程。

    • 对于第一个子进程，重定向其标准输出到第一个管道的写入端，关闭其他管道的读写端。
    • 对于最后一个子进程，重定向其标准输入到最后一个管道的读取端，关闭其他管道的读写端。
    • 对于中间的子进程，重定向其标准输入到前一个管道的读端，重定向其标准输出到后一个管道的写端，关闭除前后两个管道以外的其他管道的读写端。

  5. 在子进程中执行对应的命令。

  6. 在父进程中关闭所有管道的读写端，并等待所有子进程完成。

多管协调

在这里插入图片描述

void myPipe(char *argv[], int argc) // ls -a 算两个命令
{
    int i, j;
    int pipe_num = 0; // 记录管道数
    int cmd_num = 0;  // 记录命令个数  ls -a 算一个命令
    // cmd_num=has[pipeline];  --->不能直接将命令里的所有管道给统计起来，因为><>>函数里有调用该函数，传入的参数为存><>>前面的命令的数组arg及数组里的命令个数ls -a 算两个命令,而cmd_num中ls -a 算一个命令
    int index[8]; // 记录管道在命令中的位置，好分割命令，最大管道数为8
    for (i = 0; i < argc; i++)
    {
        if (strcmp(argv[i], "|") == 0)
        {
            index[i]++;
            pipe_num++;
        }
    }
    cmd_num = pipe_num + 1;

    char *cmd[cmd_num][MAX_ARGS]; // 装命令的数组 ls -a | grep abc | wc -l > 1.txt 中ls -a装在cmd[0]里面，ls、-a分别装在cmd[0][0]、cmd[0][1]里面
    for (i = 0; i < cmd_num; i++)
    {
        if (i == 0) // 第一个命令
        {
            int n = 0;
            for (int j = 0; j < index[i]; j++)
            {
                cmd[i][n++] = argv[j];
            }
            cmd[i][n] = NULL;
        }
        else if (i == cmd_num - 1) // 最后一个命令
        {
            int n = 0;
            for (int j = index[i - 1] + 1; j < cmd_num - 1; j++)
            {
                cmd[i][n++] = argv[j];
            }
            cmd[i][n] = NULL;
        }
        else
        {
            int n = 0;
            for (int j = index[i - 1] + 1; j < index[i]; j++)
            {
                cmd[i][n++] = argv[j];
            }
            cmd[i][n] = NULL;
        }
    }

    int fd[pipe_num][2];           // 管道描述符，pipe_num个管道，就有这么多对描述符
    for (i = 0; i < pipe_num; i++) // 根据管道数量创建管道
    {
        pipe(fd[i]);
    }

    pid_t pid;
    for (i = 0; i < cmd_num; i++)
    {
        pid = fork();
        if (pid == 0) // 因为要创建多个并列的子进程而不是五代同堂
            break;
    }

    if (pid < 0)
    {
        perror("fork()");
        exit(1);
    }

    // 子进程
    else if (pid == 0 && pipe_num > 0)
    {
        if (i == 0) // 第一个管道（子进程）
        {
            dup2(fd[0][1], 1);             // 子进程的标准输出被重定向到第一个管道的写入端
            close(fd[0][0]);               // 关闭读端
            for (j = 1; j < pipe_num; j++) // 将其他管道读写端全部关闭，可以避免不必要的资源浪费，提高程序的效率。如果不关闭其他管道的读写端，当程序执行到读写其他管道时，由于这些管道的读写端没有被关闭，就会出现无法预料的行为，导致程序出错或崩溃
            {
                close(fd[j][1]);
                close(fd[j][0]);
            }
        }
        else if (i == pipe_num) // 最后一个管道（子进程）
        {
            dup2(fd[pipe_num - 1][0], 0); // 子进程的标准输入被重定向到最后一个管道的读取端
            close(fd[pipe_num - 1][1]);   // 关闭写端
            for (j = 0; j < pipe_num - 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 (j = 0; j < pipe_num; j++)
            {
                if (j != i - 1 && j != i)
                {
                    close(fd[j][0]);
                    close(fd[j][1]);
                }
            }
        }

        execvp(cmd[i][0], cmd[i]);
        perror("execvp()");
        exit(1);
    }

    // 父进程
    else if (pid > 0)
    {
        for (i = 0; i < pipe_num; i++)
        { // 父进程创完子进程后就把所有读写端给关了
            close(fd[i][0]);
            close(fd[i][i]);
        }
        for (i = 0; i < cmd_num; i++) // 父进程等待子进程
        {
            waitpid(pid, NULL, 0);
        }
    }
}

ls

void myls(char *argv[])
{
    pid_t pid = fork();
    if (pid < 0)
    {
        perror("fork()");
        exit(1);
    }
    else if (pid == 0)
    {
        execvp(argv[0], argv);
        perror("execvp()");
        exit(1);
    }
    else
    {
        // if(has[Background_running]){   //有&时
        //     has[Background_running]=0;
        //     printf("%d\n",pid);
        //     return ;
        // }
        waitpid(pid, NULL, 0);
    }
}
JINGZMR
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LinuxC实战—myshell（cd内置命令，重定向，管道，屏蔽ctrl+c，自动补全，移动光标，命令切换，ls自带颜色）
RandyLambert的博客
07-27 711
实现屏蔽^c信号，只要这一行代码 signal(SIGINT,SIG_IGN); 补全功能和移动光标，命令切换____readline库 自动补全这个功能需要用Readline 库 ,没有的话需要安装，至于如何使用readline推荐这篇帖子点一点 sudo apt-get install libreadline6-dev 因为readline 是动态链接库 所以 ,编译的时候 需要加...
综合实例：用C语言实现一个自定义的shell程序
热门推荐
str999_cn的专栏
12-03 1万+
一个shell需要实现若干功能，首先对要实现的功能做一个简要介绍：       （1）输出重定向：就是把执行某命令后的结果输出到某个文件。例如： ls -al > list.txt       （2）输入重定向：这里的，而是从文件中取出数据到指定的文件中。例如： cat > newfile       上述命令将test3中的数据取出，然后输入到newfile这个文
c++自己实现shell
05-30
模拟linux的shell，用c++实现了shell的3个功能（ls，cp，pwd）
自己写一个Linux的shell程序
klay的博客
04-26 3233
Linux下的Shell程序设计 我们需要设计一个shell程序，目前实现的功能有如下： 获取当前操作系统的用户名、当前路径、以及操作权限展示为提示符 输入一系列的内部指令并执行：cd、exit、help以及无效指令 输入一系列的外部指令并执行：ps、ls执行当前路径文件等 利用管道标识符“||”将标识符的命令输出的内容作为标识符后面的命令的输入内容 利用 < 和 >进行输入输出的重...
linuxc 实现my_shell
qq_43701555的博客
07-23 338
问题 1.cd命令的实现(cd ,cd ~,cd -,cd path) 由于cd命令是shell 内建的命令,是不能调用系统的命令实现cd,所以就得手写 所用函数: char * getcwd(char * buf, size_t size); //取得当前工作目录 buf 为所取得的路径,   size为所取的大小 int chdir(const char * path); //改变当前...
linux内核实验二实现过程
lightblueme的专栏
02-05 331
linux内核实验two实现过程 #include #include #include #include #include #include #include #include #include #define normal         0 /*一般的命令*/ #define out_redirect   1 /*输出重定向*/ #define in_redirect
MyShell
MoshMode的博客
05-31 273
C语言自制shell
shell的实现
天才鸟蛋的专栏
04-29 693
今日在完成一个大作业，主要的任务是编写linux下的shell程序，这有助于我们理解什么是shell，还有其实他也渗透了linux操作系统微内核的概念，下面有几篇还不错的资料，供大家参考。 首先是一篇解析shell原理的文章，对我帮助不大，因为我还没有要编写一个完整的shell的需要，所以只是资料，略看了一下。http://files.linjian.org/articles/bash_stud
实现自己的shell
weixin_74111699的博客
03-24 235
包含头文件：#include 函数定义：int execvp(const char *file, char * const argv []);函数说明：execvp()会从环境变量所指的目录中查找符合参数 file 的文件名, 找到后执行该文件, 然后将第二个参数argv传给该执行的文件。返回值：如果执行成功则函数不会返回, 执行失败则直接返回-1.该函数可以。
shell脚本实现多彩进度条
09-15
主要介绍了shell脚本实现多彩进度条的相关资料,需要的朋友可以参考下
shell 进度条实现代码
01-20
代码如下:#!/bin/bashCOUNTER=0_R=0_C=`tput cols`_PROCEC=`tput cols`tput cup $_C $_Rprintf “[“while [ $COUNTER -lt 100 ]do COUNTER=`expr $COUNTER + 1` sleep 0.1 printf “=>” _R=`expr $_R + 1` _C...
shell实现图书管理系统
09-15
主要介绍了shell实现图书管理系统，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Linux C小项目 —— 实现自己的myshell
trb331617的博客
03-03 3298
简单的shell，其功能有：解释执行命令，支持输入输出重定向，支持管道，后台运行程序支持的命令格式：       单个命令：如 ls       带1到多个参数的命令：如ls -l /tmp       带一个输出重定向或输入重定向或管道的命令：如ls -l &gt; a, wc -c &lt; a, ls -l / | wc -c       后台运行符&amp;可加在以上各个命令的最后面，如l...
编写自己的Shell解释器-3[转]
weixin_30851867的博客
12-05 81
实现shell实例 程序主框架 主程序很简单，它在做一些必要的初始化工作之后，进入这样一个循环： u打印提示符并等待用户输入 u获取用户输入 u分析用户输入 u解释执行； 如果用户输入 logout或者 exit 之后，才退出这个循环。 用类似伪代码的形式表示如下： while(1) { pri...
编写my_shell
weixin_51259834的博客
05-05 391
编写my_shell 基本需求： 实现 管道（也就是 | ） 实现 输入输出重定向(<> >>) 实现 后台运行（ &）(ps:linuxc上的&实现其实并不是真正的后台运行，可以考虑一下为什么) 实现 内建命令（cd ） 屏蔽一些信号（如ctrl + c 不能终止） 通过设置环境变量 可以直接使用 (在任意地方都可以运行你的shell) 界面美观 进阶需求： 实现 tab补全 （提示:使用readline库） 实现内置命令history 实现光标的移动 在编写m
my_shell实现
weixin_51781547的博客
05-07 327
下面是我根据书上的my_shell实现的my_shell.涉及到一下关于进程的知识，下面我将介绍一下. 代码部分 #include<stdio.h> #include<stdlib.h> #include<unistd.h> #include<string.h> #include<sys/wait.h> #include<sys/types.h> #include<fcntl.h> #include<sys/stat.
Linux fallocate工具用于预分配或释放文件空间的块
最新发布
不积跬步，无以至千里；不积小流，无以成江海。
06-09 300
命令，您需要在具有适当权限的环境中运行它，例如通过SSH登录到Linux服务器或在Linux终端中运行。请确保指定的路径存在且可写。文件中未使用的磁盘空间。请注意，这不会改变文件的大小，只是释放了未使用的磁盘空间。之前，建议了解文件系统和存储设备的特性，以避免潜在的性能问题。是一个Linux命令行工具，用于预分配或释放文件空间的块。文件的大小截断为5MB。大于5MB的部分将被删除。文件的10MB偏移量处开始预分配5MB的磁盘空间。文件的10MB偏移量处开始的5MB磁盘空间。文件预分配10MB的磁盘空间。
嵌入式Linux系统编程 — 3.4 access、chmod和 umask函数修改文件访问权限
几度春风里的博客
06-09 920
文件的权限检查不仅讨论文件本身的权限，还需要涉及到文件所在目录的权限， 只有同时都满足了，才能通过操作系统的权限检查，进而才可以对文件进行相关操作；所以，程序当中对文件进行相关操作之前，需要先检查执行进程的用户是否对该文件拥有相应的权限。需要进行权限检查的文件路径。F_OK：检查文件是否存在R_OK：检查是否拥有读权限W_OK：检查是否拥有写权限X_OK：检查是否拥有执行权限检查项通过则返回 0，表示拥有相应的权限并且文件存在；

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值