le.c File Reference

#include "le.h"
#include <rz_bin.h>

Go to the source code of this file.

Functions
const char *	le_get_module_type (rz_bin_le_obj_t *bin)
const char *	le_get_os_type (rz_bin_le_obj_t *bin)
const char *	le_get_cpu_type (rz_bin_le_obj_t *bin)
const char *	le_get_arch (rz_bin_le_obj_t *bin)
static char *	le_read_nonnull_str_at (RzBuffer *buf, ut64 *offset)
static RzBinSymbol *	le_get_symbol (rz_bin_le_obj_t *bin, ut64 *offset)
RzList *	le_get_entries (rz_bin_le_obj_t *bin)
static void	le_get_symbols_at (rz_bin_le_obj_t *bin, RzList *syml, RzList *entl, ut64 offset, ut64 end)
RzList *	rz_bin_le_get_symbols (rz_bin_le_obj_t *bin)
RzList *	rz_bin_le_get_imports (rz_bin_le_obj_t *bin)
RzList *	rz_bin_le_get_entrypoints (rz_bin_le_obj_t *bin)
RzList *	rz_bin_le_get_libs (rz_bin_le_obj_t *bin)
static void	__create_iter_sections (RzList *l, rz_bin_le_obj_t *bin, RzBinSection *sec, LE_object_page_entry *page, ut64 vaddr, int cur_page)
RzList *	rz_bin_le_get_sections (rz_bin_le_obj_t *bin)
char *	le_get_modname_by_ord (rz_bin_le_obj_t *bin, ut32 ordinal)
RzList *	rz_bin_le_get_relocs (rz_bin_le_obj_t *bin)
static bool	read_le_header_aux (rz_bin_le_obj_t *bin, RzBuffer *buf)
static bool	le_init_header (rz_bin_le_obj_t *bin, RzBuffer *buf)
void	rz_bin_le_free (rz_bin_le_obj_t *bin)
rz_bin_le_obj_t *	rz_bin_le_new_buf (RzBuffer *buf)

Function Documentation

__create_iter_sections()

static void __create_iter_sections ( RzList *  l, rz_bin_le_obj_t *  bin, RzBinSection *  sec, LE_object_page_entry *  page, ut64  vaddr, int  cur_page  )

static

Definition at line 268 of file le.c.

                                                                                                                                             {
    rz_return_if_fail(l && bin && sec && page);
    LE_image_header *h = bin->header;
    ut32 offset = (h->itermap + (page->offset << (bin->is_le ? 0 : h->pageshift)));
 
    // Gets the first iter record
    ut16 iter_n;
    if (!rz_buf_read_ble16_at(bin->buf, offset, &iter_n, h->worder)) {
        return;
    }
 
    offset += sizeof(ut16);
    ut16 data_size;
    if (!rz_buf_read_ble16_at(bin->buf, offset, &data_size, h->worder)) {
        return;
    }
 
    offset += sizeof(ut16);
 
    ut64 tot_size = 0;
    int iter_cnt = 0;
    ut64 bytes_left = page->size;
    while (iter_n && bytes_left > 0) {
        int i;
        for (i = 0; i < iter_n; i++) {
            RzBinSection *s = RZ_NEW0(RzBinSection);
            if (!s) {
                break;
            }
            s->name = rz_str_newf("%s.page.%d.iter.%d", sec->name, cur_page, iter_cnt);
            s->bits = sec->bits;
            s->perm = sec->perm;
            s->size = data_size;
            s->vsize = data_size;
            s->paddr = offset;
            s->vaddr = vaddr;
            vaddr += data_size;
            tot_size += data_size;
            rz_list_append(l, s);
            iter_cnt++;
        }
        bytes_left -= sizeof(ut16) * 2 + data_size;
        // Get the next iter record
        offset += data_size;
 
        if (!rz_buf_read_ble16_at(bin->buf, offset, &iter_n, h->worder)) {
            return;
        }
        offset += sizeof(ut16);
 
        if (!rz_buf_read_ble16_at(bin->buf, offset, &data_size, h->worder)) {
            return;
        }
        offset += sizeof(ut16);
    }
    if (tot_size < h->pagesize) {
        RzBinSection *s = RZ_NEW0(RzBinSection);
        if (!s) {
            return;
        }
        s->name = rz_str_newf("%s.page.%d.iter.zerofill", sec->name, cur_page);
        s->bits = sec->bits;
        s->perm = sec->perm;
        s->vsize = h->pagesize - tot_size;
        s->vaddr = vaddr;
        rz_list_append(l, s);
    }
}

References rz_bin_section_t::bits, bin::buf, h, i, rz_bin_section_t::name, LE_object_page_entry_s::offset, rz_bin_section_t::perm, rz_list_append(), RZ_NEW0, rz_return_if_fail, rz_str_newf(), s, LE_object_page_entry_s::size, and ut64().

Referenced by rz_bin_le_get_sections().

le_get_arch()

const char* le_get_arch

(

rz_bin_le_obj_t *

bin

)

