关于exec的问题,恳请各位高手解惑!

lazycat_2005

程序目的:
实现一个shell程序,可以实现:
1.重定向;
2.管道;

问题:在实现功能2(由函数ispipe实现)的时候,

a:如果使用"尝试1"中的代码,则可以实现ls -al /usr/include | more之类的功能,
但是程序运行完此命令后会退出!并非我本意!
b:如果使用"尝试2"中的代码,在键入ls -al /usr/include | more之后,感觉子进程2(pid1 == 0)
对于键盘输入响应有些问题,实在不好描述,请运行实验一下;但是如果在调用fork的进程中
加入sleep(5)之后就没有问题了,但这又不是我的本意(因为这需要在5秒之内"more"完)!


恳请高手解惑!不胜感激!

另外,如何贴代码讷呢?找了半天没找到....校园网,太慢了

代码如下:

1. 
   
2. #include <stdio.h>
   
3. #include <unistd.h>
   
4. #include <stdlib.h>
   
5. #include <string.h>
   
6. #include <sys/wait.h>
   
7. #include <sys/stat.h>
   
8. #include <fcntl.h>
   
9. #include <sys/types.h>
   
10. 
    
11. char buf[128],cmd1[10],cmd2[10],file[20];
    
12. char *var1[20],*var2[20];
    
13. int flag,flagcmd1,flagcmd2;
    
14. 
    
15. int getcmd()/*get the command and the varialble*/
    
16. {
    
17.         int i,j;
    
18.         i = j = 0;
    
19.         char *p = NULL;
    
20.                 var1[0] = var2[0] = NULL;
    
21.                 cmd1[0] = cmd2[0] = 0;
    
22.                 printf(">");
    
23.                 gets(buf);
    
24.                 i = j = 0;
    
25.                 flag = flagcmd1 = flagcmd2 = 0;
    
26.        
    
27.                 p = strtok(buf," ");
    
28.                 while(p != NULL){
    
29.                         if(strcmp(p,"|") == 0){
    
30.                                 flag = 1;
    
31.                                 p = strtok(NULL," ");
    
32.                                 continue;
    
33.                         }
    
34.                         if(strcmp(p,"<") == 0){
    
35.                                 flag = 2;
    
36.                                 p = strtok(NULL," ");
    
37.                                 continue;
    
38.                         }
    
39.                         if(strcmp(p,">") == 0){
    
40.                                 flag = 3;
    
41.                                 p = strtok(NULL," ");
    
42.                                 continue;
    
43.                         }
    
44.                        
    
45.                         if(flag == 0){       
    
46.                                 if(flagcmd1 == 0){
    
47.                                         strcpy(cmd1,p);
    
48.                                         flagcmd1 = 1;
    
49.                                 } else {
    
50.                                              var1[i++] = p;
    
51.                                         p = strtok(NULL," ");
    
52.                                 }
    
53.                         }else if (flag == 1){
    
54.                                 if(flagcmd2 == 0){
    
55.                                         strcpy(cmd2,p);
    
56.                                         flagcmd2 = 1;
    
57.                                 } else {
    
58.                                              var2[j++] = p;
    
59.                                         p = strtok(NULL," ");
    
60.                                 }
    
61.                         }else if(flag == 2){
    
62.                                 strcpy(file,p);
    
63.                                 p = strtok(NULL," ");
    
64.                         }else if(flag == 3){
    
65.                                 strcpy(file,p);               
    
66.                                 p = strtok(NULL," ");
    
67.                         }
    
68.                        
    
69.                 }       
    
70.         var1[i] = NULL;
    
71.         var2[j] = NULL;
    
72.         printf("The command 1 is %s\n",cmd1);       
    
73.         printf("The command 2 is %s\n",cmd2);       
    
74.         return flag;       
    
75. }
    
76. void onecmd()
    
77. {
    
78.         pid_t pid;
    
79.         if((pid = fork()) < 0){
    
80.                 printf("fork error\n");
    
81.                 exit(0);
    
82.         } else if(pid == 0){        /*child*/
    
83.                 execvp(cmd1,var1);
    
84.                 printf("wrong command.\n");
    
85.         }else if(pid > 0)        /*parent*/
    
86.                 wait(NULL);
    
87.        
    
88. }
    
89. 
    
90. void onecmdin(int fd[2])
    
91. {
    
92.         pid_t pid;
    
93.         int n,m;
    
94.         char ch;
    
95.         int  fp;
    
96.         if((fp =open(file,O_RDONLY)) == -1){
    
97.                 printf("can't open %s\n",file);
    
98.                 exit(0);
    
99.         }
    
100.         if(pipe(fd) < 0){
     
101.                 printf("pipe error\n");
     
102.                 exit(0);
     
103.         }
     
104.         if((pid = fork()) < 0){
     
105.                 printf("fork error\n");
     
106.                 exit(0);
     
107.         } else if(pid > 0){        /*parent*/
     
108.                 close(fd[0]);
     
109.                 while(read(fp,&ch,1) != 0 )
     
110.                          write(fd[1],&ch,1);
     
111.                 close(fd[1]);
     
112.                 if(waitpid(pid,NULL,0) < 0)
     
113.                         printf("waitpid error\n");
     
114.         }else if(pid == 0){        /*child*/
     
115.                 printf("in.....");
     
116.                 close(fd[1]);
     
117.                 if(fd[0] != STDIN_FILENO){
     
118.                         if(dup2(fd[0],STDIN_FILENO) != STDIN_FILENO){
     
119.                                 printf("dup2 error to stdin\n");
     
120.                                 exit(0);
     
121.                         }
     
122.                 }
     
123.                 printf("in.....");
     
124.                 execvp(cmd1,var1);
     
125.                 printf("wrong command.\n");
     
126.         }
     
127.                        
     
128. }
     
