subprocess.c File Reference

#include <rz_cons.h>
#include <rz_util.h>
#include <errno.h>
#include <sys/wait.h>

Go to the source code of this file.

Classes
struct	rz_subprocess_t

Macros
#define	BUFFER_SIZE   0x500

Functions
static void	subprocess_lock (void)
static void	subprocess_unlock (void)
static void	handle_sigchld (int sig)
static void *	sigchld_th (void *th)
RZ_API bool	rz_subprocess_init (void)
RZ_API void	rz_subprocess_fini (void)
static char **	create_child_env (const char *envvars[], const char *envvals[], size_t env_size)
static void	destroy_child_env (char **child_env)
RZ_API RzSubprocess *	rz_subprocess_start_opt (RzSubprocessOpt *opt)
static size_t	read_to_strbuf (RzStrBuf *sb, int fd, bool *fd_eof, size_t n_bytes)
static RzSubprocessWaitReason	subprocess_wait (RzSubprocess *proc, ut64 timeout_ms, int pipe_fd, size_t n_bytes)
	Wait for subprocess to do something, for a maximum of timeout_ms millisecond. More...
RZ_API RzSubprocessWaitReason	rz_subprocess_wait (RzSubprocess *proc, ut64 timeout_ms)
RZ_API ssize_t	rz_subprocess_stdin_write (RzSubprocess *proc, const ut8 *buf, size_t buf_size)
RZ_API RzStrBuf *	rz_subprocess_stdout_read (RzSubprocess *proc, size_t n, ut64 timeout_ms)
RZ_API RzStrBuf *	rz_subprocess_stdout_readline (RzSubprocess *proc, ut64 timeout_ms)
RZ_API void	rz_subprocess_kill (RzSubprocess *proc)
RZ_API RzSubprocessOutput *	rz_subprocess_drain (RzSubprocess *proc)
RZ_API void	rz_subprocess_free (RzSubprocess *proc)
RZ_API int	rz_subprocess_ret (RzSubprocess *proc)
RZ_API ut8 *	rz_subprocess_out (RzSubprocess *proc, int *length)
RZ_API ut8 *	rz_subprocess_err (RzSubprocess *proc, int *length)
RZ_API void	rz_subprocess_output_free (RzSubprocessOutput *out)
RZ_API RzSubprocess *	rz_subprocess_start (const char *file, const char *args[], size_t args_size, const char *envvars[], const char *envvals[], size_t env_size)

Variables
static RzPVector	subprocs
static RzThreadLock *	subprocs_mutex
static int	sigchld_pipe [2]
static RzThread *	sigchld_thread

Macro Definition Documentation

BUFFER_SIZE

#define BUFFER_SIZE   0x500

Definition at line 8 of file subprocess.c.

Function Documentation

create_child_env()

static char** create_child_env ( const char *  envvars[], const char *  envvals[], size_t  env_size  )

static

Definition at line 826 of file subprocess.c.

                                                                                              {
    char **ep;
    size_t new_env_size = env_size, size = 0;
    size_t *positions = RZ_NEWS(size_t, env_size);
    if (!positions) {
        return NULL;
    }
    for (size_t i = 0; i < env_size; i++) {
        positions[i] = SIZE_MAX;
    }
 
    char **environ = rz_sys_get_environ();
    for (ep = environ; *ep; ep++, size++) {
        size_t j;
 
        for (j = 0; j < env_size; j++) {
            if (positions[j] != SIZE_MAX) {
                continue;
            }
            size_t namelen = strlen(envvars[j]);
            if (!strncmp(*ep, envvars[j], namelen) && (*ep)[namelen] == '=') {
                positions[j] = size;
                new_env_size--;
                break;
            }
        }
    }
 
    char **new_env = RZ_NEWS(char *, size + new_env_size + 1);
    if (!new_env) {
        free(positions);
        return NULL;
    }
    for (size_t i = 0; i < size; i++) {
        new_env[i] = strdup(environ[i]);
    }
    for (size_t i = 0; i <= new_env_size; i++) {
        new_env[size + i] = NULL;
    }
 
    for (size_t i = 0; i < env_size; i++) {
        char *new_var = rz_str_newf("%s=%s", envvars[i], envvals[i]);
        if (positions[i] == SIZE_MAX) {
            // No env var exists with the same name, add it at the end
            free(new_env[size]);
            new_env[size++] = new_var;
        } else {
            // Replace the existing env var
            free(new_env[positions[i]]);
            new_env[positions[i]] = new_var;
        }
    }
    free(positions);
    return new_env;
}

