static RList* sections(RBinArch *arch) {
RList *ret = NULL;
RBinSection *ptr = NULL;
struct r_bin_mach0_section_t *sections = NULL;
int i;
if (!(ret = r_list_new ()))
return NULL;
ret->free = free;
if (!(sections = MACH0_(r_bin_mach0_get_sections) (arch->bin_obj)))
return ret;
for (i = 0; !sections[i].last; i++) {
if (!(ptr = R_NEW (RBinSection)))
break;
strncpy (ptr->name, (char*)sections[i].name, R_BIN_SIZEOF_STRINGS);
ptr->size = sections[i].size;
ptr->vsize = sections[i].size;
ptr->offset = sections[i].offset;
ptr->rva = sections[i].addr;
ptr->srwx = sections[i].srwx;
r_list_append (ret, ptr);
}
free (sections);
return ret;
}
static RList* imports(RBinArch *arch) {
RList *ret = NULL;
RBinImport *ptr = NULL;
struct r_bin_mach0_import_t *imports = NULL;
int i;
if (!(ret = r_list_new ()))
return NULL;
ret->free = free;
if (!(imports = MACH0_(r_bin_mach0_get_imports) (arch->bin_obj)))
return ret;
for (i = 0; !imports[i].last; i++) {
if (!(ptr = R_NEW (RBinImport)))
break;
strncpy (ptr->name, (char*)imports[i].name, R_BIN_SIZEOF_STRINGS);
strncpy (ptr->bind, "NONE", R_BIN_SIZEOF_STRINGS);
if (imports[i].type == R_BIN_MACH0_IMPORT_TYPE_FUNC)
strncpy (ptr->type, "FUNC", R_BIN_SIZEOF_STRINGS);
else strncpy (ptr->type, "OBJECT", R_BIN_SIZEOF_STRINGS);
ptr->rva = imports[i].addr;
ptr->offset = imports[i].offset;
ptr->size = 0;
ptr->ordinal = 0;
ptr->hint = 0;
r_list_append (ret, ptr);
}
free (imports);
return ret;
}
static RList* symbols(RBinArch *arch) {
RList *ret = NULL;
RBinSymbol *ptr = NULL;
struct r_bin_mach0_symbol_t *symbols = NULL;
int i;
if (!(ret = r_list_new ()))
return NULL;
ret->free = free;
if (!(symbols = MACH0_(r_bin_mach0_get_symbols) (arch->bin_obj)))
return ret;
for (i = 0; !symbols[i].last; i++) {
if (!(ptr = R_NEW (RBinSymbol)))
break;
strncpy (ptr->name, (char*)symbols[i].name, R_BIN_SIZEOF_STRINGS);
strncpy (ptr->forwarder, "NONE", R_BIN_SIZEOF_STRINGS);
strncpy (ptr->bind, "NONE", R_BIN_SIZEOF_STRINGS);
strncpy (ptr->type, "FUNC", R_BIN_SIZEOF_STRINGS); //XXX Get the right type
if (symbols[i].type == R_BIN_MACH0_SYMBOL_TYPE_LOCAL)
strncat (ptr->type, "_LOCAL", sizeof (ptr->type)-strlen (ptr->type)-1);
ptr->rva = symbols[i].addr;
ptr->offset = symbols[i].offset;
ptr->size = symbols[i].size;
ptr->ordinal = 0;
r_list_append (ret, ptr);
}
free (symbols);
return ret;
}
static RBinAddr* binsym(RBinFile *arch, int sym) {
ut64 addr;
RBinAddr *ret = NULL;
switch (sym) {
case R_BIN_SYM_MAIN:
addr = MACH0_(get_main) (arch->o->bin_obj);
if (!addr || !(ret = R_NEW0 (RBinAddr)))
return NULL;
ret->paddr = ret->vaddr = addr;
break;
}
return ret;
}
static RBinAddr* binsym(RBinArch *arch, int sym) {
ut64 addr;
RBinAddr *ret = NULL;
switch (sym) {
case R_BIN_SYM_MAIN:
addr = MACH0_(r_bin_mach0_get_main) (arch->bin_obj);
if (!addr || !(ret = R_NEW (RBinAddr)))
return NULL;
memset (ret, '\0', sizeof (RBinAddr));
ret->offset = ret->rva = addr;
break;
}
return ret;
}
static RList* libs(RBinArch *arch) {
int i;
char *ptr = NULL;
struct r_bin_mach0_lib_t *libs;
RList *ret = r_list_new ();
if (!ret) return NULL;
ret->free = free;
if ((libs = MACH0_(r_bin_mach0_get_libs) (arch->bin_obj))) {
for (i = 0; !libs[i].last; i++) {
ptr = strdup (libs[i].name);
r_list_append (ret, ptr);
}
free (libs);
}
return ret;
}
static RList* entries(RBinArch *arch) {
RList *ret;
RBinAddr *ptr = NULL;
struct r_bin_mach0_addr_t *entry = NULL;
if (!(ret = r_list_new ()))
return NULL;
ret->free = free;
if (!(entry = MACH0_(r_bin_mach0_get_entrypoint) (arch->bin_obj)))
return ret;
if ((ptr = R_NEW (RBinAddr))) {
memset (ptr, '\0', sizeof (RBinAddr));
ptr->offset = entry->offset;
ptr->rva = entry->addr;
r_list_append (ret, ptr);
}
free (entry);
return ret;
}
static RBinInfo* info(RBinArch *arch) {
char *str;
RBinInfo *ret = NULL;
if ((ret = R_NEW (RBinInfo)) == NULL)
return NULL;
memset (ret, '\0', sizeof (RBinInfo));
strncpy (ret->file, arch->file, R_BIN_SIZEOF_STRINGS);
strncpy (ret->rpath, "NONE", R_BIN_SIZEOF_STRINGS);
if ((str = MACH0_(r_bin_mach0_get_class) (arch->bin_obj))) {
strncpy (ret->bclass, str, R_BIN_SIZEOF_STRINGS);
free (str);
}
strncpy (ret->rclass, "mach0", R_BIN_SIZEOF_STRINGS);
/* TODO get os */
strncpy (ret->os, "darwin", R_BIN_SIZEOF_STRINGS);
strncpy (ret->subsystem, "darwin", R_BIN_SIZEOF_STRINGS);
if ((str = MACH0_(r_bin_mach0_get_cputype) (arch->bin_obj))) {
strncpy (ret->arch, str, R_BIN_SIZEOF_STRINGS);
free (str);
}
if ((str = MACH0_(r_bin_mach0_get_cpusubtype) (arch->bin_obj))) {
strncpy (ret->machine, str, R_BIN_SIZEOF_STRINGS);
free (str);
}
if ((str = MACH0_(r_bin_mach0_get_filetype) (arch->bin_obj))) {
strncpy (ret->type, str, R_BIN_SIZEOF_STRINGS);
free (str);
}
ret->bits = MACH0_(r_bin_mach0_get_bits) (arch->bin_obj);
ret->big_endian = MACH0_(r_bin_mach0_is_big_endian) (arch->bin_obj);
/* TODO detailed debug info */
ret->dbg_info = 0;
ret->has_va = R_TRUE;
return ret;
}
static int load(RBinArch *arch) {
if(!(arch->bin_obj = MACH0_(r_bin_mach0_new_buf) (arch->buf)))
return R_FALSE;
return R_TRUE;
}
static ut64 baddr(RBinArch *arch) {
return MACH0_(r_bin_mach0_get_baddr) (arch->bin_obj);
}
static int destroy(RBinArch *arch) {
MACH0_(r_bin_mach0_free) (arch->bin_obj);
return R_TRUE;
}
.license = "LGPL3",
.get_sdb = &get_sdb,
.load = &load,
.load_bytes = &load_bytes,
.destroy = &destroy,
.check_bytes = &check_bytes,
.baddr = &baddr,
.binsym = binsym,
.entries = &entries,
.sections = §ions,
.signature = &entitlements,
.symbols = &symbols,
.imports = &imports,
.info = &info,
.libs = &libs,
.header = &MACH0_(mach_headerfields),
.relocs = &relocs,
.fields = &MACH0_(mach_fields),
.create = &create,
.classes = &MACH0_(parse_classes),
.write = &r_bin_write_mach0,
};
#ifndef CORELIB
RLibStruct radare_plugin = {
.type = R_LIB_TYPE_BIN,
.data = &r_bin_plugin_mach064,
.version = R2_VERSION
};
#endif
nlib = data->file_count;
result = r_list_newf (r_bin_xtrdata_free);
if (!result) {
return NULL;
}
r_list_append (result, data);
for (i = 1; data && i < nlib; i++) {
data = extract (bin, i);
r_list_append (result, data);
}
return result;
}
static inline void fill_metadata_info_from_hdr(RBinXtrMetadata *meta,
struct MACH0_ (mach_header) *hdr) {
meta->arch = MACH0_(get_cputype_from_hdr) (hdr);
meta->bits = MACH0_(get_bits_from_hdr) (hdr);
meta->machine = MACH0_(get_cpusubtype_from_hdr) (hdr);
meta->type = MACH0_(get_filetype_from_hdr) (hdr);
}
static RBinXtrData *extract(RBin *bin, int idx) {
int nlib = 0;
RBinXtrData *res = NULL;
char *libname;
struct MACH0_(mach_header) *hdr;
struct r_bin_dyldcache_lib_t *lib = r_bin_dyldcache_extract (
(struct r_bin_dyldcache_obj_t*)bin->cur->xtr_obj, idx, &nlib);
if (lib) {
RBinXtrMetadata *metadata = R_NEW0(RBinXtrMetadata);