问个pipe方式重定向的问题

shaoh

这是在linux下的一个程序，附一是主程序，附二是个简单的打印"hello,world"
的程序
我想实现的功能是，在主程序中调用helloworld程序，并将helloworld的输出的结
果通过
pipe方式在主程序中打印出来（或者保存到主程序中的一个变量）。
但是下面的程序为什么有时能够正确运行，而有时又对helloworld的输出没有重定
向呢？
请大虾帮忙看看。谢谢先

附一： test.cpp

1. 
   
2. #include <iostream>
   
3. #include <stdio.h>
   
4. #include <unistd.h>
   
5. #include <stdlib.h>
   
6. #include <string.h>
   
7. #include <ctype.h>
   
8. #include <signal.h>
   
9. #include <errno.h>
   
10. #include <fcntl.h>
    
11. 
    
12. #define BUF_SIZE 1024
    
13. 
    
14. using namespace std;
    
15. 
    
16. /* engine related elements */
    
17. int to_eng[2];  /* pipe used to send commands to chinese chess engine *
    
18. /
    
19. int from_eng[2]; /* pipe used to recieve engine response */
    
20. void start_engine(char * cmd);  /* start chess engine and set the pipes
    
21. */
    
22. void send_to_eng(char *msg);
    
23. int recv_from_eng(char *msg);
    
24. 
    
25. void start_engine(char *cmd) {
    
26.         char *argv[64], *p;
    
27.         char buf[BUF_SIZE];
    
28.         int pid,k;
    
29.         printf("command used to start engine : %s\n", cmd );
    
30.         /* create the pipes */
    
31.         signal(SIGPIPE, SIG_IGN);
    
32.     if (pipe(to_eng)) {
    
33.         perror("creating pipe for send\n");
    
34.         exit(EXIT_FAILURE);
    
35.     }
    
36.     if (pipe(from_eng)) {
    
37.         perror("creating pipe for recieve\n");
    
38.         exit(EXIT_FAILURE);
    
39.     }
    
40. 
    
41.     /* split the commands in file and argv */
    
42.         k=0;
    
43.         strcpy(buf, cmd);
    
44.         p = buf;
    
45.         while (1) {
    
46.                 argv[k++] = p;
    
47.                 p = strchr(p, ' ');
    
48.                 if ( p == NULL ) break;
    
49.                 *p++ = '\0';
    
50.         }
    
51.         argv[k] = NULL;
    
52. 
    
53.         /* start the engine */
    
54.         if ( (pid = fork()) ==  0 ) {
    
55.                 /* the child */
    
56.                 dup2(to_eng[0], 0);
    
57.                 dup2(from_eng[1], 1);
    
58. 
    
59.                 close(to_eng[0]);
    
60.                 close(to_eng[1]);
    
61.                 close(from_eng[0]);
    
62.                 close(from_eng[1]);
    
63.                 dup2(1, fileno(stderr)); /* redirect stderr to the pipe */
    
64.         //dup2(1, fileno(stdout)); /* redirect stderr to the pipe */
    
65. 
    
66.         perror("faint!");
    
67.         execvp(argv[0], argv);
    
68. 
    
69.                 perror(argv[0]);
    
70.         fflush(stdout);
    
71.         fflush(stderr);
    
72. 
    
73.                 exit( EXIT_FAILURE );
    
74. 
    
75.         } else if (pid < 0) {
    
76.         perror("fork");
    
77.         exit(EXIT_FAILURE);
    
78.         } else {
    
79.                 /* the parent */
    
80.                 close ( to_eng[0]);
    
81.                 close ( from_eng[1]);
    
82. 
    
83.         /* set nonblocking read */
    
84.                 fcntl( from_eng[0], F_SETFL, O_NONBLOCK);
    
85.         }
    
86. }
    
87. 
    
88. void send_to_eng(char *msg) {
    
89.         write ( to_eng[1], msg, strlen(msg));
    
90. }
    
91. 
    