References environ, free(), i, NULL, RZ_NEWS, rz_str_newf(), rz_sys_get_environ(), SIZE_MAX, and strdup().

Referenced by rz_subprocess_start_opt().

destroy_child_env()

static void destroy_child_env ( char **  child_env )

static

Definition at line 882 of file subprocess.c.

                                                {
    if (!child_env) {
        return;
    }
    char **ep;
    for (ep = child_env; *ep; ep++) {
        free(*ep);
    }
    free(child_env);
}

References free().

Referenced by rz_subprocess_start_opt().

handle_sigchld()

static void handle_sigchld ( int  sig )

static

Definition at line 732 of file subprocess.c.

                                    {
    ut8 b = 1;
    rz_xwrite(sigchld_pipe[1], &b, 1);
}

References b, rz_xwrite, and sigchld_pipe.

Referenced by rz_subprocess_init().

read_to_strbuf()

static size_t read_to_strbuf ( RzStrBuf *  sb, int  fd, bool *  fd_eof, size_t  n_bytes  )

static

Definition at line 1055 of file subprocess.c.

                                                                                 {
    char buf[BUFFER_SIZE];
    size_t to_read = sizeof(buf);
    if (n_bytes && to_read > n_bytes) {
        to_read = n_bytes;
    }
    ssize_t sz = read(fd, buf, to_read);
    if (sz < 0) {
        perror("read");
    } else if (sz == 0) {
        *fd_eof = true;
    } else {
        rz_strbuf_append_n(sb, buf, (int)sz);
    }
    return sz;
}

References BUFFER_SIZE, fd, read(), rz_strbuf_append_n(), and sb.

Referenced by subprocess_wait().

rz_subprocess_drain()

RZ_API RzSubprocessOutput* rz_subprocess_drain

(

RzSubprocess *

proc

)

Definition at line 1260 of file subprocess.c.

                                                                   {
    subprocess_lock();
    RzSubprocessOutput *out = RZ_NEW(RzSubprocessOutput);
    if (out) {
        out->out = rz_subprocess_out(proc, &out->out_len);
        out->err = rz_subprocess_err(proc, &out->err_len);
        out->ret = proc->ret;
        out->timeout = false;
    }
    subprocess_unlock();
    return out;
}

References out, proc, RZ_NEW, rz_subprocess_err(), rz_subprocess_out(), subprocess_lock(), and subprocess_unlock().

Referenced by subprocess_runner().

rz_subprocess_err()

RZ_API ut8* rz_subprocess_err	(	RzSubprocess *	proc,
		int *	length
	)

Definition at line 1312 of file subprocess.c.

                                                               {
    int bin_len = 0;
    const ut8 *bin = rz_strbuf_getbin(&proc->err, &bin_len);
    ut8 *buf = (ut8 *)rz_str_newlen((const char *)bin, bin_len);
    if (length) {
        *length = bin_len;
    }
    rz_strbuf_fini(&proc->err);
    return buf;
}

References length, proc, rz_str_newlen(), rz_strbuf_fini(), and rz_strbuf_getbin().

Referenced by rz_subprocess_drain(), rz_sys_cmd_str_full(), and rz_test_run_asm_test().

rz_subprocess_fini()

RZ_API void rz_subprocess_fini

(

void

)

Definition at line 814 of file subprocess.c.

                                     {
    rz_sys_signal(SIGCHLD, SIG_IGN);
    ut8 b = 0;
    rz_xwrite(sigchld_pipe[1], &b, 1);
    rz_sys_pipe_close(sigchld_pipe[1]);
    rz_th_wait(sigchld_thread);
    rz_sys_pipe_close(sigchld_pipe[0]);
    rz_th_free(sigchld_thread);
    rz_pvector_clear(&subprocs);
    rz_th_lock_free(subprocs_mutex);
}

References b, rz_pvector_clear(), rz_sys_pipe_close(), rz_sys_signal(), rz_th_free(), rz_th_lock_free(), rz_th_wait(), rz_xwrite, sigchld_pipe, sigchld_thread, subprocs, and subprocs_mutex.

Referenced by rz_sys_cmd_str_full(), rz_test_main(), system_exec(), and system_exec_stdin().

rz_subprocess_free()

RZ_API void rz_subprocess_free

(

RzSubprocess *

proc

)

