my_shell实现

于 2021-05-07 19:36:53 发布
阅读量355 收藏 2
点赞数
分类专栏： 笔记 文章标签： linux c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51781547/article/details/116479367
版权
本文详细介绍了如何实现一个简单的命令行解释器my_shell，包括输入处理、命令解析、进程创建以及重定向和管道功能。核心思想是利用exec函数族在子进程中执行命令，同时讲解了fork、chdir、dup2等系统调用的作用，以及信号处理、环境变量和文件描述符管理在进程交互中的角色。此外，还讨论了cd命令作为内置命令的特殊处理。
摘要由CSDN通过智能技术生成

下面是我根据书上的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.h>
#include<dirent.h>
#include<string.h>
#define normal 0 /*一般的命令*/
#define out_redirent 1  /*输出重定向*/
#define in_redirent 2  /*输入重定向*/
#define have_pipe 3 /*命令中有管道*/

//打印shell的提示符
void print_prompt();
//得到输入的命令
void get_input(char *);
//对输入命令进行解析
void explanin_input(char *,int *,char a[][256]);
//执行命令
void do_cmd(int ,char [][256]);
//查找命令中的可执行程序
int find_command(char *);
void cd(char*);

int main()
{

    signal(SIGINT,SIG_IGN);
    int argcount = 0;
    char arglist[100][256];
    char **arg = NULL;
    char *buf = NULL;
    buf = (char *)malloc(256);
    if(buf == NULL)
    {
        perror("malloc failed");
        exit(-1);
    }
    while(1)
    {
        memset(buf,0,256);
        print_prompt();
        get_input(buf);   // buf是以\n结尾的 
        //若输出的命令为exit就推出程序
        if(0==strcmp(buf,"exit\n"))
            break;
        argcount=0;
        explanin_input(buf,&argcount,arglist);
        if(strcmp("cd",arglist[0])!=0)
        do_cmd(argcount,arglist);
        else if(strcmp("cd",arglist[0])==0)
            cd(arglist[1]);
    }
    if(buf !=NULL)
    {
        free(buf);
        buf=NULL;
    }
    exit(0);
}
void cd(char *path)
{
    chdir(path);
}
//打印出欢迎的界面
void print_prompt()
{
    printf("my_shell$$:\n");
}
//获取用户的输出
void get_input(char *buf)
{
    int len = 0;
    int ch;
    ch = getchar();
    while(len<256 && ch != '\n')
    {
        buf[len++]=ch;
        ch = getchar();
    }
    if(256 == len)
    {
        printf("command is too long \n");
        exit(-1);
    }
    buf[len] ='\n';
    len++;
    buf[len] = '\0';
}
void explanin_input(char *buf,int *argcount,char arglist[][256])
{
    char *p=buf;
    char *q=buf;
    int number = 0;
    while(1)
    {
        if(p[0]=='\n')
            break;
        if(p[0]==' ')
            p++;
        else
        {
            q=p;
            number = 0;
            while(q[0]!=' '&&(q[0]!='\n'))
            {
                number++;
                q++;
            }
            strncpy(arglist[*argcount],p,number+1);
            arglist[*argcount][number]='\0';
            *argcount = *argcount + 1;
            p = q;
        }
    }
}
void do_cmd(int argcount,char arglist[][256])
{
    //how 用于标识命令中是否含有> < |
    // background 标识命令中是否有后台运行标识符  &
    int flag=0,how=0,background=0,status,i,fd;
    char *arg[argcount+1];    
    char *argnext[argcount+1];
    char *file;
    pid_t  pid;
    //取出命令行
    for(i=0;i<argcount;i++)
        arg[i]=arglist[i];
    arg[i]=NULL;
    //查看命令行是否有后台运行
    for(i=0;i<argcount;i++)
    {
        if(strncmp(arg[i],"&",1)==0)
        {
           if(i==argcount-1)
           {
               background = 1;
                arg[argcount -1] = NULL;
                break;
           }
           else
           {
               printf("wrong command   %d\n",__LINE__);
               return;
           }
        }
    }
    for(i = 0;arg[i]!=NULL;i++)
    {
        if(strcmp(arg[i],">")==0)
        {
            flag++;
            how = out_redirent;
            if(arg[i+1]==NULL)
                flag++;
        }
        else if(strcmp(arg[i],"<")==0)
        {
            flag++;
            how = in_redirent;
            if(i==0)
                flag++;
        }
        else if(strcmp(arg[i],"|")==0)
        {
            flag++;
            how = have_pipe;
            if(arg[i+1]==NULL)
                flag++;
            if(i==0)
                flag++;
        }
    }
    //flag 大于 1 ,说明命令中含有多个>,<,|符号，本程序不支持这样的命令
    //或者格式不对。如 ls -l /temp >
    if(flag > 1)
    {
        printf("wrong command   %d\n",__LINE__);
        return ;
    }
    if(how==out_redirent)
    {
        for(i = 0;arg[i]!=NULL;i++)
        {
            if(strcmp(arg[i],">")==0)
            {
                file = arg[i+1];
                arg[i]=NULL;
            }
        }
    }
    if(how == in_redirent)
    {
        for(i=0;arg[i]!=NULL;i++)
        {
            if(strcmp(arg[i],"<")==0)
            {
                file =arg[i+1];
                arg[i]=NULL;
            }
        }
    }
    if(how == have_pipe)
    {
        for(i=0;arg[i]!=NULL;i++)
        {
            if(strcmp(arg[i],"|")==0)
            {
            arg[i] = NULL;
            int j;
            for(j = i+1;arg[j]!=NULL;j++)
            argnext[j-i-1] =arg[j];
            argnext[j-i-1] =arg[j];
            break;
            }
        }
        
    }
    if((pid = fork())<0)
    {
        printf("%d fork error\n",__LINE__);
        return;
    }
    if(pid==0)
    {
        //子进程设置信号
        signal(SIGINT,SIG_IGN);
    }
    switch(how)
    {
        case 0:
            if(pid==0) //子进程
            {
                if(!find_command(arg[0]))
                {
                  printf("%d %s:command not found\n",__LINE__,arg[0]);
                  exit(0);  
                }
                execvp(arg[0],arg);
                exit(0);
            }
            break;
        case 1:
            //  >
            if(pid==0)
            {
                if(!(find_command(arg[0])))
                {
                    printf("%d %s :command not found\n",__LINE__,arg[0]);
                    exit(0);
                }
                fd = open(file,O_RDWR|O_CREAT|O_TRUNC,0664);
                dup2(fd,1);
                execvp(arg[0],arg);
                exit(0);

            }
            break;


        case 2:
            //输出的命令中含有重定向符号 <
            if(pid == 0)
            {
                if(!(find_command(arg[0])))
                {
                    printf("%d %s :command not found\n",__LINE__,arg[0]);
                    exit(0);
                }
            
            fd = open(file,O_RDONLY);
            dup2(fd,0);
            execvp(arg[0],arg);
            exit(0);
            }
            break;
        case 3:
            if(pid == 0)   //子进程
            {
                int pid2,status2,fd2;
                if((pid2 = fork())<0)
                {
                    printf("%d fork2 error\n",__LINE__);
                    return;
                }
                if(pid2 ==0)
                {
                    if(!(find_command(arg[0])))
                    {
                        printf("%s: command not found %d \n",arg[0],__LINE__);
                        exit(0);
                    }
                    fd2 =open("/tmp/youdonotknowfile",O_WRONLY|O_CREAT|O_TRUNC,0664);
                    dup2(fd2,1);  //子进程负责输出
                    execvp(arg[0],arg);
                    exit(0);   //字进程退出
                }
                if(waitpid(pid2,&status2,0)==-1)
                {
                    printf("wait for child process error %d\n",__LINE__);
                }
                if(!(find_command(argnext[0])))
                {
                    printf("%s :command not found  %d\n",argnext[0],__LINE__);
                }
                fd2 = open("/tmp/youdonotknowfile",O_RDONLY);
                dup2(fd2,0);  //父进程负责输入
                if(remove("/tmp/youdonotknowfile"))                                                                                                                                     		printf("remove error %d\n",__LINE__);
                execvp(argnext[0],argnext);
                exit(0);
            }
            break;
        default:
            break;

    }
    //若命令中有&，表示后台执行，父进程直接推出，不等待子进程结束
    if(background == 1)
    {
        printf("process id %d\n",pid);
        return;
    }
    //父进程等待子进程结束
   if(waitpid(pid,&status,0)==-1) 
    {
        printf("wait for child porcess error  %d\n",__LINE__);
    }

}
int find_command(char *command)
{

    DIR* dp;
    struct dirent* dirp;
    char *path[]={"./","/bin","/usr/bin",NULL};
    if(strncmp(command,"./",2)==0)
        command = command +2;
    int i = 0;
    while(path[i]!=NULL)
    {
        if((dp = opendir(path[i]))==NULL)
            printf("can not open /bin %d\n",__LINE__);
        while((dirp = readdir(dp))!=NULL)
        {
            if(strcmp(dirp->d_name,command)==0)
            {
                closedir(dp);
                return 1;
            }
        }
            closedir(dp);
            i++;
    }
    return 0;
}

