my_shell 实现

最新推荐文章于 2021-05-07 19:36:53 发布
最新推荐文章于 2021-05-07 19:36:53 发布
阅读量553 收藏 2
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53313553/article/details/115360608
版权

MyShell 实现

一、主要函数

1.fork

被调用一次，有两个返回值。

1）在父进程中，fork返回新创建子进程的进程ID；
2）在子进程中，fork返回0；
3）如果出现错误，fork返回一个负值；

fork出错可能有两种原因：
1）当前的进程数已经达到了系统规定的上限，这时errno的值被设置为EAGAIN。
2）系统内存不足，这时errno的值被设置为ENOMEM。

注：
1.每个进程都有一个独特（互不相同）的进程标识符（process ID），可以通过**getpid（）函数获得，还有一个记录父进程pid的变量，可以通过getppid（）**函数获得变量的值。
2.fork的子进程有自己独立的地址空间。不论全局变量或局部变量，子进程与父进程修改互不影响。
3.读时共享，写时复制（实际内存）

2.exec

fork()函数通过系统调用创建一个与原来进程（父进程）几乎完全相同的进程（子进程是父进程的副本，它将获得父进程数据空间、堆、栈等资源的副本。注意，子进程持有的是上述存储空间的“副本”，这意味着父子进程不共享这些存储空间。linux将复制父进程的地址空间内容给子进程，因此，子进程有了独立的地址空间。），也就是这两个进程做完全相同的事。

在fork后的子进程中使用exec函数族，可以装入和运行其它程序（子进程替换原有进程，和父进程做不同的事）。

实际上，在Linux中并没有exec函数，而是有6个以exec开头的函数族，下表列举了exec函数族的6个成员函数的语法。
在这里插入图片描述
调用exec并不创建新进程，所以前后的进程ID并未改变。exec只是用一个全新的程序替换了当前进程的正文、数据、堆和栈段。

exec后新进程保持原进程以下特征:
环境变量（使用了execle、execve函数则不继承环境变量）；
Ÿ进程ID和父进程ID；
实际用户ID和实际组ID；
附加组ID；
进程组ID；
会话ID；
控制终端；
当前工作目录；
根目录；
文件权限屏蔽字；
文件锁；
进程信号屏蔽；
未决信号；
资源限制；

