#include <rz_types.h>
#include <rz_util.h>
#include <rz_lib.h>
#include <rz_bin.h>
#include "wasm.h"

Typedefs
typedef size_t(*	ConsumeFcn) (const ut8 p, const ut8 max, ut32 *out_value)

typedef void (	ParseEntryFcn) (RzBuffer *b, ut64 max)

Functions
static ut32	consume_r (RzBuffer b, ut64 max, size_t n_out, ConsumeFcn consume_fcn)

static size_t	consume_u32_r (RzBuffer b, ut64 max, ut32 out)

static size_t	consume_u7_r (RzBuffer b, ut64 max, ut8 out)

static size_t	consume_s7_r (RzBuffer b, ut64 max, st8 out)

static size_t	consume_u1_r (RzBuffer b, ut64 max, ut8 out)

static size_t	consume_str_r (RzBuffer b, ut64 max, size_t sz, char out)

static size_t	consume_init_expr_r (RzBuffer b, ut64 max, ut8 eoc, void out)

static size_t	consume_locals_r (RzBuffer b, ut64 max, RzBinWasmCodeEntry out)

static size_t	consume_limits_r (RzBuffer b, ut64 max, struct rz_bin_wasm_resizable_limits_t out)

static RzList *	rz_bin_wasm_get_sections_by_id (RzList *sections, ut8 id)

static void	rz_bin_wasm_free_types (RzBinWasmTypeEntry *ptr)

static void	rz_bin_wasm_free_codes (RzBinWasmCodeEntry *ptr)

static RzList *	get_entries_from_section (RzBinWasmObj bin, RzBinWasmSection sec, ParseEntryFcn parse_entry, RzListFree free_entry)

static void *	parse_type_entry (RzBuffer *b, ut64 max)

static void *	parse_import_entry (RzBuffer *b, ut64 max)

static void *	parse_export_entry (RzBuffer *b, ut64 max)

static void *	parse_code_entry (RzBuffer *b, ut64 max)

static void *	parse_data_entry (RzBuffer *b, ut64 max)

static bool	parse_namemap (RzBuffer b, ut64 max, RzIDStorage map, ut32 *count)

static void *	parse_custom_name_entry (RzBuffer *b, ut64 max)

static void *	parse_memory_entry (RzBuffer *b, ut64 max)

static void *	parse_table_entry (RzBuffer *b, ut64 max)

static void *	parse_global_entry (RzBuffer *b, ut64 max)

static void *	parse_element_entry (RzBuffer *b, ut64 max)

static RzList *	rz_bin_wasm_get_type_entries (RzBinWasmObj bin, RzBinWasmSection sec)

static RzList *	rz_bin_wasm_get_import_entries (RzBinWasmObj bin, RzBinWasmSection sec)

static RzList *	rz_bin_wasm_get_export_entries (RzBinWasmObj bin, RzBinWasmSection sec)

static RzList *	rz_bin_wasm_get_code_entries (RzBinWasmObj bin, RzBinWasmSection sec)

static RzList *	rz_bin_wasm_get_data_entries (RzBinWasmObj bin, RzBinWasmSection sec)

static RzBinWasmStartEntry *	rz_bin_wasm_get_start (RzBinWasmObj bin, RzBinWasmSection sec)

static RzList *	rz_bin_wasm_get_memory_entries (RzBinWasmObj bin, RzBinWasmSection sec)

static RzList *	rz_bin_wasm_get_table_entries (RzBinWasmObj bin, RzBinWasmSection sec)

static RzList *	rz_bin_wasm_get_global_entries (RzBinWasmObj bin, RzBinWasmSection sec)

static RzList *	rz_bin_wasm_get_element_entries (RzBinWasmObj bin, RzBinWasmSection sec)

static RzList *	rz_bin_wasm_get_custom_name_entries (RzBinWasmObj bin, RzBinWasmSection sec)

RzBinWasmObj *	rz_bin_wasm_init (RzBinFile bf, RzBuffer buf)

void	rz_bin_wasm_destroy (RzBinFile *bf)

RzList *	rz_bin_wasm_get_sections (RzBinWasmObj *bin)

ut32	rz_bin_wasm_get_entrypoint (RzBinWasmObj *bin)

RzList *	rz_bin_wasm_get_imports (RzBinWasmObj *bin)

RzList *	rz_bin_wasm_get_exports (RzBinWasmObj *bin)

RzList *	rz_bin_wasm_get_types (RzBinWasmObj *bin)

RzList *	rz_bin_wasm_get_tables (RzBinWasmObj *bin)

RzList *	rz_bin_wasm_get_memories (RzBinWasmObj *bin)

RzList *	rz_bin_wasm_get_globals (RzBinWasmObj *bin)

RzList *	rz_bin_wasm_get_elements (RzBinWasmObj *bin)

RzList *	rz_bin_wasm_get_codes (RzBinWasmObj *bin)

RzList *	rz_bin_wasm_get_datas (RzBinWasmObj *bin)

RzList *	rz_bin_wasm_get_custom_names (RzBinWasmObj *bin)

const char *	rz_bin_wasm_get_function_name (RzBinWasmObj *bin, ut32 idx)

Typedef Documentation

◆ ConsumeFcn

typedef size_t(* ConsumeFcn) (const ut8 *p, const ut8 *max, ut32 *out_value)

Definition at line 12 of file wasm.c.

◆ ParseEntryFcn

typedef void*(* ParseEntryFcn) (RzBuffer *b, ut64 max)

Definition at line 13 of file wasm.c.

Function Documentation

◆ consume_init_expr_r()

static size_t consume_init_expr_r	(	RzBuffer *	b,
		ut64	max,
		ut8	eoc,
		void *	out
	)

static

Definition at line 93 of file wasm.c.

                                                                              {
     if (!b || max >= rz_buf_size(b) || rz_buf_tell(b) > max) {
         return 0;
     }
     size_t res = 0;
     ut8 cur;
     if (!rz_buf_read8(b, &cur)) {
         return 0;
     }
     while (rz_buf_tell(b) <= max && cur != eoc) {
         if (!rz_buf_read8(b, &cur)) {
             return 0;
         }
         res++;
     }
     if (cur != eoc) {
         return 0;
     }
     return res + 1;
 }

References b, max, rz_buf_read8(), rz_buf_size(), and rz_buf_tell().

Referenced by parse_data_entry(), parse_element_entry(), and parse_global_entry().

◆ consume_limits_r()

static size_t consume_limits_r	(	RzBuffer *	b,
		ut64	max,
		struct rz_bin_wasm_resizable_limits_t *	out
	)

static

Definition at line 144 of file wasm.c.

                                                                                                   {
     if (!b || max >= rz_buf_size(b) || rz_buf_tell(b) > max || !out) {
         return 0;
     }
     ut32 i = rz_buf_tell(b);
     if (!(consume_u7_r(b, max, &out->flags))) {
         return 0;
     }
     if (!(consume_u32_r(b, max, &out->initial))) {
         return 0;
     }
     if (out->flags && (!(consume_u32_r(b, max, &out->maximum)))) {
         return 0;
     }
     return (size_t)(rz_buf_tell(b) - i);
 }

References b, consume_u32_r(), consume_u7_r(), i, max, out, rz_buf_size(), and rz_buf_tell().

Referenced by parse_import_entry(), parse_memory_entry(), and parse_table_entry().

◆ consume_locals_r()

static size_t consume_locals_r	(	RzBuffer *	b,
		ut64	max,
		RzBinWasmCodeEntry *	out
	)

static

Definition at line 114 of file wasm.c.

                                                                                {
     ut64 cur = rz_buf_tell(b);
     if (!b || max >= rz_buf_size(b) || cur > max) {
         return 0;
     }
     ut32 count = out->local_count;
     if (count > 0) {
         if (!(out->locals = RZ_NEWS0(struct rz_bin_wasm_local_entry_t, count))) {
             return 0;
         }
     }
     ut32 j = 0;
     while (rz_buf_tell(b) <= max && j < count) {
         if (!(consume_u32_r(b, max, &out->locals[j].count))) {
             goto beach;
         }
         if (!(consume_s7_r(b, max, (st8 *)&out->locals[j].type))) {
             goto beach;
         }
         j++;
     }
     if (j != count) {
         goto beach;
     }
     return j;
 beach:
     RZ_FREE(out->locals);
     return 0;
 }

