Rewrite MZ bin plugin

* Add const modifiers, fix function call style
* Add checking and using dos_file_size
* Fix number of arguments in load_bytes.
* Add check for NE, LE and LX executables.
* Fix function declaration for btree_traverse.

libr/bin/format/mz/mz.c

@@ -0,0 +1,272 @@
+/* radare - LGPL - Copyright 2015 nodepad */
+
+#include "mz.h"
+#include <btree.h>
+
+static ut64 r_bin_mz_seg_to_paddr(const struct r_bin_mz_obj_t *bin,
+	const ut16 segment)
+{
+	return (bin->dos_header->header_paragraphs + segment) << 4;
+}
+
+int r_bin_mz_get_entrypoint(const struct r_bin_mz_obj_t *bin)
+{
+	/* Value of CS in DOS header may be negative */
+	const short cs = (const short)bin->dos_header->cs;
+	const int paddr = ((bin->dos_header->header_paragraphs + cs) << 4) + \
+            bin->dos_header->ip;
+	if (paddr >= 0 && paddr < bin->dos_file_size)
+		return paddr;
+	else
+		return -1;
+}
+
+int cmp_segs(const void *a, const void *b) {
+	const ut16 * const ma = (const ut16 * const)a;
+	const ut16 * const mb = (const ut16 * const)b;
+	if (ma == NULL || mb == NULL)
+		return 0;
+	return (int)(*ma-*mb);
+}
+
+void trv_segs(const void *seg, const void *segs)
+{
+	const ut16 * const mseg = (const ut16 * const)seg;
+	ut16 ** const msegs = (ut16 **)segs;
+	if (mseg != NULL && msegs != NULL && *msegs != NULL) {
+		**msegs = *mseg;
+		*msegs = *msegs + 1;
+	}
+}
+
+struct r_bin_mz_segment_t * r_bin_mz_get_segments(
+	const struct r_bin_mz_obj_t *bin)
+{
+	struct btree_node *tree;
+	struct r_bin_mz_segment_t *ret;
+	ut16 *segments, *curr_seg;
+	int i, num_segs;
+	ut64 paddr;
+	const ut16 first_segment = 0;
+	const ut16 stack_segment = bin->dos_header->ss;
+	const MZ_image_relocation_entry * const relocs = bin->relocation_entries;
+	const int num_relocs = bin->dos_header->num_relocs;
+	const ut64 last_parag = ((bin->dos_file_size + 0xF) >> 4) - \
+            bin->dos_header->header_paragraphs;
+
+	btree_init (&tree);
+
+	for (i = 0; i < num_relocs; i++) {
+		paddr = r_bin_mz_seg_to_paddr (bin, relocs[i].segment) + \
+                relocs[i].offset;
+		if ((paddr + 2) < bin->dos_file_size) {
+			curr_seg = (ut16 *) (bin->b->buf + paddr);
+			/* Add segment only if it's located inside dos executable data */
+			if (*curr_seg <= last_parag)
+				btree_add (&tree, curr_seg, cmp_segs);
+		}
+	}
+
+	/* Add segment address of first segment to make sure that it will be
+    added. If relocations empty or there isn't first segment in relocations.)
+    */
+	btree_add (&tree, (void *)&first_segment, cmp_segs);
+	/* Add segment address of stack segment if it's resides inside dos
+	executable.
+    */
+	if (r_bin_mz_seg_to_paddr (bin, stack_segment) < bin->dos_file_size) {
+		btree_add (&tree, (void *)&stack_segment, cmp_segs);
+	}
+
+	segments = calloc (num_relocs, sizeof(*segments));
+	if (segments == NULL) {
+		eprintf ("Error: calloc (segments)\n");
+		return NULL;
+	}
+
+	curr_seg = segments;
+	btree_traverse (tree, 0, &curr_seg, trv_segs);
+
+	num_segs = curr_seg - segments;
+	ret = calloc (num_segs + 1, sizeof(struct r_bin_mz_segment_t));
+	if (ret == NULL) {
+		free (segments);
+		btree_cleartree (tree, NULL);
+		eprintf ("Error: calloc (struct r_bin_mz_segment_t)\n");
+		return NULL;
+	}
+
+	btree_cleartree (tree, NULL);
+
+	ret[0].paddr = r_bin_mz_seg_to_paddr (bin, segments[0]);
+	for (i = 1; i < num_segs; i++) {
+		ret[i].paddr = r_bin_mz_seg_to_paddr (bin, segments[i]);
+		ret[i - 1].size = ret[i].paddr - ret[i - 1].paddr;
+	}
+	ret[i - 1].size = bin->dos_file_size - ret[i - 1].paddr;
+	ret[i].last = 1;
+
+	free (segments);
+	return ret;
+}
+
+struct r_bin_mz_reloc_t *r_bin_mz_get_relocs(const struct r_bin_mz_obj_t *bin)
+{
+	struct r_bin_mz_reloc_t *relocs;
+	int i, j;
+	const int num_relocs = bin->dos_header->num_relocs;
+	const MZ_image_relocation_entry * const rel_entry = \
+		bin->relocation_entries;
+
+	relocs = calloc (num_relocs + 1, sizeof(*relocs));
+	if (relocs == NULL) {
+		eprintf ("Error: calloc (struct r_bin_mz_reloc_t)\n");
+		return NULL;
+	}
+
+	for (i = 0, j = 0; i < num_relocs; i++) {
+		relocs[j].paddr = r_bin_mz_seg_to_paddr (bin,
+			rel_entry[i].segment) + rel_entry[i].offset;
+		/* Add only relocations which resides inside dos executable */
+		if (relocs[j].paddr < bin->dos_file_size) j++;
+	}
+	relocs[j].last = 1;
+
+	return relocs;
+}
+
+void *r_bin_mz_free(struct r_bin_mz_obj_t* bin) {
+	if (!bin) return NULL;
+	free ((void *)bin->dos_header);
+	free ((void *)bin->dos_extended_header);
+	free ((void *)bin->relocation_entries);
+	r_buf_free (bin->b);
+	bin->b = NULL;
+	free (bin);
+	return NULL;
+}
+
+static int r_bin_mz_init_hdr(struct r_bin_mz_obj_t* bin) {
+	int relocations_size, dos_file_size;
+
+	if (!(bin->dos_header = malloc (sizeof(MZ_image_dos_header)))) {
+		r_sys_perror ("malloc (MZ_image_dos_header)");
+		return R_FALSE;
+	}
+	if (r_buf_read_at (bin->b, 0, (ut8*)bin->dos_header,
+            sizeof(*bin->dos_header)) == -1) {
+		eprintf ("Error: read (MZ_image_dos_header)\n");
+		return R_FALSE;
+	}
+
+	if (bin->dos_header->blocks_in_file < 1)
+		return R_FALSE;
+
+	dos_file_size = ((bin->dos_header->blocks_in_file - 1) << 9) + \
+			bin->dos_header->bytes_in_last_block;
+
+	bin->dos_file_size = dos_file_size;
+
+	if (dos_file_size > bin->size)
+		return R_FALSE;
+
+    relocations_size = bin->dos_header->num_relocs * \
+            sizeof(MZ_image_relocation_entry);
+
+    /* Check if relocation table doesn't exceed dos binary size */
+	if ((bin->dos_header->reloc_table_offset + relocations_size) > \
+			dos_file_size)
+		return R_FALSE;
+
+	sdb_num_set (bin->kv, "mz.initial.cs", bin->dos_header->cs, 0);
+	sdb_num_set (bin->kv, "mz.initial.ip", bin->dos_header->ip, 0);
+	sdb_num_set (bin->kv, "mz.initial.ss", bin->dos_header->ss, 0);
+	sdb_num_set (bin->kv, "mz.initial.sp", bin->dos_header->sp, 0);
+	sdb_num_set (bin->kv, "mz.overlay_number",
+            bin->dos_header->overlay_number, 0);
+	sdb_num_set (bin->kv, "mz.dos_header.offset", 0, 0);
+	sdb_set (bin->kv, "mz.dos_header.format", "[2]zwwwwwwwwwwwww"
+			" signature bytes_in_last_block blocks_in_file num_relocs "
+			" header_paragraphs min_extra_paragraphs max_extra_paragraphs "
+			" ss sp checksum ip cs reloc_table_offset overlay_number ", 0);
+
+	bin->dos_extended_header_size = bin->dos_header->reloc_table_offset - \
+            sizeof(MZ_image_dos_header);
+
+	if (bin->dos_extended_header_size > 0)
+	{
+		if (!(bin->dos_extended_header = \
+                malloc (bin->dos_extended_header_size))) {
+			r_sys_perror ("malloc (dos extended header)");
+			return R_FALSE;
+		}
+		if (r_buf_read_at (bin->b, sizeof(MZ_image_dos_header),
+                (ut8*)bin->dos_extended_header,
+				bin->dos_extended_header_size) == -1) {
+			eprintf ("Error: read (dos extended header)\n");
+			return R_FALSE;
+		}
+	}
+
+	if (relocations_size > 0)
+	{
+		if (!(bin->relocation_entries = malloc (relocations_size))) {
+			r_sys_perror ("malloc (dos relocation entries)");
+			return R_FALSE;
+		}
+		if (r_buf_read_at (bin->b, bin->dos_header->reloc_table_offset,
+				(ut8*)bin->relocation_entries, relocations_size) == -1) {
+			eprintf ("Error: read (dos relocation entries)\n");
+			return R_FALSE;
+		}
+	}
+
+	return R_TRUE;
+}
+
+static int r_bin_mz_init(struct r_bin_mz_obj_t* bin) {
+	bin->dos_header = NULL;
+	bin->dos_extended_header = NULL;
+	bin->relocation_entries = NULL;
+	bin->kv = sdb_new0 ();
+
+	if (!r_bin_mz_init_hdr (bin)) {
+		eprintf ("Warning: File is not MZ\n");
+		return R_FALSE;
+	}
+
+	return R_TRUE;
+}
+
+struct r_bin_mz_obj_t* r_bin_mz_new(const char* file)
+{
+	const ut8 *buf;
+	struct r_bin_mz_obj_t *bin = R_NEW0 (struct r_bin_mz_obj_t);
+	if (!bin) return NULL;
+	bin->file = file;
+	if (!(buf = (ut8*)r_file_slurp (file, &bin->size)))
+		return r_bin_mz_free (bin);
+	bin->b = r_buf_new ();
+	if (!r_buf_set_bytes (bin->b, buf, bin->size)) {
+		free ((void *)buf);
+		return r_bin_mz_free (bin);
+	}
+	free ((void *)buf);
+	if (!r_bin_mz_init (bin))
+		return r_bin_mz_free (bin);
+	return bin;
+}
+
+struct r_bin_mz_obj_t* r_bin_mz_new_buf(const struct r_buf_t *buf)
+{
+	struct r_bin_mz_obj_t *bin = R_NEW0 (struct r_bin_mz_obj_t);
+	if (!bin) return NULL;
+	bin->b = r_buf_new ();
+	bin->size = buf->length;
+	if (!r_buf_set_bytes (bin->b, buf->buf, bin->size)){
+		return r_bin_mz_free (bin);
+	}
+	if (!r_bin_mz_init (bin))
+		return r_bin_mz_free (bin);
+	return bin;
+}

