Linux系统编程：dup2()重定向

对于Dup2 的理解：

源代码：

 

 1 #include <unistd.h>
 2 #include <stdio.h>
 3 #include <stdlib.h>
 4 #include <string.h>
 5 #include <time.h>
 6 
 7 #define MSGSIZE 20
 8 #define READ 0 
 9 #define WRITE 1
10 
11 int main(int argc, char const *argv[])
12 {
13     int p[2], bytes, res, c;
14     char inbuf[10240];
15     int pid;
16     printf("%c", 11);
17     if(pipe(p) == -1){// creat the pipe , if pipe is built failed , exit .
18         perror("pip call");
19         exit(1);
20     }
21     pid = fork();
22     if(pid != 0){// creat parent pid and child pid.
23         close(p[READ]);//close parent pipe read 
24         dup2(p[WRITE], 1);
25         close(p[WRITE]);//close parent pipe write
26         execlp(argv[1], argv[1], NULL);
27     }
28     else{
29 
30         close(p[WRITE]);//close child pipe write
31         
32         dup2(p[READ],0);
33 
34         close(p[READ]);//close child pipe read
35 
36         execlp(argv[2], argv[2], NULL);
37     }
38     return 0;
39 }

 

通过命令行输出：

./a.out “ls” “ps”

仅仅在终端执行了ps的命令， 而没有看到ls 命令的结果。

因此，开始走入了第一个误区：父进程没有执行

通过调试 在父进程执行if条件中加入以下代码：

if(pid != 0){

printf("4556\n");

close(p[READ]);

dup2(p[WRITE], 1);

close(p[WRITE]);

printf("4556\n");

execlp(argv[1], argv[1], NULL);

}

加入了2个printf , 但是只有dup2 上面的printf 结果输出到屏幕上，因此我注释了 dup2(p[WRITE], 1); 结果在父进程if语句中的dup2 后面的命令都执行并且输出到屏幕上了。通过查找dup2 命令发现了重定向的强大之处。

先解释下 dup2 命令，

int dup2(int filedes, int filedes2);

说明：

用dup2 则可以用filedes2 参数指定新描述符的数值。如果filedes2 已经打开，则先将其关闭。如若filedes 等于filedes2，则返回filedes2，而不关闭它。

dup2(p[WRITE], 1); 这句话可以理解为将标准输出重定向到 p[WRITE], 因此在这句话后面的所有printf 语句打印或者exec 执行的内容都输入到了p[WRITE]中。刚开始有个迷惑，就是既然已经close（1）了，为什么还能输入到p[WRITE]中，通过自己的直觉判断，应当是close(1)关闭了屏幕的输出，但是它有缓冲区保存printf打印出的内容，并且由于重定向的关系，输进了p[WRITE]中。

 

代码：

 

 1 #include <unistd.h>
 2 #include <stdio.h>
 3 #include <stdlib.h>
 4 #include <string.h>
 5 #include <time.h>
 6 
 7 #define MSGSIZE 20
 8 #define READ 0 
 9 #define WRITE 1
10 
11 int main(int argc, char const *argv[])
12 {
13     int p[2], bytes, res, c;
14     char inbuf[10240];
15     int pid;
16     printf("%c", 11);
17     if(pipe(p) == -1){// creat the pipe , if pipe is built failed , exit .
18         perror("pip call");
19         exit(1);
20     }
21     pid = fork();
22     if(pid != 0){// creat parent pid and child pid.
23         close(p[READ]);//close parent pipe read 
24         dup2(p[WRITE], 1);
25         close(p[WRITE]);//close parent pipe write
26         printf("123!\n");
27         execlp(argv[1], argv[1], NULL);
28         perror("execlp");//error output
29     }
30     else{
31         while(1){
32             res = read(p[READ], inbuf, 10240);
33                 if(res>0)
34                     printf("%s\n", inbuf);
35             break;
36         }
37 
38         close(p[WRITE]);//close child pipe write
39         
40         dup2(p[READ],0);
41 
42         close(p[READ]);//close child pipe read
43 
44         execlp(argv[2], argv[2], NULL);
45     }
46     return 0;
47 }

 

 

 

通过在子进程中用while(1)循环读取p[READ]内容，发现读出了父进程本应在屏幕上打印的内容，因此父进程是执行了所有命令行，只是通过重定向命令存到了p[WRITE]管道中。