92. int recv_from_eng(char *msg){
    
93.         memset( msg, '\0', BUF_SIZE );
    
94.         int nread = read( from_eng[0], msg, BUF_SIZE );
    
95.     cout << "nread=" << nread << endl;
    
96. 
    
97.         return strlen(msg);
    
98. }
    
99. 
    
100. int main()
     
101. {
     
102.     char msg[BUF_SIZE];
     
103. 
     
104.     start_engine("helloworld");
     
105. 
     
106.         /* empty the pipe*/
     
107.     while(recv_from_eng(msg))
     
108.     {
     
109.         cout << msg;
     
110.     }
     
111. }
     

复制代码

附二： helloworld.cpp

1. 
   
2. #include <cstdio>
   
3. 
   
4. using namespace std;
   
5. 
   
6. int main()
   
7. {
   
8.     printf("Hello,world!\n");
   
9.     fflush(stdout);
   
10. }
    
11. 
    

复制代码

doubleelec

在你运行的“helloworld”里面要 fflush 一下，如果“helloworld”不能改的话，这样的重定向需要用伪终端来实现了。

shaoh

伪终端是什么概念？
你说的fflush不是我代码中的那个fflush吗？

doubleelec

哦，不好意思，没看清你的“附二”，原来你已经 fflush 了。

是这一句惹的祸：
        /* set nonblocking read */
                fcntl( from_eng[0], F_SETFL, O_NONBLOCK);

你设置了非阻塞读，实际上有时还没读到你就输出了。

shaoh

谢谢你的回复，问题确实是在这里。不过这个还不是我想实现的功能。在我的想实现的功能中可能还不希望主程序被阻塞。

我想实现的功能是，在程序test中输入命令，将命令重定向到程序engine, 然后
将engine的返回结果在当前进程中打印出来。

下面是我新编的代码，跟前面略有不同，
它包括两个程序代码，附一是test.cpp，附二是engine.cpp

在我这里如果编译后直接运行./test,则无法返回engine程序的字串
但是我在用gdb调试的时候就可以按照理想的顺序返回。

哪位大虾能帮忙看看问题出在哪里？非常感谢。

附一：test.cpp

1. 
   
2. #include <iostream>
   
3. #include <stdio.h>
   
4. #include <unistd.h>
   
5. #include <fcntl.h>
   
6. #include <signal.h>
   
7. 
   
8. #define BUF_SIZE 1024
   
9. 
   
10. using namespace std;
    
11. 
    
12. /* engine related elements */
    
13. int to_eng[2];         /* pipe used to send commands to the  engine */
    
14. int from_eng[2]; /* pipe used to recieve engine response */
    
15. void start_engine();         /* start  engine and set the pipes */
    
16. void send_to_eng(char *msg);
    
17. int recv_from_eng(char *msg);
    
18. 
    
19. void start_engine() {
    
20.         char *argv[64], *p;
    
21.         char buf[BUF_SIZE];
    
22.         int pid,k;
    
23.         /* create the pipes */
    
24.         if(signal(SIGPIPE, SIG_IGN)==SIG_ERR)
    
25.     {
    
26.         perror("signal error");
    
27.         exit(EXIT_FAILURE);
    
28.     }
    
29. 
    
30.     if (pipe(to_eng)<0 || pipe(from_eng)<0)
    
31.     {
    
32.         perror("creating pipe error\n");
    
33.         exit(EXIT_FAILURE);
    
34.     }
    
35.    
    
36.         /* start the engine */
    
37.         if ( (pid = fork()) < 0 )
    
38.     {
    
39.         //perror("pid<0");
    
40.         perror("fork");
    
41.         exit(EXIT_FAILURE);
    
42.     }
    
43.     else if(pid==0)
    
44.     {
    
45.                 /* the child */
    
46.                 dup2(to_eng[0], 0);
    
47.                 dup2(from_eng[1], 1);
    
48. 
    
49.                 close(to_eng[1]);
    
50.                 close(from_eng[0]);
    
51. 
    
52.         if(dup2(to_eng[0], STDIN_FILENO)!=STDIN_FILENO) /* redirect stdout to the pipe */
    
53.             perror("dup2 error to stdin\n");
    
54.         close(to_eng[0]);
    
55. 
    
56.         if(dup2(from_eng[1], STDERR_FILENO)!=STDERR_FILENO) /* redirect stdout to the pipe */
    
57.             perror("dup2 error to stdout\n");
    
58.         close(from_eng[1]);
    
59. 
    
60.         if((execl("./engine", "engine", (char *)0)) <0)
    
61.         {
    
62.             perror("error");
    
63.         }
    
64. 
    
65.                 perror(argv[0]);
    
66.                 exit( EXIT_FAILURE );
    
67.         }
    
68.     else {
    
69.                 /* the parent */
    
70.                 close ( to_eng[0]);
    
71.                 close ( from_eng[1]);
    
72. 
    
73.         /* set nonblocking read */
    
74.                 fcntl( from_eng[0], F_SETFL, O_NONBLOCK);
    
75.         }
    
76. }
    
