rz_io.h File Reference

#include "rz_list.h"
#include <rz_util.h>
#include <rz_bind.h>
#include "rz_vector.h"
#include "rz_skyline.h"

Go to the source code of this file.

Classes
struct	rz_io_t
struct	rz_io_desc_t
struct	RzIODescData
struct	rz_io_plugin_t
struct	rz_io_map_t
struct	rz_io_cache_t
struct	rz_io_desc_cache_t
struct	rz_event_io_write_t
struct	rz_event_io_desc_close_t
struct	rz_event_io_map_del_t
struct	rz_io_bind_t

Macros
#define	RZ_IO_SEEK_SET   0
#define	RZ_IO_SEEK_CUR   1
#define	RZ_IO_SEEK_END   2
#define	rz_io_map_get_from(map)   map->itv.addr
#define	rz_io_map_get_to(map)   (rz_itv_size(map->itv) ? rz_itv_end(map->itv) - 1 : 0)
#define	RZ_IO_DESC_CACHE_SIZE   (sizeof(ut64) * 8)
#define	rz_io_bind_init(x)   memset(&x, 0, sizeof(x))
#define	rz_io_range_new()   RZ_NEW0(RzIORange)
#define	rz_io_range_free(x)   free(x)

Typedefs
typedef struct rz_io_t	RzIO
typedef struct rz_io_desc_t	RzIODesc
typedef struct rz_io_plugin_t	RzIOPlugin
typedef struct rz_io_map_t	RzIOMap
typedef struct rz_io_cache_t	RzIOCache
typedef struct rz_io_desc_cache_t	RzIODescCache
typedef struct rz_event_io_write_t	RzEventIOWrite
typedef struct rz_event_io_desc_close_t	RzEventIODescClose
typedef struct rz_event_io_map_del_t	RzEventIOMapDel
typedef int(*	RzIOGetCurrentFd) (RzIO *io)
typedef bool(*	RzIODescUse) (RzIO *io, int fd)
typedef RzIODesc *(*	RzIODescGet) (RzIO *io, int fd)
typedef ut64(*	RzIODescSize) (RzIODesc *desc)
typedef RzIODesc *(*	RzIOOpen) (RzIO *io, const char *uri, int flags, int mode)
typedef RzIODesc *(*	RzIOOpenAt) (RzIO *io, const char *uri, int flags, int mode, ut64 at, RZ_NULLABLE RZ_OUT RzIOMap **map)
typedef bool(*	RzIOClose) (RzIO *io, int fd)
typedef bool(*	RzIOReadAt) (RzIO *io, ut64 addr, ut8 *buf, int len)
typedef bool(*	RzIOWriteAt) (RzIO *io, ut64 addr, const ut8 *buf, int len)
typedef char *(*	RzIOSystem) (RzIO *io, const char *cmd)
typedef int(*	RzIOFdOpen) (RzIO *io, const char *uri, int flags, int mode)
typedef bool(*	RzIOFdClose) (RzIO *io, int fd)
typedef ut64(*	RzIOFdSeek) (RzIO *io, int fd, ut64 addr, int whence)
typedef ut64(*	RzIOFdSize) (RzIO *io, int fd)
typedef bool(*	RzIOFdResize) (RzIO *io, int fd, ut64 newsize)
typedef ut64(*	RzIOP2V) (RzIO *io, ut64 pa)
typedef ut64(*	RzIOV2P) (RzIO *io, ut64 va)
typedef int(*	RzIOFdRead) (RzIO *io, int fd, ut8 *buf, int len)
typedef int(*	RzIOFdWrite) (RzIO *io, int fd, const ut8 *buf, int len)
typedef int(*	RzIOFdReadAt) (RzIO *io, int fd, ut64 addr, ut8 *buf, int len)
typedef int(*	RzIOFdWriteAt) (RzIO *io, int fd, ut64 addr, const ut8 *buf, int len)
typedef bool(*	RzIOFdIsDbg) (RzIO *io, int fd)
typedef const char *(*	RzIOFdGetName) (RzIO *io, int fd)
typedef RzList *(*	RzIOFdGetMap) (RzIO *io, int fd)
typedef bool(*	RzIOFdRemap) (RzIO *io, int fd, ut64 addr)
typedef ut8 *(*	RzIOFdGetBuf) (RzIO *io, int fd, ut64 *size)
typedef bool(*	RzIOIsValidOff) (RzIO *io, ut64 addr, int hasperm)
typedef RzIOMap *(*	RzIOMapGet) (RzIO *io, ut64 addr)
typedef RzIOMap *(*	RzIOMapGetPaddr) (RzIO *io, ut64 paddr)
typedef bool(*	RzIOAddrIsMapped) (RzIO *io, ut64 addr)
typedef RzIOMap *(*	RzIOMapAdd) (RzIO *io, int fd, int flags, ut64 delta, ut64 addr, ut64 size)
typedef struct rz_io_bind_t	RzIOBind

Functions
	RZ_LIB_VERSION_HEADER (rz_io)
RZ_API RzIOMap *	rz_io_map_new (RzIO *io, int fd, int flags, ut64 delta, ut64 addr, ut64 size)
RZ_API void	rz_io_map_init (RzIO *io)
RZ_API bool	rz_io_map_remap (RzIO *io, ut32 id, ut64 addr)
RZ_API bool	rz_io_map_remap_fd (RzIO *io, int fd, ut64 addr)
RZ_API ut64	rz_io_map_location (RzIO *io, ut64 size)
	Returns a memory location that can hold enough bytes without overlapping. More...
RZ_API bool	rz_io_map_exists (RzIO *io, RzIOMap *map)
RZ_API bool	rz_io_map_exists_for_id (RzIO *io, ut32 id)
RZ_API RzIOMap *	rz_io_map_resolve (RzIO *io, ut32 id)
RZ_API RzIOMap *	rz_io_map_add (RzIO *io, int fd, int flags, ut64 delta, ut64 addr, ut64 size)
RZ_API RzIOMap *	rz_io_map_add_batch (RzIO *io, int fd, int flags, ut64 delta, ut64 addr, ut64 size)
RZ_API RzIOMap *	rz_io_map_get (RzIO *io, ut64 addr)
RZ_API void	rz_io_update (RzIO *io)
RZ_API bool	rz_io_map_is_mapped (RzIO *io, ut64 addr)
RZ_API RzIOMap *	rz_io_map_get_paddr (RzIO *io, ut64 paddr)
RZ_API void	rz_io_map_reset (RzIO *io)
RZ_API bool	rz_io_map_del (RzIO *io, ut32 id)
RZ_API bool	rz_io_map_del_for_fd (RzIO *io, int fd)
RZ_API bool	rz_io_map_depriorize (RzIO *io, ut32 id)
RZ_API bool	rz_io_map_priorize (RzIO *io, ut32 id)
RZ_API bool	rz_io_map_priorize_for_fd (RzIO *io, int fd)
RZ_API void	rz_io_map_cleanup (RzIO *io)
RZ_API void	rz_io_map_fini (RzIO *io)
RZ_API void	rz_io_map_set_name (RzIOMap *map, const char *name)
RZ_API void	rz_io_map_del_name (RzIOMap *map)
RZ_API RzList *	rz_io_map_get_for_fd (RzIO *io, int fd)
RZ_API bool	rz_io_map_resize (RzIO *io, ut32 id, ut64 newsize)
RZ_API RZ_BORROW RzPVector *	rz_io_maps (RzIO *io)
	Returns the pointer to vector containing maps list. More...
RZ_API ut64	rz_io_map_next_available (RzIO *io, ut64 addr, ut64 size, ut64 load_align)
RZ_API ut64	rz_io_map_next_address (RzIO *io, ut64 addr)
RZ_API ut64	rz_io_p2v (RzIO *io, ut64 pa)
RZ_API ut64	rz_io_v2p (RzIO *io, ut64 va)
RZ_API RzIO *	rz_io_new (void)
RZ_API RzIO *	rz_io_init (RzIO *io)
RZ_API RzIODesc *	rz_io_open_nomap (RzIO *io, const char *uri, int flags, int mode)
RZ_API RzIODesc *	rz_io_open (RzIO *io, const char *uri, int flags, int mode)
RZ_API RzIODesc *	rz_io_open_at (RzIO *io, const char *uri, int flags, 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 flags, int mode)
RZ_API RzIODesc *	rz_io_open_buffer (RzIO *io, RzBuffer *b, int flags, int mode)
RZ_API bool	rz_io_close (RzIO *io)
RZ_API bool	rz_io_reopen (RzIO *io, int fd, int flags, 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)
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_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 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)
RZ_API void	rz_io_free (RzIO *io)
RZ_API bool	rz_io_plugin_init (RzIO *io)
RZ_API bool	rz_io_plugin_add (RzIO *io, RZ_BORROW RzIOPlugin *plugin)
RZ_API int	rz_io_plugin_read (RzIODesc *desc, ut8 *buf, int len)
RZ_API int	rz_io_plugin_write (RzIODesc *desc, const ut8 *buf, int len)
RZ_API int	rz_io_plugin_read_at (RzIODesc *desc, ut64 addr, ut8 *buf, int len)
RZ_API int	rz_io_plugin_write_at (RzIODesc *desc, ut64 addr, const ut8 *buf, int len)
RZ_API RzIOPlugin *	rz_io_plugin_resolve (RzIO *io, const char *filename, bool many)
RZ_API RzIOPlugin *	rz_io_plugin_get_default (RzIO *io, const char *filename, bool many)
RZ_API RzIODesc *	rz_io_desc_new (RzIO *io, RzIOPlugin *plugin, const char *uri, int flags, int mode, void *data)
RZ_API RzIODesc *	rz_io_desc_open (RzIO *io, const char *uri, int flags, int mode)
RZ_API RzIODesc *	rz_io_desc_open_plugin (RzIO *io, RzIOPlugin *plugin, const char *uri, int flags, int mode)
RZ_API bool	rz_io_desc_close (RzIODesc *desc)
RZ_API int	rz_io_desc_read (RzIODesc *desc, ut8 *buf, int count)
RZ_API int	rz_io_desc_write (RzIODesc *desc, const ut8 *buf, int count)
RZ_API void	rz_io_desc_free (RzIODesc *desc)
RZ_API bool	rz_io_desc_add (RzIO *io, RzIODesc *desc)
RZ_API bool	rz_io_desc_del (RzIO *io, int fd)
RZ_API RzIODesc *	rz_io_desc_get (RzIO *io, int fd)
RZ_API ut64	rz_io_desc_seek (RzIODesc *desc, ut64 offset, int whence)
RZ_API bool	rz_io_desc_resize (RzIODesc *desc, ut64 newsize)
RZ_API ut64	rz_io_desc_size (RzIODesc *desc)
RZ_API ut8 *	rz_io_desc_get_buf (RzIODesc *desc, RZ_OUT RZ_NONNULL ut64 *size)
	Returns the underlying buffer of the io descriptor. More...
RZ_API bool	rz_io_desc_is_blockdevice (RzIODesc *desc)
RZ_API bool	rz_io_desc_is_chardevice (RzIODesc *desc)
RZ_API bool	rz_io_desc_exchange (RzIO *io, int fd, int fdx)
RZ_API bool	rz_io_desc_is_dbg (RzIODesc *desc)
RZ_API int	rz_io_desc_get_pid (RzIODesc *desc)
RZ_API int	rz_io_desc_get_tid (RzIODesc *desc)
RZ_API bool	rz_io_desc_get_base (RzIODesc *desc, ut64 *base)
RZ_API int	rz_io_desc_read_at (RzIODesc *desc, ut64 addr, ut8 *buf, int len)
RZ_API int	rz_io_desc_write_at (RzIODesc *desc, ut64 addr, const ut8 *buf, int len)
RZ_IPI bool	rz_io_desc_init (RzIO *io)
RZ_IPI bool	rz_io_desc_fini (RzIO *io)
RZ_API int	rz_io_cache_invalidate (RzIO *io, ut64 from, ut64 to)
RZ_API bool	rz_io_cache_at (RzIO *io, ut64 addr)
RZ_API void	rz_io_cache_commit (RzIO *io, ut64 from, ut64 to)
RZ_API void	rz_io_cache_init (RzIO *io)
RZ_API void	rz_io_cache_fini (RzIO *io)
RZ_API void	rz_io_cache_reset (RzIO *io, int set)
RZ_API bool	rz_io_cache_write (RzIO *io, ut64 addr, const ut8 *buf, int len)
RZ_API bool	rz_io_cache_read (RzIO *io, ut64 addr, ut8 *buf, int len)
RZ_API bool	rz_io_desc_cache_init (RzIODesc *desc)
RZ_API int	rz_io_desc_cache_write (RzIODesc *desc, ut64 paddr, const ut8 *buf, int len)
RZ_API int	rz_io_desc_cache_read (RzIODesc *desc, ut64 paddr, ut8 *buf, int len)
RZ_API bool	rz_io_desc_cache_commit (RzIODesc *desc)
RZ_API void	rz_io_desc_cache_cleanup (RzIODesc *desc)
RZ_API void	rz_io_desc_cache_fini (RzIODesc *desc)
RZ_API void	rz_io_desc_cache_fini_all (RzIO *io)
RZ_API RzList *	rz_io_desc_cache_list (RzIODesc *desc)
RZ_API int	rz_io_fd_open (RzIO *io, const char *uri, int flags, int mode)
RZ_API bool	rz_io_fd_close (RzIO *io, int fd)
RZ_API int	rz_io_fd_read (RzIO *io, int fd, ut8 *buf, int len)
RZ_API int	rz_io_fd_write (RzIO *io, int fd, const ut8 *buf, int len)
RZ_API ut64	rz_io_fd_seek (RzIO *io, int fd, ut64 addr, int whence)
RZ_API ut64	rz_io_fd_size (RzIO *io, int fd)
RZ_API ut8 *	rz_io_fd_get_buf (RzIO *io, int fd, RZ_OUT RZ_NONNULL ut64 *size)
	Returns the underlying buffer of the file descriptor. More...