References b, consume_s7_r(), consume_u32_r(), count, max, out, rz_buf_size(), rz_buf_tell(), RZ_FREE, RZ_NEWS0, st8, and ut64().

Referenced by parse_code_entry().

◆ consume_r()

static ut32 consume_r	(	RzBuffer *	b,
		ut64	max,
		size_t *	n_out,
		ConsumeFcn	consume_fcn
	)

static

Definition at line 16 of file wasm.c.

                                                                                     {
     rz_return_val_if_fail(b && n_out && consume_fcn, 0);
  
     size_t n;
     ut32 tmp;
     ut64 cur = rz_buf_tell(b);
     if (max >= rz_buf_size(b) || cur > max) {
         return 0;
     }
     // 16 bytes are enough to store 128bits values
     ut8 *buf = RZ_NEWS(ut8, 16);
     if (!buf) {
         return 0;
     }
     rz_buf_read(b, buf, 16);
     if (!(n = consume_fcn(buf, buf + max + 1, &tmp))) {
         free(buf);
         return 0;
     }
     rz_buf_seek(b, cur + n, RZ_BUF_SET);
     *n_out = n;
     free(buf);
     return tmp;
 }

References b, free(), max, n, rz_buf_read(), rz_buf_seek(), RZ_BUF_SET, rz_buf_size(), rz_buf_tell(), RZ_NEWS, rz_return_val_if_fail, autogen_x86imm::tmp, and ut64().

Referenced by consume_s7_r(), consume_u1_r(), consume_u32_r(), and consume_u7_r().

◆ consume_s7_r()

static size_t consume_s7_r	(	RzBuffer *	b,
		ut64	max,
		st8 *	out
	)

static

Definition at line 59 of file wasm.c.

                                                             {
     size_t n = 0;
     ut32 tmp = consume_r(b, max, &n, (ConsumeFcn)read_i32_leb128);
     if (out) {
         *out = (st8)(((tmp & 0x10000000) << 7) | (tmp & 0x7f));
     }
     return n;
 }

References b, consume_r(), max, n, out, read_i32_leb128(), st8, and autogen_x86imm::tmp.

Referenced by consume_locals_r(), parse_import_entry(), parse_table_entry(), and parse_type_entry().

◆ consume_str_r()

static size_t consume_str_r	(	RzBuffer *	b,
		ut64	max,
		size_t	sz,
		char *	out
	)

static

Definition at line 77 of file wasm.c.

                                                                          {
     ut64 cur = rz_buf_tell(b);
     if (!b || max >= rz_buf_size(b) || cur > max) {
         return 0;
     }
     if (!(cur + sz - 1 <= max)) {
         return 0;
     }
     if (sz > 0) {
         rz_buf_read(b, (ut8 *)out, RZ_MIN(RZ_BIN_WASM_STRING_LENGTH - 1, sz));
     } else {
         *out = 0;
     }
     return sz;
 }

References b, max, out, RZ_BIN_WASM_STRING_LENGTH, rz_buf_read(), rz_buf_size(), rz_buf_tell(), RZ_MIN, and ut64().

Referenced by parse_custom_name_entry(), parse_export_entry(), parse_import_entry(), parse_namemap(), and rz_bin_wasm_get_sections().

◆ consume_u1_r()

static size_t consume_u1_r	(	RzBuffer *	b,
		ut64	max,
		ut8 *	out
	)

static

Definition at line 68 of file wasm.c.

                                                             {
     size_t n = 0;
     ut32 tmp = consume_r(b, max, &n, read_u32_leb128);
     if (out) {
         *out = (ut8)(tmp & 0x1);
     }
     return n;
 }

References b, consume_r(), max, n, out, read_u32_leb128(), autogen_x86imm::tmp, and ut8.

Referenced by parse_global_entry(), parse_import_entry(), and parse_type_entry().

◆ consume_u32_r()

static size_t consume_u32_r	(	RzBuffer *	b,
		ut64	max,
		ut32 *	out
	)

static

Definition at line 41 of file wasm.c.

                                                               {
     size_t n = 0;
     ut32 tmp = consume_r(b, max, &n, read_u32_leb128);
     if (out) {
         *out = tmp;
     }
     return n;
 }

References b, consume_r(), max, n, out, read_u32_leb128(), and autogen_x86imm::tmp.

Referenced by consume_limits_r(), consume_locals_r(), parse_code_entry(), parse_custom_name_entry(), parse_data_entry(), parse_element_entry(), parse_export_entry(), parse_import_entry(), parse_namemap(), parse_type_entry(), rz_bin_wasm_get_sections(), and rz_bin_wasm_get_start().

◆ consume_u7_r()

static size_t consume_u7_r	(	RzBuffer *	b,
		ut64	max,
		ut8 *	out
	)

static

Definition at line 50 of file wasm.c.

                                                             {
     size_t n = 0;
     ut32 tmp = consume_r(b, max, &n, read_u32_leb128);
     if (out) {
         *out = (ut8)(tmp & 0x7f);
     }
     return n;
 }

References b, consume_r(), max, n, out, read_u32_leb128(), autogen_x86imm::tmp, and ut8.

Referenced by consume_limits_r(), parse_custom_name_entry(), parse_export_entry(), parse_global_entry(), parse_import_entry(), parse_type_entry(), and rz_bin_wasm_get_sections().

◆ get_entries_from_section()

static RzList* get_entries_from_section	(	RzBinWasmObj *	bin,
		RzBinWasmSection *	sec,
		ParseEntryFcn	parse_entry,
		RzListFree	free_entry
	)

static

Definition at line 236 of file wasm.c.

                                                                                                                                     {
     rz_return_val_if_fail(sec && bin, NULL);
  
     RzList *ret = rz_list_newf(free_entry);
     if (!ret) {
         return NULL;
     }
     RzBuffer *b = bin->buf;
     rz_buf_seek(b, sec->payload_data, RZ_BUF_SET);
     ut32 r = 0;
     ut64 max = rz_buf_tell(b) + sec->payload_len - 1;
     if (!(max < rz_buf_size(b))) {
         goto beach;
     }
     while (rz_buf_tell(b) <= max && r < sec->count) {
         void *entry = parse_entry(b, max);
         if (!entry) {
             goto beach;
         }
  
         if (!rz_list_append(ret, entry)) {
             free_entry(entry);
             // should this jump to beach?
         }
         r++;
     }
     return ret;
 beach:
     RZ_LOG_ERROR("wasm: failed to read entries for section %s\n", sec->name);
     return ret;
 }

References b, bin::buf, count, max, rz_bin_wasm_section_t::name, NULL, rz_bin_wasm_section_t::payload_data, rz_bin_wasm_section_t::payload_len, r, rz_buf_seek(), RZ_BUF_SET, rz_buf_size(), rz_buf_tell(), rz_list_append(), rz_list_newf(), RZ_LOG_ERROR, rz_return_val_if_fail, and ut64().

Referenced by rz_bin_wasm_get_code_entries(), rz_bin_wasm_get_data_entries(), rz_bin_wasm_get_element_entries(), rz_bin_wasm_get_export_entries(), rz_bin_wasm_get_global_entries(), rz_bin_wasm_get_import_entries(), rz_bin_wasm_get_memory_entries(), rz_bin_wasm_get_table_entries(), and rz_bin_wasm_get_type_entries().

◆ parse_code_entry()

static void* parse_code_entry	(	RzBuffer *	b,
		ut64	max
	)

static

Definition at line 392 of file wasm.c.

                                                      {
     RzBinWasmCodeEntry *ptr = RZ_NEW0(RzBinWasmCodeEntry);
     if (!ptr) {
         return NULL;
     }
     if (!(consume_u32_r(b, max, &ptr->body_size))) {
         goto beach;
     }
     ut32 j = rz_buf_tell(b);
     if (!(rz_buf_tell(b) + ptr->body_size - 1 <= max)) {
         goto beach;
     }
     if (!(consume_u32_r(b, max, &ptr->local_count))) {
         goto beach;
     }
     if (consume_locals_r(b, max, ptr) < ptr->local_count) {
         goto beach;
     }
     ptr->code = rz_buf_tell(b);
     ptr->len = ptr->body_size - ptr->code + j;
     rz_buf_seek(b, ptr->len - 1, RZ_BUF_CUR); // consume bytecode
     rz_buf_read(b, &ptr->byte, 1);
     if (ptr->byte != RZ_BIN_WASM_END_OF_CODE) {
         goto beach;
     }
     return ptr;
  
 beach:
     rz_bin_wasm_free_codes(ptr);
     return NULL;
 }

