sys.c File Reference

#include <rz_userconf.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <rz_types.h>
#include <rz_util.h>
#include <rz_lib.h>

Go to the source code of this file.

Macros
#define	RZ_SYS_ASM_START_ROP()    eprintf("rz_sys_run_rop: Unsupported arch\n");
#define	USE_FORK   0

Functions
	RZ_LIB_VERSION (rz_util)
RZ_API int	rz_sys_sigaction (int *sig, void(*handler)(int))
RZ_API int	rz_sys_signal (int sig, void(*handler)(int))
RZ_API void	rz_sys_exit (int status, bool nocleanup)
static DIR *	sys_opendir (const char *path)
RZ_API RzList *	rz_sys_dir (const char *path)
RZ_API char *	rz_sys_cmd_strf (const char *fmt,...)
RZ_API void	rz_sys_backtrace (void)
	Print the backtrace at the point this function is called from. More...
RZ_API int	rz_sys_sleep (int secs)
	Sleep for secs seconds. More...
RZ_API int	rz_sys_usleep (int usecs)
	Sleep for usecs microseconds. More...
RZ_API int	rz_sys_clearenv (void)
	Clean all environment variables in the calling process. More...
RZ_API int	rz_sys_setenv (const char *key, const char *value)
	Set an environment variable in the calling process. More...
RZ_API int	rz_sys_crash_handler (const char *cmd)
RZ_API char *	rz_sys_getenv (const char *key)
	Get the value of an environment variable named key or NULL if none exists. More...
RZ_API bool	rz_sys_getenv_asbool (const char *key)
	Return true if the environment variable has the value 1, false otherwise. More...
RZ_API char *	rz_sys_getdir (void)
	Get current working directory. More...
RZ_API bool	rz_sys_chdir (RZ_NONNULL const char *s)
	Change current directory to s, taking care of home expansion ~. More...
RZ_API bool	rz_sys_aslr (int val)
	Enable or disable ASLR for the calling process. More...
RZ_API int	rz_sys_cmd_str_full (const char *cmd, const char *input, char **output, int *len, char **sterr)
RZ_API int	rz_sys_cmdf (const char *fmt,...)
RZ_API int	rz_sys_cmdbg (const char *str)
RZ_API char *	rz_sys_cmd_str (const char *cmd, const char *input, int *len)
RZ_API bool	rz_sys_mkdir (const char *dir)
RZ_API bool	rz_sys_mkdirp (const char *dir)
RZ_API void	rz_sys_perror_str (const char *fun)
RZ_API bool	rz_sys_arch_match (const char *archstr, const char *arch)
RZ_API int	rz_sys_arch_id (const char *arch)
RZ_API const char *	rz_sys_arch_str (int arch)
RZ_API int	rz_sys_run (const ut8 *buf, int len)
RZ_API int	rz_sys_run_rop (const ut8 *buf, int len)
RZ_API bool	rz_is_heap (void *p)
RZ_API char *	rz_sys_pid_to_path (int pid)
RZ_API void	rz_sys_env_init (void)
RZ_API char **	rz_sys_get_environ (void)
RZ_API void	rz_sys_set_environ (char **e)
RZ_API char *	rz_sys_whoami (char *buf)
RZ_API int	rz_sys_getpid (void)
RZ_API RSysInfo *	rz_sys_info (void)
RZ_API void	rz_sys_info_free (RSysInfo *si)
RZ_API int	rz_sys_pipe (int pipefd[2], bool close_on_exec)
RZ_API int	rz_sys_pipe_close (int fd)
RZ_API int	rz_sys_execv (const char *pathname, char *const argv[])
RZ_API int	rz_sys_execve (const char *pathname, char *const argv[], char *const envp[])
RZ_API int	rz_sys_execvp (const char *file, char *const argv[])
RZ_API int	rz_sys_execl (const char *pathname, const char *arg,...)
RZ_API int	rz_sys_system (const char *command)
RZ_API int	rz_sys_fork (void)
RZ_API int	rz_sys_truncate_fd (int fd, ut64 length)
RZ_API int	rz_sys_truncate (const char *file, int sz)
RZ_API int	rz_sys_open_perms (int rizin_perms)
	Convert rizin permissions (RZ_PERM_*) to posix permissions that can be passed to rz_sys_open . More...
RZ_API int	rz_sys_open (const char *path, int perm, int mode)
RZ_API FILE *	rz_sys_fopen (const char *path, const char *mode)
RZ_API int	rz_sys_kill (int pid, int sig)
	Send signal sig to process with pid pid. More...
RZ_API bool	rz_sys_stop (void)
	Send SIGTSTP signal to every process in this process group. More...

Variables
static char **	env = NULL
struct {
const char *   name
ut64   bit
}	arch_bit_array []

Macro Definition Documentation

RZ_SYS_ASM_START_ROP

#define RZ_SYS_ASM_START_ROP

(

)

eprintf("rz_sys_run_rop: Unsupported arch\n");

Definition at line 103 of file sys.c.

USE_FORK

#define USE_FORK   0

Definition at line 808 of file sys.c.

Function Documentation

rz_is_heap()

RZ_API bool rz_is_heap

(

void *

p

)

Definition at line 911 of file sys.c.

                                {
    void *q = malloc(8);
    ut64 mask = UT64_MAX;
    mask >>= 16;
    mask <<= 16;
    free(q);
    return (((ut64)(size_t)p) == mask);
}

References free(), malloc(), mask, p, ut64(), and UT64_MAX.

RZ_LIB_VERSION()

RZ_LIB_VERSION

(

rz_util

)

rz_sys_arch_id()

RZ_API int rz_sys_arch_id

(

const char *

arch

)

Definition at line 788 of file sys.c.

                                            {
    int i;
    for (i = 0; arch_bit_array[i].name; i++) {
        if (!strcmp(arch, arch_bit_array[i].name)) {
            return arch_bit_array[i].bit;
        }
    }
    return 0;
}

References arch, arch_bit_array, and i.

Referenced by rz_core_rtr_gdb_run(), rz_debug_gdb_attach(), rz_debug_gdb_reg_profile(), rz_debug_qnx_attach(), and rz_debug_qnx_reg_profile().

rz_sys_arch_match()

RZ_API bool rz_sys_arch_match	(	const char *	archstr,
		const char *	arch
	)

Definition at line 768 of file sys.c.

                                                                     {
    char *ptr;
    if (!archstr || !arch || !*archstr || !*arch) {
        return true;
    }
    if (!strcmp(archstr, "*") || !strcmp(archstr, "any")) {
        return true;
    }
    if (!strcmp(archstr, arch)) {
        return true;
    }
    if ((ptr = strstr(archstr, arch))) {
        char p = ptr[strlen(arch)];
        if (!p || p == ',') {
            return true;
        }
    }
    return false;
}

References arch, and p.

rz_sys_arch_str()

RZ_API const char* rz_sys_arch_str

(

int

arch

)

Definition at line 798 of file sys.c.

                                             {
    int i;
    for (i = 0; arch_bit_array[i].name; i++) {
        if (arch & arch_bit_array[i].bit) {
            return arch_bit_array[i].name;
        }
    }
    return "none";
}

References arch, arch_bit_array, bit, and i.

Referenced by info(), and rz_egg_load_file().

rz_sys_aslr()

RZ_API bool rz_sys_aslr

(

int

val

)

Enable or disable ASLR for the calling process.

