file.c File Reference

#include "rz_types.h"
#include "rz_util.h"
#include <stdio.h>
#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <rz_lib.h>

Go to the source code of this file.

Macros
#define	BS   1024
#define	StructStat   struct stat

Functions
static int	file_stat (const char *file, StructStat *pStat)
RZ_API bool	rz_file_truncate (const char *filename, ut64 newsize)
RZ_API const char *	rz_file_basename (const char *path)
RZ_API const char *	rz_file_dos_basename (RZ_BORROW RZ_NONNULL const char *path)
RZ_API char *	rz_file_dirname (const char *path)
RZ_API bool	rz_file_is_c (const char *file)
RZ_API bool	rz_file_is_regular (const char *str)
RZ_API bool	rz_file_is_directory (const char *str)
RZ_API bool	rz_file_fexists (const char *fmt,...)
RZ_API bool	rz_file_exists (const char *str)
RZ_API ut64	rz_file_size (const char *str)
RZ_API bool	rz_file_is_abspath (const char *file)
RZ_API char *	rz_file_abspath_rel (const char *cwd, const char *file)
RZ_API char *	rz_file_abspath (const char *file)
RZ_API char *	rz_file_relpath (const char *base, const char *path)
RZ_API char *	rz_file_path_local_to_unix (const char *path)
RZ_API char *	rz_file_path_unix_to_local (const char *path)
RZ_API char *	rz_file_path (const char *bin)
RZ_API char *	rz_file_binsh (void)
RZ_API char *	rz_stdin_slurp (int *sz)
RZ_API RZ_OWN char *	rz_file_slurp (const char *str, RZ_NULLABLE size_t *usz)
RZ_API ut8 *	rz_file_gzslurp (const char *str, int *outlen, int origonfail)
RZ_API ut8 *	rz_file_slurp_hexpairs (const char *str, int *usz)
RZ_API char *	rz_file_slurp_range (const char *str, ut64 off, int sz, int *osz)
RZ_API char *	rz_file_slurp_random_line (const char *file)
RZ_API char *	rz_file_slurp_random_line_count (const char *file, int *line)
RZ_API char *	rz_file_slurp_line (const char *file, int line, int context)
RZ_API RZ_OWN char *	rz_file_slurp_lines_from_bottom (const char *file, int line)
RZ_API char *	rz_file_slurp_lines (const char *file, int line, int count)
RZ_API char *	rz_file_root (const char *root, const char *path)
RZ_API bool	rz_file_hexdump (const char *file, const ut8 *buf, int len, int append)
RZ_API bool	rz_file_touch (const char *file)
RZ_API bool	rz_file_dump (const char *file, const ut8 *buf, int len, bool append)
RZ_API bool	rz_file_rm (const char *file)
RZ_API char *	rz_file_readlink (const char *path)
static RzMmap *	file_mmap (RzMmap *m)
RZ_API RzMmap *	rz_file_mmap (const char *file, int perm, int mode, ut64 base)
RZ_API void	rz_file_mmap_free (RzMmap *m)
RZ_API void *	rz_file_mmap_resize (RzMmap *m, ut64 newsize)
RZ_API char *	rz_file_temp (const char *prefix)
RZ_API int	rz_file_mkstemp (RZ_NULLABLE const char *prefix, char **oname)
RZ_API char *	rz_file_tmpdir (void)
RZ_API bool	rz_file_copy (const char *src, const char *dst)
static void	recursive_search_glob (const char *path, const char *glob, RzList *list, int depth)
RZ_API RzList *	rz_file_globsearch (const char *_globbed_path, int maxdepth)
RZ_API RZ_OWN char *	rz_file_path_join (RZ_NONNULL const char *s1, RZ_NULLABLE const char *s2)
	Concatenate two paths to create a new one with s1+s2 with the correct path separator. More...
RZ_API bool	rz_file_deflate (RZ_NONNULL const char *src, RZ_NONNULL const char *dst)
	zip the contents of src and store in dst More...
RZ_API bool	rz_file_inflate (RZ_NONNULL const char *src, RZ_NONNULL const char *dst)
	unzip the contents of src and store in dst More...
RZ_API bool	rz_file_is_deflated (RZ_NONNULL const char *src)
	check whether a file is a deflated (gzip) file More...

Macro Definition Documentation

BS

#define BS   1024

Definition at line 25 of file file.c.

StructStat

#define StructStat   struct stat

Definition at line 29 of file file.c.

Function Documentation

file_mmap()

static RzMmap* file_mmap ( RzMmap *  m )

static

Definition at line 959 of file file.c.

                                    {
    m->len = lseek(m->fd, (off_t)0, SEEK_END);
    m->buf = malloc (m->len));
    if (!m->buf) {
        rz_file_mmap_free(m);
        return NULL;
    }
    lseek(m->fd, (off_t)0, SEEK_SET);
    rz_xread(m->fd, m->buf, m->len);
    return m;
}

References lseek, regress::m, malloc(), NULL, rz_file_mmap_free(), rz_xread, SEEK_END, and SEEK_SET.

Referenced by rz_file_mmap(), and rz_file_mmap_resize().

file_stat()

static int file_stat ( const char *  file, StructStat *  pStat  )

static

Definition at line 32 of file file.c.

                                                          {
    rz_return_val_if_fail(file && pStat, -1);
#if __WINDOWS__
    wchar_t *wfile = rz_utf8_to_utf16(file);
    if (!wfile) {
        return -1;
    }
    int ret = _wstati64(wfile, pStat);
    free(wfile);
    return ret;
#else // __WINDOWS__
    return stat(file, pStat);
#endif // __WINDOWS__
}

References free(), rz_return_val_if_fail, and stat.

Referenced by rz_file_exists(), rz_file_is_directory(), rz_file_is_regular(), and rz_file_size().

recursive_search_glob()

static void recursive_search_glob ( const char *  path, const char *  glob, RzList *  list, int  depth  )

static

Definition at line 1232 of file file.c.

                                                                                               {
    if (depth < 1) {
        return;
    }
    char *file;
    RzListIter *iter;
    RzList *dir = rz_sys_dir(path);
    rz_list_foreach (dir, iter, file) {
        if (!strcmp(file, ".") || !strcmp(file, "..")) {
            continue;
        }
        char *filename = malloc(strlen(path) + strlen(file) + 2);
        if (!filename) {
            rz_list_free(dir);
            return;
        }
        strcpy(filename, path);
        strcat(filename, file);
        if (rz_file_is_directory(filename)) {
            strcat(filename, RZ_SYS_DIR);
            recursive_search_glob(filename, glob, list, depth - 1);
            free(filename);
        } else if (rz_str_glob(file, glob)) {
            rz_list_append(list, filename);
        } else {
            free(filename);
        }
    }
    rz_list_free(dir);
}

References file, free(), list(), malloc(), path, rz_file_is_directory(), rz_list_append(), rz_list_free(), rz_str_glob(), RZ_SYS_DIR, and rz_sys_dir().

Referenced by rz_file_globsearch().

rz_file_abspath()

RZ_API char* rz_file_abspath

(

const char *

file

)

Definition at line 267 of file file.c.

                                               {
    rz_return_val_if_fail(file, NULL);
    char *cwd = rz_sys_getdir();
    if (cwd) {
        char *ret = rz_file_abspath_rel(cwd, file);
        free(cwd);
        return ret;
    }
    return NULL;
}

References test-lz4-speed::cwd, free(), NULL, rz_file_abspath_rel(), rz_return_val_if_fail, and rz_sys_getdir().

Referenced by file_save(), get_file_in_cur_dir(), getcommapath(), prj_dir_abs(), rz_cons_hud_path(), rz_core_cmd_file(), rz_core_file_open(), rz_core_file_print(), rz_core_file_reopen_debug(), rz_core_raw_file_print(), rz_core_rtr_http_run(), rz_core_run_script(), rz_debug_get_baddr(), rz_file_exists(), rz_file_path(), rz_lang_prompt(), rz_main_rizin(), and rz_test_chdir_fromtest().