References b, rz_bin_wasm_code_t::body_size, rz_bin_wasm_code_t::byte, rz_bin_wasm_code_t::code, consume_locals_r(), consume_u32_r(), rz_bin_wasm_code_t::len, rz_bin_wasm_code_t::local_count, max, NULL, RZ_BIN_WASM_END_OF_CODE, rz_bin_wasm_free_codes(), RZ_BUF_CUR, rz_buf_read(), rz_buf_seek(), rz_buf_tell(), and RZ_NEW0.

Referenced by rz_bin_wasm_get_code_entries().

◆ parse_custom_name_entry()

static void* parse_custom_name_entry	(	RzBuffer *	b,
		ut64	max
	)

static

Definition at line 485 of file wasm.c.

                                                             {
     RzBinWasmCustomNameEntry *ptr = NULL;
     size_t i;
     if (!(ptr = RZ_NEW0(RzBinWasmCustomNameEntry))) {
         return NULL;
     }
  
     if (!(consume_u7_r(b, max, &ptr->type))) {
         goto beach;
     };
  
     if (!(consume_u32_r(b, max, &ptr->size))) {
         goto beach;
     };
  
     switch (ptr->type) {
     case RZ_BIN_WASM_NAMETYPE_Module:
         ptr->mod_name = RZ_NEW0(struct rz_bin_wasm_name_t);
         if (!ptr->mod_name) {
             goto beach;
         }
         if (!(consume_u32_r(b, max, &ptr->mod_name->len))) {
             goto beach;
         }
  
         if (!(consume_str_r(b, max, ptr->mod_name->len, (char *)ptr->mod_name->name))) {
             goto beach;
         }
  
         ptr->mod_name->name[ptr->mod_name->len] = 0;
         break;
     case RZ_BIN_WASM_NAMETYPE_Function:
         ptr->func = RZ_NEW0(RzBinWasmCustomNameFunctionNames);
         if (!ptr->func) {
             goto beach;
         }
  
         ptr->func->names = rz_id_storage_new(0, UT32_MAX);
  
         if (!ptr->func->names) {
             goto beach;
         }
  
         if (!parse_namemap(b, max, ptr->func->names, &ptr->func->count)) {
             goto beach;
         }
         break;
     case RZ_BIN_WASM_NAMETYPE_Local:
         ptr->local = RZ_NEW0(RzBinWasmCustomNameLocalNames);
         if (!ptr->local) {
             goto beach;
         }
         if (!(consume_u32_r(b, max, &ptr->local->count))) {
             free(ptr->local);
             goto beach;
         }
  
         ptr->local->locals = rz_list_new();
  
         for (i = 0; i < ptr->local->count; i++) {
             RzBinWasmCustomNameLocalName *local_name = RZ_NEW0(RzBinWasmCustomNameLocalName);
             if (!local_name) {
                 free(ptr->local);
                 free(ptr);
                 return NULL;
             }
  
             if (!(consume_u32_r(b, max, &local_name->index))) {
                 rz_list_free(ptr->local->locals);
                 free(ptr->local);
                 free(local_name);
                 goto beach;
             }
  
             local_name->names = rz_id_storage_new(0, UT32_MAX);
             if (!local_name->names) {
                 rz_list_free(ptr->local->locals);
                 free(ptr->local);
                 free(local_name);
                 goto beach;
             }
  
             if (!parse_namemap(b, max, local_name->names, &local_name->names_count)) {
                 rz_id_storage_free(local_name->names);
                 rz_list_free(ptr->local->locals);
                 free(ptr->local);
                 free(local_name);
                 goto beach;
             }
  
             if (!rz_list_append(ptr->local->locals, local_name)) {
                 free(local_name);
                 goto beach;
             };
         }
         break;
     }
  
     return ptr;
 beach:
     free(ptr);
     return NULL;
 }

Referenced by rz_bin_wasm_get_custom_name_entries().

◆ parse_data_entry()

static void* parse_data_entry	(	RzBuffer *	b,
		ut64	max
	)

static

Definition at line 424 of file wasm.c.

                                                      {
     RzBinWasmDataEntry *ptr = RZ_NEW0(RzBinWasmDataEntry);
     if (!ptr) {
         return NULL;
     }
     if (!(consume_u32_r(b, max, &ptr->index))) {
         goto beach;
     }
     if (!(ptr->offset.len = consume_init_expr_r(b, max, RZ_BIN_WASM_END_OF_CODE, NULL))) {
         goto beach;
     }
     if (!(consume_u32_r(b, max, &ptr->size))) {
         goto beach;
     }
     ptr->data = rz_buf_tell(b);
     rz_buf_seek(b, ptr->size, RZ_BUF_CUR);
     return ptr;
  
 beach:
     free(ptr);
     return NULL;
 }

References b, consume_init_expr_r(), consume_u32_r(), rz_bin_wasm_data_t::data, free(), rz_bin_wasm_data_t::index, rz_bin_wasm_init_expr_t::len, max, NULL, rz_bin_wasm_data_t::offset, RZ_BIN_WASM_END_OF_CODE, RZ_BUF_CUR, rz_buf_seek(), rz_buf_tell(), RZ_NEW0, and rz_bin_wasm_data_t::size.

Referenced by rz_bin_wasm_get_data_entries().

◆ parse_element_entry()

static void* parse_element_entry	(	RzBuffer *	b,
		ut64	max
	)

static

Definition at line 643 of file wasm.c.

                                                         {
     RzBinWasmElementEntry *ptr = RZ_NEW0(RzBinWasmElementEntry);
     if (!ptr) {
         return NULL;
     }
     if (!(consume_u32_r(b, max, &ptr->index))) {
         goto beach;
     }
     if (!(consume_init_expr_r(b, max, RZ_BIN_WASM_END_OF_CODE, NULL))) {
         goto beach;
     }
     if (!(consume_u32_r(b, max, &ptr->num_elem))) {
         goto beach;
     }
     ut32 j = 0;
     while (rz_buf_tell(b) <= max && j < ptr->num_elem) {
         // TODO: allocate space and fill entry
         if (!(consume_u32_r(b, max, NULL))) {
             goto beach;
         }
     }
     return ptr;
  
 beach:
     free(ptr);
     return NULL;
 }

References b, consume_init_expr_r(), consume_u32_r(), free(), rz_bin_wasm_element_t::index, max, NULL, rz_bin_wasm_element_t::num_elem, RZ_BIN_WASM_END_OF_CODE, rz_buf_tell(), and RZ_NEW0.

Referenced by rz_bin_wasm_get_element_entries().

◆ parse_export_entry()

static void* parse_export_entry	(	RzBuffer *	b,
		ut64	max
	)

static

Definition at line 369 of file wasm.c.

                                                        {
     RzBinWasmExportEntry *ptr = RZ_NEW0(RzBinWasmExportEntry);
     if (!ptr) {
         return NULL;
     }
     if (!(consume_u32_r(b, max, &ptr->field_len))) {
         goto beach;
     }
     if (consume_str_r(b, max, ptr->field_len, ptr->field_str) < ptr->field_len) {
         goto beach;
     }
     if (!(consume_u7_r(b, max, &ptr->kind))) {
         goto beach;
     }
     if (!(consume_u32_r(b, max, &ptr->index))) {
         goto beach;
     }
     return ptr;
 beach:
     free(ptr);
     return NULL;
 }

References b, consume_str_r(), consume_u32_r(), consume_u7_r(), rz_bin_wasm_export_t::field_len, rz_bin_wasm_export_t::field_str, free(), rz_bin_wasm_export_t::index, rz_bin_wasm_export_t::kind, max, NULL, and RZ_NEW0.

Referenced by rz_bin_wasm_get_export_entries().

◆ parse_global_entry()

static void* parse_global_entry	(	RzBuffer *	b,
		ut64	max
	)

static

Definition at line 622 of file wasm.c.

                                                        {
     RzBinWasmGlobalEntry *ptr = RZ_NEW0(RzBinWasmGlobalEntry);
     if (!ptr) {
         return NULL;
     }
     if (!(consume_u7_r(b, max, (ut8 *)&ptr->content_type))) {
         goto beach;
     }
     if (!(consume_u1_r(b, max, &ptr->mutability))) {
         goto beach;
     }
     if (!(consume_init_expr_r(b, max, RZ_BIN_WASM_END_OF_CODE, NULL))) {
         goto beach;
     }
     return ptr;
  
 beach:
     free(ptr);
     return NULL;
 }