77. 
    
78. void send_to_eng(char *msg) {
    
79.         write ( to_eng[1], msg, strlen(msg));
    
80. }
    
81. 
    
82. int recv_from_eng(char *msg){
    
83.         memset( msg, '\0', BUF_SIZE );
    
84.         int nread = read( from_eng[0], msg, BUF_SIZE );
    
85.     cout << "nread=" << nread << endl;
    
86. 
    
87.         return strlen(msg);
    
88. }
    
89. 
    
90. int main()
    
91. {
    
92. 
    
93.     char msg[BUF_SIZE];
    
94. 
    
95.     start_engine();
    
96. 
    
97.        
    
98.     int ret = 0;
    
99.     while((ret = recv_from_eng(msg))>0)
    
100.     {
     
101.         cout << "ret=" << ret << ":" << msg;
     
102.     }
     
103. 
     
104.     send_to_eng("change\n");
     
105. 
     
106.     while((ret = recv_from_eng(msg))>0)
     
107.     {
     
108.         cout << "ret=" << ret << ":" << msg;
     
109.     }
     
110. 
     
111.     send_to_eng("stop\n");
     
112. 
     
113.     while((ret = recv_from_eng(msg))>0)
     
114.     {
     
115.         cout << "ret=" << ret << ":" << msg;
     
116.     }
     
117. 
     
118.     exit(0);
     
119. }
     

复制代码

附二：engine.cpp

1. 
   
2. #include <cstdio>
   
3. #include <cstdlib>
   
4. #include <iostream>
   
5. 
   
6. using namespace std;
   
7. 
   
8. int main()
   
9. {
   
10. 
    
11.     cout << "loop begin" << endl;
    
12. 
    
13.     int n, int1, int2;
    
14.     char msg[1024];
    
15. 
    
16.     while(1)
    
17.     {
    
18.         memset( msg, '\0', 1024 );
    
19.         int n = read(STDIN_FILENO, msg, 1024);
    
20.         
    
21.         if(strstr(msg, "stop"))
    
22.         {
    
23.             write(STDOUT_FILENO, "stopped\n", 9);
    
24.             break;
    
25.         }
    
26. 
    
27.         if(strstr(msg, "change"))
    
28.             write(STDOUT_FILENO, "Changed\n", 9);
    
29.         else if(strlen(msg)>0)
    
30.             write(STDOUT_FILENO, "Hello,world\n", 13);
    
31.     }
    
32. 
    
33.     return 0;
    
34. }
    

复制代码

doubleelec

（1）你重定向的是标准错误输出，注释却说是标准输出？

（2）在recv_from_eng中，应该返回nread，比返回strlen(msg)更可靠。

（3）如果你要用非阻塞方式，你用的循环条件就有问题了；而且既然要循环读，用非阻塞方式又有什么意义？不如用阻塞方式，我改成阻塞方式试过了，没问题。

这是我改的test.cpp

1. 
   
2. #include <iostream>
   
3. #include <stdio.h>
   
4. #include <unistd.h>
   
5. #include <fcntl.h>
   
6. #include <signal.h>
   
7. 
   
8. #define BUF_SIZE 1024
   
9. 
   
10. using namespace std;
    
11. 
    
12. /* engine related elements */
    