RZ_API bool	rz_io_fd_resize (RzIO *io, int fd, ut64 newsize)
RZ_API bool	rz_io_fd_is_blockdevice (RzIO *io, int fd)
RZ_API bool	rz_io_fd_is_chardevice (RzIO *io, int fd)
RZ_API int	rz_io_fd_read_at (RzIO *io, int fd, ut64 addr, ut8 *buf, int len)
RZ_API int	rz_io_fd_write_at (RzIO *io, int fd, ut64 addr, const ut8 *buf, int len)
RZ_API bool	rz_io_fd_is_dbg (RzIO *io, int fd)
RZ_API int	rz_io_fd_get_pid (RzIO *io, int fd)
RZ_API int	rz_io_fd_get_tid (RzIO *io, int fd)
RZ_API bool	rz_io_fd_get_base (RzIO *io, int fd, ut64 *base)
RZ_API const char *	rz_io_fd_get_name (RzIO *io, int fd)
RZ_API int	rz_io_fd_get_current (RzIO *io)
RZ_API int	rz_io_fd_get_next (RzIO *io, int fd)
RZ_API int	rz_io_fd_get_prev (RzIO *io, int fd)
RZ_API int	rz_io_fd_get_highest (RzIO *io)
RZ_API int	rz_io_fd_get_lowest (RzIO *io)
RZ_API bool	rz_io_use_fd (RzIO *io, int fd)
RZ_API bool	rz_io_is_valid_offset (RzIO *io, ut64 offset, int hasperm)
RZ_API bool	rz_io_addr_is_mapped (RzIO *io, ut64 vaddr)
RZ_API bool	rz_io_read_i (RzIO *io, ut64 addr, ut64 *val, int size, bool endian)
RZ_API bool	rz_io_write_i (RzIO *io, ut64 addr, ut64 *val, int size, bool endian)

Variables
RzIOPlugin	rz_io_plugin_procpid
RzIOPlugin	rz_io_plugin_malloc
RzIOPlugin	rz_io_plugin_sparse
RzIOPlugin	rz_io_plugin_ptrace
RzIOPlugin	rz_io_plugin_w32dbg
RzIOPlugin	rz_io_plugin_windbg
RzIOPlugin	rz_io_plugin_mach
RzIOPlugin	rz_io_plugin_debug
RzIOPlugin	rz_io_plugin_dmp
RzIOPlugin	rz_io_plugin_shm
RzIOPlugin	rz_io_plugin_gdb
RzIOPlugin	rz_io_plugin_rap
RzIOPlugin	rz_io_plugin_http
RzIOPlugin	rz_io_plugin_bfdbg
RzIOPlugin	rz_io_plugin_w32
RzIOPlugin	rz_io_plugin_zip
RzIOPlugin	rz_io_plugin_default
RzIOPlugin	rz_io_plugin_ihex
RzIOPlugin	rz_io_plugin_srec
RzIOPlugin	rz_io_plugin_self
RzIOPlugin	rz_io_plugin_gzip
RzIOPlugin	rz_io_plugin_winkd
RzIOPlugin	rz_io_plugin_rzpipe
RzIOPlugin	rz_io_plugin_rzweb
RzIOPlugin	rz_io_plugin_qnx
RzIOPlugin	rz_io_plugin_rzk
RzIOPlugin	rz_io_plugin_tcp
RzIOPlugin	rz_io_plugin_bochs
RzIOPlugin	rz_io_plugin_null
RzIOPlugin	rz_io_plugin_ar
RzIOPlugin	rz_io_plugin_winedbg
RzIOPlugin	rz_io_plugin_gprobe
RzIOPlugin	rz_io_plugin_fd

Macro Definition Documentation

rz_io_bind_init

#define rz_io_bind_init

(

x

)

memset(&x, 0, sizeof(x))

Definition at line 344 of file rz_io.h.

RZ_IO_DESC_CACHE_SIZE

#define RZ_IO_DESC_CACHE_SIZE   (sizeof(ut64) * 8)

Definition at line 169 of file rz_io.h.

rz_io_map_get_from

#define rz_io_map_get_from

(

map

)

map->itv.addr

Definition at line 19 of file rz_io.h.

rz_io_map_get_to

#define rz_io_map_get_to

(

map

)

(rz_itv_size(map->itv) ? rz_itv_end(map->itv) - 1 : 0)

Definition at line 20 of file rz_io.h.

rz_io_range_free

#define rz_io_range_free

(

x

)

free(x)

Definition at line 430 of file rz_io.h.

rz_io_range_new

#define rz_io_range_new

(

)

RZ_NEW0(RzIORange)

Definition at line 429 of file rz_io.h.

RZ_IO_SEEK_CUR

#define RZ_IO_SEEK_CUR   1

Definition at line 16 of file rz_io.h.

RZ_IO_SEEK_END

#define RZ_IO_SEEK_END   2

Definition at line 17 of file rz_io.h.

RZ_IO_SEEK_SET

#define RZ_IO_SEEK_SET   0

Definition at line 15 of file rz_io.h.

Typedef Documentation

RzEventIODescClose

typedef struct rz_event_io_desc_close_t RzEventIODescClose

RzEventIOMapDel

typedef struct rz_event_io_map_del_t RzEventIOMapDel

RzEventIOWrite

typedef struct rz_event_io_write_t RzEventIOWrite

RzIO

typedef struct rz_io_t RzIO

RzIOAddrIsMapped

typedef bool(* RzIOAddrIsMapped) (RzIO *io, ut64 addr)

Definition at line 220 of file rz_io.h.

RzIOBind

typedef struct rz_io_bind_t RzIOBind

RzIOCache

typedef struct rz_io_cache_t RzIOCache

RzIOClose

typedef bool(* RzIOClose) (RzIO *io, int fd)

Definition at line 197 of file rz_io.h.

RzIODesc

typedef struct rz_io_desc_t RzIODesc

RzIODescCache

typedef struct rz_io_desc_cache_t RzIODescCache

RzIODescGet

typedef RzIODesc*(* RzIODescGet) (RzIO *io, int fd)

Definition at line 193 of file rz_io.h.

RzIODescSize

typedef ut64(* RzIODescSize) (RzIODesc *desc)

Definition at line 194 of file rz_io.h.

RzIODescUse

typedef bool(* RzIODescUse) (RzIO *io, int fd)

Definition at line 192 of file rz_io.h.

RzIOFdClose

typedef bool(* RzIOFdClose) (RzIO *io, int fd)

Definition at line 202 of file rz_io.h.

RzIOFdGetBuf

typedef ut8*(* RzIOFdGetBuf) (RzIO *io, int fd, ut64 *size)

Definition at line 216 of file rz_io.h.

RzIOFdGetMap

typedef RzList*(* RzIOFdGetMap) (RzIO *io, int fd)

Definition at line 214 of file rz_io.h.

RzIOFdGetName

typedef const char*(* RzIOFdGetName) (RzIO *io, int fd)

Definition at line 213 of file rz_io.h.

RzIOFdIsDbg

typedef bool(* RzIOFdIsDbg) (RzIO *io, int fd)

Definition at line 212 of file rz_io.h.

RzIOFdOpen

typedef int(* RzIOFdOpen) (RzIO *io, const char *uri, int flags, int mode)

Definition at line 201 of file rz_io.h.

RzIOFdRead

typedef int(* RzIOFdRead) (RzIO *io, int fd, ut8 *buf, int len)

Definition at line 208 of file rz_io.h.

RzIOFdReadAt

typedef int(* RzIOFdReadAt) (RzIO *io, int fd, ut64 addr, ut8 *buf, int len)

Definition at line 210 of file rz_io.h.

RzIOFdRemap

typedef bool(* RzIOFdRemap) (RzIO *io, int fd, ut64 addr)

Definition at line 215 of file rz_io.h.

RzIOFdResize

typedef bool(* RzIOFdResize) (RzIO *io, int fd, ut64 newsize)

Definition at line 205 of file rz_io.h.

RzIOFdSeek

typedef ut64(* RzIOFdSeek) (RzIO *io, int fd, ut64 addr, int whence)

Definition at line 203 of file rz_io.h.

RzIOFdSize

typedef ut64(* RzIOFdSize) (RzIO *io, int fd)

Definition at line 204 of file rz_io.h.

RzIOFdWrite

typedef int(* RzIOFdWrite) (RzIO *io, int fd, const ut8 *buf, int len)

Definition at line 209 of file rz_io.h.

RzIOFdWriteAt

typedef int(* RzIOFdWriteAt) (RzIO *io, int fd, ut64 addr, const ut8 *buf, int len)

Definition at line 211 of file rz_io.h.

RzIOGetCurrentFd

typedef int(* RzIOGetCurrentFd) (RzIO *io)

Definition at line 191 of file rz_io.h.

RzIOIsValidOff

typedef bool(* RzIOIsValidOff) (RzIO *io, ut64 addr, int hasperm)

Definition at line 217 of file rz_io.h.

RzIOMap

typedef struct rz_io_map_t RzIOMap

RzIOMapAdd

typedef RzIOMap*(* RzIOMapAdd) (RzIO *io, int fd, int flags, ut64 delta, ut64 addr, ut64 size)

Definition at line 221 of file rz_io.h.

RzIOMapGet

typedef RzIOMap*(* RzIOMapGet) (RzIO *io, ut64 addr)

Definition at line 218 of file rz_io.h.

RzIOMapGetPaddr

typedef RzIOMap*(* RzIOMapGetPaddr) (RzIO *io, ut64 paddr)

Definition at line 219 of file rz_io.h.

RzIOOpen

typedef RzIODesc*(* RzIOOpen) (RzIO *io, const char *uri, int flags, int mode)

Definition at line 195 of file rz_io.h.

RzIOOpenAt

typedef RzIODesc*(* RzIOOpenAt) (RzIO *io, const char *uri, int flags, int mode, ut64 at, RZ_NULLABLE RZ_OUT RzIOMap **map)

Definition at line 196 of file rz_io.h.

RzIOP2V

typedef ut64(* RzIOP2V) (RzIO *io, ut64 pa)

Definition at line 206 of file rz_io.h.

RzIOPlugin

typedef struct rz_io_plugin_t RzIOPlugin

RzIOReadAt

typedef bool(* RzIOReadAt) (RzIO *io, ut64 addr, ut8 *buf, int len)

Definition at line 198 of file rz_io.h.

RzIOSystem

typedef char*(* RzIOSystem) (RzIO *io, const char *cmd)

Definition at line 200 of file rz_io.h.

RzIOV2P

typedef ut64(* RzIOV2P) (RzIO *io, ut64 va)

Definition at line 207 of file rz_io.h.

RzIOWriteAt

typedef bool(* RzIOWriteAt) (RzIO *io, ut64 addr, const ut8 *buf, int len)

Definition at line 199 of file rz_io.h.

Function Documentation

rz_io_addr_is_mapped()

RZ_API bool rz_io_addr_is_mapped	(	RzIO *	io,
		ut64	vaddr
	)

Definition at line 11 of file ioutils.c.

                                                       {
    rz_return_val_if_fail(io, false);
    return (io->va && rz_io_map_get(io, vaddr));
}

References rz_io_map_get(), rz_return_val_if_fail, and rz_io_t::va.

Referenced by rz_io_bind().

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

RZ_API bool rz_io_cache_at	(	RzIO *	io,
		ut64	addr
	)

Definition at line 16 of file io_cache.c.

                                                {
    rz_return_val_if_fail(io, false);
    return rz_skyline_contains(&io->cache_skyline, addr);
}

References addr, rz_io_t::cache_skyline, rz_return_val_if_fail, and rz_skyline_contains().

Referenced by rz_io_desc_read().

rz_io_cache_commit()

RZ_API void rz_io_cache_commit	(	RzIO *	io,
		ut64	from,
		ut64	to
	)

Definition at line 35 of file io_cache.c.

                                                             {
    void **iter;
    RzIOCache *c;
    RzInterval range = (RzInterval){ from, to - from };
    rz_return_if_fail(io);
    rz_pvector_foreach (&io->cache, iter) {
        // if (from <= c->to - 1 && c->from <= to - 1) {
        c = *iter;
        if (rz_itv_overlap(c->itv, range)) {
            int cached = io->cached;
            io->cached = 0;
            if (rz_io_write_at(io, rz_itv_begin(c->itv), c->data, rz_itv_size(c->itv))) {
                c->written = true;
            } else {
                eprintf("Error writing change at 0x%08" PFMT64x "\n", rz_itv_begin(c->itv));
            }
            io->cached = cached;
            // break; // XXX old behavior, revisit this
        }
    }
}

References c, rz_io_t::cache, rz_io_t::cached, eprintf, from, PFMT64x, capstone::range, rz_io_write_at(), rz_itv_begin(), rz_itv_overlap(), rz_itv_size(), rz_pvector_foreach, rz_return_if_fail, and to.

Referenced by rz_write_cache_commit_all_handler(), and rz_write_cache_commit_handler().

rz_io_cache_fini()

RZ_API void rz_io_cache_fini

(

RzIO *

io

)

Definition at line 28 of file io_cache.c.

                                       {
    rz_return_if_fail(io);
    rz_pvector_fini(&io->cache);
    rz_skyline_fini(&io->cache_skyline);
    io->cached = 0;
}

References rz_io_t::cache, rz_io_t::cache_skyline, rz_io_t::cached, rz_pvector_fini(), rz_return_if_fail, and rz_skyline_fini().

Referenced by rz_core_disasm_pde(), rz_io_close_all(), and rz_io_fini().

rz_io_cache_init()

RZ_API void rz_io_cache_init

(

RzIO *

io

)

Definition at line 21 of file io_cache.c.

                                       {
    rz_return_if_fail(io);
    rz_pvector_init(&io->cache, (RzPVectorFree)cache_item_free);
    rz_skyline_init(&io->cache_skyline);
    io->cached = 0;
}

References rz_io_t::cache, cache_item_free(), rz_io_t::cache_skyline, rz_io_t::cached, rz_pvector_init(), rz_return_if_fail, and rz_skyline_init().

Referenced by rz_core_disasm_pde(), and rz_io_init().

rz_io_cache_invalidate()

RZ_API int rz_io_cache_invalidate	(	RzIO *	io,
		ut64	from,
		ut64	to
	)

Definition at line 64 of file io_cache.c.

                                                                {
    rz_return_val_if_fail(io, 0);
    int invalidated = 0;
    void **iter;
    RzIOCache *c;
    RzInterval range = (RzInterval){ from, to - from };
    rz_pvector_foreach_prev(&io->cache, iter) {
        c = *iter;
        if (rz_itv_overlap(c->itv, range)) {
            int cached = io->cached;
            io->cached = 0;
            rz_io_write_at(io, rz_itv_begin(c->itv), c->odata, rz_itv_size(c->itv));
            io->cached = cached;
            c->written = false;
            rz_pvector_remove_data(&io->cache, c);
            free(c->data);
            free(c->odata);
            free(c);
            invalidated++;
        }
    }
    rz_skyline_clear(&io->cache_skyline);
    rz_pvector_foreach (&io->cache, iter) {
        c = *iter;
        rz_skyline_add(&io->cache_skyline, c->itv, c);
    }
    return invalidated;
}

References c, rz_io_t::cache, rz_io_t::cache_skyline, rz_io_t::cached, free(), from, capstone::range, rz_io_write_at(), rz_itv_begin(), rz_itv_overlap(), rz_itv_size(), rz_pvector_foreach, rz_pvector_foreach_prev, rz_pvector_remove_data(), rz_return_val_if_fail, rz_skyline_add(), rz_skyline_clear(), and to.

