io.c File Reference

#include <rz_io.h>
#include <sdb.h>
#include <config.h>
#include "io_private.h"

Go to the source code of this file.

Macros
#define	CMP(addr, part)
#define	IO_EXTEND_BLOCK_SZ   256

Typedefs
typedef int(*	cbOnIterMap) (RzIO *io, int fd, ut64 addr, ut8 *buf, int len, RzIOMap *map, void *user)

Functions
	RZ_LIB_VERSION (rz_io)
static int	fd_read_at_wrap (RzIO *io, int fd, ut64 addr, ut8 *buf, int len, RzIOMap *map, void *user)
static int	fd_write_at_wrap (RzIO *io, int fd, ut64 addr, ut8 *buf, int len, RzIOMap *map, void *user)
static st64	on_map_skyline (RzIO *io, ut64 vaddr, ut8 *buf, int len, int match_flg, cbOnIterMap op, bool prefix_mode)
RZ_API RzIO *	rz_io_new (void)
RZ_API RzIO *	rz_io_init (RzIO *io)
RZ_API void	rz_io_free (RzIO *io)
RZ_API RzIODesc *	rz_io_open_buffer (RzIO *io, RzBuffer *b, int perm, int mode)
RZ_API RzIODesc *	rz_io_open_nomap (RzIO *io, const char *uri, int perm, int mode)
RZ_API RzIODesc *	rz_io_open (RzIO *io, const char *uri, int perm, int mode)
RZ_API RzIODesc *	rz_io_open_at (RzIO *io, const char *uri, int perm, int mode, ut64 at, RZ_NULLABLE RZ_OUT RzIOMap **map)
	Open a file and directly map it at the given offset. More...
RZ_API RzList *	rz_io_open_many (RzIO *io, const char *uri, int perm, int mode)
RZ_API bool	rz_io_reopen (RzIO *io, int fd, int perm, int mode)
RZ_API int	rz_io_close_all (RzIO *io)
RZ_API int	rz_io_pread_at (RzIO *io, ut64 paddr, ut8 *buf, int len)
RZ_API int	rz_io_pwrite_at (RzIO *io, ut64 paddr, const ut8 *buf, int len)
RZ_API bool	rz_io_vread_at_mapped (RzIO *io, ut64 vaddr, ut8 *buf, int len)
static bool	rz_io_vwrite_at (RzIO *io, ut64 vaddr, const ut8 *buf, int len)
RZ_API bool	rz_io_read_at (RzIO *io, ut64 addr, ut8 *buf, int len)
RZ_API bool	rz_io_read_at_mapped (RzIO *io, ut64 addr, ut8 *buf, int len)
RZ_API int	rz_io_nread_at (RzIO *io, ut64 addr, ut8 *buf, int len)
RZ_API bool	rz_io_write_at (RzIO *io, ut64 addr, const ut8 *buf, int len)
RZ_API bool	rz_io_read (RzIO *io, ut8 *buf, int len)
RZ_API bool	rz_io_write (RzIO *io, const ut8 *buf, int len)
RZ_API ut64	rz_io_size (RzIO *io)
RZ_API bool	rz_io_is_listener (RzIO *io)
RZ_API char *	rz_io_system (RzIO *io, const char *cmd)
RZ_API bool	rz_io_resize (RzIO *io, ut64 newsize)
RZ_API bool	rz_io_close (RzIO *io)
RZ_API bool	rz_io_extend_at (RzIO *io, ut64 addr, ut64 size)
	Extend the RzIODesc at addr by inserting size 0 bytes. More...
RZ_API bool	rz_io_set_write_mask (RzIO *io, const ut8 *mask, int len)
	Set a mask that is used on all following write operations. More...
RZ_API ut64	rz_io_p2v (RzIO *io, ut64 pa)
RZ_API ut64	rz_io_v2p (RzIO *io, ut64 va)
RZ_API void	rz_io_bind (RzIO *io, RzIOBind *bnd)
RZ_API bool	rz_io_shift (RzIO *io, ut64 start, ut64 end, st64 move)
RZ_API ut64	rz_io_seek (RzIO *io, ut64 offset, int whence)
RZ_API int	rz_io_fini (RzIO *io)

Macro Definition Documentation

CMP

#define CMP	(		addr,
			part
	)

Value:

                                                                        ((addr) < rz_itv_end(((RzSkylineItem *)(part))->itv) - 1 ? -1 : (addr) > rz_itv_end(((RzSkylineItem *)(part))->itv) - 1 ? 1 \
                                                                        : 0)

IO_EXTEND_BLOCK_SZ

#define IO_EXTEND_BLOCK_SZ   256

Typedef Documentation

cbOnIterMap

typedef int(* cbOnIterMap) (RzIO *io, int fd, ut64 addr, ut8 *buf, int len, RzIOMap *map, void *user)

Definition at line 26 of file io.c.

Function Documentation

fd_read_at_wrap()

static int fd_read_at_wrap ( RzIO *  io, int  fd, ut64  addr, ut8 *  buf, int  len, RzIOMap *  map, void *  user  )

static

Definition at line 18 of file io.c.

                                                                                                     {
    return rz_io_fd_read_at(io, fd, addr, buf, len);
}

References addr, fd, len, and rz_io_fd_read_at().

Referenced by rz_io_nread_at(), rz_io_read_at_mapped(), and rz_io_vread_at_mapped().

fd_write_at_wrap()

static int fd_write_at_wrap ( RzIO *  io, int  fd, ut64  addr, ut8 *  buf, int  len, RzIOMap *  map, void *  user  )

static

Definition at line 22 of file io.c.

                                                                                                      {
    return rz_io_fd_write_at(io, fd, addr, buf, len);
}

References addr, fd, len, and rz_io_fd_write_at().

Referenced by rz_io_vwrite_at().

on_map_skyline()

static st64 on_map_skyline ( RzIO *  io, ut64  vaddr, ut8 *  buf, int  len, int  match_flg, cbOnIterMap  op, bool  prefix_mode  )

static