Definition at line 42 of file le.c.

                                              {
    switch (bin->header->cpu) {
    case 1:
    case 2:
    case 3:
        return "x86";
    case 0x20:
    case 0x21:
        return "i860";
    case 0x40:
    case 0x41:
    case 0x42:
        return "mips";
    default:
        return "Unknown";
    }
}

Referenced by rz_bin_le_new_buf().

le_get_cpu_type()

const char* le_get_cpu_type

(

rz_bin_le_obj_t *

bin

)

Definition at line 28 of file le.c.

                                                  {
    switch (bin->header->cpu) {
    case 1: return "80286";
    case 2: return "80386";
    case 3: return "80486";
    case 0x20: return "N10";
    case 0x21: return "N11";
    case 0x40: return "R3000";
    case 0x41: return "R6000";
    case 0x42: return "R4000";
    default: return "Unknown";
    }
}

Referenced by rz_bin_le_new_buf().

le_get_entries()

RzList* le_get_entries

(

rz_bin_le_obj_t *

bin

)

Definition at line 97 of file le.c.

                                             {
    ut64 offset = (ut64)bin->header->enttab + bin->headerOff;
    RzList *l = rz_list_newf(free);
    if (!l) {
        return NULL;
    }
    while (true) {
        LE_entry_bundle_header header;
        LE_entry_bundle_entry e;
        ut64 off = offset;
        if (!(rz_buf_read8_offset(bin->buf, &off, &header.count) &&
                rz_buf_read8_offset(bin->buf, &off, &header.type) &&
                rz_buf_read_le16_offset(bin->buf, &off, &header.objnum))) {
            break;
        }
        if (!header.count) {
            break;
        }
        if ((header.type & ~ENTRY_PARAMETER_TYPING_PRESENT) == UNUSED_ENTRY) {
            offset += sizeof(header.type) + sizeof(header.count);
            while (header.count) {
                rz_list_append(l, strdup("")); // (ut64 *)-1);
                header.count--;
            }
            continue;
        }
        offset += sizeof(LE_entry_bundle_header);
        bool typeinfo = header.type & ENTRY_PARAMETER_TYPING_PRESENT;
        int i;
        for (i = 0; i < header.count; i++) {
            ut64 entry = -1;
            rz_buf_read_at(bin->buf, offset, (ut8 *)&e, sizeof(e));
            switch (header.type & ~ENTRY_PARAMETER_TYPING_PRESENT) {
            case ENTRY16:
                if ((header.objnum - 1) < bin->header->objcnt) {
                    entry = (ut64)e.entry_16.offset + bin->objtbl[header.objnum - 1].reloc_base_addr;
                }
                offset += sizeof(e.entry_16);
                if (typeinfo) {
                    offset += (ut64)(e.entry_16.flags & ENTRY_PARAM_COUNT_MASK) * 2;
                }
                break;
            case CALLGATE:
                if ((header.objnum - 1) < bin->header->objcnt) {
                    entry = (ut64)e.callgate.offset + bin->objtbl[header.objnum - 1].reloc_base_addr;
                }
                offset += sizeof(e.callgate);
                if (typeinfo) {
                    offset += (ut64)(e.callgate.flags & ENTRY_PARAM_COUNT_MASK) * 2;
                }
                break;
            case ENTRY32:
                if ((header.objnum - 1) < bin->header->objcnt) {
                    entry = (ut64)e.entry_32.offset + bin->objtbl[header.objnum - 1].reloc_base_addr;
                }
                offset += sizeof(e.entry_32);
                if (typeinfo) {
                    offset += (ut64)(e.entry_32.flags & ENTRY_PARAM_COUNT_MASK) * 2;
                }
                break;
            case FORWARDER:
                offset += sizeof(e.forwarder);
                break;
            }
            if (entry != UT64_MAX) {
                rz_list_append(l, rz_str_newf("0x%" PFMT64x, entry));
            }
        }
    }
    return l;
}

References bin::buf, CALLGATE, e, ENTRY16, ENTRY32, ENTRY_PARAM_COUNT_MASK, ENTRY_PARAMETER_TYPING_PRESENT, FORWARDER, free(), header, i, NULL, off, PFMT64x, rz_buf_read8_offset, rz_buf_read_at(), rz_buf_read_le16_offset, rz_list_append(), rz_list_newf(), rz_str_newf(), strdup(), UNUSED_ENTRY, ut64(), and UT64_MAX.

Referenced by rz_bin_le_get_relocs(), and rz_bin_le_get_symbols().

le_get_modname_by_ord()

char* le_get_modname_by_ord	(	rz_bin_le_obj_t *	bin,
		ut32	ordinal
	)

Definition at line 442 of file le.c.

                                                                {
    char *modname = NULL;
    ut64 off = (ut64)bin->header->impmod + bin->headerOff;
    while (ordinal > 0) {
        free(modname);
        modname = le_read_nonnull_str_at(bin->buf, &off);
        ordinal--;
    }
    return modname;
}

References bin::buf, free(), le_read_nonnull_str_at(), NULL, off, ut64(), and while().

Referenced by rz_bin_le_get_relocs().

le_get_module_type()

const char* le_get_module_type

(

rz_bin_le_obj_t *

bin

)

