函数popen()

川长思鸟来 2022-08-23 05:45 153阅读 0赞

### 转载：http://blog.csdn.net/qian\_f/article/details/8227435 ###

### 函数说明 ###

popen()函数通过创建一个管道，调用fork()产生一个子进程，执行一个shell以运行命令来开启一个进程。这个管道必须由pclose()函数关闭，而不是fclose()函数。pclose()函数关闭标准I/O流，等待命令执行结束，然后返回shell的终止状态。如果shell不能被执行，则pclose()返回的终止状态与shell已执行exit一样。

type参数只能是读或者写中的一种，得到的返回值（标准I/O流）也具有和type相应的只读或只写类型。如果type是"r"则文件指针连接到command的标准输出；如果type是"w"则文件指针连接到command的标准输入。

command参数是一个指向以NULL结束的shell命令字符串的指针。这行命令将被传到bin/sh并使用-c标志，shell将执行这个命令。

popen()的返回值是个标准I/O流，必须由pclose来终止。前面提到这个流是单向的（只能用于读或写）。向这个流写内容相当于写入该命令的标准输入，命令的标准输出和调用popen()的进程相同；与之相反的，从流中读数据相当于读取命令的标准输出，命令的标准输入和调用popen()的进程相同。

### 返回值 ###

如果调用fork()或pipe()失败，或者不能分配内存将返回NULL，否则返回标准I/O流。popen()没有为内存分配失败设置errno值。如果调用fork()或pipe()时出现错误，errno被设为相应的错误类型。如果type参数不合法，errno将返回EINVAL。

用到popen()的时候，到网上找了找，发现网上好多对man帮助里的内容进行了解释，有部分解释内容如下：“popen 的返回值是个标准 I/O 流，必须由 pclose 来终止。前面提到这个流是单向的。所以向这个流写内容相当于写入该命令的标准输入；命令的标准输出和调用 popen 的进程相同。与之相反的，从流中读数据相当于读取命令的标准输出；命令的标准输入和调用 popen 的进程相同。”这话怎么读都别扭，理解起来就有些难了。先来看看popen的函数声明：FILE \* popen(const char\* command, const char\* type)

在使用这个函数的时候，将参数type写成“w”就出现了不能理解的地方（网上的一些程序参数type多是“r”）。看下面一个程序：

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  \#include <stdio.h>  
2.  **int** main()  
3.  \{  
4.          **FILE** \* fp;  
5.          **char** buf\[40\] = \{0\};  
6.          fp = popen(NULL, "w");  
7.          **if**(NULL == fp)  
8.          \{  
9.                  perror("popen error.\\n");  
10.                 **return** -1;  
11.         \}  
12.         printf("Input command:");  
13.         fgets(buf, 40, stdin);  
14.         fputs(buf, fp);  
15.         pclose(fp);  
16.         **return** 0;  
17. \}

执行结果：

\[root@localhost codetest\]\# ./a.out   
sh: -c: option requires an argument  
Input command:pwd

很明显出错了，但是根据那段翻译的内容，搞得自己很糊涂，后来问了老师，说是type参数为"w"的时候，popen的第一个参数为命令解释器，即bash/sh之类。修改后的程序如下：

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  \#include <stdio.h>  
2.  **int** main()  
3.  \{  
4.          **FILE** \* fp;  
5.          **char** buf\[40\] = \{0\};  
6.          fp = popen("bash", "w");  
7.          **if**(NULL == fp)  
8.          \{  
9.                  perror("popen error.\\n");  
10.                 **return** -1;  
11.         \}  
12.         printf("Input command:");  
13.         fgets(buf, 40, stdin);  
14.         fputs(buf, fp);  
15.         pclose(fp);  
16.         **return** 0;  
17. \}

执行结果：

\[root@localhost codetest\]\# ./a.out   
Input command:pwd  
/home/qian/codetest

这下就对了！

可是还是有疑问的，如果我直接在popen()的第一个参数写命令，也同样可以得到命令结果，程序如下：

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  \#include <stdio.h>  
2.  **int** main()  
3.  \{  
4.          **FILE** \* fp;  
5.          **char** buf\[40\] = \{0\};  
6.          fp = popen("pwd", "w");  
7.          **if**(NULL == fp)  
8.          \{  
9.                  perror("popen error.\\n");  
10.                 **return** -1;  
11.         \}  
12.         pclose(fp);  
13.         **return** 0;  
14. \}

