精华内容
参与话题
问答
  • Popen

    2020-12-25 19:07:02
    <div><p>This pull request adds <code>popen</code> and <code>popen_pipeline</code> which are based on the existing <code>pipeline</code> (and aim to obsolete it), fixing issue #81 (because stdout is no...
  • popen

    2019-05-15 15:13:14
    popen()可以执行shell命令,并读取此命令的返回值;  popen()函数通过创建一个管道,调用fork()产生一个子进程,执行一个shell以运行命令来开启一个进程。可以通过这个管道执行标准输入输出操作。这个管道必须由...

    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);
            }
    }
    

    展开全文
  • popen uci

    2020-12-06 01:33:05
    t behave with popen_uci at initialisation. <p>Logger shows connection made << uci <p>but no return of engine id, author etc. <p>the popen_uci code works fine with other test engines and my ...
  • popen函数

    2020-11-26 21:05:16
    popen函数 函数原型: FILE * popen(conste char * command, const char * type); 函数说明:popen()会调用fork()生成子进程,在子进程中调用/bin/sh -c来执行参数command的指令,command对应的指令与在终端命令行...

    popen函数

    函数原型:

    FILE * popen(conste char * command, const char * type);
    

    函数说明:popen()会调用fork()生成子进程,在子进程中调用/bin/sh -c来执行参数command的指令,command对应的指令与在终端命令行中输入的命令相似如:“ls - l”、"/tmp/load_usb.sh"等

    参数:
    type:可使用“r”或者"w",分别代表读取及写入,但由于popen是以创建管道的方式创建进程连接到子进程的标准输出设备或标准输入设备,因此其带有管道的一些特性,同一时刻只能定义为写或者读。

    command:如其名,单纯是一个命令字符串指针。

    返回值:文件指针,函数执行成功返回文件指针,否则返回NULL。

    在使用我们可以使用popen函数运行开机初始化设备时所需要加载的驱动脚本,比如:

    #include <stdio.h> 
    int  main(int argc, char *argv[]) 
    { 
        FILE * fp; 
        char buffer[1024];
        
        sprintf(buffer, "/customer/sys_ko/load.sh");
        fp = popen(&buffer, "r"); 
        pclose(fp); 
        
        return 0;
    }
    

    执行此程序后系统会执行/customer/sys_ko/目录下的脚本文件load.sh

    展开全文
  • <div><p>This fix issue #141 on master branch, by using internal popen.popen()</p><p>该提问来源于开源项目:viewvc/viewvc</p></div>
  • 从python2.4版本开始,可以用subprocess这...subprocess意在替代其他几个老的模块或者函数,比如:os.system os.spawn* os.popen* popen2.* commands.*一、subprocess.Popensubprocess模块定义了一个类: Popenclass...

    从python2.4版本开始,可以用subprocess这个模块来产生子进程,并连接到子进程的标准输入/输出/错误中去,还可以得到子进程的返回值。

    subprocess意在替代其他几个老的模块或者函数,比如:os.system os.spawn* os.popen* popen2.* commands.*

    一、subprocess.Popen

    subprocess模块定义了一个类: Popen

    class subprocess.Popen( args,

    bufsize=0,

    executable=None,

    stdin=None,

    stdout=None,

    stderr=None,

    preexec_fn=None,

    close_fds=False,

    shell=False,

    cwd=None,

    env=None,

    universal_newlines=False,

    startupinfo=None,

    creationflags=0)

    各参数含义如下:

    args:

    args参数。可以是一个字符串,可以是一个包含程序参数的列表。要执行的程序一般就是这个列表的第一项,或者是字符串本身。

    subprocess.Popen(["cat","test.txt"])

    subprocess.Popen("cat test.txt")

    这两个之中,后者将不会工作。因为如果是一个字符串的话,必须是程序的路径才可以。(考虑unix的api函数exec,接受的是字符串

    列表)

    但是下面的可以工作

    subprocess.Popen("cat test.txt", shell=True)

    这是因为它相当于

    subprocess.Popen(["/bin/sh", "-c", "cat test.txt"])

    在*nix下,当shell=False(默认)时,Popen使用os.execvp()来执行子程序。args一般要是一个【列表】。如果args是个字符串的

    话,会被当做是可执行文件的路径,这样就不能传入任何参数了。

    注意:

    shlex.split()可以被用于序列化复杂的命令参数,比如:

    >>> shlex.split('ls ps top grep pkill')

    ['ls', 'ps', 'top', 'grep', 'pkill']

    >>>import shlex, subprocess

    >>>command_line = raw_input()

    /bin/cat -input test.txt -output "diege.txt" -cmd "echo '$MONEY'"

    >>>args = shlex.split(command_line)

    >>> print args

    ['/bin/cat', '-input', 'test.txt', '-output', 'diege.txt', '-cmd', "echo '$MONEY'"]

    >>>p=subprocess.Popen(args)

    可以看到,空格分隔的选项(如-input)和参数(如test.txt)会被分割为列表里独立的项,但引号里的或者转义过的空格不在此列

    。这也有点像大多数shell的行为。

    http://blog.csdn.net/g457499940/article/details/17068277

    展开全文
  • No popen support

    2020-11-27 15:18:22
    <div><p>Is there a counterpart to popen as the (broken) EventMachine::popen or is spawning processes seen differently in Celluloid? <p>Thank you</p><p>该提问来源于开源项目:celluloid/celluloid-...
  • popen 函数

    2017-11-06 15:31:00
    函数原型: #include<stdio.h> FILE* popen(const char* command, const char* type); void pclose(FILE* stream); man文本英语描述: DESCRIPTION: The popen() function ope...

    函数原型:

    #include<stdio.h>

    FILE*   popen(const  char*  command,    const   char*  type);

    void  pclose(FILE*  stream);


    man文本英语描述:

    DESCRIPTION:
           The popen() function opens a process by creating a pipe,  forking,  and
           invoking  the shell.  Since a pipe is by definition unidirectional, the
           type argument may specify  only  reading  or  writing,  not  both;  the
           resulting stream is correspondingly read-only or write-only.


          The  command argument is a pointer to a null-terminated string contain‐
           ing a shell command line.  This command is passed to /bin/sh using  the
           -c  flag;  interpretation, if any, is performed by the shell.  The type
           argument is a pointer to a null-terminated string  which  must  contain
           either the letter 'r' for reading or the letter 'w' for writing.  Since
           glibc 2.9, this argument can additionally include the letter 'e', which
           causes  the close-on-exec flag (FD_CLOEXEC) to be set on the underlying
           file descriptor; see the description of the O_CLOEXEC flag  in  open(2)
           for reasons why this may be useful.

    RETURN VALUE:
           The popen() function returns NULL if the fork(2) or pipe(2) calls fail,
           or if it cannot allocate memory.
           The pclose() function returns -1 if wait4(2) returns an error, or  some
           other error is detected.  In the event of an error, these functions set
           errno to indicate the cause of the error.
    ERRORS:
           The popen() function does not set errno if memory allocation fails.  If
           the  underlying  fork(2)  or pipe(2) fails, errno is set appropriately.
           If the type argument is invalid, and this condition is detected,  errno
           is set to EINVAL.
           If pclose() cannot obtain the child status, errno is set to ECHILD.


    中文总结:

    1. popen函数是通过创建一个管道的方式打开一个进程,并调用shell。因为管道是被定义为单向的,所以type的值只能是r或w其中的一个,结果流也是如此。

    2. command(命令行/命令的意思)参数:是一个以NULL结尾的字符串,这个字符串应是一个shell命令。这个命令会被送到 /bin/sh中,并以 -c执行即被shell执行。

    3. type参数:只能是r或w中的一个,r或w是相当command管道而言的。r表示从command管道中读,w表示通过command管道输出到stdout中(输出流为全缓冲)。

    4. 返回值:如果fork或者pipe失败,或者不能分配到内存都会返回NULL,成功则返回标志I/O流。popen没有为申请内存失败设置errno值,但fork和pipe都有其相应的errno值。如果type参数不合法,errno会别设置为EINVAL.

    注意:只能用pclose函数进行关闭操作,不能用fclose。


    相关代码:

    type为  r时:

    #include<stdio.h>
    #include<unistd.h>
    #include<stdlib.h>
    #include<sys/types.h>
    #include<string.h>
    const int BUF_SIZE = 1024;

    int main()
    {
        FILE* stream;
        FILE* wstream;
        char buf[BUF_SIZE];

        stream = popen("ls -l","r");
        wstream = fopen("test_popen.txt","w+");

        memset(buf, '\0', sizeof(buf));
        fread(buf, sizeof(char), sizeof(buf), stream);//把返回标准I/O流内的内容读到buf中
        fwrite(buf,sizeof(char), strlen(buf), wstream);

        fclose(wstream);//一定要记得关闭
        pclose(stream);//只能用pclose不能用fclose

        return 0;
    }

    执行结果:

    wKiom1cM25WiarsQAABpPzqeJMM765.png


    当type为 w  时:(此时popen函数会通过FIFO管道直接向stdout中写数据)

    #include<stdio.h>

    int main()
    {
        FILE* stream;
        stream = popen("ls -l","w");
        if(stream == NULL)
        {
            perror("popen");
            return -1;
        }
        pclose(stream);
        return 0;
    }


    wKioL1cM3t3SYSpqAABKBRBo5j8839.png

    注意:一个执行的命令是 cat  test_popen.txt        一个是./a.out




    以下是在网上找到的popen函数和pclose函数实现的代码:

    Figure 15.12. The popen and pclose functions  

    #include "apue.h"  

    #include <errno.h>  

    #include <fcntl.h>  

    #include <sys/wait.h>  

      

    /* 

     * Pointer to array allocated at run-time. 

     */  

    static pid_t    *childpid = NULL;  

      

    /* 

     * From our open_max(), Figure 2.16. 

     */  

    static int      maxfd;  

      

    FILE *  

    popen(const char *cmdstring, const char *type)  

    {  

        int     i;  

        int     pfd[2];  

        pid_t   pid;  

        FILE    *fp;  

      

        /* only allow "r" or "w" */  

        if ((type[0] != 'r' && type[0] != 'w') || type[1] != 0) {  

            errno = EINVAL;     /* required by POSIX */  

            return(NULL);  

        }  

      

        if (childpid == NULL) {     /* first time through */  

            /* allocate zeroed out array for child pids */  

            maxfd = open_max();  

            if ((childpid = calloc(maxfd, sizeof(pid_t))) == NULL)  

                return(NULL);  

        }  

      

        if (pipe(pfd) < 0)  

            return(NULL);   /* errno set by pipe() */  

      

        if ((pid = fork()) < 0) {  

            return(NULL);   /* errno set by fork() */  

        } else if (pid == 0) {                           /* child */  

            if (*type == 'r') {  

                close(pfd[0]);  

                if (pfd[1] != STDOUT_FILENO) {  

                    dup2(pfd[1], STDOUT_FILENO);  

                    close(pfd[1]);  

                }  

            } else {  

                close(pfd[1]);  

                if (pfd[0] != STDIN_FILENO) {  

                    dup2(pfd[0], STDIN_FILENO);  

                    close(pfd[0]);  

                }  

            }  

      

            /* close all descriptors in childpid[] */  

            for (i = 0; i < maxfd; i++)  

                if (childpid[i] > 0)  

                    close(i);  

      

            execl("/bin/sh""sh""-c", cmdstring, (char *)0);  

            _exit(127);  

        }  

      

        /* parent continues... */  

        if (*type == 'r') {  

            close(pfd[1]);  

            if ((fp = fdopen(pfd[0], type)) == NULL)  

                return(NULL);  

        } else {  

            close(pfd[0]);  

            if ((fp = fdopen(pfd[1], type)) == NULL)  

                return(NULL);  

        }  

      

        childpid[fileno(fp)] = pid; /* remember child pid for this fd */  

        return(fp);  

    }  

      

      

    int  

    pclose(FILE *fp)  

    {  

        int     fd, stat;  

        pid_t   pid;  

      

        if (childpid == NULL) {  

            errno = EINVAL;  

            return(-1);     /* popen() has never been called */  

        }  

      

        fd = fileno(fp);  

        if ((pid = childpid[fd]) == 0) {  

            errno = EINVAL;  

            return(-1);     /* fp wasn't opened by popen() */  

        }  

      

        childpid[fd] = 0;  

        if (fclose(fp) == EOF)  

            return(-1);  

      

        while (waitpid(pid, &stat, 0) < 0)  

            if (errno != EINTR)  

                return(-1); /* error other than EINTR from waitpid() */  

      

        return(stat);   /* return child's termination status */  

    }  










    本文转自 ye小灰灰  51CTO博客,原文链接:http://blog.51cto.com/10704527/1763143,如需转载请自行联系原作者
    展开全文
  • popen详解

    2019-01-23 10:45:33
    popen详解 说明:本文题目来源于牛客网,答案分析来源个人,仅为参考 1、请问下面的程序最后会产生多少个进程: int main( ){ int i; for(i = 0; i&lt;5;i++){ int pid = fork(); if(pid == 0){ ...
  • [638]python os.popen() 方法

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

    2020-12-02 02:31:38
    <p>However when the process is spawned using Popen which is supposed to be non-blocking qtile freezes. I can still move the mouse but all windows stall. </p><p>该提问来源于开源项目:qtile/qtile...
  • ###subprocess.Popen###首先先看Popen类:class subprocess.Popen( args,bufsize=0,executable=None,stdin=None,stdout=None,stderr=None,preexec_fn=None,close_fds=False,shell=False,cwd=None,env=None,universal_...
  • subprocess.Popen(args,bufsize=0,executable=None,stdin=None,stdout=None,stderr=None,preexec_fn=None,close_fds=False,shell=False,cwd=None,env=None,universal_newlines=False,startupinfo=None,creationflags...
  • linux popen函数

    2010-04-28 20:45:18
    linux popen函数linux popen函数linux popen函数linux popen函数
  • 参考http://zsl-oo7.blog.163.com/blog/static/353297032013101101820439/一:基本概念subprocess模块中只定义了一个类,PopenPopen的构造函数创建一个进程:p=Popen(["nslookup","www.baidu.com","8.8.8.8"],...
  • s custom popen module was written some 20 years ago to avoid the security pitfalls of using <code>os.system()</code> or <code>os.popen()</code> (which accept shell-like command strings that require ...

空空如也

1 2 3 4 5 ... 20
收藏数 8,929
精华内容 3,571
关键字:

popen