ne.c File Reference

#include "ne.h"

Go to the source code of this file.

Functions
static char *	__get_target_os (rz_bin_ne_obj_t *bin)
static int	__translate_perms (int flags)
static char *	__read_nonnull_str_at (RzBuffer *buf, ut64 offset)
static char *	__func_name_from_ord (char *module, ut16 ordinal)
RzList *	rz_bin_ne_get_segments (rz_bin_ne_obj_t *bin)
static int	__find_symbol_by_paddr (const void *paddr, const void *sym)
static void	ne_sanitize_name (char *name, ut16 count)
RzList *	rz_bin_ne_get_symbols (rz_bin_ne_obj_t *bin)
static char *	__resource_type_str (int type)
static void	__free_resource_entry (void *entry)
static void	__free_resource (void *resource)
static bool	__ne_get_resources (rz_bin_ne_obj_t *bin)
RzList *	rz_bin_ne_get_imports (rz_bin_ne_obj_t *bin)
RzList *	rz_bin_ne_get_entrypoints (rz_bin_ne_obj_t *bin)
RzList *	rz_bin_ne_get_relocs (rz_bin_ne_obj_t *bin)
bool	rz_bin_ne_buf_init (RzBuffer *buf, rz_bin_ne_obj_t *bin)
void	rz_bin_ne_free (rz_bin_ne_obj_t *bin)
rz_bin_ne_obj_t *	rz_bin_ne_new_buf (RzBuffer *buf, bool verbose)

Function Documentation

__find_symbol_by_paddr()

static int __find_symbol_by_paddr ( const void *  paddr, const void *  sym  )

static

Definition at line 108 of file ne.c.

                                                                      {
    return (int)!(*(ut64 *)paddr == ((RzBinSymbol *)sym)->paddr);
}

References ut64().

Referenced by rz_bin_ne_get_symbols().

__free_resource()

static void __free_resource ( void *  resource )

static

Definition at line 285 of file ne.c.

                                            {
    rz_ne_resource *res = (rz_ne_resource *)resource;
    free(res->name);
    rz_list_free(res->entry);
    free(res);
}

References rz_ne_resource::entry, free(), rz_ne_resource::name, and rz_list_free().

Referenced by __ne_get_resources().

__free_resource_entry()

static void __free_resource_entry ( void *  entry )

static

Definition at line 279 of file ne.c.

                                               {
    rz_ne_resource_entry *en = (rz_ne_resource_entry *)entry;
    free(en->name);
    free(en);
}

References free(), and rz_ne_resource_entry::name.

Referenced by __ne_get_resources().

__func_name_from_ord()

static char* __func_name_from_ord ( char *  module, ut16  ordinal  )

static

Definition at line 55 of file ne.c.

                                                              {
    char *formats_dir = rz_path_system(RZ_SDB_FORMAT);
    char *path = rz_str_newf(RZ_JOIN_3_PATHS("%s", "dll", "%s.sdb"), formats_dir, module);
    free(formats_dir);
    char *ord = rz_str_newf("%d", ordinal);
    char *name;
    if (rz_file_exists(path)) {
        Sdb *sdb = sdb_new(NULL, path, 0);
        name = sdb_get(sdb, ord, NULL);
        if (!name) {
            name = ord;
        } else {
            free(ord);
        }
        sdb_close(sdb);
        free(sdb);
    } else {
        name = ord;
    }
    free(path);
    return name;
}

References free(), name, NULL, path, rz_file_exists(), RZ_JOIN_3_PATHS, rz_path_system(), RZ_SDB_FORMAT, rz_str_newf(), sdb_close(), sdb_get(), and sdb_new().

Referenced by rz_bin_ne_get_relocs().

__get_target_os()

static char* __get_target_os ( rz_bin_ne_obj_t *  bin )

static

Definition at line 6 of file ne.c.

                                                   {
    switch (bin->ne_header->targOS) {
    case 1:
        return "OS/2";
    case 2:
        return "Windows";
    case 3:
        return "European MS-DOS 4.x";
    case 4:
        return "Windows 386";
    case 5:
        return "BOSS (Borland Operating System Services)";
    default:
        return "Unknown";
    }
}

Referenced by rz_bin_ne_buf_init().

__ne_get_resources()

static bool __ne_get_resources ( rz_bin_ne_obj_t *  bin )

static

