再问关于重定向(非重复贴，却是遇到问题了)

chice

stdout 重定向已经成功了。

但 stderr 却无论如何无法定向(看不到输出)，

大侠们帮忙看看啊，调了好几天也没调通。  55555~~~

另：我已经测试过, rm用stderr进行输出。rm test.txt 2>a.txt，可以看到a.txt里有rm的提示信息

如果那位大侠有完全控制子进程IO的例子那就更好了。谢谢。

1. 
   
2. #include        <sys/wait.h>
   
3. #include        <errno.h>
   
4. #include        <fcntl.h>
   
5. #include <stdio.h>
   
6. 
   
7. 
   
8. #define STDIN 0
   
9. #define STDOUT 1
   
10. #define STDERR 2
    
11. 
    
12. 
    
13. void os_stdio_status(int s, int *readable, int *writeable, int *error)
    
14. {
    
15.         fd_set set;
    
16.         struct timeval tv;
    
17.         tv.tv_sec = 0;
    
18.         tv.tv_usec = 0;
    
19.         if(readable)
    
20.         {
    
21.                 FD_ZERO(&set);
    
22.                 FD_SET(s, &set);
    
23.                 select(s + 1, &set, NULL, NULL, &tv);
    
24.                 *readable = FD_ISSET(s, &set);
    
25.         }
    
26. 
    
27.         if(writeable)
    
28.         {
    
29.                 FD_ZERO(&set);
    
30.                 FD_SET(s, &set);
    
31.                 select(s + 1, NULL, &set, NULL, &tv);
    
32.                 *writeable = FD_ISSET(s, &set);
    
33.         }
    
34.         if(error)
    
35.         {
    
36.                 FD_ZERO(&set);
    
37.                 FD_SET(s, &set);
    
38.                 select(s + 1,  NULL, NULL, &set, &tv);
    
39.                 *error = FD_ISSET(s, &set);
    
40.         }
    
41. }
    
42. 
    
43. 
    
44. void my_run(char *command)
    
