myshell小结

最新推荐文章于 2024-05-21 15:35:48 发布
最新推荐文章于 2024-05-21 15:35:48 发布
阅读量183 收藏
点赞数
文章标签： shell linux bash
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50935486/article/details/117041761
版权

用c实现shell

功能的实现

  • 实现输入输出重定向(< > >>)
  • 实现管道(|)
  • 实现后台运行（ &）
  • 实现内建命令（cd ）
  • 实现信号屏蔽（如ctrl + c 不能终止）
  • 实现界面美观
  • 实现内置命令history
  • 实现光标的移动

流程图
在这里插入图片描述

  • 其中tab补全的功能可以借助readline库来完成
    可以参考https://blog.csdn.net/xuancbm/article/details/81436681

代码如下

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/types.h>
#include<unistd.h>
#include<fcntl.h>
#include<string.h>
#include<sys/wait.h>
#include<dirent.h>
#include<sys/stat.h>
#include<readline/readline.h>
#include<readline/history.h>
#include<signal.h>
/* char *readline (const char *prompt);  返回值为读取的字符串
void add_history(const char *string); 用来返回历史
typedef char *rl_compentry_func_t(const char *text, int state);
char **rl_completion_matches(const char *text,rl_compentry_func_t,*entry_func);*/

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

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

 char oldload[256];      /* 为了实现cd - ,用来保存上个路径 */
// char arglist[100][256];

void hander(int sign){
    char tmp[256];
    char tmp_ll[256];
    int  tm = 0;
    getcwd(tmp,256);
    int lt = strlen(tmp) - 2;
    for(int i=lt;i>=0;i--){
        if(tmp[i]=='/'){
            tm = i;
            break;
        }
    }
    for(int i=tm;i<=lt+1;i++) 
    tmp_ll[i-tm]=tmp[i];
    tmp_ll[lt+2-tm]='\0';
    printf("\001\033[1m\002");
    printf("\033[36m");
    printf("\n错误!myshell@%s$$:",tmp);
    printf("\001\033[34m\002");
}
void Showhistory(){
    int i = 0;
    HIST_ENTRY **his;
    his = history_list();
    while(his[i] != NULL)
    printf("%s\n",his[i++]->line);
}

