[gcc] 可执行文件之间数据的非文件传递

libinary

1. 
   
2. #include <stdio.h>
   
3. #include <sys/types.h>
   
4. #include <unistd.h>
   
5. #include <sys/wait.h>
   
6. 
   
7. void err_sys(char *);
   
8. 
   
9. int
   
10. main(int argc, char *argv[])
    
11. {
    
12.   int fd1[2], fd2[2];
    
13.   pid_t pid;
    
14.   int n;
    
15.   char buf[100];
    
16. 
    
17.   if(pipe(fd1) < 0)    /* 两个半双工管道，[0]读、[1]写 */
    
18.     err_sys("pipe(fd1) error");
    
19.   if(pipe(fd2) < 0)
    
20.     err_sys("pipe(fd2) error");
    
21. 
    
22.   if((pid = fork()) < 0)
    
23.     err_sys("fork error");
    
24.   else if(pid == 0){   /* 子进程 */
    
25.     if(fd1[0] != STDIN_FILENO)
    
26.       dup2(fd1[0], STDIN_FILENO); /* 复制fd1[0]到标准读 */
    
27.     if(fd2[1] != STDOUT_FILENO)
    
28.       dup2(fd2[1], STDOUT_FILENO); /* 复制fd2[1]到标准写 */
    
29.     close(fd1[1]); /* 关闭对应的读、写管道描述符 */
    
30.     close(fd2[0]); /* 这里有问题，因为已经复制过管道描述符了， */
    
31.                    /* 子进程只使用标准的读、写描述符， */
    
32.                    /* 所以管道描述符已经不需要了，全部关闭或不关闭都可以 */
    
33.     execl("./name", "name", (char *)0); /* 运行name */
    
34.     err_sys("execl error");
    
35.   }else{
    
36.     close(fd2[1]); /* 关闭子进程使用的读、写管道描述符，留下对应的 */
    
37.     close(fd1[0]); /* 比如子进程向fd2[1]写，父进程就从对应的fd2[0]读 */
    
38.     printf("This is %s\n", argv[0]);
    
39.     n = read(fd2[0], buf, 99); /* 读"What's your name?\n: " */
    
40.     buf[n] = '\0';
    
41.     printf(buf);
    
42.     fgets(buf, 99, stdin);
    
43.     write(fd1[1], buf, strlen(buf)); /* 写buf到子进程 */
    
44.     n = read(fd2[0], buf, 99); /* 读"Your name is "%s".\n" */
    
45.     buf[n] = '\0';
    
46.     printf(buf);
    
47.     wait(NULL); /* 等待子进程结束 */
    
48.   }
    
49. 
    
50.   exit(0);
    
51. }
    
52. 
    
53. void
    
54. err_sys(char *s)
    
55. {
    
56.   perror(s);
    
57.   exit(-1);
    
58. }
    

复制代码