Linux--实现一个简易的Shell（可以获取命令提示符，支持管道）

最新推荐文章于 2024-04-22 23:52:13 发布
最新推荐文章于 2024-04-22 23:52:13 发布
阅读量4.8k 收藏 47
点赞数 7
分类专栏： linux 文章标签： Shell 管道
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xu1105775448/article/details/80311274
版权

Shell的实现过程

1.从标准输入获取命令行；
2.对用户输入的命令行进行解析，解析出要执行的指令和参数；
3.创建一个子进程；
4.子进程进行程序替换，父进程等待；
5.当子进程执行完毕，父进程从wait中返回，继续下一次循环。

shell命令提示符

（1）一般的shell输入命令之前都会有命令提示符：

[root@localhost 进程替换]#

root为用户名，localhost为主机名，后面跟着的是当前目录的相对路径；
（2）所以在自己的Shell里面也可以输出这个命令提示符：
①获取用户名
getpwuid根据传入的用户ID,返回指向passwd的结构体,该结构体初始化了里面的所有成员.用户的ID通过getuid( )函数获得。

//passwd结构体
struct passwd
{
      char *pw_name;       /* 用户名*/
      char *pw_passwd;     /* 密码.*/
      __uid_t pw_uid;      /* 用户ID.*/
      __gid_t pw_gid;      /*组ID.*/
      char *pw_gecos;      /*真实名*/
      char *pw_dir;        /* 主目录.*/
      char *pw_shell;      /*使用的shell*/
};

用于获取用户名：


        struct passwd *pwd; //定义一个passwd类型的指针pwd
        pwd = getpwuid(getuid());
        pwd->pw_name;

②获取主机名：（通过gethostname函数）


//获得主机名
char hostname[100] ={0};
gethostname(hostname,sizeof(hostname));   //hostname里面存放的就是主机名

③获取相对路径
getcwd( )函数用于获取当前目录的绝对路径，但是shell里命令提示符的后面是相对路径，路径使用/进行分隔，所以最后一个/后面的内容为相对路径。

//char * strtok ( char * str, const char * delimiters );

Parse函数用于路径的切分，将路径按照”/”进行切分，将切分后的结果保存在字符串数组output里面。

void Parse(char* input, char* output[])//用于将路径进行切分，最后一个/后面为当前路径
{
    char* p = strtok(input,"/");
    int i = 0;
    while(p!= NULL)
    {
        output[i++] = p;
        p=strtok(NULL,"/");
    }
}

main函数中获取相对路径的有关代码：

 char path[100] = {0};
 getcwd(path,sizeof(path)); //getcwd获得的是绝对路径(path里面存放的是绝对路径)

 char* path2[100] = {0};                                                                                                             
 Parse(path,path2);  //Parse函数用于切分路径，将路径按照"/"进行切分

 char* path3 = NULL;  //path里面为绝对路径，将path按照/进行分割，分割的结果保存在path2里面,path3里面保存最后一个字符串，即相对路>径
 int i = 0;
 while(path2[i] !=NULL)
 {                                                                                                                             
       path3= path2[i];
       i++;
 }
从标准输入获取命令

定义一个buf数组用于存放输入的指令（指令是字符串的形式）；
在main函数中编写如下代码，用于获取命令行：

    char buf[1024] = {0};
    fgets(buf);
对用户输入的命令行进行解析

通过ParseArg函数对指令按照空格进行切分，将切分出来的单独的字符串放入output数组里面。（切分用到字符串处理函数strtok）

void ParseArg(char* input, char* output[])  //用于对输入的命令进行切分
{
    char* p = strtok(input," ");
    int output_size = 0;
    while(p != NULL)
    {
        output[output_size++] = p;
        p = strtok(NULL," ");
    }
    output[output_size] = NULL;
}

在main函数中编写如下代码：

//解析字符串，解析出指令和参数
char* argv[100] = {};
ParseArg(buf,argv);  //ParseArg函数用于对命令行进行切分，buf存放从标准输入获取的指令，argv存放解析出来的命令参数
创建一个子进程，子进程进行程序替换，父进程等待

用Exec函数进行封装，Exec函数里面创建一个子进程，子进程进行程序替换，父进程进行等待（父进程不关心子进程的退出状态，所以可以采用wait(NULL)）