执行结果：

\[root@localhost codetest\]\# ./a.out   
/home/qian/codetest

关于这个参数的问题，一直是个疙瘩，如果谁知道的话，可以给个解答，感激不尽！

下面是type参数为“r”的一个程序：

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  \#include <stdio.h>  
2.  **int** main()  
3.  \{  
4.          **FILE** \* fp;  
5.          **char** buf\[20\] = \{0\};  
6.          fp = popen("ls","r");  
7.          **if**(NULL == fp)  
8.          \{  
9.                  perror("popen error!\\n");  
10.                 **return** -1;  
11.         \}  
12.         **while**(fgets(buf, 20, fp) != NULL)  
13.         \{  
14.                 printf("%s", buf);  
15.         \}  
16.         pclose(fp);  
17.         **return** 0;  
18. \}

值得注意的是：一定要用pclose()来关闭文件指针，这是我老忘记的事。

下面给出一个网上给出的popen()和pclose()实现函数：

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  Figure 15.12. The popen and pclose functions  
2.  \#include "apue.h"  
3.  \#include <errno.h>  
4.  \#include <fcntl.h>  
5.  \#include <sys/wait.h>  
6.    
7.  /\* 
8.   \* Pointer to array allocated at run-time. 
9.   \*/  
10. **static** pid\_t    \*childpid = NULL;  
11.   
12. /\* 
13.  \* From our open\_max(), Figure 2.16. 
14.  \*/  
15. **static** **int**      maxfd;  
16.   
17. **FILE** \*  
18. popen(**const** **char** \*cmdstring, **const** **char** \*type)  
19. \{  
20.     **int**     i;  
21.     **int**     pfd\[2\];  
22.     pid\_t   pid;  
23.     **FILE**    \*fp;  
24.   
25.     /\* only allow "r" or "w" \*/  
26.     **if** ((type\[0\] != 'r' && type\[0\] != 'w') || type\[1\] != 0) \{  
27.         errno = EINVAL;     /\* required by POSIX \*/  
28.         **return**(NULL);  
29.     \}  
30.   
31.     **if** (childpid == NULL) \{     /\* first time through \*/  
32.         /\* allocate zeroed out array for child pids \*/  
33.         maxfd = open\_max();  
34.         **if** ((childpid = calloc(maxfd, **sizeof**(pid\_t))) == NULL)  
35.             **return**(NULL);  
36.     \}  
37.   
38.     **if** (pipe(pfd) < 0)  
39.         **return**(NULL);   /\* errno set by pipe() \*/  
40.   
41.     **if** ((pid = fork()) < 0) \{  
42.         **return**(NULL);   /\* errno set by fork() \*/  
43.     \} **else** **if** (pid == 0) \{                           /\* child \*/  
44.         **if** (\*type == 'r') \{  
45.             close(pfd\[0\]);  
46.             **if** (pfd\[1\] != STDOUT\_FILENO) \{  
47.                 dup2(pfd\[1\], STDOUT\_FILENO);  
48.                 close(pfd\[1\]);  
49.             \}  
50.         \} **else** \{  
51.             close(pfd\[1\]);  
52.             **if** (pfd\[0\] != STDIN\_FILENO) \{  
53.                 dup2(pfd\[0\], STDIN\_FILENO);  
54.                 close(pfd\[0\]);  
55.             \}  
56.         \}  
57.   
58.         /\* close all descriptors in childpid\[\] \*/  
59.         **for** (i = 0; i < maxfd; i++)  
60.             **if** (childpid\[i\] > 0)  
61.                 close(i);  
62.   
63.         execl("/bin/sh", "sh", "-c", cmdstring, (**char** \*)0);  
64.         \_exit(127);  
65.     \}  
66.   
67.     /\* parent continues... \*/  
68.     **if** (\*type == 'r') \{  
69.         close(pfd\[1\]);  
70.         **if** ((fp = fdopen(pfd\[0\], type)) == NULL)  
71.             **return**(NULL);  
72.     \} **else** \{  
73.         close(pfd\[0\]);  
74.         **if** ((fp = fdopen(pfd\[1\], type)) == NULL)  
75.             **return**(NULL);  
76.     \}  
77.   
78.     childpid\[fileno(fp)\] = pid; /\* remember child pid for this fd \*/  
79.     **return**(fp);  
80. \}  
81.   
82.   
83. **int**  
84. pclose(**FILE** \*fp)  
85. \{  
86.     **int**     fd, stat;  
87.     pid\_t   pid;  
88.   
89.     **if** (childpid == NULL) \{  
90.         errno = EINVAL;  
91.         **return**(-1);     /\* popen() has never been called \*/  
92.     \}  
93.   
94.     fd = fileno(fp);  
95.     **if** ((pid = childpid\[fd\]) == 0) \{  
96.         errno = EINVAL;  
97.         **return**(-1);     /\* fp wasn't opened by popen() \*/  
98.     \}  
99.   
100.     childpid\[fd\] = 0;  
101.     **if** (fclose(fp) == EOF)  
102.         **return**(-1);  
103.   
104.     **while** (waitpid(pid, &stat, 0) < 0)  
105.         **if** (errno != EINTR)  
106.             **return**(-1); /\* error other than EINTR from waitpid() \*/  
107.   
108.     **return**(stat);   /\* return child's termination status \*/  
109. \}