Definition at line 7 of file le.c.

                                                     {
    switch (bin->header->mflags & M_TYPE_MASK) {
    case M_TYPE_EXE: return "Program module (EXE)";
    case M_TYPE_DLL: return "Library module (DLL)";
    case M_TYPE_PDD: return "Physical Device Driver";
    case M_TYPE_VDD: return "Virtual Device Driver";
    default: return "Unknown";
    }
}

References M_TYPE_DLL, M_TYPE_EXE, M_TYPE_MASK, M_TYPE_PDD, and M_TYPE_VDD.

Referenced by rz_bin_le_new_buf().

le_get_os_type()

const char* le_get_os_type

(

rz_bin_le_obj_t *

bin

)

Definition at line 17 of file le.c.

                                                 {
    switch (bin->header->os) {
    case 1: return "OS/2";
    case 2: return "Windows";
    case 3: return "DOS 4.x";
    case 4: return "Windows 386";
    case 5: return "IBM Microkernel Personality Neutral";
    default: return "Unknown";
    }
}

Referenced by rz_bin_le_new_buf().

le_get_symbol()

static RzBinSymbol* le_get_symbol ( rz_bin_le_obj_t *  bin, ut64 *  offset  )

static

Definition at line 77 of file le.c.

                                                                      {
    RzBinSymbol *sym = RZ_NEW0(RzBinSymbol);
    if (!sym) {
        return NULL;
    }
    char *name = le_read_nonnull_str_at(bin->buf, offset);
    if (!name) {
        rz_bin_symbol_free(sym);
        return NULL;
    }
    sym->name = name;
    ut16 entry_idx;
    if (!rz_buf_read_le16_offset(bin->buf, offset, &entry_idx)) {
        rz_bin_symbol_free(sym);
        return NULL;
    }
    sym->ordinal = entry_idx;
    return sym;
}

References bin::buf, le_read_nonnull_str_at(), name, rz_bin_symbol_t::name, NULL, rz_bin_symbol_t::ordinal, rz_bin_symbol_free(), rz_buf_read_le16_offset, and RZ_NEW0.

Referenced by le_get_symbols_at().

le_get_symbols_at()

static void le_get_symbols_at ( rz_bin_le_obj_t *  bin, RzList *  syml, RzList *  entl, ut64  offset, ut64  end  )

static

Definition at line 169 of file le.c.

                                                                                                       {
    while (offset < end) {
        RzBinSymbol *sym = le_get_symbol(bin, &offset);
        if (!sym) {
            break;
        }
        if (sym->ordinal) {
            const char *n = rz_list_get_n(entl, sym->ordinal - 1);
            if (n) {
                sym->vaddr = rz_num_get(NULL, n);
                sym->bind = RZ_BIN_BIND_GLOBAL_STR;
                sym->type = RZ_BIN_TYPE_FUNC_STR;
                rz_list_append(syml, sym);
            } else {
                rz_bin_symbol_free(sym);
            }
        } else {
            rz_bin_symbol_free(sym);
        }
    }
}

References rz_bin_symbol_t::bind, test_evm::end, le_get_symbol(), n, NULL, rz_bin_symbol_t::ordinal, RZ_BIN_BIND_GLOBAL_STR, rz_bin_symbol_free(), RZ_BIN_TYPE_FUNC_STR, rz_list_append(), rz_list_get_n(), rz_num_get(), rz_bin_symbol_t::type, and rz_bin_symbol_t::vaddr.

Referenced by rz_bin_le_get_symbols().

le_init_header()

static bool le_init_header ( rz_bin_le_obj_t *  bin, RzBuffer *  buf  )

static

Definition at line 775 of file le.c.

                                                                {
    ut8 magic[2];
    rz_buf_read_at(buf, 0, magic, sizeof(magic));
    if (!memcmp(&magic, "MZ", 2)) {
        ut16 tmp;
        if (!rz_buf_read_le16_at(buf, 0x3c, &tmp)) {
            return false;
        }
        bin->headerOff = tmp;
    } else {
        bin->headerOff = 0;
    }
    bin->header = RZ_NEW0(LE_image_header);
    if (!bin->header) {
        RZ_LOG_ERROR("Failed to allocate memory");
        return false;
    }
    return read_le_header_aux(bin, buf);
}

References read_le_header_aux(), rz_buf_read_at(), rz_buf_read_le16_at, RZ_LOG_ERROR, RZ_NEW0, and autogen_x86imm::tmp.

Referenced by rz_bin_le_new_buf().

le_read_nonnull_str_at()

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

static

Definition at line 60 of file le.c.

                                                                 {
    ut8 size;
    if (!rz_buf_read8_at(buf, *offset, &size)) {
        return NULL;
    }
 
    size &= 0x7F; // Max is 127
    if (!size) {
        return NULL;
    }
    (*offset)++;
    char *str = calloc((ut64)size + 1, sizeof(char));
    rz_buf_read_at(buf, *offset, (ut8 *)str, size);
    *offset += size;
    return str;
}

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

