coff.h File Reference

#include <rz_types.h>
#include <rz_util.h>
#include <rz_lib.h>
#include <rz_bin.h>
#include <ht_up.h>
#include <ht_uu.h>
#include "coff_specs.h"

Go to the source code of this file.

Classes
struct	rz_bin_coff_obj

Macros
#define	COFF_IS_BIG_ENDIAN   1
#define	COFF_IS_LITTLE_ENDIAN   0
#define	RZ_COFF_RELOC_TARGET_SIZE   8

Functions
RZ_API bool	rz_coff_supported_arch (const ut8 *buf)
RZ_API ut64	rz_coff_perms_from_section_flags (ut32 flags)
RZ_API struct rz_bin_coff_obj *	rz_bin_coff_new_buf (RzBuffer *buf, bool verbose)
RZ_API void	rz_bin_coff_free (struct rz_bin_coff_obj *obj)
RZ_API RzBinAddr *	rz_coff_get_entry (struct rz_bin_coff_obj *obj)
RZ_API char *	rz_coff_symbol_name (struct rz_bin_coff_obj *obj, void *ptr)
RZ_API ut64	rz_coff_import_index_addr (struct rz_bin_coff_obj *obj, ut64 imp_index)
RZ_API ut64	rz_coff_get_reloc_targets_map_base (struct rz_bin_coff_obj *obj)
	base vaddr where to map the artificial reloc target vfile More...
RZ_API RzList *	rz_coff_get_relocs (struct rz_bin_coff_obj *bin)
RZ_API ut64	rz_coff_get_reloc_targets_vfile_size (struct rz_bin_coff_obj *obj)
	size of the artificial reloc target vfile More...
RZ_API RZ_BORROW RzBuffer *	rz_coff_get_patched_buf (struct rz_bin_coff_obj *bin)

Macro Definition Documentation

COFF_IS_BIG_ENDIAN

#define COFF_IS_BIG_ENDIAN   1

Definition at line 14 of file coff.h.

COFF_IS_LITTLE_ENDIAN

#define COFF_IS_LITTLE_ENDIAN   0

Definition at line 15 of file coff.h.

RZ_COFF_RELOC_TARGET_SIZE

#define RZ_COFF_RELOC_TARGET_SIZE   8

Definition at line 55 of file coff.h.

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_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_get_patched_buf()

RZ_API RZ_BORROW RzBuffer* rz_coff_get_patched_buf

(

struct rz_bin_coff_obj *

bin

)

Definition at line 219 of file coff_reloc.c.

                                                                                {
    rz_return_val_if_fail(bin, NULL);
    if (bin->buf_patched) {
        return bin->buf_patched;
    }
    bin->buf_patched = rz_buf_new_sparse_overlay(bin->b, RZ_BUF_SPARSE_WRITE_MODE_SPARSE);
    if (!bin->buf_patched) {
        return NULL;
    }
    relocs_foreach(bin, patch_reloc_cb, bin->buf_patched);
    rz_buf_sparse_set_write_mode(bin->buf_patched, RZ_BUF_SPARSE_WRITE_MODE_THROUGH);
    return bin->buf_patched;
}

References NULL, patch_reloc_cb(), relocs_foreach(), rz_buf_new_sparse_overlay(), rz_buf_sparse_set_write_mode(), RZ_BUF_SPARSE_WRITE_MODE_SPARSE, RZ_BUF_SPARSE_WRITE_MODE_THROUGH, and rz_return_val_if_fail.

Referenced by virtual_files().

rz_coff_get_reloc_targets_map_base()

RZ_API ut64 rz_coff_get_reloc_targets_map_base

(

struct rz_bin_coff_obj *

obj

)

base vaddr where to map the artificial reloc target vfile

Definition at line 9 of file coff_reloc.c.

                                                                            {
    rz_return_val_if_fail(obj, 0);
    if (obj->reloc_targets_map_base_calculated) {
        return obj->reloc_targets_map_base;
    }
    if (!obj->scn_va) {
        return 0;
    }
    ut64 max = 0;
    for (size_t i = 0; i < obj->hdr.f_nscns; i++) {
        struct coff_scn_hdr *hdr = &obj->scn_hdrs[i];
        ut64 val = obj->scn_va[i] + hdr->s_size;
        if (val > max) {
            max = val;
        }
    }
    max += 8;
    max += rz_num_align_delta(max, RZ_COFF_RELOC_TARGET_SIZE);
    obj->reloc_targets_map_base = max;
    obj->reloc_targets_map_base_calculated = true;
    return obj->reloc_targets_map_base;
}

References rz_bin_coff_obj::hdr, i, max, rz_bin_coff_obj::reloc_targets_map_base, rz_bin_coff_obj::reloc_targets_map_base_calculated, RZ_COFF_RELOC_TARGET_SIZE, rz_num_align_delta(), rz_return_val_if_fail, rz_bin_coff_obj::scn_hdrs, rz_bin_coff_obj::scn_va, ut64(), and val.

Referenced by maps(), and rz_coff_import_index_addr().

rz_coff_get_reloc_targets_vfile_size()

RZ_API ut64 rz_coff_get_reloc_targets_vfile_size

(

struct rz_bin_coff_obj *

obj

)

size of the artificial reloc target vfile

Definition at line 206 of file coff_reloc.c.

                                                                              {
    rz_return_val_if_fail(obj, 0);
    ut64 count = obj->imp_index ? obj->imp_index->count : 0;
    return count * RZ_COFF_RELOC_TARGET_SIZE;
}

References count, rz_bin_coff_obj::imp_index, RZ_COFF_RELOC_TARGET_SIZE, rz_return_val_if_fail, and ut64().

Referenced by maps(), and virtual_files().

rz_coff_get_relocs()

RZ_API RzList* rz_coff_get_relocs

(

struct rz_bin_coff_obj *

bin

)

Definition at line 195 of file coff_reloc.c.

                                                               {
    rz_return_val_if_fail(bin, NULL);
    RzList *r = rz_list_newf(free);
    if (!r) {
        return NULL;
    }
    relocs_foreach(bin, get_relocs_list_cb, r);
    return r;
}

References free(), get_relocs_list_cb(), NULL, r, relocs_foreach(), rz_list_newf(), and rz_return_val_if_fail.

Referenced by relocs().

rz_coff_import_index_addr()

RZ_API ut64 rz_coff_import_index_addr	(	struct rz_bin_coff_obj *	obj,
		ut64	imp_index
	)

Definition at line 32 of file coff_reloc.c.

                                                                                   {
    return rz_coff_get_reloc_targets_map_base(obj) + imp_index * RZ_COFF_RELOC_TARGET_SIZE;
}

References rz_coff_get_reloc_targets_map_base(), and RZ_COFF_RELOC_TARGET_SIZE.

Referenced by _fill_bin_symbol(), and relocs_foreach().

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_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().