coff.c File Reference

#include <rz_util.h>
#include "coff.h"

Go to the source code of this file.

Functions
RZ_API bool	rz_coff_supported_arch (const ut8 *buf)
RZ_API ut64	rz_coff_perms_from_section_flags (ut32 flags)
RZ_API char *	rz_coff_symbol_name (struct rz_bin_coff_obj *obj, void *ptr)
static int	rz_coff_rebase_sym (struct rz_bin_coff_obj *obj, RzBinAddr *addr, struct coff_symbol *sym)
RZ_API RzBinAddr *	rz_coff_get_entry (struct rz_bin_coff_obj *obj)
static bool	rz_bin_coff_init_hdr (struct rz_bin_coff_obj *obj)
static bool	rz_bin_coff_init_opt_hdr (struct rz_bin_coff_obj *obj)
static bool	rz_bin_coff_init_scn_hdr (struct rz_bin_coff_obj *obj)
static bool	rz_bin_coff_init_symtable (struct rz_bin_coff_obj *obj)
static bool	rz_bin_coff_init_scn_va (struct rz_bin_coff_obj *obj)
static int	rz_bin_coff_init (struct rz_bin_coff_obj *obj, RzBuffer *buf, bool verbose)
RZ_API void	rz_bin_coff_free (struct rz_bin_coff_obj *obj)
RZ_API struct rz_bin_coff_obj *	rz_bin_coff_new_buf (RzBuffer *buf, bool verbose)

Function Documentation

rz_bin_coff_free()

RZ_API void rz_bin_coff_free

(

struct rz_bin_coff_obj *

obj

)

Definition at line 266 of file coff.c.

                                                          {
    ht_up_free(obj->sym_ht);
    ht_up_free(obj->imp_ht);
    ht_uu_free(obj->imp_index);
    free(obj->scn_va);
    free(obj->scn_hdrs);
    free(obj->symbols);
    rz_buf_free(obj->buf_patched);
    rz_buf_free(obj->b);
    free(obj);
}

References rz_bin_coff_obj::b, rz_bin_coff_obj::buf_patched, free(), rz_bin_coff_obj::imp_ht, rz_bin_coff_obj::imp_index, rz_buf_free(), rz_bin_coff_obj::scn_hdrs, rz_bin_coff_obj::scn_va, rz_bin_coff_obj::sym_ht, and rz_bin_coff_obj::symbols.

Referenced by destroy().

rz_bin_coff_init()

static int rz_bin_coff_init ( struct rz_bin_coff_obj *  obj, RzBuffer *  buf, bool  verbose  )

static

Definition at line 239 of file coff.c.

                                                                                      {
    obj->b = rz_buf_ref(buf);
    obj->size = rz_buf_size(buf);
    obj->verbose = verbose;
    obj->sym_ht = ht_up_new0();
    obj->imp_ht = ht_up_new0();
    obj->imp_index = ht_uu_new0();
    if (!rz_bin_coff_init_hdr(obj)) {
        RZ_LOG_ERROR("failed to init hdr\n");
        return false;
    }
    rz_bin_coff_init_opt_hdr(obj);
    if (!rz_bin_coff_init_scn_hdr(obj)) {
        RZ_LOG_ERROR("failed to init section header\n");
        return false;
    }
    if (!rz_bin_coff_init_scn_va(obj)) {
        RZ_LOG_ERROR("failed to init section VA table\n");
        return false;
    }
    if (!rz_bin_coff_init_symtable(obj)) {
        RZ_LOG_ERROR("failed to init symtable\n");
        return false;
    }
    return true;
}

References rz_bin_coff_obj::b, rz_bin_coff_obj::imp_ht, rz_bin_coff_obj::imp_index, rz_bin_coff_init_hdr(), rz_bin_coff_init_opt_hdr(), rz_bin_coff_init_scn_hdr(), rz_bin_coff_init_scn_va(), rz_bin_coff_init_symtable(), rz_buf_ref(), rz_buf_size(), RZ_LOG_ERROR, rz_bin_coff_obj::size, rz_bin_coff_obj::sym_ht, verbose, and rz_bin_coff_obj::verbose.

Referenced by rz_bin_coff_new_buf().

rz_bin_coff_init_hdr()

static bool rz_bin_coff_init_hdr ( struct rz_bin_coff_obj *  obj )

static