Definition at line 292 of file ne.c.

                                                     {
    if (!bin->resources) {
        bin->resources = rz_list_newf(__free_resource);
    }
    ut16 resoff = bin->ne_header->ResTableOffset + bin->header_offset;
 
    ut16 alignment;
    if (!rz_buf_read_le16_at(bin->buf, resoff, &alignment) || alignment > 31) {
        return false;
    }
 
    ut32 off = resoff + 2;
    while (true) {
        NE_image_typeinfo_entry ti = { 0 };
        rz_ne_resource *res = RZ_NEW0(rz_ne_resource);
        if (!res) {
            break;
        }
        res->entry = rz_list_newf(__free_resource_entry);
        if (!res->entry) {
            break;
        }
        rz_buf_read_at(bin->buf, off, (ut8 *)&ti, sizeof(ti));
        if (!ti.rtTypeID) {
            break;
        } else if (ti.rtTypeID & 0x8000) {
            res->name = __resource_type_str(ti.rtTypeID & ~0x8000);
        } else {
            // Offset to resident name table
            res->name = __read_nonnull_str_at(bin->buf, (ut64)resoff + ti.rtTypeID);
        }
        off += sizeof(NE_image_typeinfo_entry);
        int i;
        for (i = 0; i < ti.rtResourceCount; i++) {
            NE_image_nameinfo_entry ni;
            rz_ne_resource_entry *ren = RZ_NEW0(rz_ne_resource_entry);
            if (!ren) {
                break;
            }
            rz_buf_read_at(bin->buf, off, (ut8 *)&ni, sizeof(NE_image_nameinfo_entry));
            ren->offset = ni.rnOffset << alignment;
            ren->size = ni.rnLength;
            if (ni.rnID & 0x8000) {
                ren->name = rz_str_newf("%d", ni.rnID & ~0x8000);
            } else {
                // Offset to resident name table
                ren->name = __read_nonnull_str_at(bin->buf, (ut64)resoff + ni.rnID);
            }
            rz_list_append(res->entry, ren);
            off += sizeof(NE_image_nameinfo_entry);
        }
        rz_list_append(bin->resources, res);
    }
    return true;
}

References __free_resource(), __free_resource_entry(), __read_nonnull_str_at(), __resource_type_str(), bin::buf, rz_ne_resource::entry, i, rz_ne_resource_entry::name, rz_ne_resource::name, off, rz_ne_resource_entry::offset, _NAMEINFO::rnID, _NAMEINFO::rnLength, _NAMEINFO::rnOffset, _TYPEINFO::rtResourceCount, _TYPEINFO::rtTypeID, rz_buf_read_at(), rz_buf_read_le16_at, rz_list_append(), rz_list_newf(), RZ_NEW0, rz_str_newf(), rz_ne_resource_entry::size, and ut64().

Referenced by rz_bin_ne_buf_init().

__read_nonnull_str_at()

static char* __read_nonnull_str_at ( RzBuffer *  buf, ut64  offset  )

static

Definition at line 38 of file ne.c.

                                                               {
    ut8 sz;
    if (!rz_buf_read8_at(buf, offset, &sz)) {
        return NULL;
    }
    if (!sz) {
        return NULL;
    }
    char *str = malloc((ut64)sz + 1);
    if (!str) {
        return NULL;
    }
    rz_buf_read_at(buf, offset + 1, (ut8 *)str, sz);
    str[sz] = '\0';
    return str;
}

References malloc(), NULL, rz_buf_read8_at(), rz_buf_read_at(), cmd_descs_generate::str, and ut64().

Referenced by __ne_get_resources(), and rz_bin_ne_get_relocs().

__resource_type_str()

static char* __resource_type_str ( int  type )

static