References b, consume_init_expr_r(), consume_u1_r(), consume_u7_r(), rz_bin_wasm_global_t::content_type, free(), max, rz_bin_wasm_global_t::mutability, NULL, RZ_BIN_WASM_END_OF_CODE, and RZ_NEW0.

Referenced by rz_bin_wasm_get_global_entries().

◆ parse_import_entry()

static void* parse_import_entry	(	RzBuffer *	b,
		ut64	max
	)

static

Definition at line 312 of file wasm.c.

                                                        {
     RzBinWasmImportEntry *ptr = RZ_NEW0(RzBinWasmImportEntry);
     if (!ptr) {
         return NULL;
     }
     if (!(consume_u32_r(b, max, &ptr->module_len))) {
         goto beach;
     }
     if (consume_str_r(b, max, ptr->module_len, ptr->module_str) < ptr->module_len) {
         goto beach;
     }
     if (!(consume_u32_r(b, max, &ptr->field_len))) {
         goto beach;
     }
     if (consume_str_r(b, max, ptr->field_len, ptr->field_str) < ptr->field_len) {
         goto beach;
     }
     if (!(consume_u7_r(b, max, &ptr->kind))) {
         goto beach;
     }
     switch (ptr->kind) {
     case 0: // Function
         if (!(consume_u32_r(b, max, &ptr->type_f))) {
             goto beach;
         }
         break;
     case 1: // Table
         if (!(consume_s7_r(b, max, (st8 *)&ptr->type_t.elem_type))) {
             goto beach;
         }
         if (!(consume_limits_r(b, max, &ptr->type_t.limits))) {
             goto beach;
         }
         break;
     case 2: // Memory
         if (!(consume_limits_r(b, max, &ptr->type_m.limits))) {
             goto beach;
         }
         break;
     case 3: // Global
         if (!(consume_s7_r(b, max, (st8 *)&ptr->type_g.content_type))) {
             goto beach;
         }
         if (!(consume_u1_r(b, max, (ut8 *)&ptr->type_g.mutability))) {
             goto beach;
         }
         break;
     default:
         goto beach;
     }
     return ptr;
  
 beach:
     free(ptr);
     return NULL;
 }

Referenced by rz_bin_wasm_get_import_entries().

◆ parse_memory_entry()

static void* parse_memory_entry	(	RzBuffer *	b,
		ut64	max
	)

static

Definition at line 589 of file wasm.c.

                                                        {
     RzBinWasmMemoryEntry *ptr = RZ_NEW0(RzBinWasmMemoryEntry);
     if (!ptr) {
         return NULL;
     }
     if (!(consume_limits_r(b, max, &ptr->limits))) {
         goto beach;
     }
     return ptr;
  
 beach:
     free(ptr);
     return NULL;
 }

References b, consume_limits_r(), free(), rz_bin_wasm_memory_t::limits, max, NULL, and RZ_NEW0.

Referenced by rz_bin_wasm_get_memory_entries().

◆ parse_namemap()

static bool parse_namemap	(	RzBuffer *	b,
		ut64	max,
		RzIDStorage *	map,
		ut32 *	count
	)

static

Definition at line 447 of file wasm.c.

                                                                                 {
     size_t i;
     if (!(consume_u32_r(b, max, count))) {
         return false;
     }
  
     for (i = 0; i < *count; i++) {
         struct rz_bin_wasm_name_t *name = RZ_NEW0(struct rz_bin_wasm_name_t);
         if (!name) {
             return false;
         }
  
         ut32 idx;
         if (!(consume_u32_r(b, max, &idx))) {
             RZ_FREE(name);
             return false;
         }
  
         if (!(consume_u32_r(b, max, &name->len))) {
             RZ_FREE(name);
             return false;
         }
  
         if (!(consume_str_r(b, max, name->len, (char *)name->name))) {
             RZ_FREE(name);
             return false;
         }
         name->name[name->len] = 0;
  
         if (!rz_id_storage_add(map, name, &idx)) {
             RZ_FREE(name);
             return false;
         };
     }
  
     return true;
 }

References b, consume_str_r(), consume_u32_r(), count, i, setup::idx, map(), max, name::name, RZ_FREE, rz_id_storage_add(), and RZ_NEW0.

Referenced by parse_custom_name_entry().

◆ parse_table_entry()

static void* parse_table_entry	(	RzBuffer *	b,
		ut64	max
	)

static

Definition at line 604 of file wasm.c.

                                                       {
     RzBinWasmTableEntry *ptr = RZ_NEW0(RzBinWasmTableEntry);
     if (!ptr) {
         return NULL;
     }
     if (!(consume_s7_r(b, max, (st8 *)&ptr->element_type))) {
         goto beach;
     }
     if (!(consume_limits_r(b, max, &ptr->limits))) {
         goto beach;
     }
     return ptr;
  
 beach:
     free(ptr);
     return NULL;
 }

References b, consume_limits_r(), consume_s7_r(), rz_bin_wasm_table_t::element_type, free(), rz_bin_wasm_table_t::limits, max, NULL, RZ_NEW0, and st8.

Referenced by rz_bin_wasm_get_table_entries().

◆ parse_type_entry()

static void* parse_type_entry	(	RzBuffer *	b,
		ut64	max
	)

static

Definition at line 268 of file wasm.c.

                                                      {
     RzBinWasmTypeEntry *ptr = RZ_NEW0(RzBinWasmTypeEntry);
     if (!ptr) {
         return NULL;
     }
     if (!(consume_u7_r(b, max, &ptr->form))) {
         goto beach;
     }
     // check valid type?
     if (!(consume_u32_r(b, max, &ptr->param_count))) {
         goto beach;
     }
     ut32 count = ptr->param_count;
     if (!(rz_buf_tell(b) + count <= max)) {
         goto beach;
     }
     if (count > 0) {
         if (!(ptr->param_types = RZ_NEWS0(rz_bin_wasm_value_type_t, count))) {
             goto beach;
         }
     }
     int j;
     for (j = 0; j < count; j++) {
         if (!(consume_s7_r(b, max, (st8 *)&ptr->param_types[j]))) {
             goto beach;
         }
     }
     if (!(consume_u1_r(b, max, (ut8 *)&ptr->return_count))) {
         goto beach;
     }
     if (ptr->return_count > 1) {
         goto beach;
     }
     if (ptr->return_count == 1) {
         if (!(consume_s7_r(b, max, (st8 *)&ptr->return_type))) {
             goto beach;
         }
     }
     return ptr;
  
 beach:
     rz_bin_wasm_free_types(ptr);
     return NULL;
 }

References b, consume_s7_r(), consume_u1_r(), consume_u32_r(), consume_u7_r(), count, rz_bin_wasm_type_t::form, max, NULL, rz_bin_wasm_type_t::param_count, rz_bin_wasm_type_t::param_types, rz_bin_wasm_type_t::return_count, rz_bin_wasm_type_t::return_type, rz_bin_wasm_free_types(), rz_buf_tell(), RZ_NEW0, RZ_NEWS0, and st8.

Referenced by rz_bin_wasm_get_type_entries().

◆ rz_bin_wasm_destroy()

void rz_bin_wasm_destroy ( RzBinFile * bf )

Definition at line 789 of file wasm.c.

                                         {
     RzBinWasmObj *bin;
  
     if (!bf || !bf->o || !bf->o->bin_obj) {
         return;
     }
  
     bin = bf->o->bin_obj;
     rz_buf_free(bin->buf);
  
     rz_list_free(bin->g_sections);
     rz_list_free(bin->g_types);
  
     rz_list_free(bin->g_imports);
     rz_list_free(bin->g_exports);
     rz_list_free(bin->g_tables);
     rz_list_free(bin->g_memories);
     rz_list_free(bin->g_globals);
     rz_list_free(bin->g_codes);
     rz_list_free(bin->g_datas);
  
     RzListIter *iter;
     RzBinWasmCustomNameEntry *nam;
     rz_list_foreach (bin->g_names, iter, nam) {
         switch (nam->type) {
         case RZ_BIN_WASM_NAMETYPE_Module:
             if (nam->mod_name) {
                 free(nam->mod_name);
             }
             break;
         case RZ_BIN_WASM_NAMETYPE_Function:
             if (nam->func) {
                 rz_id_storage_free(nam->func->names);
             }
             break;
         case RZ_BIN_WASM_NAMETYPE_Local:
             if (nam->local && nam->local->locals) {
                 RzListIter *iter;
                 RzBinWasmCustomNameLocalName *local;
                 rz_list_foreach (nam->local->locals, iter, local) {
                     if (local->names) {
                         rz_id_storage_free(local->names);
                     }
                 }
  
                 rz_list_free(nam->local->locals);
             }
             break;
         }
     }
     rz_list_free(bin->g_names);
  
     free(bin->g_start);
     free(bin);
     bf->o->bin_obj = NULL;
 }

