标签: spawn

在节点中,我使用一个模块(GM),发现它使用 spawn从child_process模块传递参数给GraphicMagick的convert可执行文件.

我正在将用户提交的信息传递给GM​​.是否存在安全问题,用户可以使用管道(或其他命令行欺骗)进行某种注入攻击？或者确实spawn可以防范？如果没有,在这种情况下是否有最佳做法可以转义用户提交的值？

我使用节点child_process API

https://nodejs.org/api/child_process.html#child_process_child_process_spawn_command_args_options

var child = child_process.spawn(cmd, val, options);

从孩子我使用以下

child.stdout.pipe(process.stdout);
child.stderr.pipe(process.stderr);

我可以在这些管道事件里面添加一些代码如console.log吗？

例如,可能与原型

child.on('error', function(err) {
        console.log(err);
    });

更新

我需要的是听听这个childProcess.stderr.pipe(process.stderr);,以防我得到错误process.exit(1)

当我尝试像我得到错误的东西

    child.stderr.pipe(function () {
            console.log("im here");
            process.stderr;
            process.exit(1);
        }
    );

UPDATE2

我尝试以下方法

var child = child_process.spawn(cmd, value, opt);

child.stdout.on('data', function (data) {
    console.log("IM HERE");
    console.log('data' + data);
});
child.stderr.on('data', function (data) {
    console.log("IM HERE");
    console.log('test: ' + data);
    reject(data);
});
child.on('close', function (code) {
    console.log("IM HERE");
    console.log("close");
});
child.on('error', function (err) {
    console.log("IM HERE");
    console.log(err);
}); …

我以这种方式启动一个 spawn 子进程：

let process = spawn(apiPath, {
  detached: true
})

process.unref()

process.stdout.on('data', data => { /* do something */ })

当我开始这个过程时，我需要保持它的连接，因为我想读取它的输出。但就在关闭我的 Node 进程（父进程）之前，我想分离所有未完成的子进程以保持它们在后台运行，但正如文档所说：

当使用 detached 选项启动一个长时间运行的进程时，进程在父进程退出后不会一直在后台运行，除非它提供了一个没有连接到父进程的 stdio 配置。

但是有了这个选项，stdio: 'ignore'我无法阅读stdout这是一个问题。

我试图在关闭父进程之前手动关闭管道，但没有成功：

// Trigger just before the main process end
process.stdin.end()
process.stderr.unpipe()
process.stdout.unpipe()

我正在使用libuv.我已经阅读了http://nikhilm.github.com/uvbook/processes.html但仍然无法弄清楚如何捕获子进程的stdout以便它在父进程中可用(但不能代替父进程的stdin) ).

我的代码目前是:

#include <stdio.h>
#include <stdlib.h>
#include "../../libuv/include/uv.h"

uv_loop_t *loop;
uv_process_t child_req;
uv_process_options_t options;
uv_pipe_t apipe;

void on_child_exit(uv_process_t *req, int exit_status, int term_signal) {
    fprintf(stderr, "Process exited with status %d, signal %d\n", exit_status, term_signal);
    uv_close((uv_handle_t*) req, NULL);
}

uv_buf_t alloc_buffer(uv_handle_t *handle, size_t len) {
    printf("alloc_buffer called\n");
    uv_buf_t buf;
    buf.base = malloc(len);
    buf.len = len;
    return buf;
}

void read_apipe(uv_stream_t* stream, ssize_t nread, uv_buf_t buf) {
    printf("read %li bytes from the child process\n", nread);
}

int main(int argc, …

我正在尝试让nodejs与冒险,一个旧的基于文本的游戏进行交互.我们的想法是将冒险作为一个子进程开放,然后通过写入stdin并放置一个事件监听器来玩游戏stdout.

游戏开始时,会打印出一个初始值:

欢迎来到冒险!你想要指示吗？

所以为了说明我的问题,我有一个nodejs + express实例:

var childProcess = require('child_process');
var spawn = childProcess.spawn;
var child = spawn('adventure');

console.log("spawned: " + child.pid);

child.stdout.on('data', function(data) {
  console.log("Child data: " + data);
});
child.on('error', function () {
  console.log("Failed to start child.");
});
child.on('close', function (code) {
  console.log('Child process exited with code ' + code);
});
child.stdout.on('end', function () {
  console.log('Finished collecting data chunks.');
});

但是当我启动服务器时,游戏中的文本没有到达事件监听器:

spawned: 24250

这就是我得到的所有输出.该child.stdout.on甚至监听器永远不会被调用.为什么游戏中的初始线不会被拾取？

如果我将以下行附加到上面的javascript块,则程序输出立即出现.所以adventure运行,我现在可以强制它触发child.stdout.on …

首先,我是一个完整的菜鸟,并且昨天开始使用Node.JS(这也是我多年来第一次使用Linux)所以请保持良好和明确

我目前正在制作Node.JS程序,其中包括启动shell命令(主要是:安装usb驱动器).我正在使用

var spawn = require('child_process').spawnSync;

function shspawn(command) {
    spawn('sh', ['-c', command], { stdio: 'inherit' });
}

shspawn('echo Hello world');
shspawn('mkdir newdir');

这对我来说是一种非常舒适的方式.问题是我想以一种方式存储变量中的"ls"命令的输出,例如

var result = shspawn('ls -l')

我在线阅读了一些例子,但他们很少使用spawn,当他们这样做时,它对我不起作用(我想我可能做错了,但我又是Node中的菜鸟)

如果你们有一个比使用child_process_spawnSync更好的想法,我会对任何想法持开放态度,但我希望尽可能长时间保持我的程序包免费:)