Definition at line 546 of file sys.c.

                                 {
    bool ret = true;
#if __linux__
    const char *rva = "/proc/sys/kernel/randomize_va_space";
    char buf[3] = { 0 };
    snprintf(buf, sizeof(buf), "%d\n", val != 0 ? 2 : 0);
    int fd = rz_sys_open(rva, O_WRONLY, 0644);
    if (fd != -1) {
        if (write(fd, (ut8 *)buf, sizeof(buf)) != sizeof(buf)) {
            eprintf("Failed to set RVA\n");
            ret = false;
        }
        close(fd);
    }
#elif __FreeBSD__ && __FreeBSD_version >= 1300000
    size_t vlen = sizeof(val);
    if (sysctlbyname("kern.elf32.aslr.enable", NULL, 0, &val, vlen) == -1) {
        eprintf("Failed to set RVA 32 bits\n");
        return false;
    }
 
#if __LP64__
    if (sysctlbyname("kern.elf64.aslr.enable", NULL, 0, &val, vlen) == -1) {
        eprintf("Failed to set RVA 64 bits\n");
        ret = false;
    }
#endif
#elif __NetBSD__
    size_t vlen = sizeof(val);
    if (sysctlbyname("security.pax.aslr.enabled", NULL, 0, &val, vlen) == -1) {
        eprintf("Failed to set RVA\n");
        ret = false;
    }
#elif __DragonFly__
    size_t vlen = sizeof(val);
    if (sysctlbyname("vm.randomize_mmap", NULL, 0, &val, vlen) == -1) {
        eprintf("Failed to set RVA\n");
        ret = false;
    }
#elif __DragonFly__
#endif
    return ret;
}

References close, eprintf, fd, NULL, O_WRONLY, rva(), rz_sys_open(), snprintf, val, and write.

Referenced by setASLR().

rz_sys_backtrace()

RZ_API void rz_sys_backtrace

(

void

)

Print the backtrace at the point this function is called from.

Definition at line 265 of file sys.c.

                                   {
#if HAVE_BACKTRACE
    void *array[10];
    size_t size = backtrace(array, 10);
    eprintf("Backtrace %zd stack frames.\n", size);
    backtrace_symbols_fd(array, size, 2);
#elif __APPLE__
    void **fp = (void **)__builtin_frame_address(0);
    void *saved_pc = __builtin_return_address(0);
    void *saved_fp = __builtin_frame_address(1);
    int depth = 0;
 
    eprintf("[%d] pc == %p fp == %p\n", depth++, saved_pc, saved_fp);
    fp = saved_fp;
    while (fp) {
        saved_fp = *fp;
        fp = saved_fp;
        if (!*fp) {
            break;
        }
        saved_pc = *(fp + 2);
        eprintf("[%d] pc == %p fp == %p\n", depth++, saved_pc, saved_fp);
    }
#else
#ifdef _MSC_VER
#pragma message("TODO: rz_sys_bt : unimplemented")
#else
#warning TODO: rz_sys_bt : unimplemented
#endif
#endif
}

References eprintf.

Referenced by rz_assert_log(), rz_core_is_valid_offset(), rz_io_desc_add(), and winkd_wait_packet().

rz_sys_chdir()

RZ_API bool rz_sys_chdir

(

RZ_NONNULL const char *

s

)

Change current directory to s, taking care of home expansion ~.

Definition at line 532 of file sys.c.

                                                   {
    rz_return_val_if_fail(s, false);
    char *homepath = rz_path_home_expand(s);
    if (homepath) {
        int ret = chdir(homepath);
        free(homepath);
        return ret == 0;
    }
    return chdir(s) == 0;
}

References chdir, free(), rz_path_home_expand(), rz_return_val_if_fail, and s.

Referenced by rz_cmd_shell_cd_handler(), rz_main_rizin(), and rz_test_chdir_fromtest().

rz_sys_clearenv()

RZ_API int rz_sys_clearenv

(

void

)

Clean all environment variables in the calling process.

Please note that environment variables should not be used to store sensitive info as they might be kept elsewhere and there is no access control over that data.

Definition at line 346 of file sys.c.

                                 {
#if __UNIX__
#if __APPLE__ && !HAVE_ENVIRON
    /* do nothing */
    if (!env) {
        rz_sys_env_init();
        return 0;
    }
    char **e = env;
    while (*e) {
        *e++ = NULL;
    }
#else
    if (!environ) {
        return 0;
    }
    while (*environ) {
        *environ++ = NULL;
    }
#endif
    return 0;
#else
#ifdef __WINDOWS__
    LPWCH env = GetEnvironmentStringsW();
    LPWCH var = env;
    while (*var) {
        wchar_t *eq = wcschr(var, L'=');
        if (!eq) {
            FreeEnvironmentStringsW(env);
            return -1;
        }
        const size_t len = eq - var;
        if (!len) {
            var += wcslen(var) + 1;
            continue;
        }
        wchar_t *v = RZ_NEWS0(wchar_t, len + 1);
        if (!v) {
            return -1;
        }
        wcsncpy(v, var, len);
        if (_wputenv_s(v, L"")) {
            free(v);
            break;
        }
        free(v);
        var += wcslen(var) + 1;
    }
    FreeEnvironmentStringsW(env);
#else
#warning rz_sys_clearenv : unimplemented for this platform
#endif
    return 0;
#endif
}

References e, env, environ, eq, free(), L, len, NULL, RZ_NEWS0, rz_sys_env_init(), and v.

Referenced by rz_run_parseline(), and rz_sys_set_environ().

rz_sys_cmd_str()

RZ_API char* rz_sys_cmd_str	(	const char *	cmd,
		const char *	input,
		int *	len
	)

Definition at line 669 of file sys.c.

                                                                          {
    char *output = NULL;
    if (rz_sys_cmd_str_full(cmd, input, &output, len, NULL)) {
        return output;
    }
    free(output);
    return NULL;
}

References cmd, free(), input(), len, NULL, output, and rz_sys_cmd_str_full().

Referenced by assemble(), getstr(), rz_core_cmd_command(), rz_sys_cmd_strf(), and socket_http_get_recursive().

rz_sys_cmd_str_full()

RZ_API int rz_sys_cmd_str_full	(	const char *	cmd,
		const char *	input,
		char **	output,
		int *	len,
		char **	sterr
	)

Definition at line 590 of file sys.c.

                                                                                                          {
    int argc;
    char **argv = rz_str_argv(cmd, &argc);
    if (!argv) {
        return false;
    }
    RzSubprocessOpt opts = {
        .file = argv[0],
        .args = (const char **)&argv[1],
        .args_size = argc - 1,
        .envvars = NULL,
        .envvals = NULL,
        .env_size = 0,
        .stdin_pipe = input ? RZ_SUBPROCESS_PIPE_CREATE : RZ_SUBPROCESS_PIPE_NONE,
        .stdout_pipe = output ? RZ_SUBPROCESS_PIPE_CREATE : RZ_SUBPROCESS_PIPE_NONE,
        .stderr_pipe = sterr ? RZ_SUBPROCESS_PIPE_CREATE : RZ_SUBPROCESS_PIPE_NONE,
    };
 
    if (!rz_subprocess_init()) {
        RZ_LOG_ERROR("Failed to initialize subprocess\n");
        return false;
    }
    RzSubprocess *subprocess = rz_subprocess_start_opt(&opts);
    if (!subprocess) {
        rz_subprocess_fini();
        return false;
    }
    if (input) {
        rz_subprocess_stdin_write(subprocess, (ut8 *)input, strlen(input) + 1);
    }
    rz_subprocess_wait(subprocess, UT64_MAX);
    if (output) {
        *output = (char *)rz_subprocess_out(subprocess, len);
    }
    if (sterr) {
        *sterr = (char *)rz_subprocess_err(subprocess, NULL);
    }
    rz_subprocess_free(subprocess);
    rz_subprocess_fini();
    rz_str_argv_free(argv);
    return true;
}