Definition at line 1273 of file subprocess.c.

                                                   {
    if (!proc) {
        return;
    }
    subprocess_lock();
    rz_pvector_remove_data(&subprocs, proc);
    subprocess_unlock();
    rz_strbuf_fini(&proc->out);
    rz_strbuf_fini(&proc->err);
    rz_sys_pipe_close(proc->killpipe[0]);
    rz_sys_pipe_close(proc->killpipe[1]);
    if (proc->stdin_fd != -1) {
        rz_sys_pipe_close(proc->stdin_fd);
    }
    if (proc->stdout_fd != -1) {
        rz_sys_pipe_close(proc->stdout_fd);
    }
    if (proc->stderr_fd != -1 && proc->stderr_fd != proc->stdout_fd) {
        rz_sys_pipe_close(proc->stderr_fd);
    }
    free(proc);
}

References free(), proc, rz_pvector_remove_data(), rz_strbuf_fini(), rz_sys_pipe_close(), subprocess_lock(), subprocess_unlock(), and subprocs.

Referenced by rz_sys_cmd_str_full(), rz_test_check_jq_available(), rz_test_check_json_test(), rz_test_run_asm_test(), subprocess_runner(), system_exec(), and system_exec_stdin().

rz_subprocess_init()

RZ_API bool rz_subprocess_init

(

void

)

Definition at line 787 of file subprocess.c.

                                     {
    rz_pvector_init(&subprocs, NULL);
    subprocs_mutex = rz_th_lock_new(true);
    if (!subprocs_mutex) {
        return false;
    }
    if (rz_sys_pipe(sigchld_pipe, true) == -1) {
        perror("pipe");
        rz_th_lock_free(subprocs_mutex);
        return false;
    }
    sigchld_thread = rz_th_new(sigchld_th, NULL);
    if (!sigchld_thread) {
        rz_sys_pipe_close(sigchld_pipe[0]);
        rz_sys_pipe_close(sigchld_pipe[1]);
        rz_th_lock_free(subprocs_mutex);
        return false;
    }
    if (rz_sys_signal(SIGCHLD, handle_sigchld) < 0) {
        rz_sys_pipe_close(sigchld_pipe[0]);
        rz_sys_pipe_close(sigchld_pipe[1]);
        rz_th_lock_free(subprocs_mutex);
        return false;
    }
    return true;
}

References handle_sigchld(), NULL, rz_pvector_init(), rz_sys_pipe(), rz_sys_pipe_close(), rz_sys_signal(), rz_th_lock_free(), rz_th_lock_new(), rz_th_new(), sigchld_pipe, sigchld_th(), sigchld_thread, subprocs, and subprocs_mutex.

Referenced by rz_sys_cmd_str_full(), rz_test_main(), system_exec(), and system_exec_stdin().

rz_subprocess_kill()

RZ_API void rz_subprocess_kill

(

RzSubprocess *

proc

)

Definition at line 1256 of file subprocess.c.

                                                   {
    kill(proc->pid, SIGKILL);
}

References kill, proc, and SIGKILL.

Referenced by rz_test_run_asm_test(), and subprocess_runner().

rz_subprocess_out()

RZ_API ut8* rz_subprocess_out	(	RzSubprocess *	proc,
		int *	length
	)

Definition at line 1301 of file subprocess.c.

                                                               {
    int bin_len = 0;
    const ut8 *bin = rz_strbuf_getbin(&proc->out, &bin_len);
    ut8 *buf = (ut8 *)rz_str_newlen((const char *)bin, bin_len);
    if (length) {
        *length = bin_len;
    }
    rz_strbuf_fini(&proc->out);
    return buf;
}

References length, proc, rz_str_newlen(), rz_strbuf_fini(), and rz_strbuf_getbin().

Referenced by rz_subprocess_drain(), rz_sys_cmd_str_full(), rz_test_run_asm_test(), system_exec(), and system_exec_stdin().

rz_subprocess_output_free()

RZ_API void rz_subprocess_output_free

(

RzSubprocessOutput *

out

)

Definition at line 1323 of file subprocess.c.

                                                               {
    if (!out) {
        return;
    }
    free(out->out);
    free(out->err);
    free(out);
}

References free(), and out.

Referenced by rz_test_test_result_info_free().

rz_subprocess_ret()

RZ_API int rz_subprocess_ret

(

RzSubprocess *

proc

)

Definition at line 1297 of file subprocess.c.

                                                 {
    return proc->ret;
}

References proc.