Definition at line 30 of file io.c.

                                                                                                                     {
    RzVector *skyline = &io->map_skyline.v;
    ut64 addr = vaddr;
    size_t i;
    bool ret = true, wrap = !prefix_mode && vaddr + len < vaddr;
#define CMP(addr, part) ((addr) < rz_itv_end(((RzSkylineItem *)(part))->itv) - 1 ? -1 : (addr) > rz_itv_end(((RzSkylineItem *)(part))->itv) - 1 ? 1 \
                                                                        : 0)
    // Let i be the first skyline part whose right endpoint > addr
    if (!len) {
        i = rz_vector_len(skyline);
    } else {
        rz_vector_lower_bound(skyline, addr, i, CMP);
        if (i == rz_vector_len(skyline) && wrap) {
            wrap = false;
            i = 0;
            addr = 0;
        }
    }
#undef CMP
    while (i < rz_vector_len(skyline)) {
        const RzSkylineItem *part = rz_vector_index_ptr(skyline, i);
        // Right endpoint <= addr
        if (rz_itv_end(part->itv) - 1 < addr) {
            i++;
            if (wrap && i == rz_vector_len(skyline)) {
                wrap = false;
                i = 0;
                addr = 0;
            }
            continue;
        }
        if (addr < part->itv.addr) {
            // [addr, part->itv.addr) is a gap
            if (prefix_mode || len <= part->itv.addr - vaddr) {
                break;
            }
            addr = part->itv.addr;
        }
        // Now left endpoint <= addr < right endpoint
        ut64 len1 = RZ_MIN(vaddr + len - addr, rz_itv_end(part->itv) - addr);
        if (len1 < 1) {
            break;
        }
        RzIOMap *map = part->user;
        // The map satisfies the permission requirement or p_cache is enabled
        if (((map->perm & match_flg) == match_flg || io->p_cache)) {
            st64 result = op(io, map->fd, map->delta + addr - map->itv.addr,
                buf + (addr - vaddr), len1, map, NULL);
            if (prefix_mode) {
                if (result < 0) {
                    return result;
                }
                addr += result;
                if (result != len1) {
                    break;
                }
            } else {
                if (result != len1) {
                    ret = false;
                }
                addr += len1;
            }
        } else if (prefix_mode) {
            break;
        } else {
            addr += len1;
            ret = false;
        }
        // Reaches the end
        if (addr == vaddr + len) {
            break;
        }
        // Wrap to the beginning of skyline if address wraps
        if (!addr) {
            i = 0;
        }
    }
    return prefix_mode ? addr - vaddr : ret;
}

References addr, rz_interval_t::addr, CMP, i, rz_skyline_item_t::itv, len, map(), rz_io_t::map_skyline, NULL, op, rz_io_t::p_cache, rz_itv_end(), RZ_MIN, rz_vector_index_ptr(), rz_vector_len(), rz_vector_lower_bound, st64, rz_skyline_item_t::user, ut64(), and rz_skyline_t::v.

Referenced by rz_io_nread_at(), rz_io_read_at_mapped(), rz_io_vread_at_mapped(), and rz_io_vwrite_at().

rz_io_bind()

RZ_API void rz_io_bind	(	RzIO *	io,
		RzIOBind *	bnd
	)

Definition at line 550 of file io.c.

                                                {
    rz_return_if_fail(io && bnd);
 
    bnd->io = io;
    bnd->init = true;
    bnd->fd_get_current = rz_io_fd_get_current;
    bnd->desc_use = rz_io_use_fd;
    bnd->desc_get = rz_io_desc_get;
    bnd->desc_size = rz_io_desc_size;
    bnd->p2v = rz_io_p2v;
    bnd->v2p = rz_io_v2p;
    bnd->open = rz_io_open_nomap;
    bnd->open_at = rz_io_open_at;
    bnd->close = rz_io_fd_close;
    bnd->read_at = rz_io_read_at;
    bnd->write_at = rz_io_write_at;
    bnd->system = rz_io_system;
    bnd->fd_open = rz_io_fd_open;
    bnd->fd_close = rz_io_fd_close;
    bnd->fd_seek = rz_io_fd_seek;
    bnd->fd_size = rz_io_fd_size;
    bnd->fd_resize = rz_io_fd_resize;
    bnd->fd_read = rz_io_fd_read;
    bnd->fd_write = rz_io_fd_write;
    bnd->fd_read_at = rz_io_fd_read_at;
    bnd->fd_write_at = rz_io_fd_write_at;
    bnd->fd_is_dbg = rz_io_fd_is_dbg;
    bnd->fd_get_name = rz_io_fd_get_name;
    bnd->fd_get_map = rz_io_map_get_for_fd;
    bnd->fd_remap = rz_io_map_remap_fd;
    bnd->fd_getbuf = rz_io_fd_get_buf;
    bnd->is_valid_offset = rz_io_is_valid_offset;
    bnd->map_get = rz_io_map_get;
    bnd->map_get_paddr = rz_io_map_get_paddr;
    bnd->addr_is_mapped = rz_io_addr_is_mapped;
    bnd->map_add = rz_io_map_add;
#if HAVE_PTRACE
    bnd->ptrace = rz_io_ptrace;
    bnd->ptrace_func = rz_io_ptrace_func;
#endif
#if __WINDOWS__
    bnd->get_w32dbg_wrap = rz_io_get_w32dbg_wrap;
#endif
}