References argv, cmd, rz_subprocess_opt_t::file, input(), len, NULL, output, RZ_LOG_ERROR, rz_str_argv(), rz_str_argv_free(), rz_subprocess_err(), rz_subprocess_fini(), rz_subprocess_free(), rz_subprocess_init(), rz_subprocess_out(), RZ_SUBPROCESS_PIPE_CREATE, RZ_SUBPROCESS_PIPE_NONE, rz_subprocess_start_opt(), rz_subprocess_stdin_write(), rz_subprocess_wait(), stdin_pipe, stdout_pipe, and UT64_MAX.

Referenced by rz_cons_flush(), rz_core_cmd_pipe_old(), and rz_sys_cmd_str().

rz_sys_cmd_strf()

RZ_API char* rz_sys_cmd_strf	(	const char *	fmt,
			...
	)

Definition at line 252 of file sys.c.

                                                   {
    char *ret, cmd[4096];
    va_list ap;
    va_start(ap, fmt);
    vsnprintf(cmd, sizeof(cmd), fmt, ap);
    ret = rz_sys_cmd_str(cmd, NULL, NULL);
    va_end(ap);
    return ret;
}

References cmd, NULL, rz_sys_cmd_str(), and vsnprintf.

rz_sys_cmdbg()

RZ_API int rz_sys_cmdbg

(

const char *

str

)

Definition at line 644 of file sys.c.

                                         {
#if __UNIX__
    int ret, pid = rz_sys_fork();
    if (pid == -1) {
        return -1;
    }
    if (pid) {
        return pid;
    }
    char *bin_sh = rz_file_binsh();
    ret = rz_sys_execl(bin_sh, "sh", "-c", str, (const char *)NULL);
    free(bin_sh);
    eprintf("{exit: %d, pid: %d, cmd: \"%s\"}", ret, pid, str);
    exit(0);
    return -1;
#else
#ifdef _MSC_VER
#pragma message("rz_sys_cmdbg is not implemented for this platform")
#else
#warning rz_sys_cmdbg is not implemented for this platform
#endif
    return -1;
#endif
}

References eprintf, test-lz4-list::exit, free(), NULL, pid, rz_file_binsh(), rz_sys_execl(), rz_sys_fork(), and cmd_descs_generate::str.

Referenced by rz_main_rz_agent().

rz_sys_cmdf()

RZ_API int rz_sys_cmdf	(	const char *	fmt,
			...
	)

Definition at line 633 of file sys.c.

                                             {
    int ret;
    char cmd[4096];
    va_list ap;
    va_start(ap, fmt);
    vsnprintf(cmd, sizeof(cmd), fmt, ap);
    ret = rz_sys_system(cmd);
    va_end(ap);
    return ret;
}

References cmd, rz_sys_system(), and vsnprintf.

rz_sys_crash_handler()

RZ_API int rz_sys_crash_handler

(

const char *

cmd

)

Definition at line 457 of file sys.c.

                                                 {
#ifndef __WINDOWS__
    int sig[] = { SIGINT, SIGSEGV, SIGBUS, SIGQUIT, SIGHUP, 0 };
 
    if (!checkcmd(cmd)) {
        return false;
    }
#if HAVE_BACKTRACE
    void *array[1];
    /* call this outside of the signal handler to init it safely */
    backtrace(array, 1);
#endif
 
    free(crash_handler_cmd);
    crash_handler_cmd = strdup(cmd);
 
    rz_sys_sigaction(sig, signal_handler);
#else
#pragma message("rz_sys_crash_handler : unimplemented for this platform")
#endif
    return true;
}

References cmd, free(), rz_sys_sigaction(), SIGHUP, signal_handler(), and strdup().

Referenced by rz_main_rizin().

rz_sys_dir()

RZ_API RzList* rz_sys_dir

(

const char *

path

)

Definition at line 216 of file sys.c.

                                            {
    RzList *list = NULL;
#if __WINDOWS__
    WIN32_FIND_DATAW entry;
    char *cfname;
    HANDLE fh = sys_opendir(path, &entry);
    if (fh == INVALID_HANDLE_VALUE) {
        // IFDGB eprintf ("Cannot open directory %ls\n", wcpath);
        return list;
    }
    list = rz_list_newf(free);
    if (list) {
        do {
            if ((cfname = rz_utf16_to_utf8(entry.cFileName))) {
                rz_list_append(list, cfname);
            }
        } while (FindNextFileW(fh, &entry));
    }
    FindClose(fh);
#else
    struct dirent *entry;
    DIR *dir = sys_opendir(path);
    if (dir) {
        list = rz_list_new();
        if (list) {
            list->free = free;
            while ((entry = readdir(dir))) {
                rz_list_append(list, strdup(entry->d_name));
            }
        }
        closedir(dir);
    }
#endif
    return list;
}

References fh, free(), HANDLE, INVALID_HANDLE_VALUE, list(), NULL, path, readdir, rz_list_append(), rz_list_new(), rz_list_newf(), strdup(), and sys_opendir().

Referenced by __clear_layout_cb(), __get_panels_config_file_from_dir(), __init_menu_saved_layout(), autocmplt_cmd_arg_file(), autocomplete_process_path(), cmd_print_format(), database_load(), is_cpu_valid(), list_themes_in_path(), load_scripts_for(), recursive_search_glob(), rtr_dir_files(), rz_cons_hud_path(), rz_core_loadlibs(), rz_core_parse_rizinrc(), rz_syscmd_ls(), rz_test_test_database_load_fuzz(), and rzfind_open_dir().

rz_sys_env_init()

RZ_API void rz_sys_env_init

(

void

)

Definition at line 1108 of file sys.c.

                                  {
    char **envp = rz_sys_get_environ();
    if (envp) {
        env = envp;
    }
}

References env, and rz_sys_get_environ().

Referenced by rz_main_rizin(), and rz_sys_clearenv().

rz_sys_execl()

RZ_API int rz_sys_execl	(	const char *	pathname,
		const char *	arg,
			...
	)

Definition at line 1575 of file sys.c.

                                                                    {
    return -1;
}

Referenced by bochs_open(), rz_core_cmd_pipe_old(), rz_run_start(), and rz_sys_cmdbg().

rz_sys_execv()

RZ_API int rz_sys_execv	(	const char *	pathname,
		char *const	argv[]
	)

Definition at line 1483 of file sys.c.

                                                                  {
    return -1;
}

Referenced by rz_run_start(), and rz_socket_proc_open().

rz_sys_execve()

RZ_API int rz_sys_execve	(	const char *	pathname,
		char *const	argv[],
		char *const	envp[]
	)

Definition at line 1504 of file sys.c.

                                                                                       {
    return -1;
}

rz_sys_execvp()

RZ_API int rz_sys_execvp	(	const char *	file,
		char *const	argv[]
	)

Definition at line 1525 of file sys.c.

                                                               {
    return -1;
}

Referenced by rz_subprocess_start_opt().

rz_sys_exit()

RZ_API void rz_sys_exit	(	int	status,
		bool	nocleanup
	)

Definition at line 183 of file sys.c.

                                                    {
    if (nocleanup) {
        _exit(status);
    } else {
        exit(status);
    }
}

References test-lz4-list::exit, and status.

Referenced by lang_pipe_run(), and rz_subprocess_start_opt().

rz_sys_fopen()

RZ_API FILE* rz_sys_fopen	(	const char *	path,
		const char *	mode
	)