Referenced by rz_test_check_jq_available(), rz_test_check_json_test(), rz_test_run_asm_test(), and system_exec().

rz_subprocess_start()

RZ_API RzSubprocess* rz_subprocess_start	(	const char *	file,
		const char *	args[],
		size_t	args_size,
		const char *	envvars[],
		const char *	envvals[],
		size_t	env_size
	)

Start a program in a new child process with the specified parameters.

Parameters

file	Name of the program to start. It is also evaluated against PATH
args	Array of arguments to pass to the new program. It does not include argv[0]
args_size	Number of arguments in the args array
envvars	Name of environment variables that the newprocess has different from the parent
envvals	Values of environment variables that the newprocess has different from the parent. Elements are evaluated in parallel with envvars, so envvals[0] specifies the value of the environment variable named envvars[0] and so on.
env_size	Number of environment variables in arrays envvars and envvals

Definition at line 1345 of file subprocess.c.

                                                                   {
    RzSubprocessOpt opt = {
        .file = file,
        .args = args,
        .args_size = args_size,
        .envvars = envvars,
        .envvals = envvals,
        .env_size = env_size,
        .stdin_pipe = RZ_SUBPROCESS_PIPE_CREATE,
        .stdout_pipe = RZ_SUBPROCESS_PIPE_CREATE,
        .stderr_pipe = RZ_SUBPROCESS_PIPE_CREATE,
    };
    return rz_subprocess_start_opt(&opt);
}

References args, file, rz_subprocess_opt_t::file, RZ_SUBPROCESS_PIPE_CREATE, and rz_subprocess_start_opt().

Referenced by rz_test_check_jq_available(), rz_test_check_json_test(), rz_test_run_asm_test(), and subprocess_runner().

rz_subprocess_start_opt()

RZ_API RzSubprocess* rz_subprocess_start_opt

(

RzSubprocessOpt *

opt

)