Referenced by rz_write_cache_remove_handler().

rz_io_cache_read()

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

Definition at line 131 of file io_cache.c.

                                                                     {
    rz_return_val_if_fail(io && buf, false);
    RzSkyline *skyline = &io->cache_skyline;
    if (!len) {
        return true;
    }
    if (UT64_ADD_OVFCHK(addr, len)) {
        const ut64 first_len = UT64_MAX - addr;
        rz_io_cache_read(io, 0, buf + first_len, len - first_len);
        len = first_len;
    }
    const RzSkylineItem *iter = rz_skyline_get_item_intersect(skyline, addr, len);
    if (!iter) {
        return false;
    }
    const RzSkylineItem *last = (RzSkylineItem *)skyline->v.a + skyline->v.len;
    bool covered = false;
    while (iter != last) {
        const ut64 begin = rz_itv_begin(iter->itv);
        const st64 addr_offset = begin - addr;
        const ut64 buf_offset = addr_offset > 0 ? addr_offset : 0;
        const ut64 cur_addr = addr + buf_offset;
        const ut64 left = len - buf_offset;
        if (begin > cur_addr + left) {
            break;
        }
        RzIOCache *cache = iter->user;
        const ut64 cache_shift = addr_offset < 0 ? -addr_offset : 0;
        const ut64 cache_offset = begin - rz_itv_begin(cache->itv) + cache_shift;
        const ut64 read = RZ_MIN(left, rz_itv_size(iter->itv) - cache_shift);
        memcpy(buf + buf_offset, cache->data + cache_offset, read);
        covered = true;
        if (left - read <= 0) {
            break;
        }
        iter++;
    }
    return covered;
}

References rz_vector_t::a, addr, rz_io_t::cache_skyline, rz_io_cache_t::data, rz_io_cache_t::itv, len, rz_vector_t::len, memcpy(), read(), rz_io_cache_read(), rz_itv_begin(), rz_itv_size(), RZ_MIN, rz_return_val_if_fail, rz_skyline_get_item_intersect(), st64, ut64(), UT64_ADD_OVFCHK, UT64_MAX, rz_skyline_t::v, and while().

Referenced by rz_io_cache_read(), rz_io_desc_read(), rz_io_nread_at(), rz_io_read_at(), and rz_io_read_at_mapped().

rz_io_cache_reset()

RZ_API void rz_io_cache_reset	(	RzIO *	io,
		int	set
	)

Definition at line 57 of file io_cache.c.

                                                 {
    rz_return_if_fail(io);
    io->cached = set;
    rz_pvector_clear(&io->cache);
    rz_skyline_clear(&io->cache_skyline);
}

References rz_io_t::cache, rz_io_t::cache_skyline, rz_io_t::cached, rz_pvector_clear(), rz_return_if_fail, and rz_skyline_clear().

Referenced by rz_core_link_stroff(), and rz_write_cache_remove_all_handler().

rz_io_cache_write()

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

Definition at line 93 of file io_cache.c.

                                                                            {
    rz_return_val_if_fail(io && buf, false);
    RzIOCache *ch = RZ_NEW0(RzIOCache);
    if (!ch) {
        return false;
    }
    if (UT64_ADD_OVFCHK(addr, len)) {
        const ut64 first_len = UT64_MAX - addr;
        rz_io_cache_write(io, 0, buf + first_len, len - first_len);
        len = first_len;
    }
    ch->itv = (RzInterval){ addr, len };
    ch->odata = (ut8 *)calloc(1, len + 1);
    if (!ch->odata) {
        free(ch);
        return false;
    }
    ch->data = (ut8 *)calloc(1, len + 1);
    if (!ch->data) {
        free(ch->odata);
        free(ch);
        return false;
    }
    ch->written = false;
    {
        const bool cm = io->cachemode;
        io->cachemode = false;
        rz_io_read_at(io, addr, ch->odata, len);
        io->cachemode = cm;
    }
    memcpy(ch->data, buf, len);
    rz_pvector_push(&io->cache, ch);
    rz_skyline_add(&io->cache_skyline, ch->itv, ch);
    RzEventIOWrite iow = { addr, buf, len };
    rz_event_send(io->event, RZ_EVENT_IO_WRITE, &iow);
    return true;
}

References addr, rz_io_t::cache, rz_io_t::cache_skyline, rz_io_t::cachemode, calloc(), rz_io_cache_t::data, rz_io_t::event, free(), rz_io_cache_t::itv, len, memcpy(), rz_io_cache_t::odata, RZ_EVENT_IO_WRITE, rz_event_send(), rz_io_cache_write(), rz_io_read_at(), RZ_NEW0, rz_pvector_push(), rz_return_val_if_fail, rz_skyline_add(), ut64(), UT64_ADD_OVFCHK, UT64_MAX, and rz_io_cache_t::written.

Referenced by rz_io_cache_write(), rz_io_desc_read(), and rz_io_write_at().

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

RZ_API bool rz_io_desc_add	(	RzIO *	io,
		RzIODesc *	desc
	)

Definition at line 49 of file io_desc.c.

                                                     {
    rz_return_val_if_fail(io && desc && desc->io, false);
    if (!rz_id_storage_set(io->files, desc, desc->fd)) {
        // TODO: use assert here
        eprintf("You are using this API incorrectly\n");
        eprintf("fd %d was probably not generated by this RzIO-instance\n", desc->fd);
        rz_sys_backtrace();
        return false;
    }
    return true;
}

References desc, eprintf, rz_io_t::files, rz_id_storage_set(), rz_return_val_if_fail, and rz_sys_backtrace().

Referenced by find_apk_binary(), rz_core_file_open_many(), rz_io_desc_open(), rz_io_desc_open_plugin(), and rz_io_open_many().

rz_io_desc_cache_cleanup()

RZ_API void rz_io_desc_cache_cleanup

(

RzIODesc *

desc

)

Definition at line 343 of file p_cache.c.

                                                     {
    if (desc && desc->cache) {
        ht_up_foreach(desc->cache, __desc_cache_cleanup_cb, desc);
    }
}

References __desc_cache_cleanup_cb(), and desc.

Referenced by rz_io_desc_exchange(), and rz_io_desc_resize().

rz_io_desc_cache_commit()

RZ_API bool rz_io_desc_cache_commit

(

RzIODesc *

desc

)

Definition at line 302 of file p_cache.c.

                                                    {
    RzIODesc *current;
    if (!desc || !(desc->perm & RZ_PERM_W) || !desc->io || !desc->io->files || !desc->io->p_cache) {
        return false;
    }
    if (!desc->cache) {
        return true;
    }
    current = desc->io->desc;
    desc->io->desc = desc;
    desc->io->p_cache = false;
    ht_up_foreach(desc->cache, __desc_cache_commit_cb, desc);
    ht_up_free(desc->cache);
    desc->cache = NULL;
    desc->io->p_cache = true;
    desc->io->desc = current;
    return true;
}

References __desc_cache_commit_cb(), desc, NULL, and RZ_PERM_W.

Referenced by rz_write_pcache_commit_handler().

rz_io_desc_cache_fini()

RZ_API void rz_io_desc_cache_fini

(

RzIODesc *

desc

)

Definition at line 358 of file p_cache.c.

                                                  {
    __desc_fini_cb(NULL, (void *)desc, 0);
}

References __desc_fini_cb(), desc, and NULL.

Referenced by rz_io_desc_free().

rz_io_desc_cache_fini_all()

RZ_API void rz_io_desc_cache_fini_all

(

RzIO *

io

)

Definition at line 362 of file p_cache.c.

                                                {
    if (io && io->files) {
        rz_id_storage_foreach(io->files, __desc_fini_cb, NULL);
    }
}

References __desc_fini_cb(), rz_io_t::files, NULL, and rz_id_storage_foreach().

Referenced by cb_iopcache(), cb_iopcacheread(), cb_iopcachewrite(), and rz_io_fini().

rz_io_desc_cache_init()

RZ_API bool rz_io_desc_cache_init

(

RzIODesc *

desc

)

Definition at line 79 of file p_cache.c.

                                                  {
    if (!desc || desc->cache) {
        return false;
    }
    return (desc->cache = ht_up_new(NULL, pcache_kv_free, NULL)) ? true : false;
}

References desc, NULL, pcache_kv_free(), and true.

Referenced by rz_io_desc_cache_write().

rz_io_desc_cache_list()

RZ_API RzList* rz_io_desc_cache_list

(

RzIODesc *

desc

)

Definition at line 249 of file p_cache.c.

                                                     {
    if (!desc || !desc->io || !desc->io->desc || !desc->io->p_cache || !desc->cache) {
        return NULL;
    }
    RzList *writes = rz_list_newf((RzListFree)__riocache_free);
    if (!writes) {
        return NULL;
    }
    ht_up_foreach(desc->cache, __desc_cache_list_cb, writes);
    RzIODesc *current = desc->io->desc;
    desc->io->desc = desc;
    desc->io->p_cache = false;
 
    RzIOCache *c;
    RzListIter *iter;
    rz_list_foreach (writes, iter, c) {
        const ut64 itvSize = rz_itv_size(c->itv);
        c->odata = calloc(1, itvSize);
        if (!c->odata) {
            rz_list_free(writes);
            return NULL;
        }
        rz_io_pread_at(desc->io, rz_itv_begin(c->itv), c->odata, itvSize);
    }
    desc->io->p_cache = true;
    desc->io->desc = current;
    return writes;
}

References __desc_cache_list_cb(), __riocache_free(), c, calloc(), desc, NULL, rz_io_pread_at(), rz_itv_begin(), rz_itv_size(), rz_list_free(), rz_list_newf(), and ut64().

Referenced by rz_core_io_pcache_print().

rz_io_desc_cache_read()

RZ_API int rz_io_desc_cache_read	(	RzIODesc *	desc,
		ut64	paddr,
		ut8 *	buf,
		int	len
	)

Definition at line 142 of file p_cache.c.

                                                                                {
    RzIODescCache *cache;
    ut8 *ptr = buf;
    ut64 caddr, desc_sz = rz_io_desc_size(desc);
    int cbaddr, amount = 0;
    if ((len < 1) || !desc || (desc_sz <= paddr) || !desc->io || !desc->cache) {
        return 0;
    }
    if (len > desc_sz) {
        len = (int)desc_sz;
    }
    if (paddr > (desc_sz - len)) {
        len = (int)(desc_sz - paddr);
    }
    caddr = paddr / RZ_IO_DESC_CACHE_SIZE;
    cbaddr = paddr % RZ_IO_DESC_CACHE_SIZE;
    while (amount < len) {
        // get an existing desc-cache, if it exists
        if (!(cache = (RzIODescCache *)ht_up_find(desc->cache, caddr, NULL))) {
            amount += (RZ_IO_DESC_CACHE_SIZE - cbaddr);
            ptr += (RZ_IO_DESC_CACHE_SIZE - cbaddr);
            goto beach;
        }
        if ((len - amount) > (RZ_IO_DESC_CACHE_SIZE - cbaddr)) {
            amount += (RZ_IO_DESC_CACHE_SIZE - cbaddr);
            for (; cbaddr < RZ_IO_DESC_CACHE_SIZE; cbaddr++) {
                if (cache->cached & (0x1ULL << cbaddr)) {
                    *ptr = cache->cdata[cbaddr];
                }
                ptr++;
            }
        } else {
            do {
                if (cache->cached & (0x1ULL << cbaddr)) {
                    *ptr = cache->cdata[cbaddr];
                }
                ptr++;
                amount++;
                cbaddr++;
            } while (len > amount);
        }
    beach:
        caddr++;
        cbaddr = 0;
    }
    return amount;
}

References rz_io_desc_cache_t::cached, rz_io_desc_cache_t::cdata, desc, int, len, NULL, RZ_IO_DESC_CACHE_SIZE, rz_io_desc_size(), and ut64().

Referenced by rz_io_desc_read().

rz_io_desc_cache_write()

RZ_API int rz_io_desc_cache_write	(	RzIODesc *	desc,
		ut64	paddr,
		const ut8 *	buf,
		int	len
	)

Definition at line 86 of file p_cache.c.

                                                                                       {
    RzIODescCache *cache;
    ut64 caddr, desc_sz = rz_io_desc_size(desc);
    int cbaddr, written = 0;
    if ((len < 1) || !desc || (desc_sz <= paddr) ||
        !desc->io || (!desc->cache && !rz_io_desc_cache_init(desc))) {
        return 0;
    }
    if (len > desc_sz) {
        len = (int)desc_sz;
    }
    if (paddr > (desc_sz - len)) {
        len = (int)(desc_sz - paddr);
    }
    caddr = paddr / RZ_IO_DESC_CACHE_SIZE;
    cbaddr = paddr % RZ_IO_DESC_CACHE_SIZE;
    while (written < len) {
        // get an existing desc-cache, if it exists
        if (!(cache = (RzIODescCache *)ht_up_find(desc->cache, caddr, NULL))) {
            // create new desc-cache
            cache = RZ_NEW0(RzIODescCache);
            if (!cache) {
                return 0;
            }
            // feed ht with the new desc-cache
            ht_up_insert(desc->cache, caddr, cache);
        }
        // check if the remaining data fits into the cache
        if ((len - written) > (RZ_IO_DESC_CACHE_SIZE - cbaddr)) {
            written += (RZ_IO_DESC_CACHE_SIZE - cbaddr);
            // this can be optimized
            for (; cbaddr < RZ_IO_DESC_CACHE_SIZE; cbaddr++) {
                // write to cache
                cache->cdata[cbaddr] = *buf;
                // save, that its cached
                cache->cached |= (0x1ULL << cbaddr);
                buf++;
            }
        } else {
            // XXX this looks like very suspicious
            do {
                cache->cdata[cbaddr] = *buf;
                cache->cached |= (0x1ULL << cbaddr);
                buf++;
                written++;
                cbaddr++;
            } while (len > written);
        }
        caddr++;
        cbaddr = 0;
    }
    RzEventIOWrite iow = { paddr, buf, len };
    rz_event_send(desc->io->event, RZ_EVENT_IO_WRITE, &iow);
    return written;
}

References rz_io_desc_cache_t::cached, rz_io_desc_cache_t::cdata, desc, int, len, NULL, RZ_EVENT_IO_WRITE, rz_event_send(), rz_io_desc_cache_init(), RZ_IO_DESC_CACHE_SIZE, rz_io_desc_size(), RZ_NEW0, and ut64().

Referenced by rz_io_desc_write().

rz_io_desc_close()

RZ_API bool rz_io_desc_close