45. {
    
46.         /*  Define gints arrays to ref pipes */
    
47.         int    stdin_pipe[2];
    
48.         int    stdout_pipe[2];
    
49.         int    stderr_pipe[2];
    
50. 
    
51.         /*  Define buffs to copy your reads from the pipes to */
    
52.         char buffer[BUFSIZ+1];
    
53.         char buffer_err[BUFSIZ+1];
    
54. 
    
55.         /* Def some vars to hold your results */
    
56.         int fork_result;
    
57.         int data_processed;
    
58.         int data_processed_err;
    
59.         int nchars=0;
    
60.         int readable, writeable, error;
    
61.        
    
62.         /* Clear Your Buffers */
    
63.         memset(buffer, '\0', sizeof(buffer));
    
64.         memset(buffer_err, '\0', sizeof(buffer_err));
    
65. 
    
66.         buffer[0] = 0;
    
67.         buffer_err[0] = 0;
    
68.         /* Do the fork and pipe - watch closely here */
    
69. 
    
70.         /* Create pipes to read from and write too */
    
71.         if( (        pipe(stdin_pipe) == 0)
    
72.                 && (pipe(stdout_pipe) == 0)
    
73.                 && (pipe(stderr_pipe) == 0)
    
74.           )
    
75.         {
    
76.                 /* Perform the fork */
    
77.                 fork_result = fork();
    
78. 
    
79.                 /* fork attempt was not successful */
    
80.                 if(fork_result == -1)
    
81.                 {
    
82.                         //fprintf(stderr, "Fork Failure\n");
    
83.                         exit(-1);
    
84.                 }
    
85. 
    
86.                 /*  We're in the child process! */
    
87.                 else if(fork_result == 0)
    
88.                 {
    
89.                         /* Close the Child process' STDIN */
    
90.                         close(0);
    
91. 
    
92.                         /* Duplicate the Child's STDIN to the stdin_pipe file descriptor */
    
93.                         dup(stdin_pipe[0]);
    
94. 
    
95.                         /* Close the read and write to for the pipe for the child.  The child will now only be able to read from it's STDIN (which is our pipe). */
    
96.                         close(stdin_pipe[0]);
    
97.                         close(stdin_pipe[1]);
    
98. 
    
99.                         /* Close the Child process' STDOUT */
    
100.                         close(1);
     
101.                         dup(stdout_pipe[1]);       
     
102.                         close(stdout_pipe[0]);
     
103.                         close(stdout_pipe[1]);
     
104. 
     
105.                         /* Close the Child process' STDERR */
     
106.                         close(2);
     
107.                         //dup(stdout_pipe[1]);
     
108.                         dup(stderr_pipe[1]);
     
109.                         close(stderr_pipe[0]);
     
110.                         close(stderr_pipe[1]);
     
111. 
     
112.                         /*  Make the exec call to run the javac program. */
     
113.                         //execlp("javac","javac", "-d", codemonkey->current->class_path, codemonkey->current->file_name, (char *)0);
     
114.                         //execlp(program,program, arg1, (char *)0);
     
115.                         execl("/bin/sh", "sh", "-c", command, NULL);
     
116. 
     
117.                         /*  If javac didn't take over the exec call failed. */
     
118.                         exit(-1);
     
119.                 }
     
120. 
     
121.                 /* We're in the parent process. */
     
122.                 else
     
123.                 {
     
124.                         // Close STDIN for read & write and close STDERR for write
     
125.                         //close(stdin_pipe[0]);
     
126.                         //close(stdin_pipe[1]);
     
127.                         //close(stderr_pipe[0]);
     
128.                         //close(stderr_pipe[1]);
     
129.                        
     
130.                         
     
131.                         //close(stdin_pipe[0]);
     
132.                         close(stderr_pipe[1]);
     
133.                         close(stdout_pipe[1]);
     
134.                        
     
135.                         while(1)
     
136.                         {
     
137. 
     
138.                                                                
     
139.                                 os_stdio_status(stderr_pipe[0], &readable, NULL, &error);
     
140.                                 if(error)
     
141.                                 {
     
142.                                         //puts("stderr ERROR!!!!!!!!!!!!!!!!!!");
     
143.                                         //break;
     
144.                                 }
     
145.                                 if(readable)
     
146.                                 {
     
147.                                         //puts("stderr readable");
     
148.                                         data_processed_err=read(stderr_pipe[0],buffer_err,BUFSIZ);
     
149.                                         if(data_processed_err >0 )
     
150.                                                 write(STDOUT, buffer_err, data_processed_err);
     
151.                                         //if(data_processed_err == 0) break;
     
152.                                 }
     
153.                                
     
154.                                
     
155.                                
     
156.                                 os_stdio_status(stdout_pipe[0], &readable, NULL, &error);
     
157.                                 if(error)
     
158.                                 {
     
159.                                         //puts("stdout ERROR!!!!!!!!!!!!!!!!!!");
     
160.                                         //break;
     
161.                                 }
     
162.                                 if(readable)
     
163.                                 {
     
164.                                         //puts("stdout readable");
     
165.                                         data_processed=read(stdout_pipe[0],buffer,BUFSIZ);
     
166.                                         if(data_processed >0 )
     
167.                                                 write(STDOUT, buffer, data_processed);
     
168.                                         //if(data_processed == 0) break;
     
169.                                 }
     
170.                                
     
171.                                
     
172.                                 /*
     
173.                                 os_stdio_status(stdin_pipe[1], NULL, &writeable, &error);
     
174.                                 if(error)
     
175.                                 {
     
176.                                         puts("stdin ERROR!!!!!!!!!!!!!!!!!!");
     
177.                                         break;
     
178.                                 }                               
     
179.                                 if(writeable)
     
180.                                 {
     
181.                                         puts("stdin writeable");
     
182.                                         write(stdin_pipe[1], getchar(), 1);
     
183.                                         //data_processed=read(stdout_pipe[0],buffer,BUFSIZ);
     
184.                                         //write(STDOUT, buffer, data_processed);
     
185.                                         //if(data_processed == 0) break;
     
186.                                 }
     
187.                                 */
     
188.                         }
     
189.                         /* Close the read end of STDERR */
     
190.                         close(stderr_pipe[0]);
     
191.                         /* Close the write end of STDOUT */
     
192.                         close(stdout_pipe[1]);
     
193.                         /* Close STDOUT for reading */
     
194.                         close(stdout_pipe[0]);
     
195.                 }
     
196.         }
     
197.         return;
     
198.         /* THE END */
     
199. }
     