rz_file_abspath_rel()

RZ_API char* rz_file_abspath_rel	(	const char *	cwd,
		const char *	file
	)

Definition at line 219 of file file.c.

                                                                    {
    char *ret = NULL;
    if (RZ_STR_ISEMPTY(file) || !strcmp(file, ".") || !strcmp(file, "./")) {
        return strdup(cwd);
    }
    if (strstr(file, "://")) {
        return strdup(file);
    }
    ret = rz_path_home_expand(file);
#if __UNIX__
    if (cwd && *ret != '/') {
        char *tmp = rz_str_newf("%s" RZ_SYS_DIR "%s", cwd, ret);
        if (!tmp) {
            free(ret);
            return NULL;
        }
        free(ret);
        ret = tmp;
    }
#elif __WINDOWS__
    // Network path
    if (!strncmp(ret, "\\\\", 2)) {
        return strdup(ret);
    }
    if (!strchr(ret, ':')) {
        char *tmp = rz_str_newf("%s" RZ_SYS_DIR "%s", cwd, ret);
        if (!tmp) {
            free(ret);
            return NULL;
        }
        free(ret);
        ret = tmp;
    }
#endif
#if HAVE_REALPATH
    char rp[PATH_MAX] = { 0 };
    char *abspath = realpath(ret, rp); // second arg == NULL is only an extension
    if (abspath) {
        abspath = strdup(abspath);
        if (abspath) {
            free(ret);
            ret = abspath;
        }
    }
#endif
    return ret;
}

References test-lz4-speed::cwd, free(), NULL, rp, rz_path_home_expand(), RZ_STR_ISEMPTY, rz_str_newf(), RZ_SYS_DIR, strdup(), and autogen_x86imm::tmp.

Referenced by prj_relative_restore(), rz_file_abspath(), and rz_test_main().

rz_file_basename()

RZ_API const char* rz_file_basename

(

const char *

path

)

Definition at line 83 of file file.c.

                                                      {
    rz_return_val_if_fail(path, NULL);
    const char *ptr = rz_str_rchr(path, NULL, '/');
    if (ptr) {
        path = ptr + 1;
    }
#if __WINDOWS__
    if ((ptr = rz_str_rchr(path, NULL, '\\'))) {
        path = ptr + 1;
    }
#endif
    return path;
}

References NULL, path, rz_return_val_if_fail, and rz_str_rchr().

Referenced by add_library(), addroflib(), autocmplt_cmd_arg_file(), cb_binprefix(), extract_binobj(), get_file_in_cur_dir(), MAIN_NAME(), prompt_add_file(), rz_cmd_debug_dmi(), rz_cmd_debug_dmS_handler(), rz_core_pdb_load_info(), rz_debug_dmp_init(), rz_lib_open(), and sigdb_signature_resolve_details().

rz_file_binsh()

RZ_API char* rz_file_binsh

(

void

)

Definition at line 393 of file file.c.

                                 {
    char *bin_sh = rz_sys_getenv("SHELL");
    if (RZ_STR_ISNOTEMPTY(bin_sh)) {
        return bin_sh;
    }
    free(bin_sh);
    bin_sh = rz_file_path("sh");
    if (RZ_STR_ISNOTEMPTY(bin_sh)) {
        return bin_sh;
    }
    free(bin_sh);
    bin_sh = strdup("/bin/sh");
    return bin_sh;
}

References free(), rz_file_path(), RZ_STR_ISNOTEMPTY, rz_sys_getenv(), and strdup().

Referenced by rz_run_start(), and rz_sys_cmdbg().

rz_file_copy()

RZ_API bool rz_file_copy	(	const char *	src,
		const char *	dst
	)