(

RzIODesc *

desc

)

Definition at line 165 of file io_desc.c.

                                             {
    if (!desc || !desc->io || !desc->plugin) {
        return false;
    }
    RzIO *io = desc->io;
    RzEventIODescClose ev = { desc };
    rz_event_send(io->event, RZ_EVENT_IO_DESC_CLOSE, &ev);
    if (desc->plugin->close && desc->plugin->close(desc)) {
        return false;
    }
    // remove entry from idstorage and free the desc-struct
    rz_io_desc_del(io, desc->fd);
    // remove all dead maps
    rz_io_map_cleanup(io);
    return true;
}

References desc, rz_io_t::event, RZ_EVENT_IO_DESC_CLOSE, rz_event_send(), rz_io_desc_del(), and rz_io_map_cleanup().

Referenced by dmp_close(), handle_tmp_desc(), hash_context_create_desc_io_stdin(), hash_context_create_desc_io_string(), hash_context_run(), io_create_mem_map(), perform_mapped_file_yank(), reopen_in_malloc_cb(), rz_core_cmd_subst_i(), rz_core_file_close(), rz_core_rtr_rap_run(), rz_core_vfile_bin_file_deleted(), rz_diff_io_close(), rz_diff_io_open(), rz_io_close(), rz_io_fd_close(), rz_io_reopen(), and rz_open_binary_file_handler().

rz_io_desc_del()

RZ_API bool rz_io_desc_del	(	RzIO *	io,
		int	fd
	)

Definition at line 61 of file io_desc.c.

                                             { // can we pass this a riodesc and check if it belongs to the desc->io ?
    rz_return_val_if_fail(io && io->files, false);
    RzIODesc *desc = rz_id_storage_get(io->files, fd);
    rz_io_desc_free(desc);
    if (desc == io->desc) {
        io->desc = NULL;
    }
    // remove all dead maps
    rz_io_map_cleanup(io);
    return true;
}

References desc, rz_io_t::desc, fd, rz_io_t::files, NULL, rz_id_storage_get(), rz_io_desc_free(), rz_io_map_cleanup(), and rz_return_val_if_fail.

Referenced by rz_io_desc_close(), and rz_io_reopen().

rz_io_desc_exchange()

RZ_API bool rz_io_desc_exchange	(	RzIO *	io,
		int	fd,
		int	fdx
	)

Definition at line 275 of file io_desc.c.

                                                           {
    RzIODesc *desc, *descx;
    if (!(desc = rz_io_desc_get(io, fd)) || !(descx = rz_io_desc_get(io, fdx))) {
        return false;
    }
    desc->fd = fdx;
    descx->fd = fd;
    rz_id_storage_set(io->files, desc, fdx);
    rz_id_storage_set(io->files, descx, fd);
    if (io->p_cache) {
        HtUP *cache = desc->cache;
        desc->cache = descx->cache;
        descx->cache = cache;
        rz_io_desc_cache_cleanup(desc);
        rz_io_desc_cache_cleanup(descx);
    }
    void **it;
    rz_pvector_foreach (&io->maps, it) {
        RzIOMap *map = *it;
        if (map->fd == fdx) {
            map->perm &= (desc->perm | RZ_PERM_X);
        } else if (map->fd == fd) {
            map->perm &= (descx->perm | RZ_PERM_X);
        }
    }
    return true;
}

References rz_io_desc_t::cache, desc, fd, rz_io_desc_t::fd, rz_io_t::files, map(), rz_io_t::maps, rz_io_t::p_cache, rz_io_desc_t::perm, rz_id_storage_set(), rz_io_desc_cache_cleanup(), rz_io_desc_get(), RZ_PERM_X, and rz_pvector_foreach.

Referenced by reopen_in_malloc_cb(), rz_io_reopen(), and rz_open_exchange_handler().

rz_io_desc_fini()

RZ_IPI bool rz_io_desc_fini

(

RzIO *

io

)

Definition at line 390 of file io_desc.c.

                                      {
    rz_return_val_if_fail(io, false);
    if (io->files) {
        rz_id_storage_foreach(io->files, desc_fini_cb, io);
        rz_id_storage_free(io->files);
        io->files = NULL;
    }
    // no map-cleanup here, to keep it modular useable
    io->desc = NULL;
    return true;
}

References rz_io_t::desc, desc_fini_cb(), rz_io_t::files, NULL, rz_id_storage_foreach(), rz_id_storage_free(), and rz_return_val_if_fail.

Referenced by rz_io_close_all(), rz_io_desc_init(), and rz_io_fini().

rz_io_desc_free()

RZ_API void rz_io_desc_free

(

RzIODesc *

desc

)

Definition at line 35 of file io_desc.c.

                                            {
    if (desc) {
        free(desc->uri);
        free(desc->referer);
        free(desc->name);
        rz_io_desc_cache_fini(desc);
        if (desc->io && desc->io->files) {
            rz_id_storage_delete(desc->io->files, desc->fd);
        }
        //      free (desc->plugin);
    }
    free(desc);
}

References desc, free(), rz_id_storage_delete(), and rz_io_desc_cache_fini().

Referenced by desc_fini_cb(), rz_core_file_open(), rz_core_file_open_many(), rz_io_desc_del(), rz_io_desc_open(), rz_io_desc_open_plugin(), and rz_io_zip_open().

rz_io_desc_get()

RZ_API RzIODesc* rz_io_desc_get	(	RzIO *	io,
		int	fd
	)

Definition at line 73 of file io_desc.c.

                                                  {
    rz_return_val_if_fail(io && io->files, NULL);
    return (RzIODesc *)rz_id_storage_get(io->files, fd);
}

References fd, rz_io_t::files, NULL, rz_id_storage_get(), and rz_return_val_if_fail.

Referenced by add_map(), basefind_new_bin_file(), core_file_do_load_for_debug(), file_save(), io_map_add(), is_valid_dmp_file(), is_valid_gdb_file(), isValidAddress(), map_multi_dex(), reopen_nobin_headers(), rz_core_bin_apply_maps(), rz_core_bin_load(), rz_core_bin_set_arch_bits(), rz_core_bin_whole_strings(), rz_core_file_binlist(), rz_core_file_close(), rz_core_file_find_by_name(), rz_core_file_info_print(), rz_core_file_open(), rz_core_file_open_load(), rz_core_file_print(), rz_core_file_reopen(), rz_core_file_reopen_debug(), rz_core_file_reopen_remote_debug(), rz_core_raw_file_print(), rz_core_rtr_gdb_cb(), rz_core_setup_debugger(), rz_core_sysenv_begin(), rz_core_visual_title(), rz_io_bind(), rz_io_desc_exchange(), rz_io_desc_get_highest(), rz_io_desc_get_lowest(), rz_io_fd_close(), rz_io_fd_get_base(), rz_io_fd_get_buf(), rz_io_fd_get_name(), rz_io_fd_get_pid(), rz_io_fd_get_tid(), rz_io_fd_is_blockdevice(), rz_io_fd_is_chardevice(), rz_io_fd_is_dbg(), 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_map_cleanup(), rz_io_reopen(), rz_io_use_fd(), rz_main_rizin(), rz_open_binary_add_handler(), rz_open_malloc_handler(), rz_open_maps_all_fd_handler(), rz_open_maps_map_fd_handler(), rz_open_maps_map_handler(), rz_open_show_current_handler(), rz_write_pcache_commit_handler(), and rz_write_pcache_list_handler().

rz_io_desc_get_base()

RZ_API bool rz_io_desc_get_base	(	RzIODesc *	desc,
		ut64 *	base
	)

Definition at line 344 of file io_desc.c.

                                                            {
    if (!base || !desc || !desc->plugin || !desc->plugin->isdbg || !desc->plugin->getbase) {
        return false;
    }
    return desc->plugin->getbase(desc, base);
}

References desc.

Referenced by core_file_do_load_for_debug(), rz_debug_get_baddr(), and rz_io_fd_get_base().

rz_io_desc_get_buf()

RZ_API ut8* rz_io_desc_get_buf	(	RzIODesc *	desc,
		RZ_OUT RZ_NONNULL ut64 *	size
	)

Returns the underlying buffer of the io descriptor.

Parameters

[in]	desc	The io descriptor
[out]	size	Size of buffer returned

Returns

The buffer or NULL if the buffer is not available

Definition at line 241 of file io_desc.c.

                                                                             {
    rz_return_val_if_fail(size, NULL);
    if (!desc || !desc->plugin || !desc->plugin->get_buf) {
        *size = 0;
        return NULL;
    }
    return desc->plugin->get_buf(desc, size);
}

References desc, NULL, and rz_return_val_if_fail.

Referenced by rz_io_fd_get_buf().

rz_io_desc_get_pid()

RZ_API int rz_io_desc_get_pid

(

RzIODesc *

desc

)

Definition at line 310 of file io_desc.c.

                                              {
    //-1 and -2 are reserved
    if (!desc) {
        return -3;
    }
    if (!desc->plugin) {
        return -4;
    }
    if (!desc->plugin->isdbg) {
        return -5;
    }
    if (!desc->plugin->getpid) {
        return -6;
    }
    return desc->plugin->getpid(desc);
}

References desc.

Referenced by rz_core_setup_debugger(), rz_debug_get_baddr(), and rz_io_fd_get_pid().

rz_io_desc_get_tid()

RZ_API int rz_io_desc_get_tid

(

RzIODesc *

desc

)

Definition at line 327 of file io_desc.c.

                                              {
    //-1 and -2 are reserved
    if (!desc) {
        return -3;
    }
    if (!desc->plugin) {
        return -4;
    }
    if (!desc->plugin->isdbg) {
        return -5;
    }
    if (!desc->plugin->gettid) {
        return -6;
    }
    return desc->plugin->gettid(desc);
}

References desc.

Referenced by rz_debug_get_baddr(), and rz_io_fd_get_tid().

rz_io_desc_init()

RZ_IPI bool rz_io_desc_init

(

RzIO *

io

)

Definition at line 368 of file io_desc.c.

                                      {
    rz_return_val_if_fail(io, false);
    rz_io_desc_fini(io);
    // TODO: it leaks if called twice
    // fd is signed
    io->files = rz_id_storage_new(3, 0x80000000);
    if (!io->files) {
        return false;
    }
    return true;
}

References rz_io_t::files, rz_id_storage_new(), rz_io_desc_fini(), and rz_return_val_if_fail.

Referenced by rz_io_close_all(), and rz_io_init().

rz_io_desc_is_blockdevice()

RZ_API bool rz_io_desc_is_blockdevice

(

RzIODesc *

desc

)

Definition at line 261 of file io_desc.c.

                                                      {
    if (!desc || !desc->plugin || !desc->plugin->is_blockdevice) {
        return false;
    }
    return desc->plugin->is_blockdevice(desc);
}

References desc.

Referenced by reopen_in_malloc_cb(), and rz_io_fd_is_blockdevice().

rz_io_desc_is_chardevice()

RZ_API bool rz_io_desc_is_chardevice

(

RzIODesc *

desc

)

Definition at line 268 of file io_desc.c.

                                                     {
    if (!desc || !desc->plugin || !desc->plugin->is_chardevice) {
        return false;
    }
    return desc->plugin->is_chardevice(desc);
}

References desc.

Referenced by rz_io_fd_is_chardevice(), rz_io_plugin_read_at(), and rz_io_plugin_write_at().

rz_io_desc_is_dbg()

RZ_API bool rz_io_desc_is_dbg

(

RzIODesc *

desc

)

Definition at line 303 of file io_desc.c.

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

References desc.

Referenced by reopen_in_malloc_cb(), rz_core_bin_apply_maps(), rz_core_bin_load(), and rz_io_fd_is_dbg().

rz_io_desc_new()

RZ_API RzIODesc* rz_io_desc_new	(	RzIO *	io,
		RzIOPlugin *	plugin,
		const char *	uri,
		int	flags,
		int	mode,
		void *	data
	)

Definition at line 11 of file io_desc.c.

                                                                                                               {
    ut32 fd32 = 0;
    // this is required for emscripten builds to work, but should assert
    if (!io || !plugin || !uri) {
        return NULL;
    }
    if (io->files) {
        if (!rz_id_pool_grab_id(io->files->pool, &fd32)) {
            return NULL;
        }
    }
    RzIODesc *desc = RZ_NEW0(RzIODesc);
    if (desc) {
        desc->fd = fd32;
        desc->io = io;
        desc->plugin = plugin;
        desc->data = data;
        desc->perm = perm;
        // because the uri-arg may live on the stack
        desc->uri = strdup(uri);
    }
    return desc;
}

References desc, rz_io_t::files, NULL, rz_id_storage_t::pool, rz_id_pool_grab_id(), RZ_NEW0, and strdup().

Referenced by __open(), __rap_open(), dmp_open(), find_apk_binary(), rz_io_ar_open(), rz_io_ar_open_many(), rz_io_def_mmap_open(), rz_io_zip_open(), rz_io_zip_open_many(), rzk__open(), vf_open(), and windbg_open().

rz_io_desc_open()

RZ_API RzIODesc* rz_io_desc_open	(	RzIO *	io,
		const char *	uri,
		int	flags,
		int	mode
	)

Definition at line 112 of file io_desc.c.

                                                                                {
    rz_return_val_if_fail(io && uri, NULL);
    RzIOPlugin *plugin = rz_io_plugin_resolve(io, uri, 0);
    if (!plugin || !plugin->open) {
        return NULL;
    }
    RzIODesc *desc = plugin->open(io, uri, perm, mode);
    if (!desc) {
        return NULL;
    }
    // for none static callbacks, those that cannot use rz_io_desc_new
    if (!desc->name) {
        desc->name = strdup(uri);
    }
    if (!desc->uri) {
        desc->uri = strdup(uri);
    }
    if (!desc->plugin) {
        desc->plugin = plugin;
    }
    if (!rz_io_desc_add(io, desc)) {
        rz_io_desc_free(desc);
        return NULL;
    }
    return desc;
}

References desc, NULL, rz_io_plugin_t::open, rz_io_desc_add(), rz_io_desc_free(), rz_io_plugin_resolve(), rz_return_val_if_fail, and strdup().

Referenced by rz_io_fd_open(), and rz_io_open_nomap().

rz_io_desc_open_plugin()

RZ_API RzIODesc* rz_io_desc_open_plugin	(	RzIO *	io,
		RzIOPlugin *	plugin,
		const char *	uri,
		int	flags,
		int	mode
	)

