精华内容
下载资源
问答
  • popen 使用方法

    万次阅读 多人点赞 2017-08-23 09:41:21
    popen()可以执行shell命令,并读取此命令的返回值;...这个管道必须由pclose()函数关闭,必须由pclose()函数关闭,必须由pclose()函数关闭,而不是fclose()函数(若使用fclose则会产生僵尸进程)。p
     
    

         popen()可以执行shell命令,并读取此命令的返回值;  

         popen()函数通过创建一个管道,调用fork()产生一个子进程,执行一个shell以运行命令来开启一个进程。可以通过这个管道执行标准输入输出操作。这个管道必须由pclose()函数关闭,必须由pclose()函数关闭,必须由pclose()函数关闭而不是fclose()函数(若使用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。

     

    函数原型

    FILE *popen(const char *command, const char *type);
    int pclose(FILE *stream);

    例:

    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <string.h>
    
    void
    print_result(FILE *fp)
    {
            char buf[100];
    
            if(!fp) {
                    return;
            }
            printf("\n>>>\n");
            while(memset(buf, 0, sizeof(buf)), fgets(buf, sizeof(buf) - 1, fp) != 0 ) {
                    printf("%s", buf);
            }
            printf("\n<<<\n");
    }
    
    int
    main(void)
    {
            FILE *fp = NULL;
    
            while(1) {
                    fp = NULL;
                    fp = popen("ls", "r");
                    if(!fp) {
                            perror("popen");
                            exit(EXIT_FAILURE);
                    }
                    print_result(fp);
                    pclose(fp);
                    sleep(1);
            }
    }
    


    展开全文
  • 今天小编就为大家分享一篇python中的subprocess.Popen()使用详解,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • popen使用方法及场景

    千次阅读 2018-04-16 22:34:53
    Popen使用方法 1.Popen的应用场景 popen应用于执行shell命令,并读取此命令的返值,或者与执行的命令进行交互。 2.Popen的实现 Popen()函数通过创建一个管道,调用fork()产生一个子进程,然后调用execl("...

    Popen的使用方法

    1.Popen的应用场景

    popen应用于执行shell命令,并读取此命令的返值,或者与执行的命令进行交互。

    2.Popen的实现

    Popen()函数通过创建一个管道,调用fork()产生一个子进程,然后调用execl("/bin/sh", "sh", "-c”,command,0);执行shell命令。可以通过这个管道进行标准输入输出操作,下面会附上源码。

    3.Pclose操作

    Pclose()函数会闭标准i/0流,等待子进程结束,然后返回shell终止状态。如果不执行,则pclose()返回终止状态就是shell的exit状态。

     源码附上:

    /* Copyright (C) 2004       Manuel Novoa III    <mjn3@codepoet.org>
     * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org>
     *
     * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball.
     *
     * Dedicated to Toni.  See uClibc/DEDICATION.mjn3 for details.
     */
    
    /* Jan 1, 2004
     *
     * Rewrite popen for SUSv3 compliance.
     *   Added a list of popen()'d to store pids and use waitpid() in pclose().
     *   Loop on waitpid() failure due to EINTR as required.
     *   Close parent's popen()'d FILEs in the {v}fork()'d child.
     *   Fix failure exit code for failed execve().
     */
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <errno.h>
    #include <unistd.h>
    #include <sys/wait.h>
    #include <bits/uClibc_mutex.h>
    
    #ifdef __UCLIBC_MJN3_ONLY__
    #warning "hmm... susv3 says Pipe streams are byte-oriented."
    #endif /* __UCLIBC_MJN3_ONLY__ */
    
    
    /* uClinux-2.0 has vfork, but Linux 2.0 doesn't */
    #include <sys/syscall.h>
    #if ! defined __NR_vfork
    # define vfork fork
    # define VFORK_LOCK		((void) 0)
    # define VFORK_UNLOCK		((void) 0)
    #endif
    
    #ifndef VFORK_LOCK
    __UCLIBC_MUTEX_STATIC(mylock, PTHREAD_MUTEX_INITIALIZER);
    # define VFORK_LOCK		__UCLIBC_MUTEX_LOCK(mylock)
    # define VFORK_UNLOCK		__UCLIBC_MUTEX_UNLOCK(mylock)
    #endif
    
    struct popen_list_item {
    	struct popen_list_item *next;
    	FILE *f;
    	pid_t pid;
    };
    
    static struct popen_list_item *popen_list /* = NULL (bss initialized) */;
    
    FILE *popen(const char *command, const char *modes)
    {
    	FILE *fp;
    	struct popen_list_item *pi;
    	struct popen_list_item *po;
    	int pipe_fd[2];
    	int parent_fd;
    	int child_fd;
    	int child_writing;			/* Doubles as the desired child fildes. */
    	pid_t pid;
    
    	child_writing = 0;			/* Assume child is writing. */
    	if (modes[0] != 'w') {		/* Parent not writing... */
    		++child_writing;		/* so child must be writing. */
    		if (modes[0] != 'r') {	/* Oops!  Parent not reading either! */
    			__set_errno(EINVAL);
    			goto RET_NULL;
    		}
    	}
    
    	if (!(pi = malloc(sizeof(struct popen_list_item)))) {
    		goto RET_NULL;
    	}
    	// 打开一个pipe,管道是单向。故数据流只能单向流动。
    	if (pipe(pipe_fd)) {
    		goto FREE_PI;
    	}
    
    	//下面两个描述符就是管道的两端的描述,一个为读一个为写。
    	child_fd = pipe_fd[child_writing]; 
    	parent_fd = pipe_fd[1-child_writing]; 
    	//fdopen就是打开一个描述,fd相同模式或者字集的方式打开。意思就是把一个已找打开的流与一个文件描述符相关联,且
    	//这个文件描述是唯一的,这样也就可以保证这个函数接口的可重入性。如果设计的不可重入性,也就没必要再做一次fdopen了。
    	if (!(fp = fdopen(parent_fd, modes))) {
    		close(parent_fd);
    		close(child_fd);
    		goto FREE_PI;
    	}
    
    	VFORK_LOCK;
    	//再这里创建一个子进程,然后执行 shell命令。这里最重的两步就是用pipe的两个描述替换标准输入或者输出。
    	if ((pid = vfork()) == 0) {	/* Child of vfork... */
    		close(parent_fd);
    		if (child_fd != child_writing) {
    			dup2(child_fd, child_writing); //用child_fd来代替标准输入或输出。
    			close(child_fd);
    		}
    
    		/* SUSv3 requires that any previously popen()'d streams in the
    		 * parent shall be closed in the child. */
    		//关闭不必要的资源。
    		for (po = popen_list ; po ; po = po->next) {
    			close(po->f->__filedes);
    		}
    
    		//执行exec shell,这个时候标准输入/输出就变为pipe管道的一端了。
    		//这里只能实现单向的功能。要么读要么写。
    		execl("/bin/sh", "sh", "-c", command, (char *)0);
    
    		/* SUSv3 mandates an exit code of 127 for the child if the
    		 * command interpreter can not be invoked. */
    		_exit(127);
    	}
    	VFORK_UNLOCK;
    
    	/* We need to close the child filedes whether vfork failed or
    	 * it succeeded and we're in the parent. */
    	close(child_fd);
    	//将当前的信息保存到全局链表。为了是pclose可以找到对的子进程与通信文件描述。
    	if (pid > 0) {				/* Parent of vfork... */
    		pi->pid = pid;
    		pi->f = fp;
    		VFORK_LOCK;
    		pi->next = popen_list;
    		popen_list = pi;
    		VFORK_UNLOCK;
    
    		return fp;
    	}
    
    	/* If we get here, vfork failed. */
    	fclose(fp);					/* Will close parent_fd. */
    
     FREE_PI:
    	free(pi);
    
     RET_NULL:
    	return NULL;
    }
    
    #warning is pclose correct wrt the new mutex semantics?
    
    int pclose(FILE *stream)
    {
    	struct popen_list_item *p;
    	int stat;
    	pid_t pid;
    
    	/* First, find the list entry corresponding to stream and remove it
    	 * from the list.  Set p to the list item (NULL if not found). */
    	VFORK_LOCK;
    	if ((p = popen_list) != NULL) {
    		if (p->f == stream) {// 找到stream对应的popen结点。
    			popen_list = p->next;
    		} else {
    			struct popen_list_item *t;
    			do {
    				t = p;
    				if (!(p = t->next)) {
    					__set_errno(EINVAL); /* Not required by SUSv3. */
    					break;
    				}
    				if (p->f == stream) {
    					t->next = p->next;
    					break;
    				}
    			} while (1);
    		}
    	}
    	VFORK_UNLOCK;
    
    	if (p) {
    		pid = p->pid;			/* Save the pid we need */
    		free(p);				/* and free the list item. */
    
    		fclose(stream);	/* The SUSv3 example code ignores the return. */
    
    		/* SUSv3 specificly requires that pclose not return before the child
    		 * terminates, in order to disallow pclose from returning on EINTR. */
    		do {
    			if (waitpid(pid, &stat, 0) >= 0) { //等待子进程返回。获取返回值。
    				return stat;
    			}
    			if (errno != EINTR) {
    				break;
    			}
    		} while (1);
    	}
    
    	return -1;
    }
    

    举例附上:

    #include <stdio.h>
    #include <string.h>
    
    int main()
    {
    	FILE *fp = NULL;
    	char buf[1024] = "";
    
    	fp = popen("ls -al", "r");
    	if(fp == NULL)
    	{
    		perror("popen error\n");
    		return -1;
    	}
    	while(fgets(buf, sizeof(buf), fp) != 0)
    	{
    		printf("%s\n", buf);
    		memset(buf, 0x0, sizeof(buf));
    	}
    	pclose(fp);
    	return 0;
    }
    
    

     

     

     

     

    展开全文
  • C++popen用法

    万次阅读 2018-10-28 22:46:58
    开发过程当中,发现可执行文件的返回值不太方便获取,于是改成获取可执行文件的打印结果,根据打印结果进行判定,这里用到了popen。   popen: popen() 函数通过创建一个管道,调用 fork 产生一个子进程,执行一个...

    开发过程中,为了在一段C++代码中调用另一个C++写的可执行文件,并需要获取可执行文件的返回值,根据返回值进行校验。开发过程当中,发现可执行文件的返回值不太方便获取,于是改成获取可执行文件的打印结果,根据打印结果进行判定,这里用到了popen。

     

    popen:

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

    FILE * popen ( const char * command , const char * type );
    int pclose ( FILE * stream );

    利用popen获取命令行输出结果:

    #include<iostream>
    #include<stdio.h>
    #include<string.h>
    
    using namespace std;
    int main()
    {
        FILE *fp = NULL;
        char cmd[1024];
        char buf[1024];
        char result[4096];
        sprintf(cmd, "./test");
        if( (fp = popen(cmd, "r")) != NULL)
        {
            while(fgets(buf, 1024, fp) != NULL)
            {
                strcat(result, buf);
            }
            pclose(fp);
            fp = NULL;
        }
        cout<<"result:"<<result<<endl;
        return 0;
    }

     

     

    展开全文
  • linux popen用法详解

    万次阅读 2013-03-21 22:28:07
    函数原型:  #include “stdio.h”  FILE *popen( const char* command, const char* mode )  参数说明:  command: 是一个指向以 NULL 结束的 shell 命令字符串的指针。这行命令将被传到 bin/sh 并使用 -

    http://linux.chinaitlab.com/c/806015.html

    函数原型:

      #include “stdio.h”

      FILE *popen( const char* command, const char* mode )

      参数说明:

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

      mode: 只能是读或者写中的一种,得到的返回值(标准 I/O 流)也具有和 type 相应的只读或只写类型。如果 type 是 “r” 则文件指针连接到 command 的标准输出;如果 type 是 “w” 则文件指针连接到command 的标准输入。

      返回值:

      如果调用成功,则返回一个读或者打开文件的指针,如果失败,返回NULL,具体错误要根据errno判断

      int pclose (FILE* stream)

      参数说明:

      stream:popen返回的文件指针

      返回值:

      如果调用失败,返回 -1

      作用:

      popen() 函数用于创建一个管道:其内部实现为调用 fork 产生一个子进程,执行一个 shell 以运行命令来开启一个进程这个进程必须由 pclose() 函数关闭。

    例子:

      管道读:先创建一个文件test,然后再test文件内写入“Readpipe successfully !”

      #include “stdio.h”

      #include “stdlib.h”

      int main()

      {

      FILE *fp;

      char buf[200] = {0};

      if((fp = popen(“cat test”, “r”)) == NULL) {

      perror(“Fail to popen\n”);

      exit(1);

      }

      while(fgets(buf, 200, fp) != NULL) {

      printf(“%s”, buf);

      }

      pclose(fp);

      return 0;

      }

      打印输出: Read pipe successfully !

      管道读:

      #include “stdio.h”

      #include “stdlib.h”

      int main()

      {

      FILE *fp;

      char buf[200] = {0};

      if((fp = popen(“cat > test1″, “w”)) == NULL) {

      perror(“Fail to popen\n”);

      exit(1);

      }

      fwrite(“Read pipe successfully !”, 1, sizeof(“Read pipe successfully!”), fp);

      pclose(fp);

      return 0;

      }

      执行完毕后,当前目录下多了一个test1文件,打开,里面内容为Read pipe successfully !

    展开全文
  • popen()可以执行shell命令,并读取此命令的返回值   popen() 函数通过创建一个管道,调用 fork() 产生一个子进程,调用一个 shell 以运行命令来开启一个进程。可以通过这个管道执行标准输入输出操作。这个管道...
  • subprocess允许你去创建一个新的进程让其执行另外的程序,并与它...subprocess模块中基本的进程创建和管理由Popen类来处理.subprocess.popen是用来替代os.popen的. from subprocess import Popen, PIPE p = Pop...
  • popen 使用方法和kill功能描述

    千次阅读 2018-02-26 15:09:26
    转http://blog.csdn.net/stone8761/article/details/77498439[ KILL ]功能描述: 转 ...头文件用法:#include &lt;sys/types.h&gt; #include &lt;signal....
  • subprocess.Popen()的用法

    千次阅读 2019-09-20 09:01:21
    subprocess.Popen()的简单用法 subprocess 模块允许你生成新的进程,连接它们的输入、输出、错误管道,并且获取它们的返回码。 subprocess.Popen(args, shell=True, stderr=subprocess.PIPE, stdin=subprocess.PIPE,...
  • Linux中的popen()函数可以在程序中执行一个shell命令,并返回命令执行的结果。有两种操作模式,分别为读和写。在读模式中,程序中可以读取到命令的输出,其中有一个应用就是获取网络接口的参数。在写模式中,最常用...
  • C语言:popen函数的使用

    千次阅读 2020-03-25 14:53:21
    C语言:popen函数的使用 一、利用system函数调用shell命令,只能获取到shell命令的返回值,而不能获取shell命令的输出结果,那如果想获取输出结果怎么办呢?用popen函数可以实现。 二、定义函数:FILE * popen...
  • python的subprocess.Popen()的简单用法

    万次阅读 2017-04-15 20:43:41
    英语原文: https://www.python.org/dev/peps/pep-0324/ This module defines one class called Popen: class Popen(args, bufsize=0, executable=None, stdin=None, stdout=None, stderr=None, ...
  • linux popen 用法

    2015-03-27 09:53:20
     FILE *popen( const char* command, const char* mode )  参数说明:  command: 是一个指向以 NULL 结束的 shell 命令字符串的指针。这行命令将被传到 bin/sh 并使用 -c 标志,shell 将执行这个命令。 ...
  • popen使用方法及场景

    2021-08-02 14:48:46
    1. popen的应用场景 ...这个管道必须由pclose()函数关闭,必须由pclose()函数关闭,必须由pclose()函数关闭,而不是fclose()函数(若使用fclose则会产生僵尸进程)。pclose()函数关闭标准I/O流,等待命令执行
  • Python os.popen()方法用法

    千次阅读 2016-05-20 20:03:54
    os模块下的popen()可以调用shell命令或者shell脚本,但是默认无法获得调用的命令的标准输出值,可以使用以下方式获得:  A=os.popen('ls')  print A.read() 又如 在Python命令下输入如下的命令: import ...
  • popen用法

    2008-08-22 09:53:58
    popen函数及其使用 NAMEpopen, pclose - process I/O SYNOPSIS#include <stdio.h> FILE *popen(const char *command, const char *type); int pclose(FILE *stream); 描述popen() 函数.....
  • Linux popen用法

    2012-10-31 08:49:46
     进程I/O函数,与pclose函数一起使用。 表头文件  #include stdio.h> 函数定义  FILE * popen ( const char * command , const char * type );  int pclose ( FILE * stream ); 函数说明  ...
  • python中popen使用

    2019-10-24 16:09:06
    os.popen() 功能强于os.system() , os.popen() 可以返回回显的内容,以文件描述符返回 实例 import os r = os.popen(“ipconfig”) # 执行操作系统命令dir print(r.read()) 输出 以太网适配器 以太网: 连接特定的 ...
  • subprocess意在替代其他几个老的模块或者函数,比如:os.system os.spawn* os.popen* popen2.* commands.* 一、subprocess.Popen subprocess模块定义了一个类: Popen class subprocess.Popen( args, bufsize=...
  • 从python2.4版本开始,可以用subprocess这个...subprocess意在替代其他几个老的模块或者函数,比如:os.system os.spawn* os.popen* popen2.* commands.*一、subprocess.Popen subprocess模块定义了一个类: Popen cl...
  • [638]python os.popen() 方法

    万次阅读 多人点赞 2019-07-18 19:08:11
    os.popen() 方法用于从一个命令打开一个管道。 在Unix,Windows中有效 语法 popen()方法语法格式如下: os.popen(command[, mode[, bufsize]]) 参数 command – 使用的命令。 mode – 模式权限可以是 ‘r’(默认) ...
  • python的popen函数

    千次阅读 2019-04-18 11:49:02
    最近了解了一下python的popen函数的使用,主要是用来执行linux命令 函数使用 使用之前需要导入import os模块 使用方式: os.popen(cmd) 返回值: 返回一个文件句柄 import os cmd="/sbin/partx /dev/sdb" result_...
  • 有时候我们需要在程序里执行一些cmd命令,使用os或者其它模块中的popen方法去执行 这个问题一般是程序内有输入导致的,这个输入可以是input(),也可以是其它的一些stdin操作(如os.popen实际上会造成输入请求) 本质...
  • linux popen用法

    千次阅读 2011-06-30 12:34:00
    popen() 函数 用 创建管道 的 方式启动一个 进程, 并调用 shell. 因为 管道是被定义成单向的, 所以 type 参数 只能定义成 只读或者 只写, 不能是 两者同时, 结果流也相应的 是只读 或者 只写. command 参数 是 一个 ...
  • popen用法简单说明

    万次阅读 2019-03-08 13:00:07
    标准I/O函数库提供了popen函数,它启动另外一个进程去执行一个shell命令行。 这里我们称调用popen的进程为父进程,由popen启动的进程称为子进程。 popen函数还创建一个管道用于父子进程间通信。父进程要么从管道读...
  • 那么我们在python3中使用os.popen()出错该怎么办?本篇文章小编同样以错误的操作方法为大家进行讲解,一起找寻不对的地方吧。 在当前 desktop 目录下,有如下内容: desktop $ls client.py server.py 中文测试 ...
  • python中的subprocess.Popen()使用

    万次阅读 2018-10-10 09:44:17
    从python2.4版本开始,可以用subprocess这个模块来产生子进程,并连接到子进程的标准输入/输出/错误中去,还可以...subprocess意在替代其他几个老的模块或者函数,比如:os.system os.spawn* os.popen* popen2.* co...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,193
精华内容 7,677
关键字:

popen用法