Definition at line 893 of file subprocess.c.

                                                                   {
    RzSubprocess *proc = NULL;
    char **child_env = NULL;
    char **argv = calloc(opt->args_size + 2, sizeof(char *));
    if (!argv) {
        return NULL;
    }
    argv[0] = (char *)opt->file;
    if (opt->args_size) {
        memcpy(argv + 1, opt->args, sizeof(char *) * opt->args_size);
    }
    // done by calloc: argv[args_size + 1] = NULL;
    subprocess_lock();
    proc = RZ_NEW0(RzSubprocess);
    if (!proc) {
        goto error;
    }
    proc->killpipe[0] = proc->killpipe[1] = -1;
    proc->ret = -1;
    proc->stdin_fd = -1;
    proc->stdout_fd = -1;
    proc->stderr_fd = -1;
    rz_strbuf_init(&proc->out);
    rz_strbuf_init(&proc->err);
 
    if (rz_sys_pipe(proc->killpipe, true) == -1) {
        perror("pipe");
        goto error;
    }
    if (fcntl(proc->killpipe[1], F_SETFL, O_NONBLOCK) < 0) {
        perror("fcntl");
        goto error;
    }
 
    int stdin_pipe[2] = { -1, -1 };
    int stdout_pipe[2] = { -1, -1 };
    int stderr_pipe[2] = { -1, -1 };
    if (opt->stdin_pipe == RZ_SUBPROCESS_PIPE_CREATE) {
        if (rz_sys_pipe(stdin_pipe, true) == -1) {
            perror("pipe");
            goto error;
        }
        proc->stdin_fd = stdin_pipe[1];
    }
 
    if (opt->stdout_pipe == RZ_SUBPROCESS_PIPE_CREATE) {
        if (rz_sys_pipe(stdout_pipe, true) == -1) {
            perror("pipe");
            goto error;
        }
        if (fcntl(stdout_pipe[0], F_SETFL, O_NONBLOCK) < 0) {
            perror("fcntl");
            goto error;
        }
        proc->stdout_fd = stdout_pipe[0];
    }
 
    if (opt->stderr_pipe == RZ_SUBPROCESS_PIPE_CREATE) {
        if (rz_sys_pipe(stderr_pipe, true) == -1) {
            perror("pipe");
            goto error;
        }
        if (fcntl(stderr_pipe[0], F_SETFL, O_NONBLOCK) < 0) {
            perror("fcntl");
            goto error;
        }
        proc->stderr_fd = stderr_pipe[0];
    } else if (opt->stderr_pipe == RZ_SUBPROCESS_PIPE_STDOUT) {
        stderr_pipe[0] = stdout_pipe[0];
        stderr_pipe[1] = stdout_pipe[1];
        proc->stderr_fd = proc->stdout_fd;
    }
 
    // Let's create the environment for the child in the parent, with malloc,
    // because we can't use functions that lock after fork
    child_env = create_child_env(opt->envvars, opt->envvals, opt->env_size);
 
    proc->pid = rz_sys_fork();
    if (proc->pid == -1) {
        // fail
        perror("fork");
        goto error;
    } else if (proc->pid == 0) {
        // child
        if (stderr_pipe[1] != -1) {
            while ((dup2(stderr_pipe[1], STDERR_FILENO) == -1) && (errno == EINTR)) {
            }
            if (proc->stderr_fd != proc->stdout_fd) {
                rz_sys_pipe_close(stderr_pipe[1]);
                rz_sys_pipe_close(stderr_pipe[0]);
            }
        }
        if (stdout_pipe[1] != -1) {
            while ((dup2(stdout_pipe[1], STDOUT_FILENO) == -1) && (errno == EINTR)) {
            }
            rz_sys_pipe_close(stdout_pipe[1]);
            rz_sys_pipe_close(stdout_pipe[0]);
        }
        if (stdin_pipe[0] != -1) {
            while ((dup2(stdin_pipe[0], STDIN_FILENO) == -1) && (errno == EINTR)) {
            }
            rz_sys_pipe_close(stdin_pipe[0]);
            rz_sys_pipe_close(stdin_pipe[1]);
        }
 
        // Use the previously created environment
        rz_sys_set_environ(child_env);
 
        rz_sys_execvp(opt->file, argv);
        perror("exec");
        rz_sys_exit(-1, true);
    }
    destroy_child_env(child_env);
    free(argv);
 
    if (stdin_pipe[0] != -1) {
        rz_sys_pipe_close(stdin_pipe[0]);
    }
    if (stdout_pipe[1] != -1) {
        rz_sys_pipe_close(stdout_pipe[1]);
    }
    if (stderr_pipe[1] != -1 && proc->stderr_fd != proc->stdout_fd) {
        rz_sys_pipe_close(stderr_pipe[1]);
    }
 
    rz_pvector_push(&subprocs, proc);
 
    subprocess_unlock();
 
    return proc;
error:
    free(argv);
    if (proc && proc->killpipe[0] == -1) {
        rz_sys_pipe_close(proc->killpipe[0]);
    }
    if (proc && proc->killpipe[1] == -1) {
        rz_sys_pipe_close(proc->killpipe[1]);
    }
    free(proc);
    if (stderr_pipe[0] != -1 && stderr_pipe[0] != stdout_pipe[0]) {
        rz_sys_pipe_close(stderr_pipe[0]);
    }
    if (stderr_pipe[1] != -1 && stderr_pipe[1] != stdout_pipe[1]) {
        rz_sys_pipe_close(stderr_pipe[1]);
    }
    if (stdout_pipe[0] != -1) {
        rz_sys_pipe_close(stdout_pipe[0]);
    }
    if (stdout_pipe[1] != -1) {
        rz_sys_pipe_close(stdout_pipe[1]);
    }
    if (stdin_pipe[0] != -1) {
        rz_sys_pipe_close(stdin_pipe[0]);
    }
    if (stdin_pipe[1] != -1) {
        rz_sys_pipe_close(stdin_pipe[1]);
    }
    destroy_child_env(child_env);
    subprocess_unlock();
    return NULL;
}

References rz_subprocess_opt_t::args, rz_subprocess_opt_t::args_size, argv, calloc(), create_child_env(), destroy_child_env(), dup2, EINTR, rz_subprocess_opt_t::env_size, rz_subprocess_opt_t::envvals, rz_subprocess_opt_t::envvars, error(), F_SETFL, fcntl, rz_subprocess_opt_t::file, free(), if(), memcpy(), NULL, O_NONBLOCK, proc, RZ_NEW0, rz_pvector_push(), rz_strbuf_init(), RZ_SUBPROCESS_PIPE_CREATE, RZ_SUBPROCESS_PIPE_STDOUT, rz_sys_execvp(), rz_sys_exit(), rz_sys_fork(), rz_sys_pipe(), rz_sys_pipe_close(), rz_sys_set_environ(), STDERR_FILENO, rz_subprocess_opt_t::stderr_pipe, STDIN_FILENO, rz_subprocess_opt_t::stdin_pipe, stdin_pipe, STDOUT_FILENO, rz_subprocess_opt_t::stdout_pipe, stdout_pipe, subprocess_lock(), subprocess_unlock(), and subprocs.