Definition at line 204 of file ne.c.

                                           {
    char *typeName;
    switch (type) {
    case 1:
        typeName = "CURSOR";
        break;
    case 2:
        typeName = "BITMAP";
        break;
    case 3:
        typeName = "ICON";
        break;
    case 4:
        typeName = "MENU";
        break;
    case 5:
        typeName = "DIALOG";
        break;
    case 6:
        typeName = "STRING";
        break;
    case 7:
        typeName = "FONTDIR";
        break;
    case 8:
        typeName = "FONT";
        break;
    case 9:
        typeName = "ACCELERATOR";
        break;
    case 10:
        typeName = "RCDATA";
        break;
    case 11:
        typeName = "MESSAGETABLE";
        break;
    case 12:
        typeName = "GROUP_CURSOR";
        break;
    case 14:
        typeName = "GROUP_ICON";
        break;
    case 15:
        typeName = "NAMETABLE";
        break;
    case 16:
        typeName = "VERSION";
        break;
    case 17:
        typeName = "DLGINCLUDE";
        break;
    case 19:
        typeName = "PLUGPLAY";
        break;
    case 20:
        typeName = "VXD";
        break;
    case 21:
        typeName = "ANICURSOR";
        break;
    case 22:
        typeName = "ANIICON";
        break;
    case 23:
        typeName = "HTML";
        break;
    case 24:
        typeName = "MANIFEST";
        break;
    default:
        return rz_str_newf("UNKNOWN (%d)", type);
    }
    return strdup(typeName);
}

References rz_str_newf(), strdup(), and type.

Referenced by __ne_get_resources().

__translate_perms()

static int __translate_perms ( int  flags )

static

Definition at line 23 of file ne.c.

                                        {
    int perms = 0;
    if (flags & IS_RX) {
        if (flags & IS_DATA) {
            perms = RZ_PERM_R;
        } else {
            perms = RZ_PERM_X;
        }
    }
    if (!perms) {
        perms = RZ_PERM_RWX;
    }
    return perms;
}

References flags, IS_DATA, IS_RX, RZ_PERM_R, RZ_PERM_RWX, and RZ_PERM_X.

Referenced by rz_bin_ne_get_segments().

ne_sanitize_name()

static void ne_sanitize_name ( char *  name, ut16  count  )

static

Definition at line 112 of file ne.c.

                                                     {
    // expect to have names in ASCII format.
    for (ut16 i = 0; i < count && name[i]; ++i) {
        if (!IS_PRINTABLE(name[i])) {
            name[i] = '?';
        }
    }
}

References count, i, and IS_PRINTABLE.

Referenced by rz_bin_ne_get_symbols().

rz_bin_ne_buf_init()

bool rz_bin_ne_buf_init	(	RzBuffer *	buf,
		rz_bin_ne_obj_t *	bin
	)

Definition at line 616 of file ne.c.

                                                             {
    if (!rz_buf_read_le16_at(buf, 0x3c, &bin->header_offset)) {
        return false;
    }
 
    bin->ne_header = RZ_NEW0(NE_image_header);
    if (!bin->ne_header) {
        return false;
    }
    bin->buf = buf;
    rz_buf_read_at(buf, bin->header_offset, (ut8 *)bin->ne_header, sizeof(NE_image_header));
    if (bin->ne_header->FileAlnSzShftCnt > 31) {
        return false;
    }
    bin->alignment = 1 << bin->ne_header->FileAlnSzShftCnt;
    if (!bin->alignment) {
        bin->alignment = 1 << 9;
    }
    bin->os = __get_target_os(bin);
 
    ut16 offset = bin->ne_header->SegTableOffset + bin->header_offset;
    ut16 size = bin->ne_header->SegCount * sizeof(NE_image_segment_entry);
    if (!size) {
        return false;
    }
    bin->segment_entries = calloc(bin->ne_header->SegCount, sizeof(NE_image_segment_entry));
    if (!bin->segment_entries) {
        return false;
    }
    rz_buf_read_at(buf, offset, (ut8 *)bin->segment_entries, size);
    if (!bin->ne_header->EntryTableLength) {
        return false;
    }
    bin->entry_table = calloc(1, bin->ne_header->EntryTableLength);
    if (!bin->entry_table) {
        return false;
    }
    rz_buf_read_at(buf, (ut64)bin->header_offset + bin->ne_header->EntryTableOffset, bin->entry_table, bin->ne_header->EntryTableLength);
    bin->imports = rz_bin_ne_get_imports(bin);
    __ne_get_resources(bin);
    return true;
}

References __get_target_os(), __ne_get_resources(), bin::buf, calloc(), rz_bin_ne_get_imports(), rz_buf_read_at(), rz_buf_read_le16_at, RZ_NEW0, and ut64().

Referenced by rz_bin_ne_new_buf().

rz_bin_ne_free()

void rz_bin_ne_free

(

rz_bin_ne_obj_t *

bin

)