int my_cd(char *buf){
    if(chdir(buf)<0)
    return 0;
    else return 1;
}

 int main(int argc,char **argv){
     system("clear");
     setbuf(stdout,NULL);  //程序在接受到SIGINT信号室转入的处理函数不处理缓冲区会转入下一行
     signal(SIGINT,hander);
     int i=0;
     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){
         buf = (char *)malloc(256);
         if(buf == NULL){
         perror("malloc failed");    //将其写入到while函数中防止多次输入命令发生malloc报错的情况
         exit(1);
        }
         memset(buf,0,256);
         print_prompt();
         get_input(&buf);
         /* 若输入的命令为exit或logout则退出本程序 */
         if((strcmp(buf,"exit") == 0) || (strcmp(buf,"logout") == 0))break;
         for(i = 0;i < 100;i++)
         arglist[i][0] = '\0';
         argcount = 0;
         explain_input(buf,&argcount,arglist);
         if(!(strcmp(buf,"history"))){
             Showhistory();
             continue;
         }
         if(!strcmp(arglist[0],"cd")){
             arglist[1][strlen(arglist[1])]='\0';
             if((my_cd(arglist[1]))){
                 char  tmp_file[256];
                 getcwd(tmp_file,256);  //获取当前路径
                 continue;
             }
             else{

                 printf("param error !\n");
                 continue;
             }
         }

         do_cmd(argcount,arglist);
         free(buf);
     }
    exit(1);
    //return 0;
 }

 void print_prompt(){
   char tmp[256];
    char tmp_ll[256];
    int  tm = 0;
    getcwd(tmp,256);
    int lt = strlen(tmp) - 2;
    for(int i=lt;i>=0;i--){
        if(tmp[i]=='/'){
            tm = i;
            break;
        }
    }
    for(int i=tm;i<=lt+1;i++) 
    tmp_ll[i-tm]=tmp[i];
    tmp_ll[lt+2]='\0';
    printf("\001\033[0m\002");
    printf("\033[32m");
    printf("\nmyshell@%s$$:",tmp_ll);
    printf("\001\033[0m\002");
 }

 /* 获取用户输入 */
 void get_input(char **buf){
      int len = 0;
      char ch='\0';  //这里是为了防止光标显示出现问题

    //   ch = getchar();

    //   while ((len < 256) && (ch != '\n')){
    //       buf[len++] = ch;
    //       ch = getchar();
    //   }
    //   if(strcmp(buf,"cd") == 0 || strcmp(buf,"cd ") == 0 ){
    //          strcat(buf," ~");
    //      }
  
    *buf = readline("myshell@:");
    // ch = getchar();
    //   while ((len < 256) && (ch != '\n')){
    //       buf[len++] = ch;
    //       ch = getchar();
    //   }
    add_history(*buf);
    write_history(NULL);
      if(len == 256){
          printf("command is too long \n");
          return ; /* 输入的命令过长则退出程序 */
      }
    //   buf[len] = '\n';
    //   len++;
    //   buf[len] = '\0';
      
 }

 /* 解析buf中的命令，将结果存入arglist中，命令以回车符号\n结束 */
 /* 如输入命令为“ls -l /tmp”,则arglist[1] arglist[2] 分别为ls -l /tmp */
 void explain_input(char *buf,int *argcount,char arglist[100][256]){
     char   *p = buf;
     char   *q = buf;
     int number  = 0;
     
     while(1){
         if(p[0] == '\0')
         break;

         if(p[0] == ' ')
         p++;

         else{
             q = p;
             number = 0;
             while((q[0] != ' ') && (q[0] != '\0')){
                 number++;
                 q++;
             }
             strncpy(arglist[*argcount],p,number+1);
             arglist[*argcount][number] = '\0';
             *argcount = *argcount + 1;
             p = q;
         }
     }
 }
 

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

     /* 将命令取出 */
     for(i = 0;i < argcount;i++){
         arg[i] = (char*) arglist[i];
     }
        arg[argcount] = 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\n");
                return;
            }
        }
    }
    for(i = 0;arg[i] != NULL;i++){
        if(strcmp(arg[i],">") == 0){
            flag++;
            how = out_redirect;
            if(arg[i+1] == NULL)
            flag++;
        }
    }
     for(i = 0;arg[i] != NULL;i++){
        if(strcmp(arg[i],"<") == 0){
            flag++;
            how = in_redirect;
            if(i == 0)
            flag++;
        }
     }
      for(i = 0;arg[i] != NULL;i++){
        if(strcmp(arg[i],"|") == 0){
            flag++;
            how = have_pipe;
            if(arg[i+1] ==NULL)
            flag++;
            if(i == 0)
            flag++;
        }
      }
       for(i = 0;arg[i] != NULL;i++){
        if(strcmp(arg[i],">>") == 0){
        flag++;
        how = out_redirectt;
        if(arg[i+1] == NULL)
        flag++;
        }
    }
    /* flag大于1，说明命令中含有多个>,<,|符号，本程序是不支持这样运行的或者说命令格式不对，如“ls -l/tmp >” */
    


    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){   /* 命令中只含有一个管道符号| */
    /* 把管道符号符号后面的部分存入argnext中，管道后面的部分是一个可执行的shell命令 */
        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(how == out_redirectt){  /* 命令中只含有一个输出重定向符号>> */
        for (i = 0;arg[i] != NULL;i++){
            if (strcmp(arg[i],">>") == 0){
                file = arg[i+1];
                arg[i] = NULL;
           }
        }
    } 



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

    switch(how){
    case 0:
        /* pid为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_RDWR | O_CREAT | O_TRUNC,0644);
            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(1);
                }
                fd2 = open("/tmp/youdonotknowfile",O_WRONLY|O_CREAT|O_TRUNC,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",argnext[0]);
                exit(1);
            }
            fd2 = open("/tmp/youdonotknowfile",O_RDONLY);
            dup2(fd2,0);
            execvp(argnext[0],argnext);

            if(remove("/tmp/youdonotkonwfile") )
            printf("remove error\n");
            exit(1);
        }
        break;
        case 4:
            if(pid == 0){
                if(!(find_command(arg[0])) ){
                    printf("%s :command not found !\n",arg[0]);
                    exit(0);
                }
                fd =open(file,O_RDWR | O_APPEND,0644);
                dup2(fd,1);

                execvp(arg[0],arg);
                exit(0);
            }
        break;
        default:
        break;
    }

    /* 若命令中有&，表示后台执行，父进程直接返回，不等待子进程结束 */
    if(background == 1){
        printf("[process id %d]\n",pid);
        return;
    }

    /* 父进程等待子进程结束 */
    if(waitpid (pid,&status,0) < 0){
        printf("wait for child process error\n");
        exit(1);
    }

 }
    /* 查找命令中的可执行程序 */
    int find_command(char* command){
        DIR *dp;
        struct dirent* dirp;
        char* path[] = {"./","/bin","/usr/bin","/~/home/zt_xavier",NULL};//从这里的几个路径去查找文件

        /* 使当前目录下的程序可以运行，如命令“./fork”可以被正确的解释和运行 */
        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("error in opendir \n");
                exit(1);
            }
                while((dirp = readdir(dp)) != NULL){
                    if(!strcmp(dirp->d_name,command)){

                    closedir(dp);
                    return 1;

                    }
                }
            closedir(dp);
            i++;
        }
        return 0;
    
 }