Definition at line 139 of file io_desc.c.

                                                                                                           {
    rz_return_val_if_fail(io && io->files && uri, NULL);
    if (!plugin || !plugin->open || !plugin->check || !plugin->check(io, uri, false)) {
        return NULL;
    }
    RzIODesc *desc = plugin->open(io, uri, perm, mode);
    if (!desc) {
        return NULL;
    }
    // for none static callbacks, those that cannot use rz_io_desc_new
    if (!desc->plugin) {
        desc->plugin = plugin;
    }
    if (!desc->uri) {
        desc->uri = strdup(uri);
    }
    if (!desc->name) {
        desc->name = strdup(uri);
    }
    if (!rz_io_desc_add(io, desc)) {
        rz_io_desc_free(desc);
        return NULL;
    }
    return desc;
}

References rz_io_plugin_t::check, desc, rz_io_t::files, NULL, rz_io_plugin_t::open, rz_io_desc_add(), rz_io_desc_free(), rz_return_val_if_fail, and strdup().

rz_io_desc_read()

RZ_API int rz_io_desc_read	(	RzIODesc *	desc,
		ut8 *	buf,
		int	count
	)

Definition at line 197 of file io_desc.c.

                                                              {
    // check pointers and permissions
    if (!buf || !desc || !desc->plugin || !(desc->perm & RZ_PERM_R)) {
        return -1;
    }
    ut64 seek = rz_io_desc_seek(desc, 0LL, RZ_IO_SEEK_CUR);
    if (desc->io->cachemode) {
        if (seek != UT64_MAX && rz_io_cache_at(desc->io, seek)) {
            return rz_io_cache_read(desc->io, seek, buf, len);
        }
    }
    int ret = rz_io_plugin_read(desc, buf, len);
    if (ret > 0 && desc->io->cachemode) {
        rz_io_cache_write(desc->io, seek, buf, len);
    } else if ((ret > 0) && desc->io && (desc->io->p_cache & 1)) {
        ret = rz_io_desc_cache_read(desc, seek, buf, ret);
    }
    return ret;
}

References desc, len, rz_io_cache_at(), rz_io_cache_read(), rz_io_cache_write(), rz_io_desc_cache_read(), rz_io_desc_seek(), rz_io_plugin_read(), RZ_IO_SEEK_CUR, RZ_PERM_R, seek(), ut64(), and UT64_MAX.

Referenced by rz_io_desc_read_at(), and rz_io_fd_read().

rz_io_desc_read_at()

RZ_API int rz_io_desc_read_at	(	RzIODesc *	desc,
		ut64	addr,
		ut8 *	buf,
		int	len
	)

Definition at line 351 of file io_desc.c.

                                                                            {
    if (desc && buf && (rz_io_desc_seek(desc, addr, RZ_IO_SEEK_SET) == addr)) {
        return rz_io_desc_read(desc, buf, len);
    }
    return 0;
}

References addr, desc, len, rz_io_desc_read(), rz_io_desc_seek(), and RZ_IO_SEEK_SET.

Referenced by dmp_read(), read_at_kernel_virtual(), reopen_in_malloc_cb(), rz_io_fd_read_at(), and rz_io_pread_at().

rz_io_desc_resize()

RZ_API bool rz_io_desc_resize	(	RzIODesc *	desc,
		ut64	newsize
	)

Definition at line 250 of file io_desc.c.

                                                            {
    if (desc && desc->plugin && desc->plugin->resize) {
        bool ret = desc->plugin->resize(desc->io, desc, newsize);
        if (desc->io && desc->io->p_cache) {
            rz_io_desc_cache_cleanup(desc);
        }
        return ret;
    }
    return false;
}

References desc, and rz_io_desc_cache_cleanup().

Referenced by rz_io_fd_resize(), and rz_io_resize().

rz_io_desc_seek()

RZ_API ut64 rz_io_desc_seek	(	RzIODesc *	desc,
		ut64	offset,
		int	whence
	)

Definition at line 217 of file io_desc.c.

                                                                     {
    if (!desc || !desc->plugin || !desc->plugin->lseek) {
        return (ut64)-1;
    }
    return desc->plugin->lseek(desc->io, desc, offset, whence);
}

References desc, and ut64().

Referenced by dmp_lseek(), rz_io_desc_read(), rz_io_desc_read_at(), rz_io_desc_size(), rz_io_desc_write(), rz_io_desc_write_at(), rz_io_fd_seek(), rz_io_plugin_read_at(), rz_io_plugin_write(), rz_io_plugin_write_at(), rz_io_seek(), and rz_io_shift().

rz_io_desc_size()

RZ_API ut64 rz_io_desc_size

(

RzIODesc *

desc

)

Definition at line 224 of file io_desc.c.

                                            {
    if (!desc || !desc->plugin || !desc->plugin->lseek) {
        return 0LL;
    }
    ut64 off = rz_io_desc_seek(desc, 0LL, RZ_IO_SEEK_CUR);
    ut64 ret = rz_io_desc_seek(desc, 0LL, RZ_IO_SEEK_END);
    // what to do if that seek fails?
    rz_io_desc_seek(desc, off, RZ_IO_SEEK_SET);
    return ret;
}

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

Referenced by __desc_cache_cleanup_cb(), basefind_new_bin_file(), calculate_decrypt(), calculate_encrypt(), calculate_hash(), desc_list_cb(), desc_list_json_cb(), desc_list_table_cb(), desc_list_visual_cb(), init_desc_list_visual_cb(), map_multi_dex(), reopen_in_malloc_cb(), rz_core_bin_load(), rz_core_bin_whole_strings(), rz_core_cmd_subst_i(), rz_core_file_info_print(), rz_core_file_open_many(), rz_core_file_print(), rz_core_sysenv_begin(), rz_diff_file_open(), rz_diff_io_open(), rz_io_bind(), rz_io_desc_cache_read(), rz_io_desc_cache_write(), rz_io_extend_at(), rz_io_fd_size(), rz_io_is_valid_offset(), rz_io_open(), rz_io_open_at(), rz_io_size(), rz_main_rizin(), and rz_open_maps_map_fd_handler().

rz_io_desc_write()

RZ_API int rz_io_desc_write	(	RzIODesc *	desc,
		const ut8 *	buf,
		int	count
	)

Definition at line 183 of file io_desc.c.

                                                                     {
    rz_return_val_if_fail(desc && buf, -1);
    if (len < 0) {
        return -1;
    }
    // check pointers and pcache
    if (desc->io && (desc->io->p_cache & 2)) {
        return rz_io_desc_cache_write(desc,
            rz_io_desc_seek(desc, 0LL, RZ_IO_SEEK_CUR), buf, len);
    }
    return rz_io_plugin_write(desc, buf, len);
}

References desc, len, rz_io_desc_cache_write(), rz_io_desc_seek(), rz_io_plugin_write(), RZ_IO_SEEK_CUR, and rz_return_val_if_fail.

Referenced by rz_io_desc_write_at(), rz_io_fd_write(), and rz_io_open_buffer().

rz_io_desc_write_at()

RZ_API int rz_io_desc_write_at	(	RzIODesc *	desc,
		ut64	addr,
		const ut8 *	buf,
		int	len
	)

Definition at line 358 of file io_desc.c.

                                                                                   {
    if (desc && buf && (rz_io_desc_seek(desc, addr, RZ_IO_SEEK_SET) == addr)) {
        return rz_io_desc_write(desc, buf, len);
    }
    return 0;
}

References addr, desc, len, rz_io_desc_seek(), rz_io_desc_write(), and RZ_IO_SEEK_SET.

Referenced by dmp_write(), reopen_in_malloc_cb(), rz_io_fd_write_at(), rz_io_pwrite_at(), and rz_open_malloc_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_fd_close()

RZ_API bool rz_io_fd_close	(	RzIO *	io,
		int	fd
	)

Definition at line 11 of file io_fd.c.

                                             {
    return rz_io_desc_close(rz_io_desc_get(io, fd));
}

References fd, rz_io_desc_close(), and rz_io_desc_get().

Referenced by ds_free(), ds_init(), get_bin_info(), GetHeapGlobalsOffset(), rz_core_analysis_esil_init_mem(), rz_core_analysis_esil_init_mem_del(), rz_core_file_close_fd(), and rz_io_bind().

rz_io_fd_get_base()

RZ_API bool rz_io_fd_get_base	(	RzIO *	io,
		int	fd,
		ut64 *	base
	)

Definition at line 106 of file io_fd.c.

                                                            {
    rz_return_val_if_fail(io && io->files && base, false);
    RzIODesc *desc = rz_io_desc_get(io, fd);
    return rz_io_desc_get_base(desc, base);
}

References desc, fd, rz_io_t::files, rz_io_desc_get(), rz_io_desc_get_base(), and rz_return_val_if_fail.

rz_io_fd_get_buf()

RZ_API ut8* rz_io_fd_get_buf	(	RzIO *	io,
		int	fd,
		RZ_OUT RZ_NONNULL ut64 *	size
	)

Returns the underlying buffer of the file descriptor.

Parameters

[in]	io	The RzIO instance
[in]	fd	The file descriptor
[out]	size	Size of the buffer returned

Returns

The buffer or NULL if the file descriptor is invalid or the buffer is not available

Definition at line 53 of file io_fd.c.

                                                                             {
    rz_return_val_if_fail(io && size, NULL);
    return rz_io_desc_get_buf(rz_io_desc_get(io, fd), size);
}

References fd, NULL, rz_io_desc_get(), rz_io_desc_get_buf(), and rz_return_val_if_fail.

Referenced by rz_io_bind().

rz_io_fd_get_current()

RZ_API int rz_io_fd_get_current

(

RzIO *

io

)

Definition at line 135 of file io_fd.c.

                                          {
    rz_return_val_if_fail(io, -1);
    if (io->desc) {
        return io->desc->fd;
    }
    return -1;
}

References rz_io_t::desc, rz_io_desc_t::fd, and rz_return_val_if_fail.

Referenced by append_bound(), DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), handle_tmp_desc(), prioritize_file(), rz_core_bin_set_arch_bits(), rz_core_cmd_foreach3(), rz_core_file_info_print(), rz_core_serve(), rz_io_bind(), rz_main_rizin(), rz_main_rz_bin(), rz_open_binary_add_handler(), rz_open_binary_file_handler(), rz_open_maps_all_fd_handler(), rz_open_maps_map_fd_handler(), rz_open_prioritize_next_handler(), rz_open_prioritize_next_rotate_handler(), and rz_open_prioritize_prev_handler().

rz_io_fd_get_highest()

RZ_API int rz_io_fd_get_highest

(

RzIO *

io

)

Definition at line 161 of file io_fd.c.

                                          {
    rz_return_val_if_fail(io, -1);
    int fd = -1;
    if (!rz_id_storage_get_highest(io->files, (ut32 *)&fd)) {
        return -1;
    }
    return fd;
}

References fd, rz_io_t::files, rz_id_storage_get_highest(), and rz_return_val_if_fail.

Referenced by rz_io_desc_get_highest().

rz_io_fd_get_lowest()

RZ_API int rz_io_fd_get_lowest

(

RzIO *

io

)

Definition at line 170 of file io_fd.c.

                                         {
    rz_return_val_if_fail(io, -1);
    int fd = -1;
    if (!rz_id_storage_get_lowest(io->files, (ut32 *)&fd)) {
        return -1;
    }
    return fd;
}

References fd, rz_io_t::files, rz_id_storage_get_lowest(), and rz_return_val_if_fail.

Referenced by rz_io_desc_get_lowest(), and rz_open_prioritize_next_rotate_handler().

rz_io_fd_get_name()

RZ_API const char* rz_io_fd_get_name	(	RzIO *	io,
		int	fd
	)

Definition at line 112 of file io_fd.c.

                                                       {
    rz_return_val_if_fail(io && io->files, NULL);
    RzIODesc *desc = rz_io_desc_get(io, fd);
    return desc ? desc->name : NULL;
}

References desc, fd, rz_io_t::files, NULL, rz_io_desc_get(), and rz_return_val_if_fail.

Referenced by rz_io_bind().

rz_io_fd_get_next()

RZ_API int rz_io_fd_get_next	(	RzIO *	io,
		int	fd
	)

Definition at line 143 of file io_fd.c.

                                               {
    rz_return_val_if_fail(io, -1);
    int ret = fd;
    if (!rz_id_storage_get_next(io->files, (ut32 *)&ret)) {
        return -1;
    }
    return ret;
}

References fd, rz_io_t::files, rz_id_storage_get_next(), and rz_return_val_if_fail.

Referenced by rz_io_desc_get_next(), rz_open_prioritize_next_handler(), and rz_open_prioritize_next_rotate_handler().

rz_io_fd_get_pid()

RZ_API int rz_io_fd_get_pid	(	RzIO *	io,
		int	fd
	)

Definition at line 92 of file io_fd.c.

                                              {
    if (!io || !io->files) {
        return -2;
    }
    RzIODesc *desc = rz_io_desc_get(io, fd);
    return rz_io_desc_get_pid(desc);
}

References desc, fd, rz_io_t::files, rz_io_desc_get(), and rz_io_desc_get_pid().

Referenced by cb_cfgdebug(), cmd_debug_pid(), core_file_do_load_for_debug(), rz_core_debug_attach(), and rz_core_file_reopen().

rz_io_fd_get_prev()

RZ_API int rz_io_fd_get_prev	(	RzIO *	io,
		int	fd
	)

Definition at line 152 of file io_fd.c.

                                               {
    rz_return_val_if_fail(io, -1);
    int ret = fd;
    if (!rz_id_storage_get_prev(io->files, (ut32 *)&ret)) {
        return -1;
    }
    return ret;
}

References fd, rz_io_t::files, rz_id_storage_get_prev(), and rz_return_val_if_fail.

Referenced by rz_io_desc_get_prev(), and rz_open_prioritize_prev_handler().

rz_io_fd_get_tid()

RZ_API int rz_io_fd_get_tid	(	RzIO *	io,
		int	fd
	)

Definition at line 100 of file io_fd.c.

                                              {
    rz_return_val_if_fail(io && io->files, -2);
    RzIODesc *desc = rz_io_desc_get(io, fd);
    return rz_io_desc_get_tid(desc);
}

References desc, fd, rz_io_t::files, rz_io_desc_get(), rz_io_desc_get_tid(), and rz_return_val_if_fail.

Referenced by cb_cfgdebug(), cmd_debug_pid(), core_file_do_load_for_debug(), and rz_core_file_reopen().

rz_io_fd_is_blockdevice()

RZ_API bool rz_io_fd_is_blockdevice	(	RzIO *	io,
		int	fd
	)

Definition at line 62 of file io_fd.c.

                                                      {
    return rz_io_desc_is_blockdevice(rz_io_desc_get(io, fd));
}

References fd, rz_io_desc_get(), and rz_io_desc_is_blockdevice().

rz_io_fd_is_chardevice()

RZ_API bool rz_io_fd_is_chardevice	(	RzIO *	io,
		int	fd
	)