Definition at line 659 of file ne.c.

                                          {
    if (!bin) {
        return;
    }
    // rz_list_free (bin->imports); // double free
    rz_list_free(bin->resources);
    free(bin->entry_table);
    free(bin->ne_header);
    free(bin->resident_name_table);
    free(bin->segment_entries);
    free(bin);
}

References free(), and rz_list_free().

Referenced by destroy(), and rz_bin_ne_new_buf().

rz_bin_ne_get_entrypoints()

RzList* rz_bin_ne_get_entrypoints

(

rz_bin_ne_obj_t *

bin

)

Definition at line 384 of file ne.c.

                                                        {
    RzList *entries = rz_list_newf(free);
    if (!entries) {
        return NULL;
    }
    RzBinAddr *entry;
    RzList *segments = rz_bin_ne_get_segments(bin);
    if (!segments) {
        rz_list_free(entries);
        return NULL;
    }
    if (bin->ne_header->csEntryPoint) {
        entry = RZ_NEW0(RzBinAddr);
        if (!entry) {
            rz_list_free(entries);
            return NULL;
        }
        entry->bits = 16;
        RzBinSection *s = rz_list_get_n(segments, bin->ne_header->csEntryPoint - 1);
        entry->paddr = bin->ne_header->ipEntryPoint + (s ? s->paddr : 0);
        rz_list_append(entries, entry);
    }
    ut32 off = 0;
    while (off < bin->ne_header->EntryTableLength) {
        ut8 bundle_length = *(ut8 *)(bin->entry_table + off);
        if (!bundle_length) {
            break;
        }
        off++;
        if (off >= bin->ne_header->EntryTableLength) {
            break;
        }
        ut8 bundle_type = *(ut8 *)(bin->entry_table + off);
        off++;
        int i;
        for (i = 0; i < bundle_length; i++) {
            entry = RZ_NEW0(RzBinAddr);
            if (!entry) {
                rz_list_free(entries);
                return NULL;
            }
            off++;
            if (!bundle_type) { // Skip
                off--;
                free(entry);
                break;
            } else if (bundle_type == 0xFF) { // Moveable
                off += 2;
                ut8 segnum = *(bin->entry_table + off);
                off++;
                ut16 segoff = *(ut16 *)(bin->entry_table + off);
                if (!segnum) {
                    free(entry);
                    continue;
                }
                entry->paddr = (ut64)bin->segment_entries[segnum - 1].offset * bin->alignment + segoff;
            } else { // Fixed
                ut16 *p = (ut16 *)(bin->entry_table + off);
                if (off >= bin->ne_header->EntryTableLength || bundle_type > bin->ne_header->SegCount) {
                    free(entry);
                    continue;
                }
                entry->paddr = (ut64)bin->segment_entries[bundle_type - 1].offset * bin->alignment + (*p);
            }
            off += 2;
            rz_list_append(entries, entry);
        }
    }
    rz_list_free(segments);
    bin->entries = entries;
    return entries;
}

References entries(), free(), i, NULL, off, p, rz_bin_ne_get_segments(), rz_list_append(), rz_list_free(), rz_list_get_n(), rz_list_newf(), RZ_NEW0, s, and ut64().

Referenced by entries(), and rz_bin_ne_get_symbols().

rz_bin_ne_get_imports()

RzList* rz_bin_ne_get_imports

(

rz_bin_ne_obj_t *

bin

)

Definition at line 348 of file ne.c.

                                                    {
    RzList *imports = rz_list_newf((RzListFree)rz_bin_import_free);
    if (!imports) {
        return NULL;
    }
    ut16 off = bin->ne_header->ImportNameTable + bin->header_offset + 1;
    int i;
    for (i = 0; i < bin->ne_header->ModRefs; i++) {
        RzBinImport *imp = RZ_NEW0(RzBinImport);
        if (!imp) {
            break;
        }
        ut8 sz;
        if (!rz_buf_read8_at(bin->buf, off, &sz)) {
            break;
        }
        if (!sz) {
            rz_bin_import_free(imp);
            break;
        }
        off++;
        char *name = malloc((ut64)sz + 1);
        if (!name) {
            break;
        }
        rz_buf_read_at(bin->buf, off, (ut8 *)name, sz);
        name[sz] = '\0';
        imp->name = name;
        imp->ordinal = i + 1;
        rz_list_append(imports, imp);
        off += sz;
    }
    bin->imports = imports;
    return imports;
}