3.wait(阻塞）

#include <sys/types.h>
#include <wait.h>
int wait(int *status)

函数功能：
父进程一旦调用了wait就立即阻塞自己，由wait自动分析是否当前进程的某个子进程已经退出，如果让它找到了这样一个已经变成僵尸的子进程，wait就会收集这个子进程的信息，并把它彻底销毁后返回；如果没有找到这样一个子进程，wait就会一直阻塞在这里，直到有一个出现为止。

注：
当父进程忘了用wait()函数等待已终止的子进程时,子进程就会进入一种无父进程的状态,此时子进程就是僵尸进程.
wait()要与fork()配套出现,如果在使用fork()之前调用wait(),wait()的返回值则为-1,正常情况下wait()的返回值为子进程的PID.
如果先终止父进程,子进程将继续正常进行，只是它将由init进程(PID 1)继承,当子进程终止时,init进程捕获这个状态.
参数status用来保存被收集进程退出时的一些状态，它是一个指向int类型的指针。但如果我们对这个子进程是如何死掉毫不在意，只想把这个僵尸进程消灭掉，（事实上绝大多数情况下，我们都会这样想），我们就可以设定这个参数为NULL。
一次wait()只能回收一个。

4.waitpid（非阻塞）

#include <sys/wait.h>
     pid_t
       waitpid(pid_t pid, int *stat_loc, int options);

参数的四种情况：
1.pid>0时，只等待进程ID等于pid的子进程，不管其它已经有多少子进程运行结束退出了，只要指定的子进程还没有结束，waitpid就会一直等下去。
2.pid=-1时，等待任何一个子进程退出，没有任何限制，此时waitpid和wait的作用一模一样。
3.pid=0时，等待同一个进程组中的任何子进程，如果子进程已经加入了别的进程组，waitpid不会对它做任何理睬。
4.pid<-1时，等待一个指定进程组中的任何子进程，这个进程组的ID等于pid的绝对值。

options
1.options提供了一些额外的选项来控制waitpid，目前在Linux中只支持WNOHANG和WUNTRACED两个选项。
2.这是两个常数，可以用"|"运算符把它们连接起来使用，比如：
ret=waitpid(-1,NULL,WNOHANG | WUNTRACED);
3.如果我们不想使用它们，也可以把options设为0，如：
ret=waitpid(-1,NULL,0);
4.如果使用了WNOHANG(wait no hung)参数调用waitpid，即使没有子进程退出，它也会立即返回，不会像wait那样永远等下去。

如果waitpid()函数执行成功，则返回子进程的进程号；如果有错误发生，则返回-1，并且将失败的原因存放在errno变量中。

5.dup / dup2

dup2( int oldfd , int newfd )

dup2可以用参数newfd指定新文件描述符的数值，dup2调用成功，返回新的描述符。（文件描述符0代表标准输入文件，一般就是键盘; 文件描述符1代表标准输出文件，一般是显示器; 文件描述符2代表标准错误输出，一般也指显示器 ）

dup2(fd,1)的意思就是把文件描述符替换为1，因为执行命令得到的结果是会向名为1的输出流中输出得到的结果，现在将文件描述符的数值变为1,执行命令后自然就会将结果输入到文件中了。
dup2(fd,0)同理，将文件符的值变为0,命令会从名为0的输入流中读取信息。

二、管道pipe

管道是将前一个命令的输出作为后一个命令的输入

//将|左边的命令执行的结果保存至文件中，在运行|右边的命令时将再将刚刚文件中的内容传入|右边的命令去执行。
fd2 = open("/tmp/youdonotknowfile",O_WRONLY|O_TRUNC|O_CREAT,0644);            //创建临时文件保存管道符前面的操作
dup2(fd2,1);
execvp(arg[0],arg);

fd2 = open("/tmp/youdonotknowfile",O_RDONLY);
dup2(fd2,0);
execvp(argnext[0],argnext);

三、重定向

1.输入重定向

command1 > file1

上面这个命令执行command1然后将输出的内容存入file1。
注意任何file1内的已经存在的内容将被新内容替代。如果要将新内容添加在文件末尾，需使用>>操作符。

2.输出重定向

command1 < file1

这样，本来需要从键盘获取输入的命令会转移到文件读取内容。

3举例

command1 < infile > outfile

同时替换输入和输出，执行command1，从文件infile读取内容，然后将输出写入到outfile中。

四、实现代码

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<sys/types.h>
#include<sys/wait.h>
#include<fcntl.h>
#include<sys/stat.h>
#include<dirent.h>

#define normal 0         //一般
#define out_redirect 1       //输出重定向
#define in_redirect 2     //输入重定向
#define have_pipe 3     //命令中有管道


//打印myshell的提示符"myshell$$"
void print_prompt()
{
    printf("myshell@lin ");
}


//获取待执行命令,buf用于存放输入的命令
//命令过长，则终止程序，输入的命令以"\n"作为结束标志
void get_input(char* buf)
{
    int len = 0;
    char ch;

    ch=getchar();
    while(len < 256 && ch != '\n'){
        buf[len++] = ch;
        ch = getchar();
    }

    if(len == 256){
        printf("command id too long \n");
        exit(-1); //输入命令过长则退出程序
    }
    buf[len] = '\n';
    len++;
    buf[len] = '\0';
}


//解析命令，将结果存入list中
void explain_input(char *buf, int *count, char list[100][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(list [*count], p, number+1);
            list[*count][number] = '\0';
            *count = *count + 1;
            p = q;
        }
    }
}



//分别在当前目录下、/bin、/usr/bin下查找命令的可执行程序
int find_command(char* command)
{
    DIR* dp;
    struct dirent *dirp;
    char* path[ ] = {"./","/bin","/usr/bin",NULL};

    //使当前目录下的程序可运行
    if(strncmp(command,"./",2) == 0)
        command = command + 2;

    //分别在当前目录、/bin、/usr/bin目录下找要执行的程序
    int i = 0;
    while(path[i] != NULL){
        if((dp = opendir(path[i])) == NULL)
            printf("can not open /bin \n");
        while((dirp = readdir(dp)) != NULL){
            if(strcmp(dirp->d_name,command) == 0){
                closedir(dp);
                return 1;
            }
        }
        closedir(dp);
        i++;
    }
    return 0;
}