Definition at line 1179 of file file.c.

                                                           {
    /* TODO: implement in C */
    /* TODO: Use NO_CACHE for iOS dyldcache copying */
#if HAVE_COPYFILE
    return copyfile(src, dst, 0, COPYFILE_DATA | COPYFILE_XATTR) != -1;
#elif HAVE_COPY_FILE_RANGE
    int srcfd = open(src, O_RDONLY);
    if (srcfd == -1) {
        RZ_LOG_ERROR("rz_file_copy: Failed to open %s\n", src);
        return false;
    }
    int mask = (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
    int dstfd = open(dst, O_WRONLY | O_CREAT | O_TRUNC, mask);
    if (dstfd == -1) {
        RZ_LOG_ERROR("rz_file_copy: Failed to open %s\n", dst);
        close(srcfd);
        return false;
    }
    /* copy_file_path can handle large file up to SSIZE_MAX
     * with optimised performances.
     */
    off_t sz = lseek(srcfd, 0, SEEK_END);
    lseek(srcfd, 0, SEEK_SET);
    ssize_t ret = copy_file_range(srcfd, 0, dstfd, 0, SSIZE_MAX, 0);
    close(dstfd);
    close(srcfd);
    return ret == sz;
#elif __WINDOWS__
    PWCHAR s = rz_utf8_to_utf16(src);
    PWCHAR d = rz_utf8_to_utf16(dst);
    if (!s || !d) {
        RZ_LOG_ERROR("rz_file_copy: Failed to allocate memory\n");
        free(s);
        free(d);
        return false;
    }
    bool ret = CopyFileW(s, d, 0);
    if (!ret) {
        rz_sys_perror("rz_file_copy");
    }
    free(s);
    free(d);
    return ret;
#else
    char *src2 = rz_str_replace(strdup(src), "'", "\\'", 1);
    char *dst2 = rz_str_replace(strdup(dst), "'", "\\'", 1);
    int rc = rz_sys_cmdf("cp -f '%s' '%s'", src2, dst2);
    free(src2);
    free(dst2);
    return rc == 0;
#endif
}

References close, d, dst, free(), lseek, mask, O_CREAT, O_RDONLY, O_TRUNC, O_WRONLY, RZ_LOG_ERROR, rz_str_replace(), rz_sys_cmdf(), rz_sys_perror, s, SEEK_END, SEEK_SET, src, SSIZE_MAX, and strdup().

Referenced by rz_cmd_shell_cp_handler().

rz_file_deflate()

RZ_API bool rz_file_deflate	(	RZ_NONNULL const char *	src,
		RZ_NONNULL const char *	dst
	)

zip the contents of src and store in dst

Parameters

src	source file (string containing filename)
dst	destination file (string containing filename)

Returns

true, if successful; false otherwise

Definition at line 1329 of file file.c.

                                                                                    {
    rz_return_val_if_fail(src && dst, false);
 
    bool ret = false;
 
    RzBuffer *src_buf = rz_buf_new_file(src, O_RDONLY, 0);
    RzBuffer *dst_buf = rz_buf_new_file(dst, O_WRONLY | O_CREAT, 0644);
 
    if (!(src_buf && dst_buf)) {
        goto return_goto;
    }
 
    ut64 block_size = 1 << 18; // 256 KB
 
    if (!rz_deflate_buf(src_buf, dst_buf, block_size, NULL)) {
        goto return_goto;
    }
 
    ret = true;
 
return_goto:
    rz_buf_free(src_buf);
    rz_buf_free(dst_buf);
    return ret;
}

References dst, NULL, O_CREAT, O_RDONLY, O_WRONLY, rz_buf_free(), rz_buf_new_file(), rz_deflate_buf(), rz_return_val_if_fail, src, and ut64().

Referenced by rz_project_save_file().

rz_file_dirname()

RZ_API char* rz_file_dirname

(

const char *

path

)

Definition at line 120 of file file.c.

                                               {
    rz_return_val_if_fail(path, NULL);
    char *newpath = strdup(path);
    char *ptr = (char *)rz_str_rchr(newpath, NULL, '/');
    if (ptr) {
        if (ptr == newpath) {
            ptr++;
        }
        *ptr = 0;
    } else {
        ptr = (char *)rz_str_rchr(newpath, NULL, '\\');
        if (!ptr) {
            ptr = newpath;
        }
        if (ptr && ptr == newpath && *ptr == '.') { // keep '.'
            ptr++;
            if (*ptr == '.') { // keep '..'
                ptr++;
            }
        }
        if (ptr) {
            *ptr = 0;
        }
    }
    return newpath;
}

References NULL, path, rz_return_val_if_fail, rz_str_rchr(), and strdup().

Referenced by autocmplt_cmd_arg_file(), download(), prj_dir_abs(), rz_core_bin_pdb_get_filename(), and sdb_disk_create().

rz_file_dos_basename()

RZ_API const char* rz_file_dos_basename

(

RZ_BORROW RZ_NONNULL const char *

path

)

Definition at line 102 of file file.c.

                                                                               {
    rz_return_val_if_fail(path, NULL);
    const char *ptr = rz_str_rchr(path, NULL, '/');
    if (ptr) {
        path = ptr + 1;
    }
    if ((ptr = rz_str_rchr(path, NULL, '\\'))) {
        path = ptr + 1;
    }
    return path;
}

References NULL, path, rz_return_val_if_fail, and rz_str_rchr().

Referenced by rz_bin_pdb_download(), rz_core_bin_pdb_get_filename(), rz_debug_dmp_maps(), rz_debug_dmp_modules(), and rz_debug_winkd_maps().

rz_file_dump()

RZ_API bool rz_file_dump	(	const char *	file,
		const ut8 *	buf,
		int	len,
		bool	append
	)

Definition at line 838 of file file.c.

                                                                                 {
    rz_return_val_if_fail(!RZ_STR_ISEMPTY(file), false);
    FILE *fd;
    if (append) {
        fd = rz_sys_fopen(file, "ab");
    } else {
        rz_sys_truncate(file, 0);
        fd = rz_sys_fopen(file, "wb");
    }
    if (!fd) {
        eprintf("Cannot open '%s' for writing\n", file);
        return false;
    }
    if (buf) {
        if (len < 0) {
            len = strlen((const char *)buf);
        }
        if (len > 0 && fwrite(buf, len, 1, fd) != 1) {
            rz_sys_perror("rz_file_dump: fwrite: error\n");
            fclose(fd);
            return false;
        }
    }
    fclose(fd);
    return true;
}

References append, eprintf, fd, benchmark::FILE, len, rz_return_val_if_fail, RZ_STR_ISEMPTY, rz_sys_fopen(), rz_sys_perror, and rz_sys_truncate().

Referenced by __dumpSections(), convert_dot_str_to_image(), dump_maps(), extract_binobj(), http_logf(), rz_buf_dump(), rz_core_rtr_http_run(), rz_egg_Cfile_parseCompiled(), rz_egg_Cfile_parser(), rz_file_touch(), rz_main_rizin(), rz_main_rz_bin(), rz_reopen_debug_rzrun_handler(), rz_run_start(), rz_test_main(), save_test_file_for_fix(), set_profile_string(), and visual_comma().

rz_file_exists()

RZ_API bool rz_file_exists

(

const char *

str

)

Definition at line 192 of file file.c.

                                            {
    rz_return_val_if_fail(!RZ_STR_ISEMPTY(str), false);
    char *absfile = rz_file_abspath(str);
    StructStat buf = { 0 };
 
    if (file_stat(absfile, &buf) == -1) {
        free(absfile);
        return false;
    }
    free(absfile);
    return S_IFREG == (S_IFREG & buf.st_mode);
}

References file_stat(), free(), rz_file_abspath(), rz_return_val_if_fail, RZ_STR_ISEMPTY, cmd_descs_generate::str, and StructStat.

Referenced by __func_name_from_ord(), bin_pe_parse_imports(), database_load(), download(), download_and_write(), find_include(), get_file_in_cur_dir(), get_main_arena_with_symbol(), GetHeapGlobalsOffset(), lang_lib_file_run(), load_sdb(), load_theme(), run_commands(), rz_analysis_function_cc_load_handler(), rz_bin_pdb_extract_in_folder(), rz_cmd_debug_dmi(), rz_cmd_info_pdb_load_handler(), rz_cmd_info_pdb_show_handler(), rz_cmd_kuery(), rz_core_analysis_cc_init(), rz_core_bin_apply_config(), rz_core_bin_pdb_get_filename(), rz_core_cmd_str_pipe(), rz_core_config_init(), rz_core_file_reopen_debug(), rz_core_io_file_open(), rz_core_rtr_http_run(), rz_core_visual_hud(), rz_egg_Cfile_parser(), rz_file_fexists(), rz_file_path(), rz_file_slurp(), rz_file_truncate(), rz_lib_path(), rz_main_rizin(), rz_platform_load_profile_sdb(), rz_platform_target_index_load_sdb(), rz_project_load_file_raw(), rz_resolve_jemalloc(), rz_run_start(), rz_sysreg_load_sdb(), rz_test_test_database_load_fuzz(), rz_type_db_load_callables_sdb(), rz_type_db_load_sdb(), rz_types_open_file(), rz_write_hex_from_file_handler(), and set_bin_relocs().

rz_file_fexists()

RZ_API bool rz_file_fexists	(	const char *	fmt,
			...
	)

Definition at line 181 of file file.c.

                                                  {
    int ret;
    char string[BS];
    va_list ap;
    va_start(ap, fmt);
    vsnprintf(string, sizeof(string), fmt, ap);
    ret = rz_file_exists(string);
    va_end(ap);
    return ret;
}

References BS, rz_file_exists(), and vsnprintf.

rz_file_globsearch()

RZ_API RzList* rz_file_globsearch	(	const char *	_globbed_path,
		int	maxdepth
	)

Definition at line 1263 of file file.c.

                                                                           {
    char *globbed_path = strdup(_globbed_path);
    RzList *files = rz_list_newf(free);
    char *glob = strchr(globbed_path, '*');
    if (!glob) {
        rz_list_append(files, strdup(globbed_path));
    } else {
        *glob = '\0';
        char *last_slash = (char *)rz_str_last(globbed_path, RZ_SYS_DIR);
        *glob = '*';
        char *path, *glob_ptr;
        if (last_slash) {
            glob_ptr = last_slash + 1;
            if (globbed_path[0] == '~') {
                char *rpath = rz_str_newlen(globbed_path + 2, last_slash - globbed_path - 1);
                path = rz_str_home(rpath ? rpath : "");
                free(rpath);
            } else {
                path = rz_str_newlen(globbed_path, last_slash - globbed_path + 1);
            }
        } else {
            glob_ptr = globbed_path;
            path = rz_str_newf(".%s", RZ_SYS_DIR);
        }
 
        if (!path) {
            rz_list_free(files);
            free(globbed_path);
            return NULL;
        }
 
        if (*(glob + 1) == '*') { // "**"
            recursive_search_glob(path, glob_ptr, files, maxdepth);
        } else { // "*"
            recursive_search_glob(path, glob_ptr, files, 1);
        }
        free(path);
    }
    free(globbed_path);
    return files;
}

References files, free(), NULL, path, recursive_search_glob(), rz_list_append(), rz_list_free(), rz_list_newf(), rz_str_home(), rz_str_last(), rz_str_newf(), rz_str_newlen(), RZ_SYS_DIR, and strdup().

Referenced by rz_flirt_scan_handler(), and rz_sign_sigdb_load_database().

rz_file_gzslurp()

RZ_API ut8* rz_file_gzslurp	(	const char *	str,
		int *	outlen,
		int	origonfail
	)

Definition at line 529 of file file.c.

                                                                          {
    rz_return_val_if_fail(str, NULL);
    if (outlen) {
        *outlen = 0;
    }
    size_t sz;
    ut8 *in = (ut8 *)rz_file_slurp(str, &sz);
    if (!in) {
        return NULL;
    }
    ut8 *out = rz_inflate(in, (int)sz, NULL, outlen);
    if (!out && origonfail) {
        // if uncompression fails, return orig buffer ?
        if (outlen) {
            *outlen = (int)sz;
        }
        in[sz] = 0;
        return in;
    }
    free(in);
    return out;
}

References free(), in, int, NULL, out, rz_file_slurp(), rz_inflate(), rz_return_val_if_fail, and cmd_descs_generate::str.

rz_file_hexdump()

RZ_API bool rz_file_hexdump	(	const char *	file,
		const ut8 *	buf,
		int	len,
		int	append
	)

Definition at line 794 of file file.c.

                                                                                   {
    FILE *fd;
    int i, j;
    if (!file || !*file || !buf || len < 0) {
        eprintf("rz_file_hexdump file: %s buf: %p\n", file, buf);
        return false;
    }
    if (append) {
        fd = rz_sys_fopen(file, "ab");
    } else {
        rz_sys_truncate(file, 0);
        fd = rz_sys_fopen(file, "wb");
    }
    if (!fd) {
        eprintf("Cannot open '%s' for writing\n", file);
        return false;
    }
    for (i = 0; i < len; i += 16) {
        int l = RZ_MIN(16, len - i);
        fprintf(fd, "0x%08" PFMT64x "  ", (ut64)i);
        for (j = 0; j + 2 <= l; j += 2) {
            fprintf(fd, "%02x%02x ", buf[i + j], buf[i + j + 1]);
        }
        if (j < l) {
            fprintf(fd, "%02x   ", buf[i + j]);
            j += 2;
        }
        if (j < 16) {
            fprintf(fd, "%*s ", (16 - j) / 2 * 5, "");
        }
        for (j = 0; j < 16; j++) {
            fprintf(fd, "%c", j < l && IS_PRINTABLE(buf[i + j]) ? buf[i + j] : '.');
        }
        fprintf(fd, "\n");
    }
    fclose(fd);
    return true;
}

References append, eprintf, fd, benchmark::FILE, i, IS_PRINTABLE, len, PFMT64x, RZ_MIN, rz_sys_fopen(), rz_sys_truncate(), and ut64().

rz_file_inflate()

RZ_API bool rz_file_inflate	(	RZ_NONNULL const char *	src,
		RZ_NONNULL const char *	dst
	)

unzip the contents of src and store in dst

Parameters

src	source file (string containing filename)
dst	destination file (string containing filename)

Returns

true, if successful; false otherwise

Definition at line 1361 of file file.c.

                                                                                    {
    rz_return_val_if_fail(src && dst, false);
 
    bool ret = false;
 
    RzBuffer *src_buf = rz_buf_new_file(src, O_RDONLY, 0);
    RzBuffer *dst_buf = rz_buf_new_file(dst, O_WRONLY | O_CREAT, 0644);
 
    if (!(src_buf && dst_buf)) {
        goto return_goto;
    }
 
    ut64 block_size = 1 << 13; // 8 KB
 
    if (!rz_inflate_buf(src_buf, dst_buf, block_size, NULL)) {
        goto return_goto;
    }
 
    ret = true;
 
return_goto:
    rz_buf_free(src_buf);
    rz_buf_free(dst_buf);
    return ret;
}

References dst, NULL, O_CREAT, O_RDONLY, O_WRONLY, rz_buf_free(), rz_buf_new_file(), rz_inflate_buf(), rz_return_val_if_fail, src, and ut64().

Referenced by rz_project_load_file_raw().

rz_file_is_abspath()

RZ_API bool rz_file_is_abspath

(

const char *

file

)

Definition at line 214 of file file.c.

                                                 {
    rz_return_val_if_fail(!RZ_STR_ISEMPTY(file), 0);
    return ((*file && file[1] == ':') || *file == '/');
}

References rz_return_val_if_fail, and RZ_STR_ISEMPTY.

Referenced by autocmplt_cmd_arg_file(), and rz_test_main().

rz_file_is_c()

RZ_API bool rz_file_is_c

(

const char *

file

)

Definition at line 147 of file file.c.

                                           {
    rz_return_val_if_fail(file, false);
    const char *ext = rz_str_lchr(file, '.'); // TODO: add api in rz_file_extension or rz_str_ext for this
    if (ext) {
        ext++;
        if (!strcmp(ext, "cparse") || !strcmp(ext, "c") || !strcmp(ext, "h")) {
            return true;
        }
    }
    return false;
}

References ext, rz_return_val_if_fail, and rz_str_lchr().

Referenced by rz_core_run_script().

rz_file_is_deflated()

RZ_API bool rz_file_is_deflated

(

RZ_NONNULL const char *

src

)

check whether a file is a deflated (gzip) file

Parameters

src	source file (string containing filename)

Returns

true, if src is a deflated (gzip) file; false otherwise

Definition at line 1392 of file file.c.

                                                            {
    rz_return_val_if_fail(src, false);
 
    bool ret = false;
    unsigned char *header = (unsigned char *)rz_file_slurp_range(src, 0, 3, NULL);
 
    if (!header || rz_str_nlen((char *)header, 3) != 3) {
        goto return_goto;
    }
 
    ret = (header[0] == 0x1f && header[1] == 0x8b && header[2] == 0x08); // 1f 8b 08
 
return_goto:
    free(header);
    return ret;
}

References free(), header, NULL, rz_file_slurp_range(), rz_return_val_if_fail, rz_str_nlen(), and src.

Referenced by rz_project_load_file_raw().

rz_file_is_directory()

RZ_API bool rz_file_is_directory

(

const char *

str

)

Definition at line 167 of file file.c.

                                                  {
    StructStat buf = { 0 };
    rz_return_val_if_fail(!RZ_STR_ISEMPTY(str), false);
    if (file_stat(str, &buf) == -1) {
        return false;
    }
#ifdef S_IFBLK
    if ((S_IFBLK & buf.st_mode) == S_IFBLK) {
        return false;
    }
#endif
    return S_IFDIR == (S_IFDIR & buf.st_mode);
}

References file_stat(), rz_return_val_if_fail, RZ_STR_ISEMPTY, cmd_descs_generate::str, and StructStat.

Referenced by analysis_sigdb_add(), autocmplt_cmd_arg_file(), autocomplete_process_path(), database_load(), get_file_in_cur_dir(), hash_parse_cmdline(), linux_thread_list(), recursive_search_glob(), rz_bin_pdb_extract_in_folder(), rz_cons_hud_path(), rz_core_parse_rizinrc(), rz_core_rtr_http_run(), rz_diff_is_file(), rz_file_rm(), rz_file_tmpdir(), rz_file_truncate(), rz_main_rizin(), rz_main_rz_find(), rz_sign_sigdb_load_database(), rz_syscmd_ls(), rz_test_chdir(), rz_test_chdir_fromtest(), rz_test_test_database_load_fuzz(), rzfind_open(), session_sdb_save(), and showfile().

rz_file_is_regular()

RZ_API bool rz_file_is_regular

(

const char *

str

)

Definition at line 159 of file file.c.

                                                {
    StructStat buf = { 0 };
    if (!str || !*str || file_stat(str, &buf) == -1) {
        return false;
    }
    return ((S_IFREG & buf.st_mode) == S_IFREG);
}

References file_stat(), cmd_descs_generate::str, and StructStat.

Referenced by rz_core_parse_rizinrc(), rz_file_slurp(), rz_file_truncate(), rz_sys_fopen(), rz_syscmd_ls(), and try_load_file().

rz_file_mkstemp()

RZ_API int rz_file_mkstemp	(	RZ_NULLABLE const char *	prefix,
		char **	oname
	)

Definition at line 1058 of file file.c.

                                                                         {
    int h = -1;
    char *path = rz_file_tmpdir();
    if (!prefix) {
        prefix = "rz";
    }
#if __WINDOWS__
    LPWSTR wname = malloc(sizeof(WCHAR) * (MAX_PATH + 1));
    LPWSTR wpath = rz_utf8_to_utf16(path);
    LPWSTR wprefix = prefix ? rz_utf8_to_utf16(prefix) : _wcsdup(L"");
 
    if (!(wname && wpath && wprefix)) {
        goto err_r_file_mkstemp;
    }
 
    if (GetTempFileNameW(wpath, wprefix, 0, wname)) {
        char *name = rz_utf16_to_utf8(wname);
        h = rz_sys_open(name, O_RDWR | O_EXCL | O_BINARY, 0644);
        if (oname) {
            if (h != -1) {
                *oname = name;
            } else {
                *oname = NULL;
                free(name);
            }
        } else {
            free(name);
        }
    }
err_r_file_mkstemp:
    free(wname);
    free(wpath);
    free(wprefix);
#else
    char pfxx[1024];
    const char *suffix = strchr(prefix, '*');
 
    if (suffix) {
        suffix++;
        rz_str_ncpy(pfxx, prefix, (size_t)(suffix - prefix));
        prefix = pfxx;
    } else {
        suffix = "";
    }
 
    char *name = rz_str_newf("%s/rz.%s.XXXXXX%s", path, prefix, suffix);
    mode_t mask = umask(S_IWGRP | S_IWOTH);
    if (suffix && *suffix) {
#if defined(__GLIBC__) && defined(__GLIBC_MINOR__) && 2 <= __GLIBC__ && 19 <= __GLIBC__MINOR__
        h = mkstemps(name, strlen(suffix));
#else
        char *const xpos = strrchr(name, 'X');
        const char c = (char)(NULL != xpos ? *(xpos + 1) : 0);
        if (0 != c) {
            xpos[1] = 0;
            h = mkstemp(name);
            xpos[1] = c;
        } else {
            h = -1;
        }
#endif
    } else {
        h = mkstemp(name);
    }
    umask(mask);
    if (oname) {
        *oname = (h != -1) ? strdup(name) : NULL;
    }
    free(name);
#endif
    free(path);
    return h;
}

References c, free(), h, L, LPWSTR, malloc(), mask, name, NULL, O_BINARY, O_EXCL, O_RDWR, path, prefix, rz_file_tmpdir(), rz_str_ncpy(), rz_str_newf(), rz_sys_open(), strdup(), suffix, and umask.

Referenced by assemble(), binutils_assemble(), config_path(), interact_commands(), rz_core_cmd_str_pipe(), rz_core_editor(), rz_core_sysenv_begin(), rz_project_load_file_raw(), and rz_project_save_file().

rz_file_mmap()

RZ_API RzMmap* rz_file_mmap	(	const char *	file,
		int	perm,
		int	mode,
		ut64	base
	)

Definition at line 972 of file file.c.

                                                                             {
    RzMmap *m = NULL;
    m = RZ_NEW0(RzMmap);
    if (!m) {
        return NULL;
    }
    m->base = base;
    m->perm = perm;
    m->len = 0;
    m->filename = strdup(file);
    m->mode = mode;
    if (!m->filename) {
        rz_file_mmap_free(m);
        return NULL;
    }
    m->fd = rz_sys_open(m->filename, m->perm, m->mode);
    if (m->fd == -1) {
        rz_file_mmap_free(m);
        return NULL;
    }
    return file_mmap(m);
}

References file_mmap(), regress::m, NULL, rz_file_mmap_free(), RZ_NEW0, rz_sys_open(), and strdup().

Referenced by buf_mmap_init().

rz_file_mmap_free()

RZ_API void rz_file_mmap_free

(

RzMmap *

m

)

Definition at line 995 of file file.c.

                                         {
    if (!m) {
        return;
    }
#if __WINDOWS__
    if (m->buf) {
        UnmapViewOfFile(m->buf);
    }
    if (m->fm) {
        CloseHandle(m->fm);
    }
    if (m->fd != -1) {
        _close(m->fd);
    }
#elif __UNIX__
    munmap(m->buf, m->len);
    close(m->fd);
#endif
    free(m->filename);
    free(m);
}

References close, free(), regress::m, and munmap.

Referenced by buf_mmap_fini(), file_mmap(), rz_file_mmap(), and rz_file_mmap_resize().

rz_file_mmap_resize()

RZ_API void* rz_file_mmap_resize	(	RzMmap *	m,
		ut64	newsize
	)

Definition at line 1017 of file file.c.

                                                          {
#if __WINDOWS__
    if (m->buf) {
        UnmapViewOfFile(m->buf);
    }
    if (m->fm) {
        CloseHandle(m->fm);
    }
    if (m->fd != -1) {
        _close(m->fd);
    }
#elif __UNIX__
    if (m->buf && munmap(m->buf, m->len) != 0) {
        return NULL;
    }
#endif
    if (!rz_sys_truncate(m->filename, newsize)) {
        return NULL;
    }
    m->fd = rz_sys_open(m->filename, m->perm, m->mode);
    if (m->fd == -1) {
        rz_file_mmap_free(m);
        return NULL;
    }
    // In case of mmap failure it frees the RzMmap and return NULL
    if (!file_mmap(m)) {
        return NULL;
    }
    return m->buf;
}

References file_mmap(), regress::m, munmap, NULL, rz_file_mmap_free(), rz_sys_open(), and rz_sys_truncate().

Referenced by buf_mmap_resize().

rz_file_path()

RZ_API char* rz_file_path

(

const char *

bin

)

Definition at line 354 of file file.c.

                                           {
    rz_return_val_if_fail(bin, NULL);
    char *file = NULL;
    char *path = NULL;
    char *str, *ptr;
    const char *extension = "";
    if (!strncmp(bin, "./", 2)) {
        return rz_file_exists(bin)
            ? rz_file_abspath(bin)
            : NULL;
    }
    char *path_env = (char *)rz_sys_getenv("PATH");
#if __WINDOWS__
    if (!rz_str_endswith(bin, ".exe")) {
        extension = ".exe";
    }
#endif
    if (path_env) {
        str = path = strdup(path_env);
        do {
            ptr = strchr(str, RZ_SYS_ENVSEP[0]);
            if (ptr) {
                *ptr = '\0';
                file = rz_str_newf(RZ_JOIN_2_PATHS("%s", "%s%s"), str, bin, extension);
                if (rz_file_exists(file)) {
                    free(path);
                    free(path_env);
                    return file;
                }
                str = ptr + 1;
                free(file);
            }
        } while (ptr);
    }
    free(path_env);
    free(path);
    return strdup(bin);
}

References file, free(), NULL, path, rz_file_abspath(), rz_file_exists(), RZ_JOIN_2_PATHS, rz_return_val_if_fail, rz_str_endswith(), rz_str_newf(), RZ_SYS_ENVSEP, rz_sys_getenv(), cmd_descs_generate::str, and strdup().

Referenced by dot_executable_path(), getViewerPath(), rz_cmd_shell_which_handler(), rz_core_run_script(), rz_egg_Cfile_getCompiler(), rz_file_binsh(), rz_main_rizin(), rz_run_start(), rz_test_chdir(), and rz_test_main().

rz_file_path_join()

RZ_API RZ_OWN char* rz_file_path_join	(	RZ_NONNULL const char *	s1,
		RZ_NULLABLE const char *	s2
	)

Concatenate two paths to create a new one with s1+s2 with the correct path separator.

Parameters

s1	First path
s2	Second path, can be NULL

Returns

Full path

Definition at line 1312 of file file.c.

                                                                                             {
    rz_return_val_if_fail(s1, NULL);
 
    if (!s2) {
        return strdup(s1);
    }
    bool ends_with_dir = s1[strlen(s1) - 1] == RZ_SYS_DIR[0];
    const char *sep = ends_with_dir ? "" : RZ_SYS_DIR;
    return rz_str_newf("%s%s%s", s1, sep, s2);
}

References NULL, rz_return_val_if_fail, rz_str_newf(), RZ_SYS_DIR, s1, s2, and strdup().

Referenced by __get_panels_config_dir_path(), autocmplt_cmd_arg_file(), cmd_print_format(), load_scripts_for(), load_sdb(), main_help(), rizin_fortune_file(), rz_core_analysis_cc_init(), rz_core_bin_apply_config(), rz_core_init(), rz_core_theme_load(), rz_core_visual_hud(), rz_path_home(), rz_path_prefix(), rz_platform_profiles_init(), rz_platform_target_index_init(), rz_run_config_env(), rz_sysreg_set_arch(), rz_type_db_init(), and rzfind_open_dir().

rz_file_path_local_to_unix()

RZ_API char* rz_file_path_local_to_unix

(

const char *

path

)

Definition at line 332 of file file.c.

                                                          {
    char *r = strdup(path);
    if (!r) {
        return NULL;
    }
#if __WINDOWS__
    rz_str_replace(r, RZ_SYS_DIR, "/", true);
#endif
    return r;
}

References NULL, path, r, rz_str_replace(), RZ_SYS_DIR, and strdup().

Referenced by prj_relative_make().

rz_file_path_unix_to_local()

RZ_API char* rz_file_path_unix_to_local

(

const char *

path

)

Definition at line 343 of file file.c.

                                                          {
    char *r = strdup(path);
    if (!r) {
        return NULL;
    }
#if __WINDOWS__
    rz_str_replace(r, "/", RZ_SYS_DIR, true);
#endif
    return r;
}

References NULL, path, r, rz_str_replace(), RZ_SYS_DIR, and strdup().

Referenced by prj_relative_restore().

rz_file_readlink()

RZ_API char* rz_file_readlink

(

const char *

path

)

Definition at line 892 of file file.c.

                                                {
    rz_return_val_if_fail(!RZ_STR_ISEMPTY(path), false);
#if __UNIX__
    int ret;
    char pathbuf[4096] = { 0 };
    strncpy(pathbuf, path, sizeof(pathbuf) - 1);
repeat:
    ret = readlink(path, pathbuf, sizeof(pathbuf) - 1);
    if (ret != -1) {
        pathbuf[ret] = 0;
        path = pathbuf;
        goto repeat;
    }
    return strdup(pathbuf);
#endif
    return NULL;
}

References NULL, path, readlink, repeat(), rz_return_val_if_fail, RZ_STR_ISEMPTY, and strdup().

rz_file_relpath()

RZ_API char* rz_file_relpath	(	const char *	base,
		const char *	path
	)

Definition at line 278 of file file.c.

                                                                 {
    // skip longest common prefix
    while (*base && *path) {
        while (*base == *RZ_SYS_DIR) {
            base++;
        }
        while (*path == *RZ_SYS_DIR) {
            path++;
        }
        while (*base && *path && *base != *RZ_SYS_DIR && *path != *RZ_SYS_DIR) {
            if (*base != *path) {
                goto diverge;
            }
            base++;
            path++;
        }
    }
    while (*path == *RZ_SYS_DIR) {
        path++;
    }
 
    size_t ups;
diverge:
    // count number of ".." needed which is just the number of remaining tokens in base
    ups = 0;
    while (*base) {
        while (*base == *RZ_SYS_DIR) {
            base++;
        }
        if (!*base) {
            break;
        }
        ups++;
        while (*base && *base != *RZ_SYS_DIR) {
            base++;
        }
    }
 
    // put all the ".."s and append the rest of the path
    size_t suff_len = strlen(path);
    char *r = malloc(ups * 3 + suff_len + 1); // ups * strlen("../") + strlen(path)
    if (!r) {
        return NULL;
    }
    size_t i;
    for (i = 0; i < ups; i++) {
        r[i * 3] = '.';
        r[i * 3 + 1] = '.';
        r[i * 3 + 2] = *RZ_SYS_DIR;
    }
    memcpy(r + i * 3, path, suff_len + 1);
    return r;
}

References i, malloc(), memcpy(), NULL, path, r, and RZ_SYS_DIR.

Referenced by prj_relative_make().

rz_file_rm()

RZ_API bool rz_file_rm

(

const char *

file

)

Definition at line 865 of file file.c.

                                         {
    if (RZ_STR_ISEMPTY(file)) {
        return false;
    }
    if (rz_file_is_directory(file)) {
#if __WINDOWS__
        LPWSTR wfile = rz_utf8_to_utf16(file);
        bool ret = RemoveDirectoryW(wfile);
 
        free(wfile);
        return !ret;
#else
        return !rmdir(file);
#endif
    } else {
#if __WINDOWS__
        LPWSTR wfile = rz_utf8_to_utf16(file);
        bool ret = DeleteFileW(wfile);
 
        free(wfile);
        return !ret;
#else
        return !unlink(file);
#endif
    }
}

References free(), LPWSTR, rmdir, rz_file_is_directory(), RZ_STR_ISEMPTY, and unlink.

Referenced by __clear_layout_cb(), __rap_reg_profile(), download(), rz_cmd_debug(), rz_cmd_debug_dmi(), rz_cmd_shell_rm_handler(), rz_core_cmd_str_pipe(), rz_core_cmd_subst_i(), rz_core_editor(), rz_core_sysenv_end(), rz_egg_Cfile_parser(), rz_egg_load_file(), rz_project_load_file_raw(), rz_project_save_file(), and system_exec().

rz_file_root()

RZ_API char* rz_file_root	(	const char *	root,
		const char *	path
	)

Definition at line 775 of file file.c.

                                                              {
    rz_return_val_if_fail(root && path, NULL);
    char *ret, *s = rz_str_replace(strdup(path), "..", "", 1);
    // XXX ugly hack
    while (strstr(s, "..")) {
        s = rz_str_replace(s, "..", "", 1);
    }
    while (strstr(s, "./")) {
        s = rz_str_replace(s, "./", "", 1);
    }
    while (strstr(s, "//")) {
        s = rz_str_replace(s, "//", "", 1);
    }
    ret = rz_str_append(strdup(root), RZ_SYS_DIR);
    ret = rz_str_append(ret, s);
    free(s);
    return ret;
}

References free(), NULL, path, root, rz_return_val_if_fail, rz_str_append(), rz_str_replace(), RZ_SYS_DIR, s, and strdup().

Referenced by rz_core_rtr_http_run().

rz_file_size()

RZ_API ut64 rz_file_size

(

const char *

str

)

Definition at line 205 of file file.c.

                                          {
    rz_return_val_if_fail(!RZ_STR_ISEMPTY(str), 0);
    StructStat buf = { 0 };
    if (file_stat(str, &buf) == -1) {
        return 0;
    }
    return (ut64)buf.st_size;
}

References file_stat(), rz_return_val_if_fail, RZ_STR_ISEMPTY, cmd_descs_generate::str, StructStat, and ut64().

Referenced by rz_egg_Cfile_parser(), rz_type_parse_file(), rz_type_parse_file_stateless(), and showfile().

rz_file_slurp()

RZ_API RZ_OWN char* rz_file_slurp	(	const char *	str,
		RZ_NULLABLE size_t *	usz
	)

Definition at line 454 of file file.c.

                                                                            {
    rz_return_val_if_fail(str, NULL);
    if (usz) {
        *usz = 0;
    }
    if (!rz_file_exists(str)) {
        return NULL;
    }
    FILE *fd = rz_sys_fopen(str, "rb");
    if (!fd) {
        return NULL;
    }
    if (fseek(fd, 0, SEEK_END) == -1) {
        // cannot determine the size of the file
    }
    long sz = ftell(fd);
    if (sz < 0) {
        fclose(fd);
        return NULL;
    }
    if (!sz) {
        if (rz_file_is_regular(str)) {
            char *buf = NULL;
            long size = 0;
            (void)fseek(fd, 0, SEEK_SET);
            do {
                char *nbuf = realloc(buf, size + BS);
                if (!nbuf) {
                    break;
                }
                buf = nbuf;
                size_t r = fread(buf + size, 1, BS, fd);
                if (ferror(fd)) {
                    RZ_FREE(buf);
                    goto regular_err;
                }
                size += r;
            } while (!feof(fd));
            char *nbuf = realloc(buf, size + 1);
            if (!nbuf) {
                fclose(fd);
                free(buf);
                return NULL;
            }
            buf = nbuf;
            buf[size] = '\0';
            if (usz) {
                *usz = size;
            }
        regular_err:
            fclose(fd);
            return buf;
        }
        // try to read 64K
        sz = UT16_MAX;
    }
    rewind(fd);
    char *ret = (char *)malloc(sz + 1);
    if (!ret) {
        fclose(fd);
        return NULL;
    }
    size_t rsz = fread(ret, 1, sz, fd);
    if (rsz != sz) {
        eprintf("Warning: rz_file_slurp: fread: truncated read\n");
        sz = rsz;
    }
    fclose(fd);
    ret[sz] = '\0';
    if (usz) {
        *usz = sz;
    }
    return ret;
}

References BS, eprintf, fd, benchmark::FILE, free(), malloc(), NULL, r, realloc(), rz_file_exists(), rz_file_is_regular(), RZ_FREE, rz_return_val_if_fail, rz_sys_fopen(), SEEK_END, SEEK_SET, cmd_descs_generate::str, and UT16_MAX.

Referenced by __open(), __rap_reg_profile(), DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), getFileData(), getstr(), hash_parse_any(), interact_commands(), linux_info(), rcc_next(), read_test_file_for_fix(), rz_asm_pseudo_incbin(), rz_bin_fatmach0_new(), rz_bin_mz_new(), rz_bin_te_new(), rz_buf_new_slurp(), rz_cmd_debug_dml_handler(), rz_cmd_search(), rz_cons_hud_file(), rz_core_cmd_file(), rz_core_cmd_str_pipe(), rz_core_cmd_subst_i(), rz_core_editor(), rz_core_fortune_list(), rz_core_rtr_http_run(), rz_core_visual_cmd(), rz_debug_plugin_set_reg_profile(), rz_egg_Cfile_parseCompiled(), rz_egg_include(), rz_egg_load_file(), rz_file_gzslurp(), rz_file_slurp_line(), rz_file_slurp_lines(), rz_file_slurp_lines_from_bottom(), rz_file_slurp_random_line_count(), rz_lang_run_file(), rz_load_panels_layout(), rz_main_rizin(), rz_main_rz_agent(), rz_main_rz_asm(), rz_main_rz_find(), rz_main_rz_gg(), rz_reg_parse_gdb_profile(), rz_reg_set_profile(), rz_run_parsefile(), rz_str_version(), rz_syscmd_cat(), rz_syscmd_join(), rz_syscmd_sort(), rz_syscmd_uniq(), rz_test_load_asm_test_file(), rz_test_load_cmd_test_file(), rz_test_load_json_test_file(), rz_type_parse_file(), rz_type_parse_file_stateless(), rz_write_assembly_file_handler(), rz_write_from_file_handler(), rz_write_hex_from_file_handler(), rz_write_unified_patch_handler(), and visual_comma().