核心的思想

核心的思想就是通过exec函数族来实现，当进程调用一种e x e c函数时，该进程完全由新程序代换，而新程序则从其 main函数开始执行。
因为调用exec并不创建新进程，所以前后的进程 I D并未改变。 exec只是用另一个新程序替换了
当前进程的正文、数据、堆和栈段，进程还是原来的那个进程
另外，每次我们执行输入的命令的时候，必须要fork一个进程，用子进程去执行我们输入的命令，另外，命令其实就是一个可执行的程序而已.这样的话我们的父进程就不会死掉，也就一直循环输入命令了，也就是可以一直执行可执行程序了。

exec函数族

下面是函数原型

int execl(const char * pathname, const char *arg 0, ... /* (char *) 0 */);
int execv(const char * pathname, char *const a rgv [] );
int execle(const char * pathname, const char *arg 0, ...
/* (char *)0, char *const e n v p [] */);
int execve(const char * pathname, char *const argv [], char *const envp [] );
int execlp(const char * filename, const char *arg 0, ... /* (char *) 0 */);
int execvp(const char * filename, char *const argv []

这里我们使用的是execvp函数。所以do_cond之前的部分都是在为了解析出execvp的参数，构建好参数让父进程的子进程来执行。

cd命令必须要我们自己构建

也就是会所cd命令是一个内置的命令
我们在终端下面用type判断一个命令是不是内置的命令

❯ type cd
cd is a shell builtin

可以看出来cd命令就是一个内置的命令，也就是说cd不是一个已经存在的可执行程序。
原因
如果我们要切换目录的话，要调用的函数是chdir。
因为当前工作目录是一个进程的属性，所以它只影响调用 c h d i r的进程本身，而不影响其他
进程。也就是说如果我们自己写一个cd程序出来，那么在我们cd的时候，是执行的是cd本身，程序本身的工作目录是没有改变的。

环境变量

环境变量是至关重要的东西，因为环境变量觉得了我们exec函数搜索的路径，也就是说我们的exec函数需要在环境目录里面的目录里面去找可执行程序。
另一方面，我们输入的命令其实就是程序，默认就是在环境变量的目录里面去寻找可执行的程序，换句话说，如果我们把可执行程序放到了环境变量里面，我们运行我们的可执行程序的时候就可以直接输入程序的名字了。

 echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/bin:/var/lib/flatpak/exports/bin:/usr/bin/site_perl:/usr/bin/vendor_perl:/usr/bin/core_perl

fork函数

fork函数就是要生成一个子进程，子进程的返回值为0，父进程的返回值是子进程的pid。如果生成的子进程失败，返回-1。
父进程和子进程共享文件表项,也就是说我们对文件读写的时候是可以同步，是不会出错的，还有缓冲区也是会继承的。
子进程和父进程继续执行 fork之后的指令。子进程是父进程的复制品。例如，子进程获得
父进程数据空间、堆和栈的复制品。注意，这是子进程所拥有的拷贝。父、子进程并不共享这些存储空间部分。如果正文段是只读的，则父、子进程共享正文段。
在这里插入图片描述

子进程继承的其他属性
• 实际用户I D、实际组I D、有效用户I D、有效组I D。
• 添加组I D。
• 进程组I D。
• 对话期I D。
• 控制终端。
• 设置-用户- I D标志和设置-组- I D标志。
• 当前工作目录。
• 根目录。
• 文件方式创建屏蔽字。
• 信号屏蔽和排列。
• 对任一打开文件描述符的在执行时关闭标志。
• 环境。
• 连接的共享存储段。
• 资源限制。
父、子进程之间的区别是：
• fork的返回值。
• 进程I D。
• 不同的父进程I D。
• 子进程的t m s _ u t i m e , t m s _ s t i m e , t m s _ c u t i m e以及t m s _ u s t i m e设置为0。
• 父进程设置的锁，子进程不继承。
• 子进程的未决告警被清除。
• 子进程的未决信号集设置为空集

signal函数

函数原型
#include <signal.h>
void (*signal (int signo, void (*func)(int))) (int);
signo是信号名，也就是产生的信号的名字，fanc也就是产生这个信号的时候我们的操作。signal的返回值是指向之前的信号处理程序的指针。
可以要求系统在某个信号出现时按照下列三种方式中的一种进行操作。
(1) 忽略此信号。这里的 func就是SIG_IGN
(2) 捕捉信号。func 我们自己写的函数
(3) 执行系统默认动作 。SIG_DFL 默认操作

dup和dup2函数

可以复制一个现存的文件描述符。
函数原型
#include <unistd.h>
int dup(int filedes) ;
int dup2(int filedes, int filedes2) ;
两函数的返回：若成功为新的文件描述符，若出错为- 1
由d u p返回的新文件描述符一定是当前可用文件描述符中的最小数值。用 dup2则可以用filedes 参数指定新描述符的数值。如果filede s 2已经打开，则先将其关闭。如若filedes等于filedes 2，则dup2返回filedes2，而不关闭它。这些函数返回的新文件描述符与参数filede s共享同一个文件表项。
在这里插入图片描述
也就是说当我们dup(fd,1)的时候，fd和1这个文件描述符都指向了一个文件表项。
我们就是利用这一点来实现了管道这个命令，子进程在fork一个子进程，fork之后的子进程写东西到文件里面，然后父进程读取子进程写的东西。也就是说当我们使用管道的时候，输入的左边的命令所运行的程序在这里相当于是子进程，右边的进程是父进程。

lonely eagle
关注
专栏目录
简单实现myshell
如故的博客
03-24 1018
一个简易的myshell fock函数 //fork函数 创建子进程 pid_t fork(void); execvp函数 //进程替换 int execvp(const char *file ,char * const argv []); waitpid函数 //进程等待 pid_t waitpid(pid_t pid,int * status,int options);...
my_shell实现和分析
adlatereturn的博客
05-10 888
上个月初的myshell实现让人大费脑筋，在字符串处理和多重管道上出了不少差错，但好在最后还是实现了要求的功能。真的太懒了，把博客拖到现在～ 需求一个一个分析吧 实现管道 | 这个的意思就是想要你把一个命令的输出当作输入交给后面一个命令。如ls -l | grep “a” |wc -c就是把ls -l的输出结果交给grep 处理,grep的处理结果交给wc处理。 解决方案：dup2(fd,0)重定...
my_shell 实现
m0_53313553的博客
04-13 550
MyShell 实现 一、主要函数 1.fork 被调用一次，有两个返回值。 1）在父进程中，fork返回新创建子进程的进程ID； 2）在子进程中，fork返回0； 3）如果出现错误，fork返回一个负值； fork出错可能有两种原因： 1）当前的进程数已经达到了系统规定的上限，这时errno的值被设置为EAGAIN。 2）系统内存不足，这时errno的值被设置为ENOMEM。 注： 1.每个进程都有一个独特（互不相同）的进程标识符（process ID），可以通过**getpid（）函数获得，还有
my_shell简单实现
qq_52609580的博客
04-28 324
my_shell简单实现 实现功能 实现 管道（也就是 | ） 实现 输入输出重定向(<> >>) 实现 后台运行 实现 内建命令（cd ） 屏蔽一些信号（如ctrl + c 不能终止） 通过设置环境变量 可以直接使用 (在任意地方都可以运行你的shell) 界面美观 实现 tab补全 实现内置命令history 注意 gcc 编译时需要添加动态库-lreadline vscode x修改配置文件 task.json "args": [ "${fi
编写my_shell
weixin_51259834的博客
05-05 445
编写my_shell 基本需求： 实现 管道（也就是 | ） 实现 输入输出重定向(<> >>) 实现 后台运行（ &）(ps:linuxc上的&实现其实并不是真正的后台运行，可以考虑一下为什么) 实现 内建命令（cd ） 屏蔽一些信号（如ctrl + c 不能终止） 通过设置环境变量 可以直接使用 (在任意地方都可以运行你的shell) 界面美观 进阶需求： 实现 tab补全 （提示:使用readline库） 实现内置命令history 实现光标的移动 在编写m
实现一个my_shell
李兆龙的博客
07-28 797
实现的功能 实现 输入输出重定向 (< > >>) 实现 后台运行（&） 实现 内建命令（cd） 界面美观（上色） 屏蔽部分信号(如ctrl+c) 实现管道(|) 支持 使用Tab补全、光标移动 实现 内置命令history 总结 基本功能其实都非常基础 就是在使用readline动态链接库的时候因为不熟悉出现了一些问题 其实库的使用非常简单 代码中非常清楚 ...
my_shell.cpp
08-21
操作系统原理关于文件系统的C语言二叉树方式实现。免费但请尊重原创，不得用于学术论文与商业应用。若有需要可通过私信联系
Shellbianchengjichu.rar_doc_shell_shell 编程
09-19
在Shell中，数组用于存储多个值，如`my_array=(value1 value2 value3)`。访问数组元素使用 `${my_array[索引]}`。 **六、函数** 定义函数如下： ```bash function my_function() { # 函数体 } ``` 调用函数：`my_...
Linux_Shell-programming.zip_Linux shell_linux
09-24
在Linux环境下，Shell不仅是一个交互式的命令解释器，更是一种强大的编程语言，能够实现复杂的逻辑控制和文件处理。本资料"Linux_Shell编程基础.ppt"应该包含了对这一主题的详细介绍。 首先，我们需要理解什么是...
plane.rar_Shell编程_Python_
08-11
`enemy.py`、`myplane.py`、`supply.py`和`bullet.py`分别代表敌机、玩家飞机、补给和子弹的模块，每个文件可能包含相应的类定义和行为逻辑。 2. **面向对象编程**：Python支持面向对象编程，这些模块化的`.py`文件...
MyShell:Shell的实现
04-02
我的壳牌 在C中实现Shell 要编译，请运行以下命令： gcc shell.c 要运行交互式shell，请运行以下命令： ./a.out 命令应以分号（;）分隔 要从文件运行命令，请运行以下命令： ./a.out input1-quit.bat
C语言实现：Linux下的myshell
04-27
基本功能： 1.基本的内部命令。如：cd, ls, pwd 等； 2.能处理后台程序(不需要wait) 3.具有管道和重定向功能。如输入：who | wc -l 进行测试； 4.可以处理多条命令，以';'分隔, 滤掉无效的空格、tab符等；
myshell操作系统
12-14
在ubuntu环境下编写的myshell，实现输入输出重定向和管道功能。
简单的myshell实现
DuckyLoser的博客
03-23 874
myshell.c//strtok()用来将字符串分割成一个个片段。参数s指向欲分割的字符串，参数delim则为分割字符串中包含的所有字符。//当strtok()在参数s的字符串中发现参数delim中包含的分割字符时,则会将该字符改为\0 字符。//在第一次调用时，strtok()必需给予参数s字符串，往后的调用则将参数s设置成NULL。每次调用成功则返回指向被分割出片段的指针。#include&...
实现myshell--简易版
Warrior_Harlan的博客
06-05 298
实现步骤：1.获取命令行2.解析命令行3.创建一个子进程4.替换子进程5.父进程等待回收子进程实现： #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;sys/wait.h&gt; #include &lt;unistd.h&gt; #include &lt;string.h&gt; #include &lt;...
my_shell 编写
ythunder的博客
08-02 748
本周学习了第七章,进程管理. 经过上周,发现自己的学习方法真的有些问题,之前把概念抄了一大堆,结果后来编写ls时就发现基本没有太多卵用. 本周我没有抄太多概念,而是通过看书百度以及请教小伙伴对书本内容设身处地到计算机上做尽量深的了解,编写my_shell时根据书本范例前的关键函数及思路方面的说明尽量自己编写,主要实现方式就是从得到字符串,以空格又分开存入二维数组,然后从"./"  "/bin"
myshell
weixin_44801852的博客
03-18 506
#include<stdio.h> #include<string.h> #include<stdlib.h> #include<unistd.h> #include<sys/types.h> #include<sys/wait.h> #include<readline/readline.h> #include<readline/history.h> #define MAXCOM 1000 // max num
my_shell
qin1888的博客
08-06 244
#include #include #include #include #include #include #define MAXLINE 64 int main (void) {         pid_t pid;         char buf [MAXLINE];         int status;        
模拟实现myshell
agate_zhang的博客
05-14 553
模拟实现myshell 直观地看来Linux下的Shell命令提示符：用户名@主机号 当前目录名  提示符 函数gethostname（）可以获取到当前用户的用户名 函数getcwd（） 是获得执行程序的当前路径。
dc_shell collection 去重
最新发布
06-02
在dc_shell中，可以使用"uniq"命令来实现对集合的去重。具体步骤如下： 1. 首先，将需要去重的集合从文件中读入，并将其保存到一个变量中，例如： ``` set my_set [split [read_file my_set.txt] "\n"] ``` 2. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值