void do_cmd(int count, char list[100][256])
{
    int flag = 0;
    int how = 0;         //是否含有>/</|
    int background = 0;    //命令中是否有后台运行标识符&
    int status;
    int i;
    int fd;
    char* arg[count+1];
    char* argnext[count+1];
    char* file;
    pid_t pid;

    //输出命令
    for(i = 0; i < count; i++){
        arg[i] = (char*)list[i];
    }
    arg[count] = NULL;

    //查看命令行是否有后台运行符
    for(i=0; i<count; i++){
        if(strncmp(arg[i],"&",1) == 0){
            if(i == count-1){
                background = 1;
                arg[count - 1] = NULL;
                break;
            }
            else{
                printf("wrong command\n");
                return;
            }
        }
    }

    for(i=0; arg[i] != NULL; i++){
        if(strcmp(arg[i],">") == 0){
            flag++;
            how = out_redirect;
            if(arg[i+1] == NULL)
                flag++;
        }
        if(strcmp(arg[i],"<") == 0){
            flag++;
            how = in_redirect;
            if(i == 0)
                flag++;
        }
        if(strcmp(arg[i],"|") ==0){
            flag++;
            how = have_pipe;
            if(arg[i+1] == NULL)
                flag++;
            if(i == 0)
                flag++;
        }
    }
    //flag>1,说明含有多个< > |符号，本程序不支持
    if(flag>1){
        printf("wrong command\n");
        return;
    }
    if(how == out_redirect){
        for(i=0; arg[i] != NULL; i++){
            if(strcmp(arg[i],">") == 0){
                file = arg[i+1];
                arg[i] = NULL;
            }
        }
    }

    if(how == in_redirect){
        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];   //NULL
                break;
            }
        }
    }

    if((pid = fork()) < 0){
        printf("fork error\n");
        return;
    }

    switch(how) {
        case 0:
            //子进程，不含> < |
            if(pid == 0){
                if(!(find_command(arg[0]))){
                    printf("%s : command not found\n",arg[0]);
                    exit(0);
                }
                execvp(arg[0],arg);
                exit(0);
            }
            break;
        case 1:
            //输入命令含有输出重定向 >
            if(pid == 0){
                if(!(find_command(arg[0]))){
                    printf("%s : command not found\n",arg[0]);
                    exit(0);
                }
                fd = open(file,O_RDONLY);
                dup2(fd,1);
                execvp(arg[0],arg);
                exit(0);
            }
            break;
        case 2:
            //输入命令含有输入重定向 <
            if(pid == 0){
                if(!(find_command(arg[0]))){
                    printf("%s : command not found\n",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;
                int status2;
                int fd2;

                if((pid2 = fork()) < 0){              //子进程再次分离一个子进程
                    printf("fork2 error\n");
                    return ;
                }
                else if(pid2 == 0){
                    if(!(find_command(arg[0]))){
                        printf("%s : command not found\n",arg[0]);
                        exit(0);
                    }
                    fd2 = open("/tmp/youdonotknowfile",O_WRONLY|O_TRUNC|O_CREAT,0644);            //创建临时文件保存管道符前面的操作
                    dup2(fd2,1);
                    execvp(arg[0],arg);
                    exit(0);
                }
                if(waitpid(pid2,&status2,0) == -1)                    //确保管道符前的操作先执行完成
                    printf("wait for child process error\n");

                if( !(find_command(argnext[0])) ){
                    printf("%s : command not found\n",arg[0]);
                    exit(0);
                }
                fd2 = open("/tmp/youdonotknowfile",O_RDONLY);
                dup2(fd2,0);
                execvp(argnext[0],argnext);

                if(remove("/tmp/youdonotknowfile"))
                    printf("remove error\n");
                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 process error\n");
}


int main (int argc,char**argv)
{
    int i;
    int count = 0;
    char list[100][256];
    char **arg = NULL;
    char *buf = NULL;

    buf=(char*)malloc(256);
    if(buf == NULL){
        perror("malloc failed");
        exit(-1);
    }

    while(1){
        //将buf所指向的空间清零
        memset(buf,0,256);
        print_prompt();
        get_input(buf);
        //如果输入的命令为exit/logout则退出本程序
        if(strcmp(buf,"exit\n") == 0 || strcmp(buf,"logout\n") == 0)
            break;
        for(i = 0; i < 100; i++){
            list[i][0]='\0';
        }
        count = 0;
        explain_input(buf, &count, list);
        do_cmd(count, list);
    }
    if(buf != NULL){
        free(buf);
        buf = NULL;
    }
    exit(0);
}

注：
1.

void *memset(void *str, int c, size_t n)

复制字符 c（一个无符号字符）到参数 str 所指向的字符串的前 n 个字符。

  • str – 指向要填充的内存块。
  • c – 要被设置的值。该值以 int 形式传递，但是函数在填充内存块时是使用该值的无符号字符形式。
  • n – 要被设置为该值的字符数。

2.在Linux系统中一切皆可以看成是文件，文件又可分为：普通文件、目录文件、链接文件和设备文件。文件描述符（file descriptor）是内核为了高效管理已被打开的文件所创建的索引，其是一个非负整数（通常是小整数），用于指代被打开的文件，所有执行I/O操作的系统调用都通过文件描述符。程序刚刚启动的时候，0是标准输入，1是标准输出，2是标准错误。如果此时去打开一个新的文件，它的文件描述符会是3。
在这里插入图片描述

Nubula-Stars
关注
简单实现myshell
如故的博客
03-24 1020
一个简易的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 892
上个月初的myshell实现让人大费脑筋，在字符串处理和多重管道上出了不少差错，但好在最后还是实现了要求的功能。真的太懒了，把博客拖到现在～ 需求一个一个分析吧 实现管道 | 这个的意思就是想要你把一个命令的输出当作输入交给后面一个命令。如ls -l | grep “a” |wc -c就是把ls -l的输出结果交给grep 处理,grep的处理结果交给wc处理。 解决方案：dup2(fd,0)重定...
my_shell实现
weixin_51781547的博客
05-07 356
下面是我根据书上的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.
my_shell简单实现
qq_52609580的博客
04-28 325
my_shell简单实现 实现功能 实现 管道（也就是 | ） 实现 输入输出重定向(<> >>) 实现 后台运行 实现 内建命令（cd ） 屏蔽一些信号（如ctrl + c 不能终止） 通过设置环境变量 可以直接使用 (在任意地方都可以运行你的shell) 界面美观 实现 tab补全 实现内置命令history 注意 gcc 编译时需要添加动态库-lreadline vscode x修改配置文件 task.json "args": [ "${fi
实现myshell--简易版
Warrior_Harlan的博客
06-05 299
实现步骤：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;...
myshell
weixin_44801852的博客
03-18 507
#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.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.c
09-25
myshenll 帮助大家更好的写程序！
myshell操作系统
12-14
在ubuntu环境下编写的myshell，实现输入输出重定向和管道功能。
模拟实现myshell
agate_zhang的博客
05-14 554
模拟实现myshell 直观地看来Linux下的Shell命令提示符：用户名@主机号 当前目录名  提示符 函数gethostname（）可以获取到当前用户的用户名 函数getcwd（） 是获得执行程序的当前路径。
实现自己的myshell
weixin_36888577的博客
07-29 1124
这一周的小项目是实现一个自己的she’ll：实现输入输出重定向，管道，支持shell的内置cd命令，支持后台运行，实现tab补全和历史记录上下翻，ctrl+c不能中断程序，设置环境变量（让其可以像bash,zsh一样运行）各点的实现总结如下：1.重定向：输出重定向，创建你想输出到的文件，然后用dup2(old_fd,new_fd)这个函数，将其的文件描述符置为1，因为 标准输入（stdin）：代码
实现一个my_shell
李兆龙的博客
07-28 797
实现的功能 实现 输入输出重定向 (< > >>) 实现 后台运行（&） 实现 内建命令（cd） 界面美观（上色） 屏蔽部分信号(如ctrl+c) 实现管道(|) 支持 使用Tab补全、光标移动 实现 内置命令history 总结 基本功能其实都非常基础 就是在使用readline动态链接库的时候因为不熟悉出现了一些问题 其实库的使用非常简单 代码中非常清楚 ...
简单的myshell实现
DuckyLoser的博客
03-23 874
myshell.c//strtok()用来将字符串分割成一个个片段。参数s指向欲分割的字符串，参数delim则为分割字符串中包含的所有字符。//当strtok()在参数s的字符串中发现参数delim中包含的分割字符时,则会将该字符改为\0 字符。//在第一次调用时，strtok()必需给予参数s字符串，往后的调用则将参数s设置成NULL。每次调用成功则返回指向被分割出片段的指针。#include&...
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、付费专栏及课程。

余额充值