rz_file_slurp_hexpairs()

RZ_API ut8* rz_file_slurp_hexpairs	(	const char *	str,
		int *	usz
	)

Definition at line 552 of file file.c.

                                                              {
    rz_return_val_if_fail(str, NULL);
    if (usz) {
        *usz = 0;
    }
    ut8 *ret;
    long sz;
    int c, bytes = 0;
    FILE *fd = rz_sys_fopen(str, "rb");
    if (!fd) {
        return NULL;
    }
    (void)fseek(fd, 0, SEEK_END);
    sz = ftell(fd);
    (void)fseek(fd, 0, SEEK_SET);
    ret = (ut8 *)malloc((sz >> 1) + 1);
    if (!ret) {
        fclose(fd);
        return NULL;
    }
    for (;;) {
        if (fscanf(fd, " #%*[^\n]") == 1) {
            continue;
        }
        if (fscanf(fd, "%02x", &c) == 1) {
            ret[bytes++] = c;
            continue;
        }
        if (feof(fd)) {
            break;
        }
        free(ret);
        fclose(fd);
        return NULL;
    }
    ret[bytes] = '\0';
    fclose(fd);
    if (usz) {
        *usz = bytes;
    }
    return ret;
}

References bytes, c, fd, benchmark::FILE, free(), malloc(), NULL, rz_return_val_if_fail, rz_sys_fopen(), SEEK_END, SEEK_SET, and cmd_descs_generate::str.