Definition at line 1815 of file sys.c.

                                                              {
    rz_return_val_if_fail(path && mode, NULL);
    FILE *ret = NULL;
    char *epath = rz_path_home_expand(path);
    if ((strchr(mode, 'w') || strchr(mode, 'a') || rz_file_is_regular(epath))) {
#if __WINDOWS__
        wchar_t *wepath = rz_utf8_to_utf16(epath);
        if (!wepath) {
            free(epath);
            return ret;
        }
        wchar_t *wmode = rz_utf8_to_utf16(mode);
        if (!wmode) {
            free(wepath);
            free(epath);
            return ret;
        }
        ret = _wfopen(wepath, wmode);
        free(wmode);
        free(wepath);
#else // __WINDOWS__
        ret = fopen(epath, mode);
#endif // __WINDOWS__
    }
    free(epath);
    return ret;
}

References benchmark::FILE, free(), NULL, path, rz_file_is_regular(), rz_path_home_expand(), and rz_return_val_if_fail.

Referenced by __write(), DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), ihex_write(), load_1(), rz_cmd_cmp_file_handler(), rz_cons_flush(), rz_core_cmd_foreach(), rz_core_dump(), rz_file_dump(), rz_file_hexdump(), rz_file_slurp(), rz_file_slurp_hexpairs(), rz_file_slurp_range(), rz_line_hist_load(), rz_line_hist_save(), rz_run_parseline(), rz_save_panels_layout(), and rz_vlog().

rz_sys_fork()

RZ_API int rz_sys_fork

(

void

)

Definition at line 1679 of file sys.c.

                             {
    return -1;
}

Referenced by lang_pipe_run(), redirect_socket_to_pty(), rz_core_cmd_pipe_old(), rz_main_rz_agent(), rz_main_rz_bin(), rz_run_config_env(), rz_run_start(), rz_socket_proc_open(), rz_socket_spawn(), rz_subprocess_start_opt(), rz_sys_cmdbg(), rz_sys_run(), rz_sys_run_rop(), rzpipe_open(), and wrap_fork().

rz_sys_get_environ()

RZ_API char** rz_sys_get_environ

(

void

)

Definition at line 1115 of file sys.c.

                                       {
#if __APPLE__ && !HAVE_ENVIRON
    env = *_NSGetEnviron();
#elif HAVE_ENVIRON
    env = environ;
#endif
    // return environ if available??
    if (!env) {
        env = rz_lib_dl_sym(NULL, "environ");
    }
    return env;
}

References env, environ, NULL, and rz_lib_dl_sym().

Referenced by autocmplt_cmd_arg_env(), create_child_env(), rz_cmd_shell_env_handler(), rz_main_rizin(), rz_run_start(), and rz_sys_env_init().

rz_sys_getdir()

RZ_API char* rz_sys_getdir

(

void

)

Get current working directory.

Definition at line 521 of file sys.c.

                                 {
#if __WINDOWS__
    return _getcwd(NULL, 0);
#else
    return getcwd(NULL, 0);
#endif
}

References NULL.

Referenced by getcommapath(), rz_cmd_shell_cd_handler(), rz_cmd_shell_pwd_handler(), rz_file_abspath(), rz_test_chdir_fromtest(), rz_test_main(), and windbg_gcore().

rz_sys_getenv()

RZ_API char* rz_sys_getenv

(

const char *

key

)

Get the value of an environment variable named key or NULL if none exists.

Definition at line 483 of file sys.c.

                                            {
#if __WINDOWS__
    if (!key) {
        return NULL;
    }
    wchar_t *val;
    wchar_t *wkey = rz_utf8_to_utf16(key);
    if (_wdupenv_s(&val, NULL, wkey) || !val) {
        free(wkey);
        return NULL;
    }
    free(wkey);
    char *ret = rz_utf16_to_utf8(val);
    free(val);
    return ret;
#else
    char *b;
    if (!key) {
        return NULL;
    }
    b = getenv(key);
    return b ? strdup(b) : NULL;
#endif
}

Referenced by rz_sys_getenv_asbool().

rz_sys_getenv_asbool()

RZ_API bool rz_sys_getenv_asbool

(

const char *

key

)

Return true if the environment variable has the value 1, false otherwise.

Definition at line 511 of file sys.c.

                                                  {
    char *env = rz_sys_getenv(key);
    const bool res = (env && *env == '1');
    free(env);
    return res;
}

References env, free(), key, and rz_sys_getenv().

Referenced by rz_core_parse_rizinrc(), and rz_main_rizin().

rz_sys_getpid()

RZ_API int rz_sys_getpid

(

void

)

Definition at line 1164 of file sys.c.

                               {
#if __UNIX__
    return getpid();
#elif __WINDOWS__
    return GetCurrentProcessId();
#else
#warning rz_sys_getpid not implemented for this platform
    return -1;
#endif
}

rz_sys_info()

RZ_API RSysInfo* rz_sys_info

(

void

)

Definition at line 1175 of file sys.c.

                                   {
#if __UNIX__
    struct utsname un = { { 0 } };
    if (uname(&un) != -1) {
        RSysInfo *si = RZ_NEW0(RSysInfo);
        if (si) {
            si->sysname = strdup(un.sysname);
            si->nodename = strdup(un.nodename);
            si->release = strdup(un.release);
            si->version = strdup(un.version);
            si->machine = strdup(un.machine);
            return si;
        }
    }
#elif __WINDOWS__
    HKEY key;
    DWORD type;
    DWORD size;
    DWORD major;
    DWORD minor;
    char tmp[256] = { 0 };
    RSysInfo *si = RZ_NEW0(RSysInfo);
    if (!si) {
        return NULL;
    }
 
    if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", 0,
            KEY_QUERY_VALUE, &key) != ERROR_SUCCESS) {
        rz_sys_perror("rz_sys_info/RegOpenKeyExA");
        rz_sys_info_free(si);
        return NULL;
    }
 
    size = sizeof(tmp);
    if (RegQueryValueExA(key, "ProductName", NULL, &type,
            (LPBYTE)&tmp, &size) != ERROR_SUCCESS ||
        type != REG_SZ) {
        goto beach;
    }
    si->sysname = strdup(tmp);
 
    size = sizeof(major);
    if (RegQueryValueExA(key, "CurrentMajorVersionNumber", NULL, &type,
            (LPBYTE)&major, &size) != ERROR_SUCCESS ||
        type != REG_DWORD) {
        goto beach;
    }
    size = sizeof(minor);
    if (RegQueryValueExA(key, "CurrentMinorVersionNumber", NULL, &type,
            (LPBYTE)&minor, &size) != ERROR_SUCCESS ||
        type != REG_DWORD) {
        goto beach;
    }
 
    size = sizeof(tmp);
    if (RegQueryValueExA(key, "CurrentBuild", NULL, &type,
            (LPBYTE)&tmp, &size) != ERROR_SUCCESS ||
        type != REG_SZ) {
        goto beach;
    }
    si->version = rz_str_newf("%lu.%lu.%s", major, minor, tmp);
 
    size = sizeof(tmp);
    if (RegQueryValueExA(key, "ReleaseId", NULL, &type,
            (LPBYTE)tmp, &size) != ERROR_SUCCESS ||
        type != REG_SZ) {
        goto beach;
    }
    si->release = strdup(tmp);
beach:
    RegCloseKey(key);
    return si;
#endif
    return NULL;
}

References DWORD, key, major, minor, NULL, RZ_NEW0, rz_str_newf(), rz_sys_info_free(), rz_sys_perror, si, strdup(), autogen_x86imm::tmp, type, and uname.

Referenced by __is_windows_ten(), and rz_cmd_shell_uname_handler().

rz_sys_info_free()

RZ_API void rz_sys_info_free

