shell的实现

最新推荐文章于 2024-04-14 00:41:12 发布
最新推荐文章于 2024-04-14 00:41:12 发布
阅读量698 收藏 2
点赞数
分类专栏： 技术论文
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/curley/article/details/24692853
版权

 今日在完成一个大作业，主要的任务是编写linux下的shell程序，这有助于我们理解什么是shell，还有其实他也渗透了linux操作系统微内核的概念，下面有几篇还不错的资料，供大家参考。

首先是一篇解析shell原理的文章，对我帮助不大，因为我还没有要编写一个完整的shell的需要，所以只是资料，略看了一下。http://files.linjian.org/articles/bash_study/bash_linjian.html

然后就是下面这两篇文章，里面的代码很不错，它实现了一些shell的基本功能，顺便把他的代码也贴出来看看，缺点是没有实现一些内部命令。

http://www.jiechic.com/archives/24.html

http://www.jiechic.com/archives/25.html

 

 
 
  1. #include <stdio.h> 
  2. #include <stdlib.h> 
  3. #include <unistd.h> 
  4. #include <string.h> 
  5. #include <sys/types.h> 
  6. #include <sys/wait.h> 
  7. #include <fcntl.h> 
  8. #include <sys/stat.h> 
  9. #include <dirent.h> 
  10. #define normal      0  /* 一般的命令 */ 
  11. #define out_redirect    1  /* 输出重定向 */ 
  12. #define in_redirect 2  /* 输入重定向 */ 
  13. #define have_pipe   3  /* 命令中有管道 */  
  14.   
  15. void print_prompt();                    /* 打印提示符 */ 
  16. void get_input(char *);                 /* 得到输入的命令 */ 
  17. void explain_input(char *buf, int *argcount, char arglist[100][256]);       /* 对输入命令进行解析 */ 
  18. void do_cmd(int argcount, char arglist[100][256]);      /* 执行命令 */ 
  19. int  find_command(char *);                  /* 查找命令中的可执行程序 */ 
  20.   
  21. int main(int argc, char **argv) 
  22. { 
  23.     int    i; 
  24.     int    argcount = 0; 
  25.     char   arglist[100][256]; 
  26.     //char   **arg = NULL; 
  27.     char   *buf  = NULL; 
  28.     buf = (char *)malloc(256); 
  29.     if( buf == NULL ) { 
  30.         perror("malloc failed"); 
  31.         exit(-1); 
  32.     } 
  33.     while(1) { 
  34.         /* 将buf所指向的空间清零 */ 
  35.         memset(buf, 0, 256); 
  36.         print_prompt(); 
  37.         get_input(buf); 
  38.         /* 若输入的命令为exit或logout则退出本程序 */ 
  39.         if( strcmp(buf,"exit\n") == 0 || strcmp(buf,"logout\n") == 0 ) 
  40.             break; 
  41.         for (i=0; i < 100; i++) 
  42.         { 
  43.             arglist[i][0]='\0'; 
  44.   
  45.         } 
  46.         argcount = 0; 
  47.         explain_input(buf, &argcount, arglist); 
  48.         do_cmd(argcount, arglist);   
  49.   
  50.     } 
  51.     if(buf != NULL) { 
  52.         free(buf); 
  53.         buf = NULL; 
  54.     } 
  55.     exit(0); 
  56. } 
  57.   
  58. void print_prompt() 
  59. { 
  60.     printf("myshell$$ "); 
  61. } 
  62.   
  63. /*获取用户输入*/ 
  64. void get_input(char *buf) 
  65. { 
  66.     int len = 0; 
  67.     int ch; 
  68.     ch = getchar(); 
  69.     while (len < 256 && ch != '\n') { 
  70.         buf[len++] = ch; 
  71.         ch = getchar(); 
  72.     } 
  73.     if(len == 256) { 
  74.         printf("command is too long \n"); 
  75.         exit(-1); /* 输入的命令过长则退出程序 */ 
  76.     } 
  77.     buf[len] = '\n'; 
  78.     len++; 
  79.     buf[len] = '\0';         
  80.   
  81. } 
  82.   
  83. /* 解析buf中的命令，将结果存入arglist中，命令以回车符号\n结束 */ 
  84. /* 例如输入命令为"ls -l /tmp"，则arglist[0]、arglist[1]、arglsit[2]分别为ls、-l和/tmp */ 
  85. void explain_input(char *buf, int *argcount, char arglist[100][256]) 
  86. { 
  87.     char    *p  = buf; 
  88.     char    *q  = buf; 
  89.     int number  = 0; 
  90.     while (1) { 
  91.         if ( p[0] == '\n' ) 
  92.             break; 
  93.         if ( p[0] == ' '  ) 
  94.             p++; 
  95.         else { 
  96.             q = p; 
  97.             number = 0; 
  98.             while( (q[0]!=' ') && (q[0]!='\n') ) { 
  99.                 number++; 
  100.                 q++; 
  101.             } 
  102.             strncpy(arglist[*argcount], p, number+1); 
  103.             arglist[*argcount][number] = '\0'; 
  104.             *argcount = *argcount + 1; 
  105.             p = q; 
  106.         } 
  107.     } 
  108. } 
  109.   
  110. void do_cmd(int argcount, char arglist[100][256]) 
  111. { 
  112.     int flag = 0; 
  113.     int how = 0;        /* 用于指示命令中是否含有>、<、|   */ 
  114.     int background = 0; /* 标识命令中是否有后台运行标识符& */ 
  115.     int status; 
  116.     int i; 
  117.     int fd; 
  118.     char*   arg[argcount+1]; 
  119.     char*   argnext[argcount+1]; 
  120.     char*   file; 
  121.     pid_t   pid; 
  122.     /*将命令取出*/ 
  123.     for (i=0; i < argcount; i++) { 
  124.         arg[i] = (char *) arglist[i]; 
  125.     } 
  126.     arg[argcount] = NULL; 
  127.     /*查看命令行是否有后台运行符*/ 
  128.     for (i=0; i < argcount; i++) { 
  129.         if (strncmp(arg[i], "&",1) == 0) { 
  130.             if (i == argcount-1) { 
  131.                 background = 1; 
  132.                 arg[argcount-1] = NULL; 
  133.                 break; 
  134.             } 
  135.             else { 
  136.                 printf("wrong command\n"); 
  137.                 return ; 
  138.             } 
  139.         } 
  140.     } 
  141.     for (i=0; arg[i]!=NULL; i++) { 
  142.         if (strcmp(arg[i], ">") == 0 ) { 
  143.             flag++; 
  144.             how = out_redirect; 
  145.             if (arg[i+1] == NULL) 
  146.                 flag++; 
  147.         } 
  148.         if ( strcmp(arg[i],"<") == 0 ) { 
  149.             flag++; 
  150.             how = in_redirect; 
  151.             if(i == 0) 
  152.                 flag++; 
  153.         } 
  154.         if ( strcmp(arg[i],"|")==0 ) { 
  155.             flag++; 
  156.             how = have_pipe; 
  157.             if(arg[i+1] == NULL) 
  158.                 flag++; 
  159.             if(i == 0 ) 
  160.                 flag++; 
  161.         } 
  162.     } 
  163.     /* flag大于1，说明命令中含有多个> ,<,|符号，本程序是不支持这样的命令的 
  164.        或者命令格式不对，如"ls －l /tmp >" */ 
  165.     if (flag > 1) { 
  166.         printf("wrong command\n"); 
  167.         return; 
  168.     } 
  169.     if (how == out_redirect) {  /*命令只含有一个输出重定向符号> */ 
  170.         for (i=0; arg[i] != NULL; i++) { 
  171.             if (strcmp(arg[i],">")==0) { 
  172.                 file   = arg[i+1]; 
  173.                 arg[i] = NULL; 
  174.             } 
  175.         } 
  176.     } 
  177.     if (how == in_redirect) {    /*命令只含有一个输入重定向符号< */ 
  178.         for (i=0; arg[i] != NULL; i++) { 
  179.             if (strcmp (arg[i],"<") == 0) { 
  180.                 file   = arg[i+1]; 
  181.                 arg[i] = NULL; 
  182.             } 
  183.         } 
  184.     } 
  185.     if (how == have_pipe) {  /* 命令只含有一个管道符号| */ 
  186. /* 把管道符号后门的部分存入argnext中，管道后面的部分是一个可执行的shell命令 */ 
  187.         for (i=0; arg[i] != NULL; i++) { 
  188.             if (strcmp(arg[i],"|")==0) { 
  189.                 arg[i] = NULL; 
  190.                 int j; 
  191.                 for (j=i+1; arg[j] != NULL; j++) { 
  192.                     argnext[j-i-1] = arg[j]; 
  193.                 } 
  194.                 argnext[j-i-1] = arg[j]; 
  195.                 break; 
  196.             } 
  197.         } 
  198.     } 
  199.     if ( (pid = fork()) < 0 ) { 
  200.         printf("fork error\n"); 
  201.         return; 
  202.     } 
  203.     switch(how) { 
  204.         case 0: 
  205.             /* pid为0说明是子进程，在子进程中执行输入的命令 */ 
  206.             /* 输入的命令中不含>、<和| */ 
  207.             if (pid == 0) { 
  208.                 if ( !(find_command(arg[0])) ) { 
  209.                     printf("%s : command not found\n", arg[0]); 
  210.                     exit (0); 
  211.                 } 
  212.                 execvp(arg[0], arg); 
  213.                 exit(0); 
  214.             } 
  215.             break; 
  216.         case 1: 
  217.             /* 输入的命令中含有输出重定向符> */ 
  218.             if (pid == 0) { 
  219.                 if ( !(find_command(arg[0])) ) { 
  220.                     printf("%s : command not found\n",arg[0]); 
  221.                     exit(0); 
  222.                 } 
  223.                 fd = open(file,O_RDWR|O_CREAT|O_TRUNC,0644); 
  224.                 dup2(fd,1); 
  225.                 execvp(arg[0],arg); 
  226.                 exit(0); 
  227.             } 
  228.             break; 
  229.         case 2: 
  230.             /* 输入的命令中含有输入重定向符< */ 
  231.             if (pid == 0) { 
  232.                 if ( !(find_command (arg[0])) ) { 
  233.                     printf("%s : command not found\n",arg[0]); 
  234.                     exit(0); 
  235.                 } 
  236.                 fd = open(file,O_RDONLY); 
  237.                 dup2(fd,0); 
  238.                 execvp(arg[0],arg); 
  239.                 exit(0); 
  240.             } 
  241.             break; 
  242.         case 3: 
  243.             /* 输入的命令中含有管道符| */ 
  244.             if(pid == 0) { 
  245.                 int  pid2; 
  246.                 int  status2; 
  247.                 int  fd2; 
  248.                 if ( (pid2 = fork()) < 0 ) { 
  249.                     printf("fork2 error\n"); 
  250.                     return; 
  251.                 } 
  252.                 else if (pid2==0) { 
  253.                     if ( !(find_command(arg[0])) ) { 
  254.                         printf("%s : command not found\n",arg[0]); 
  255.                         exit(0); 
  256.                     } 
  257.                     fd2 = open("/tmp/youdonotknowfile", 
  258.                             O_WRONLY|O_CREAT|O_TRUNC,0644); 
  259.                     dup2(fd2, 1); 
  260.                     execvp(arg[0], arg); 
  261.                     exit(0); 
  262.                 } 
  263.                 if (waitpid(pid2, &status2, 0) == -1) 
  264.                     printf("wait for child process error\n"); 
  265.                 if ( !(find_command(argnext[0])) ) { 
  266.                     printf("%s : command not found\n",argnext[0]); 
  267.                     exit(0); 
  268.                 } 
  269.                 fd2 = open("/tmp/youdonotknowfile",O_RDONLY); 
  270.                 dup2(fd2,0); 
  271.                 execvp (argnext[0],argnext); 
  272.                 if ( remove("/tmp/youdonotknowfile") ) 
  273.                     printf("remove error\n"); 
  274.                 exit(0); 
  275.             } 
  276.             break; 
  277.         default: 
  278.             break; 
  279.     } 
  280.     /* 若命令中有&，表示后台执行，父进程直接返回不等待子进程结束 */ 
  281.     if ( background == 1 ) { 
  282.         printf("[process id %d]\n",pid); 
  283.         return ; 
  284.     } 
  285.     /* 父进程等待子进程结束 */ 
  286.     if (waitpid (pid, &status,0) == -1) 
  287.         printf("wait for child process error\n"); 
  288. } 
  289.   
  290. /* 查找命令中的可执行程序 */ 
  291. int find_command (char *command) 
  292. { 
  293.     DIR*             dp; 
  294.     struct dirent*   dirp; 
  295.     char *path[] = { "./", "/bin", "/usr/bin", NULL}; 
  296.     /* 使当前目录下的程序可以被运行，如命令"./fork"可以被正确解释和执行 */ 
  297.     if( strncmp(command,"./",2) == 0 ) 
  298.         command = command + 2; 
  299.     /* 分别在当前目录、/bin和/usr/bin目录查找要可执行程序 */ 
  300.     int i = 0; 
  301.     while (path[i] != NULL) { 
  302.         if ( (dp = opendir(path[i]) ) == NULL) 
  303.             printf ("can not open /bin \n"); 
  304.         while ( (dirp = readdir(dp)) != NULL) { 
  305.             if (strcmp(dirp->d_name,command) == 0) { 
  306.                 closedir(dp); 
  307.                 return 1; 
  308.             } 
  309.         } 
  310.         closedir (dp); 
  311.         i++; 
  312.     } 
  313.     return 0; 
  314. } 

 下面这段代码是我自己写的，实现了信号和一部分内部命令如cd，kill

 

 
 
  1. /********************************************************** 
  2. 在使用输入输出重定向时，需将特殊符号用空格隔开，默认管道与输入重定向和输出重定向不能兼容 
  3. 实例命令： 
  4. ls 
  5. ls & 
  6. ls -l 
  7. ls > in 
  8. cat < in > out 
  9. ls | cat 
  10. cd .. 
  11. cd / 
  12. kill -9 pid 
  13. ***********************************************************/ 
  14. #include <stdio.h> 
  15. #include <stdlib.h> 
  16. #include <string.h> 
  17. #include <unistd.h> 
  18. #include <dirent.h> 
  19. #include <pwd.h> 
  20. #include <grp.h> 
  21. #include <time.h> 
  22. #include <sys/types.h> 
  23. #include <sys/stat.h> 
  24. #include <sys/types.h> 
  25. #include <dirent.h> 
  26. #include <fcntl.h> 
  27. #include <signal.h> 
  28. #define M 1024 
  29.  
  30. void intHandler()//对于ctrl-c的处理 
  31. { 
  32.     printf("\n"); 
  33. } 
  34.  
  35. int main() 
  36. { 
  37.     int i,j,n; 
  38.     int flag_back,flag_in,flag_out,flag_pipe,pid,fd_in,fd_out,status,pid2,status2,fd2;//定义标志变量和文件描述符：后台，输入，输出，管道，定义进程状态 
  39.     char command[M],path[M],*usr,*com[M],*buf,outfile[M],infile[M],*com2[M]; 
  40.     while(1) 
  41.     { 
  42.         signal(SIGINT,intHandler);//为ctrl-c 
  43.         if((usr=getlogin()) == NULL)//获取当前用户名 
  44.         { 
  45.             exit(0); 
  46.         } 
  47.         printf("%s:",usr); 
  48.  
  49.         if(getcwd(path,sizeof(path)-1) == NULL)//获得现有执行路径 
  50.         { 
  51.             exit(0); 
  52.         } 
  53.         printf("%s",path); 
  54.         printf(">"); 
  55.         memset(command,0,sizeof(command));//初始化各变量 
  56.         memset(com,0,sizeof(com)); 
  57.         memset(com2,0,sizeof(com2)); 
  58.         flag_back=0; 
  59.         flag_in=0; 
  60.         flag_out=0; 
  61.         flag_pipe=0; 
  62.         n=0; 
  63.  
  64.         gets(command);//命令获取 
  65.  
  66.         buf=strtok(command," ");//把命令分解，获取各个参数 
  67.         while( buf!= NULL ) 
  68.         { 
  69.             com[n]=buf; 
  70.             n++; 
  71.             buf=strtok(NULL," "); 
  72.         } 
  73.  
  74.         if (!strcmp(com[0],"cd"))//处理内部命令cd 
  75.         { 
  76.             if (n != 1) 
  77.             { 
  78.                 chdir(com[1]); 
  79.             } 
  80.         } 
  81.         else if (!strcmp(com[0],"kill"))//处理内部命令kill，可以实现kill -9 pid类似命令 
  82.         { 
  83.             kill(atoi(com[2]),atoi(com[1]+1)); 
  84.         } 
  85.     else if (!strcmp(command,"exit")||!strcmp(command,"logout"))//查看是否为推出命令 
  86.         { 
  87.             break; 
  88.         } 
  89.         else if (!strcmp(command,""))//为空继续等待输入 
  90.         { 
  91.             continue; 
  92.         } 
  93.         else 
  94.         { 
  95.             for ( i = 0; i < n; i++) 
  96.             { 
  97.                 if (!strcmp(com[i],"&"))//后台标志 
  98.                 { 
  99.                     flag_back=1; 
  100.                     for ( j = i; j < n-1; j++) 
  101.                     { 
  102.                         com[j]=com[j+1]; 
  103.                     } 
  104.                     com[n-1]=NULL; 
  105.                     n--; 
  106.                     i--; 
  107.                 } 
  108.                 else if (!strcmp(com[i],">"))//输出重定向 
  109.                 { 
  110.                     flag_out=1; 
  111.                     strcpy(outfile,com[i+1]); 
  112.                     for ( j = i; j < n-2; j++) 
  113.                     { 
  114.                         com[j]=com[j+2]; 
  115.                     } 
  116.                     com[n-2]=NULL; 
  117.                     n-=2; 
  118.                     i--; 
  119.                 } 
  120.                 else if (!strcmp(com[i],"<"))//输入重定向 
  121.                 { 
  122.                     flag_in=1; 
  123.                     strcpy(infile,com[i+1]); 
  124.                     for ( j = i; j < n-2; j++) 
  125.                     { 
  126.                         com[j]=com[j+2]; 
  127.                     } 
  128.                     com[n-2]=NULL; 
  129.                     n-=2; 
  130.                     i--; 
  131.                 } 
  132.                 else if (!strcmp(com[i],"|"))//管道 
  133.                 { 
  134.                     flag_pipe=1; 
  135.                     for ( j = 0; j < i; j++) 
  136.                     { 
  137.                         com2[j]=com[j]; 
  138.                     } 
  139.                     com2[i]=NULL; 
  140.                     for ( j = 0; j < n-i-1; j++) 
  141.                     { 
  142.                         com[j]=com[j+i+1]; 
  143.                     } 
  144.                     com[n-i-1]=NULL; 
  145.                     break; 
  146.                 } 
  147.             } 
  148.             if ( (pid = fork()) < 0 )//建立子进程 
  149.             { 
  150.                 printf("fork error\n"); 
  151.                 return; 
  152.             } 
  153.             if (!pid) 
  154.             { 
  155.                 if (flag_out) 
  156.                 { 
  157.                     fd_out = open(outfile,O_RDWR|O_CREAT|O_TRUNC,0644);//输出重定向 
  158.                     dup2(fd_out,1); 
  159.                 } 
  160.                 if (flag_in) 
  161.                 { 
  162.                     fd_in = open(infile,O_RDONLY);//输入重定向 
  163.                     dup2(fd_in,0); 
  164.                 } 
  165.                 if (flag_pipe) 
  166.                 { 
  167.                     if ( (pid2 = fork()) < 0 )//管道建立另一个进程 
  168.                     { 
  169.                         printf("fork2 error\n"); 
  170.                         return; 
  171.                     } 
  172.                     else if (!pid2) 
  173.                     { 
  174.                         fd2 = open("/tmp/wb",O_WRONLY|O_CREAT|O_TRUNC,0644);//为管道建立临时文件 
  175.                         dup2(fd2,1); 
  176.                         execvp(com2[0],com2); 
  177.                         exit(0); 
  178.                     } 
  179.                     if (waitpid(pid2, &status2, 0) == -1) 
  180.                     { 
  181.                         //printf("wait for child process error\n"); 
  182.                     } 
  183.                     fd2 = open("/tmp/wb",O_RDONLY); 
  184.                     dup2(fd2,0); 
  185.                 } 
  186.                 execvp(com[0],com);//执行命令 
  187.                 remove("/tmp/wb"); 
  188.                 exit(0); 
  189.             } 
  190.             else 
  191.             { 
  192.                 if (flag_back) 
  193.                 { 
  194.                     printf("[process id %d]\n",pid);//若为后台程序，则输出进程号 
  195.                     continue; 
  196.                 } 
  197.                 else 
  198.                 { 
  199.                     if (waitpid (pid,&status,0) == -1) 
  200.                     { 
  201.                         //printf("wait for child process error\n"); 
  202.                     } 
  203.                 } 
  204.             } 
  205.         } 
  206.     } 
  207.     return 0; 
  208. } 

 