Referenced by rz_subprocess_start(), rz_sys_cmd_str_full(), system_exec(), and system_exec_stdin().

rz_subprocess_stdin_write()

RZ_API ssize_t rz_subprocess_stdin_write	(	RzSubprocess *	proc,
		const ut8 *	buf,
		size_t	buf_size
	)

Sends some data to the stdin of the subprocess and returns the number of bytes sent.

Parameters

proc	Subprocess to communicate with
buf	Data that needs to be send to the subprocess stdin
buf_size	Number of bytes to send

Definition at line 1206 of file subprocess.c.

                                                                                              {
    ssize_t written = -1;
    if (proc->stdin_fd == -1) {
        return written;
    }
    rz_sys_signal(SIGPIPE, SIG_IGN);
    written = write(proc->stdin_fd, buf, buf_size);
    rz_sys_signal(SIGPIPE, SIG_DFL);
    return written;
}

References buf_size, proc, rz_sys_signal(), and write.

Referenced by rz_sys_cmd_str_full(), rz_test_check_jq_available(), rz_test_check_json_test(), and system_exec_stdin().

rz_subprocess_stdout_read()

RZ_API RzStrBuf* rz_subprocess_stdout_read	(	RzSubprocess *	proc,
		size_t	n,
		ut64	timeout_ms
	)

Read some data from the stdout of the subprocess and returns a RzStrBuf containing it. Callers must not free the returned pointer.

Parameters

proc	Subprocess to communicate with
n	Number of bytes to read from the subprocess' stdout
timeout_ms	Wait for at most this amount of millisecond to read subprocess' stdout

Definition at line 1225 of file subprocess.c.

                                                                                          {
    rz_strbuf_fini(&proc->out);
    rz_strbuf_init(&proc->out);
    if (proc->stdout_fd != -1) {
        subprocess_wait(proc, timeout_ms, RZ_SUBPROCESS_STDOUT, n);
    }
    return &proc->out;
}

References n, proc, rz_strbuf_fini(), rz_strbuf_init(), RZ_SUBPROCESS_STDOUT, and subprocess_wait().

rz_subprocess_stdout_readline()

RZ_API RzStrBuf* rz_subprocess_stdout_readline	(	RzSubprocess *	proc,
		ut64	timeout_ms
	)

Read one line from the stdout of the subprocess and returns a RzStrBuf containing it. Callers must not free the returned pointer.

Parameters

proc	Subprocess to communicate with
timeout_ms	Wait for at most this amount of millisecond to read subprocess' stdout

Definition at line 1241 of file subprocess.c.

                                                                                    {
    rz_strbuf_fini(&proc->out);
    rz_strbuf_init(&proc->out);
    if (proc->stdout_fd != -1) {
        char c = '\0';
        RzSubprocessWaitReason reason;
        // FIXME: the timeout should also be checked globally here
        do {
            reason = subprocess_wait(proc, timeout_ms, RZ_SUBPROCESS_STDOUT, 1);
            c = rz_strbuf_get(&proc->out)[rz_strbuf_length(&proc->out) - 1];
        } while (c != '\n' && reason == RZ_SUBPROCESS_BYTESREAD);
    }
    return &proc->out;
}

References c, proc, rz_strbuf_fini(), rz_strbuf_get(), rz_strbuf_init(), rz_strbuf_length(), RZ_SUBPROCESS_BYTESREAD, RZ_SUBPROCESS_STDOUT, and subprocess_wait().

rz_subprocess_wait()

RZ_API RzSubprocessWaitReason rz_subprocess_wait	(	RzSubprocess *	proc,
		ut64	timeout_ms
	)

Wait until process dies or timeout expires and collect stdout + stderr. No more input can be sent after this call.

Parameters

proc	Subprocess to communicate with
timeout_ms	Wait for at most this amount of millisecond

Definition at line 1185 of file subprocess.c.

                                                                                      {
    if (proc->stdin_fd != -1) {
        // Close subprocess stdin to tell it that no more input will come from us
        rz_sys_pipe_close(proc->stdin_fd);
        proc->stdin_fd = -1;
    }
    // Empty buffers and read everything we can
    rz_strbuf_fini(&proc->out);
    rz_strbuf_init(&proc->out);
    rz_strbuf_fini(&proc->err);
    rz_strbuf_init(&proc->err);
    return subprocess_wait(proc, timeout_ms, RZ_SUBPROCESS_STDOUT | RZ_SUBPROCESS_STDERR, 0);
}