(

RSysInfo *

si

)

Definition at line 1251 of file sys.c.

                                           {
    free(si->sysname);
    free(si->nodename);
    free(si->release);
    free(si->version);
    free(si->machine);
    free(si);
}

References free(), and si.

Referenced by __is_windows_ten(), rz_cmd_shell_uname_handler(), and rz_sys_info().

rz_sys_kill()

RZ_API int rz_sys_kill	(	int	pid,
		int	sig
	)

Send signal sig to process with pid pid.

Parameters

pid	PID of the process to send the signal to
sig	Signal to send to the process.

Returns

0 on success, -1 on failure.

Definition at line 1850 of file sys.c.

                                         {
    rz_return_val_if_fail(pid != -1, -1);
#if __UNIX__
    return kill(pid, sig);
#else
    return -1;
#endif
}

References kill, pid, and rz_return_val_if_fail.

Referenced by rz_debug_signal_send(), rz_main_rz_agent(), and rz_sys_stop().

rz_sys_mkdir()

RZ_API bool rz_sys_mkdir

(

const char *

dir

)

Definition at line 678 of file sys.c.

                                          {
    bool ret;
 
#if __WINDOWS__
    wchar_t *dir_utf16 = rz_utf8_to_utf16(dir);
    ret = _wmkdir(dir_utf16) != -1;
    free(dir_utf16);
#else
    ret = mkdir(dir, 0755) != -1;
#endif
    return ret;
}

References free(), and mkdir.

Referenced by rz_sys_mkdirp().

rz_sys_mkdirp()

RZ_API bool rz_sys_mkdirp

(

const char *

dir

)

Definition at line 691 of file sys.c.

                                           {
    bool ret = true;
    char slash = RZ_SYS_DIR[0];
    char *path = strdup(dir), *ptr = path;
    if (!path) {
        eprintf("rz_sys_mkdirp: Unable to allocate memory\n");
        return false;
    }
    if (*ptr == slash) {
        ptr++;
    }
#if __WINDOWS__
    {
        char *p = strstr(ptr, ":\\");
        if (p) {
            ptr = p + 3;
        }
    }
#endif
    for (;;) {
        // find next slash
        for (; *ptr; ptr++) {
            if (*ptr == '/' || *ptr == '\\') {
                slash = *ptr;
                break;
            }
        }
        if (!*ptr) {
            break;
        }
        *ptr = 0;
        if (!rz_sys_mkdir(path) && rz_sys_mkdir_failed()) {
            eprintf("rz_sys_mkdirp: fail '%s' of '%s'\n", path, dir);
            free(path);
            return false;
        }
        *ptr = slash;
        ptr++;
    }
    if (!rz_sys_mkdir(path) && rz_sys_mkdir_failed()) {
        ret = false;
    }
    free(path);
    return ret;
}

References eprintf, free(), p, path, RZ_SYS_DIR, rz_sys_mkdir(), rz_sys_mkdir_failed, and strdup().

Referenced by __create_panels_config_path(), download_and_write(), extract_binobj(), rz_line_hist_save(), rz_syscmd_mkdir(), and sdb_disk_create().

rz_sys_open()

RZ_API int rz_sys_open	(	const char *	path,
		int	perm,
		int	mode
	)

Definition at line 1740 of file sys.c.

                                                             {
    rz_return_val_if_fail(path, -1);
    char *epath = rz_path_home_expand(path);
    int ret = -1;
#if __WINDOWS__
    if (!strcmp(path, "/dev/null")) {
        path = "NUL";
    }
    {
        DWORD flags = 0;
        DWORD sharing = FILE_SHARE_READ;
        if (perm & O_RANDOM) {
            flags = FILE_FLAG_RANDOM_ACCESS;
        } else if (perm & O_SEQUENTIAL) {
            flags = FILE_FLAG_SEQUENTIAL_SCAN;
        }
        if (perm & O_TEMPORARY) {
            flags |= FILE_FLAG_DELETE_ON_CLOSE | FILE_ATTRIBUTE_TEMPORARY;
            sharing |= FILE_SHARE_DELETE;
        } else if (perm & _O_SHORT_LIVED) {
            flags |= FILE_ATTRIBUTE_TEMPORARY;
        } else {
            flags |= FILE_ATTRIBUTE_NORMAL;
        }
        DWORD creation = 0;
        bool read_only = false;
        if (perm & O_CREAT) {
            if (perm & O_EXCL) {
                creation = CREATE_NEW;
            } else {
                creation = OPEN_ALWAYS;
            }
            if (mode & S_IREAD && !(mode & S_IWRITE)) {
                flags = FILE_ATTRIBUTE_READONLY;
                read_only = true;
            }
        } else if (perm & O_TRUNC) {
            creation = TRUNCATE_EXISTING;
        }
        if (!creation || !strcasecmp("NUL", path)) {
            creation = OPEN_EXISTING;
        }
        DWORD permission = 0;
        if (perm & O_WRONLY) {
            permission = GENERIC_WRITE;
        } else if (perm & O_RDWR) {
            permission = GENERIC_WRITE | GENERIC_READ;
        } else {
            permission = GENERIC_READ;
        }
        if (perm & O_APPEND) {
            permission |= FILE_APPEND_DATA;
        }
        if (!read_only) {
            sharing |= FILE_SHARE_WRITE;
        }
 
        wchar_t *wepath = rz_utf8_to_utf16(epath);
        if (!wepath) {
            free(epath);
            return -1;
        }
        HANDLE h = CreateFileW(wepath, permission, sharing, NULL, creation, flags, NULL);
        if (h != INVALID_HANDLE_VALUE) {
            ret = _open_osfhandle((intptr_t)h, perm);
        }
        free(wepath);
    }
#else // __WINDOWS__
    ret = open(epath, perm, mode);
#endif // __WINDOWS__
    free(epath);
    return ret;
}

References DWORD, flags, free(), h, HANDLE, INVALID_HANDLE_VALUE, NULL, O_APPEND, O_CREAT, O_EXCL, O_RDWR, O_TRUNC, O_WRONLY, path, rz_path_home_expand(), and rz_return_val_if_fail.

Referenced by apprentice_compile(), apprentice_map(), binutils_assemble(), buf_file_init(), langFromHashbang(), procfs_pid_slurp(), rz_cons_pipe_open(), rz_core_editor(), rz_file_mkstemp(), rz_file_mmap(), rz_file_mmap_resize(), rz_file_truncate(), rz_sys_aslr(), rz_sys_truncate(), and sp_open().

rz_sys_open_perms()

RZ_API int rz_sys_open_perms

(

int

rizin_perms

)

Convert rizin permissions (RZ_PERM_*) to posix permissions that can be passed to rz_sys_open .

rz_sys_open accepts posix permissions for now, not the arch-independent ones provided by RZ_PERM_*. This function is an helper to convert from rizin permissions to posix ones.

Definition at line 1718 of file sys.c.

                                              {
    int res = 0;
    if ((rizin_perms & RZ_PERM_R) && (rizin_perms & RZ_PERM_W)) {
        res |= O_RDWR;
        // NOTE: O_CREAT is added here because Rizin for now assumes Write means
        // ability to create a file as well.
        res |= O_CREAT;
    } else if (rizin_perms & RZ_PERM_R) {
        res |= O_RDONLY;
    } else if (rizin_perms & RZ_PERM_W) {
        res |= O_WRONLY;
        // NOTE: O_CREAT is added here because Rizin for now assumes Write means
        // ability to create a file as well.
        res |= O_CREAT;
    }
    if (rizin_perms & RZ_PERM_CREAT) {
        res |= O_CREAT;
    }
    return res;
}