References bin::buf, i, imports(), malloc(), name, rz_bin_import_t::name, NULL, off, rz_bin_import_t::ordinal, rz_bin_import_free(), rz_buf_read8_at(), rz_buf_read_at(), rz_list_append(), rz_list_newf(), RZ_NEW0, and ut64().

Referenced by imports(), and rz_bin_ne_buf_init().

rz_bin_ne_get_relocs()

RzList* rz_bin_ne_get_relocs

(

rz_bin_ne_obj_t *

bin

)

Definition at line 457 of file ne.c.

                                                   {
    RzList *segments = bin->segments;
    if (!segments) {
        return NULL;
    }
    RzList *entries = bin->entries;
    if (!entries) {
        return NULL;
    }
    RzList *symbols = bin->symbols;
    if (!symbols) {
        return NULL;
    }
 
    ut16 *modref = calloc(bin->ne_header->ModRefs, sizeof(ut16));
    if (!modref) {
        return NULL;
    }
    rz_buf_read_at(bin->buf, (ut64)bin->ne_header->ModRefTable + bin->header_offset, (ut8 *)modref, bin->ne_header->ModRefs * sizeof(ut16));
 
    RzList *relocs = rz_list_newf(free);
    if (!relocs) {
        free(modref);
        return NULL;
    }
 
    ut64 bufsz = rz_buf_size(bin->buf);
    RzListIter *it;
    RzBinSection *seg;
    int index = -1;
    rz_list_foreach (segments, it, seg) {
        index++;
        if (!(bin->segment_entries[index].flags & RELOCINFO)) {
            continue;
        }
        ut32 off, start = off = seg->paddr + seg->size;
        if ((ut64)off + 2 > bufsz) {
            continue;
        }
        ut16 length;
        if (!rz_buf_read_le16_at(bin->buf, off, &length)) {
            continue;
        }
 
        if (!length) {
            continue;
        }
        off += 2;
        while (off < start + length * sizeof(NE_image_reloc_item) && off + sizeof(NE_image_reloc_item) <= bufsz) {
            RzBinReloc *reloc = RZ_NEW0(RzBinReloc);
            if (!reloc) {
                return NULL;
            }
            NE_image_reloc_item rel;
            rz_buf_read_at(bin->buf, off, (ut8 *)&rel, sizeof(rel));
            reloc->paddr = seg->paddr + rel.offset;
            switch (rel.type) {
            case LOBYTE:
                reloc->type = RZ_BIN_RELOC_8;
                break;
            case SEL_16:
            case OFF_16:
                reloc->type = RZ_BIN_RELOC_16;
                break;
            case POI_32:
            case OFF_32:
                reloc->type = RZ_BIN_RELOC_32;
                break;
            case POI_48:
                reloc->type = RZ_BIN_RELOC_64;
                break;
            }
 
            ut32 offset;
            if (rel.flags & (IMPORTED_ORD | IMPORTED_NAME)) {
                RzBinImport *imp = RZ_NEW0(RzBinImport);
                if (!imp) {
                    free(reloc);
                    break;
                }
                char *name = NULL;
                if (rel.index > bin->ne_header->ModRefs || !rel.index) {
                    name = rz_str_newf("UnknownModule%d_%x", rel.index, off); // ????
                } else {
                    offset = modref[rel.index - 1] + bin->header_offset + bin->ne_header->ImportNameTable;
                    name = __read_nonnull_str_at(bin->buf, offset);
                }
                if (rel.flags & IMPORTED_ORD) {
                    imp->ordinal = rel.func_ord;
                    imp->name = rz_str_newf("%s.%s", name, __func_name_from_ord(name, rel.func_ord));
                } else {
                    offset = bin->header_offset + bin->ne_header->ImportNameTable + rel.name_off;
                    char *func = __read_nonnull_str_at(bin->buf, offset);
                    imp->name = rz_str_newf("%s.%s", name, func);
                    free(func);
                }
                free(name);
                reloc->import = imp;
            } else if (rel.flags & OSFIXUP) {
                // TODO
            } else {
                if (strstr(seg->name, "FIXED")) {
                    RzBinSection *s = rz_list_get_n(segments, rel.segnum - 1);
                    if (s) {
                        offset = s->paddr + rel.segoff;
                    } else {
                        offset = -1;
                    }
                } else {
                    RzBinAddr *entry = rz_list_get_n(entries, rel.entry_ordinal - 1);
                    if (entry) {
                        offset = entry->paddr;
                    } else {
                        offset = -1;
                    }
                }
                reloc->addend = offset;
                RzBinSymbol *sym = NULL;
                RzListIter *sit;
                rz_list_foreach (symbols, sit, sym) {
                    if (sym->paddr == reloc->addend) {
                        reloc->symbol = sym;
                        break;
                    }
                }
            }
 
            if (rel.flags & ADDITIVE) {
                reloc->additive = 1;
                rz_list_append(relocs, reloc);
            } else {
                do {
                    rz_list_append(relocs, reloc);
                    ut16 tmp_offset;
                    if (!rz_buf_read_le16_at(bin->buf, reloc->paddr, &tmp_offset)) {
                        reloc = NULL;
                        break;
                    }
 
                    offset = tmp_offset;
 
                    RzBinReloc *tmp = reloc;
                    reloc = RZ_NEW0(RzBinReloc);
                    if (!reloc) {
                        break;
                    }
                    *reloc = *tmp;
                    reloc->paddr = seg->paddr + offset;
                } while (offset != 0xFFFF);
                free(reloc);
            }
 
            off += sizeof(NE_image_reloc_item);
        }
    }
    free(modref);
    return relocs;
}