Definition at line 136 of file coff.c.

                                                              {
    ut16 magic;
    if (!rz_buf_read_le16_at(obj->b, 0, &magic)) {
        return false;
    }
 
    switch (magic) {
    case COFF_FILE_MACHINE_H8300:
    case COFF_FILE_MACHINE_AMD29KBE:
        obj->endian = COFF_IS_BIG_ENDIAN;
        break;
    default:
        obj->endian = COFF_IS_LITTLE_ENDIAN;
    }
    int ret = 0;
    ret = rz_buf_fread_at(obj->b, 0, (ut8 *)&obj->hdr, obj->endian ? "2S3I2S" : "2s3i2s", 1);
    if (ret != sizeof(struct coff_hdr)) {
        return false;
    }
    if (obj->hdr.f_magic == COFF_FILE_TI_COFF) {
        ret = rz_buf_fread(obj->b, (ut8 *)&obj->target_id, obj->endian ? "S" : "s", 1);
        if (ret != sizeof(ut16)) {
            return false;
        }
    }
    return true;
}

References rz_bin_coff_obj::b, COFF_FILE_MACHINE_AMD29KBE, COFF_FILE_MACHINE_H8300, COFF_FILE_TI_COFF, COFF_IS_BIG_ENDIAN, COFF_IS_LITTLE_ENDIAN, rz_bin_coff_obj::endian, rz_bin_coff_obj::hdr, rz_buf_fread(), rz_buf_fread_at(), rz_buf_read_le16_at, and rz_bin_coff_obj::target_id.

Referenced by rz_bin_coff_init().

rz_bin_coff_init_opt_hdr()

static bool rz_bin_coff_init_opt_hdr ( struct rz_bin_coff_obj *  obj )

static

Definition at line 164 of file coff.c.

                                                                  {
    int ret;
    if (!obj->hdr.f_opthdr) {
        return false;
    }
    ret = rz_buf_fread_at(obj->b, sizeof(struct coff_hdr),
        (ut8 *)&obj->opt_hdr, obj->endian ? "2S6I" : "2s6i", 1);
    if (ret != sizeof(struct coff_opt_hdr)) {
        return false;
    }
    return true;
}

References rz_bin_coff_obj::b, rz_bin_coff_obj::endian, rz_bin_coff_obj::hdr, rz_bin_coff_obj::opt_hdr, and rz_buf_fread_at().

Referenced by rz_bin_coff_init().

rz_bin_coff_init_scn_hdr()

static bool rz_bin_coff_init_scn_hdr ( struct rz_bin_coff_obj *  obj )

static

Definition at line 177 of file coff.c.

                                                                  {
    int ret, size;
    ut64 offset = sizeof(struct coff_hdr) + (obj->hdr.f_opthdr ? sizeof(struct coff_opt_hdr) : 0);
    if (obj->hdr.f_magic == COFF_FILE_TI_COFF) {
        offset += 2;
    }
    size = obj->hdr.f_nscns * sizeof(struct coff_scn_hdr);
    if (offset > obj->size || offset + size > obj->size || size < 0) {
        return false;
    }
    obj->scn_hdrs = calloc(1, size + sizeof(struct coff_scn_hdr));
    if (!obj->scn_hdrs) {
        return false;
    }
    ret = rz_buf_fread_at(obj->b, offset, (ut8 *)obj->scn_hdrs, obj->endian ? "8c6I2S1I" : "8c6i2s1i", obj->hdr.f_nscns);
    if (ret != size) {
        RZ_FREE(obj->scn_hdrs);
        return false;
    }
    return true;
}

References rz_bin_coff_obj::b, calloc(), COFF_FILE_TI_COFF, rz_bin_coff_obj::endian, rz_bin_coff_obj::hdr, if(), rz_buf_fread_at(), RZ_FREE, rz_bin_coff_obj::scn_hdrs, rz_bin_coff_obj::size, and ut64().

Referenced by rz_bin_coff_init().

rz_bin_coff_init_scn_va()

static bool rz_bin_coff_init_scn_va ( struct rz_bin_coff_obj *  obj )

static

Definition at line 224 of file coff.c.

                                                                 {
    obj->scn_va = RZ_NEWS(ut64, obj->hdr.f_nscns);
    if (!obj->scn_va) {
        return false;
    }
    int i;
    ut64 va = 0;
    for (i = 0; i < obj->hdr.f_nscns; i++) {
        obj->scn_va[i] = va;
        va += obj->scn_hdrs[i].s_size ? obj->scn_hdrs[i].s_size : 16;
        va = RZ_ROUND(va, 16ULL);
    }
    return true;
}

References rz_bin_coff_obj::hdr, i, RZ_NEWS, RZ_ROUND, rz_bin_coff_obj::scn_hdrs, rz_bin_coff_obj::scn_va, and ut64().