void Exec(char* argv[])  //创建子进程执行进程程序替换
{
    pid_t pid = fork();
    if(pid == -1)
    {
        perror("fork()");
    }
    else if(pid == 0)
    {
        //child
        execvp(argv[0],argv);
        //execvp失败会执行下面的语句
        perror("execvp()");
        exit(0);
    }
    else
    {
        //parent                                                                                                                      
        wait(NULL);
    }
Shell简易版
#include<stdio.h>                                                                                                                  
#include<unistd.h>
#include<stdlib.h>
#include<wait.h>
#include<string.h>
#include<pwd.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<netdb.h>

void Parse(char* input, char* output[])//用于将路径进行切分，最后一个/后面为当前路径
{
    char* p = strtok(input,"/");
    int i = 0;
    while(p!= NULL)
    {
        output[i++] = p;
        p=strtok(NULL,"/");
    }
}

void ParseArg(char* input, char* output[])  //用于对输入的命令进行切分
{
    char* p = strtok(input," ");
    int output_size = 0;
    while(p != NULL)
    {
        output[output_size++] = p;
        p = strtok(NULL," ");
    }
    output[output_size] = NULL;
}

void Exec(char* argv[])  //创建子进程执行进程程序替换
{
    pid_t pid = fork();
    if(pid == -1)                                                                                                                       
    {
        perror("fork()");
    }
    else if(pid == 0)
    {
            execvp(argv[0],argv);
        //execvp失败会执行下面的语句
        perror("execvp()");
        exit(0);
    }
    else
    {
        //parent
        wait(NULL);
    }
 }

int main()
{
    while(1)
    {
        //首先显示shell提示
        //通过getuid获得用户的id,然后通过getpwuid通过用户的id查找用户的passwd数据来获取系统登录的用户名
        //获得当前路径
        char path[100] = {0};
        getcwd(path,sizeof(path)); //getcwd获得的是绝对路径(path里面存放的是绝对路径)
        char* path2[100] = {0};                                                                                                             
        Parse(path,path2);

        char* path3 = NULL;  //path里面为绝对路径，将path按照/进行分割，分割的结果保存在path2里面,path3里面保存最后一个字符串，即相对路>径
        int i = 0;                                                                                                                      
        while(path2[i] !=NULL)
        {
            path3= path2[i];
            i++;
        }

        struct passwd *pwd;
        pwd = getpwuid(getuid());

        //获得主机名
        char hostname[100] ={0};
        gethostname(hostname,sizeof(hostname));
        printf("[%s@%s %s MyShell]",pwd->pw_name,hostname,path3);
        fflush(stdout);

        //从标准输入读取字符串
        char buf[1024] = {0};
        gets(buf);

        //解析字符串，解析出指令和参数
        char* argv[100] = {};
        ParseArg(buf,argv);

        //子进程执行exec函数，将这个过程封装在Exec函数里
         Exec(argv);
    }
    return 0;
}

运行结果：（注意到自己编写的shell的命令提示符后面会带上MyShell，这是为了与自己的shell进行区分）
这里写图片描述

让Shell支持管道
管道的实现方法

1.管道”|”是将”|”左边指令的执行结果作为”|”右边的输入。
2.我们可以将一条带有”|”的指令进行分割，将管道左边指令的输出结果重定向到管道的输入（也就是管道的写端），将标准输入重定向至管道的读端。让两个进程分别执行两边重定向后的指令。

管道的具体实现

（1）首先判断一条指令是否包含管道（指令已经存放至char*的数组里面，且该数组以NULL作为结束标志）

int IsPipe(char* argv[])
{                                                                                                                                       
    int i = 0;
    while(argv[i] != NULL)
    {
        if(strcmp(argv[i], "|") == 0)
        {
            return i+1;     //i的位置是管道，则i+1就是管道的下一个命令
        }
        ++i;
    }
    return 0;
}

（2）将管道左右两边的指令进行切分,切分后的分别放入两个char*数组里，并保证每个数组以NULL作为结束标志

void ParsePipe(char* input[], char* output1[],char* output2[])//用于将input按照|进行切分，最后一个后面为当前路径                    

{
    int i = 0;
    int size1 = 0;
    int size2 = 0;
    int ret = IsPipe(input);   //ret是input数组中管道"|"的下一个位置

    while(strcmp(input[i], "|")!=0)
    {
        output1[size1++] = input[i++];
    }
    output1[size1] = NULL;  //将分割出来的两个char*数组都以NULL结尾

    int j = ret;//j指向管道的后面那个字符
    while(input[j] != NULL)
    {
        output2[size2++] = input[j++];
    }           
    output2[size2] = NULL;
}

（3）执行包含管道的指令（利用execvp函数，首先创建一个进程，让子进程创建一个管道，再创让子进程建一个子进程（孙子进程），让孙子进程执行管道左边的指令，并将输出结果重定向入管道，让子进程从执行管道右边的指令）

void ExecvPipe(char* argv1[],char* argv2[])  //argv1为左边指令及参数的数组argv2则为存放管道右边指令及参数的数组
{
    pid_t pid = fork();
    if(pid == -1)                                                                                                                       
    {                                                                                                                           
        perror("fork()");
    }
    else if(pid == 0)
    {
        //child,创建一个管道
        int fd[2];
        int ret = pipe(fd);

        if(fork() == 0 )
        {
            //子进程创建一个子进程，用于执行管道之前的命令
            close(fd[0]); //孙子进程关闭掉读端
            dup2(fd[1],1);  //将标准输出作为管道的标准输入
            execvp(argv1[0],argv1);
        }
        wait(NULL);
        close(fd[1]); //子进程关闭掉写端

        dup2(fd[0],0);   //将标准输入重定向至管道的读端
        execvp(argv2[0],argv2);
        //execvp失败会执行下面的语句
        perror("execvp()");
        exit(0);    
    }
    else
    {
        //parent
        wait(NULL);                                                                                                                     
    }
}

（4）整体代码

#include<stdio.h>                                                                                                                       
#include<unistd.h>
#include<stdlib.h>
#include<wait.h>
#include<string.h>
#include<pwd.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<netdb.h>

//用于将路径进行切分，最后一个/后面为当前路径
void Parse(char* input, char* output[])
{
    char* p = strtok(input,"/");
    int i = 0;
    while(p!= NULL)
    {
        output[i++] = p;
        p=strtok(NULL,"/");
    }
}

//用于对输入的命令进行切分
void ParseArg(char* input, char* output[])  
{
    char* p = strtok(input," ");
    int output_size = 0;
    while(p != NULL)
    {
        output[output_size++] = p;
        p = strtok(NULL," ");
    }
    output[output_size] = NULL;
}

void Exec(char* argv[])  //创建子进程执行进程程序替换
{
    pid_t pid = fork();
    if(pid == -1)                                                                                                                       
    {
        perror("fork()");
    }
    else if(pid == 0)
    {
         //child                                                                                                                         
        execvp(argv[0],argv);
        //execvp失败会执行下面的语句
        perror("execvp()");
        exit(0);
    }
    else
    {
        //parent
        wait(NULL);
    }
}

//判断指令是否包含管道
int IsPipe(char* argv[])
{
    int i = 0;
    while(argv[i] != NULL)
    {
        if(strcmp(argv[i], "|") == 0)
        {
            return i+1; //i是管道，则i+1就是管道的下一个命令
        }
        ++i;
    }
    return 0;
}

void ParsePipe(char* input[], char* output1[],char* output2[])//用于将input按照|进行切分，最后一个后面为当前路径                    

{
    int i = 0;
    int size1 = 0;
    int size2 = 0;                                                                                                                      
    int ret = IsPipe(input);

    while(strcmp(input[i], "|")!=0)
    {
        output1[size1++] = input[i++];
    }
     output1[size1] = NULL;

     int j = ret;//j指向管道的后面那个字符
     while(input[j] != NULL)
     {
         output2[size2++] = input[j++];
     }

     output2[size2] = NULL;
}


void ExecvPipe(char* argv1[],char* argv2[])
{
    pid_t pid = fork();
    if(pid == -1)
    {                                                                                                                           
        perror("fork()");
    }                                                                                                                                   
    else if(pid == 0)
    {
        //child,创建一个管道
        int fd[2];
        int ret = pipe(fd);
        if(fork() == 0 )
        {
            //子进程创建一个子进程，用于执行管道之前的命令
            close(fd[0]); //孙子进程关闭掉读端
            dup2(fd[1],1);  //将标准输出作为管道的标准输入
            execvp(argv1[0],argv1);
        }
        wait(NULL);

        close(fd[1]); //关闭掉写端
        dup2(fd[0],0);
        execvp(argv2[0],argv2);
        //execvp失败会执行下面的语句
        perror("execvp()");
        exit(0);    
    }
    else                                                                                                                                
    {
        //parent
        wait(NULL);
    }
}
int main()
{
    //获得当前路径
    while(1)
    {
        //首先显示shell提示
        //通过getuid获得用户的id,然后通过getpwuid通过用户的id查找用户的passwd数据来获取系统登录的用户名

        //获得当前路径
        char path[100] = {0};
        getcwd(path,sizeof(path)); //getcwd获得的是绝对路径(path里面存放的是绝对路径)
        char* path2[100] = {0};                                                                                                             
        Parse(path,path2);

        char* path3 = NULL;  //path里面为绝对路径，将path按照/进行分割，分割的结果保存在path2里面,path3里面保存最后一个字符串，即相对路>径                                                                                                                                      
        int i = 0;
        while(path2[i] !=NULL)
        {
            path3= path2[i];
            i++;
        }      

        struct passwd *pwd;
        pwd = getpwuid(getuid());
        //获得主机名
        char hostname[100] ={0};
        gethostname(hostname,sizeof(hostname));
        printf("[%s@%s %s MyShell]",pwd->pw_name,hostname,path3);
        fflush(stdout);

        //从标准输入读取字符串
        char buf[1024] = {0};

        //解析字符串，解析出指令和参数
        char* argv[100];
        ParseArg(buf,argv);

        //判断解析出来的字符串数组里面是否含有管道                                                                                      
        int ret1 = IsPipe(argv);
        if(ret1 > 0)
        {
            //是管道
            char* argv1[10];
            char* argv2[10];
            ParsePipe(argv,argv1,argv2);
            ExecvPipe(argv1,argv2);
        }
        else
        {
            Exec(argv);
        }
    }
    return 0;
Nicole xu
关注
  • 7
    点赞
  • 踩
  • 47
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Linux-编写一个自己的命令
在嵌入式嵌入式领域奋斗的程序猿的博客
02-27 3275
Linux-编写一个自己的命令
Linux获取命令的使用方法
pdstar的博客
09-26 806
当我们对某个指令不熟悉时，可以通过Linux提供的帮助命令来了解这个指令的使用方法。 Linux命令分为内建命令和外部命令；内建命令是shell本身自带的，外部命令是是一个可执行程序. 查看一个命令是内建命令还是外部命令的方法：type 命令名 获得外部命令的帮助信息： man [命令名或配置文件] 【使用q退出帮助文档】 获得shell内置命令的帮助信息： help [命令名] ...
linux的shell的管道的常用命令
最新发布
qq_35693377的博客
04-22 315
管道是一个缓冲区，将一个程序的标准输出到管道里，另一个程序的标准输入为管道出口。管道的语法非常简单，使用竖线符号 | 将两个命令连接起来。
Linux 编写简易shell，支持输入输出重定向
雪碧柠七的博客
05-12 793
引用前面写过的代码：https://blog.csdn.net/ihaha233/article/details/79833397将void do_execute(void)替换为新写的void do_shell()即可实现。下面先看代码：#include &lt;unistd.h&gt; #include &lt;sys/wait.h&gt; #include &lt;stdio.h&gt; #...
break,continue,exit,命令行提示符，While循环
asufeiya的博客
09-02 520
break:跳出整个循环 不会再执行循环后面的内容 continue：跳出本次循环，continue后面的代码不会执行 exit():结束程序的运行 区分： for i in range(10): # 0~9 if i == 5: #break #continue exit() print(i) print('hello') 命令提示符的实现 os.mkdir(...
Custom-Linux-Shell:编写我自己的自定义linux shell
03-14
在`Custom-Linux-Shell-master`这个压缩包中，可能包含了实现上述功能的Python源代码文件，可能包括`shell.py`这样的主程序文件，以及一些辅助函数和数据结构的定义。通过阅读和理解这些代码，你可以学习到如何用...
Linux shell
11-28
Linux Shell是操作系统与...总的来说，创建一个支持多重管道和重定向的Linux Shell是理解和掌握操作系统原理，特别是进程通信和I/O重定向的好方法。这个过程不仅锻炼了编程技巧，还加深了对Linux系统底层机制的理解。
Shell脚本实现Linux系统和进程资源监控
09-03
通过以上方法，我们可以构建一个完整的Shell脚本来全面监控Linux系统的资源使用情况，从而更好地管理和维护服务器。这种监控不仅可以帮助我们预防系统问题，还可以在问题发生时快速定位和解决，确保服务的稳定性和...
常用Linux命令总结
01-20
25. `|（管道）`：将一个命令的输出作为另一个命令的输入，实现命令的串联。 26. `yum`：包管理器，用于安装、更新和管理RPM软件包，能自动处理依赖关系。 27. `mkdir`：创建新的目录，`-p`选项可以递归创建多级...
cmd命令循环
12-25
这是一款坑人命令指令，可以把电脑死机 ，利用了cmd指令，这是你值得拥有的代码
Linux Shell笔记要点
01-11
在 Linux 中， Shell 是用户与操作系统之间的接口，它提供了一个交互式的命令行环境，用户可以通过 Shell 来执行命令、管理文件、配置系统等。 一、 Shell 简介 * Shell 是命令解释器，负责解释和执行用户输入的...
用c语言实现Linux命令ls操作
你听得到
05-16 8226
主要的流程是解析输入和调用相关的函数获得文件详细信息。 能够实现的命令格式有：ls –l (-d –R –a –I –al -ai) [filename1]([filename2] ……)。 演示效果如图所示： 代码如下： #include #include #include #include #include #include #include #inclu
shell脚本——常见的管道命令（sort、uniq、tr、cut）
橘子的博客
04-19 2211
文章目录一、sort命令1、格式2、常用选项二、uniq命令1、格式2、常用选项三、tr命令1、格式2、常用选项3、参数四、cut命令1、格式2、常用选项 一、sort命令 1、格式 sort命令可针对文本文件的内容，以行为单位来排序。 格式： sort [选项] 参数 cat file | sort 选项 2、常用选项 选项 说明 -f 忽略大小写，会将小写字母都转换为大写字母来进行比较 -b 忽略每行前面的空格 -n 按照数字进行排序 -r 反向排序 -u 等同于u
shell脚本的那点小事儿--shell脚本管道和重定向(四)
Avalanching博客
09-11 726
  内容一:shell脚本管道 分析场景:一个命令的输出作为另外一个命令的输入 语法结构: command1 | command2 内容二:输入/输出重定向 1.expr 关键字的应用 e.g: #!/bin/bash function operationAdd1() { number1=${1} number2=${2} result=`expr $n...
【linux】shell中命令替换$(cmd)和符号`cmd`
weixin_33976072的博客
01-11 372
来源：https://zhidao.baidu.com/question/485498670.html   作用： $(cmd)和`cmd`的作用是相同的,在执行一条命令时，会先将其中的 ``，或者是$() 中的语句当作命令执行一遍，再将结果加入到原命令中重新执行，例如：echo `ls`会先执行 ls 得到xx.sh等，再替换原命令为：echo xx.sh最后执行结果为xx.sh 例子： da...
命令行使用for循环依次执行多条命令
热门推荐
小仙女的博客
06-20 1万+
使用场景： 更新SAS HBA 固件，但是系统有多个sg device: ./SeaChest --scan |grep SEAG SEAGATE /dev/sg10 ST10000NM0096 ZA273EM0 E002 SEAGATE /dev/sg11 ST10000NM0096 ZA26YMJF ...
Shell 中使用管道来将输入作为参数输入到后面的指令
weixin_41921624的博客
10-26 8720
查找文件用find，grep是搜索内容，whereis是查找二进制命令的。 xargs 接受参数 -d （分隔符), -n(每次传递的参数个数），-p每次确认完整指令。   1， 查找文件并删除。三种办法： 使用xargs -https://www.cnblogs.com/wangqiguo/p/6464234.html find /etc -name *php* | xargs sud...
Linux-7(ppt文档).ppt
11-13
Linux-7(ppt文档).ppt，是一份关于Linux shell程序设计的PPT文档。其中第7讲主要介绍了控制结构，包括if语句、条件测试、case语句、while语句、until语句、for语句、break命令和continue命令、exit命令、select语句...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值