References __func_name_from_ord(), __read_nonnull_str_at(), rz_bin_reloc_t::addend, ADDITIVE, rz_bin_reloc_t::additive, bin::buf, calloc(), entries(), _RELOC::entry_ordinal, _RELOC::flags, free(), _RELOC::func_ord, rz_bin_reloc_t::import, IMPORTED_NAME, IMPORTED_ORD, _RELOC::index, length, LOBYTE, rz_bin_section_t::name, rz_bin_import_t::name, _RELOC::name_off, NULL, off, OFF_16, OFF_32, _RELOC::offset, rz_bin_import_t::ordinal, OSFIXUP, rz_bin_section_t::paddr, rz_bin_symbol_t::paddr, rz_bin_reloc_t::paddr, POI_32, POI_48, RELOCINFO, relocs(), RZ_BIN_RELOC_16, RZ_BIN_RELOC_32, RZ_BIN_RELOC_64, RZ_BIN_RELOC_8, rz_buf_read_at(), rz_buf_read_le16_at, rz_buf_size(), rz_list_append(), rz_list_get_n(), rz_list_newf(), RZ_NEW0, rz_str_newf(), s, _RELOC::segnum, _RELOC::segoff, SEL_16, rz_bin_section_t::size, start, rz_bin_reloc_t::symbol, symbols(), autogen_x86imm::tmp, _RELOC::type, rz_bin_reloc_t::type, and ut64().

Referenced by relocs().

rz_bin_ne_get_segments()

RzList* rz_bin_ne_get_segments

(

rz_bin_ne_obj_t *

bin

)

Definition at line 78 of file ne.c.

                                                     {
    int i;
    if (!bin) {
        return NULL;
    }
    RzList *segments = rz_list_newf((RzListFree)rz_bin_section_free);
    if (!segments) {
        return NULL;
    }
    for (i = 0; i < bin->ne_header->SegCount; i++) {
        RzBinSection *bs = RZ_NEW0(RzBinSection);
        NE_image_segment_entry *se = &bin->segment_entries[i];
        if (!bs || !se) {
            free(bs);
            return segments;
        }
        bs->size = se->length;
        bs->vsize = se->minAllocSz ? se->minAllocSz : 64000;
        bs->bits = RZ_SYS_BITS_16;
        bs->is_data = se->flags & IS_DATA;
        bs->perm = __translate_perms(se->flags);
        bs->paddr = (ut64)se->offset * bin->alignment;
        bs->name = rz_str_newf("%s.%" PFMT64d, se->flags & IS_MOVEABLE ? "MOVEABLE" : "FIXED", bs->paddr);
        bs->is_segment = true;
        rz_list_append(segments, bs);
    }
    bin->segments = segments;
    return segments;
}

References __translate_perms(), rz_bin_section_t::bits, _SEGMENT::flags, free(), i, IS_DATA, rz_bin_section_t::is_data, IS_MOVEABLE, rz_bin_section_t::is_segment, _SEGMENT::length, _SEGMENT::minAllocSz, rz_bin_section_t::name, NULL, _SEGMENT::offset, rz_bin_section_t::paddr, rz_bin_section_t::perm, PFMT64d, rz_bin_section_free(), rz_list_append(), rz_list_newf(), RZ_NEW0, rz_str_newf(), RZ_SYS_BITS_16, rz_bin_section_t::size, ut64(), and rz_bin_section_t::vsize.

