rz_subprocess.h File Reference

#include <rz_types.h>
#include <rz_util/rz_strbuf.h>

Go to the source code of this file.

Classes
struct	rz_process_output_t
struct	rz_subprocess_opt_t

Macros
#define	RZ_SUBPROCESS_STDIN   (1 << 0)
#define	RZ_SUBPROCESS_STDOUT   (1 << 1)
#define	RZ_SUBPROCESS_STDERR   (1 << 2)

Typedefs
typedef enum rz_subprocess_pipe_create_t	RzSubprocessPipeCreate
typedef enum rz_process_wait_reason_t	RzSubprocessWaitReason
typedef struct rz_process_output_t	RzSubprocessOutput
typedef struct rz_subprocess_opt_t	RzSubprocessOpt
typedef struct rz_subprocess_t	RzSubprocess

Enumerations
enum	rz_subprocess_pipe_create_t { RZ_SUBPROCESS_PIPE_NONE , RZ_SUBPROCESS_PIPE_CREATE , RZ_SUBPROCESS_PIPE_STDOUT }
enum	rz_process_wait_reason_t { RZ_SUBPROCESS_DEAD , RZ_SUBPROCESS_TIMEDOUT , RZ_SUBPROCESS_BYTESREAD }

Functions
RZ_API bool	rz_subprocess_init (void)
RZ_API void	rz_subprocess_fini (void)
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)
RZ_API RzSubprocess *	rz_subprocess_start_opt (RzSubprocessOpt *opt)
RZ_API void	rz_subprocess_free (RzSubprocess *proc)
RZ_API RzSubprocessWaitReason	rz_subprocess_wait (RzSubprocess *proc, ut64 timeout_ms)
RZ_API void	rz_subprocess_kill (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 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 RzSubprocessOutput *	rz_subprocess_drain (RzSubprocess *proc)
RZ_API void	rz_subprocess_output_free (RzSubprocessOutput *out)

Macro Definition Documentation

RZ_SUBPROCESS_STDERR

#define RZ_SUBPROCESS_STDERR   (1 << 2)

Definition at line 28 of file rz_subprocess.h.

RZ_SUBPROCESS_STDIN

#define RZ_SUBPROCESS_STDIN   (1 << 0)

Values passed to rz_subprocess API to mention stdin, stdout, stderr or a combination of those

Definition at line 26 of file rz_subprocess.h.

RZ_SUBPROCESS_STDOUT

#define RZ_SUBPROCESS_STDOUT   (1 << 1)

Definition at line 27 of file rz_subprocess.h.

Typedef Documentation

RzSubprocess

typedef struct rz_subprocess_t RzSubprocess

Definition at line 1 of file rz_subprocess.h.

RzSubprocessOpt

typedef struct rz_subprocess_opt_t RzSubprocessOpt

Specify how the new subprocess should be created.

RzSubprocessOutput

typedef struct rz_process_output_t RzSubprocessOutput

Provide results from running a sub-process, like output, return value, etc.

RzSubprocessPipeCreate

typedef enum rz_subprocess_pipe_create_t RzSubprocessPipeCreate

Enum used to determine how pipes should be created, if at all, in the subprocess.

RzSubprocessWaitReason

typedef enum rz_process_wait_reason_t RzSubprocessWaitReason

Enumeration Type Documentation

rz_process_wait_reason_t

enum rz_process_wait_reason_t

Enumerator
RZ_SUBPROCESS_DEAD
RZ_SUBPROCESS_TIMEDOUT
RZ_SUBPROCESS_BYTESREAD

Definition at line 30 of file rz_subprocess.h.

                                      {
    RZ_SUBPROCESS_DEAD,
    RZ_SUBPROCESS_TIMEDOUT,
    RZ_SUBPROCESS_BYTESREAD,
} RzSubprocessWaitReason;

rz_subprocess_pipe_create_t

enum rz_subprocess_pipe_create_t

Enum used to determine how pipes should be created, if at all, in the subprocess.

Enumerator
RZ_SUBPROCESS_PIPE_NONE	No pipe should be created. It can be used for stdin, stdout and stderr. A new pipe should be created. It can be used for stdin, stdout and stderr.
RZ_SUBPROCESS_PIPE_CREATE	Re-use the same pipe as stdout. It can be used for stderr only.
RZ_SUBPROCESS_PIPE_STDOUT

Definition at line 14 of file rz_subprocess.h.

                                         {
    RZ_SUBPROCESS_PIPE_NONE,
    RZ_SUBPROCESS_PIPE_CREATE,
    RZ_SUBPROCESS_PIPE_STDOUT,
} RzSubprocessPipeCreate;

Function Documentation

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().