References rz_io_bind_t::addr_is_mapped, rz_io_bind_t::close, rz_io_bind_t::desc_get, rz_io_bind_t::desc_size, rz_io_bind_t::desc_use, rz_io_bind_t::fd_close, rz_io_bind_t::fd_get_current, rz_io_bind_t::fd_get_map, rz_io_bind_t::fd_get_name, rz_io_bind_t::fd_getbuf, rz_io_bind_t::fd_is_dbg, rz_io_bind_t::fd_open, rz_io_bind_t::fd_read, rz_io_bind_t::fd_read_at, rz_io_bind_t::fd_remap, rz_io_bind_t::fd_resize, rz_io_bind_t::fd_seek, rz_io_bind_t::fd_size, rz_io_bind_t::fd_write, rz_io_bind_t::fd_write_at, rz_io_bind_t::init, rz_io_bind_t::io, rz_io_bind_t::is_valid_offset, rz_io_bind_t::map_add, rz_io_bind_t::map_get, rz_io_bind_t::map_get_paddr, rz_io_bind_t::open, rz_io_bind_t::open_at, rz_io_bind_t::p2v, rz_io_bind_t::read_at, rz_io_addr_is_mapped(), rz_io_desc_get(), rz_io_desc_size(), rz_io_fd_close(), rz_io_fd_get_buf(), rz_io_fd_get_current(), rz_io_fd_get_name(), rz_io_fd_is_dbg(), rz_io_fd_open(), rz_io_fd_read(), rz_io_fd_read_at(), rz_io_fd_resize(), rz_io_fd_seek(), rz_io_fd_size(), rz_io_fd_write(), rz_io_fd_write_at(), rz_io_is_valid_offset(), rz_io_map_add(), rz_io_map_get(), rz_io_map_get_for_fd(), rz_io_map_get_paddr(), rz_io_map_remap_fd(), rz_io_open_at(), rz_io_open_nomap(), rz_io_p2v(), rz_io_read_at(), rz_io_system(), rz_io_use_fd(), rz_io_v2p(), rz_io_write_at(), rz_return_if_fail, rz_io_bind_t::system, rz_io_bind_t::v2p, and rz_io_bind_t::write_at.

Referenced by __open(), download_pdb(), rz_core_file_reopen(), rz_core_init(), rz_diff_file_open(), and rzfind_open_file().

rz_io_close()

RZ_API bool rz_io_close

(

RzIO *

io

)

Definition at line 441 of file io.c.

                                  {
    return io ? rz_io_desc_close(io->desc) : false;
}

References rz_io_t::desc, and rz_io_desc_close().

rz_io_close_all()

RZ_API int rz_io_close_all

(

RzIO *

io

)

Definition at line 258 of file io.c.

                                     { // what about undo?
    if (!io) {
        return false;
    }
    rz_io_desc_fini(io);
    rz_io_map_reset(io);
    rz_io_desc_init(io);
    rz_io_cache_fini(io);
    return true;
}

References rz_io_cache_fini(), rz_io_desc_fini(), rz_io_desc_init(), and rz_io_map_reset().

Referenced by __close_file_cb(), file_load(), rz_core_io_file_open(), and rz_open_close_all_handler().

rz_io_extend_at()

RZ_API bool rz_io_extend_at	(	RzIO *	io,
		ut64	addr,
		ut64	size
	)

Extend the RzIODesc at addr by inserting size 0 bytes.

Parameters

io	Reference to RzIO instance
addr	Address where to insert new 0 bytes
size	Number of 0 bytes to insert

Returns

true if extend operation was successful, false otherwise

Definition at line 453 of file io.c.

                                                            {
#define IO_EXTEND_BLOCK_SZ 256
    rz_return_val_if_fail(io, false);
 
    if (!io->desc || !io->desc->plugin) {
        return false;
    }
    if (size == 0) {
        return true;
    }
 
    if ((io->desc->perm & RZ_PERM_RW) != RZ_PERM_RW) {
        return false;
    }
    ut64 cur_size = rz_io_desc_size(io->desc);
    if (addr > cur_size) {
        return false;
    }
 
    // Extend the file to include the additional <size> bytes
    if (UT64_ADD_OVFCHK(cur_size, size)) {
        return false;
    }
    if (!rz_io_resize(io, cur_size + size)) {
        return false;
    }
 
    // Shift old data to make space for the zero bytes
    ut64 tmp = cur_size >= IO_EXTEND_BLOCK_SZ ? RZ_MAX(cur_size - IO_EXTEND_BLOCK_SZ, addr) : addr;
    ut64 remaining = cur_size - addr;
 
    ut8 *buffer = RZ_NEWS(ut8, IO_EXTEND_BLOCK_SZ);
    if (!buffer) {
        return false;
    }
    while (remaining) {
        int sz = rz_io_pread_at(io, tmp, buffer, IO_EXTEND_BLOCK_SZ);
        rz_io_pwrite_at(io, tmp + size, buffer, sz);
 
        tmp = tmp - IO_EXTEND_BLOCK_SZ > addr ? tmp - IO_EXTEND_BLOCK_SZ : addr;
        remaining = remaining > sz ? remaining - sz : 0;
    }
    free(buffer);
 
    // Put the zero bytes at the right place
    ut8 *empty = RZ_NEWS0(ut8, size);
    if (!empty) {
        return false;
    }
    rz_io_pwrite_at(io, addr, empty, size);
    free(empty);
 
    return true;
#undef IO_EXTEND_BLOCK_SZ
}

References addr, rz_io_t::desc, free(), IO_EXTEND_BLOCK_SZ, rz_io_desc_t::perm, rz_io_desc_t::plugin, rz_io_desc_size(), rz_io_pread_at(), rz_io_pwrite_at(), rz_io_resize(), RZ_MAX, RZ_NEWS, RZ_NEWS0, RZ_PERM_RW, rz_return_val_if_fail, autogen_x86imm::tmp, ut64(), and UT64_ADD_OVFCHK.

Referenced by rz_core_extend_at().

rz_io_fini()

RZ_API int rz_io_fini

(

RzIO *

io

)

Definition at line 724 of file io.c.

                                {
    if (!io) {
        return false;
    }
    rz_io_desc_cache_fini_all(io);
    rz_io_desc_fini(io);
    rz_io_map_fini(io);
    rz_list_free(io->plugins);
    rz_io_cache_fini(io);
    if (io->runprofile) {
        RZ_FREE(io->runprofile);
    }
    rz_event_free(io->event);
    free(io->envprofile);
#if RZ_IO_USE_PTRACE_WRAP
    if (io->ptrace_wrap) {
        ptrace_wrap_instance_stop(io->ptrace_wrap);
        free(io->ptrace_wrap);
    }
#endif
#if __WINDOWS__
    w32dbg_wrap_free((W32DbgWInst *)io->priv_w32dbg_wrap);
#endif
    return true;
}