rz_file_slurp_line()

RZ_API char* rz_file_slurp_line	(	const char *	file,
		int	line,
		int	context
	)

Definition at line 673 of file file.c.

                                                                         {
    rz_return_val_if_fail(file, NULL);
    int i, lines = 0;
    size_t sz;
    char *ptr = NULL, *str = rz_file_slurp(file, &sz);
    // TODO: Implement context
    if (str) {
        for (i = 0; str[i]; i++) {
            if (str[i] == '\n') {
                lines++;
            }
        }
        if (line > lines) {
            free(str);
            return NULL;
        }
        lines = line - 1;
        for (i = 0; str[i] && lines; i++) {
            if (str[i] == '\n') {
                lines--;
            }
        }
        ptr = str + i;
        for (i = 0; ptr[i]; i++) {
            if (ptr[i] == '\n') {
                ptr[i] = '\0';
                break;
            }
        }
        ptr = strdup(ptr);
        free(str);
    }
    return ptr;
}

References free(), i, setup::line, lines(), NULL, rz_file_slurp(), rz_return_val_if_fail, cmd_descs_generate::str, and strdup().

Referenced by core_analysis_graph_label(), rz_bin_addr2text(), and step_line().

rz_file_slurp_lines()

RZ_API char* rz_file_slurp_lines	(	const char *	file,
		int	line,
		int	count
	)