References rz_bin_object_t::bin_obj, bin::buf, free(), rz_bin_wasm_custom_name_entry_t::func, rz_bin_wasm_custom_name_entry_t::local, local, rz_bin_wasm_custom_name_local_names_t::locals, rz_bin_wasm_custom_name_entry_t::mod_name, rz_bin_wasm_custom_name_function_names_t::names, NULL, rz_bin_file_t::o, RZ_BIN_WASM_NAMETYPE_Function, RZ_BIN_WASM_NAMETYPE_Local, RZ_BIN_WASM_NAMETYPE_Module, rz_buf_free(), rz_id_storage_free(), rz_list_free(), and rz_bin_wasm_custom_name_entry_t::type.

Referenced by destroy().

◆ rz_bin_wasm_free_codes()

static void rz_bin_wasm_free_codes ( RzBinWasmCodeEntry * ptr )

static

Definition at line 228 of file wasm.c.

                                                             {
     if (ptr) {
         free(ptr->locals);
     }
     free(ptr);
 }

References free(), and rz_bin_wasm_code_t::locals.

Referenced by parse_code_entry(), and rz_bin_wasm_get_code_entries().

◆ rz_bin_wasm_free_types()

static void rz_bin_wasm_free_types ( RzBinWasmTypeEntry * ptr )

static

Definition at line 221 of file wasm.c.

                                                             {
     if (ptr) {
         free(ptr->param_types);
     }
     free(ptr);
 }

References free(), and rz_bin_wasm_type_t::param_types.

Referenced by parse_type_entry(), and rz_bin_wasm_get_type_entries().

◆ rz_bin_wasm_get_code_entries()

static RzList* rz_bin_wasm_get_code_entries	(	RzBinWasmObj *	bin,
		RzBinWasmSection *	sec
	)

static

Definition at line 683 of file wasm.c.

                                                                                       {
     return get_entries_from_section(bin, sec, parse_code_entry, (RzListFree)rz_bin_wasm_free_codes);
 }

References get_entries_from_section(), parse_code_entry(), and rz_bin_wasm_free_codes().

Referenced by rz_bin_wasm_get_codes().

◆ rz_bin_wasm_get_codes()

RzList* rz_bin_wasm_get_codes ( RzBinWasmObj * bin )

Definition at line 1168 of file wasm.c.

                                                  {
     RzBinWasmSection *code = NULL;
     ;
     RzList *codes = NULL;
  
     if (!bin || !bin->g_sections) {
         return NULL;
     }
     if (bin->g_codes) {
         return bin->g_codes;
     }
     if (!(codes = rz_bin_wasm_get_sections_by_id(bin->g_sections, RZ_BIN_WASM_SECTION_CODE))) {
         return rz_list_new();
     }
     // support for multiple export sections against spec
     if (!(code = (RzBinWasmSection *)rz_list_first(codes))) {
         rz_list_free(codes);
         return rz_list_new();
     }
     bin->g_codes = rz_bin_wasm_get_code_entries(bin, code);
     rz_list_free(codes);
     return bin->g_codes;
 }

References codes(), NULL, rz_bin_wasm_get_code_entries(), rz_bin_wasm_get_sections_by_id(), RZ_BIN_WASM_SECTION_CODE, rz_list_first(), rz_list_free(), and rz_list_new().

Referenced by entries(), rz_bin_wasm_init(), and symbols().

◆ rz_bin_wasm_get_custom_name_entries()

static RzList* rz_bin_wasm_get_custom_name_entries	(	RzBinWasmObj *	bin,
		RzBinWasmSection *	sec
	)

static

Definition at line 730 of file wasm.c.

                                                                                              {
     RzList *ret = rz_list_new();
  
     RzBuffer *buf = bin->buf;
  
     rz_buf_seek(buf, sec->payload_data, RZ_BUF_SET);
     ut64 max = sec->payload_data + sec->payload_len - 1;
  
     if (max > rz_buf_size(buf)) {
         goto beach;
     }
  
     while (rz_buf_tell(buf) < max) {
         RzBinWasmCustomNameEntry *nam = parse_custom_name_entry(buf, max);
  
         if (!nam) {
             goto beach;
         }
  
         if (!rz_list_append(ret, nam)) {
             goto beach;
         }
     }
  
     return ret;
 beach:
     rz_list_free(ret);
     return NULL;
 }

References bin::buf, max, NULL, parse_custom_name_entry(), rz_bin_wasm_section_t::payload_data, rz_bin_wasm_section_t::payload_len, rz_buf_seek(), RZ_BUF_SET, rz_buf_size(), rz_buf_tell(), rz_list_append(), rz_list_free(), rz_list_new(), and ut64().

Referenced by rz_bin_wasm_get_custom_names().

◆ rz_bin_wasm_get_custom_names()

RzList* rz_bin_wasm_get_custom_names ( RzBinWasmObj * bin )

Definition at line 1215 of file wasm.c.

                                                         {
     RzBinWasmSection *cust = NULL;
     RzList *customs = NULL;
  
     rz_return_val_if_fail(bin && bin->g_sections, NULL);
  
     if (bin->g_names) {
         return bin->g_names;
     }
     if (!(customs = rz_bin_wasm_get_sections_by_id(bin->g_sections, RZ_BIN_WASM_SECTION_CUSTOM))) {
         return rz_list_new();
     }
     // support for multiple "name" sections against spec
     if (!(cust = (RzBinWasmSection *)rz_list_first(customs)) || strncmp(cust->name, "name", 5)) {
         rz_list_free(customs);
         return rz_list_new();
     }
     bin->g_names = rz_bin_wasm_get_custom_name_entries(bin, cust);
     rz_list_free(customs);
     return bin->g_names;
 }

References rz_bin_wasm_section_t::name, NULL, rz_bin_wasm_get_custom_name_entries(), rz_bin_wasm_get_sections_by_id(), RZ_BIN_WASM_SECTION_CUSTOM, rz_list_first(), rz_list_free(), rz_list_new(), and rz_return_val_if_fail.

Referenced by rz_bin_wasm_init().

◆ rz_bin_wasm_get_data_entries()

static RzList* rz_bin_wasm_get_data_entries	(	RzBinWasmObj *	bin,
		RzBinWasmSection *	sec
	)

static

Definition at line 687 of file wasm.c.

                                                                                       {
     return get_entries_from_section(bin, sec, parse_data_entry, (RzListFree)free);
 }

References free(), get_entries_from_section(), and parse_data_entry().

Referenced by rz_bin_wasm_get_datas().

◆ rz_bin_wasm_get_datas()

RzList* rz_bin_wasm_get_datas ( RzBinWasmObj * bin )

Definition at line 1192 of file wasm.c.

                                                  {
     RzBinWasmSection *data = NULL;
     RzList *datas = NULL;
  
     if (!bin || !bin->g_sections) {
         return NULL;
     }
     if (bin->g_datas) {
         return bin->g_datas;
     }
     if (!(datas = rz_bin_wasm_get_sections_by_id(bin->g_sections, RZ_BIN_WASM_SECTION_DATA))) {
         return rz_list_new();
     }
     // support for multiple export sections against spec
     if (!(data = (RzBinWasmSection *)rz_list_first(datas))) {
         rz_list_free(datas);
         return rz_list_new();
     }
     bin->g_datas = rz_bin_wasm_get_data_entries(bin, data);
     rz_list_free(datas);
     return bin->g_datas;
 }

References NULL, rz_bin_wasm_get_data_entries(), rz_bin_wasm_get_sections_by_id(), RZ_BIN_WASM_SECTION_DATA, rz_list_first(), rz_list_free(), and rz_list_new().

Referenced by rz_bin_wasm_init().

◆ rz_bin_wasm_get_element_entries()

static RzList* rz_bin_wasm_get_element_entries	(	RzBinWasmObj *	bin,
		RzBinWasmSection *	sec
	)

static