13. int to_eng[2];         /* pipe used to send commands to the  engine */
    
14. int from_eng[2]; /* pipe used to recieve engine response */
    
15. void start_engine();         /* start  engine and set the pipes */
    
16. void send_to_eng(char *msg);
    
17. int recv_from_eng(char *msg);
    
18. 
    
19. void start_engine() {
    
20.         char *argv[64], *p;
    
21.         char buf[BUF_SIZE];
    
22.         int pid,k;
    
23.         /* create the pipes */
    
24.         if(signal(SIGPIPE, SIG_IGN)==SIG_ERR)
    
25.     {
    
26.         perror("signal error");
    
27.         exit(EXIT_FAILURE);
    
28.     }
    
29. 
    
30.     if (pipe(to_eng)<0 || pipe(from_eng)<0)
    
31.     {
    
32.         perror("creating pipe error\n");
    
33.         exit(EXIT_FAILURE);
    
34.     }
    
35.    
    
36.         /* start the engine */
    
37.         if ( (pid = fork()) < 0 )
    
38.     {
    
39.         //perror("pid<0");
    
40.         perror("fork");
    
41.         exit(EXIT_FAILURE);
    
42.     }
    
43.     else if(pid==0)
    
44.     {
    
45.                 /* the child */
    
46.                 dup2(to_eng[0], 0);
    
47.                 dup2(from_eng[1], 1);
    
48. 
    
49.                 close(to_eng[1]);
    
50.                 close(from_eng[0]);
    
51. 
    
52.         if(dup2(to_eng[0], STDIN_FILENO)!=STDIN_FILENO) /* redirect stdout to the pipe */
    
53.             perror("dup2 error to stdin\n");
    
54.         close(to_eng[0]);
    
55. 
    
56.         [color=Red]if(dup2(from_eng[1], STDOUT_FILENO)!=STDOUT_FILENO) /* redirect stdout to the pipe */[/color]            perror("dup2 error to stdout\n");
    
57.         close(from_eng[1]);
    
58. 
    
59.         if((execl("./engine", "engine", (char *)0)) <0)
    
60.         {
    
61.             perror("error");
    
62.         }
    
63. 
    
64.                 perror(argv[0]);
    
65.                 exit( EXIT_FAILURE );
    
66.         }
    
67.     else {
    
68.                 /* the parent */
    
69.                 close ( to_eng[0]);
    
70.                 close ( from_eng[1]);
    
71. 
    
72.         /* set nonblocking read */
    
73. [color=Red]//                fcntl( from_eng[0], F_SETFL, O_NONBLOCK);[/color]
    
74.         }
    
75. }
    
76. 
    
77. void send_to_eng(char *msg) {
    
78.         write ( to_eng[1], msg, strlen(msg));
    
79. }
    
80. 
    
81. int recv_from_eng(char *msg){
    
82.         memset( msg, '\0', BUF_SIZE );
    
83.         int nread = read( from_eng[0], msg, BUF_SIZE );
    
84.     cout << "nread=" << nread << endl;
    
85. 
    
86.         return nread;
    
87. }
    
88. 
    
89. int main()
    
90. {
    
91. 
    
92.     char msg[BUF_SIZE];
    
93. 
    
94.     start_engine();
    
95. 
    
96.        
    
97.     int ret = 0;
    
98. [color=Red]
    
99.     recv_from_eng(msg); // 严格的讲还是要循环的，我在这里就省了[/color]
    
100.     printf("test: %s\n", msg);
     
101. 
     
102.     send_to_eng("change\n");
     
103.     ret = recv_from_eng(msg);
     
104.     printf("test: %s\n", msg);
     
105. 
     
106.     send_to_eng("stop\n");
     
107.     recv_from_eng(msg);
     
108.     printf("test: %s\n", msg);
     
109. 
     
110.     exit(0);
     
111. }
     

复制代码

shaoh

谢谢！
问题已经解决。
原来我看到的例程是非阻塞方式的，但是人家会定时间间隔地检查子进程输出流是否有内容。
所以如果直接检查输出流的话便很可能没有任何输出。

brucelee520

google