里面多重管道还未实现，需要完善…

Xavier丶
关注
myshell_实现一个简易的myshell_
10-03
在本项目中，我们关注的是“myshell”的实现，这是一个简化版的shell程序，具有基本的命令处理能力，例如改变工作目录（cd命令）。我们将探讨如何构建这样一个程序，并了解它涉及到的关键知识点。 首先，我们要理解...
myshell:实现自己的shell
m0_73960806的博客
03-20 1485
myshell
设计并编写一个简单的 Linux Shell 程序：myShell
Kovnt的博客
08-11 3007
介绍一下如何用 C 编写一个极简的 Linux Shell 程序，文末附有源码仓库。
[Linux]下制作myshell
拾至名瑰的博客
11-05 1157
本小节是完善我们上次完成[Linux]下制作简易myshell这篇博客。上次因为我们的知识还不是很完善，所以留了一些小尾巴，本篇博客来将我们的myshell完成。
myshell :实现自己的shell
lucky_starr的博客
05-06 1559
目录 功能： 负一 框架 一.print() 二.get_cmd() 获取切割输入的命令 四. void cmd_cd(char *arglist[256]); 五. do_cmd,cmd_cdx,cmd_pipe,三个重头函数。 六. 实现历史命令查看还有tab补全 ⑦。code 功能： 实现 管道 (也就是 |) 实现 输入输出重定向(也就是 < > >>) 实现 后台运行（也就是 & ） 实现 cd，要求支持能切换到绝对路径，相...
Linux C编程my_shell的实现
weixin_53012351的博客
03-24 1210
Linux C编程my_shell的实现功能流程图完整代码命令功能1.普通命令2.重定向符3.管道符实现普通命令 功能 支持的命令： 单个命令，如：ls 。 带一到多个参数的命令，如：ls -l。 带一个输出重定向的命令,如：ls > text 带一个输入重定向的命令，如：wc < text 带一个管道的命令，如 ：ls -l |wc -c 后台运行符&加在以上各个命令后面 如：ls & 如：ls -l & 输入exit或logout退出myshell 错误处理：
MyShell.zip
04-26
总之，"MyShell.zip"提供的源码为开发者提供了一个探索和学习shell编程的机会，无论是为了提升个人技能，还是为了创建独特的用户交互体验，都具有很高的价值。如果你对操作系统原理、shell编程或者想要打造自己的...
msh.zip_MSH_myshell
09-24
自己编写的shell 解释器，包括myshell.c parse.lex he makefile三个文件可以实现列表，管道，重定向，内外部命令等等
myshell命令解释器
11-24
"myshell命令解释器"是一个操作系统级别的作业，它是一个自定义的命令行接口，用于接收用户输入的命令并执行相应的操作。在这个项目中，我们将会深入理解操作系统如何处理用户输入的命令，以及如何构建一个简单的...
myshell操作系统
12-14
### myshell操作系统 #### 概述 在Ubuntu环境下编写的`myshell`是一个简单的命令行解释器或Shell程序，它实现了基本的输入输出重定向（通过`和`>`符号）以及管道功能（通过`|`符号）。该Shell允许用户执行一系列...
myshell（支持管道）
Alsnoa的博客
05-02 913
首先总结一下思路：1. 如果要支持管道就首先需要分析命令中是否包含管道。（使用stringcmp函数）2.如果包含管道就将管道符号位置为NULL，然后将管道符号前后的命令分到两个指针数组中 即：tmp1[ ]和tmp2[ ]3.这个时候需要执行两个execvp函数，我们为了保证循环的进程不会被替换，需要fork两次，分别用孙子进程执行tmp1[ ]和子进程执行tmp2[ ]。4.关于管道创建的位置...
Linux之Shell编程
xiaoyao_zhy的博客
09-18 1884
基本介绍就是shell设计者事先定义好的变量。可以直接在shell脚本中使用基本语法$$ （功能描述：当前进程的进程号（PID））$!（功能描述：后台运行的最后一个进程的进程号（PID））$?（功能描述：最后一次执行的命令的返回状态。如果这个变量的值为0，证明上一个命令正确执行；如果这个变量的值为非0（具体是哪一个数，由命令自己来决定）,则证明上一个命令执行不正确了。）正确实例在一个shell脚本中简单使用以下预定义变量函数介绍。
编写myshell
weixin_74474546的博客
04-02 288
把标准输出流给关闭了，然后紧接着创建的文件就会占用已关闭的标准输出流，使得本该流向显示器的数据流向了新创建的文件。dup()虽然可以完成重定向，但是使用起来也不是那么方便，因为它只能重定向未被使用的最小的文件描述符，对已有的文件不能完成重定向。fork 函数会新生成一个进程，调用 fork 函数的进程为父进程，新生成的进程为子进程。在父进程中返回子进程的 pid，在子进程中返回 0，失败返回-1。dup()返回的文件描述符重新指向了oldfd指向的文件，这个新的文件描述符是没有被使用的最小的文件描述符。
myShell:Linux Shell 的简单实现
热门推荐
山城过雨
05-09 1万+
C语言小程序，完成了最基本的shell角色：给出命令行提示符、能够逐次接受命令，支持管道，重定向等。
编写my_shell
weixin_51259834的博客
05-05 445
编写my_shell 基本需求： 实现 管道（也就是 | ） 实现 输入输出重定向(<> >>) 实现 后台运行（ &）(ps:linuxc上的&实现其实并不是真正的后台运行，可以考虑一下为什么) 实现 内建命令（cd ） 屏蔽一些信号（如ctrl + c 不能终止） 通过设置环境变量 可以直接使用 (在任意地方都可以运行你的shell) 界面美观 进阶需求： 实现 tab补全 （提示:使用readline库） 实现内置命令history 实现光标的移动 在编写m
基于readline库，实现命令行补全和记录
徐维溢的博客
06-29 4690
#if 1 /* GNU Readline是一个跨平台开源程序库，提供交互式的文本编辑功能。应用程序借助该库函数，*/ /*允许用户编辑键入的命令行，并提供自动补全和命令历史等功能。Bash(Bourne Again Shell)、GDB/* /*tp 和mail等程序就使用Readline库提供其命令行界面。*/ /*主要函数*/ char *readline(
MyShell教程，保姆级别教程＜三＞
最新发布
qq_42010520的博客
05-21 430
MyShell 是一个去中心化的 AI 消费者层，允许创建者构建消费者或用户可以使用的 AI 代理或机器人。可以免费试用GPT4,GPT3.5,会有更多机器人可供使用。MyShell总融资1660万美元，币安孵化器孵化的项目。分为web2跟web3,web3测试网必做占大头。
基于Linux系统用C语言实现myshell(minishell)功能实现
m0_58193842的博客
09-03 2845
实现原理很简单，我们将用户输入的字符串读取到我们的缓冲区中，，并且将重定向符改为\0并且读取出重定向的文件，随后保存判断结果。之后我们再次遍历一遍进行指令处理，我们利用字符指针数组让每一个指针指向每一个指令，并且将之间的空白符如(空格)改为\0。做完以上这一切，创建子进程利用进程替换将其替换为目标指令中的程序让其执行指定功能，如果有重定向符要先打开指定文件并且将标准输入重定向到指定文件中，者必须在子进程中完成，然后等待子进程关闭，父进程阻塞，并且让以上过程不断循环即可。...
教你写一个简单的myshell
super604zong的博客
08-07 1508
一.myshell的功能： 1. ls 2. 输入输出重定向 3. 管道操作 4. linux的内置命令 cd 5. 简单的history 6. 屏蔽ctrl + c 二.主要难点： 1.命令解析 2.进程的应用 3.cd命令的输出格式 三.代码：#include<stdio.h> # include <sys/types.h> # include <u
c语言myshell流程图
05-26
下面是一个简单的 C 语言 myshell 的流程图： ![C语言myshell流程图](https://i.imgur.com/UXT1U2A.png) 1. 用户输入命令。 2. 程序将输入的命令解析成一个个参数。 3. 程序判断输入的命令是否为内置命令（如 cd、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值