Referenced by le_get_modname_by_ord(), le_get_symbol(), rz_bin_le_get_imports(), rz_bin_le_get_libs(), rz_bin_le_get_relocs(), and rz_bin_le_new_buf().

read_le_header_aux()

static bool read_le_header_aux ( rz_bin_le_obj_t *  bin, RzBuffer *  buf  )

static

Definition at line 724 of file le.c.

                                                                    {
    if (!rz_buf_read_at(buf, bin->headerOff, (ut8 *)bin->header, 4)) {
        return false;
    }
    ut64 offset = bin->headerOff + 4; /* skip magic, border, and worder */
    return rz_buf_read_le32_offset(buf, &offset, &bin->header->level) &&
        rz_buf_read_le16_offset(buf, &offset, &bin->header->cpu) &&
        rz_buf_read_le16_offset(buf, &offset, &bin->header->os) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->ver) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->mflags) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->mpages) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->startobj) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->eip) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->stackobj) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->esp) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->pagesize) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->pageshift) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->fixupsize) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->fixupsum) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->ldrsize) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->ldrsum) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->objtab) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->objcnt) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->objmap) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->itermap) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->rsrctab) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->rsrccnt) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->restab) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->enttab) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->dirtab) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->dircnt) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->fpagetab) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->frectab) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->impmod) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->impmodcnt) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->impproc) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->pagesum) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->datapage) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->preload) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->nrestab) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->cbnrestab) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->nressum) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->autodata) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->debuginfo) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->debuglen) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->instpreload) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->instdemand) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->heapsize) &&
        rz_buf_read_le32_offset(buf, &offset, &bin->header->stacksize);
}

References rz_buf_read_at(), rz_buf_read_le16_offset, rz_buf_read_le32_offset, and ut64().

Referenced by le_init_header().

rz_bin_le_free()

void rz_bin_le_free

(

rz_bin_le_obj_t *

bin

)

Definition at line 795 of file le.c.

                                          {
    rz_return_if_fail(bin);
    free(bin->header);
    free(bin->objtbl);
    free(bin->filename);
    free(bin);
}

References free(), and rz_return_if_fail.

Referenced by destroy(), and rz_bin_le_new_buf().

rz_bin_le_get_entrypoints()

RzList* rz_bin_le_get_entrypoints

(

rz_bin_le_obj_t *

bin

)

Definition at line 229 of file le.c.

                                                        {
    RzList *l = rz_list_newf((RzListFree)free);
    if (!l) {
        return NULL;
    }
    RzBinAddr *entry = RZ_NEW0(RzBinAddr);
    if (entry) {
        if ((bin->header->startobj - 1) < bin->header->objcnt) {
            entry->vaddr = (ut64)bin->objtbl[bin->header->startobj - 1].reloc_base_addr + bin->header->eip;
        }
    }
    rz_list_append(l, entry);
 
    return l;
}

References free(), NULL, rz_list_append(), rz_list_newf(), RZ_NEW0, and ut64().

Referenced by entries().

rz_bin_le_get_imports()

RzList* rz_bin_le_get_imports

(

rz_bin_le_obj_t *

bin

)

Definition at line 205 of file le.c.

                                                    {
    RzList *l = rz_list_newf((RzListFree)rz_bin_import_free);
    if (!l) {
        return NULL;
    }
    LE_image_header *h = bin->header;
    ut64 offset = (ut64)h->impproc + bin->headerOff + 1; // First entry is a null string
    ut64 end = (ut64)h->fixupsize + h->fpagetab + bin->headerOff;
    while (offset < end) {
        RzBinImport *imp = RZ_NEW0(RzBinImport);
        if (!imp) {
            break;
        }
        imp->name = le_read_nonnull_str_at(bin->buf, &offset);
        if (!imp->name) {
            rz_bin_import_free(imp);
            break;
        }
        imp->type = RZ_BIN_TYPE_FUNC_STR;
        rz_list_append(l, imp);
    }
    return l;
}

References bin::buf, test_evm::end, h, le_read_nonnull_str_at(), rz_bin_import_t::name, NULL, rz_bin_import_free(), RZ_BIN_TYPE_FUNC_STR, rz_list_append(), rz_list_newf(), RZ_NEW0, rz_bin_import_t::type, and ut64().

Referenced by imports().

rz_bin_le_get_libs()

RzList* rz_bin_le_get_libs

(

rz_bin_le_obj_t *

bin

)

Definition at line 245 of file le.c.

                                                 {
    RzList *l = rz_list_newf((RzListFree)free);
    if (!l) {
        return NULL;
    }
    LE_image_header *h = bin->header;
    ut64 offset = (ut64)h->impmod + bin->headerOff;
    ut64 end = offset + h->impproc - h->impmod;
    while (offset < end) {
        char *name = le_read_nonnull_str_at(bin->buf, &offset);
        if (!name) {
            break;
        }
        rz_list_append(l, name);
    }
    return l;
}

References bin::buf, test_evm::end, free(), h, le_read_nonnull_str_at(), NULL, rz_list_append(), rz_list_newf(), ut64(), and while().

Referenced by libs().

rz_bin_le_get_relocs()

RzList* rz_bin_le_get_relocs