129. void onecmdout(int fd[2]){
     
130.         pid_t pid;
     
131.         int n,m;
     
132.         char line[1024];
     
133.         char ch;
     
134.         int  fp;
     
135.         if((fp = open(file,O_WRONLY)) == -1){
     
136.                 printf("can't open %s\n",file);
     
137.                 exit(0);
     
138.         }
     
139.         if(pipe(fd) < 0){
     
140.                 printf("pipe error\n");
     
141.                 exit(0);
     
142.         }
     
143.         if((pid = fork()) < 0){
     
144.                 printf("fork error\n");
     
145.                 exit(0);
     
146.         } else if(pid > 0){        /*parent*/
     
147.                 close(fd[1]);
     
148.                 while((m = read(fd[0],&ch,1)) != 0){
     
149.                         write(fp,&ch,1);
     
150.                 }
     
151.                
     
152.         }else if(pid == 0){        /*child*/
     
153.                 close(fd[0]);
     
154.                 if(fd[1] != STDOUT_FILENO){
     
155.                         if(dup2(fd[1],STDOUT_FILENO) != STDOUT_FILENO){
     
156.                                 printf("dup2 error to stdin\n");
     
157.                                 exit(0);
     
158.                         }
     
159.                 execvp(cmd1,var1);
     
160.                 printf("wrong command.\n");
     
161.                 }
     
162.         }
     
163.        
     
164. }
     
165. 
     
166. void ispipe(int fd[2])
     
167. {
     
168.         pid_t pid,pid1;
     
169.          if(pipe(fd) < 0)
     
170.                  printf("pipe error\n");
     
171.        
     
172.          /*deal with the  command before '|'*/
     
173.                
     
174.        
     
175.          if(0){//尝试1
     
176.                   if((pid = fork()) < 0)
     
177.                          printf("fork error");
     
178.                  if(pid > 0){
     
179.                         close(fd[0]);         //close read end
     
180.                         dup2(fd[1],STDOUT_FILENO);
     
181.                         execvp(cmd1,var1);
     
182.                  } else if (pid == 0){
     
183.                         close(fd[1]);        //close write end
     
184.                         dup2(fd[0],STDIN_FILENO);
     
185.                         execvp(cmd2,var2);
     
186.                  
     
187.                  }
     
188.         }
     
189.         if(1){ 尝试2
     
190.                 if((pid = fork()) < 0)
     
191.                          printf("fork error");
     
192.                 if(pid == 0) {        /*child1*/
     
193.                         close(fd[0]);         /*close read end*/
     
194.                         dup2(fd[1],STDOUT_FILENO);
     
195.                         close(fd[1]);//aaaaaa
     
196.                         execvp(cmd1,var1);
     
197.                 }
     
198.        
     
199.         /*deal with the  command after '|'*/
     
200.        
     
201.                  if((pid1 = fork()) < 0)
     
202.                          printf("fork error");
     
203.                  if(pid1 == 0){        /*child2*/
     
204.                         close(fd[1]);        /*close write end*/
     
205.                         dup2(fd[0],STDIN_FILENO);
     
206.                         close(fd[0]);
     
207.                         execvp(cmd2,var2);
     
208.                  }
     
209. 
     
210.                  //sleep(5);
     
211.                  
     
212.         }
     
213.        
     
214. }
     
215. int main(int argc,char *argv[])
     
216. {       
     
217.         int fd[2];
     
218.         int filed;
     
219.         system("clear");
     
220.         for( ; ; ){
     
221.                 getcmd();
     
222.                 if(flag == 0)                /*There is no pipe*/
     
223.                         onecmd();
     
224.                  else if(flag == 1)        /*There is a pipe*/
     
225.                         ispipe(fd);
     
226.                  else if(flag == 2)        /*There is a redirect '<'*/
     
227.                         onecmdin(fd);
     
228.                  else if(flag == 3)     /*There is a redirect '>'*/
     
229.                         onecmdout(fd);
     
230.         }
     
231. }

复制代码

墟里烟

楼主电子科大的么？我们是不是在群里见过？

rickxbx

尝试2那段大概改成这个样子:

1. 
   