Definition at line 726 of file wasm.c.

                                                                                          {
     return get_entries_from_section(bin, sec, parse_element_entry, (RzListFree)free);
 }

References free(), get_entries_from_section(), and parse_element_entry().

Referenced by rz_bin_wasm_get_elements().

◆ rz_bin_wasm_get_elements()

RzList* rz_bin_wasm_get_elements ( RzBinWasmObj * bin )

Definition at line 1145 of file wasm.c.

                                                     {
     RzBinWasmSection *element = NULL;
     RzList *elements = NULL;
  
     if (!bin || !bin->g_sections) {
         return NULL;
     }
     if (bin->g_elements) {
         return bin->g_elements;
     }
     if (!(elements = rz_bin_wasm_get_sections_by_id(bin->g_sections, RZ_BIN_WASM_SECTION_ELEMENT))) {
         return rz_list_new();
     }
     // support for multiple export sections against spec
     if (!(element = (RzBinWasmSection *)rz_list_first(elements))) {
         rz_list_free(elements);
         return rz_list_new();
     }
     bin->g_elements = rz_bin_wasm_get_element_entries(bin, element);
     rz_list_free(elements);
     return bin->g_elements;
 }

References NULL, rz_bin_wasm_get_element_entries(), rz_bin_wasm_get_sections_by_id(), RZ_BIN_WASM_SECTION_ELEMENT, rz_list_first(), rz_list_free(), and rz_list_new().

◆ rz_bin_wasm_get_entrypoint()

ut32 rz_bin_wasm_get_entrypoint ( RzBinWasmObj * bin )

Definition at line 966 of file wasm.c.

                                                    {
     RzList *secs = NULL;
     RzBinWasmStartEntry *start = NULL;
     RzBinWasmSection *sec = NULL;
     RzBinWasmCodeEntry *func = NULL;
  
     if (!bin || !bin->g_sections) {
         return 0;
     }
     if (bin->entrypoint) {
         return bin->entrypoint;
     }
     if (bin->g_start) {
         start = bin->g_start;
     } else if (!(secs = rz_bin_wasm_get_sections_by_id(bin->g_sections, RZ_BIN_WASM_SECTION_START))) {
         return 0;
     } else if (!(sec = (RzBinWasmSection *)rz_list_first(secs))) {
         rz_list_free(secs);
         return 0;
     } else {
         start = rz_bin_wasm_get_start(bin, sec);
         bin->g_start = start;
     }
     if (!start) {
         rz_list_free(secs);
         return 0;
     }
     // FIX: entrypoint can be also an import
     if (!bin->g_codes) {
         rz_list_free(secs);
         return 0;
     }
     func = rz_list_get_n(bin->g_codes, start->index);
     rz_list_free(secs);
     return (ut32)(func ? func->code : 0);
 }

References rz_bin_wasm_code_t::code, NULL, rz_bin_wasm_get_sections_by_id(), rz_bin_wasm_get_start(), RZ_BIN_WASM_SECTION_START, rz_list_first(), rz_list_free(), rz_list_get_n(), and start.

Referenced by entries(), and rz_bin_wasm_init().

◆ rz_bin_wasm_get_export_entries()

static RzList* rz_bin_wasm_get_export_entries	(	RzBinWasmObj *	bin,
		RzBinWasmSection *	sec
	)

static

Definition at line 679 of file wasm.c.

                                                                                         {
     return get_entries_from_section(bin, sec, parse_export_entry, (RzListFree)free);
 }

References free(), get_entries_from_section(), and parse_export_entry().

Referenced by rz_bin_wasm_get_exports().

◆ rz_bin_wasm_get_exports()

RzList* rz_bin_wasm_get_exports ( RzBinWasmObj * bin )

Definition at line 1026 of file wasm.c.

                                                    {
     RzBinWasmSection *export = NULL;
     RzList *exports = NULL;
  
     if (!bin || !bin->g_sections) {
         return NULL;
     }
     if (bin->g_exports) {
         return bin->g_exports;
     }
     if (!(exports = rz_bin_wasm_get_sections_by_id(bin->g_sections, RZ_BIN_WASM_SECTION_EXPORT))) {
         return rz_list_new();
     }
     // support for multiple export sections against spec
     if (!(export = (RzBinWasmSection *)rz_list_first(exports))) {
         rz_list_free(exports);
         return rz_list_new();
     }
     bin->g_exports = rz_bin_wasm_get_export_entries(bin, export);
     rz_list_free(exports);
     return bin->g_exports;
 }

References NULL, rz_bin_wasm_get_export_entries(), rz_bin_wasm_get_sections_by_id(), RZ_BIN_WASM_SECTION_EXPORT, rz_list_first(), rz_list_free(), and rz_list_new().

Referenced by rz_bin_wasm_init(), and symbols().

◆ rz_bin_wasm_get_function_name()

const char* rz_bin_wasm_get_function_name	(	RzBinWasmObj *	bin,
		ut32	idx
	)

Definition at line 1237 of file wasm.c.

                                                                        {
     if (!(bin && bin->g_names)) {
         return NULL;
     };
  
     RzListIter *iter;
     RzBinWasmCustomNameEntry *nam;
     rz_list_foreach (bin->g_names, iter, nam) {
         if (nam->type == RZ_BIN_WASM_NAMETYPE_Function) {
             struct rz_bin_wasm_name_t *n = NULL;
  
             if ((n = rz_id_storage_get(nam->func->names, idx))) {
                 return (const char *)n->name;
             }
         }
     }
  
     return NULL;
 }

References rz_bin_wasm_custom_name_entry_t::func, setup::idx, n, rz_bin_wasm_custom_name_function_names_t::names, NULL, RZ_BIN_WASM_NAMETYPE_Function, rz_id_storage_get(), and rz_bin_wasm_custom_name_entry_t::type.

Referenced by symbols().

◆ rz_bin_wasm_get_global_entries()

static RzList* rz_bin_wasm_get_global_entries	(	RzBinWasmObj *	bin,
		RzBinWasmSection *	sec
	)

static

Definition at line 722 of file wasm.c.

                                                                                         {
     return get_entries_from_section(bin, sec, parse_global_entry, (RzListFree)free);
 }

References free(), get_entries_from_section(), and parse_global_entry().

Referenced by rz_bin_wasm_get_globals().

◆ rz_bin_wasm_get_globals()

RzList* rz_bin_wasm_get_globals ( RzBinWasmObj * bin )

Definition at line 1122 of file wasm.c.

                                                    {
     RzBinWasmSection *global = NULL;
     RzList *globals = NULL;
  
     if (!bin || !bin->g_sections) {
         return NULL;
     }
     if (bin->g_globals) {
         return bin->g_globals;
     }
     if (!(globals = rz_bin_wasm_get_sections_by_id(bin->g_sections, RZ_BIN_WASM_SECTION_GLOBAL))) {
         return rz_list_new();
     }
     // support for multiple export sections against spec
     if (!(global = (RzBinWasmSection *)rz_list_first(globals))) {
         rz_list_free(globals);
         return rz_list_new();
     }
     bin->g_globals = rz_bin_wasm_get_global_entries(bin, global);
     rz_list_free(globals);
     return bin->g_globals;
 }

References NULL, rz_bin_wasm_get_global_entries(), rz_bin_wasm_get_sections_by_id(), RZ_BIN_WASM_SECTION_GLOBAL, rz_list_first(), rz_list_free(), and rz_list_new().

Referenced by rz_bin_wasm_init().

◆ rz_bin_wasm_get_import_entries()

static RzList* rz_bin_wasm_get_import_entries	(	RzBinWasmObj *	bin,
		RzBinWasmSection *	sec
	)

static

Definition at line 675 of file wasm.c.

                                                                                         {
     return get_entries_from_section(bin, sec, parse_import_entry, (RzListFree)free);
 }

References free(), get_entries_from_section(), and parse_import_entry().

Referenced by rz_bin_wasm_get_imports().

◆ rz_bin_wasm_get_imports()

RzList* rz_bin_wasm_get_imports ( RzBinWasmObj * bin )