Definition at line 736 of file file.c.

                                                                        {
    rz_return_val_if_fail(file, NULL);
    int i, lines = 0;
    size_t sz;
    char *ptr = NULL, *str = rz_file_slurp(file, &sz);
    // TODO: Implement context
    if (str) {
        for (i = 0; str[i]; i++) {
            if (str[i] == '\n') {
                lines++;
            }
        }
        if (line > lines) {
            free(str);
            return NULL;
        }
        lines = line - 1;
        for (i = 0; str[i] && lines; i++) {
            if (str[i] == '\n') {
                lines--;
            }
        }
        ptr = str + i;
        for (i = 0; ptr[i]; i++) {
            if (ptr[i] == '\n') {
                if (count) {
                    count--;
                } else {
                    ptr[i] = '\0';
                    break;
                }
            }
        }
        ptr = strdup(ptr);
        free(str);
    }
    return ptr;
}

References count, free(), i, setup::line, lines(), NULL, rz_file_slurp(), rz_return_val_if_fail, cmd_descs_generate::str, and strdup().

Referenced by rz_syscmd_head().

rz_file_slurp_lines_from_bottom()

RZ_API RZ_OWN char* rz_file_slurp_lines_from_bottom	(	const char *	file,
		int	line
	)

Definition at line 708 of file file.c.

                                                                                {
    rz_return_val_if_fail(file, NULL);
    int i, lines = 0;
    size_t sz;
    char *ptr = NULL, *str = rz_file_slurp(file, &sz);
    // TODO: Implement context
    if (str) {
        for (i = 0; str[i]; i++) {
            if (str[i] == '\n') {
                lines++;
            }
        }
        if (line > lines) {
            return str; // number of lines requested in more than present, return all
        }
        i--;
        for (; str[i] && line; i--) {
            if (str[i] == '\n') {
                line--;
            }
        }
        ptr = str + i;
        ptr = strdup(ptr);
        free(str);
    }
    return ptr;
}