References rz_io_t::envprofile, rz_io_t::event, free(), rz_io_t::plugins, ptrace_wrap_instance_stop(), rz_io_t::runprofile, rz_event_free(), RZ_FREE, rz_io_cache_fini(), rz_io_desc_cache_fini_all(), rz_io_desc_fini(), rz_io_map_fini(), rz_list_free(), and w32dbg_wrap_free().

Referenced by rz_io_free().

rz_io_free()

RZ_API void rz_io_free

(

RzIO *

io

)

Definition at line 126 of file io.c.

                                 {
    if (io) {
        rz_io_fini(io);
        free(io);
    }
}

References free(), and rz_io_fini().

Referenced by download_pdb(), hash_context_run(), rz_core_fini(), rz_diff_io_close(), rz_diff_io_open(), and rzfind_open_file().

rz_io_init()

RZ_API RzIO* rz_io_init

(

RzIO *

io

)

Definition at line 114 of file io.c.

                                  {
    rz_return_val_if_fail(io, NULL);
    io->addrbytes = 1;
    rz_io_desc_init(io);
    rz_skyline_init(&io->map_skyline);
    rz_io_map_init(io);
    rz_io_cache_init(io);
    rz_io_plugin_init(io);
    io->event = rz_event_new(io);
    return io;
}

References rz_io_t::addrbytes, rz_io_t::event, rz_io_t::map_skyline, NULL, rz_event_new(), rz_io_cache_init(), rz_io_desc_init(), rz_io_map_init(), rz_io_plugin_init(), rz_return_val_if_fail, and rz_skyline_init().

Referenced by rz_io_new().

rz_io_is_listener()

RZ_API bool rz_io_is_listener

(

RzIO *

io

)

Definition at line 404 of file io.c.

                                        {
    if (io && io->desc && io->desc->plugin && io->desc->plugin->listener) {
        return io->desc->plugin->listener(io->desc);
    }
    return false;
}

References rz_io_t::desc, rz_io_plugin_t::listener, and rz_io_desc_t::plugin.

Referenced by rz_core_file_open(), and rz_core_rtr_rap_run().

rz_io_new()

RZ_API RzIO* rz_io_new

(

void

)

Definition at line 110 of file io.c.

                             {
    return rz_io_init(RZ_NEW0(RzIO));
}

References rz_io_init(), and RZ_NEW0.

Referenced by download_pdb(), hash_context_run(), rz_core_init(), rz_diff_io_open(), and rzfind_open_file().

rz_io_nread_at()

RZ_API int rz_io_nread_at	(	RzIO *	io,
		ut64	addr,
		ut8 *	buf,
		int	len
	)

Definition at line 338 of file io.c.

                                                                  {
    int ret;
    rz_return_val_if_fail(io && buf && len >= 0, -1);
    if (len == 0) {
        return 0;
    }
    if (io->va) {
        if (io->ff) {
            memset(buf, io->Oxff, len);
        }
        ret = on_map_skyline(io, addr, buf, len, RZ_PERM_R, fd_read_at_wrap, true);
    } else {
        ret = rz_io_pread_at(io, addr, buf, len);
    }
    if (ret > 0 && io->cached & RZ_PERM_R) {
        (void)rz_io_cache_read(io, addr, buf, len);
    }
    return ret;
}

References addr, rz_io_t::cached, fd_read_at_wrap(), rz_io_t::ff, len, memset(), on_map_skyline(), rz_io_t::Oxff, rz_io_cache_read(), rz_io_pread_at(), RZ_PERM_R, rz_return_val_if_fail, and rz_io_t::va.

Referenced by core_recover_golang_functions_go_1_16(), core_recover_golang_functions_go_1_18(), core_recover_golang_functions_go_1_2(), decode_from_table(), decode_ldr_set_addr(), GH(), go_offset(), op_at_phys(), read_at_kernel_virtual(), recover_string_at(), rizin_compare_words(), rz_cmd_cmp_hex_block_handler(), rz_cmd_cmp_hex_block_hexdiff_handler(), rz_cmd_cmp_hex_diff_lines_handler(), rz_cmd_heap_chunks_print_handler(), rz_core_analysis_recover_golang_functions(), rz_core_analysis_resolve_golang_strings(), rz_core_cmp_disasm(), rz_core_cmp_mem_data(), rz_core_cmp_mem_mem(), rz_core_cmpwatch_add(), rz_core_cmpwatch_update(), rz_core_transform_op(), rz_core_write_duplicate_at(), rz_heap_tcache_content(), and type_match().

rz_io_open()

RZ_API RzIODesc* rz_io_open	(	RzIO *	io,
		const char *	uri,
		int	perm,
		int	mode
	)

Definition at line 156 of file io.c.

                                                                           {
    rz_return_val_if_fail(io, NULL);
    RzIODesc *desc = rz_io_open_nomap(io, uri, perm, mode);
    if (!desc) {
        return NULL;
    }
    rz_io_map_new(io, desc->fd, desc->perm, 0LL, 0LL, rz_io_desc_size(desc));
    return desc;
}

References desc, NULL, rz_io_desc_size(), rz_io_map_new(), rz_io_open_nomap(), and rz_return_val_if_fail.

Referenced by rz_open_binary_file_handler().

rz_io_open_at()

RZ_API RzIODesc* rz_io_open_at	(	RzIO *	io,
		const char *	uri,
		int	perm,
		int	mode,
		ut64	at,
		RZ_NULLABLE RZ_OUT RzIOMap **	map
	)

Open a file and directly map it at the given offset.

This executes both rz_io_open_nomap() and rz_io_map_new() and returns their results without updating the skyline.

Parameters

uri	file uri to open
at	where to map the file
map	optionally returns the created RzIOMap

Returns

the opened RzIODesc of the file

Definition at line 177 of file io.c.

                                                                                                                         {
    rz_return_val_if_fail(io && uri, NULL);
 
    RzIODesc *desc = rz_io_open_nomap(io, uri, perm, mode);
    if (!desc) {
        return NULL;
    }
    ut64 size = rz_io_desc_size(desc);
    // second map
    if (size && ((UT64_MAX - size + 1) < at)) {
        // split map into 2 maps if only 1 big map results into interger overflow
        io_map_new(io, desc->fd, desc->perm, UT64_MAX - at + 1, 0LL, size - (UT64_MAX - at) - 1);
        // someone pls take a look at this confusing stuff
        size = UT64_MAX - at + 1;
    }
    // skyline not updated
    RzIOMap *m = rz_io_map_new(io, desc->fd, desc->perm, 0LL, at, size);
    if (map) {
        *map = m;
    }
    return desc;
}