References O_CREAT, O_RDONLY, O_RDWR, O_WRONLY, RZ_PERM_CREAT, RZ_PERM_R, and RZ_PERM_W.

Referenced by rz_io_ar_open(), rz_io_ar_open_many(), and rz_io_def_mmap_create_new_file().

rz_sys_perror_str()

RZ_API void rz_sys_perror_str

(

const char *

fun

)

Definition at line 737 of file sys.c.

                                               {
#if __UNIX__
#pragma push_macro("perror")
#undef perror
    perror(fun);
#pragma pop_macro("perror")
#elif __WINDOWS__
    LPTSTR lpMsgBuf;
    DWORD dw = GetLastError();
 
    if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
                FORMAT_MESSAGE_FROM_SYSTEM |
                FORMAT_MESSAGE_IGNORE_INSERTS,
            NULL,
            dw,
            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
            (LPTSTR)&lpMsgBuf,
            0, NULL)) {
        char *err = rz_sys_conv_win_to_utf8(lpMsgBuf);
        if (err) {
            eprintf("%s: (%#lx) %s%s", fun, dw, err,
                rz_str_endswith(err, "\n") ? "" : "\n");
            free(err);
        }
        LocalFree(lpMsgBuf);
    } else {
        eprintf("%s\n", fun);
    }
#endif
}

References DWORD, eprintf, err, free(), NULL, and rz_str_endswith().

rz_sys_pid_to_path()

RZ_API char* rz_sys_pid_to_path

(

int

pid

)

Definition at line 920 of file sys.c.

                                         {
#if __WINDOWS__
    // TODO: add maximum path length support
    HANDLE processHandle;
    const DWORD maxlength = MAX_PATH;
    WCHAR filename[MAX_PATH];
    char *result = NULL;
 
    processHandle = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pid);
    if (!processHandle) {
        eprintf("rz_sys_pid_to_path: Cannot open process.\n");
        return NULL;
    }
    DWORD length = GetModuleFileNameExW(processHandle, NULL, filename, maxlength);
    if (length == 0) {
        // Upon failure fallback to GetProcessImageFileName
        length = GetProcessImageFileNameW(processHandle, filename, maxlength);
        CloseHandle(processHandle);
        if (length == 0) {
            eprintf("rz_sys_pid_to_path: Error calling GetProcessImageFileName\n");
            return NULL;
        }
        // Convert NT path to win32 path
        char *name = rz_utf16_to_utf8(filename);
        if (!name) {
            eprintf("rz_sys_pid_to_path: Error converting to utf8\n");
            return NULL;
        }
        char *tmp = strchr(name + 1, '\\');
        if (!tmp) {
            free(name);
            eprintf("rz_sys_pid_to_path: Malformed NT path\n");
            return NULL;
        }
        tmp = strchr(tmp + 1, '\\');
        if (!tmp) {
            free(name);
            eprintf("rz_sys_pid_to_path: Malformed NT path\n");
            return NULL;
        }
        length = tmp - name;
        tmp = malloc(length + 1);
        if (!tmp) {
            free(name);
            eprintf("rz_sys_pid_to_path: Error allocating memory\n");
            return NULL;
        }
        strncpy(tmp, name, length);
        tmp[length] = '\0';
        WCHAR device[MAX_PATH];
        for (WCHAR drv[] = L"A:"; drv[0] <= L'Z'; drv[0]++) {
            if (QueryDosDeviceW(drv, device, maxlength) > 0) {
                char *dvc = rz_utf16_to_utf8(device);
                if (!dvc) {
                    free(name);
                    free(tmp);
                    eprintf("rz_sys_pid_to_path: Error converting to utf8\n");
                    return NULL;
                }
                if (!strcmp(tmp, dvc)) {
                    free(tmp);
                    free(dvc);
                    char *d = rz_utf16_to_utf8(drv);
                    if (!d) {
                        free(name);
                        eprintf("rz_sys_pid_to_path: Error converting to utf8\n");
                        return NULL;
                    }
                    tmp = rz_str_newf("%s%s", d, &name[length]);
                    free(d);
                    if (!tmp) {
                        free(name);
                        eprintf("rz_sys_pid_to_path: Error calling rz_str_newf\n");
                        return NULL;
                    }
                    result = strdup(tmp);
                    break;
                }
                free(dvc);
            }
        }
        free(name);
        free(tmp);
    } else {
        CloseHandle(processHandle);
        result = rz_utf16_to_utf8(filename);
    }
    return result;
#elif __APPLE__
    char pathbuf[PROC_PIDPATHINFO_MAXSIZE];
    pathbuf[0] = 0;
    int ret = proc_pidpath(pid, pathbuf, sizeof(pathbuf));
    if (ret <= 0) {
        return NULL;
    }
    return strdup(pathbuf);
#else
    int ret;
#if __FreeBSD__ || __DragonFly__
    char pathbuf[PATH_MAX];
    size_t pathbufl = sizeof(pathbuf);
    int mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, pid };
    ret = sysctl(mib, 4, pathbuf, &pathbufl, NULL, 0);
    if (ret != 0) {
        return NULL;
    }
#elif __OpenBSD__
    // Taken from https://stackoverflow.com/questions/31494901/how-to-get-the-executable-path-on-openbsd
    char pathbuf[PATH_MAX];
    int mib[4] = { CTL_KERN, KERN_PROC_ARGS, pid, KERN_PROC_ARGV };
    size_t len;
 
    pathbuf[0] = '\0';
    ret = sysctl(mib, 4, NULL, &len, NULL, 0);
    if (ret < 0) {
        return NULL;
    }
    char **argv = malloc(len);
    ret = sysctl(mib, 4, argv, &len, NULL, 0);
    if (ret < 0) {
        free(argv);
        return NULL;
    }
    const char *comm = argv[0];
    int ok = 0;
    if (*comm == '/' || *comm == '.') {
        if (!realpath(comm, pathbuf)) {
            free(argv);
            return NULL;
        }
    } else {
        char *sp;
        char *xpath = strdup(getenv("PATH"));
        char *path = strtok_r(xpath, ":", &sp);
        struct stat st;
 
        if (!xpath) {
            free(argv);
            return NULL;
        }
 
        while (path) {
            snprintf(pathbuf, PATH_MAX, "%s/%s", path, comm);
            if (!stat(pathbuf, &st) && (st.st_mode & S_IXUSR)) {
                ok = 1;
                break;
            }
            path = strtok_r(NULL, ":", &sp);
        }
        free(xpath);
    }
 
    if (ok) {
        char *p = strrchr(pathbuf, '/');
        if (p) {
            *p = '\0';
        }
    }
    free(argv);
#elif __HAIKU__
    char pathbuf[MAXPATHLEN];
    int32_t group = 0;
    image_info ii;
 
    while (get_next_image_info((team_id)pid, &group, &ii) == B_OK) {
        if (ii.type == B_APP_IMAGE) {
            break;
        }
    }
 
    if (ii.type == B_APP_IMAGE) {
        rz_str_ncpy(pathbuf, ii.name, MAXPATHLEN);
    } else {
        pathbuf[0] = '\0';
    }
#else
    char buf[128], pathbuf[1024];
    snprintf(buf, sizeof(buf), "/proc/%d/exe", pid);
    ret = readlink(buf, pathbuf, sizeof(pathbuf) - 1);
    if (ret < 1) {
        return NULL;
    }
    pathbuf[ret] = 0;
#endif
    return strdup(pathbuf);
#endif
}

References argv, d, DWORD, eprintf, FALSE, free(), getenv(), HANDLE, L, len, length, malloc(), name, NULL, ok, p, path, pid, readlink, rz_str_ncpy(), rz_str_newf(), snprintf, sp, stat, strdup(), and autogen_x86imm::tmp.