Definition at line 1003 of file wasm.c.

                                                    {
     RzBinWasmSection *import = NULL;
     RzList *imports = NULL;
  
     if (!bin || !bin->g_sections) {
         return NULL;
     }
     if (bin->g_imports) {
         return bin->g_imports;
     }
     if (!(imports = rz_bin_wasm_get_sections_by_id(bin->g_sections, RZ_BIN_WASM_SECTION_IMPORT))) {
         return rz_list_new();
     }
     // support for multiple import sections against spec
     if (!(import = (RzBinWasmSection *)rz_list_first(imports))) {
         rz_list_free(imports);
         return rz_list_new();
     }
     bin->g_imports = rz_bin_wasm_get_import_entries(bin, import);
     rz_list_free(imports);
     return bin->g_imports;
 }

References imports(), NULL, rz_bin_wasm_get_import_entries(), rz_bin_wasm_get_sections_by_id(), RZ_BIN_WASM_SECTION_IMPORT, rz_list_first(), rz_list_free(), and rz_list_new().

Referenced by imports(), rz_bin_wasm_init(), and symbols().

◆ rz_bin_wasm_get_memories()

RzList* rz_bin_wasm_get_memories ( RzBinWasmObj * bin )

Definition at line 1095 of file wasm.c.

                                                     {
     RzBinWasmSection *memory;
     RzList *memories;
  
     if (!bin || !bin->g_sections) {
         return NULL;
     }
  
     if (bin->g_memories) {
         return bin->g_memories;
     }
  
     if (!(memories = rz_bin_wasm_get_sections_by_id(bin->g_sections, RZ_BIN_WASM_SECTION_MEMORY))) {
         return rz_list_new();
     }
  
     // support for multiple export sections against spec
     if (!(memory = (RzBinWasmSection *)rz_list_first(memories))) {
         rz_list_free(memories);
         return rz_list_new();
     }
  
     bin->g_memories = rz_bin_wasm_get_memory_entries(bin, memory);
     rz_list_free(memories);
     return bin->g_memories;
 }

References NULL, rz_bin_wasm_get_memory_entries(), rz_bin_wasm_get_sections_by_id(), RZ_BIN_WASM_SECTION_MEMORY, rz_list_first(), rz_list_free(), and rz_list_new().

Referenced by rz_bin_wasm_init().

◆ rz_bin_wasm_get_memory_entries()

static RzList* rz_bin_wasm_get_memory_entries	(	RzBinWasmObj *	bin,
		RzBinWasmSection *	sec
	)

static

Definition at line 714 of file wasm.c.

                                                                                         {
     return get_entries_from_section(bin, sec, parse_memory_entry, (RzListFree)free);
 }

References free(), get_entries_from_section(), and parse_memory_entry().

Referenced by rz_bin_wasm_get_memories().

◆ rz_bin_wasm_get_sections()

RzList* rz_bin_wasm_get_sections ( RzBinWasmObj * bin )

Definition at line 846 of file wasm.c.

                                                     {
     RzList *ret = NULL;
     RzBinWasmSection *ptr = NULL;
  
     if (!bin) {
         return NULL;
     }
     if (bin->g_sections) {
         return bin->g_sections;
     }
     if (!(ret = rz_list_newf((RzListFree)free))) {
         return NULL;
     }
     RzBuffer *b = bin->buf;
     ut64 max = rz_buf_size(b) - 1;
     rz_buf_seek(b, 8, RZ_BUF_SET);
     while (rz_buf_tell(b) <= max) {
         if (!(ptr = RZ_NEW0(RzBinWasmSection))) {
             return ret;
         }
         if (!(consume_u7_r(b, max, &ptr->id))) {
             goto beach;
         }
         if (!(consume_u32_r(b, max, &ptr->size))) {
             goto beach;
         }
         // against spec. TODO: choose criteria for parsing
         if (ptr->size < 1) {
             goto beach;
             // free (ptr);
             // continue;
         }
         if (!(rz_buf_tell(b) + (ut64)ptr->size - 1 <= max)) {
             goto beach;
         }
         ptr->count = 0;
         ptr->offset = rz_buf_tell(b);
         switch (ptr->id) {
         case RZ_BIN_WASM_SECTION_CUSTOM:
             if (!(consume_u32_r(b, max, &ptr->name_len))) {
                 goto beach;
             }
             if (consume_str_r(b, max, ptr->name_len, (char *)ptr->name) < ptr->name_len) {
                 goto beach;
             }
             break;
         case RZ_BIN_WASM_SECTION_TYPE:
             strcpy(ptr->name, "type");
             ptr->name_len = 4;
             break;
         case RZ_BIN_WASM_SECTION_IMPORT:
             strcpy(ptr->name, "import");
             ptr->name_len = 6;
             break;
         case RZ_BIN_WASM_SECTION_FUNCTION:
             strcpy(ptr->name, "function");
             ptr->name_len = 8;
             break;
         case RZ_BIN_WASM_SECTION_TABLE:
             strcpy(ptr->name, "table");
             ptr->name_len = 5;
             break;
         case RZ_BIN_WASM_SECTION_MEMORY:
             strcpy(ptr->name, "memory");
             ptr->name_len = 6;
             break;
         case RZ_BIN_WASM_SECTION_GLOBAL:
             strcpy(ptr->name, "global");
             ptr->name_len = 6;
             break;
         case RZ_BIN_WASM_SECTION_EXPORT:
             strcpy(ptr->name, "export");
             ptr->name_len = 6;
             break;
         case RZ_BIN_WASM_SECTION_START:
             strcpy(ptr->name, "start");
             ptr->name_len = 5;
             break;
         case RZ_BIN_WASM_SECTION_ELEMENT:
             strcpy(ptr->name, "element");
             ptr->name_len = 7;
             break;
         case RZ_BIN_WASM_SECTION_CODE:
             strcpy(ptr->name, "code");
             ptr->name_len = 4;
             break;
         case RZ_BIN_WASM_SECTION_DATA:
             strcpy(ptr->name, "data");
             ptr->name_len = 4;
             break;
         default:
             RZ_LOG_ERROR("wasm: unkown section id: %d\n", ptr->id);
             rz_buf_seek(b, ptr->size - 1, RZ_BUF_CUR);
             continue;
         }
         if (ptr->id != RZ_BIN_WASM_SECTION_START && ptr->id != RZ_BIN_WASM_SECTION_CUSTOM) {
             if (!(consume_u32_r(b, max, &ptr->count))) {
                 goto beach;
             }
         }
         ptr->payload_data = rz_buf_tell(b);
         ptr->payload_len = ptr->size - (ptr->payload_data - ptr->offset);
         if (ptr->payload_len > ptr->size) {
             goto beach;
         }
         rz_buf_seek(b, ptr->payload_len, RZ_BUF_CUR);
         if (!rz_list_append(ret, ptr)) {
             free(ptr);
             // should it jump to beach?
         }
         ptr = NULL;
     }
     bin->g_sections = ret;
     return ret;
 beach:
     RZ_LOG_ERROR("wasm: failed to read sections\n");
     free(ptr);
     return ret;
 }

Referenced by rz_bin_wasm_init(), and sections().

◆ rz_bin_wasm_get_sections_by_id()

static RzList* rz_bin_wasm_get_sections_by_id	(	RzList *	sections,
		ut8	id
	)

static

Definition at line 162 of file wasm.c.

                                                                         {
     RzBinWasmSection *sec = NULL;
     RzList *ret = rz_list_newf(NULL);
     if (!ret) {
         return NULL;
     }
     RzListIter *iter;
     rz_list_foreach (sections, iter, sec) {
         if (sec->id == id) {
             rz_list_append(ret, sec);
         }
     }
     return ret;
 }

References rz_bin_wasm_section_t::id, NULL, rz_list_append(), rz_list_newf(), and sections().

Referenced by rz_bin_wasm_get_codes(), rz_bin_wasm_get_custom_names(), rz_bin_wasm_get_datas(), rz_bin_wasm_get_elements(), rz_bin_wasm_get_entrypoint(), rz_bin_wasm_get_exports(), rz_bin_wasm_get_globals(), rz_bin_wasm_get_imports(), rz_bin_wasm_get_memories(), rz_bin_wasm_get_tables(), and rz_bin_wasm_get_types().

◆ rz_bin_wasm_get_start()

static RzBinWasmStartEntry* rz_bin_wasm_get_start	(	RzBinWasmObj *	bin,
		RzBinWasmSection *	sec
	)

static