(

rz_bin_le_obj_t *

bin

)

Definition at line 453 of file le.c.

                                                   {
    RzList *l = rz_list_newf((RzListFree)free);
    if (!l) {
        return NULL;
    }
    RzList *entries = le_get_entries(bin);
    RzList *sections = rz_bin_le_get_sections(bin);
    LE_image_header *h = bin->header;
    ut64 cur_page = 0;
    const ut64 fix_rec_tbl_off = (ut64)h->frectab + bin->headerOff;
    ut32 tmp_offset;
    if (!rz_buf_read_ble32_at(bin->buf, (ut64)h->fpagetab + bin->headerOff + cur_page * sizeof(ut32), &tmp_offset, h->worder)) {
        rz_list_free(l);
        rz_list_free(entries);
        rz_list_free(sections);
        return NULL;
    }
 
    ut64 offset = tmp_offset + fix_rec_tbl_off;
 
    ut32 tmp_end;
    if (!rz_buf_read_ble32_at(bin->buf, (ut64)h->fpagetab + bin->headerOff + (cur_page + 1) * sizeof(ut32), &tmp_end, h->worder)) {
        rz_list_free(l);
        rz_list_free(entries);
        rz_list_free(sections);
        return NULL;
    }
    ut64 end = tmp_end + fix_rec_tbl_off;
 
    const RzBinSection *cur_section = (RzBinSection *)rz_list_get_n(sections, cur_page);
    ut64 cur_page_offset = cur_section ? cur_section->vaddr : 0;
    while (cur_page < h->mpages) {
        RzBinReloc *rel = RZ_NEW0(RzBinReloc);
        bool rel_appended = false; // whether rel has been appended to l and must not be freed
        if (!rel) {
            break;
        }
        LE_fixup_record_header header;
        int ret = rz_buf_read_at(bin->buf, offset, (ut8 *)&header, sizeof(header));
        if (ret != sizeof(header)) {
            RZ_LOG_WARN("Cannot read out of bounds relocation.\n");
            free(rel);
            break;
        }
        offset += sizeof(header);
        switch (header.source & F_SOURCE_TYPE_MASK) {
        case BYTEFIXUP:
            rel->type = RZ_BIN_RELOC_8;
            break;
        case SELECTOR16:
        case OFFSET16:
            rel->type = RZ_BIN_RELOC_16;
            break;
        case OFFSET32:
        case POINTER32:
        case SELFOFFSET32:
            rel->type = RZ_BIN_RELOC_32;
            break;
        case POINTER48:
            rel->type = 48;
            break;
        }
        ut8 repeat = 0;
        ut16 source = 0;
        if (header.source & F_SOURCE_LIST) {
            if (!rz_buf_read8_at(bin->buf, offset, &repeat)) {
                rz_bin_reloc_free(rel);
                break;
            }
            offset += sizeof(ut8);
        } else {
            if (!rz_buf_read_ble16_at(bin->buf, offset, &source, h->worder)) {
                rz_bin_reloc_free(rel);
                break;
            }
            offset += sizeof(ut16);
        }
        ut32 ordinal;
        if (header.target & F_TARGET_ORD16) {
            ut16 tmp;
            if (!rz_buf_read_ble16_at(bin->buf, offset, &tmp, h->worder)) {
                rz_bin_reloc_free(rel);
                break;
            }
            ordinal = tmp;
            offset += sizeof(ut16);
        } else {
            ut8 tmp;
            if (!rz_buf_read8_at(bin->buf, offset, &tmp)) {
                rz_bin_reloc_free(rel);
                break;
            }
            ordinal = tmp;
            offset += sizeof(ut8);
        }
        switch (header.target & F_TARGET_TYPE_MASK) {
        case INTERNAL:
            if ((ordinal - 1) < bin->header->objcnt) {
                rel->addend = bin->objtbl[ordinal - 1].reloc_base_addr;
                if ((header.source & F_SOURCE_TYPE_MASK) != SELECTOR16) {
                    if (header.target & F_TARGET_OFF32) {
                        ut32 tmp;
                        if (!rz_buf_read_ble32_offset(bin->buf, &offset, &tmp, h->worder)) {
                            rz_bin_reloc_free(rel);
                            continue;
                        }
                        rel->addend += tmp;
                    } else {
                        ut16 tmp;
                        if (!rz_buf_read_ble16_offset(bin->buf, &offset, &tmp, h->worder)) {
                            rz_bin_reloc_free(rel);
                            continue;
                        }
                        rel->addend += tmp;
                    }
                }
            }
            break;
        case IMPORTORD: {
            RzBinImport *imp = RZ_NEW0(RzBinImport);
            if (!imp) {
                break;
            }
            char *mod_name = le_get_modname_by_ord(bin, ordinal);
            if (!mod_name) {
                rz_bin_import_free(imp);
                break;
            }
 
            if (header.target & F_TARGET_ORD8) {
                ut8 tmp;
                if (!rz_buf_read8_at(bin->buf, offset, &tmp)) {
                    rz_bin_import_free(imp);
                    break;
                }
                ordinal = tmp;
                offset += sizeof(ut8);
            } else if (header.target & F_TARGET_OFF32) {
                if (!rz_buf_read_ble32_offset(bin->buf, &offset, &ordinal, h->worder)) {
                    rz_bin_import_free(imp);
                    break;
                }
            } else {
                ut16 tmp;
                if (!rz_buf_read_ble16_offset(bin->buf, &offset, &tmp, h->worder)) {
                    rz_bin_import_free(imp);
                    break;
                }
                ordinal = tmp;
            }
            imp->name = rz_str_newf("%s.%u", mod_name, ordinal);
            imp->ordinal = ordinal;
            rel->import = imp;
            free(mod_name);
            break;
        }
        case IMPORTNAME: {
            RzBinImport *imp = RZ_NEW0(RzBinImport);
            if (!imp) {
                break;
            }
            ut32 nameoff;
            if (header.target & F_TARGET_OFF32) {
                if (!rz_buf_read_ble32_offset(bin->buf, &offset, &nameoff, h->worder)) {
                    rz_bin_import_free(imp);
                    break;
                }
            } else {
                ut16 tmp;
                if (!rz_buf_read_ble16_offset(bin->buf, &offset, &tmp, h->worder)) {
                    rz_bin_import_free(imp);
                    break;
                }
                nameoff = tmp;
            }
            ut64 off = (ut64)h->impproc + nameoff + bin->headerOff;
            char *proc_name = le_read_nonnull_str_at(bin->buf, &off);
            char *mod_name = le_get_modname_by_ord(bin, ordinal);
            imp->name = rz_str_newf("%s.%s", mod_name ? mod_name : "", proc_name ? proc_name : "");
            rel->import = imp;
            break;
        }
        case INTERNALENTRY:
            rel->addend = (ut64)(size_t)rz_list_get_n(entries, ordinal - 1);
            break;
        }
        if (header.target & F_TARGET_ADDITIVE) {
            ut32 additive = 0;
            if (header.target & F_TARGET_ADD32) {
                if (!rz_buf_read_ble32_offset(bin->buf, &offset, &additive, h->worder)) {
                    rz_bin_reloc_free(rel);
                    break;
                }
            } else {
                ut16 tmp;
                if (!rz_buf_read_ble16_offset(bin->buf, &offset, &tmp, h->worder)) {
                    rz_bin_reloc_free(rel);
                    break;
                }
                additive = tmp;
            }
            rel->addend += additive;
        }
        if (!repeat) {
            rel->vaddr = cur_page_offset + source;
            rel->paddr = cur_section ? cur_section->paddr + source : 0;
            rz_list_append(l, rel);
            rel_appended = true;
        }
 
        if (header.target & F_TARGET_CHAIN) {
            ut32 fixupinfo;
            if (!rz_buf_read_ble32_at(bin->buf, cur_page_offset + source, &fixupinfo, h->worder)) {
                break;
            }
 
            ut64 base_target_address = rel->addend - (fixupinfo & 0xFFFFF);
            do {
                if (!rz_buf_read_ble32_at(bin->buf, cur_page_offset + source, &fixupinfo, h->worder)) {
                    break;
                }
                RzBinReloc *new = RZ_NEW0(RzBinReloc);
                *new = *rel;
                new->addend = base_target_address + (fixupinfo & 0xFFFFF);
                rz_list_append(l, new);
                source = (fixupinfo >> 20) & 0xFFF;
            } while (source != 0xFFF);
        }
 
        while (repeat) {
            ut16 off;
            if (!rz_buf_read_ble16_offset(bin->buf, &offset, &off, h->worder)) {
                break;
            }
            rel->vaddr = cur_page_offset + off;
            rel->paddr = cur_section ? cur_section->paddr + off : 0;
            RzBinReloc *new = RZ_NEW0(RzBinReloc);
            *new = *rel;
            rz_list_append(l, new);
            repeat--;
        }
        while (offset >= end) {
            cur_page++;
            if (cur_page >= h->mpages) {
                break;
            }
            ut64 at = h->fpagetab + bin->headerOff;
            ut32 w0;
            if (!rz_buf_read_ble32_at(bin->buf, at + cur_page * sizeof(ut32), &w0, h->worder)) {
                break;
            }
            ut32 w1;
            if (!rz_buf_read_ble32_at(bin->buf, at + (cur_page + 1) * sizeof(ut32), &w1, h->worder)) {
                break;
            }
            offset = fix_rec_tbl_off + w0;
            end = fix_rec_tbl_off + w1;
            if (offset < end) {
                cur_section = (RzBinSection *)rz_list_get_n(sections, cur_page);
                cur_page_offset = cur_section ? cur_section->vaddr : 0;
            }
        }
        if (!rel_appended) {
            rz_bin_reloc_free(rel);
        }
    }
    rz_list_free(entries);
    rz_list_free(sections);
    return l;
}