References desc, io_map_new(), regress::m, map(), NULL, rz_io_desc_size(), rz_io_map_new(), rz_io_open_nomap(), rz_return_val_if_fail, ut64(), and UT64_MAX.

Referenced by io_create_mem_map(), open_nobin_file(), and rz_io_bind().

rz_io_open_buffer()

RZ_API RzIODesc* rz_io_open_buffer	(	RzIO *	io,
		RzBuffer *	b,
		int	perm,
		int	mode
	)

Definition at line 133 of file io.c.

                                                                              {
    ut64 bufSize = rz_buf_size(b);
    char *uri = rz_str_newf("malloc://%" PFMT64d, bufSize);
    RzIODesc *desc = rz_io_open_nomap(io, uri, perm, mode);
    if (desc) {
        const ut8 *tmp = rz_buf_data(b, &bufSize);
        rz_io_desc_write(desc, tmp, bufSize);
    }
    free(uri);
    return desc;
}

References b, desc, free(), PFMT64d, rz_buf_data(), rz_buf_size(), rz_io_desc_write(), rz_io_open_nomap(), rz_str_newf(), autogen_x86imm::tmp, and ut64().

Referenced by handle_tmp_desc(), and rz_core_cmd_subst_i().

rz_io_open_many()

RZ_API RzList* rz_io_open_many	(	RzIO *	io,
		const char *	uri,
		int	perm,
		int	mode
	)

Definition at line 201 of file io.c.

                                                                              {
    RzList *desc_list;
    RzListIter *iter;
    RzIODesc *desc;
    rz_return_val_if_fail(io && io->files && uri, NULL);
    RzIOPlugin *plugin = rz_io_plugin_resolve(io, uri, 1);
    if (!plugin || !plugin->open_many || !plugin->close) {
        return NULL;
    }
    if (!(desc_list = plugin->open_many(io, uri, perm, mode))) {
        return NULL;
    }
    rz_list_foreach (desc_list, iter, desc) {
        if (desc) {
            if (!desc->plugin) {
                desc->plugin = plugin;
            }
            if (!desc->uri) {
                desc->uri = strdup(uri);
            }
            // should autofd be honored here?
            rz_io_desc_add(io, desc);
            if (!io->desc) {
                io->desc = desc;
            }
        }
    }
    return desc_list;
}

References rz_io_plugin_t::close, desc, rz_io_t::desc, rz_io_t::files, NULL, rz_io_plugin_t::open_many, rz_io_desc_add(), rz_io_plugin_resolve(), rz_return_val_if_fail, and strdup().

Referenced by rz_core_file_open_many().

rz_io_open_nomap()

RZ_API RzIODesc* rz_io_open_nomap	(	RzIO *	io,
		const char *	uri,
		int	perm,
		int	mode
	)

Definition at line 145 of file io.c.

                                                                                 {
    rz_return_val_if_fail(io && uri, NULL);
    RzIODesc *desc = rz_io_desc_open(io, uri, perm, mode);
    if ((io->autofd || !io->desc) && desc) {
        io->desc = desc;
    }
    // set desc as current if autofd or io->desc==NULL
    return desc;
}

References rz_io_t::autofd, desc, rz_io_t::desc, NULL, rz_io_desc_open(), and rz_return_val_if_fail.

Referenced by add_map(), hash_context_create_desc_io_stdin(), hash_context_create_desc_io_string(), hash_context_run(), perform_mapped_file_yank(), reopen_in_malloc_cb(), rz_core_file_open(), rz_core_rtr_rap_run(), rz_diff_io_open(), rz_io_bind(), rz_io_open(), rz_io_open_at(), rz_io_open_buffer(), rz_io_reopen(), and rzfind_open_file().

rz_io_p2v()

RZ_API ut64 rz_io_p2v	(	RzIO *	io,
		ut64	pa
	)

Definition at line 533 of file io.c.

                                         {
    RzIOMap *map = rz_io_map_get_paddr(io, pa);
    if (map) {
        return pa - map->delta + map->itv.addr;
    }
    return UT64_MAX;
}

References map(), rz_io_map_get_paddr(), and UT64_MAX.

Referenced by annotated_hexdump(), rz_cmd_help(), rz_io_bind(), and rz_print_hexdump_bits_handler().

rz_io_pread_at()

RZ_API int rz_io_pread_at	(	RzIO *	io,
		ut64	paddr,
		ut8 *	buf,
		int	len
	)

Definition at line 269 of file io.c.

                                                                   {
    rz_return_val_if_fail(io && buf && len >= 0, -1);
    if (io->ff) {
        memset(buf, io->Oxff, len);
    }
    return rz_io_desc_read_at(io->desc, paddr, buf, len);
}

References rz_io_t::desc, rz_io_t::ff, len, memset(), rz_io_t::Oxff, rz_io_desc_read_at(), and rz_return_val_if_fail.

Referenced by basefind_create_pointer_map(), calculate_decrypt(), calculate_encrypt(), calculate_hash(), find_next_diff(), find_prev_diff(), rz_core_bin_create_digests(), rz_diff_draw_tui(), rz_diff_slurp_file(), rz_io_desc_cache_list(), rz_io_extend_at(), rz_io_nread_at(), rz_io_read_at(), rz_io_read_at_mapped(), and rzfind_open_file().

rz_io_pwrite_at()

RZ_API int rz_io_pwrite_at	(	RzIO *	io,
		ut64	paddr,
		const ut8 *	buf,
		int	len
	)

Definition at line 277 of file io.c.

                                                                          {
    rz_return_val_if_fail(io && buf && len > 0, -1);
    return rz_io_desc_write_at(io->desc, paddr, buf, len);
}

References rz_io_t::desc, len, rz_io_desc_write_at(), and rz_return_val_if_fail.