Definition at line 66 of file io_fd.c.

                                                     {
    return rz_io_desc_is_chardevice(rz_io_desc_get(io, fd));
}

References fd, rz_io_desc_get(), and rz_io_desc_is_chardevice().

rz_io_fd_is_dbg()

RZ_API bool rz_io_fd_is_dbg	(	RzIO *	io,
		int	fd
	)

Definition at line 86 of file io_fd.c.

                                              {
    rz_return_val_if_fail(io && io->files, false);
    RzIODesc *desc = rz_io_desc_get(io, fd);
    return desc ? rz_io_desc_is_dbg(desc) : false;
}

References desc, fd, rz_io_t::files, rz_io_desc_get(), rz_io_desc_is_dbg(), and rz_return_val_if_fail.

Referenced by rz_io_bind().

rz_io_fd_open()

RZ_API int rz_io_fd_open	(	RzIO *	io,
		const char *	uri,
		int	flags,
		int	mode
	)

Definition at line 6 of file io_fd.c.

                                                                         {
    RzIODesc *desc = rz_io_desc_open(io, uri, flags, mode);
    return desc ? desc->fd : -1;
}

References desc, flags, and rz_io_desc_open().

Referenced by ds_init(), get_bin_info(), GetHeapGlobalsOffset(), rz_core_analysis_esil_init_mem(), and rz_io_bind().

rz_io_fd_read()

RZ_API int rz_io_fd_read	(	RzIO *	io,
		int	fd,
		ut8 *	buf,
		int	len
	)

Definition at line 16 of file io_fd.c.

                                                              {
    rz_return_val_if_fail(io && buf, -1);
    if (len < 0) {
        return -1;
    }
    RzIODesc *desc = rz_io_desc_get(io, fd);
    return desc ? rz_io_desc_read(desc, buf, len) : -1;
}

References desc, fd, len, rz_io_desc_get(), rz_io_desc_read(), and rz_return_val_if_fail.

Referenced by rz_io_bind().

rz_io_fd_read_at()

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

Definition at line 71 of file io_fd.c.

                                                                            {
    RzIODesc *desc;
    if (!io || !buf || (len < 1) || !(desc = rz_io_desc_get(io, fd))) {
        return 0;
    }
    return rz_io_desc_read_at(desc, addr, buf, len);
}

References addr, desc, fd, len, rz_io_desc_get(), and rz_io_desc_read_at().

Referenced by fd_read_at_wrap(), and rz_io_bind().

rz_io_fd_resize()

RZ_API bool rz_io_fd_resize	(	RzIO *	io,
		int	fd,
		ut64	newsize
	)

Definition at line 58 of file io_fd.c.

                                                            {
    return rz_io_desc_resize(rz_io_desc_get(io, fd), newsize);
}

References fd, rz_io_desc_get(), and rz_io_desc_resize().

Referenced by rz_io_bind().

rz_io_fd_seek()

RZ_API ut64 rz_io_fd_seek	(	RzIO *	io,
		int	fd,
		ut64	addr,
		int	whence
	)

Definition at line 35 of file io_fd.c.

                                                                   {
    if (!io) {
        return (ut64)-2;
    }
    return rz_io_desc_seek(rz_io_desc_get(io, fd), addr, whence);
}

References addr, fd, rz_io_desc_get(), rz_io_desc_seek(), and ut64().

Referenced by rz_io_bind().

rz_io_fd_size()

RZ_API ut64 rz_io_fd_size	(	RzIO *	io,
		int	fd
	)

Definition at line 42 of file io_fd.c.

                                            {
    return rz_io_desc_size(rz_io_desc_get(io, fd));
}

References fd, rz_io_desc_get(), and rz_io_desc_size().

Referenced by cmd_print_bars(), file_resize(), get_bin_info(), GetHeapGlobalsOffset(), isValidAddress(), num_callback(), resize_helper(), rz_core_get_boundaries_prot(), rz_core_serve(), rz_io_bind(), rz_io_resize(), rz_main_rizin(), rz_open_maps_map_handler(), rz_resize_handler(), rz_resize_human_handler(), rz_seek_end_handler(), and system_exec().

rz_io_fd_write()

RZ_API int rz_io_fd_write	(	RzIO *	io,
		int	fd,
		const ut8 *	buf,
		int	len
	)

Definition at line 26 of file io_fd.c.

                                                                     {
    rz_return_val_if_fail(io && buf, -1);
    if (len < 0) {
        return -1;
    }
    RzIODesc *desc = rz_io_desc_get(io, fd);
    return desc ? rz_io_desc_write(desc, buf, len) : -1;
}

References desc, fd, len, rz_io_desc_get(), rz_io_desc_write(), and rz_return_val_if_fail.

Referenced by rz_io_bind().

rz_io_fd_write_at()

RZ_API int rz_io_fd_write_at	(	RzIO *	io,
		int	fd,
		ut64	addr,
		const ut8 *	buf,
		int	len
	)

Definition at line 80 of file io_fd.c.

                                                                                   {
    rz_return_val_if_fail(io && buf, false);
    RzIODesc *desc = rz_io_desc_get(io, fd);
    return desc ? rz_io_desc_write_at(desc, addr, buf, len) : -1;
}

References addr, desc, fd, len, rz_io_desc_get(), rz_io_desc_write_at(), and rz_return_val_if_fail.

Referenced by fd_write_at_wrap(), and rz_io_bind().

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

RZ_API bool rz_io_is_valid_offset	(	RzIO *	io,
		ut64	offset,
		int	hasperm
	)

Definition at line 20 of file ioutils.c.

                                                                      {
    rz_return_val_if_fail(io, false);
    if (io->va) {
        if (!hasperm) {
            // return rz_io_map_is_mapped (io, offset);
            RzIOMap *map = rz_io_map_get(io, offset);
            return map ? map->perm & RZ_PERM_R : false;
        }
        RzIOMap *map = rz_io_map_get(io, offset);
        return map ? (map->perm & hasperm) == hasperm : false;
    }
    if (!io->desc) {
        return false;
    }
    if (offset > rz_io_desc_size(io->desc)) {
        return false;
    }
    return ((io->desc->perm & hasperm) == hasperm);
}

References rz_io_t::desc, map(), rz_io_desc_t::perm, rz_io_desc_size(), rz_io_map_get(), RZ_PERM_R, rz_return_val_if_fail, and rz_io_t::va.

Referenced by __core_analysis_fcn(), __op_refs(), _analysis_calls(), _pointer_table(), agraph_refresh(), do_string_search(), ds_print_core_vmode(), esilbreak_reg_write(), is_valid_xref(), mymemread(), mymemwrite(), myregwrite(), myvalid(), rz_analyze_all_data_references_to_code_handler(), rz_core_analysis_esil(), rz_core_analysis_fcn(), rz_core_analysis_function_add(), rz_core_analysis_search_xrefs(), rz_core_asm_strsearch(), rz_core_esil_step(), rz_core_is_valid_offset(), rz_core_search_prelude(), rz_core_search_value_in_range(), and rz_io_bind().

rz_io_map_add()

RZ_API RzIOMap* rz_io_map_add	(	RzIO *	io,
		int	fd,
		int	flags,
		ut64	delta,
		ut64	addr,
		ut64	size
	)

Definition at line 151 of file io_map.c.

                                                                                            {
    return io_map_add(io, fd, perm, delta, addr, size);
}

References addr, delta, fd, and io_map_add().

Referenced by ds_init(), rz_core_analysis_esil_init_mem(), rz_core_serve(), rz_io_bind(), rz_open_maps_all_fd_handler(), rz_open_maps_map_fd_handler(), and rz_open_maps_map_handler().

rz_io_map_add_batch()

RZ_API RzIOMap* rz_io_map_add_batch	(	RzIO *	io,
		int	fd,
		int	flags,
		ut64	delta,
		ut64	addr,
		ut64	size
	)

Definition at line 155 of file io_map.c.

                                                                                                  {
    return io_map_add(io, fd, perm, delta, addr, size);
}

References addr, delta, fd, and io_map_add().

Referenced by add_map(), and io_create_mem_map().

rz_io_map_cleanup()

RZ_API void rz_io_map_cleanup

(

RzIO *

io

)

Definition at line 287 of file io_map.c.

                                        {
    rz_return_if_fail(io);
    // remove all maps if no descs exist
    if (!io->files) {
        rz_io_map_fini(io);
        rz_io_map_init(io);
        return;
    }
    bool del = false;
    size_t i;
    for (i = 0; i < rz_pvector_len(&io->maps);) {
        RzIOMap *map = rz_pvector_at(&io->maps, i);
        if (!map) {
            // remove iter if the map is a null-ptr, this may fix some segfaults. This should never happen.
            rz_warn_if_reached();
            rz_pvector_remove_at(&io->maps, i);
            del = true;
        } else if (!rz_io_desc_get(io, map->fd)) {
            // delete map and iter if no desc exists for map->fd in io->files
            map = rz_pvector_remove_at(&io->maps, i);
            map_del(io, map);
            del = true;
        } else {
            i++;
        }
    }
    if (del) {
        io_map_calculate_skyline(io);
    }
}

References del(), rz_io_t::files, i, io_map_calculate_skyline(), map(), map_del(), rz_io_t::maps, rz_io_desc_get(), rz_io_map_fini(), rz_io_map_init(), rz_pvector_at(), rz_pvector_len(), rz_pvector_remove_at(), rz_return_if_fail, and rz_warn_if_reached.

Referenced by rz_io_desc_close(), rz_io_desc_del(), and rz_io_map_priorize_for_fd().

rz_io_map_del()

RZ_API bool rz_io_map_del	(	RzIO *	io,
		ut32	id
	)

Definition at line 192 of file io_map.c.

                                             {
    rz_return_val_if_fail(io, false);
    size_t i;
    for (i = 0; i < rz_pvector_len(&io->maps); i++) {
        RzIOMap *map = rz_pvector_at(&io->maps, i);
        if (map->id == id) {
            rz_pvector_remove_at(&io->maps, i);
            map_del(io, map);
            io_map_calculate_skyline(io);
            return true;
        }
    }
    return false;
}

References i, io_map_calculate_skyline(), map(), map_del(), rz_io_t::maps, rz_pvector_at(), rz_pvector_len(), rz_pvector_remove_at(), and rz_return_val_if_fail.

Referenced by rz_core_file_close(), rz_debug_dmp_init(), and rz_open_maps_remove_handler().

rz_io_map_del_for_fd()

RZ_API bool rz_io_map_del_for_fd	(	RzIO *	io,
		int	fd
	)

Definition at line 208 of file io_map.c.

                                                   {
    rz_return_val_if_fail(io, false);
    bool ret = false;
    size_t i;
    for (i = 0; i < rz_pvector_len(&io->maps);) {
        RzIOMap *map = rz_pvector_at(&io->maps, i);
        if (!map) {
            rz_pvector_remove_at(&io->maps, i);
        } else if (map->fd == fd) {
            rz_pvector_remove_at(&io->maps, i);
            map_del(io, map);
            ret = true;
        } else {
            i++;
        }
    }
    if (ret) {
        io_map_calculate_skyline(io);
    }
    return ret;
}

References fd, i, io_map_calculate_skyline(), map(), map_del(), rz_io_t::maps, rz_pvector_at(), rz_pvector_len(), rz_pvector_remove_at(), and rz_return_val_if_fail.

rz_io_map_del_name()

RZ_API void rz_io_map_del_name

(

RzIOMap *

map

)

Definition at line 340 of file io_map.c.

                                             {
    if (map) {
        RZ_FREE(map->name);
    }
}

References map(), and RZ_FREE.

Referenced by rz_open_maps_name_del_handler(), and rz_open_maps_name_id_del_handler().

rz_io_map_depriorize()

RZ_API bool rz_io_map_depriorize	(	RzIO *	io,
		ut32	id
	)

Definition at line 248 of file io_map.c.

                                                    {
    rz_return_val_if_fail(io, false);
    size_t i;
    for (i = 0; i < rz_pvector_len(&io->maps); i++) {
        RzIOMap *map = rz_pvector_at(&io->maps, i);
        // search for iter with the correct map
        if (map->id == id) {
            rz_pvector_remove_at(&io->maps, i);
            rz_pvector_push_front(&io->maps, map);
            io_map_calculate_skyline(io);
            return true;
        }
    }
    return false;
}

References i, io_map_calculate_skyline(), map(), rz_io_t::maps, rz_pvector_at(), rz_pvector_len(), rz_pvector_push_front(), rz_pvector_remove_at(), and rz_return_val_if_fail.

Referenced by rz_open_maps_deprioritize_handler().

rz_io_map_exists()

RZ_API bool rz_io_map_exists	(	RzIO *	io,
		RzIOMap *	map
	)

Definition at line 111 of file io_map.c.

                                                     {
    rz_return_val_if_fail(io && map, false);
    void **it;
    rz_pvector_foreach (&io->maps, it) {
        RzIOMap *m = *it;
        if (!memcmp(m, map, sizeof(RzIOMap))) {
            return true;
        }
    }
    return false;
}

References regress::m, map(), rz_io_t::maps, rz_pvector_foreach, and rz_return_val_if_fail.

rz_io_map_exists_for_id()

RZ_API bool rz_io_map_exists_for_id	(	RzIO *	io,
		ut32	id
	)

Definition at line 124 of file io_map.c.

                                                       {
    return rz_io_map_resolve(io, id) != NULL;
}

References NULL, and rz_io_map_resolve().

Referenced by rz_open_maps_deprioritize_handler(), and rz_open_maps_prioritize_handler().

rz_io_map_fini()

RZ_API void rz_io_map_fini

(

RzIO *

io

)

Definition at line 318 of file io_map.c.

                                     {
    rz_return_if_fail(io);
    void **it;
    rz_pvector_foreach (&io->maps, it) {
        RzIOMap *map = *it;
        RzEventIOMapDel ev = { map };
        rz_event_send(io->event, RZ_EVENT_IO_MAP_DEL, &ev);
    }
    rz_pvector_clear(&io->maps);
    rz_id_pool_free(io->map_ids);
    io->map_ids = NULL;
    rz_skyline_clear(&io->map_skyline);
}

References rz_io_t::event, map(), rz_io_t::map_ids, rz_io_t::map_skyline, rz_io_t::maps, NULL, RZ_EVENT_IO_MAP_DEL, rz_event_send(), rz_id_pool_free(), rz_pvector_clear(), rz_pvector_foreach, rz_return_if_fail, and rz_skyline_clear().

Referenced by rz_io_fini(), rz_io_map_cleanup(), and rz_io_map_reset().

rz_io_map_get()

RZ_API RzIOMap* rz_io_map_get	(	RzIO *	io,
		ut64	addr
	)