Definition at line 691 of file wasm.c.

                                                                                             {
     RzBinWasmStartEntry *ptr;
  
     if (!(ptr = RZ_NEW0(RzBinWasmStartEntry))) {
         return NULL;
     }
  
     RzBuffer *b = bin->buf;
     rz_buf_seek(b, sec->payload_data, RZ_BUF_SET);
     ut64 max = rz_buf_tell(b) + sec->payload_len - 1;
     if (!(max < rz_buf_size(b))) {
         goto beach;
     }
     if (!(consume_u32_r(b, max, &ptr->index))) {
         goto beach;
     }
     return ptr;
 beach:
     RZ_LOG_ERROR("wasm: failed to read start payload\n");
     free(ptr);
     return NULL;
 }

References b, bin::buf, consume_u32_r(), free(), rz_bin_wasm_start_t::index, max, NULL, rz_bin_wasm_section_t::payload_data, rz_bin_wasm_section_t::payload_len, rz_buf_seek(), RZ_BUF_SET, rz_buf_size(), rz_buf_tell(), RZ_LOG_ERROR, RZ_NEW0, and ut64().

Referenced by rz_bin_wasm_get_entrypoint().

◆ rz_bin_wasm_get_table_entries()

static RzList* rz_bin_wasm_get_table_entries	(	RzBinWasmObj *	bin,
		RzBinWasmSection *	sec
	)

static

Definition at line 718 of file wasm.c.

                                                                                        {
     return get_entries_from_section(bin, sec, parse_table_entry, (RzListFree)free);
 }

References free(), get_entries_from_section(), and parse_table_entry().

Referenced by rz_bin_wasm_get_tables().

◆ rz_bin_wasm_get_tables()

RzList* rz_bin_wasm_get_tables ( RzBinWasmObj * bin )

Definition at line 1072 of file wasm.c.

                                                   {
     RzBinWasmSection *table = NULL;
     RzList *tables = NULL;
  
     if (!bin || !bin->g_sections) {
         return NULL;
     }
     if (bin->g_tables) {
         return bin->g_tables;
     }
     if (!(tables = rz_bin_wasm_get_sections_by_id(bin->g_sections, RZ_BIN_WASM_SECTION_TABLE))) {
         return rz_list_new();
     }
     // support for multiple export sections against spec
     if (!(table = (RzBinWasmSection *)rz_list_first(tables))) {
         rz_list_free(tables);
         return rz_list_new();
     }
     bin->g_tables = rz_bin_wasm_get_table_entries(bin, table);
     rz_list_free(tables);
     return bin->g_tables;
 }

References NULL, rz_bin_wasm_get_sections_by_id(), rz_bin_wasm_get_table_entries(), RZ_BIN_WASM_SECTION_TABLE, rz_list_first(), rz_list_free(), and rz_list_new().

Referenced by rz_bin_wasm_init().

◆ rz_bin_wasm_get_type_entries()

static RzList* rz_bin_wasm_get_type_entries	(	RzBinWasmObj *	bin,
		RzBinWasmSection *	sec
	)

static

Definition at line 671 of file wasm.c.

                                                                                       {
     return get_entries_from_section(bin, sec, parse_type_entry, (RzListFree)rz_bin_wasm_free_types);
 }

References get_entries_from_section(), parse_type_entry(), and rz_bin_wasm_free_types().

Referenced by rz_bin_wasm_get_types().

◆ rz_bin_wasm_get_types()

RzList* rz_bin_wasm_get_types ( RzBinWasmObj * bin )

Definition at line 1049 of file wasm.c.

                                                  {
     RzBinWasmSection *type = NULL;
     RzList *types = NULL;
  
     if (!bin || !bin->g_sections) {
         return NULL;
     }
     if (bin->g_types) {
         return bin->g_types;
     }
     if (!(types = rz_bin_wasm_get_sections_by_id(bin->g_sections, RZ_BIN_WASM_SECTION_TYPE))) {
         return rz_list_new();
     }
     // support for multiple export sections against spec
     if (!(type = (RzBinWasmSection *)rz_list_first(types))) {
         rz_list_free(types);
         return rz_list_new();
     }
     bin->g_types = rz_bin_wasm_get_type_entries(bin, type);
     rz_list_free(types);
     return bin->g_types;
 }

References NULL, rz_bin_wasm_get_sections_by_id(), rz_bin_wasm_get_type_entries(), RZ_BIN_WASM_SECTION_TYPE, rz_list_first(), rz_list_free(), rz_list_new(), type, and types.

Referenced by rz_bin_wasm_init().

◆ rz_bin_wasm_init()

RzBinWasmObj* rz_bin_wasm_init	(	RzBinFile *	bf,
		RzBuffer *	buf
	)

Definition at line 761 of file wasm.c.

                                                              {
     RzBinWasmObj *bin = RZ_NEW0(RzBinWasmObj);
     if (!bin) {
         return NULL;
     }
     bin->buf = rz_buf_ref(buf);
     bin->size = (ut32)rz_buf_size(bf->buf);
     bin->g_sections = rz_bin_wasm_get_sections(bin);
     // TODO: recursive invocation more natural with streamed parsing
     // but dependency problems when sections are disordered (against spec)
  
     bin->g_types = rz_bin_wasm_get_types(bin);
     bin->g_imports = rz_bin_wasm_get_imports(bin);
     bin->g_exports = rz_bin_wasm_get_exports(bin);
     bin->g_tables = rz_bin_wasm_get_tables(bin);
     bin->g_memories = rz_bin_wasm_get_memories(bin);
     bin->g_globals = rz_bin_wasm_get_globals(bin);
     bin->g_codes = rz_bin_wasm_get_codes(bin);
     bin->g_datas = rz_bin_wasm_get_datas(bin);
  
     bin->g_names = rz_bin_wasm_get_custom_names(bin);
  
     // entrypoint from Start section
     bin->entrypoint = rz_bin_wasm_get_entrypoint(bin);
  
     return bin;
 }

References rz_bin_file_t::buf, bin::buf, NULL, rz_bin_wasm_get_codes(), rz_bin_wasm_get_custom_names(), rz_bin_wasm_get_datas(), rz_bin_wasm_get_entrypoint(), rz_bin_wasm_get_exports(), rz_bin_wasm_get_globals(), rz_bin_wasm_get_imports(), rz_bin_wasm_get_memories(), rz_bin_wasm_get_sections(), rz_bin_wasm_get_tables(), rz_bin_wasm_get_types(), rz_buf_ref(), rz_buf_size(), and RZ_NEW0.

Referenced by load_buffer().

Typedefs

Functions

Typedef Documentation

◆ ConsumeFcn

◆ ParseEntryFcn

Function Documentation

◆ consume_init_expr_r()

◆ consume_limits_r()

◆ consume_locals_r()

◆ consume_r()

◆ consume_s7_r()

◆ consume_str_r()

◆ consume_u1_r()

◆ consume_u32_r()

◆ consume_u7_r()

◆ get_entries_from_section()

◆ parse_code_entry()

◆ parse_custom_name_entry()

◆ parse_data_entry()

◆ parse_element_entry()

◆ parse_export_entry()

◆ parse_global_entry()

◆ parse_import_entry()

◆ parse_memory_entry()

◆ parse_namemap()

◆ parse_table_entry()

◆ parse_type_entry()

◆ rz_bin_wasm_destroy()

◆ rz_bin_wasm_free_codes()

◆ rz_bin_wasm_free_types()

◆ rz_bin_wasm_get_code_entries()

◆ rz_bin_wasm_get_codes()

◆ rz_bin_wasm_get_custom_name_entries()

◆ rz_bin_wasm_get_custom_names()

◆ rz_bin_wasm_get_data_entries()

◆ rz_bin_wasm_get_datas()

◆ rz_bin_wasm_get_element_entries()

◆ rz_bin_wasm_get_elements()

◆ rz_bin_wasm_get_entrypoint()

◆ rz_bin_wasm_get_export_entries()

◆ rz_bin_wasm_get_exports()

◆ rz_bin_wasm_get_function_name()

◆ rz_bin_wasm_get_global_entries()

◆ rz_bin_wasm_get_globals()

◆ rz_bin_wasm_get_import_entries()

◆ rz_bin_wasm_get_imports()

◆ rz_bin_wasm_get_memories()

◆ rz_bin_wasm_get_memory_entries()

◆ rz_bin_wasm_get_sections()

◆ rz_bin_wasm_get_sections_by_id()

◆ rz_bin_wasm_get_start()

◆ rz_bin_wasm_get_table_entries()

◆ rz_bin_wasm_get_tables()

◆ rz_bin_wasm_get_type_entries()

◆ rz_bin_wasm_get_types()

◆ rz_bin_wasm_init()