References rz_bin_reloc_t::addend, bin::buf, BYTEFIXUP, test_evm::end, entries(), F_SOURCE_LIST, F_SOURCE_TYPE_MASK, F_TARGET_ADD32, F_TARGET_ADDITIVE, F_TARGET_CHAIN, F_TARGET_OFF32, F_TARGET_ORD16, F_TARGET_ORD8, F_TARGET_TYPE_MASK, free(), h, header, if(), rz_bin_reloc_t::import, IMPORTNAME, IMPORTORD, INTERNAL, INTERNALENTRY, le_get_entries(), le_get_modname_by_ord(), le_read_nonnull_str_at(), rz_bin_import_t::name, NULL, off, OFFSET16, OFFSET32, rz_bin_import_t::ordinal, rz_bin_section_t::paddr, rz_bin_reloc_t::paddr, POINTER32, POINTER48, repeat(), rz_bin_import_free(), rz_bin_le_get_sections(), RZ_BIN_RELOC_16, RZ_BIN_RELOC_32, RZ_BIN_RELOC_8, rz_bin_reloc_free(), rz_buf_read8_at(), rz_buf_read_at(), rz_list_append(), rz_list_free(), rz_list_get_n(), rz_list_newf(), RZ_LOG_WARN, RZ_NEW0, rz_str_newf(), sections(), SELECTOR16, SELFOFFSET32, source, autogen_x86imm::tmp, rz_bin_reloc_t::type, ut64(), ut8, rz_bin_section_t::vaddr, rz_bin_reloc_t::vaddr, w0, and w1.