Definition at line 176 of file io_map.c.

                                                   {
    rz_return_val_if_fail(io, NULL);
    return rz_skyline_get(&io->map_skyline, addr);
}

References addr, rz_io_t::map_skyline, NULL, rz_return_val_if_fail, and rz_skyline_get().

Referenced by __core_analysis_fcn(), __core_visual_gogo(), canWrite(), cmd_print_blocks(), flagbar_foreach(), get_esil_stack_name(), isValidAddress(), meta_for_reloc(), num_callback(), open_maps_list(), print_cmd_analysis_after_traps_print(), rz_analysis_try_get_fcn(), rz_cmd_debug_continue_mapped_io_handler(), rz_core_analysis_get_stats(), rz_core_extend_at(), rz_core_get_boundaries_prot(), rz_core_visual_title(), rz_debug_dmp_init(), rz_io_addr_is_mapped(), rz_io_bind(), rz_io_is_valid_offset(), rz_io_map_is_mapped(), rz_io_v2p(), rz_open_maps_flags_handler(), rz_open_maps_list_cur_handler(), rz_open_maps_name_del_handler(), rz_open_maps_name_handler(), rz_open_maps_relocate_current_handler(), rz_open_show_current_handler(), rz_seek_begin_handler(), and rz_seek_end_handler().

rz_io_map_get_for_fd()

RZ_API RzList* rz_io_map_get_for_fd	(	RzIO *	io,
		int	fd
	)

Definition at line 388 of file io_map.c.

                                                        {
    RzList *map_list = rz_list_newf(NULL);
    if (!map_list) {
        return NULL;
    }
    void **it;
    rz_pvector_foreach (&io->maps, it) {
        RzIOMap *map = *it;
        if (map && map->fd == fd) {
            rz_list_append(map_list, map);
        }
    }
    return map_list;
}

References fd, map(), rz_io_t::maps, NULL, rz_list_append(), rz_list_newf(), and rz_pvector_foreach.

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), rz_core_cmd_foreach3(), rz_core_raw_file_print(), rz_io_bind(), rz_io_map_remap_fd(), and rz_io_resize().

rz_io_map_get_paddr()

RZ_API RzIOMap* rz_io_map_get_paddr	(	RzIO *	io,
		ut64	paddr
	)

Definition at line 163 of file io_map.c.

                                                          {
    rz_return_val_if_fail(io, NULL);
    void **it;
    rz_pvector_foreach_prev(&io->maps, it) {
        RzIOMap *map = *it;
        if (map->delta <= paddr && paddr <= map->delta + (map->itv.size ? map->itv.size - 1 : 0)) {
            return map;
        }
    }
    return NULL;
}

References delta, map(), rz_io_t::maps, NULL, rz_pvector_foreach_prev, and rz_return_val_if_fail.

Referenced by rz_core_pava(), rz_io_bind(), and rz_io_p2v().

rz_io_map_init()

RZ_API void rz_io_map_init

(

RzIO *

io

)

Definition at line 101 of file io_map.c.

                                     {
    rz_return_if_fail(io);
    rz_pvector_init(&io->maps, map_free);
    if (io->map_ids) {
        rz_id_pool_free(io->map_ids);
    }
    io->map_ids = rz_id_pool_new(1, END_OF_MAP_IDS);
}

References END_OF_MAP_IDS, map_free(), rz_io_t::map_ids, rz_io_t::maps, rz_id_pool_free(), rz_id_pool_new(), rz_pvector_init(), and rz_return_if_fail.

Referenced by rz_io_init(), rz_io_map_cleanup(), and rz_io_map_reset().

rz_io_map_is_mapped()

RZ_API bool rz_io_map_is_mapped	(	RzIO *	io,
		ut64	addr
	)

Definition at line 181 of file io_map.c.

                                                     {
    rz_return_val_if_fail(io, false);
    return (bool)rz_io_map_get(io, addr);
}

References addr, rz_io_map_get(), and rz_return_val_if_fail.

Referenced by bp_is_mapped().

rz_io_map_location()

RZ_API ut64 rz_io_map_location	(	RzIO *	io,
		ut64	size
	)

Returns a memory location that can hold enough bytes without overlapping.

Parameters

io	RzIO instance
size	Size of the section

Definition at line 425 of file io_map.c.

                                                    {
    ut64 base = (io->bits == 64) ? 0x60000000000ULL : 0x60000000ULL;
    return rz_io_map_next_available(io, base, size, 0x200000);
}

References rz_io_t::bits, rz_io_map_next_available(), and ut64().

Referenced by rz_core_bin_load().

rz_io_map_new()

RZ_API RzIOMap* rz_io_map_new	(	RzIO *	io,
		int	fd,
		int	flags,
		ut64	delta,
		ut64	addr,
		ut64	size
	)

Definition at line 50 of file io_map.c.

                                                                                            {
    return io_map_new(io, fd, perm, delta, addr, size);
}

References addr, delta, fd, and io_map_new().

Referenced by handle_tmp_desc(), perform_mapped_file_yank(), rz_core_bin_load(), rz_core_cmd_subst_i(), rz_debug_dmp_init(), rz_io_map_remap(), rz_io_map_resize(), rz_io_open(), rz_io_open_at(), and rz_main_rizin().

rz_io_map_next_address()

RZ_API ut64 rz_io_map_next_address	(	RzIO *	io,
		ut64	addr
	)

Definition at line 371 of file io_map.c.

                                                        {
    ut64 lowest = UT64_MAX;
    void **it;
    rz_pvector_foreach (&io->maps, it) {
        RzIOMap *map = *it;
        ut64 from = rz_itv_begin(map->itv);
        if (from > addr && addr < lowest) {
            lowest = from;
        }
        ut64 to = rz_itv_end(map->itv);
        if (to > addr && to < lowest) {
            lowest = to;
        }
    }
    return lowest;
}

References addr, from, map(), rz_io_t::maps, rz_itv_begin(), rz_itv_end(), rz_pvector_foreach, to, ut64(), and UT64_MAX.

Referenced by rz_core_search_value_in_range().

rz_io_map_next_available()

RZ_API ut64 rz_io_map_next_available	(	RzIO *	io,
		ut64	addr,
		ut64	size,
		ut64	load_align
	)

Definition at line 347 of file io_map.c.

                                                                                      {
    if (load_align == 0) {
        load_align = 1;
    }
    void **it;
    ut64 next_addr = addr,
         end_addr = next_addr + size;
    rz_pvector_foreach (&io->maps, it) {
        RzIOMap *map = *it;
        if (!rz_itv_size(map->itv)) {
            break;
        }
        ut64 to = rz_itv_end(map->itv);
        next_addr = RZ_MAX(next_addr, to + (load_align - (to % load_align)) % load_align);
        if ((map->itv.addr <= next_addr && next_addr < to) || rz_itv_contain(map->itv, end_addr)) {
            next_addr = to + (load_align - (to % load_align)) % load_align;
            continue;
        }
        break;
    }
    return next_addr;
}

References addr, map(), rz_io_t::maps, rz_itv_contain(), rz_itv_end(), rz_itv_size(), RZ_MAX, rz_pvector_foreach, to, and ut64().

Referenced by get_esil_stack_name(), perform_mapped_file_yank(), and rz_io_map_location().

rz_io_map_priorize()

RZ_API bool rz_io_map_priorize	(	RzIO *	io,
		ut32	id
	)

Definition at line 232 of file io_map.c.

                                                  {
    rz_return_val_if_fail(io, false);
    size_t i;
    for (i = 0; i < rz_pvector_len(&io->maps); i++) {
        RzIOMap *map = rz_pvector_at(&io->maps, i);
        // search for iter with the correct map
        if (map->id == id) {
            rz_pvector_remove_at(&io->maps, i);
            rz_pvector_push(&io->maps, map);
            rz_skyline_add(&io->map_skyline, map->itv, map);
            return true;
        }
    }
    return false;
}

References i, map(), rz_io_t::map_skyline, rz_io_t::maps, rz_pvector_at(), rz_pvector_len(), rz_pvector_push(), rz_pvector_remove_at(), rz_return_val_if_fail, and rz_skyline_add().

Referenced by rz_open_maps_prioritize_binid_handler(), and rz_open_maps_prioritize_handler().

rz_io_map_priorize_for_fd()

RZ_API bool rz_io_map_priorize_for_fd	(	RzIO *	io,
		int	fd
	)

Definition at line 264 of file io_map.c.

                                                        {
    rz_return_val_if_fail(io, false);
    // we need a clean list for this, or this becomes a segfault-field
    rz_io_map_cleanup(io);
    RzPVector temp;
    rz_pvector_init(&temp, NULL);
    size_t i;
    for (i = 0; i < rz_pvector_len(&io->maps);) {
        RzIOMap *map = rz_pvector_at(&io->maps, i);
        if (map->fd == fd) {
            rz_pvector_push(&temp, map);
            rz_pvector_remove_at(&io->maps, i);
            continue;
        }
        i++;
    }
    rz_pvector_insert_range(&io->maps, rz_pvector_len(&io->maps), temp.v.a, rz_pvector_len(&temp));
    rz_pvector_clear(&temp);
    io_map_calculate_skyline(io);
    return true;
}

References rz_vector_t::a, fd, i, io_map_calculate_skyline(), map(), rz_io_t::maps, NULL, rz_io_map_cleanup(), rz_pvector_at(), rz_pvector_clear(), rz_pvector_init(), rz_pvector_insert_range(), rz_pvector_len(), rz_pvector_push(), rz_pvector_remove_at(), rz_return_val_if_fail, and rz_pvector_t::v.

Referenced by rz_open_maps_prioritize_fd_handler().

rz_io_map_remap()

RZ_API bool rz_io_map_remap	(	RzIO *	io,
		ut32	id,
		ut64	addr
	)

Definition at line 54 of file io_map.c.

                                                          {
    RzIOMap *map = rz_io_map_resolve(io, id);
    if (map) {
        ut64 size = map->itv.size;
        map->itv.addr = addr;
        if (size && UT64_MAX - size + 1 < addr) {
            map->itv.size = -addr;
            rz_io_map_new(io, map->fd, map->perm, map->delta - addr, 0, size + addr);
        }
        io_map_calculate_skyline(io);
        return true;
    }
    return false;
}

References addr, io_map_calculate_skyline(), map(), rz_io_map_new(), rz_io_map_resolve(), ut64(), and UT64_MAX.

Referenced by rz_debug_dmp_init(), rz_io_map_remap_fd(), rz_open_maps_relocate_current_handler(), and rz_open_maps_relocate_handler().

rz_io_map_remap_fd()

RZ_API bool rz_io_map_remap_fd	(	RzIO *	io,
		int	fd,
		ut64	addr
	)

Definition at line 69 of file io_map.c.

                                                            {
    RzIOMap *map;
    bool retval = false;
    RzList *maps = rz_io_map_get_for_fd(io, fd);
    if (maps) {
        map = rz_list_get_n(maps, 0);
        if (map) {
            retval = rz_io_map_remap(io, map->id, addr);
        }
        rz_list_free(maps);
    }
    return retval;
}

References addr, fd, map(), maps(), rz_io_map_get_for_fd(), rz_io_map_remap(), rz_list_free(), and rz_list_get_n().

Referenced by rz_io_bind().

rz_io_map_reset()

RZ_API void rz_io_map_reset

(

RzIO *

io

)

Definition at line 186 of file io_map.c.

                                      {
    rz_io_map_fini(io);
    rz_io_map_init(io);
    io_map_calculate_skyline(io);
}

References io_map_calculate_skyline(), rz_io_map_fini(), and rz_io_map_init().

Referenced by rz_io_close_all(), and rz_open_maps_remove_all_handler().

rz_io_map_resize()

RZ_API bool rz_io_map_resize	(	RzIO *	io,
		ut32	id,
		ut64	newsize
	)

Definition at line 403 of file io_map.c.

                                                              {
    RzIOMap *map;
    if (!(map = rz_io_map_resolve(io, id))) {
        return false;
    }
    ut64 addr = map->itv.addr;
    if (newsize && UT64_MAX - newsize + 1 < addr) {
        map->itv.size = -addr;
        rz_io_map_new(io, map->fd, map->perm, map->delta - addr, 0, newsize + addr);
        return true;
    }
    map->itv.size = newsize;
    io_map_calculate_skyline(io);
    return true;
}

References addr, io_map_calculate_skyline(), map(), rz_io_map_new(), rz_io_map_resolve(), ut64(), and UT64_MAX.

Referenced by rz_io_resize(), and rz_open_maps_resize_handler().

rz_io_map_resolve()

RZ_API RzIOMap* rz_io_map_resolve	(	RzIO *	io,
		ut32	id
	)

Definition at line 128 of file io_map.c.

                                                     {
    rz_return_val_if_fail(io && id, false);
    void **it;
    rz_pvector_foreach (&io->maps, it) {
        RzIOMap *map = *it;
        if (map->id == id) {
            return map;
        }
    }
    return NULL;
}

References map(), rz_io_t::maps, NULL, rz_pvector_foreach, and rz_return_val_if_fail.

Referenced by rz_io_map_exists_for_id(), rz_io_map_remap(), rz_io_map_resize(), rz_open_maps_flags_handler(), rz_open_maps_name_id_del_handler(), and rz_open_maps_name_id_handler().

rz_io_map_set_name()

RZ_API void rz_io_map_set_name	(	RzIOMap *	map,
		const char *	name
	)

Definition at line 332 of file io_map.c.

                                                               {
    if (!map || !name) {
        return;
    }
    free(map->name);
    map->name = strdup(name);
}

References free(), map(), and strdup().

Referenced by ds_init(), rz_core_analysis_esil_init_mem(), rz_open_maps_all_fd_handler(), rz_open_maps_map_fd_handler(), rz_open_maps_map_handler(), rz_open_maps_name_handler(), and rz_open_maps_name_id_handler().

rz_io_maps()

RZ_API RZ_BORROW RzPVector* rz_io_maps

(

RzIO *

io

)

Returns the pointer to vector containing maps list.

Parameters

io	RzIO instance

Definition at line 435 of file io_map.c.

                                                 {
    rz_return_val_if_fail(io, NULL);
    return &io->maps;
}

References rz_io_t::maps, NULL, and rz_return_val_if_fail.

Referenced by __core_visual_gogo(), get_brks(), open_maps_list(), rz_core_analysis_address(), rz_core_analysis_code_count(), rz_core_analysis_coverage_count(), rz_core_get_boundaries_prot(), rz_core_io_file_reopen(), rz_core_visual_cmd(), rz_heap_resolve_main_arena(), rz_main_rizin(), rz_open_maps_flags_global_handler(), and rz_open_maps_list_ascii_handler().

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	flags,
		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	flags,
		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	flags,
		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	flags,
		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_plugin_add()