References proc, rz_strbuf_fini(), rz_strbuf_init(), RZ_SUBPROCESS_STDERR, RZ_SUBPROCESS_STDOUT, rz_sys_pipe_close(), and subprocess_wait().

Referenced by rz_sys_cmd_str_full(), rz_test_check_jq_available(), rz_test_check_json_test(), rz_test_run_asm_test(), subprocess_runner(), system_exec(), and system_exec_stdin().

sigchld_th()

static void* sigchld_th ( void *  th )

static

Definition at line 737 of file subprocess.c.

                                  {
    while (true) {
        ut8 b;
        ssize_t rd = read(sigchld_pipe[0], &b, 1);
        if (rd <= 0) {
            if (rd < 0) {
                if (errno == EINTR) {
                    continue;
                }
                perror("read");
            }
            break;
        }
        if (!b) {
            break;
        }
        while (true) {
            int wstat;
            pid_t pid = waitpid(-1, &wstat, WNOHANG);
            if (pid <= 0)
                break;
 
            subprocess_lock();
            void **it;
            RzSubprocess *proc = NULL;
            rz_pvector_foreach (&subprocs, it) {
                RzSubprocess *p = *it;
                if (p->pid == pid) {
                    proc = p;
                    break;
                }
            }
            if (!proc) {
                subprocess_unlock();
                continue;
            }
 
            if (WIFEXITED(wstat)) {
                proc->ret = WEXITSTATUS(wstat);
            } else {
                proc->ret = -1;
            }
            ut8 r = 0;
            rz_xwrite(proc->killpipe[1], &r, 1);
            subprocess_unlock();
        }
    }
    return NULL;
}

References b, EINTR, NULL, p, pid, proc, r, rd, read(), rz_pvector_foreach, rz_xwrite, sigchld_pipe, subprocess_lock(), subprocess_unlock(), and subprocs.

Referenced by rz_subprocess_init().

subprocess_lock()

static void subprocess_lock ( void  )

static

Definition at line 724 of file subprocess.c.

                                  {
    rz_th_lock_enter(subprocs_mutex);
}

References rz_th_lock_enter(), and subprocs_mutex.

Referenced by rz_subprocess_drain(), rz_subprocess_free(), rz_subprocess_start_opt(), and sigchld_th().

subprocess_unlock()

static void subprocess_unlock ( void  )

static

Definition at line 728 of file subprocess.c.

                                    {
    rz_th_lock_leave(subprocs_mutex);
}

References rz_th_lock_leave(), and subprocs_mutex.

Referenced by rz_subprocess_drain(), rz_subprocess_free(), rz_subprocess_start_opt(), and sigchld_th().

subprocess_wait()

static RzSubprocessWaitReason subprocess_wait ( RzSubprocess *  proc, ut64  timeout_ms, int  pipe_fd, size_t  n_bytes  )

static

Wait for subprocess to do something, for a maximum of timeout_ms millisecond.

This function can be used to wait for some action from the subprocess, which includes terminating or sending output to stdout/stderr. If n_bytes is not 0, the function terminates as soon as n_bytes bytes have been read or the timeout expires.

Parameters

proc	Subprocess to interact with
timeout_ms	Number of millisecond to wait before stopping the operation. If UT64_MAX no timeout is set
pipe_fds	One of RZ_SUBPROCESS_STDOUT , RZ_SUBPROCESS_STDERR or a combination of them. Bytes are read only from those.
n_bytes	Number of bytes to read. If pipe_fds references multiple FDs, this indicates the number to read in either of them.