本文出自 “天才鸟蛋” 博客，请务必保留此出处http://curley.blog.51cto.com/1627940/488361

curley
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
进程控制（退出&等待&程序替换&简单shell的实现）
Morn_Star_Oliver的博客
04-27 1097
1.进程终止
shell 命令集合的执行方式
不惜留恋_
07-17 223
如果一个命令以&结尾，那么这个命令会在子shell中异步执行，也被称为异步命令。当前shell不用等到子shell执行完成，这个异步命令的返回状态永远是0 ( 表示成功 )。 如果多个命令通过;分隔，那么这些命令顺序执行，当前shell会等到所有命令执行完毕。这个命令集的返回状态就是最后一个命令的退出状态。 如果多个命令通过&&分隔，例如 command1 && command2，只有当 command1 命令的退出状态为0时，才会执行 command2。 如果多个命
[Linux][简易实现shell]详细解读 + 代码实现
SnowK博客
04-14 1983
[Linux][简易实现shell]详细解读 + 代码实现
实现自己的shell
weixin_59514216的博客
08-29 500
实现自己的shell
shell实现netmask掩码和cidr掩码位转换1
08-03
shell实现netmask掩码和cidr掩码位转换 Shell 实现 Netmask 掩码和 CIDR 掩码位转换是一种常用的网络协议 软件/插件，经常在写脚本时需要实现掩码位和掩码之间的转换。下面将详细介绍 Shell 实现 Netmask 掩码和 ...
shell实现图书管理系统
09-15
主要介绍了shell实现图书管理系统，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
shell 实现过程
10-17
首先，我们来看"shell实现过程"。Shell的实现通常包括以下几个核心部分： 1. **命令解析**：这通常涉及到词法分析和语法分析。例如，`ysh.c`可能包含了Shell的主体代码，用于解析用户的输入，将命令行拆分为可执行...
shell实现学生考勤统计.zip
05-31
在这个场景中，我们有一个名为"shell实现学生考勤统计.zip"的压缩包，它包含了多个CSV文件和一个名为"1.sh"的shell脚本。这表明这个项目是用shell脚本来处理学生考勤数据的。下面我们将深入探讨shell脚本以及如何...
PHP+shell实现多线程的方法
10-24
本文介绍了一种结合shell脚本来实现PHP多线程的方法，这在处理一些需要并发执行的任务时非常有用，比如批量数据处理、文件下载等。 首先，我们来看一个简单的PHP脚本（test.php）： ```php for ($i = 0; $i ; $i+...
shell简单实现
05-19
shell简单实现源代码，湖南大学操作系统实验第二次实验源代码。造福学弟学妹。。。。。。。。。。。。。。。
自己编写的Minix shell
01-01
自己编的Minix shell，源码在myshell文件夹中.说明文档readme.虚拟机在文件夹中，用户名和密码都是root, 程序在/home/myshell中
minix中实现shell
12-29
在minix操作系统中实现shell的程序代码，实现语言C
shell编程实现一些小游戏
热门推荐
it_zhangxiang的博客
08-02 1万+
啊...这几天被逼着学习云计算，十分痛苦 然后痛苦归痛苦，总的来说，对linux的理解还是有了些深入的 今天就把期间做的一些小游戏源码发上来吧 #!/bin/bash # 菜单 echo    "欢迎来到虚空台，凡人，这里你可以得到匹敌世界的财富，拥有灭星的力量，只要...你能活下去" read mainmenu()                             #返回 {    ...
linux shell 脚本 父子进程 等待子进程,SHELL父子进程分析
weixin_39587113的博客
05-02 1261
导言本节将就shell交互(脚本执行)过程中涉及子进程(subprocess)以及子SHELL(subshell)的部分，配以实例，进行说明。将详细讨论如下问题：subprocess和subshell是什么subprocess的产生过程是什么什么情况下会产生subprocess和subshellshell编程中，subshell需要注意些什么如何管理subprocesssubprocess和sub...
my_shell实现和分析
adlatereturn的博客
05-10 868
上个月初的myshell实现让人大费脑筋，在字符串处理和多重管道上出了不少差错，但好在最后还是实现了要求的功能。真的太懒了，把博客拖到现在～ 需求一个一个分析吧 实现管道 | 这个的意思就是想要你把一个命令的输出当作输入交给后面一个命令。如ls -l | grep “a” |wc -c就是把ls -l的输出结果交给grep 处理,grep的处理结果交给wc处理。 解决方案：dup2(fd,0)重定...
实现mini_shell
TROYE_Sn的博客
01-15 377
通过Linux实现一个mini_shell 进程控制是学习系统的一个重要知识点，涵盖有进程创建，进程终止，进程等待，程序替换这些方面。在学完这些知识后，想通过这个mini_shell将之前学过知识做一个小小的综合。 思路： 获取命令行 解析命令行 建立一个子进程 替换子进程 父进程等待子进程退出 首先第一步获取命令行，想想之前学过获取数据的方法，有scanf()，fgets(); //scan...
go web shell 实现
最新发布
05-22
Go Web Shell 是一种基于 Web 的终端模拟器，它可以在 Web 界面中提供一个交互式的终端环境，类似于 Linux 中的 Shell 界面。Go Web Shell 的实现需要用到 Golang 的 net/http 包和 websocket 包。 Go Web Shell 的实现主要分为两个部分，前端和后端。前端负责展示终端界面，后端则负责接收用户输入的命令并将命令结果返回给前端。 前端部分使用了 WebSockets 技术，通过 WebSocket 连接与后端建立通信。在用户输入命令时，前端将用户的命令通过 WebSocket 发送给后端。 后端部分则使用了 Golang 的 net/http 包和 websocket 包。当用户连接到后端时，后端会为用户创建一个新的 Shell 进程，并将该进程的标准输入、输出、错误输出管道与 WebSocket 进行绑定。当用户在前端输入命令时，后端会将命令发送给 Shell 进程，并读取 Shell 进程的输出结果返回给前端。 至于具体的实现方式和细节，可以参考 Go Web Shell 的开源代码进行了解。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值