RZ_API bool rz_io_plugin_add	(	RzIO *	io,
		RZ_BORROW RzIOPlugin *	plugin
	)

Definition at line 12 of file io_plugin.c.

                                                                     {
    if (!io || !io->plugins || !plugin || !plugin->name) {
        return false;
    }
    RzListIter *it;
    RzIOPlugin *nplugin;
    rz_list_foreach (io->plugins, it, nplugin) {
        if (!strcmp(nplugin->name, plugin->name)) {
            return false;
        }
    }
    nplugin = RZ_NEW0(RzIOPlugin);
    if (!nplugin) {
        return false;
    }
    memcpy(nplugin, plugin, sizeof(RzIOPlugin));
    rz_list_append(io->plugins, nplugin);
    return true;
}

References memcpy(), rz_io_plugin_t::name, rz_io_t::plugins, rz_list_append(), and RZ_NEW0.

Referenced by rz_core_init(), and rz_io_plugin_init().

rz_io_plugin_get_default()

RZ_API RzIOPlugin* rz_io_plugin_get_default	(	RzIO *	io,
		const char *	filename,
		bool	many
	)

Definition at line 47 of file io_plugin.c.

                                                                                       {
    if (!default_plugin || !default_plugin->check || !default_plugin->check(io, filename, many)) {
        return NULL;
    }
    return (RzIOPlugin *)default_plugin;
}

References rz_io_plugin_t::check, default_plugin, and NULL.

Referenced by rz_io_plugin_byname(), and rz_io_plugin_resolve().

rz_io_plugin_init()

RZ_API bool rz_io_plugin_init

(

RzIO *

io

)

Definition at line 32 of file io_plugin.c.

                                        {
    int i;
    if (!io) {
        return false;
    }
    io->plugins = rz_list_newf(free);
    for (i = 0; i < RZ_ARRAY_SIZE(io_static_plugins); i++) {
        if (!io_static_plugins[i]->name) {
            continue;
        }
        rz_io_plugin_add(io, io_static_plugins[i]);
    }
    return true;
}

References free(), i, io_static_plugins, rz_io_t::plugins, RZ_ARRAY_SIZE, rz_io_plugin_add(), and rz_list_newf().

Referenced by rz_io_init().

rz_io_plugin_read()

RZ_API int rz_io_plugin_read	(	RzIODesc *	desc,
		ut8 *	buf,
		int	len
	)

Definition at line 79 of file io_plugin.c.

                                                                {
    if (!buf || !desc || !desc->plugin || len < 1 || !(desc->perm & RZ_PERM_R)) {
        return 0;
    }
    if (!desc->plugin->read) {
        return -1;
    }
    return desc->plugin->read(desc->io, desc, buf, len);
}

References desc, len, and RZ_PERM_R.

Referenced by rz_io_desc_read(), and rz_io_plugin_read_at().

rz_io_plugin_read_at()

RZ_API int rz_io_plugin_read_at	(	RzIODesc *	desc,
		ut64	addr,
		ut8 *	buf,
		int	len
	)

Definition at line 103 of file io_plugin.c.

                                                                              {
    if (rz_io_desc_is_chardevice(desc) || (rz_io_desc_seek(desc, addr, RZ_IO_SEEK_SET) == addr)) {
        return rz_io_plugin_read(desc, buf, len);
    }
    return 0;
}

References addr, desc, len, rz_io_desc_is_chardevice(), rz_io_desc_seek(), rz_io_plugin_read(), and RZ_IO_SEEK_SET.

rz_io_plugin_resolve()

RZ_API RzIOPlugin* rz_io_plugin_resolve	(	RzIO *	io,
		const char *	filename,
		bool	many
	)

Definition at line 54 of file io_plugin.c.

                                                                                   {
    RzListIter *iter;
    RzIOPlugin *ret;
    rz_list_foreach (io->plugins, iter, ret) {
        if (!ret || !ret->check) {
            continue;
        }
        if (ret->check(io, filename, many)) {
            return ret;
        }
    }
    return rz_io_plugin_get_default(io, filename, many);
}

References rz_io_plugin_t::check, rz_io_t::plugins, and rz_io_plugin_get_default().

Referenced by dmp_open(), rz_io_desc_open(), and rz_io_open_many().

rz_io_plugin_write()

RZ_API int rz_io_plugin_write	(	RzIODesc *	desc,
		const ut8 *	buf,
		int	len
	)

Definition at line 89 of file io_plugin.c.

                                                                       {
    if (!buf || !desc || !desc->plugin || len < 1 || !(desc->perm & RZ_PERM_W)) {
        return 0;
    }
    if (!desc->plugin->write) {
        return -1;
    }
    const ut64 cur_addr = rz_io_desc_seek(desc, 0LL, RZ_IO_SEEK_CUR);
    int ret = desc->plugin->write(desc->io, desc, buf, len);
    RzEventIOWrite iow = { cur_addr, buf, len };
    rz_event_send(desc->io->event, RZ_EVENT_IO_WRITE, &iow);
    return ret;
}

References desc, len, RZ_EVENT_IO_WRITE, rz_event_send(), rz_io_desc_seek(), RZ_IO_SEEK_CUR, RZ_PERM_W, and ut64().

Referenced by rz_io_desc_write(), and rz_io_plugin_write_at().

rz_io_plugin_write_at()

RZ_API int rz_io_plugin_write_at	(	RzIODesc *	desc,
		ut64	addr,
		const ut8 *	buf,
		int	len
	)

Definition at line 110 of file io_plugin.c.

                                                                                     {
    if (rz_io_desc_is_chardevice(desc) || rz_io_desc_seek(desc, addr, RZ_IO_SEEK_SET) == addr) {
        return rz_io_plugin_write(desc, buf, len);
    }
    return 0;
}

References addr, desc, len, rz_io_desc_is_chardevice(), rz_io_desc_seek(), rz_io_plugin_write(), and RZ_IO_SEEK_SET.

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

RZ_API bool rz_io_read_i	(	RzIO *	io,
		ut64	addr,
		ut64 *	val,
		int	size,
		bool	endian
	)

Definition at line 41 of file ioutils.c.

                                                                                {
    ut8 buf[8];
    rz_return_val_if_fail(io && val, false);
    size = RZ_DIM(size, 1, 8);
    if (!rz_io_read_at(io, addr, buf, size)) {
        return false;
    }
    // size says the number of bytes to read transform to bits for rz_read_ble
    *val = rz_read_ble(buf, endian, size * 8);
    return true;
}

References addr, RZ_DIM, rz_io_read_at(), rz_read_ble(), rz_return_val_if_fail, and val.

Referenced by core_analysis_followptr(), ds_build_op_str(), and rz_core_analysis_bytes().

rz_io_reopen()

RZ_API bool rz_io_reopen	(	RzIO *	io,
		int	fd,
		int	flags,
		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_update()

RZ_API void rz_io_update

(

RzIO *

io

)

Definition at line 159 of file io_map.c.

                                   {
    io_map_calculate_skyline(io);
}

References io_map_calculate_skyline().

rz_io_use_fd()

RZ_API bool rz_io_use_fd	(	RzIO *	io,
		int	fd
	)

Definition at line 118 of file io_fd.c.

                                           {
    rz_return_val_if_fail(io, false);
    if (!io->desc) {
        io->desc = rz_io_desc_get(io, fd);
        return io->desc != NULL;
    }
    if (io->desc->fd != fd) {
        RzIODesc *desc;
        // update io->desc if fd is not the same
        if (!(desc = rz_io_desc_get(io, fd))) {
            return false;
        }
        io->desc = desc;
    }
    return true;
}

References desc, rz_io_t::desc, fd, rz_io_desc_t::fd, NULL, rz_io_desc_get(), and rz_return_val_if_fail.

Referenced by core_file_do_load_for_io_plugin(), DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), handle_tmp_desc(), map_multi_dex(), perform_mapped_file_yank(), prioritize_file(), rz_core_analysis_search(), rz_core_bin_load(), rz_core_bin_raise(), rz_core_binfiles_delete(), rz_core_cmd_subst_i(), rz_core_file_bin_raise(), rz_core_file_open(), rz_core_file_reopen(), rz_core_file_set_by_fd(), rz_core_shift_block(), rz_io_bind(), rz_open_binary_file_handler(), rz_open_use_handler(), and rz_write_from_file_handler().

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_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_io_write_i()

RZ_API bool rz_io_write_i	(	RzIO *	io,
		ut64	addr,
		ut64 *	val,
		int	size,
		bool	endian
	)

Definition at line 53 of file ioutils.c.

                                                                                 {
    ut8 buf[8];
    rz_return_val_if_fail(io && val, false);
    size = RZ_DIM(size, 1, 8);
    // size says the number of bytes to read transform to bits for rz_read_ble
    rz_write_ble(buf, *val, endian, size * 8);
    return rz_io_write_at(io, addr, buf, size) == size;
}

References addr, RZ_DIM, rz_io_write_at(), rz_return_val_if_fail, rz_write_ble(), and val.

RZ_LIB_VERSION_HEADER()

RZ_LIB_VERSION_HEADER

(

rz_io

)

Variable Documentation

rz_io_plugin_ar

RzIOPlugin rz_io_plugin_ar

extern

Definition at line 135 of file io_ar.c.

Referenced by rz_io_ar_open(), and rz_io_ar_open_many().

rz_io_plugin_bfdbg

RzIOPlugin rz_io_plugin_bfdbg

extern

Definition at line 197 of file io_bfdbg.c.

Referenced by __open().

rz_io_plugin_bochs

RzIOPlugin rz_io_plugin_bochs

extern

Initial value:

= {
    .name = "bochs",
    .desc = "Attach to a BOCHS debugger instance",
    .license = "LGPL3",
    .uris = "bochs://",
    .open = __open,
    .close = __close,
    .read = __read,
    .write = __write,
    .check = __plugin_open,
    .lseek = __lseek,
    .system = __system,
    .isdbg = true
}

Definition at line 106 of file io_bochs.c.

Referenced by __open().

rz_io_plugin_debug

RzIOPlugin rz_io_plugin_debug

extern

Definition at line 571 of file io_debug.c.

rz_io_plugin_default

RzIOPlugin rz_io_plugin_default

extern

Definition at line 200 of file io_default.c.

Referenced by rz_io_def_mmap_open().

rz_io_plugin_dmp

RzIOPlugin rz_io_plugin_dmp

extern

Definition at line 162 of file io_dmp.c.

Referenced by dmp_open().

rz_io_plugin_fd

RzIOPlugin rz_io_plugin_fd

extern

Definition at line 84 of file io_fd.c.

Referenced by __open().

rz_io_plugin_gdb

RzIOPlugin rz_io_plugin_gdb

extern

Definition at line 410 of file io_gdb.c.

Referenced by __open().

rz_io_plugin_gprobe

RzIOPlugin rz_io_plugin_gprobe

extern

Definition at line 1228 of file io_gprobe.c.

Referenced by __open().

rz_io_plugin_gzip

RzIOPlugin rz_io_plugin_gzip

extern

Definition at line 181 of file io_gzip.c.

Referenced by __open().

rz_io_plugin_http

RzIOPlugin rz_io_plugin_http

extern

Definition at line 34 of file io_http.c.

rz_io_plugin_ihex

RzIOPlugin rz_io_plugin_ihex

extern

Definition at line 436 of file io_ihex.c.

Referenced by __open().

rz_io_plugin_mach

RzIOPlugin rz_io_plugin_mach

extern

Definition at line 569 of file io_mach.c.

rz_io_plugin_malloc

RzIOPlugin rz_io_plugin_malloc

extern

Definition at line 50 of file io_malloc.c.

Referenced by __open().

rz_io_plugin_null

RzIOPlugin rz_io_plugin_null

extern

Definition at line 105 of file io_null.c.

Referenced by __open().

rz_io_plugin_procpid

RzIOPlugin rz_io_plugin_procpid

extern

Definition at line 138 of file io_procpid.c.

rz_io_plugin_ptrace

RzIOPlugin rz_io_plugin_ptrace

extern

Definition at line 1 of file io_ptrace.c.

rz_io_plugin_qnx

RzIOPlugin rz_io_plugin_qnx

extern

Definition at line 148 of file io_qnx.c.

Referenced by __open().

rz_io_plugin_rap

RzIOPlugin rz_io_plugin_rap

extern

Definition at line 279 of file io_rap.c.

Referenced by __rap_open().

rz_io_plugin_rzk

RzIOPlugin rz_io_plugin_rzk

extern

Definition at line 137 of file io_rzk.c.

Referenced by rzk__open().

rz_io_plugin_rzpipe

RzIOPlugin rz_io_plugin_rzpipe

extern

Definition at line 177 of file io_rzpipe.c.

Referenced by __open().

rz_io_plugin_rzweb

RzIOPlugin rz_io_plugin_rzweb

extern

Definition at line 156 of file io_rzweb.c.

Referenced by __open().

rz_io_plugin_self

RzIOPlugin rz_io_plugin_self

extern

Definition at line 848 of file io_self.c.

rz_io_plugin_shm

RzIOPlugin rz_io_plugin_shm

extern

Definition at line 267 of file io_shm.c.

rz_io_plugin_sparse

RzIOPlugin rz_io_plugin_sparse

extern

Definition at line 110 of file io_sparse.c.

Referenced by __open().

rz_io_plugin_srec

RzIOPlugin rz_io_plugin_srec

extern

Definition at line 549 of file io_srec.c.

Referenced by __open().

rz_io_plugin_tcp

RzIOPlugin rz_io_plugin_tcp

extern

Definition at line 86 of file io_tcp.c.

Referenced by __open().

rz_io_plugin_w32

RzIOPlugin rz_io_plugin_w32

extern

Definition at line 1 of file io_w32.c.

rz_io_plugin_w32dbg

RzIOPlugin rz_io_plugin_w32dbg

extern

Definition at line 215 of file io_w32dbg.c.

rz_io_plugin_windbg

RzIOPlugin rz_io_plugin_windbg

extern

Definition at line 684 of file io_windbg.c.

Referenced by windbg_open().

rz_io_plugin_winedbg

RzIOPlugin rz_io_plugin_winedbg

extern

Definition at line 366 of file io_winedbg.c.

Referenced by __open().

rz_io_plugin_winkd

RzIOPlugin rz_io_plugin_winkd

extern

Definition at line 148 of file io_winkd.c.

Referenced by __open().

rz_io_plugin_zip

RzIOPlugin rz_io_plugin_zip

extern

Definition at line 675 of file io_zip.c.

Referenced by find_apk_binary(), rz_io_zip_open(), and rz_io_zip_open_many().