Definition at line 1085 of file subprocess.c.

                                                                                                                {
    ut64 timeout_abs = UT64_MAX;
    if (timeout_ms != UT64_MAX) {
        timeout_abs = rz_time_now_mono() + timeout_ms * RZ_USEC_PER_MSEC;
    }
 
    int r = 0;
    bool stdout_enabled = (pipe_fd & RZ_SUBPROCESS_STDOUT) && proc->stdout_fd != -1;
    bool stderr_enabled = (pipe_fd & RZ_SUBPROCESS_STDERR) && proc->stderr_fd != -1 && proc->stderr_fd != proc->stdout_fd;
    bool stdout_eof = false;
    bool stderr_eof = false;
    bool child_dead = false;
    bool timedout = true;
    bool bytes_enabled = n_bytes != 0;
    while ((!bytes_enabled || n_bytes) && ((stdout_enabled && !stdout_eof) || (stderr_enabled && !stderr_eof) || !child_dead)) {
        fd_set rfds;
        FD_ZERO(&rfds);
        int nfds = 0;
        if (stdout_enabled && !stdout_eof) {
            FD_SET(proc->stdout_fd, &rfds);
            if (proc->stdout_fd > nfds) {
                nfds = proc->stdout_fd;
            }
        }
        if (stderr_enabled && !stderr_eof) {
            FD_SET(proc->stderr_fd, &rfds);
            if (proc->stderr_fd > nfds) {
                nfds = proc->stderr_fd;
            }
        }
        if (!child_dead) {
            FD_SET(proc->killpipe[0], &rfds);
            if (proc->killpipe[0] > nfds) {
                nfds = proc->killpipe[0];
            }
        }
        nfds++;
 
        struct timeval timeout_s;
        struct timeval *timeout = NULL;
        if (timeout_ms != UT64_MAX) {
            ut64 now = rz_time_now_mono();
            if (now >= timeout_abs) {
                break;
            }
            ut64 usec_diff = timeout_abs - rz_time_now_mono();
            timeout_s.tv_sec = usec_diff / RZ_USEC_PER_SEC;
            timeout_s.tv_usec = usec_diff % RZ_USEC_PER_SEC;
            timeout = &timeout_s;
        }
        r = select(nfds, &rfds, NULL, NULL, timeout);
        if (r < 0) {
            if (errno == EINTR) {
                continue;
            }
            break;
        }
 
        timedout = true;
        if (stdout_enabled && FD_ISSET(proc->stdout_fd, &rfds)) {
            timedout = false;
            size_t r = read_to_strbuf(&proc->out, proc->stdout_fd, &stdout_eof, n_bytes);
            if (r > 0 && n_bytes) {
                n_bytes -= r;
            }
        }
        if (stderr_enabled && FD_ISSET(proc->stderr_fd, &rfds)) {
            timedout = false;
            size_t r = read_to_strbuf(&proc->err, proc->stderr_fd, &stderr_eof, n_bytes);
            if (r > 0 && n_bytes) {
                n_bytes -= r;
            }
        }
        if (FD_ISSET(proc->killpipe[0], &rfds)) {
            timedout = false;
            child_dead = true;
        }
        if (timedout) {
            break;
        }
    }
    if (r < 0) {
        perror("select");
    }
    if (child_dead) {
        return RZ_SUBPROCESS_DEAD;
    } else if (timedout) {
        return RZ_SUBPROCESS_TIMEDOUT;
    } else {
        return RZ_SUBPROCESS_BYTESREAD;
    }
}

References EINTR, FD_ISSET, FD_SET, FD_ZERO, nfds, NULL, proc, r, read_to_strbuf(), RZ_SUBPROCESS_BYTESREAD, RZ_SUBPROCESS_DEAD, RZ_SUBPROCESS_STDERR, RZ_SUBPROCESS_STDOUT, RZ_SUBPROCESS_TIMEDOUT, rz_time_now_mono(), RZ_USEC_PER_MSEC, RZ_USEC_PER_SEC, select, timeout, timeval::tv_sec, timeval::tv_usec, ut64(), and UT64_MAX.

Referenced by rz_subprocess_stdout_read(), rz_subprocess_stdout_readline(), and rz_subprocess_wait().

Variable Documentation

sigchld_pipe

int sigchld_pipe[2]

static

Definition at line 721 of file subprocess.c.

Referenced by handle_sigchld(), rz_subprocess_fini(), rz_subprocess_init(), and sigchld_th().

sigchld_thread

RzThread* sigchld_thread

static

Definition at line 722 of file subprocess.c.

Referenced by rz_subprocess_fini(), and rz_subprocess_init().

subprocs

RzPVector subprocs

static

Definition at line 719 of file subprocess.c.

Referenced by rz_subprocess_fini(), rz_subprocess_free(), rz_subprocess_init(), rz_subprocess_start_opt(), and sigchld_th().

subprocs_mutex

RzThreadLock* subprocs_mutex

static

Definition at line 720 of file subprocess.c.

Referenced by rz_subprocess_fini(), rz_subprocess_init(), subprocess_lock(), and subprocess_unlock().