References free(), i, setup::line, lines(), NULL, rz_file_slurp(), rz_return_val_if_fail, cmd_descs_generate::str, and strdup().

Referenced by rz_syscmd_tail().

rz_file_slurp_random_line()

RZ_API char* rz_file_slurp_random_line

(

const char *

file

)

Definition at line 624 of file file.c.

                                                         {
    rz_return_val_if_fail(file, NULL);
    int i = 0;
    return rz_file_slurp_random_line_count(file, &i);
}

References i, NULL, rz_file_slurp_random_line_count(), and rz_return_val_if_fail.

rz_file_slurp_random_line_count()

RZ_API char* rz_file_slurp_random_line_count	(	const char *	file,
		int *	line
	)

Definition at line 630 of file file.c.

                                                                          {
    rz_return_val_if_fail(file && line, NULL);
    /* Reservoir Sampling */
    char *ptr = NULL, *str;
    size_t i, lines, selection = -1;
    int start = *line;
    if ((str = rz_file_slurp(file, NULL))) {
        rz_num_irand();
        for (i = 0; str[i]; i++) {
            if (str[i] == '\n') {
                // here rand doesn't have any security implication
                //  https://www.securecoding.cert.org/confluence/display/c/MSC30-C.+Do+not+use+the+rand()+function+for+generating+pseudorandom+numbers
                if (!(rz_num_rand((++(*line))))) {
                    selection = (*line - 1); /* The line we want. */
                }
            }
        }
        if ((selection < start) || (selection == -1)) {
            free(str);
            return NULL;
        } else {
            lines = selection - start;
        }
        if (lines > 0) {
            for (i = 0; str[i] && lines; i++) {
                if (str[i] == '\n') {
                    lines--;
                }
            }
            ptr = str + i;
            for (i = 0; ptr[i]; i++) {
                if (ptr[i] == '\n') {
                    ptr[i] = '\0';
                    break;
                }
            }
            ptr = strdup(ptr);
        }
        free(str);
    }
    return ptr;
}

