编写myshell

最新推荐文章于 2024-04-07 09:34:45 发布
最新推荐文章于 2024-04-07 09:34:45 发布
阅读量255 收藏 3
点赞数 3
文章标签： linux c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74474546/article/details/129850663
版权

实现自己的shell
在这里插入图片描述
实现框架
在这里插入图片描述
fork()函数

fork 函数会新生成一个进程，调用 fork 函数的进程为父进程，新生成的进程为子进程。在父进程中返回子进程的 pid，在子进程中返回 0，失败返回-1。
1）在父进程中，fork返回新创建子进程的进程ID；
2）在子进程中，fork返回0；
3）如果出现错误，fork返回一个负值；
我们可以通过fork()返回的值来判断当前进程是子进程还是父进程
getppid()得到的是父进程PID
getpid()得到的是当前进程的PID
在这里插入图片描述

fork（）和vfork（）都是创建一个进程

1.fork()子进程拷贝父进程的数据段和代码段
vfork()子进程与父进程共享地址空间
2.fork()父子进程的执行次序不确定
vfork()保证子进程先运行，在调用 exec 或 exit 之前与父进程数据是共享的。父进程在子进程调用 exec 或 exit 之后才可能被调度运行，在调用这两个函数之前子进程依赖于父进程的进一步动作，则会导致死锁

execvp()函数

运行一个程序
execvp(const charfile,const charargv[])
file要执行的文件名 argv字符串数组
返回值为-1出错，执行成功，execvp没有返回值
1.将指定的程序复制到调用它的进程中
2.将指定的字符串数组作为argv[]传给这个程序
3.运行这个程序
execvp有两个参数：要运行的程序名和那个程序的命令行参数数组。当程序运行时命令行参数以argv[]传给程序。注意，将数组的第一个元素置为程序的名称。还要注意，最后一个元素必须是NULL
在这里插入图片描述

wait()函数

父进程调用wait等待子进程结束
1.wait暂停调用它的进程直到子进程结束
2.wait取得子进程结束时传给exit的值
wait执行两个操作：通知和通信
此图显示了wait是如何工作的
在这里插入图片描述

重定向
进程在最开始运行的时候，首先打开了三个文件，分别是标准输入流、标准输出流、标准错误输出流。把标准输出流给关闭了，然后紧接着创建的文件就会占用已关闭的标准输出流，使得本该流向显示器的数据流向了新创建的文件。就像是使数据流的方向从一个方向，指向了另一个方向，完成了数据流的方向重定向。现在再次理解重定向就好理解得多了：重新锚定方向
dup系列函数实现重定向

函数原型 newfd=dup(oldfd)
复制一个文件描述符
newfd=dup2(oldfd,newfd)
oldfd需要复制的文件描述符
newfd复制oldfd后得到的文件描述符
系统调用dup复制了文件描述符oldfd,而dup2将oldfd文件描述符复制给newfd。两个文件描述符都指向同一个打开的文件。这两个调用都返回新的文件描述符，若发生错误，则返回-1

dup()返回的文件描述符重新指向了oldfd指向的文件，这个新的文件描述符是没有被使用的最小的文件描述符。
dup()虽然可以完成重定向，但是使用起来也不是那么方便，因为它只能重定向未被使用的最小的文件描述符，对已有的文件不能完成重定向。因此为了解决这个问题，又提供了dup的进阶版–dup2()，可以实现指定的文件描述符newfd的重定向。
总结：首先弄清文件描述符的概念文件描述符Linux系统将所有设备都当作文件来处理，而Linux用文件描述符来标识每个文件对象。其实我们可以想象我们电脑的显示器和键盘在Linux系统中都被看作是文件，而它们都有相应的文件描述符与之对应。
其次得知道进程替换的具体应用细节，并且还得熟练掌握dup系列函数，实际应用还是比较重要的。
知道了如何编写程序将标准输出重定向到文件，接下来说说如何使用管道来连接一个进程的输出和另一个进程的输入？
实现 who|sort 这样的操作，秘诀：如何创建管道和如何将标准输入和输出通过管道连接起来。
pipe()函数