Referenced by rz_bin_coff_init().

rz_bin_coff_init_symtable()

static bool rz_bin_coff_init_symtable ( struct rz_bin_coff_obj *  obj )

static

Definition at line 199 of file coff.c.

                                                                   {
    int ret, size;
    ut64 offset = obj->hdr.f_symptr;
    if (obj->hdr.f_nsyms >= 0xffff || !obj->hdr.f_nsyms) { // too much symbols, probably not allocatable
        return false;
    }
    size = obj->hdr.f_nsyms * sizeof(struct coff_symbol);
    if (size < 0 ||
        size > obj->size ||
        offset > obj->size ||
        offset + size > obj->size) {
        return false;
    }
    obj->symbols = calloc(1, size + sizeof(struct coff_symbol));
    if (!obj->symbols) {
        return false;
    }
    ret = rz_buf_fread_at(obj->b, offset, (ut8 *)obj->symbols, obj->endian ? "8c1I2S2c" : "8c1i2s2c", obj->hdr.f_nsyms);
    if (ret != size) {
        RZ_FREE(obj->symbols);
        return false;
    }
    return true;
}

References rz_bin_coff_obj::b, calloc(), rz_bin_coff_obj::endian, rz_bin_coff_obj::hdr, rz_buf_fread_at(), RZ_FREE, rz_bin_coff_obj::size, rz_bin_coff_obj::symbols, and ut64().

Referenced by rz_bin_coff_init().

rz_bin_coff_new_buf()

RZ_API struct rz_bin_coff_obj* rz_bin_coff_new_buf	(	RzBuffer *	buf,
		bool	verbose
	)

Definition at line 278 of file coff.c.

                                                                                {
    struct rz_bin_coff_obj *bin = RZ_NEW0(struct rz_bin_coff_obj);
    rz_bin_coff_init(bin, buf, verbose);
    return bin;
}

References rz_bin_coff_init(), RZ_NEW0, and verbose.

Referenced by load_buffer().

rz_coff_get_entry()

RZ_API RzBinAddr* rz_coff_get_entry

(

struct rz_bin_coff_obj *

obj

)

Definition at line 89 of file coff.c.

                                                                 {
    RzBinAddr *addr = RZ_NEW0(RzBinAddr);
    int i;
    if (!addr) {
        return NULL;
    }
    /* Simplest case, the header provides the entrypoint address */
    if (obj->hdr.f_opthdr) {
        addr->paddr = obj->opt_hdr.entry;
        return addr;
    }
    /* No help from the header eh? Use the address of the symbols '_start'
     * or 'main' if present */
    if (obj->symbols) {
        for (i = 0; i < obj->hdr.f_nsyms; i++) {
            if ((!strcmp(obj->symbols[i].n_name, "_start") ||
                    !strcmp(obj->symbols[i].n_name, "start")) &&
                rz_coff_rebase_sym(obj, addr, &obj->symbols[i])) {
                return addr;
            }
        }
        for (i = 0; i < obj->hdr.f_nsyms; i++) {
            if ((!strcmp(obj->symbols[i].n_name, "_main") ||
                    !strcmp(obj->symbols[i].n_name, "main")) &&
                rz_coff_rebase_sym(obj, addr, &obj->symbols[i])) {
                return addr;
            }
        }
    }
#if 0
    /* Still clueless ? Let's just use the address of .text */
    if (obj->scn_hdrs) {
        for (i = 0; i < obj->hdr.f_nscns; i++) {
            // avoid doing string matching and use x bit from the section
            if (obj->scn_hdrs[i].s_flags & COFF_SCN_MEM_EXECUTE) {
                addr->paddr = obj->scn_hdrs[i].s_scnptr;
                return addr;
            }
        }
    }
#else
    free(addr);
    return NULL;
#endif
    return addr;
}

References addr, COFF_SCN_MEM_EXECUTE, free(), rz_bin_coff_obj::hdr, i, NULL, rz_bin_coff_obj::opt_hdr, rz_coff_rebase_sym(), RZ_NEW0, rz_bin_coff_obj::scn_hdrs, and rz_bin_coff_obj::symbols.

Referenced by entries().

rz_coff_perms_from_section_flags()

RZ_API ut64 rz_coff_perms_from_section_flags

(

ut32

flags

)

Definition at line 36 of file coff.c.

                                                         {
    ut32 r = 0;
    if (flags & COFF_SCN_MEM_READ) {
        r |= RZ_PERM_R;
    }
    if (flags & COFF_SCN_MEM_WRITE) {
        r |= RZ_PERM_W;
    }
    if (flags & COFF_SCN_MEM_EXECUTE) {
        r |= RZ_PERM_X;
    }
    return r;
}