References free(), i, setup::line, lines(), NULL, rz_file_slurp(), rz_num_irand(), rz_num_rand(), rz_return_val_if_fail, start, cmd_descs_generate::str, and strdup().

Referenced by rz_core_fortune_get_random(), and rz_file_slurp_random_line().

rz_file_slurp_range()

RZ_API char* rz_file_slurp_range	(	const char *	str,
		ut64	off,
		int	sz,
		int *	osz
	)

Definition at line 595 of file file.c.

                                                                              {
    char *ret;
    size_t read_items;
    FILE *fd = rz_sys_fopen(str, "rb");
    if (!fd) {
        return NULL;
    }
    // XXX handle out of bound reads (eof)
    if (fseek(fd, off, SEEK_SET) < 0) {
        fclose(fd);
        return NULL;
    }
    ret = (char *)malloc(sz + 1);
    if (ret) {
        if (osz) {
            *osz = (int)(size_t)fread(ret, 1, sz, fd);
        } else {
            read_items = fread(ret, 1, sz, fd);
            if (!read_items) {
                fclose(fd);
                return ret;
            }
        }
        ret[sz] = '\0';
    }
    fclose(fd);
    return ret;
}

References fd, benchmark::FILE, int, malloc(), NULL, off, rz_sys_fopen(), SEEK_SET, and cmd_descs_generate::str.

Referenced by rz_file_is_deflated().

rz_file_temp()

RZ_API char* rz_file_temp

(

const char *

prefix

)

Definition at line 1048 of file file.c.

                                              {
    if (!prefix) {
        prefix = "";
    }
    char *path = rz_file_tmpdir();
    char *res = rz_str_newf("%s" RZ_SYS_DIR "%s.%" PFMT64x, path, prefix, rz_time_now());
    free(path);
    return res;
}

References free(), path, PFMT64x, prefix, rz_file_tmpdir(), rz_str_newf(), RZ_SYS_DIR, and rz_time_now().

Referenced by __rap_reg_profile(), rz_cmd_debug_dmi(), rz_core_cmd_subst_i(), rz_main_rizin(), rz_reopen_debug_rzrun_handler(), and set_profile_string().

rz_file_tmpdir()

RZ_API char* rz_file_tmpdir

(

void

)

Definition at line 1132 of file file.c.

                                  {
#if __WINDOWS__
    char *path = NULL;
    DWORD len = 0;
 
    LPWSTR tmpdir = calloc(1, sizeof(WCHAR) * (MAX_PATH + 1));
    if (!tmpdir) {
        return NULL;
    }
    if ((len = GetTempPathW(MAX_PATH + 1, tmpdir)) == 0) {
        path = rz_sys_getenv("TEMP");
        if (!path) {
            path = strdup("C:\\WINDOWS\\Temp\\");
        }
    } else {
        tmpdir[len] = 0;
        // Windows XP sometimes returns short path name
        GetLongPathNameW(tmpdir, tmpdir, MAX_PATH + 1);
        path = rz_utf16_to_utf8(tmpdir);
    }
    free(tmpdir);
    // Windows 7, stat() function fail if tmpdir ends with '\\'
    if (path) {
        size_t path_len = strlen(path);
        if (path_len > 0 && path[path_len - 1] == '\\') {
            path[path_len - 1] = '\0';
        }
    }
#else
    char *path = rz_sys_getenv("TMPDIR");
    if (path && !*path) {
        RZ_FREE(path);
    }
    if (!path) {
#if __ANDROID__
        path = strdup("/data/data/org.rizin.rizininstaller/rizin/tmp");
#else
        path = strdup("/tmp");
#endif
    }
#endif
    if (!rz_file_is_directory(path)) {
        eprintf("Cannot find temporary directory '%s'\n", path);
    }
    return path;
}

References calloc(), DWORD, eprintf, free(), len, LPWSTR, NULL, path, rz_file_is_directory(), RZ_FREE, rz_sys_getenv(), and strdup().

Referenced by rz_core_config_init(), rz_file_mkstemp(), rz_file_temp(), rz_path_home(), rz_path_home_prefix(), and rz_str_home().

rz_file_touch()

RZ_API bool rz_file_touch

(

const char *

file

)

Definition at line 833 of file file.c.

                                            {
    rz_return_val_if_fail(file, false);
    return rz_file_dump(file, NULL, 0, true);
}

References NULL, rz_file_dump(), and rz_return_val_if_fail.

rz_file_truncate()

RZ_API bool rz_file_truncate	(	const char *	filename,
		ut64	newsize
	)

Definition at line 47 of file file.c.

                                                                 {
    rz_return_val_if_fail(filename, false);
    int fd;
    if (rz_file_is_directory(filename)) {
        return false;
    }
    if (!rz_file_exists(filename) || !rz_file_is_regular(filename)) {
        return false;
    }
#if __WINDOWS__
    fd = rz_sys_open(filename, O_RDWR, 0644);
#else
    fd = rz_sys_open(filename, O_RDWR | O_SYNC, 0644);
#endif
    if (fd == -1) {
        return false;
    }
#ifdef _MSC_VER
    int r = _chsize(fd, newsize);
#else
    int r = ftruncate(fd, newsize);
#endif
    if (r != 0) {
        eprintf("Could not resize %s file\n", filename);
        close(fd);
        return false;
    }
    close(fd);
    return true;
}

References close, eprintf, fd, ftruncate, O_RDWR, O_SYNC, r, rz_file_exists(), rz_file_is_directory(), rz_file_is_regular(), rz_return_val_if_fail, and rz_sys_open().

rz_stdin_slurp()

RZ_API char* rz_stdin_slurp

(

int *

sz

)

Definition at line 408 of file file.c.

                                     {
#if __UNIX__ || __WINDOWS__
    int i, ret, newfd;
    if ((newfd = dup(0)) < 0) {
        return NULL;
    }
    char *buf = malloc(BS);
    if (!buf) {
        close(newfd);
        return NULL;
    }
    for (i = 0; i >= 0; i += ret) {
        char *new = realloc(buf, i + BS);
        if (!new) {
            eprintf("Cannot realloc to %d\n", i + BS);
            free(buf);
            close(newfd);
            return NULL;
        }
        buf = new;
        ret = read(0, buf + i, BS);
        if (ret < 1) {
            break;
        }
    }
    if (i < 1) {
        i = 0;
        RZ_FREE(buf);
    } else {
        buf[i] = 0;
        dup2(newfd, 0);
        close(newfd);
    }
    if (sz) {
        *sz = i;
    }
    if (!i) {
        RZ_FREE(buf);
    }
    return buf;
#else
#warning TODO rz_stdin_slurp
    return NULL;
#endif
}

References BS, close, dup, dup2, eprintf, free(), i, malloc(), NULL, read(), realloc(), and RZ_FREE.

Referenced by hash_context_create_desc_io_stdin(), hash_parse_any(), hash_parse_hexadecimal(), hash_parse_string(), rax(), rz_main_rizin(), rz_main_rz_asm(), and rzfind_open().