Referenced by cmd_debug_pid(), and rz_debug_get_baddr().

rz_sys_pipe()

RZ_API int rz_sys_pipe	(	int	pipefd[2],
		bool	close_on_exec
	)

Definition at line 1458 of file sys.c.

                                                          {
    return -1;
}

Referenced by bochs_open(), handle_redirection(), lang_pipe_run(), rz_core_cmd_pipe_old(), rz_run_config_env(), rz_socket_proc_open(), rz_subprocess_init(), rz_subprocess_start_opt(), and rzpipe_open().

rz_sys_pipe_close()

RZ_API int rz_sys_pipe_close

(

int

fd

)

Definition at line 1462 of file sys.c.

                                     {
    return -1;
}

Referenced by bochs_open(), handle_redirection(), lang_pipe_run(), rz_core_cmd_pipe_old(), rz_run_config_env(), rz_subprocess_fini(), rz_subprocess_free(), rz_subprocess_init(), rz_subprocess_start_opt(), rz_subprocess_wait(), rzpipe_close(), and rzpipe_open().

rz_sys_run()

RZ_API int rz_sys_run	(	const ut8 *	buf,
		int	len
	)

Definition at line 809 of file sys.c.

                                               {
    const int sz = 4096;
    int pdelta, ret, (*cb)();
#if USE_FORK
    int st, pid;
#endif
    // TODO: define RZ_SYS_ALIGN_FORWARD in rz_util.h
    ut8 *ptr, *p = malloc((sz + len) << 1);
    ptr = p;
    pdelta = ((size_t)(p)) & (4096 - 1);
    if (pdelta) {
        ptr += (4096 - pdelta);
    }
    if (!ptr || !buf) {
        eprintf("rz_sys_run: Cannot run empty buffer\n");
        free(p);
        return false;
    }
    memcpy(ptr, buf, len);
    rz_mem_protect(ptr, sz, "rx");
    // rz_mem_protect (ptr, sz, "rwx"); // try, ignore if fail
    cb = (int (*)())ptr;
#if USE_FORK
#if __UNIX__
    pid = rz_sys_fork();
#else
    pid = -1;
#endif
    if (pid < 0) {
        return cb();
    }
    if (!pid) {
        ret = cb();
        exit(ret);
        return ret;
    }
    st = 0;
    waitpid(pid, &st, 0);
    if (WIFSIGNALED(st)) {
        int num = WTERMSIG(st);
        eprintf("Got signal %d\n", num);
        ret = num;
    } else {
        ret = WEXITSTATUS(st);
    }
#else
    ret = (*cb)();
#endif
    free(p);
    return ret;
}

References cb, eprintf, test-lz4-list::exit, free(), int, len, malloc(), memcpy(), num, p, pid, rz_mem_protect(), and rz_sys_fork().

Referenced by rz_egg_run().

rz_sys_run_rop()

RZ_API int rz_sys_run_rop	(	const ut8 *	buf,
		int	len
	)

Definition at line 861 of file sys.c.

                                                   {
#if USE_FORK
    int st;
#endif
    // TODO: define RZ_SYS_ALIGN_FORWARD in rz_util.h
    ut8 *bufptr = malloc(len);
    if (!bufptr) {
        eprintf("rz_sys_run_rop: Cannot allocate buffer\n");
        return false;
    }
 
    if (!buf) {
        eprintf("rz_sys_run_rop: Cannot execute empty rop chain\n");
        free(bufptr);
        return false;
    }
    memcpy(bufptr, buf, len);
#if USE_FORK
#if __UNIX__
    pid_t pid = rz_sys_fork();
#else
    pid = -1;
#endif
    if (pid < 0) {
        RZ_SYS_ASM_START_ROP();
    } else {
        RZ_SYS_ASM_START_ROP();
        exit(0);
        return 0;
    }
    st = 0;
    if (waitpid(pid, &st, 0) == -1) {
        eprintf("rz_sys_run_rop: waitpid failed\n");
        free(bufptr);
        return -1;
    }
    if (WIFSIGNALED(st)) {
        int num = WTERMSIG(st);
        eprintf("Got signal %d\n", num);
        ret = num;
    } else {
        ret = WEXITSTATUS(st);
    }
#else
    RZ_SYS_ASM_START_ROP();
#endif
    free(bufptr);
    return 0;
}

References eprintf, test-lz4-list::exit, free(), len, malloc(), memcpy(), num, pid, RZ_SYS_ASM_START_ROP, and rz_sys_fork().

Referenced by rz_egg_run_rop().

rz_sys_set_environ()

RZ_API void rz_sys_set_environ

(

char **

e

)

Definition at line 1128 of file sys.c.

                                         {
    env = e;
#if __APPLE__ && !HAVE_ENVIRON
    *_NSGetEnviron() = e;
#elif __WINDOWS__
    char **oe = e;
    rz_sys_clearenv();
    while (*e) {
        char *var = *e;
        char *val = strchr(var, '=');
        wchar_t *val_utf16 = NULL;
        if (*val) {
            *val++ = '\0';
        }
        rz_sys_setenv(var, val);
        free(*e);
        e++;
    }
    free(oe);
    env = environ;
#elif HAVE_ENVIRON
    environ = e;
#endif
}

References e, env, environ, free(), NULL, rz_sys_clearenv(), rz_sys_setenv(), and val.

Referenced by rz_subprocess_start_opt().

rz_sys_setenv()

RZ_API int rz_sys_setenv	(	const char *	key,
		const char *	value
	)

Set an environment variable in the calling process.

Definition at line 405 of file sys.c.

                                                             {
    if (!key) {
        return 0;
    }
#if __UNIX__
    if (!value) {
        unsetenv(key);
        return 0;
    }
    return setenv(key, value, 1);
#elif __WINDOWS__
    LPWSTR key_ = rz_utf8_to_utf16(key);
    LPWSTR value_ = value ? rz_utf8_to_utf16(value) : L"";
    bool ret = !_wputenv_s(key_, value_);
    free(key_);
    if (value) {
        free(value_);
    }
    return ret ? 0 : -1;
#else
#warning rz_sys_setenv : unimplemented for this platform
    return 0;
#endif
}

Referenced by rz_sys_set_environ().

rz_sys_sigaction()

RZ_API int rz_sys_sigaction	(	int *	sig,
		void(*)(int)	handler
	)

Definition at line 162 of file sys.c.

                                                            {
    if (!sig) {
        return -EINVAL;
    }
    size_t i;
    for (i = 0; sig[i] != 0; i++) {
        void (*ret)(int) = signal(sig[i], handler);
        if (ret == SIG_ERR) {
            eprintf("Failed to set signal handler for signal '%d': %s\n", sig[i], strerror(errno));
            return -1;
        }
    }
    return 0;
}

References EINVAL, eprintf, i, int, and signal.

Referenced by rz_sys_crash_handler(), and rz_sys_signal().

rz_sys_signal()

RZ_API int rz_sys_signal	(	int	sig,
		void(*)(int)	handler
	)

Definition at line 178 of file sys.c.

                                                        {
    int s[2] = { sig, 0 };
    return rz_sys_sigaction(s, handler);
}

References rz_sys_sigaction(), and s.

Referenced by activateDieTime(), rz_cons_break_end(), rz_cons_context_break_pop(), rz_cons_context_break_push(), rz_cons_new(), rz_core_cmd_pipe_old(), rz_socket_connect(), rz_socket_listen(), rz_socket_new(), rz_socket_write(), rz_subprocess_fini(), rz_subprocess_init(), rz_subprocess_stdin_write(), and tcpme().