由于有dup2(p[READ], 0) 命令，因此猜测标准输入的文件描述符定向到了p[READ] , 因此如果猜测没错，通过getchar()读取文件标准输入并把P[READ]的内容输出到屏幕上则证明我猜想没错。

代码:

 

 1 #include <unistd.h>
 2 #include <stdio.h>
 3 #include <stdlib.h>
 4 #include <string.h>
 5 #include <time.h>
 6 
 7 #define MSGSIZE 20
 8 #define READ 0 
 9 #define WRITE 1
10 
11 int main(int argc, char const *argv[])
12 {
13     int p[2], bytes, res, c;
14     char inbuf[10240];
15     int pid;
16     printf("%c", 11);
17     if(pipe(p) == -1){// creat the pipe , if pipe is built failed , exit .
18         perror("pip call");
19         exit(1);
20     }
21     pid = fork();
22     if(pid != 0){// creat parent pid and child pid.
23         close(p[READ]);//close parent pipe read 
24         dup2(p[WRITE], 1);
25         close(p[WRITE]);//close parent pipe write
26         printf("123!\n");
27         execlp(argv[1], argv[1], NULL);
28         perror("execlp");//error output
29     }
30     else{
31         // while(1){
32         //     res = read(p[READ], inbuf, 10240);
33         //         if(res>0)
34         //             printf("%s\n", inbuf);
35         //     break;
36         // }
37 
38         close(p[WRITE]);//close child pipe write
39         
40         dup2(p[READ],0);
41         while((c=getchar()) != -1){
42             printf("%c", c);
43         }
44         close(p[READ]);//close child pipe read
45 
46         execlp(argv[2], argv[2], NULL);
47     }
48     return 0;
49 }

 

通过在dup2(p[READ], 0) 后面while循环读入输入流输入的字符并且打印出来， 发现结果果然是p[READ]的内容，猜疑没错。

为了更清楚的理解dup2的重定向含义，想理解dup2(fd,0)和dup2(0,fd)功能相同吗？

为了得到答案，找些资料发现，答案是不同。

 

测试代码：

 1 #include <stdio.h>
 2 #include <unistd.h>
 3 #include <fcntl.h>
 4 
 5 #define BUFMAXSIZE 4096
 6 
 7 int main(int argc, char *argv[])
 8 {
 9     int fd;
10     int n;
11     char buf[BUFMAXSIZE];
12     int fs;
13     fs = open("test", O_RDWR);   
14     if((fd = open("duan", O_RDWR )) == -1)
15     {
16         perror("open error!");
17         return(1);
18     }
19    
20     dup2(fd, 1);       // dup2(0,fd);
21    
22     while((n = read(fs, buf, BUFMAXSIZE)) > 0)
23     {
24         printf("begin to read...\n");
25         if(write(STDOUT_FILENO, buf, n) != n)
26         {
27             perror("write error!");
28             return(1);
29         }
30         printf("end to write...\n");   
31     }
32     if(n < 0)
33     {
34         perror("read error");
35         return(1);
36     }
37 
38     return 0;
39 } 

 

 

dup(fd, 0) 这段代码测试， 打印出了 duan 文件里面的内容。

之后创建个文件 Levi 里面写和duan 文件不同的内容。

通过./a. out < Levi输出：

第一个输出是 dup(fd, 0) 输出了Duan 文件的内容。即是fd的内容

第二个输出是 dup(0, fd) 输出了 Levi 文件的内容。即是 通过文件重定向到标准输入的内容。

从图中的输出结果已经可以看到两者的区别了。

第一种dup2(fd,0)之前已经将 fd 初始化指向到文本 Duan了，

并且不会被后面的代码所修改。

第二种dup2(0,fd)则将 fd 重新指向到文件描述符0所代表的文件（即终端标准输入）了。

那么可以看到，程序的执行中不会再读取 Duan 文件了。

而是进入了一种交互模式。

另外，这时“输入重定向”也可以生效了。

文件描述符0被 “<” 重定向到 Duan 了

所以，这里直接输出了该文本的内容。

dup2(fd,0) 相当于“输入重定向”的功能，

dup2(0,fd) 不是表示 fd 所指的文件接收来自终端的输入，因为，fd 已经不再指向原来的那个文件了。

它和文件描述符0 已经在共享同一个文件表项（即指向终端标准输入的那个表项）了。

“输出重定向”的功能可以用 dup2(fd ,1) 替代。

dup2(fd,1) 和 dup2(1,fd) 也是大同小异。