Referenced by __desc_cache_commit_cb(), hash_context_create_desc_io_stdin(), hash_context_create_desc_io_string(), rz_io_extend_at(), and rz_io_write_at().

rz_io_read()

RZ_API bool rz_io_read	(	RzIO *	io,
		ut8 *	buf,
		int	len
	)

Definition at line 383 of file io.c.

                                                    {
    if (io && rz_io_read_at(io, io->off, buf, len)) {
        io->off += len;
        return true;
    }
    return false;
}

References len, rz_io_t::off, and rz_io_read_at().

rz_io_read_at()

RZ_API bool rz_io_read_at	(	RzIO *	io,
		ut64	addr,
		ut8 *	buf,
		int	len
	)

Definition at line 300 of file io.c.

                                                                  {
    rz_return_val_if_fail(io && buf && len >= 0, false);
    if (len == 0) {
        return false;
    }
    bool ret = (io->va)
        ? rz_io_vread_at_mapped(io, addr, buf, len)
        : rz_io_pread_at(io, addr, buf, len) > 0;
    if (io->cached & RZ_PERM_R) {
        (void)rz_io_cache_read(io, addr, buf, len);
    }
    return ret;
}

References addr, rz_io_t::cached, len, rz_io_cache_read(), rz_io_pread_at(), rz_io_vread_at_mapped(), RZ_PERM_R, rz_return_val_if_fail, and rz_io_t::va.

Referenced by __analysis_esil_function(), __core_cmd_search_asm_byteswap(), __core_cmd_search_asm_infinite(), _analysis_calls(), _cb_hit(), cmd_aea(), cmd_debug_backtrace(), cmd_p_minus_e(), cmd_print_bars(), cmd_print_pxA(), cmd_write_bits(), core_analysis_graph_construct_nodes(), core_walk_function_blocks(), disassembly_as_table(), do_analysis_search(), do_debug_trace_calls(), do_ref_search(), do_section_search(), do_string_search(), do_syscall_search(), ds_print_ptr(), ds_show_refs(), dump_maps(), esilbreak_mem_read(), func_walk_blocks(), get_ptr(), get_ptr_ble(), getpcfromstack(), graph_construct_nodes(), ioMemcpy(), is_string_at(), jemalloc_get_bins(), jemalloc_get_chunks(), jemalloc_print_narenas(), meta_string_8bit_add(), myregwrite(), num_callback(), objc_build_refs(), perform_mapped_file_yank(), prevop_addr(), print_cmd_analysis_after_traps_print(), print_double_linked_list_bin_graph(), print_double_linked_list_bin_simple(), print_format_values(), print_heap_chunk(), print_malloc_info(), print_rop(), propagate_types_among_used_variables(), readDword(), readQword(), rz_analysis_try_get_fcn(), rz_analysis_xrefs_from_list_handler(), rz_cmd_analysis(), rz_cmd_debug_step_prog_handler(), rz_cmd_disassemble_ropchain_handler(), rz_cmd_disassembly_basic_block_as_text_json_handler(), rz_cmd_disassembly_basic_block_handler(), rz_cmd_disassembly_function_handler(), rz_cmd_print(), rz_core_analysis_bytes(), rz_core_analysis_data(), rz_core_analysis_esil(), rz_core_analysis_esil_emulate(), rz_core_analysis_hasrefs_to_depth(), rz_core_analysis_hint_set_offset(), rz_core_analysis_name(), rz_core_analysis_op(), rz_core_analysis_read_at(), rz_core_analysis_rename(), rz_core_analysis_search(), rz_core_analysis_search_xrefs(), rz_core_arg_get(), rz_core_asm_back_disassemble(), rz_core_asm_back_disassemble_all(), rz_core_asm_bwdisassemble(), rz_core_asm_strsearch(), rz_core_bin_export_info(), rz_core_bin_whole_strings(), rz_core_block_read(), rz_core_debug_step_skip(), rz_core_disasm_instruction(), rz_core_dump(), rz_core_esil_step(), rz_core_link_stroff(), rz_core_op_analysis(), rz_core_op_str(), rz_core_print_disasm(), rz_core_print_disasm_all(), rz_core_print_dump_str(), rz_core_print_function_disasm_json(), rz_core_print_hexdump_byline_str(), rz_core_print_hexdump_diff_str(), rz_core_print_hexdump_or_hexdiff_str(), rz_core_rtr_gdb_cb(), rz_core_search_cb(), rz_core_search_prelude(), rz_core_search_rop(), rz_core_shift_block(), rz_core_syscall_as_string(), rz_core_visual_asm(), rz_core_yank(), rz_core_yank_string(), rz_heap_bin_content(), rz_heap_chunks_list(), rz_heap_fastbin_content(), rz_heap_update_main_arena(), rz_io_bind(), rz_io_cache_write(), rz_io_read(), rz_io_read_i(), rz_io_shift(), rz_open_malloc_handler(), rz_print_byte_bitstream_handler(), rz_print_hexdump_hexless_words_handler(), rz_write_from_io_xchg_handler(), search_hash(), search_similar_pattern_in(), step_until_inst(), step_until_optype(), stringAt(), tcache_chunk_size(), and tcache_read().

rz_io_read_at_mapped()

RZ_API bool rz_io_read_at_mapped	(	RzIO *	io,
		ut64	addr,
		ut8 *	buf,
		int	len
	)

Definition at line 318 of file io.c.

                                                                         {
    bool ret;
    rz_return_val_if_fail(io && buf, false);
    if (io->ff) {
        memset(buf, io->Oxff, len);
    }
    if (io->va) {
        ret = on_map_skyline(io, addr, buf, len, RZ_PERM_R, fd_read_at_wrap, false);
    } else {
        ret = rz_io_pread_at(io, addr, buf, len) > 0;
    }
    if (io->cached & RZ_PERM_R) {
        (void)rz_io_cache_read(io, addr, buf, len);
    }
    return ret;
}

References addr, rz_io_t::cached, fd_read_at_wrap(), rz_io_t::ff, len, memset(), on_map_skyline(), rz_io_t::Oxff, rz_io_cache_read(), rz_io_pread_at(), RZ_PERM_R, rz_return_val_if_fail, and rz_io_t::va.