200. 
     
201. 
     
202. int main()
     
203. {
     
204.         system("ls > test.txt");
     
205.         my_run("rm test.txt");      //这个总是有问题。
     
206.         //my_run("ls *.gz");       //这个完全可以了
     
207. }
     
208. 
     

复制代码

kj501

用[php]会对'\0'产生转义解释，改成用[code]保持缩进。

kj501

代码结构不清晰，仅看代码不可能搞清楚你的目的是什么？
我感觉你好象是要做一个shell。

chice

基本是这样的。


目的就是完全控制子进程的输入(stdin)和输出(stdout/stderr)


不知道到底应该怎样实现，哎！

kj501

呵呵，你的程序在逻辑上已经乱了。
我写个小例子给你看看吧：

1. 
   
2. /* 本程序把rm -i testfile的执行结果(包括正常输出和错误输出)重定向到temp文件 */
   
3. #include <fcntl.h>
   
4. #include <strings.h>
   
5. #include <stdlib.h>
   
6. #include <unistd.h>
   
7. #include <stdio.h>
   
8. 
   
9. 
   
10. int main()
    
11. {
    
12.         int fd;
    
13.         pid_t pid;
    
14.        
    
15.         fd = open("temp",O_WRONLY|O_CREAT|O_TRUNC,0777);
    
16.         if (pid = fork() == 0) {
    
17.                 close(1);
    
18.                 dup(fd);
    
19.                 close(2);
    
20.                 dup(fd);
    
21.                 execlp("rm","rm","-i","testfile",0);
    
22.                 perror("rm:");
    
23.                 exit(1);
    
24.         }
    
25.        
    
26.         wait(NULL);
    
27.         exit(0);       
    
28. }
    

复制代码

下面是执行结果：
[kj501@s2023 c]$ touch testfile
[kj501@s2023 c]$ ./a.out
y
[kj501@s2023 c]$ cat temp
rm：是否删除一般空文件‘testfile’?
[kj501@s2023 c]$ ./a.out
[kj501@s2023 c]$ cat temp
rm: lstat‘testfile’失败: No such file or directory
[kj501@s2023 c]$

你可以很清楚地看到，重定向不一定要用管道，关键是对文件描述符的作用要理解清楚。

doubleelec

楼主,我有一疑问
close+dup这种方式能保证文件描述符一定复制到了你想要的位置吗?
根据man dup:
dup uses the lowest-numbered unused descriptor for the new  descriptor.
这一点是值得怀疑的,改用dup2试试?

<<UNIX环境高级编程>>中有很多与你程序类似的例子

kj501

楼上的兄弟不用担心，在重定向时这样做是可以的。
重定向就是改变0,1,2这三个文件描述符，这三个文件描述符差不多是最小的。关闭掉其中一个，再马上dup，得到的文件描述符就应该正好是刚才关闭的文件描述符。比如说关闭掉文件描述符1，再dup(fd)时，此时最小的还没有使用的文件描述符不就是1吗？自然结果就是把fd复制到1了。

chice

终于知道rm test.txt没有提示的原因了。

eg:
控制台下： [chice@urwish chice]$rm test.txt 会有提示寻问是否删除。
但如果     [chice@urwish chice]$sh -c "rm test.txt"就没有提示了。当然不会有输出返回。


谢谢大家帮忙！

特别感谢斑竹多次出手相救    ^_^

doubleelec

噢,多谢 kj501 的解释,我明白了

还有楼上的发现对我很有启发
应该 sh -c "rm -i a.out"就对了