rz_sys_sleep()

RZ_API int rz_sys_sleep

(

int

secs

)

Sleep for secs seconds.

Definition at line 300 of file sys.c.

                                  {
#if HAVE_CLOCK_NANOSLEEP && defined(CLOCK_MONOTONIC)
    struct timespec rqtp;
    rqtp.tv_sec = secs;
    rqtp.tv_nsec = 0;
    return clock_nanosleep(CLOCK_MONOTONIC, 0, &rqtp, NULL);
#elif __UNIX__
    return sleep(secs);
#else
    Sleep(secs * 1000); // W32
    return 0;
#endif
}

References NULL, timespec::tv_nsec, and timespec::tv_sec.

Referenced by qnxr_attach(), rtr_visual(), rz_cmd_shell_sleep_handler(), rz_core_visual_esil(), rz_core_visual_show_char(), rz_core_visual_trackflags(), rz_main_rizin(), rz_run_config_env(), rz_socket_spawn(), and sdb_lock_wait().

rz_sys_stop()

RZ_API bool rz_sys_stop

(

void

)

Send SIGTSTP signal to every process in this process group.

Returns

true if at least one signal was sent, false otherwise

Definition at line 1864 of file sys.c.

                              {
#if __UNIX__
    return !rz_sys_kill(0, SIGTSTP);
#else
    return false;
#endif
}

References rz_sys_kill().

Referenced by rz_cons_controlz().

rz_sys_system()

RZ_API int rz_sys_system

(

const char *

command

)

Definition at line 1658 of file sys.c.

                                              {
    return -1;
}

Referenced by binutils_assemble(), handle_redirection_proc(), rz_cmd_shell_mv_handler(), rz_egg_Cfile_parser(), rz_run_start(), rz_sys_cmdf(), rz_test_test_run_unit(), and rzpipe_open().

rz_sys_truncate()

RZ_API int rz_sys_truncate	(	const char *	file,
		int	sz
	)

Definition at line 1692 of file sys.c.

                                                     {
#if __WINDOWS__
    int fd = rz_sys_open(file, O_RDWR, 0644);
    if (fd == -1) {
        return false;
    }
    int r = rz_sys_truncate_fd(fd, sz);
    if (r != 0) {
        eprintf("Could not resize '%s' file\n", file);
        close(fd);
        return false;
    }
    close(fd);
    return true;
#else
    return truncate(file, sz) == 0;
#endif
}

References close, eprintf, fd, O_RDWR, r, rz_sys_open(), rz_sys_truncate_fd(), and truncate.

Referenced by rz_core_dump(), rz_file_dump(), rz_file_hexdump(), and rz_file_mmap_resize().

rz_sys_truncate_fd()

RZ_API int rz_sys_truncate_fd	(	int	fd,
		ut64	length
	)

Definition at line 1684 of file sys.c.

                                                   {
#ifdef _MSC_VER
    return _chsize_s(fd, length);
#else
    return ftruncate(fd, (off_t)length);
#endif
}

References fd, ftruncate, and length.

Referenced by buf_file_resize(), and rz_sys_truncate().

rz_sys_usleep()

RZ_API int rz_sys_usleep

(

int

usecs

)

Sleep for usecs microseconds.

Definition at line 317 of file sys.c.

                                    {
#if HAVE_CLOCK_NANOSLEEP && defined(CLOCK_MONOTONIC)
    struct timespec rqtp;
    rqtp.tv_sec = usecs / 1000000;
    rqtp.tv_nsec = (usecs - (rqtp.tv_sec * 1000000)) * 1000;
    return clock_nanosleep(CLOCK_MONOTONIC, 0, &rqtp, NULL);
#elif __UNIX__
#if defined(__GLIBC__) && defined(__GLIBC_MINOR__) && (__GLIBC__ <= 2) && (__GLIBC_MINOR__ <= 2)
    // Old versions of GNU libc return void for usleep
    usleep(usecs);
    return 0;
#else
    return usleep(usecs);
#endif
#else
    // w32 api uses milliseconds
    usecs /= 1000;
    Sleep(usecs); // W32
    return 0;
#endif
}

References NULL, timespec::tv_nsec, and timespec::tv_sec.

Referenced by basefind_thread_ui(), run_basic_block_analysis(), rz_cmd_debug(), rz_cons_flush(), rz_core_rtr_cmds_query(), rz_core_rtr_http_run(), rz_core_visual_esil(), rz_diff_draw_tui(), rz_socket_spawn(), rz_th_yield(), and visual_seek_animation().

rz_sys_whoami()

RZ_API char* rz_sys_whoami

(

char *

buf

)

Definition at line 1153 of file sys.c.

                                      {
    char _buf[32];
    int pid = getpid();
    int hasbuf = (buf) ? 1 : 0;
    if (!hasbuf) {
        buf = _buf;
    }
    sprintf(buf, "pid%d", pid);
    return hasbuf ? buf : strdup(buf);
}

References pid, sprintf, and strdup().

Referenced by rz_core_config_init().

sys_opendir()

static DIR* sys_opendir ( const char *  path )

static

Definition at line 210 of file sys.c.

                                          {
    rz_return_val_if_fail(path, NULL);
    return opendir(path);
}

References NULL, path, and rz_return_val_if_fail.

Referenced by rz_sys_dir().

Variable Documentation

const { ... } arch_bit_array[]

Initial value:

= {
    { "x86", RZ_SYS_ARCH_X86 },
    { "arm", RZ_SYS_ARCH_ARM },
    { "ppc", RZ_SYS_ARCH_PPC },
    { "m68k", RZ_SYS_ARCH_M68K },
    { "java", RZ_SYS_ARCH_JAVA },
    { "mips", RZ_SYS_ARCH_MIPS },
    { "sparc", RZ_SYS_ARCH_SPARC },
    { "xap", RZ_SYS_ARCH_XAP },
    { "tms320", RZ_SYS_ARCH_TMS320 },
    { "msil", RZ_SYS_ARCH_MSIL },
    { "objd", RZ_SYS_ARCH_OBJD },
    { "bf", RZ_SYS_ARCH_BF },
    { "sh", RZ_SYS_ARCH_SH },
    { "avr", RZ_SYS_ARCH_AVR },
    { "dalvik", RZ_SYS_ARCH_DALVIK },
    { "z80", RZ_SYS_ARCH_Z80 },
    { "arc", RZ_SYS_ARCH_ARC },
    { "i8080", RZ_SYS_ARCH_I8080 },
    { "rar", RZ_SYS_ARCH_RAR },
    { "lm32", RZ_SYS_ARCH_LM32 },
    { "v850", RZ_SYS_ARCH_V850 },
    { NULL, 0 }
}

Referenced by rz_sys_arch_id(), and rz_sys_arch_str().

bit

ut64 bit

Definition at line 109 of file sys.c.

Referenced by rz_sys_arch_str().

env

char** env = NULL

static

Definition at line 32 of file sys.c.

Referenced by autocmplt_cmd_arg_env(), binutils_assemble(), find_include(), find_path(), make_program_env(), nto_send_env(), parse_environment(), qnxr_run(), rz_assert_log(), rz_egg_lang_include_path(), rz_lib_path(), rz_main_rizin(), rz_run_get_environ_profile(), rz_sys_clearenv(), rz_sys_env_init(), rz_sys_get_environ(), rz_sys_getenv_asbool(), rz_sys_set_environ(), system_apply_env_var(), uv_os_environ(), and uv_spawn().

name

const char* name

Definition at line 108 of file sys.c.

Referenced by rz_sys_pid_to_path().