References COFF_SCN_MEM_EXECUTE, COFF_SCN_MEM_READ, COFF_SCN_MEM_WRITE, flags, r, RZ_PERM_R, RZ_PERM_W, and RZ_PERM_X.

Referenced by maps(), and sections().

rz_coff_rebase_sym()

static int rz_coff_rebase_sym ( struct rz_bin_coff_obj *  obj, RzBinAddr *  addr, struct coff_symbol *  sym  )

static

Definition at line 79 of file coff.c.

                                                                                                     {
    if (sym->n_scnum < 1 || sym->n_scnum > obj->hdr.f_nscns) {
        return 0;
    }
    addr->paddr = obj->scn_hdrs[sym->n_scnum - 1].s_scnptr + sym->n_value;
    return 1;
}

References addr, rz_bin_coff_obj::hdr, and rz_bin_coff_obj::scn_hdrs.

Referenced by rz_coff_get_entry().

rz_coff_supported_arch()

RZ_API bool rz_coff_supported_arch

(

const ut8 *

buf

)

Definition at line 9 of file coff.c.

                                                   {
    ut16 arch = rz_read_le16(buf);
    switch (arch) {
    case COFF_FILE_MACHINE_MIPS16:
    case COFF_FILE_MACHINE_MIPSFPU:
    case COFF_FILE_MACHINE_MIPSFPU16:
    case COFF_FILE_MACHINE_AMD64:
    case COFF_FILE_MACHINE_I386:
    case COFF_FILE_MACHINE_H8300:
    case COFF_FILE_TI_COFF:
    case COFF_FILE_MACHINE_R4000:
    case COFF_FILE_MACHINE_AMD29KBE:
    case COFF_FILE_MACHINE_AMD29KLE:
    case COFF_FILE_MACHINE_SH3:
    case COFF_FILE_MACHINE_SH3DSP:
    case COFF_FILE_MACHINE_SH4:
    case COFF_FILE_MACHINE_SH5:
    case COFF_FILE_MACHINE_THUMB:
    case COFF_FILE_MACHINE_ARM:
    case COFF_FILE_MACHINE_ARM64:
    case COFF_FILE_MACHINE_ARMNT:
        return true;
    default:
        return false;
    }
}

References arch, COFF_FILE_MACHINE_AMD29KBE, COFF_FILE_MACHINE_AMD29KLE, COFF_FILE_MACHINE_AMD64, COFF_FILE_MACHINE_ARM, COFF_FILE_MACHINE_ARM64, COFF_FILE_MACHINE_ARMNT, COFF_FILE_MACHINE_H8300, COFF_FILE_MACHINE_I386, COFF_FILE_MACHINE_MIPS16, COFF_FILE_MACHINE_MIPSFPU, COFF_FILE_MACHINE_MIPSFPU16, COFF_FILE_MACHINE_R4000, COFF_FILE_MACHINE_SH3, COFF_FILE_MACHINE_SH3DSP, COFF_FILE_MACHINE_SH4, COFF_FILE_MACHINE_SH5, COFF_FILE_MACHINE_THUMB, COFF_FILE_TI_COFF, and rz_read_le16().

Referenced by check_buffer().

rz_coff_symbol_name()

RZ_API char* rz_coff_symbol_name	(	struct rz_bin_coff_obj *	obj,
		void *	ptr
	)

Definition at line 50 of file coff.c.

                                                                         {
    char n[256] = { 0 };
    int len = 0, offset = 0;
    union {
        char name[8];
        struct {
            ut32 zero;
            ut32 offset;
        };
    } *p = ptr;
    if (!ptr) {
        return strdup("");
    }
    if (p->zero) {
        return rz_str_ndup(p->name, 8);
    }
    offset = obj->hdr.f_symptr + obj->hdr.f_nsyms * sizeof(struct coff_symbol) + p->offset;
    if (offset > obj->size) {
        return strdup("");
    }
    len = rz_buf_read_at(obj->b, offset, (ut8 *)n, sizeof(n));
    if (len < 1) {
        return strdup("");
    }
    /* ensure null terminated string */
    n[sizeof(n) - 1] = 0;
    return strdup(n);
}

References rz_bin_coff_obj::b, rz_bin_coff_obj::hdr, len, n, p, rz_buf_read_at(), rz_str_ndup(), rz_bin_coff_obj::size, and strdup().

Referenced by _fill_bin_import(), _fill_bin_symbol(), maps(), and sections().