Referenced by relocs().

rz_bin_le_get_sections()

RzList* rz_bin_le_get_sections

(

rz_bin_le_obj_t *

bin

)

Definition at line 338 of file le.c.

                                                     {
    RzList *l = rz_list_newf((RzListFree)rz_bin_section_free);
    if (!l) {
        return NULL;
    }
    LE_image_header *h = bin->header;
    ut32 pages_start_off = h->datapage;
    int i;
    for (i = 0; i < h->objcnt; i++) {
        RzBinSection *sec = RZ_NEW0(RzBinSection);
        if (!sec) {
            return l;
        }
        LE_object_entry *entry = &bin->objtbl[i];
        sec->name = rz_str_newf("obj.%d", i + 1);
        sec->vsize = entry->virtual_size;
        sec->vaddr = entry->reloc_base_addr;
        if (entry->flags & O_READABLE) {
            sec->perm |= RZ_PERM_R;
        }
        if (entry->flags & O_WRITABLE) {
            sec->perm |= RZ_PERM_W;
        }
        if (entry->flags & O_EXECUTABLE) {
            sec->perm |= RZ_PERM_X;
        }
        if (entry->flags & O_BIG_BIT) {
            sec->bits = RZ_SYS_BITS_32;
        } else {
            sec->bits = RZ_SYS_BITS_16;
        }
        sec->is_data = entry->flags & O_RESOURCE || !(sec->perm & RZ_PERM_X);
        if (!entry->page_tbl_entries) {
            rz_list_append(l, sec);
        }
        int j;
        ut32 page_size_sum = 0;
        ut32 next_idx = i < h->objcnt - 1 ? bin->objtbl[i + 1].page_tbl_idx - 1 : UT32_MAX;
        ut32 objmaptbloff = h->objmap + bin->headerOff;
        ut64 objpageentrysz = bin->is_le ? sizeof(ut32) : sizeof(LE_object_page_entry);
        for (j = 0; j < entry->page_tbl_entries; j++) {
            LE_object_page_entry page;
            RzBinSection *s = RZ_NEW0(RzBinSection);
            if (!s) {
                rz_bin_section_free(sec);
                return l;
            }
            s->name = rz_str_newf("%s.page.%d", sec->name, j);
            s->is_data = sec->is_data;
 
            int cur_idx = entry->page_tbl_idx + j - 1;
            ut64 page_entry_off = objpageentrysz * cur_idx + objmaptbloff;
            ut64 offset = page_entry_off;
            if (!(rz_buf_read_le32_offset(bin->buf, &offset, &page.offset) &&
                    rz_buf_read_le16_offset(bin->buf, &offset, &page.size) &&
                    rz_buf_read_le16_offset(bin->buf, &offset, &page.flags))) {
                RZ_LOG_WARN("Cannot read out of bounds page table entry.\n");
                rz_bin_section_free(s);
                break;
            }
            if (cur_idx < next_idx) { // If not true rest of pages will be zeroes
                if (bin->is_le) {
                    // Why is it big endian???
                    ut32 tmp_offset;
                    if (!rz_buf_read_be32_at(bin->buf, page_entry_off, &tmp_offset)) {
                        rz_bin_section_free(s);
                        break;
                    }
 
                    ut64 offset = tmp_offset >> 8;
                    s->paddr = (offset - 1) * h->pagesize + pages_start_off;
                    if (entry->page_tbl_idx + j == h->mpages) {
                        page.size = h->pageshift;
                    } else {
                        page.size = h->pagesize;
                    }
                } else if (page.flags == P_ITERATED) {
                    ut64 vaddr = sec->vaddr + page_size_sum;
                    __create_iter_sections(l, bin, sec, &page, vaddr, j);
                    rz_bin_section_free(s);
                    page_size_sum += h->pagesize;
                    continue;
                } else if (page.flags == P_COMPRESSED) {
                    // TODO
                    RZ_LOG_WARN("Compressed page not handled: %s", s->name);
                } else if (page.flags != P_ZEROED) {
                    s->paddr = ((ut64)page.offset << h->pageshift) + pages_start_off;
                }
            }
            s->vsize = h->pagesize;
            s->vaddr = sec->vaddr + page_size_sum;
            s->perm = sec->perm;
            s->size = page.size;
            s->bits = sec->bits;
            rz_list_append(l, s);
            page_size_sum += s->vsize;
        }
        if (entry->page_tbl_entries) {
            rz_bin_section_free(sec);
        }
    }
    return l;
}