libr/bin/format/mz/mz.h

@@ -0,0 +1,39 @@
+/* radare - LGPL - Copyright 2015 nodepad */
+
+#include <r_types.h>
+#include <r_list.h>
+#include <r_util.h>
+#include <r_bin.h>
+#include "mz_specs.h"
+
+struct r_bin_mz_segment_t {
+	ut64 paddr;
+	ut64 size;
+	int last;
+};
+
+struct r_bin_mz_reloc_t {
+	ut64 paddr;
+	int last;
+};
+
+struct r_bin_mz_obj_t {
+	const MZ_image_dos_header *dos_header;
+	const void *dos_extended_header;
+	const MZ_image_relocation_entry *relocation_entries;
+
+	int dos_extended_header_size;
+
+	int size;
+	int dos_file_size; /* Size of dos file from dos executable header */
+	const char *file;
+	struct r_buf_t *b;
+	Sdb *kv;
+};
+
+int r_bin_mz_get_entrypoint(const struct r_bin_mz_obj_t *bin);
+struct r_bin_mz_segment_t *r_bin_mz_get_segments(const struct r_bin_mz_obj_t *bin);
+struct r_bin_mz_reloc_t *r_bin_mz_get_relocs(const struct r_bin_mz_obj_t *bin);
+void *r_bin_mz_free(struct r_bin_mz_obj_t* bin);
+struct r_bin_mz_obj_t* r_bin_mz_new(const char* file);
+struct r_bin_mz_obj_t* r_bin_mz_new_buf(const struct r_buf_t *buf);