调用pipe来创建管道并将其两端连接到两个文件描述符。arr[0]为读数据端的文件描述符，而arr[1]为写数据端的文件描述符
pipe用来创建管道
头文件 #include<unstid.h>
函数原型 result=pipe(int arr[2]);
参数arr是包含两个int类型数据的数组
返回-1则发生出错误，0代表成功
在这里插入图片描述

readline
光标移动，tab补全，历史命令用readline库中的函数解决
readline库函数

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <unistd.h>
#include <signal.h>
#include <readline/readline.h>
#include <readline/history.h>
#include <wait.h>
#include <fcntl.h>
char arr[1000]; //用来保存路径
//打印提示符
void printname();
#define MAX 128
//解析参数
void commodAnalsy(char *argv[], int number);
int isdo(char *argv[], int count);
// cd命令
void mycd(char *argv[]);
//输出重定向'>'
void mydup(char *argv[]);
//输出重定向'>>'
void mydup2(char *argv[]);
//输入重定向'<'
void mydup3(char *argv[]);
//管道'|'
void mypipe(char *argv[], int count);
//实现多重管道'|'
void callCommandWithPipe(char *argv[], int count);
int pass=0;//标记是否有&
void ShowHistory();
int main()
{
  read_history(NULL);
  signal(SIGINT, SIG_IGN);
  signal(SIGHUP, SIG_IGN);
  while (1)
  {
    char *argv[MAX] = {NULL};
    //打印提示符
    printname();
    char *commod = readline(" ");
    if (commod == NULL) //屏蔽掉ctrl d 出现死循环的情况
    {
      printf("\n");
      continue;
    }
    add_history(commod);
    write_history(NULL);
    if (strlen(commod) == 0) //屏蔽掉ctrl d 出现死循环的情况
    {
      // printf("\n");
      continue;
    }

    const char *mark = " "; //分割标识符,用strtok函数以空格为分割标识对字符串commod进行分割,将每个指令取出来.
    int i = 1;
    argv[0] = strtok(commod, mark);
    while (argv[i] = strtok(NULL, mark))
    {
      i++;
    }
    // free(commod);
    commodAnalsy(argv, i);
     free(commod);
  }
}
void printname()//打印提示符
{
  char *name1 = "dyj@dyj";
  printf("\033[1m\033[32m%s\033[0m", name1);
  printf(":");
  getcwd(arr,sizeof(arr));
  printf("\033[1m\033[34m%s\033[0m", arr);
  printf("$ ");
  fflush(stdout); //清空缓冲区,默认为行缓冲，提示符不是以\n结尾的
}
void commodAnalsy(char *argv[], int number)
{
  int flag = isdo(argv, number);
  if(pass==1)
  {
    number--;
  }
  if (flag == 1)
  {
    mycd(argv);
  }
  else if (strcmp(argv[0], "history") == 0)
  {
    ShowHistory();
  }
  else if (strcmp(argv[0], "exit") == 0)
  {
    printf("exit\n");
    printf("有停止的任务\n");
    exit(0);
  }
  else if (flag == 2) //输出重定向'>'
  {
    mydup(argv);
  }
  else if (flag == 3) //管道'|'
  {
    callCommandWithPipe(argv, number);
  }
  else if (flag == 4)
  {
    mydup2(argv);
  }
  else if (flag == 5)
  {
    mydup3(argv);
  }
  else if (flag == 10) //需要子进程进行执行的第三方函数
  {
    if (strcmp(argv[0], "ll") == 0)
    {
      strcpy(argv[0], "ls");
      argv[number++] = "-l";
    }
    if (strcmp(argv[0], "ls") == 0)
      argv[number++] = "--color=auto";
    pid_t pid = fork();
    if (pid < 0)
    {
      perror("fork");
      exit(1);
    }
    else if (pid == 0) //子进程
    {
      execvp(argv[0], argv); //执行命令
      perror("commod");
      exit(1);
    }
    else if (pid > 0) //父进程
    {
      if(pass==1)
      {
        pass=0;
        printf("%d\n",pid);
        return;
      }
      waitpid(pid, NULL, 0);
    }
  }
}
char strpwd[MAX]; //用来存放上一次的路劲  实现 cd -
void mycd(char *argv[])
{
  if (argv[1] == NULL)
  {
    getcwd(strpwd, sizeof(strpwd));
    chdir("/home");
  }
  else if (strcmp(argv[1], "-") == 0)
  {
    char strpwd1[MAX];
    getcwd(strpwd1, sizeof(strpwd));
    chdir(strpwd);
    printf("%s\n", strpwd);
    strcpy(strpwd, strpwd1);
  }
  else if (strcmp(argv[1], "~") == 0)
  {
    getcwd(strpwd, sizeof(strpwd));
    chdir("/home/dyj");
  }
  else
  {
    getcwd(strpwd, sizeof(strpwd));
    chdir(argv[1]);
  }
}
void mydup(char *argv[])
{
  char *strc[MAX] = {NULL};
  int i = 0;
  while (strcmp(argv[i], ">"))
  {
    strc[i] = argv[i];
    i++;
  }
  int number=i;//重定向前面参数的个数
  int flag =isdo(argv, number);
  i++;
  //出现 echo "adcbe" > test.c  这种情况
  int fdout = dup(1);                                   //让标准输出获取一个新的文件描述符
  int fd = open(argv[i], O_WRONLY | O_CREAT | O_TRUNC,0666); //只写模式|表示如果指定文件不存在，则创建这个文件|表示截断，如果文件存在，并且以只写、读写方式打开，则将其长度截断为0。
  dup2(fd, 1);
  pid_t pid = fork();
  if (pid < 0)
  {
    perror("fork");
    exit(1);
  }
  else if (pid == 0) //子进程
  {
    // dup2(fd, 1);
      if (flag == 3) //管道'|'
      {
        callCommandWithPipe(strc, number);
      }
      else
       execvp(strc[0], strc);
  }
  else if (pid > 0)
  {
     if(pass==1)
      {
        pass=0;
        printf("%d\n",pid);
        return;
      }
    waitpid(pid, NULL, 0);
  }
  dup2(fdout, 1); //
}
void mydup2(char *argv[])
{
  char *strc[MAX] = {NULL};
  int i = 0;
  
  while (strcmp(argv[i], ">>"))
  {
    strc[i] = argv[i];
    i++;
  }
  int number=i;//重定向前面参数的个数
  int flag =isdo(argv, number);
  i++;
  int fdout = dup(1);                                    //让标准输出获取一个新的文件描述符
  int fd = open(argv[i], O_WRONLY | O_CREAT | O_APPEND,0666); //只写模式|表示如果指定文件不存在，则创建这个文件|表示追加，如果原来文件里面有内容，则这次写入会写在文件的最末尾。
  pid_t pid = fork();
   dup2(fd, 1);
  if (pid < 0)
  {
    perror("fork");
    exit(1);
  }
  else if (pid == 0) //子进程
  {
    if (flag == 3) //管道'|'
      {
        callCommandWithPipe(strc, number);
      }
      else
       execvp(strc[0], strc);
  }
  else if (pid > 0)
  {
     if(pass==1)
      {
        pass=0;
        printf("%d\n",pid);
        return;
      }
    waitpid(pid, NULL, 0);
  }
  dup2(fdout, 1); //
}
void mydup3(char *argv[])
{
  char *strc[MAX] = {NULL};
  int i = 0;
  while (strcmp(argv[i], "<"))
  {
    strc[i] = argv[i];
    i++;
  }
  i++;
  int number=i;//重定向前面参数的个数
  int flag =isdo(argv, number);
  int fdin = dup(0);                //让标准输出获取一个新的文件描述符
  int fd = open(argv[i], O_RDONLY,0666); //只读模式
   dup2(fd, 0);
  pid_t pid = fork();
  if (pid < 0)
  {
     if(pass==1)
      {
        pass=0;
        printf("%d\n",pid);
        return;
      }
    perror("fork");
    exit(1);
  }
  else if (pid == 0) //子进程
  {
     if (flag == 3) //管道'|'
      {
        callCommandWithPipe(strc, number);
      }
      else
       execvp(strc[0], strc);
  }
  else if (pid > 0)
  {
    waitpid(pid, NULL, 0);
  }
  dup2(fdin, 0);
}
void callCommandWithPipe(char *argv[], int count)
{
   pid_t pid;
  int ret[10];//存放每个管道的下标
  int number=0;//统计管道个数
  for(int i=0;i<count;i++)
  {
    if(!strcmp(argv[i],"|"))
    {
      ret[number++]=i;
    }
  }
  int cmd_count=number+1;//命令个数
  char* cmd[cmd_count][10];
  for(int i=0;i<cmd_count;i++)//将命令以管道分割存放组数组里
  {
    if(i==0)//第一个命令
    {
      int n=0;
      for(int j=0;j<ret[i];j++)
      {
        cmd[i][n++]=argv[j];
      }
      cmd[i][n]=NULL;
    }
    else if(i==number)//最后一个命令
    {
      int n=0;
      for(int j=ret[i-1]+1;j<count;j++)
      {
        cmd[i][n++]=argv[j];
      }
      cmd[i][n]=NULL;
    }
    else 
    {
       int n=0;
      for(int j=ret[i-1]+1;j<ret[i];j++)
      {
        cmd[i][n++]=argv[j];
      }
      cmd[i][n]=NULL;
    }
  }//经过上述操作，我们已经将指令以管道为分隔符分好,下面我们就可以创建管道了
  int fd[number][2];  //存放管道的描述符
  for(int i=0;i<number;i++)//循环创建多个管道
  {
    pipe(fd[i]);
  }
  int i=0;
  for(i=0;i<cmd_count;i++)//父进程循环创建多个并列子进程
  {
    pid=fork();
    if(pid==0)//子进程直接退出循环，不参与进程的创建
    break;
  }
  if(pid==0)//子进程
  {
    if(number)
    {
      if(i==0)//第一个子进程
      {
        dup2(fd[0][1],1);//绑定写端`  
        close(fd[0][0]);//关闭读端
        //其他进程读写端全部关闭
        for(int j=1;j<number;j++)
        {
          close(fd[j][1]);
          close(fd[j][0]);
        }
      }
      else if(i==number)//最后一个进程
      {
        dup2(fd[i-1][0],0);//打开读端
        close(fd[i-1][1]);//关闭写端
         //其他进程读写端全部关闭
        for(int j=0;j<number-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(int j=0;j<number;j++)
        {
             if(j!=i&&j!=(i-1))
             {
               close(fd[j][0]);
               close(fd[j][1]);
             }
        }
      }
    }

    execvp(cmd[i][0],cmd[i]);//执行命令
    perror("execvp");
    exit(1);
  }
  //父进程什么都不干，把管道的所有口都关掉
    for(i=0;i<number;i++)
    {
        close(fd[i][0]);
        close(fd[i][1]);//父进程端口全部关掉

    }
     if(pass==1)
      {
        pass=0;
        printf("%d\n",pid);
        return;
      }
  for(int j=0;j<cmd_count;j++)//父进程等待子进程
  wait(NULL);
}

int isdo(char *argv[], int count)
{
  int flag = 10, i;
  if (argv[0] == NULL)
    return 0;
  if (strcmp(argv[0], "cd") == 0)
  {
    flag = 1;
  }
  for (i = 0; i < count; i++)
  {
    if (strcmp(argv[i], ">") == 0)
      flag = 2;
    if (strcmp(argv[i], "|") == 0)
      flag = 3;
    if (strcmp(argv[i], ">>") == 0)
      flag = 4;
    if (strcmp(argv[i], "<") == 0)
      flag = 5;
    if (strcmp(argv[i], "<<") == 0)
      flag = 6;
    if (strcmp(argv[i], "&") == 0)
    {
        pass = 1;
        argv[i]=NULL;
    }
  }
  return flag;
}
void ShowHistory()
{
  int i = 0;
  HIST_ENTRY **h;
  h = history_list();
  while (h[i] != NULL)
    printf("%-3d   %s\n", i, h[i++]->line);
}
杜子咕咕叫!
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
实现自己的shell
weixin_74111699的博客
03-24 243
包含头文件：#include 函数定义：int execvp(const char *file, char * const argv []);函数说明：execvp()会从环境变量所指的目录中查找符合参数 file 的文件名, 找到后执行该文件, 然后将第二个参数argv传给该执行的文件。返回值：如果执行成功则函数不会返回, 执行失败则直接返回-1.该函数可以。
myshell（支持管道）
Alsnoa的博客
05-02 889
首先总结一下思路：1. 如果要支持管道就首先需要分析命令中是否包含管道。（使用stringcmp函数）2.如果包含管道就将管道符号位置为NULL，然后将管道符号前后的命令分到两个指针数组中 即：tmp1[ ]和tmp2[ ]3.这个时候需要执行两个execvp函数，我们为了保证循环的进程不会被替换，需要fork两次，分别用孙子进程执行tmp1[ ]和子进程执行tmp2[ ]。4.关于管道创建的位置...
myshell_实现一个简易的myshell_
10-03
实现简易的shell程序，有改变目录cd等功能
myshell:实现自己的shell
m0_73960806的博客
03-20 696
myshell
探索MyShell：一个个性化命令行工具的创新实践
最新发布
gitblog_00092的博客
04-07 336
探索MyShell：一个个性化命令行工具的创新实践 项目地址:https://gitcode.com/limboinf/myshell 项目简介 MyShell 是一个轻量级、高度可定制化的命令行接口（CLI）工具，旨在提升用户的日常终端操作效率。它允许用户根据自己的需求自定义命令，集成各种实用工具，并提供了一种全新的交互方式，让命令行体验更加友好和个性化。 技术分析 脚本语言支持 MyShel...
[Linux]下制作myshell
拾至名瑰的博客
11-05 1129
本小节是完善我们上次完成[Linux]下制作简易myshell这篇博客。上次因为我们的知识还不是很完善，所以留了一些小尾巴，本篇博客来将我们的myshell完成。
设计并编写一个简单的 Linux Shell 程序：myShell
Kovnt的博客
08-11 2726
介绍一下如何用 C 编写一个极简的 Linux Shell 程序，文末附有源码仓库。
myshell :实现自己的shell
lucky_starr的博客
05-06 1321
目录 功能： 负一 框架 一.print() 二.get_cmd() 获取切割输入的命令 四. void cmd_cd(char *arglist[256]); 五. do_cmd,cmd_cdx,cmd_pipe,三个重头函数。 六. 实现历史命令查看还有tab补全 ⑦。code 功能： 实现 管道 (也就是 |) 实现 输入输出重定向(也就是 < > >>) 实现 后台运行（也就是 & ） 实现 cd，要求支持能切换到绝对路径，相...
基于C++仿Shell bash编写MyShell程序【100012796】
06-20
Linux 下的Shell是用户使用Linux的桥梁，是用户和Linux内核之间的接口程序。 Shell应用程序为用户提供了一个界面，用户通过这个界面访问操作系统内核的服务。 每一个 Shell 程序也拥有自己的一些内建命令和内部变量...
msh.zip_MSH_myshell
09-24
自己编写的shell 解释器，包括myshell.c parse.lex he makefile三个文件可以实现列表，管道，重定向，内外部命令等等
自己编写的myshell.c
09-25
myshenll 帮助大家更好的写程序！
myshell操作系统
12-14
在ubuntu环境下编写的myshell，实现输入输出重定向和管道功能。
Myshell:一个简单的shell解释器
06-22
我的壳一个简单的shell解释器。 仅用于学习 shell 和脚本解释器的详细信息。 该演示支持一些基本命令。 echo ls wc cp mv rm grep sort and expr find basename dirname ...) myshell filename # 执行文件中的命令。
Linux之Shell编程
xiaoyao_zhy的博客
09-18 1728
基本介绍就是shell设计者事先定义好的变量。可以直接在shell脚本中使用基本语法$$ （功能描述：当前进程的进程号（PID））$!（功能描述：后台运行的最后一个进程的进程号（PID））$?（功能描述：最后一次执行的命令的返回状态。如果这个变量的值为0，证明上一个命令正确执行；如果这个变量的值为非0（具体是哪一个数，由命令自己来决定）,则证明上一个命令执行不正确了。）正确实例在一个shell脚本中简单使用以下预定义变量函数介绍。
Linux C编程my_shell的实现
weixin_53012351的博客
03-24 885
Linux C编程my_shell的实现功能流程图完整代码命令功能1.普通命令2.重定向符3.管道符实现普通命令 功能 支持的命令： 单个命令，如：ls 。 带一到多个参数的命令，如：ls -l。 带一个输出重定向的命令,如：ls > text 带一个输入重定向的命令，如：wc < text 带一个管道的命令，如 ：ls -l |wc -c 后台运行符&加在以上各个命令后面 如：ls & 如：ls -l & 输入exit或logout退出myshell 错误处理：
基于Linux系统用C语言实现myshell(minishell)功能实现
m0_58193842的博客
09-03 2716
实现原理很简单，我们将用户输入的字符串读取到我们的缓冲区中，，并且将重定向符改为\0并且读取出重定向的文件，随后保存判断结果。之后我们再次遍历一遍进行指令处理，我们利用字符指针数组让每一个指针指向每一个指令，并且将之间的空白符如(空格)改为\0。做完以上这一切，创建子进程利用进程替换将其替换为目标指令中的程序让其执行指定功能，如果有重定向符要先打开指定文件并且将标准输入重定向到指定文件中，者必须在子进程中完成，然后等待子进程关闭，父进程阻塞，并且让以上过程不断循环即可。...
myShell:Linux Shell 的简单实现
热门推荐
山城过雨
05-09 1万+
C语言小程序，完成了最基本的shell角色：给出命令行提示符、能够逐次接受命令，支持管道，重定向等。
教你写一个简单的myshell
super604zong的博客
08-07 1487
一.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
my_shell 实现
m0_53313553的博客
04-13 533
MyShell 实现 一、主要函数 1.fork 被调用一次，有两个返回值。 1）在父进程中，fork返回新创建子进程的进程ID； 2）在子进程中，fork返回0； 3）如果出现错误，fork返回一个负值； fork出错可能有两种原因： 1）当前的进程数已经达到了系统规定的上限，这时errno的值被设置为EAGAIN。 2）系统内存不足，这时errno的值被设置为ENOMEM。 注： 1.每个进程都有一个独特（互不相同）的进程标识符（process ID），可以通过**getpid（）函数获得，还有
c语言编写shell程序myshell
06-09
然后，您可以按照以下步骤编写您的 myshell： 1. 读取用户输入的命令。可以使用 fgets 函数来读取用户输入的命令。 2. 解析用户输入的命令。将用户输入的命令按照空格分割成若干个参数，并判断是否存在管道符或...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值