References __create_iter_sections(), rz_bin_section_t::bits, bin::buf, LE_object_page_entry_s::flags, h, i, if(), rz_bin_section_t::is_data, rz_bin_section_t::name, next_idx(), NULL, O_BIG_BIT, O_EXECUTABLE, O_READABLE, O_RESOURCE, O_WRITABLE, LE_object_page_entry_s::offset, P_COMPRESSED, P_ITERATED, P_ZEROED, rz_bin_section_t::perm, rz_bin_section_free(), rz_buf_read_be32_at, rz_buf_read_le16_offset, rz_buf_read_le32_offset, rz_list_append(), rz_list_newf(), RZ_LOG_WARN, RZ_NEW0, RZ_PERM_R, RZ_PERM_W, RZ_PERM_X, rz_str_newf(), RZ_SYS_BITS_16, RZ_SYS_BITS_32, s, LE_object_page_entry_s::size, UT32_MAX, ut64(), rz_bin_section_t::vaddr, and rz_bin_section_t::vsize.

Referenced by rz_bin_le_get_relocs(), and sections().

rz_bin_le_get_symbols()

RzList* rz_bin_le_get_symbols

(

rz_bin_le_obj_t *

bin

)

Definition at line 191 of file le.c.

                                                    {
    RzList *l = rz_list_newf((RzListFree)rz_bin_symbol_free);
    RzList *entries = le_get_entries(bin);
    LE_image_header *h = bin->header;
    ut64 offset = (ut64)h->restab + bin->headerOff;
    ut32 end = h->enttab + bin->headerOff;
    le_get_symbols_at(bin, l, entries, offset, end);
    offset = h->nrestab;
    end = h->nrestab + h->cbnrestab;
    le_get_symbols_at(bin, l, entries, offset, end);
    rz_list_free(entries);
    return l;
}

References test_evm::end, entries(), h, le_get_entries(), le_get_symbols_at(), rz_bin_symbol_free(), rz_list_free(), rz_list_newf(), and ut64().

Referenced by symbols().

rz_bin_le_new_buf()

rz_bin_le_obj_t* rz_bin_le_new_buf

(

RzBuffer *

buf

)

Definition at line 803 of file le.c.

                                                  {
    rz_bin_le_obj_t *bin = RZ_NEW0(rz_bin_le_obj_t);
    if (!bin) {
        return NULL;
    }
 
    le_init_header(bin, buf);
    LE_image_header *h = bin->header;
    if (!memcmp("LE", h->magic, 2)) {
        bin->is_le = true;
    }
    bin->type = le_get_module_type(bin);
    bin->cpu = le_get_cpu_type(bin);
    bin->os = le_get_os_type(bin);
    bin->arch = le_get_arch(bin);
    bin->objtbl = calloc(h->objcnt, sizeof(LE_object_entry));
    if (!bin->objtbl) {
        rz_bin_le_free(bin);
        return NULL;
    }
    ut64 offset = (ut64)bin->headerOff + h->restab;
    bin->filename = le_read_nonnull_str_at(buf, &offset);
    offset = (ut64)bin->headerOff + h->objtab;
    for (ut32 i = 0; i < h->objcnt; i++) {
        LE_object_entry *le_obj_entry = bin->objtbl + i;
        rz_buf_read_le32_offset(buf, &offset, &le_obj_entry->virtual_size);
        rz_buf_read_le32_offset(buf, &offset, &le_obj_entry->reloc_base_addr);
        rz_buf_read_le32_offset(buf, &offset, &le_obj_entry->flags);
        rz_buf_read_le32_offset(buf, &offset, &le_obj_entry->page_tbl_idx);
        rz_buf_read_le32_offset(buf, &offset, &le_obj_entry->page_tbl_entries);
        rz_buf_read_le32_offset(buf, &offset, &le_obj_entry->reserved);
    }
    bin->buf = buf;
    return bin;
}

References bin::buf, calloc(), LE_object_entry_s::flags, h, i, le_get_arch(), le_get_cpu_type(), le_get_module_type(), le_get_os_type(), le_init_header(), le_read_nonnull_str_at(), NULL, LE_object_entry_s::page_tbl_entries, LE_object_entry_s::page_tbl_idx, LE_object_entry_s::reloc_base_addr, LE_object_entry_s::reserved, rz_bin_le_free(), rz_buf_read_le32_offset, RZ_NEW0, ut64(), and LE_object_entry_s::virtual_size.

Referenced by load_buffer().