Referenced by read_ahead(), rz_core_esil_step(), rz_core_search_value_in_range(), and rz_core_write_value_inc_at().

rz_io_reopen()

RZ_API bool rz_io_reopen	(	RzIO *	io,
		int	fd,
		int	perm,
		int	mode
	)

Definition at line 231 of file io.c.

                                                               {
    RzIODesc *old, *new;
    char *uri;
    if (!(old = rz_io_desc_get(io, fd))) {
        return false;
    }
    // does this really work, or do we have to handler debuggers ugly
    uri = old->referer ? old->referer : old->uri;
#if __WINDOWS__ // TODO: workaround, see https://github.com/rizinorg/rizin/issues/8840
    if (old->plugin->close && old->plugin->close(old)) {
        return false; // TODO: this is an unrecoverable scenario
    }
    if (!(new = rz_io_open_nomap(io, uri, perm, mode))) {
        return false;
    }
    rz_io_desc_exchange(io, old->fd, new->fd);
    rz_io_desc_del(io, old->fd);
    return true;
#else
    if (!(new = rz_io_open_nomap(io, uri, perm, mode))) {
        return false;
    }
    rz_io_desc_exchange(io, old->fd, new->fd);
    return rz_io_desc_close(old); // magic
#endif // __WINDOWS__
}

References rz_io_plugin_t::close, fd, rz_io_desc_t::fd, rz_io_desc_t::plugin, rz_io_desc_t::referer, rz_io_desc_close(), rz_io_desc_del(), rz_io_desc_exchange(), rz_io_desc_get(), rz_io_open_nomap(), and rz_io_desc_t::uri.

Referenced by rz_core_file_reopen_debug(), rz_core_io_file_open(), and rz_core_io_file_reopen().

rz_io_resize()

RZ_API bool rz_io_resize	(	RzIO *	io,
		ut64	newsize
	)

Definition at line 418 of file io.c.

                                                 {
    if (io) {
        RzList *maps = rz_io_map_get_for_fd(io, io->desc->fd);
        RzIOMap *current_map;
        RzListIter *iter;
        ut64 fd_size = rz_io_fd_size(io, io->desc->fd);
        bool ret = rz_io_desc_resize(io->desc, newsize);
        if (!ret) {
            rz_list_free(maps);
            return false;
        }
        rz_list_foreach (maps, iter, current_map) {
            // we just resize map of the same size of its fd
            if (current_map->itv.size == fd_size) {
                rz_io_map_resize(io, current_map->id, newsize);
            }
        }
        rz_list_free(maps);
        return true;
    }
    return false;
}

References rz_io_t::desc, rz_io_desc_t::fd, rz_io_map_t::id, rz_io_map_t::itv, maps(), rz_io_desc_resize(), rz_io_fd_size(), rz_io_map_get_for_fd(), rz_io_map_resize(), rz_list_free(), rz_interval_t::size, and ut64().

Referenced by file_resize(), and rz_io_extend_at().

rz_io_seek()

RZ_API ut64 rz_io_seek	(	RzIO *	io,
		ut64	offset,
		int	whence
	)

Definition at line 632 of file io.c.

                                                          {
    if (!io) {
        return 0LL;
    }
    switch (whence) {
    case RZ_IO_SEEK_SET:
        io->off = offset;
        break;
    case RZ_IO_SEEK_CUR:
        io->off += offset;
        break;
    case RZ_IO_SEEK_END:
    default:
        io->off = rz_io_desc_seek(io->desc, offset, whence);
        break;
    }
    return io->off;
}

References rz_io_t::desc, rz_io_t::off, rz_io_desc_seek(), RZ_IO_SEEK_CUR, RZ_IO_SEEK_END, and RZ_IO_SEEK_SET.

Referenced by perform_mapped_file_yank(), rz_core_seek(), and rzfind_open_file().

rz_io_set_write_mask()

RZ_API bool rz_io_set_write_mask	(	RzIO *	io,
		const ut8 *	mask,
		int	len
	)

Set a mask that is used on all following write operations.

Parameters

io	Reference to RzIo instance
mask	Mask to apply
len	Number of bytes in the mask

Returns

true if the mask was correctly set, false otherwise

Definition at line 517 of file io.c.

                                                                     {
    rz_return_val_if_fail(io, false);
    rz_return_val_if_fail(mask || len == 0, false);
 
    free(io->write_mask);
    if (!mask) {
        io->write_mask = NULL;
        io->write_mask_len = 0;
        return true;
    }
    io->write_mask = (ut8 *)malloc(len);
    memcpy(io->write_mask, mask, len);
    io->write_mask_len = len;
    return true;
}

References free(), len, malloc(), mask, memcpy(), NULL, rz_return_val_if_fail, rz_io_t::write_mask, and rz_io_t::write_mask_len.

Referenced by rz_write_mask_reset_handler(), and rz_write_mask_set_handler().

rz_io_shift()

RZ_API bool rz_io_shift	(	RzIO *	io,
		ut64	start,
		ut64	end,
		st64	move
	)

Definition at line 596 of file io.c.

                                                                   {
    ut8 *buf;
    ut64 chunksize = 0x10000;
    ut64 saved_off = io->off;
    ut64 src, shiftsize = rz_num_abs(move);
    if (!shiftsize || (end - start) <= shiftsize) {
        return false;
    }
    ut64 rest = (end - start) - shiftsize;
    if (!(buf = calloc(1, chunksize + 1))) {
        return false;
    }
    if (move > 0) {
        src = end - shiftsize;
    } else {
        src = start + shiftsize;
    }
    while (rest > 0) {
        if (chunksize > rest) {
            chunksize = rest;
        }
        if (move > 0) {
            src -= chunksize;
        }
        rz_io_read_at(io, src, buf, chunksize);
        rz_io_write_at(io, src + move, buf, chunksize);
        if (move < 0) {
            src += chunksize;
        }
        rest -= chunksize;
    }
    free(buf);
    io->off = rz_io_desc_seek(io->desc, saved_off, RZ_IO_SEEK_SET);
    return true;
}