libr/bin/format/mz/mz_specs.h

@@ -0,0 +1,23 @@
+/* radare - LGPL - Copyright 2015 nodepad */
+
+typedef struct {
+	ut16 signature; /* == 'MZ' or 'ZM' */
+	ut16 bytes_in_last_block;
+	ut16 blocks_in_file;
+	ut16 num_relocs;
+	ut16 header_paragraphs;
+	ut16 min_extra_paragraphs;
+	ut16 max_extra_paragraphs;
+	ut16 ss;
+	ut16 sp;
+	ut16 checksum;
+	ut16 ip;
+	ut16 cs;
+	ut16 reloc_table_offset;
+	ut16 overlay_number;
+} MZ_image_dos_header;
+
+typedef struct {
+	ut16 offset;
+	ut16 segment;
+} MZ_image_relocation_entry;

libr/bin/p/bin_mz.c

@@ -1,210 +1,220 @@
-/* radare - LGPL - Copyright 2012-2013 - pancake */
+/* radare - LGPL - Copyright 2015 nodepad */
 
 #include <r_types.h>
-#include <r_util.h>
-#include <r_lib.h>
 #include <r_bin.h>
+#include "mz/mz.h"
 
-#if 0
-- header
-- relocs
-- code
-#endif
-
-struct EXE {
-	ut16 signature; /* == 0x5a4D */
-	ut16 bytes_in_last_block;
-	ut16 blocks_in_file;
-	ut16 num_relocs;
-	ut16 header_paragraphs;
-	ut16 min_extra_paragraphs;
-	ut16 max_extra_paragraphs;
-	ut16 ss;
-	ut16 sp;
-	ut16 checksum;
-	ut16 ip;
-	ut16 cs;
-	ut16 reloc_table_paddr;
-	ut16 overlay_number;
-};
-
-#if 0
-// begin
-exe_data_start = exe.header_paragraphs * 16L;
-// end
-extra_data_start = exe.blocks_in_file * 512L;
-if (exe.bytes_in_last_block)
-	extra_data_start -= (512 - exe.bytes_in_last_block);
-#endif
-
-struct EXE_RELOC {
-	ut16 paddr;
-	ut16 segment;
-};
-
-static int check(RBinFile *arch);
-static int check_bytes(const ut8 *buf, ut64 length);
-
-static int load(RBinFile *arch) {
-	// parse stuff
-	return R_TRUE;
-}
-
-static int destroy (RBinFile *arch) {
-	return R_TRUE;
-}
-
-static RBinAddr* binsym(RBinFile *arch, int type) {
+static Sdb * get_sdb(RBinObject *o) {
+	const struct r_bin_mz_obj_t *bin;
+	if (!o || !o->bin_obj) return NULL;
+	bin = (struct r_bin_mz_obj_t *) o->bin_obj;
+	if (bin && bin->kv) return bin->kv;
 	return NULL;
 }
 
-static RList* entries(RBinFile *arch) {
-	RList* ret;
-	RBinAddr *ptr = NULL;
-	const struct EXE *exe = (struct EXE*) arch->buf->buf;
+static int check_bytes(const ut8 *buf, ut64 length) {
+	unsigned int exth_offset;
+	int ret = R_FALSE;
+	if (!buf)
+		return R_FALSE;
+	if (length <= 0x3d)
+		return R_FALSE;
+	if (!memcmp (buf, "MZ", 2) || !memcmp (buf, "ZM", 2))
+	{
+		ret = R_TRUE;
 
-	if (!(ret = r_list_new ()))
-		return NULL;
-	ret->free = free;
-
-	if ((ptr = R_NEW (RBinAddr))) {
-		ptr->paddr = exe->header_paragraphs * 16L;
-		ptr->vaddr = exe->ip;
-		r_list_append (ret, ptr);
+		exth_offset = (buf[0x3c] | (buf[0x3d]<<8));
+		if (length > exth_offset+2)
+		{
+			if (!memcmp (buf+exth_offset, "PE", 2) ||
+				!memcmp (buf+exth_offset, "NE", 2) ||
+				!memcmp (buf+exth_offset, "LE", 2) ||
+				!memcmp (buf+exth_offset, "LX", 2) )
+				ret = R_FALSE;
+		}
 	}
-
-	return ret;
-}
-
-static RList* sections(RBinFile *arch) {
-	const struct EXE *exe = (struct EXE*) arch->buf->buf;
-	RList *ret = NULL;
-	RBinSection *ptr = NULL;
-
-	if (arch->buf->length - exe->header_paragraphs * 16L < 1)
-		return NULL;
-
-	if (!(ret = r_list_new ()))
-		return NULL;
-	ret->free = free; // r_bin-section_free
-
-	ptr = R_NEW0 (RBinSection);
-	strncpy (ptr->name, ".text", R_BIN_SIZEOF_STRINGS);
-	ptr->paddr = exe->header_paragraphs * 16L;
-	ptr->size = arch->buf->length - ptr->paddr;
-	/* DOS always loads the binary at 0x100 */
-	ptr->vaddr = 0x100;
-	ptr->vsize = ptr->size;
-	ptr->srwx = r_str_rwx ("rwx");
-
-	r_list_append (ret, ptr);
-	return ret;
-}
-
-static RList* symbols(RBinFile *arch) {
-	return NULL;
-}
-
-static RList* imports(RBinFile *arch) {
-	return NULL;
-}
-
-static int size(RBinFile *arch) {
-	const struct EXE *exe = (struct EXE*) arch->buf->buf;
-	return (int)r_buf_size (arch->buf) -
-		(exe->blocks_in_file * 0x200) +
-		(0x200 - exe->bytes_in_last_block) -
-		exe->header_paragraphs * 0x10;
-}
-
-static RBinInfo* info(RBinFile *arch) {
-	const struct EXE *exe = (struct EXE*) arch->buf->buf;
-	RBinInfo *ret = NULL;
-
-	sdb_num_set (arch->sdb, "ss", exe->ss, 0);
-	sdb_num_set (arch->sdb, "sp", exe->sp, 0);
-	sdb_num_set (arch->sdb, "ip", exe->ip, 0);
-	sdb_num_set (arch->sdb, "cs", exe->cs, 0);
-	sdb_num_set (arch->sdb, "mz.relocs.count", exe->num_relocs, 0);
-	sdb_num_set (arch->sdb, "mz.relocs.paddr", exe->reloc_table_paddr, 0);
-	sdb_num_set (arch->sdb, "mz.checksum", exe->checksum, 0);
-
-	if ((ret = R_NEW0 (RBinInfo)) == NULL)
-		return NULL;
-	ret->file = strdup (arch->file);
-	ret->rclass = strdup ("mz");
-	ret->os = strdup ("DOS");
-	ret->arch = strdup ("x86");
-	ret->machine = strdup ("pc");
-	ret->subsystem = strdup ("DOS");
-	ret->type = strdup ("EXEC (executable file)");
-	ret->bits = 16;
-	ret->big_endian = 0;
-	ret->dbg_info = 0;
-	ret->has_va = R_TRUE;
-	ret->dbg_info = 0;
 	return ret;
 }
 
 static int check(RBinFile *arch) {
 	const ut8 *bytes = arch ? r_buf_buffer (arch->buf) : NULL;
-	ut64 sz = arch ? r_buf_size (arch->buf): 0;
+	const ut64 sz = arch ? r_buf_size (arch->buf): 0;
 	return check_bytes (bytes, sz);
-
 }
 
-static int check_bytes(const ut8 *buf, ut64 length) {
-	struct EXE *exe = (struct EXE*) buf;
-	ut16 pe_header_offset;
+static void * load_bytes(RBinFile *arch, const ut8 *buf, ut64 sz,
+		ut64 loadaddr, Sdb *sdb) {
+	const struct r_bin_mz_obj_t *res = NULL;
+	RBuffer *tbuf = NULL;
+	if (!buf || sz == 0 || sz == UT64_MAX) return NULL;
+	tbuf = r_buf_new ();
+	r_buf_set_bytes (tbuf, buf, sz);
+	res = r_bin_mz_new_buf (tbuf);
+	if (res)
+		sdb_ns_set (sdb, "info", res->kv);
+	r_buf_free (tbuf);
+	return (void *)res;
+}
 
-	if (!buf)
+static int load(RBinFile *arch) {
+	const void *res;
+	const ut8 *bytes;
+	ut64 sz;
+
+	if (!arch || !arch->o)
 		return R_FALSE;
 
-	if (length <= 0x3d)
-		return R_FALSE;
-	/* The signature must be "MZ" or "ZM" */
-	if (exe->signature != 0x5a4d && exe->signature != 0x4d5a)
-		return R_FALSE;
-
-	/* Read the (undocumented) e_lfanew field which contains the address where
-	 * the PE header is (if any). If the signature "PE" is found then this exe
-	 * is a win32 one and we reject it */
-	pe_header_offset = (buf[0x3c] | (buf[0x3d] << 8));
-	if (length < pe_header_offset)
-		return R_FALSE;
-	if (buf[pe_header_offset] == 'P' && buf[pe_header_offset+1] == 'E')
-		return R_FALSE;
+	bytes = r_buf_buffer (arch->buf);
+	sz = r_buf_size (arch->buf);
+	res = load_bytes (arch, bytes, sz, arch->o->loadaddr, arch->sdb);
+	arch->o->bin_obj = (void *)res;
+	return res? R_TRUE: R_FALSE;
+}
 
+static int destroy(RBinFile *arch) {
+	r_bin_mz_free ((struct r_bin_mz_obj_t*)arch->o->bin_obj);
 	return R_TRUE;
 }
 
-RBinPlugin r_bin_plugin_mz = {
+static RList * entries(RBinFile *arch) {
+    int entry;
+	RList *res = NULL;
+	RBinAddr *ptr = NULL;
+
+	if (!(res = r_list_new ()))
+		return NULL;
+	res->free = free;
+
+	entry = r_bin_mz_get_entrypoint (arch->o->bin_obj);
+
+	if (entry >= 0) {
+		if ((ptr = R_NEW (RBinAddr))) {
+			ptr->paddr = (ut64) entry;
+			ptr->vaddr = (ut64) entry;
+			r_list_append (res, ptr);
+		}
+	}
+
+	return res;
+}
+
+static RList * sections(RBinFile *arch) {
+	RList *ret = NULL;
+	RBinSection *ptr = NULL;
+	const struct r_bin_mz_segment_t *segments = NULL;
+	int i;
+	if (!(ret = r_list_new ()))
+		return NULL;
+	ret->free = free;
+	if (!(segments = r_bin_mz_get_segments (arch->o->bin_obj))){
+		r_list_free (ret);
+		return NULL;
+	}
+	for (i = 0; !segments[i].last; i++) {
+		if (!(ptr = R_NEW0 (RBinSection))) {
+			free ((void *)segments);
+			r_list_free (ret);
+			return NULL;
+		}
+		sprintf ((char*)ptr->name, "seg_%03d", i);
+		ptr->size = segments[i].size;
+		ptr->vsize = segments[i].size;
+		ptr->paddr = segments[i].paddr;
+		ptr->vaddr = segments[i].paddr;
+		ptr->srwx = r_str_rwx ("rwx");
+		r_list_append (ret, ptr);
+	}
+	free ((void *)segments);
+	return ret;
+}
+
+static RBinInfo * info(RBinFile *arch) {
+	RBinInfo * const ret = R_NEW0 (RBinInfo);
+	if (!ret) return NULL;
+	ret->file = strdup (arch->file);
+	ret->bclass = strdup ("MZ");
+	ret->rclass = strdup ("mz");
+	ret->os = strdup ("DOS");
+	ret->arch = strdup ("x86");
+	ret->machine = strdup ("i386");
+	ret->type = strdup ("EXEC (Executable file)");
+	ret->subsystem = strdup ("DOS");
+	ret->rpath = NULL;
+	ret->cpu = NULL;
+	ret->guid = NULL;
+	ret->debug_file_name = NULL;
+	ret->bits = 16;
+	ret->big_endian = R_FALSE;
+	ret->dbg_info = 0;
+	ret->has_crypto = R_FALSE;
+	ret->has_canary = R_FALSE;
+	ret->has_nx = R_FALSE;
+	ret->has_pi = R_FALSE;
+	ret->has_va = R_FALSE;
+
+	return ret;
+}
+
+static RList * relocs(RBinFile *arch) {
+	RList *ret = NULL;
+	RBinReloc *rel = NULL;
+	const struct r_bin_mz_reloc_t *relocs = NULL;
+	int i;
+
+	if (!arch || !arch->o || !arch->o->bin_obj)
+		return NULL;
+	if (!(ret = r_list_new ()))
+		return NULL;
+
+	ret->free = free;
+
+	if (!(relocs = r_bin_mz_get_relocs (arch->o->bin_obj)))
+		return ret;
+	for (i = 0; !relocs[i].last; i++) {
+
+		if (!(rel = R_NEW0 (RBinReloc))) {
+			free ((void *)relocs);
+			r_list_free (ret);
+			return NULL;
+		}
+		rel->type = R_BIN_RELOC_16;
+		rel->vaddr = relocs[i].paddr;
+		rel->paddr = relocs[i].paddr;
+		r_list_append (ret, rel);
+	}
+	free ((void *)relocs);
+	return ret;
+}
+
+struct r_bin_plugin_t r_bin_plugin_mz = {
 	.name = "mz",
 	.desc = "MZ bin plugin",
-	.license = "LGPL3",
+	.license = "MIT",
 	.init = NULL,
 	.fini = NULL,
-	.get_sdb = NULL,
-	.load = &load,	//.load_bytes = &load_bytes,
+	.get_sdb = &get_sdb,
+	.load = &load,
+	.load_bytes = &load_bytes,
 	.destroy = &destroy,
 	.check = &check,
 	.check_bytes = &check_bytes,
 	.baddr = NULL,
 	.boffset = NULL,
-	.binsym = &binsym,
+	.binsym = NULL,
 	.entries = &entries,
 	.sections = &sections,
-	.symbols = &symbols,
-	.imports = &imports,
+	.symbols = NULL,
+	.imports = NULL,
 	.strings = NULL,
 	.info = &info,
-	.size = &size,
 	.fields = NULL,
 	.libs = NULL,
-	.relocs = NULL,
+	.relocs = &relocs,
 	.dbginfo = NULL,
 	.write = NULL,
+	.minstrlen = 4,
 	.create = NULL,
+	.get_vaddr = NULL
 };
 
 #ifndef CORELIB

libr/bin/p/mz.mk

@@ -1,4 +1,4 @@
-OBJ_MZ=bin_mz.o
+OBJ_MZ=bin_mz.o ../format/mz/mz.o
 
 STATIC_OBJ+=${OBJ_MZ}
 TARGET_MZ=bin_mz.${EXT_SO}
@@ -6,4 +6,5 @@ TARGET_MZ=bin_mz.${EXT_SO}
 ALL_TARGETS+=${TARGET_MZ}
 
 ${TARGET_MZ}: ${OBJ_MZ}
-	${CC} $(call libname,bin_mz) ${CFLAGS} ${OBJ_MZ}
+	-${CC} $(call libname, bin_mz) ${CFLAGS} \
+	${OBJ_MZ} $(LINK) $(LDFLAGS)

libr/include/btree.h

@@ -16,11 +16,13 @@ struct btree_node {
 
 #define BTREE_CMP(x) int (* x )(const void *, const void *)
 #define BTREE_DEL(x) int (* x )(void *)
+#define BTREE_TRV(x) void (* x )(const void *, const void *)
 
 #ifdef R_API
 R_API void btree_init(struct btree_node **T);
 R_API struct btree_node *btree_remove(struct btree_node *p, BTREE_DEL(del));
 R_API void *btree_search(struct btree_node *proot, void *x, BTREE_CMP(cmp), int parent);
+R_API void btree_traverse(struct btree_node *proot, int reverse, void *context, BTREE_TRV(trv));
 R_API int btree_del(struct btree_node *proot, void *x, BTREE_CMP(cmp), BTREE_DEL(del));
 R_API void *btree_get(struct btree_node *proot, void *x, BTREE_CMP(cmp));
 R_API void btree_insert(struct btree_node **T, struct btree_node *p, BTREE_CMP(cmp));

libr/util/btree.c

@@ -47,6 +47,20 @@ R_API void *btree_search(struct btree_node *root, void *x, BTREE_CMP(cmp), int p
 	} return NULL;
 }
 
+R_API void btree_traverse(struct btree_node *root, int reverse, void *context, BTREE_TRV(trv)) {
+	if (root!=NULL) {
+		if (reverse) {
+			btree_traverse (root->right, reverse, context, trv);
+			trv(root->data, context);
+			btree_traverse (root->left, reverse, context, trv);
+		} else {
+			btree_traverse (root->left, reverse, context, trv);
+			trv(root->data, context);
+			btree_traverse (root->right, reverse, context, trv);
+		}
+	}
+}
+
 R_API int btree_del(struct btree_node *proot, void *x, BTREE_CMP(cmp), BTREE_DEL(del)) {
 	struct btree_node *p = btree_search (proot, x, cmp, 1);
 	if (p) {