2.      if(1){// 尝试2
   
3.              if((pid = fork()) < 0)
   
4.               printf("fork error");
   
5.          if(pid == 0) {  /*child1*/
   
6.              close(fd[0]);   /*close read end*/
   
7.              dup2(fd[1],STDOUT_FILENO);
   
8.              execvp(cmd1,var1);
   
9.          }
   
10. 
    
11.          waitpid(pid,NULL,0);
    
12.          close(fd[1]);//aaaaaa
    
13.      /*deal with the  command after '|'*/
    
14. 
    
15.           if((pid1 = fork()) < 0)
    
16.               printf("fork error");
    
17.           if(pid1 == 0){ /*child2*/
    
18.              close(fd[1]);   /*close write end*/
    
19.              dup2(fd[0],STDIN_FILENO);
    
20.              close(fd[0]);
    
21.              execvp(cmd2,var2);
    
22.           }
    
23. 
    
24.           waitpid(pid1,NULL,0);
    
25.           //sleep(5);
    
26.      }
    

复制代码

另外:

1. 
   
2. BUGS
   
3.        Never use gets().  Because it is impossible to tell without knowing the
   
4.        data in advance how many  characters  gets()  will  read,  and  because
   
5.        gets() will continue to store characters past the end of the buffer, it
   
6.        is extremely dangerous to use.  It has  been  used  to  break  computer
   
7.        security.  Use fgets() instead.
   

复制代码

rickxbx

对了,你的重定向实现有问题

lazycat_2005

to 2 楼:  呵呵,就是.


to 版主:
1.按照你的代码实验了一下,的确可以了.不过好像还有点小问题(该问题在我原来的代码中也存在):执行完ls -al /usr/include | more 之后 ls这个进程并没有退出(在root 下ps -ef | grep xxx),好像要等到下次命令执行完之后才会退出,为什么?(我原来的代码是more 这个进程永远不会退出)

2.请问版主,这样改动的原因是什么(这个问题才是我最想知道的,还请不吝赐教啊)?
为什么要waitpid(pid1,NULL,0)两次?

rickxbx

Post by lazycat_2005
:
1.按照你的代码实验了一下,的确可以了.不过好像还有点小问题(该问题在我原来的代码中也存在):执行完ls -al /usr/include | more 之后 ls这个进程并没有退出(在root 下ps -ef | grep xxx),好像要等到下次命令执行完之后才会退出,为什么?(我原来的代码是more 这个进程永远不会退出)

sorry,这是我的错.不应该wait两次,只需要后面一次就可以了. 就是因为wait两次,导致了ls不能结束,猜测可能是缓冲区大小的问题. /usr/include下的文件太多,加之使用-al选项,所以数据量比较大,估计管道无法接收这么多数据,所以就挂在那了.而主线程需要等他结束,他又结束不了.....

2.请问版主,这样改动的原因是什么(这个问题才是我最想知道的,还请不吝赐教啊)?
为什么要waitpid(pid1,NULL,0)两次?

上面已经说了,我搞错了.只要把

1. close(fd[1]);   /*close write end*/

复制代码

移出就行了.因为第一个程序(ls)就是向这个管道写,所以不能关闭
至于为什么要wait,跟你使用的sleep的功能其实是一样的,防止错误输出.因为可能more进程还没结束,主进程就已经输出提示符了.

lazycat_2005

多谢版主的回复,真是雪中送炭啊,我再好好研究一下~~~~~~~~~
另:

Post by rickxbx
对了,你的重定向实现有问题

是啊,开始没注意,实现 '>' 的时候要先把文件截短为0,否则上次的数据没有被清空.

lazycat_2005

to rickxbx:

又仔细研究了一下,即便按照版主的方法做了,仍然存在一点点问题:第一条指令就运行
ls -al /usr/include | more,然后使用ps -efl | grep xxx查看,可以看到,ls已经成为了僵尸进程(说明只有
一条waitpid(pid1,NULL,0)会导致主进程不能对第一个子进程进行善后处理).
改为下面的代码就没有问题了(还是加一条waitpid,不过是加在waitpid(pid1,NULL,0)的后面).

猜想问题原因应该是如果waitpid如果加在fork第二个子进程之前,则写管道操作可能没有完成或者象版主所说有关缓冲区方面问题,所以在此等待则大家都挂起.如果不加,则父进程没能对第一个进程进行善后处理,第一个进程成为僵尸进程.

if(1){// 尝试2
             if((pid = fork()) < 0)
              printf("fork error");
         if(pid == 0) {  /*child1*/
             close(fd[0]);   /*close read end*/
             dup2(fd[1],STDOUT_FILENO);
             execvp(cmd1,var1);
         }

         
         close(fd[1]);//aaaaaa
     /*deal with the  command after '|'*/

          if((pid1 = fork()) < 0)
              printf("fork error");
          if(pid1 == 0){ /*child2*/
             close(fd[1]);   /*close write end*/
             dup2(fd[0],STDIN_FILENO);
             close(fd[0]);
             execvp(cmd2,var2);
          }

          waitpid(pid1,NULL,0);
          waitpid(pid,NULL,0);
         
     }

rickxbx

多谢兄弟提醒. 本来想那个第一个进程让init来接收就是了,看来还不大好,因为如果shell一直不退出,这样的进程可能会很多