Referenced by rz_bin_ne_get_entrypoints(), and sections().

rz_bin_ne_get_symbols()

RzList* rz_bin_ne_get_symbols

(

rz_bin_ne_obj_t *

bin

)

Definition at line 121 of file ne.c.

                                                    {
    RzBinSymbol *sym;
    ut16 off = bin->ne_header->ResidNamTable + bin->header_offset;
    RzList *symbols = rz_list_newf(free);
    if (!symbols) {
        return NULL;
    }
    RzList *entries = rz_bin_ne_get_entrypoints(bin);
    bool resident = true, first = true;
    while (true) {
        ut8 sz;
        if (!rz_buf_read8_at(bin->buf, off, &sz)) {
            break;
        }
        if (!sz) {
            first = true;
            if (resident) {
                resident = false;
                off = bin->ne_header->OffStartNonResTab;
                if (!rz_buf_read8_at(bin->buf, off, &sz)) {
                    break;
                }
                if (!sz) {
                    break;
                }
            } else {
                break;
            }
        }
        char *name = malloc((ut64)sz + 1);
        if (!name) {
            break;
        }
        off++;
        rz_buf_read_at(bin->buf, off, (ut8 *)name, sz);
        name[sz] = '\0';
        off += sz;
        sym = RZ_NEW0(RzBinSymbol);
        if (!sym) {
            break;
        }
        ne_sanitize_name(name, sz);
        sym->name = name;
        if (!first) {
            sym->bind = RZ_BIN_BIND_GLOBAL_STR;
        }
        ut16 entry_off;
        if (!rz_buf_read_le16_at(bin->buf, off, &entry_off)) {
            rz_bin_symbol_free(sym);
            break;
        }
        off += 2;
        RzBinAddr *entry = rz_list_get_n(entries, entry_off);
        if (entry) {
            sym->paddr = entry->paddr;
        } else {
            sym->paddr = -1;
        }
        sym->ordinal = entry_off;
        rz_list_append(symbols, sym);
        first = false;
    }
    RzListIter *it;
    RzBinAddr *en;
    int i = 1;
    rz_list_foreach (entries, it, en) {
        if (!rz_list_find(symbols, &en->paddr, __find_symbol_by_paddr)) {
            sym = RZ_NEW0(RzBinSymbol);
            if (!sym) {
                break;
            }
            sym->name = rz_str_newf("entry%d", i - 1);
            sym->paddr = en->paddr;
            sym->bind = RZ_BIN_BIND_GLOBAL_STR;
            sym->ordinal = i;
            rz_list_append(symbols, sym);
        }
        i++;
    }
    bin->symbols = symbols;
    return symbols;
}

References __find_symbol_by_paddr(), rz_bin_symbol_t::bind, bin::buf, entries(), free(), i, malloc(), name, rz_bin_symbol_t::name, ne_sanitize_name(), NULL, off, rz_bin_symbol_t::ordinal, rz_bin_addr_t::paddr, rz_bin_symbol_t::paddr, RZ_BIN_BIND_GLOBAL_STR, rz_bin_ne_get_entrypoints(), rz_bin_symbol_free(), rz_buf_read8_at(), rz_buf_read_at(), rz_buf_read_le16_at, rz_list_append(), rz_list_find(), rz_list_get_n(), rz_list_newf(), RZ_NEW0, rz_str_newf(), symbols(), and ut64().

Referenced by symbols().

rz_bin_ne_new_buf()

rz_bin_ne_obj_t* rz_bin_ne_new_buf	(	RzBuffer *	buf,
		bool	verbose
	)

Definition at line 672 of file ne.c.

                                                                {
    rz_bin_ne_obj_t *bin = RZ_NEW0(rz_bin_ne_obj_t);
    if (!bin) {
        return NULL;
    }
    if (!rz_bin_ne_buf_init(buf, bin)) {
        rz_bin_ne_free(bin);
        return NULL;
    }
    return bin;
}

References NULL, rz_bin_ne_buf_init(), rz_bin_ne_free(), and RZ_NEW0.

Referenced by load_buffer().