References calloc(), chunksize, rz_io_t::desc, test_evm::end, free(), rz_io_t::off, rz_io_desc_seek(), rz_io_read_at(), RZ_IO_SEEK_SET, rz_io_write_at(), rz_num_abs(), src, start, and ut64().

Referenced by file_resize().

rz_io_size()

RZ_API ut64 rz_io_size

(

RzIO *

io

)

Definition at line 399 of file io.c.

                                 {
    // TODO: rethink this, maybe not needed
    return io ? rz_io_desc_size(io->desc) : 0LL;
}

References rz_io_t::desc, and rz_io_desc_size().

Referenced by basefind_create_pointer_map(), core_search_for_xrefs_in_boundaries(), flagbar_foreach(), perform_mapped_file_yank(), rz_basefind(), rz_core_get_boundaries_prot(), rz_core_shift_block(), rz_core_visual_title(), and rzfind_open_file().

rz_io_system()

RZ_API char* rz_io_system	(	RzIO *	io,
		const char *	cmd
	)

Definition at line 411 of file io.c.

                                                     {
    if (io && io->desc && io->desc->plugin && io->desc->plugin->system && RZ_STR_ISNOTEMPTY(cmd)) {
        return io->desc->plugin->system(io, io->desc, cmd);
    }
    return NULL;
}

References cmd, rz_io_t::desc, NULL, rz_io_desc_t::plugin, RZ_STR_ISNOTEMPTY, and rz_io_plugin_t::system.

Referenced by __rap_continue(), __rap_reg_profile(), __rap_reg_read(), __rap_step(), cb_dbg_gdb_page_size(), cb_dbg_gdb_retries(), handle_ts_stmt(), rz_cmd_remote(), rz_core_cmd_subst_i(), rz_core_debug_attach(), rz_debug_select(), rz_io_bind(), and rz_io_system_run_oldhandler().

rz_io_v2p()

RZ_API ut64 rz_io_v2p	(	RzIO *	io,
		ut64	va
	)

Definition at line 541 of file io.c.

                                         {
    RzIOMap *map = rz_io_map_get(io, va);
    if (map) {
        st64 delta = va - map->itv.addr;
        return map->delta + delta;
    }
    return UT64_MAX;
}

References delta, map(), rz_io_map_get(), st64, and UT64_MAX.

Referenced by add_new_bin_string(), add_new_func_symbol(), meta_string_guess_add(), rz_cmd_help(), rz_core_meta_pascal_string_add(), and rz_io_bind().

rz_io_vread_at_mapped()

RZ_API bool rz_io_vread_at_mapped	(	RzIO *	io,
		ut64	vaddr,
		ut8 *	buf,
		int	len
	)

Definition at line 283 of file io.c.

                                                                           {
    rz_return_val_if_fail(io && buf && len > 0, false);
    if (io->ff) {
        memset(buf, io->Oxff, len);
    }
    return on_map_skyline(io, vaddr, buf, len, RZ_PERM_R, fd_read_at_wrap, false);
}

References fd_read_at_wrap(), rz_io_t::ff, len, memset(), on_map_skyline(), rz_io_t::Oxff, RZ_PERM_R, and rz_return_val_if_fail.

Referenced by rz_io_read_at().

rz_io_vwrite_at()

static bool rz_io_vwrite_at ( RzIO *  io, ut64  vaddr, const ut8 *  buf, int  len  )

static

Definition at line 291 of file io.c.

                                                                           {
    return on_map_skyline(io, vaddr, (ut8 *)buf, len, RZ_PERM_W, fd_write_at_wrap, false);
}

References fd_write_at_wrap(), len, on_map_skyline(), and RZ_PERM_W.

Referenced by rz_io_write_at().

rz_io_write()

RZ_API bool rz_io_write	(	RzIO *	io,
		const ut8 *	buf,
		int	len
	)

Definition at line 391 of file io.c.

                                                           {
    if (io && buf && len > 0 && rz_io_write_at(io, io->off, buf, len)) {
        io->off += len;
        return true;
    }
    return false;
}

References len, rz_io_t::off, and rz_io_write_at().

rz_io_write_at()

RZ_API bool rz_io_write_at	(	RzIO *	io,
		ut64	addr,
		const ut8 *	buf,
		int	len
	)

Definition at line 358 of file io.c.

                                                                         {
    int i;
    bool ret = false;
    ut8 *mybuf = (ut8 *)buf;
    rz_return_val_if_fail(io && buf && len > 0, false);
    if (io->write_mask) {
        mybuf = rz_mem_dup((void *)buf, len);
        for (i = 0; i < len; i++) {
            // TODO: this needs some love because it is not optimal.
            mybuf[i] &= io->write_mask[i % io->write_mask_len];
        }
    }
    if (io->cached & RZ_PERM_W) {
        ret = rz_io_cache_write(io, addr, mybuf, len);
    } else if (io->va) {
        ret = rz_io_vwrite_at(io, addr, mybuf, len);
    } else {
        ret = rz_io_pwrite_at(io, addr, mybuf, len) > 0;
    }
    if (buf != mybuf) {
        free(mybuf);
    }
    return ret;
}

References addr, rz_io_t::cached, free(), i, len, rz_io_cache_write(), rz_io_pwrite_at(), rz_io_vwrite_at(), rz_mem_dup(), RZ_PERM_W, rz_return_val_if_fail, rz_io_t::va, rz_io_t::write_mask, and rz_io_t::write_mask_len.

Referenced by ioMemcpy(), op_at_phys(), rz_cmd_debug_dml_handler(), rz_core_shift_block(), rz_core_visual_asm(), rz_core_visual_cmd(), rz_core_write_at(), rz_heap_write_heap_chunk(), rz_io_bind(), rz_io_cache_commit(), rz_io_cache_invalidate(), rz_io_shift(), rz_io_write(), rz_io_write_i(), rz_main_rizin(), rz_write_from_file_handler(), rz_write_from_io_xchg_handler(), rz_write_from_socket_handler(), and rzfind_open_file().

RZ_LIB_VERSION()

RZ_LIB_VERSION

(

rz_io

)