[view plain]: http://blog.csdn.net/qian_f/article/details/8227435#

发表评论取消回复

表情：

评论列表（有 0 条评论，153人围观）

还没有评论，来说两句吧...

相关阅读

相关 python os popen用法_python命令调用函数os.popen

\!/usr/bin/env pthon \--\--coding=utf-8--\-- import os from terminaltables import Asc

柔光的暖阳◎/ 2023年01月08日 08:09/ 0 赞/ 142 阅读

相关函数popen()

转载：http://blog.csdn.net/qian\_f/article/details/8227435 函数说明　　popen()函数通过创建一个管道，调

川长思鸟来/ 2022年08月23日 05:45/ 0 赞/ 154 阅读

相关 popen

\include <stdio.h> FILE \popen(const char \command, const char \type)

亦凉/ 2022年08月12日 01:13/ 0 赞/ 129 阅读

相关基于管道的popen和pclose函数

标准I/O函数库提供了popen函数，它启动另外一个进程去执行一个shell命令行。这里我们称调用popen的进程为父进程，由popen启动的进程称为子进程。 popen

r囧r小猫/ 2022年08月05日 12:08/ 0 赞/ 137 阅读

相关函数popen

一.popen函数 1.简介创建一个管道，然后再创建一个进程。然后执行命令 2.调用格式 \include <stdio.h> FILE \p

系统管理员/ 2022年08月05日 08:20/ 0 赞/ 227 阅读

相关 popen函数的应用

Linux C 　　进程I/O函数,与pclose函数一起使用。表头文件　　\include < [stdio.h][]> 函数定义　　FILE \

灰太狼/ 2022年06月12日 12:43/ 0 赞/ 199 阅读

相关基于管道的popen和pclose函数

标准I/O函数库提供了popen函数，它启动另外一个进程去执行一个shell命令行。这里我们称调用popen的进程为父进程，由popen启动的进程称为子进程。 popen

布满荆棘的人生/ 2022年06月11日 00:23/ 0 赞/ 152 阅读

相关 popen和pclose函数

理论：库函数： popen(); 函数声明： FILE \popen ( char \command, char \type); 返回值： n

谁借莪１个温暖的怀抱￠/ 2022年06月10日 23:46/ 0 赞/ 883 阅读

相关 popen、system函数和fork的区别

本文转载自：[http://blog.csdn.net/liuxingen/article/details/47057539][http_blog.csdn.net_liuxi

港控/mmm°/ 2022年06月01日 10:53/ 0 赞/ 258 阅读

相关 Linux之popen()函数实现重定向功能

设计一个程序，要求利用popen函数，实现“ls –l > file.txt”的重定向功能，file.txt在程序中创建。我们先来观赏一个很好的例子 ![water

本是古典何须时尚/ 2021年12月16日 21:03/ 0 赞/ 321 阅读