编辑:我需要它同步工作!这就是我开始使用spawnSync的原因.我将使用一些命令,如dd,这需要时间,需要在程序转移到另一个命令之前完全完成.

我正在尝试构建一个启动其他完全独立进程的Python守护进程.

一般的想法是针对给定的shell命令,每隔几秒轮询一次并确保命令的k个实例正在运行.我们保持PID文件的目录,当我们轮询我们删除PID文件,其PID是不再运行和启动(并为PID文件)然而,许多流程,我们需要去ķ他们.

子进程也需要完全独立,这样如果父进程死掉,子进程就不会被杀死.根据我的阅读,似乎没有办法用subprocess模块做到这一点.为此,我使用了这里提到的片段:

http://code.activestate.com/recipes/66012-fork-a-daemon-process-on-unix/

我做了一些必要的修改(你会在附加的代码片段中看到注释掉的行):

1. 原始父进程无法退出,因为我们需要启动程序守护程序无限期地保留.
2. 子进程需要以与父进程相同的cwd开始.

这是我的spawn fn和测试:

import os
import sys
import subprocess
import time

def spawn(cmd, child_cwd):
    """
    do the UNIX double-fork magic, see Stevens' "Advanced 
    Programming in the UNIX Environment" for details (ISBN 0201563177)
    http://www.erlenstar.demon.co.uk/unix/faq_2.html#SEC16
    """
    try: 
        pid = os.fork() 
        if pid > 0:
            # exit first parent
            #sys.exit(0) # parent daemon needs to stay alive to launch more in the future
            return
    except OSError, e: 
        sys.stderr.write("fork #1 failed: %d …

语境:

我有一些使用的代码pexpect,其工作是给出一个命令的"实时"输出.即,当命令生成一些输出时或不久之后打印出一些内容,而不是等到命令完成然后与其输出交互.

我正在做的就是启动和停止服务.我spawn通过该过程执行此操作,然后在打印时输出每一行,如下所示:

def watch(process):
    output = ""
    while True:
        try:
            line = process.read_nonblocking(timeout = -1)
            print(line, end ="")
            output += line
        except pexpect.EOF:
            break
    del process
    return output

while True:
    print("IN 1")
    process = pexpect.spawn("service",["zend-server", "stop"], timeout = None)
    watch(process)
    print("OUT 1")

    print("IN 2")
    process = pexpect.spawn("service",["zend-server", "start"], timeout = None)
    watch(process)
    print("OUT 2")

这段代码应该只循环服务:启动它并反复停止它,打印开始/停止的输出.它打印输出正常.但是,它最终会在"OUT 2"之前挂起.我可以查看输出,并看到service调用停止执行.但是,该watch功能从不会提高EOF并退出.

每项服务都不会发生这种情况.有些服务无限循环.zend-server但是,与其他一些不相关的命令一起,以相同的方式间歇性地失败.

通过"最终挂起",我的意思是它启动/停止服务一些(每次运行变量)次,并挂起.它通常在4-6之后长大,虽然从来没有在第一次通话 - 总是至少在第二次(因此del声明;我认为我会安全地玩).

Python 2.6.6,CentOS(64)6.3,Pexpect 2.3-6,FWIW

题:

为什么pexpect挂在某些命令上？我该如何解决这个问题？使用超时不是一个可行的解决方案,因为其中一些命令实际上可以运行任意长时间. …

有没有一种简单的方法来模拟Node.js child_process spawn函数？

我有如下代码,并希望在单元测试中测试它,而不必依赖于实际的工具调用:

var output;
var spawn = require('child_process').spawn;
var command = spawn('foo', ['get']);

command.stdout.on('data', function (data) {
    output = data;
});

command.stdout.on('end', function () {
    if (output) {
        callback(null, true);
    }
    else {
        callback(null, false);
    }
});

是否有(经过验证和维护的)库允许我模拟spawn调用并让我指定模拟调用的输出？

我不想依赖工具或操作系统来保持测试简单和孤立.我希望能够运行测试而无需设置复杂的测试夹具,这可能意味着很多工作(包括更改系统配置).

是否有捷径可寻？

我收到这个错误

当运行这段代码时，

 reasoner = new Reasoner({
    type: 'local', 
    folder: 'csp_files' 
 });

 console.log("solving Model");
 reasoner.solve(Model, (err, stdout, stderr, isSatisfiable) => {
    console.log("isSatisfiable");
    console.log(isSatisfiable);
    if (err) {
        // manage error
        console.log("model error");
        future_response.return("model error");
    } else {
        // manage solution
        console.log(stdout);
        console.log(isSatisfiable);
        future_response.return(stdout);
    }
 });
 console.log("Model solved");
 return future_response.wait();

根据我所读到的内容，我应该找到一种方法来重写stdout以支持更大的缓冲区长度，有人可以建议我如何做到这一点吗？我相信图书馆spawn是我应该使用的，对吗？我使用节点版本12.16.1和流星