omf.c File Reference

#include "omf.h"

Go to the source code of this file.

Functions
static bool	is_valid_omf_type (ut8 type)
bool	rz_bin_checksum_omf_ok (const ut8 *buf, ut64 buf_size)
static ut16	omf_get_idx (const ut8 *buf, int buf_size)
static void	free_lname (OMF_multi_datas *lname)
static bool	load_omf_lnames (OMF_record *record, const ut8 *buf, ut64 buf_size)
static int	load_omf_segdef (OMF_record *record, const ut8 *buf, ut64 buf_size)
static ut32	omf_count_symb (ut16 total_size, ut32 ct, const ut8 *buf, int bits)
static int	load_omf_symb (OMF_record *record, ut32 ct, const ut8 *buf, int buf_size, int bits, ut16 seg_idx)
static int	load_omf_pubdef (OMF_record *record, const ut8 *buf, int buf_size)
static int	load_omf_data (const ut8 *buf, int buf_size, OMF_record *record, ut64 global_ct)
static int	load_omf_content (OMF_record *record, const ut8 *buf, ut64 global_ct, ut64 buf_size)
static OMF_record_handler *	load_record_omf (const ut8 *buf, ut64 global_ct, ut64 buf_size)
static int	load_all_omf_records (rz_bin_omf_obj *obj, const ut8 *buf, ut64 size)
static ut32	count_omf_record_type (rz_bin_omf_obj *obj, ut8 type)
static ut32	count_omf_multi_record_type (rz_bin_omf_obj *obj, ut8 type)
static OMF_record_handler *	get_next_omf_record_type (OMF_record_handler *tmp, ut8 type)
static int	cpy_omf_names (rz_bin_omf_obj *obj)
static void	get_omf_section_info (rz_bin_omf_obj *obj)
static int	get_omf_symbol_info (rz_bin_omf_obj *obj)
static int	get_omf_data_info (rz_bin_omf_obj *obj)
static int	get_omf_infos (rz_bin_omf_obj *obj)
static void	free_pubdef (OMF_multi_datas *datas)
static void	free_all_omf_records (rz_bin_omf_obj *obj)
static void	free_all_omf_sections (rz_bin_omf_obj *obj)
static void	free_all_omf_symbols (rz_bin_omf_obj *obj)
static void	free_all_omf_names (rz_bin_omf_obj *obj)
void	rz_bin_free_all_omf_obj (rz_bin_omf_obj *obj)
rz_bin_omf_obj *	rz_bin_internal_omf_load (const ut8 *buf, ut64 size)
bool	rz_bin_omf_get_entry (rz_bin_omf_obj *obj, RzBinAddr *addr)
int	rz_bin_omf_get_bits (rz_bin_omf_obj *obj)
int	rz_bin_omf_send_sections (RzList *list, OMF_segment *section, rz_bin_omf_obj *obj)
ut64	rz_bin_omf_get_paddr_sym (rz_bin_omf_obj *obj, OMF_symbol *sym)
ut64	rz_bin_omf_get_vaddr_sym (rz_bin_omf_obj *obj, OMF_symbol *sym)

Function Documentation

count_omf_multi_record_type()

static ut32 count_omf_multi_record_type ( rz_bin_omf_obj *  obj, ut8  type  )

static

Definition at line 454 of file omf.c.

                                                                       {
    OMF_record_handler *tmp = obj->records;
    ut32 ct = 0;
 
    while (tmp) {
        if (((OMF_record *)tmp)->type == type) {
            ct += ((OMF_multi_datas *)((OMF_record *)tmp)->content)->nb_elem;
        }
        tmp = tmp->next;
    }
    return ct;
}

References rz_bin_omf_obj::records, autogen_x86imm::tmp, and type.

Referenced by get_omf_infos().

count_omf_record_type()

static ut32 count_omf_record_type ( rz_bin_omf_obj *  obj, ut8  type  )

static

Definition at line 441 of file omf.c.

                                                                 {
    OMF_record_handler *tmp = obj->records;
    ut32 ct = 0;
 
    while (tmp) {
        if (((OMF_record *)tmp)->type == type) {
            ct++;
        }
        tmp = tmp->next;
    }
    return ct;
}

References rz_bin_omf_obj::records, autogen_x86imm::tmp, and type.

Referenced by get_omf_infos().

cpy_omf_names()

static int cpy_omf_names ( rz_bin_omf_obj *  obj )

static

Definition at line 477 of file omf.c.

                                              {
    OMF_record_handler *tmp = obj->records;
    OMF_multi_datas *lname;
    int ct_obj = 0;
    int ct_rec;
 
    while ((tmp = get_next_omf_record_type(tmp, OMF_LNAMES))) {
        lname = (OMF_multi_datas *)((OMF_record *)tmp)->content;
 
        ct_rec = -1;
        while (++ct_rec < lname->nb_elem) {
            if (!((char **)lname->elems)[ct_rec]) {
                obj->names[ct_obj++] = NULL;
            } else if (!(obj->names[ct_obj++] = strdup(((char **)lname->elems)[ct_rec]))) {
                return false;
            }
        }
        tmp = tmp->next;
    }
    return true;
}

References OMF_multi_datas::elems, get_next_omf_record_type(), rz_bin_omf_obj::names, NULL, OMF_LNAMES, rz_bin_omf_obj::records, strdup(), and autogen_x86imm::tmp.

Referenced by get_omf_infos().

free_all_omf_names()

static void free_all_omf_names ( rz_bin_omf_obj *  obj )

static

Definition at line 655 of file omf.c.

                                                    {
    ut32 ct = 0;
 
    while (ct < obj->nb_name) {
        RZ_FREE(obj->names[ct]);
        ct++;
    }
    RZ_FREE(obj->names);
}

References rz_bin_omf_obj::names, and RZ_FREE.

Referenced by rz_bin_free_all_omf_obj().

free_all_omf_records()

static void free_all_omf_records ( rz_bin_omf_obj *  obj )

static

Definition at line 609 of file omf.c.

                                                      {
    OMF_record_handler *tmp = NULL;
    OMF_record_handler *rec = obj->records;
 
    while (rec) {
        if (((OMF_record *)rec)->type == OMF_LNAMES) {
            free_lname((OMF_multi_datas *)((OMF_record *)rec)->content);
        } else if (((OMF_record *)rec)->type == OMF_PUBDEF) {
            free_pubdef((OMF_multi_datas *)((OMF_record *)rec)->content);
        } else {
            RZ_FREE(((OMF_record *)rec)->content);
        }
        tmp = rec->next;
        RZ_FREE(rec);
        rec = tmp;
    }
    obj->records = NULL;
}

References free_lname(), free_pubdef(), NULL, OMF_LNAMES, OMF_PUBDEF, rz_bin_omf_obj::records, RZ_FREE, autogen_x86imm::tmp, and type.

Referenced by rz_bin_free_all_omf_obj(), and rz_bin_internal_omf_load().

free_all_omf_sections()

static void free_all_omf_sections ( rz_bin_omf_obj *  obj )

static

Definition at line 628 of file omf.c.

                                                       {
    ut32 ct = 0;
    OMF_data *data;
 
    while (ct < obj->nb_section) {
        while (obj->sections[ct]->data) {
            data = obj->sections[ct]->data->next;
            RZ_FREE(obj->sections[ct]->data);
            obj->sections[ct]->data = data;
        }
        RZ_FREE(obj->sections[ct]);
        ct++;
    }
    RZ_FREE(obj->sections);
}

References OMF_segment::data, OMF_DATA::next, RZ_FREE, and rz_bin_omf_obj::sections.

Referenced by rz_bin_free_all_omf_obj().

free_all_omf_symbols()

static void free_all_omf_symbols ( rz_bin_omf_obj *  obj )

static

Definition at line 644 of file omf.c.

                                                      {
    ut32 ct = 0;
    while (ct < obj->nb_symbol) {
        RZ_FREE(obj->symbols[ct]->name);
        RZ_FREE(obj->symbols[ct]);
 
        ct++;
    }
    RZ_FREE(obj->symbols);
}

References OMF_symbol::name, RZ_FREE, and rz_bin_omf_obj::symbols.

Referenced by rz_bin_free_all_omf_obj().

free_lname()

static void free_lname ( OMF_multi_datas *  lname )

static

Definition at line 71 of file omf.c.

                                               {
    ut32 ct = 0;
 
    while (ct < lname->nb_elem) {
        RZ_FREE(((char **)lname->elems)[ct]);
        ct++;
    }
    RZ_FREE(lname->elems);
    RZ_FREE(lname);
}

References OMF_multi_datas::elems, and RZ_FREE.

Referenced by free_all_omf_records(), and load_omf_lnames().

free_pubdef()

static void free_pubdef ( OMF_multi_datas *  datas )

static

Definition at line 599 of file omf.c.

                                                {
#if 0
    while (ct_rec < datas->nb_elem) {
        RZ_FREE (((OMF_symbol *)(datas->elems + ct_rec++))->name);
    }
#endif
    RZ_FREE(datas->elems);
    RZ_FREE(datas);
}

References OMF_multi_datas::elems, and RZ_FREE.

Referenced by free_all_omf_records().

get_next_omf_record_type()

static OMF_record_handler* get_next_omf_record_type ( OMF_record_handler *  tmp, ut8  type  )

static

Definition at line 467 of file omf.c.

                                                                                       {
    while (tmp) {
        if (((OMF_record *)tmp)->type == type) {
            return (tmp);
        }
        tmp = tmp->next;
    }
    return NULL;
}

References NULL, autogen_x86imm::tmp, and type.

Referenced by cpy_omf_names(), get_omf_data_info(), get_omf_section_info(), and get_omf_symbol_info().

get_omf_data_info()

static int get_omf_data_info ( rz_bin_omf_obj *  obj )

static

Definition at line 541 of file omf.c.

                                                  {
    OMF_record_handler *tmp = obj->records;
    OMF_data *tmp_data;
 
    while ((tmp = get_next_omf_record_type(tmp, OMF_LEDATA))) {
        if (((OMF_data *)((OMF_record *)tmp)->content)->seg_idx - 1 >= obj->nb_section) {
            RZ_LOG_ERROR("Invalid Ledata record (bad segment index)\n");
            return false;
        }
        OMF_segment *os = obj->sections[((OMF_data *)((OMF_record *)tmp)->content)->seg_idx - 1];
        if (os && (tmp_data = os->data)) {
            while (tmp_data->next) {
                tmp_data = tmp_data->next;
            }
            tmp_data->next = ((OMF_record *)tmp)->content;
        } else {
            obj->sections[((OMF_data *)((OMF_record *)tmp)->content)->seg_idx - 1]->data = ((OMF_record *)tmp)->content;
        }
        ((OMF_record *)tmp)->content = NULL;
        tmp = tmp->next;
    }
    return true;
}

References OMF_segment::data, get_next_omf_record_type(), rz_bin_omf_obj::nb_section, OMF_DATA::next, NULL, OMF_LEDATA, rz_bin_omf_obj::records, RZ_LOG_ERROR, rz_bin_omf_obj::sections, and autogen_x86imm::tmp.

Referenced by get_omf_infos().

get_omf_infos()

static int get_omf_infos ( rz_bin_omf_obj *  obj )

static

Definition at line 565 of file omf.c.

                                              {
    // get all name defined in lnames records
    obj->nb_name = count_omf_multi_record_type(obj, OMF_LNAMES);
    if (obj->nb_name > 0) {
        if (!(obj->names = RZ_NEWS0(char *, obj->nb_name))) {
            return false;
        }
        if (!cpy_omf_names(obj)) {
            return false;
        }
    }
    // get all sections (segdef record)
    obj->nb_section = count_omf_record_type(obj, OMF_SEGDEF);
    if (obj->nb_section > 0) {
        if (!(obj->sections = RZ_NEWS0(OMF_segment *, obj->nb_section))) {
            return false;
        }
        get_omf_section_info(obj);
    }
    // get all data (ledata record)
    get_omf_data_info(obj);
    // get all symbols (pubdef + lpubdef)
    obj->nb_symbol = count_omf_multi_record_type(obj, OMF_PUBDEF);
    if (obj->nb_symbol > 0) {
        if (!(obj->symbols = RZ_NEWS0(OMF_symbol *, obj->nb_symbol))) {
            return false;
        }
        if (!get_omf_symbol_info(obj)) {
            return false;
        }
    }
    return true;
}

References count_omf_multi_record_type(), count_omf_record_type(), cpy_omf_names(), get_omf_data_info(), get_omf_section_info(), get_omf_symbol_info(), rz_bin_omf_obj::names, rz_bin_omf_obj::nb_name, rz_bin_omf_obj::nb_section, rz_bin_omf_obj::nb_symbol, OMF_LNAMES, OMF_PUBDEF, OMF_SEGDEF, RZ_NEWS0, rz_bin_omf_obj::sections, and rz_bin_omf_obj::symbols.

Referenced by rz_bin_internal_omf_load().

get_omf_section_info()

static void get_omf_section_info ( rz_bin_omf_obj *  obj )

static

Definition at line 499 of file omf.c.

                                                      {
    OMF_record_handler *tmp = obj->records;
    ut32 ct_obj = 0;
 
    while ((tmp = get_next_omf_record_type(tmp, OMF_SEGDEF))) {
        obj->sections[ct_obj] = ((OMF_record *)tmp)->content;
        ((OMF_record *)tmp)->content = NULL;
 
        if (!ct_obj) {
            obj->sections[ct_obj]->vaddr = 0;
        } else {
            obj->sections[ct_obj]->vaddr = obj->sections[ct_obj - 1]->vaddr +
                obj->sections[ct_obj - 1]->size;
        }
        ct_obj++;
        tmp = tmp->next;
    }
}

References get_next_omf_record_type(), NULL, OMF_SEGDEF, rz_bin_omf_obj::records, rz_bin_omf_obj::sections, OMF_segment::size, autogen_x86imm::tmp, and OMF_segment::vaddr.

Referenced by get_omf_infos().

get_omf_symbol_info()

static int get_omf_symbol_info ( rz_bin_omf_obj *  obj )

static

Definition at line 518 of file omf.c.

                                                    {
    OMF_record_handler *tmp = obj->records;
    OMF_multi_datas *symbols;
    int ct_obj = 0;
    int ct_rec = 0;
 
    while ((tmp = get_next_omf_record_type(tmp, OMF_PUBDEF))) {
        symbols = (OMF_multi_datas *)((OMF_record *)tmp)->content;
 
        ct_rec = -1;
        while (++ct_rec < symbols->nb_elem) {
            if (!(obj->symbols[ct_obj] = RZ_NEW0(OMF_symbol))) {
                return false;
            }
            memcpy(obj->symbols[ct_obj], ((OMF_symbol *)symbols->elems) + ct_rec, sizeof(*(obj->symbols[ct_obj])));
            obj->symbols[ct_obj]->name = strdup(((OMF_symbol *)symbols->elems)[ct_rec].name);
            ct_obj++;
        }
        tmp = tmp->next;
    }
    return true;
}

References get_next_omf_record_type(), memcpy(), OMF_symbol::name, OMF_PUBDEF, rz_bin_omf_obj::records, RZ_NEW0, strdup(), rz_bin_omf_obj::symbols, symbols(), and autogen_x86imm::tmp.

Referenced by get_omf_infos().

is_valid_omf_type()

static bool is_valid_omf_type ( ut8  type )

static

Definition at line 7 of file omf.c.

                                        {
    int ct = 0;
    ut8 types[] = {
        OMF_THEADR, OMF_LHEADR, OMF_COMENT, OMF_MODEND, OMF_MODEND32,
        OMF_EXTDEF, OMF_PUBDEF, OMF_PUBDEF32, OMF_LINNUM,
        OMF_LINNUM32, OMF_LNAMES, OMF_LNAMES, OMF_SEGDEF,
        OMF_SEGDEF32, OMF_GRPDEF, OMF_FIXUPP, OMF_FIXUPP32,
        OMF_LEDATA, OMF_LEDATA32, OMF_LIDATA, OMF_LIDATA32,
        OMF_COMDEF, OMF_BAKPAT, OMF_BAKPAT32, OMF_LEXTDEF,
        OMF_LPUBDEF, OMF_LPUBDEF32, OMF_LCOMDEF, OMF_CEXTDEF,
        OMF_COMDAT, OMF_COMDAT32, OMF_LINSYM, OMF_LINSYM32,
        OMF_ALIAS, OMF_NBKPAT, OMF_NBKPAT32, OMF_LLNAMES, OMF_VERNUM,
        OMF_VENDEXT, 0
    };
    for (; types[ct]; ct++) {
        if (type == types[ct]) {
            return true;
        }
    }
    // RZ_LOG_ERROR("Invalid record type\n");
    return false;
}

References OMF_ALIAS, OMF_BAKPAT, OMF_BAKPAT32, OMF_CEXTDEF, OMF_COMDAT, OMF_COMDAT32, OMF_COMDEF, OMF_COMENT, OMF_EXTDEF, OMF_FIXUPP, OMF_FIXUPP32, OMF_GRPDEF, OMF_LCOMDEF, OMF_LEDATA, OMF_LEDATA32, OMF_LEXTDEF, OMF_LHEADR, OMF_LIDATA, OMF_LIDATA32, OMF_LINNUM, OMF_LINNUM32, OMF_LINSYM, OMF_LINSYM32, OMF_LLNAMES, OMF_LNAMES, OMF_LPUBDEF, OMF_LPUBDEF32, OMF_MODEND, OMF_MODEND32, OMF_NBKPAT, OMF_NBKPAT32, OMF_PUBDEF, OMF_PUBDEF32, OMF_SEGDEF, OMF_SEGDEF32, OMF_THEADR, OMF_VENDEXT, OMF_VERNUM, type, and types.

Referenced by load_record_omf().

load_all_omf_records()

static int load_all_omf_records ( rz_bin_omf_obj *  obj, const ut8 *  buf, ut64  size  )

static

Definition at line 418 of file omf.c.

                                                                                {
    ut64 ct = 0;
    OMF_record_handler *new_rec = NULL;
    OMF_record_handler *tmp = NULL;
 
    while (ct < size) {
        if (!(new_rec = load_record_omf(buf + ct, ct, size - ct))) {
            return false;
        }
 
        // the order is important because some link are made by index
        if (!tmp) {
            obj->records = new_rec;
            tmp = obj->records;
        } else {
            tmp->next = new_rec;
            tmp = tmp->next;
        }
        ct += 3 + ((OMF_record *)tmp)->size;
    }
    return true;
}

References load_record_omf(), NULL, rz_bin_omf_obj::records, autogen_x86imm::tmp, and ut64().

Referenced by rz_bin_internal_omf_load().

load_omf_content()

static int load_omf_content ( OMF_record *  record, const ut8 *  buf, ut64  global_ct, ut64  buf_size  )

static

Definition at line 366 of file omf.c.

                                                                                               {
    if (record->type == OMF_LNAMES) {
        return load_omf_lnames(record, buf, buf_size);
    }
    if (record->type == OMF_SEGDEF || record->type == OMF_SEGDEF32) {
        return load_omf_segdef(record, buf, buf_size);
    }
    if (record->type == OMF_PUBDEF || record->type == OMF_PUBDEF32 || record->type == OMF_LPUBDEF || record->type == OMF_LPUBDEF32) {
        return load_omf_pubdef(record, buf, buf_size);
    }
    if (record->type == OMF_LEDATA || record->type == OMF_LEDATA32) {
        return load_omf_data(buf, buf_size, record, global_ct);
    }
    // generic loader just copy data from buf to content
    if (!record->size) {
        RZ_LOG_ERROR("Invalid record (size to short)\n");
        return false;
    }
    if (!(record->content = RZ_NEWS0(char, record->size))) {
        return false;
    }
    ((char *)record->content)[record->size - 1] = 0;
    return true;
}

References buf_size, load_omf_data(), load_omf_lnames(), load_omf_pubdef(), load_omf_segdef(), OMF_LEDATA, OMF_LEDATA32, OMF_LNAMES, OMF_LPUBDEF, OMF_LPUBDEF32, OMF_PUBDEF, OMF_PUBDEF32, OMF_SEGDEF, OMF_SEGDEF32, RZ_LOG_ERROR, and RZ_NEWS0.

Referenced by load_record_omf().

load_omf_data()

static int load_omf_data ( const ut8 *  buf, int  buf_size, OMF_record *  record, ut64  global_ct  )

static

Definition at line 326 of file omf.c.

                                                                                           {
    ut16 seg_idx;
    ut32 offset;
    ut16 ct = 4;
    OMF_data *ret;
 
    if ((!(record->type & 1) && record->size < 4) || (record->size < 6)) {
        RZ_LOG_ERROR("Invalid Ledata record (bad size)\n");
        return false;
    }
    seg_idx = omf_get_idx(buf + 3, buf_size - 3);
    if (seg_idx & 0xff00) {
        if ((!(record->type & 1) && record->size < 5) || (record->size < 7)) {
            RZ_LOG_ERROR("Invalid Ledata record (bad size)\n");
            return false;
        }
        ct++;
    }
    if (record->type == OMF_LEDATA32) {
        offset = rz_read_le32(buf + ct);
        ct += 4;
    } else {
        offset = rz_read_le16(buf + ct);
        ct += 2;
    }
    if (!(ret = RZ_NEW0(OMF_data))) {
        return false;
    }
    record->content = ret;
 
    ret->size = record->size - 1 - (ct - 3);
    ret->paddr = global_ct + ct;
    ret->offset = offset;
    ret->seg_idx = seg_idx;
    ret->next = NULL;
    record->type = OMF_LEDATA;
 
    return true;
}

References buf_size, OMF_DATA::next, NULL, OMF_DATA::offset, omf_get_idx(), OMF_LEDATA, OMF_LEDATA32, OMF_DATA::paddr, RZ_LOG_ERROR, RZ_NEW0, rz_read_le16(), rz_read_le32(), OMF_DATA::seg_idx, and OMF_DATA::size.

Referenced by load_omf_content().

load_omf_lnames()

static bool load_omf_lnames ( OMF_record *  record, const ut8 *  buf, ut64  buf_size  )

static

Definition at line 82 of file omf.c.

                                                                               {
    ut32 tmp_size = 0;
    ut32 ct_name = 0;
    OMF_multi_datas *ret = NULL;
    char **names;
    if (!record || !buf) {
        return false;
    }
 
    if (!(ret = RZ_NEW0(OMF_multi_datas))) {
        return false;
    }
    record->content = ret;
 
    while ((int)tmp_size < (int)(record->size - 1)) {
        int next;
        ret->nb_elem++;
        next = buf[3 + tmp_size] + 1;
        if (next < 1) {
            break;
        }
        tmp_size += next;
    }
    if (!(ret->elems = RZ_NEWS0(char *, ret->nb_elem + 1))) {
        RZ_FREE(ret);
        return false;
    }
    names = (char **)ret->elems;
    tmp_size = 0;
    while ((int)tmp_size < (int)(record->size - 1)) {
        if (ct_name >= ret->nb_elem) {
            RZ_LOG_ERROR("Invalid number of element (overflow)\n");
            break;
        }
        // sometimes there is a name with a null size so we just skip it
        char cb = buf[3 + tmp_size];
        if (cb < 1) {
            names[ct_name++] = NULL;
            tmp_size++;
            continue;
        }
        if (record->size + 3 < tmp_size + cb) {
            RZ_LOG_ERROR("Invalid Lnames record (bad size)\n");
            free(ret);
            return false;
        }
        if (!(names[ct_name] = RZ_NEWS0(char, cb + 1))) {
            free_lname(ret);
            return false;
        }
        if ((tmp_size + 4 + cb) < buf_size) {
            memcpy(names[ct_name], buf + 3 + tmp_size + 1, cb);
        }
        ct_name++;
        tmp_size += cb + 1; // buf[3 + tmp_size] + 1;
    }
    return true;
}

References buf_size, cb, OMF_multi_datas::elems, free(), free_lname(), int, memcpy(), names, OMF_multi_datas::nb_elem, NULL, RZ_FREE, RZ_LOG_ERROR, RZ_NEW0, RZ_NEWS0, and while().

Referenced by load_omf_content().

load_omf_pubdef()

static int load_omf_pubdef ( OMF_record *  record, const ut8 *  buf, int  buf_size  )

static

Definition at line 254 of file omf.c.

                                                                             {
    OMF_multi_datas *ret = NULL;
    ut16 seg_idx;
    ut16 ct = 0;
    ut16 base_grp;
 
    if (record->size < 2) {
        RZ_LOG_ERROR("Invalid Pubdef record (bad size)\n");
        return false;
    }
 
    ct = 3;
    base_grp = omf_get_idx(buf + ct, buf_size - ct);
    if (buf[ct] & 0x80) { // sizeof base groups index
        ct += 2;
    } else {
        ct++;
    }
 
    if (record->size < ct - 2) {
        RZ_LOG_ERROR("Invalid Pubdef record (bad size)\n");
        return false;
    }
 
    seg_idx = omf_get_idx(buf + ct, buf_size - ct);
 
    if (buf[ct] & 0x80) { // sizeof base segment index
        ct += 2;
    } else {
        ct++;
    }
 
    if (!base_grp && !seg_idx) {
        ct += 2;
    }
    if (record->size < ct - 2) {
        RZ_LOG_ERROR("Invalid Pubdef record (bad size)\n");
        return false;
    }
 
    if (!(ret = RZ_NEW0(OMF_multi_datas))) {
        return false;
    }
    record->content = ret;
 
    if (!(record->type & 1)) { // 16 bit addr
        ret->nb_elem = omf_count_symb(record->size + 3, ct, buf, 16);
        if (ret->nb_elem > 0) {
            if (!(ret->elems = RZ_NEWS0(OMF_symbol, ret->nb_elem))) {
                return false;
            }
        }
        if (!load_omf_symb(record, ct, buf, buf_size, 16, seg_idx)) {
            return false;
        }
    } else { // 32 bit addr
        ret->nb_elem = omf_count_symb(record->size + 3, ct, buf, 32);
        if (ret->nb_elem > 0) {
            if (!(ret->elems = RZ_NEWS0(OMF_symbol, ret->nb_elem))) {
                return false;
            }
        }
        if (!load_omf_symb(record, ct, buf, buf_size, 32, seg_idx)) {
            return false;
        }
    }
 
    // tricks to keep the save index when copying content from record
    record->type = OMF_PUBDEF;
    return true;
}

References buf_size, OMF_multi_datas::elems, load_omf_symb(), OMF_multi_datas::nb_elem, NULL, omf_count_symb(), omf_get_idx(), OMF_PUBDEF, RZ_LOG_ERROR, RZ_NEW0, and RZ_NEWS0.

Referenced by load_omf_content().

load_omf_segdef()

static int load_omf_segdef ( OMF_record *  record, const ut8 *  buf, ut64  buf_size  )

static

Definition at line 141 of file omf.c.

                                                                              {
    OMF_segment *ret = NULL;
    int off_add;
 
    if (!(ret = RZ_NEW0(OMF_segment))) {
        return false;
    }
    record->content = ret;
 
    if (record->size < 2) {
        RZ_LOG_ERROR("Invalid Segdef record (bad size)\n");
        return false;
    }
    off_add = buf[3] & 0xe ? 0 : 3;
 
    if (record->type == OMF_SEGDEF32) {
        if (record->size < 5 + off_add) {
            RZ_LOG_ERROR("Invalid Segdef record (bad size)\n");
            return false;
        }
        ret->name_idx = omf_get_idx(buf + 8 + off_add, buf_size - 8 - off_add);
        if (buf[3] & 2) {
            ret->size = UT32_MAX;
        } else {
            ret->size = rz_read_le32(buf + 4 + off_add);
        }
    } else {
        if (record->size < 3 + off_add) {
            RZ_LOG_ERROR("Invalid Segdef record (bad size)\n");
            return false;
        }
        ret->name_idx = omf_get_idx(buf + 6 + off_add, buf_size - 6 - off_add);
        if (buf[3] & 2) {
            ret->size = UT16_MAX;
        }
        ret->size = rz_read_le16(buf + 4 + off_add);
    }
 
    ret->bits = (buf[3] & 1) ? 32 : 16;
 
    // tricks to keep the save index when copying content from record
    record->type = OMF_SEGDEF;
 
    return true;
}

References OMF_segment::bits, buf_size, OMF_segment::name_idx, NULL, omf_get_idx(), OMF_SEGDEF, OMF_SEGDEF32, RZ_LOG_ERROR, RZ_NEW0, rz_read_le16(), rz_read_le32(), OMF_segment::size, UT16_MAX, and UT32_MAX.

Referenced by load_omf_content().

load_omf_symb()

static int load_omf_symb ( OMF_record *  record, ut32  ct, const ut8 *  buf, int  buf_size, int  bits, ut16  seg_idx  )

static

Definition at line 204 of file omf.c.

                                                                                                            {
    ut32 nb_symb = 0;
    ut8 str_size = 0;
    OMF_symbol *symbol;
 
    while (nb_symb < ((OMF_multi_datas *)record->content)->nb_elem) {
        symbol = ((OMF_symbol *)((OMF_multi_datas *)record->content)->elems) + nb_symb;
 
        if (record->size - 1 < ct - 2) {
            RZ_LOG_ERROR("Invalid Pubdef record (bad size)\n");
            return false;
        }
        str_size = buf[ct];
 
        if (bits == 32) {
            if (ct + 1 + str_size + 4 - 3 > record->size) {
                RZ_LOG_ERROR("Invalid Pubdef record (bad size)\n");
                return false;
            }
            symbol->offset = rz_read_le32(buf + ct + 1 + str_size);
        } else {
            if (ct + 1 + str_size + 2 - 3 > record->size) {
                RZ_LOG_ERROR("Invalid Pubdef record (bad size)\n");
                return false;
            }
            symbol->offset = rz_read_le16(buf + ct + 1 + str_size);
        }
 
        symbol->seg_idx = seg_idx;
 
        if (!(symbol->name = RZ_NEWS0(char, str_size + 1))) {
            return false;
        }
        symbol->name[str_size] = 0;
        memcpy(symbol->name, buf + ct + 1, sizeof(char) * str_size);
 
        ct += 1 + str_size + (bits == 32 ? 4 : 2);
        if (ct >= buf_size) {
            return false;
        }
        if (buf[ct] & 0x80) { // type index
            ct += 2;
        } else {
            ct++;
        }
        nb_symb++;
    }
    return true;
}

References bits(), buf_size, memcpy(), OMF_symbol::name, OMF_symbol::offset, RZ_LOG_ERROR, RZ_NEWS0, rz_read_le16(), rz_read_le32(), and OMF_symbol::seg_idx.

Referenced by load_omf_pubdef().

load_record_omf()

static OMF_record_handler* load_record_omf ( const ut8 *  buf, ut64  global_ct, ut64  buf_size  )

static

Definition at line 391 of file omf.c.

                                                                                          {
    OMF_record_handler *new = NULL;
 
    if (is_valid_omf_type(*buf) && rz_bin_checksum_omf_ok(buf, buf_size)) {
        if (!(new = RZ_NEW0(OMF_record_handler))) {
            return NULL;
        }
        ((OMF_record *)new)->type = *buf;
        ((OMF_record *)new)->size = rz_read_le16(buf + 1);
 
        // at least a record have a type a size and a checksum
        if (((OMF_record *)new)->size > buf_size - 3 || buf_size < 4) {
            RZ_LOG_ERROR("Invalid record (too short)\n");
            RZ_FREE(new);
            return NULL;
        }
 
        if (!(load_omf_content((OMF_record *)new, buf, global_ct, buf_size))) {
            RZ_FREE(new);
            return NULL;
        }
        ((OMF_record *)new)->checksum = buf[2 + ((OMF_record *)new)->size];
        new->next = NULL;
    }
    return new;
}

References buf_size, is_valid_omf_type(), load_omf_content(), NULL, rz_bin_checksum_omf_ok(), RZ_FREE, RZ_LOG_ERROR, RZ_NEW0, and rz_read_le16().

Referenced by load_all_omf_records().

omf_count_symb()

static ut32 omf_count_symb ( ut16  total_size, ut32  ct, const ut8 *  buf, int  bits  )

static

Definition at line 187 of file omf.c.

                                                                               {
    ut32 nb_symb = 0;
    while (ct < total_size - 1) {
        ct += buf[ct] + 1 + (bits == 32 ? 4 : 2);
        if (ct > total_size - 1) {
            return nb_symb;
        }
        if (buf[ct] & 0x80) {
            ct += 2;
        } else {
            ct++;
        }
        nb_symb++;
    }
    return nb_symb;
}

References bits().

Referenced by load_omf_pubdef().

omf_get_idx()

static ut16 omf_get_idx ( const ut8 *  buf, int  buf_size  )

static

Definition at line 61 of file omf.c.

                                                      {
    if (buf_size < 2) {
        return 0;
    }
    if (*buf & 0x80) {
        return (ut16)((*buf & 0x7f) * 0x100 + buf[1]);
    }
    return *buf;
}

References buf_size.

Referenced by load_omf_data(), load_omf_pubdef(), and load_omf_segdef().

rz_bin_checksum_omf_ok()

bool rz_bin_checksum_omf_ok	(	const ut8 *	buf,
		ut64	buf_size
	)

Definition at line 30 of file omf.c.

                                                           {
    ut16 size;
    ut8 checksum = 0;
 
    if (buf_size < 3) {
        RZ_LOG_ERROR("Invalid record (too short)\n");
        return false;
    }
    size = rz_read_le16(buf + 1);
    if (buf_size < size + 3) {
        RZ_LOG_ERROR("Invalid record (too short)\n");
        return false;
    }
    // Some compiler set checksum to 0
    if (!buf[size + 2]) {
        return true;
    }
    size += 3;
    for (; size; size--) {
        if (buf_size < size) {
            RZ_LOG_ERROR("Invalid record (too short)\n");
            return false;
        }
        checksum += buf[size - 1];
    }
    if (checksum) {
        // RZ_LOG_ERROR("Invalid record checksum\n");
    }
    return !checksum ? true : false;
}

References buf_size, RZ_LOG_ERROR, rz_read_le16(), and true.

Referenced by check_buffer(), and load_record_omf().

rz_bin_free_all_omf_obj()

void rz_bin_free_all_omf_obj

(

rz_bin_omf_obj *

obj

)

Definition at line 665 of file omf.c.

                                                  {
    if (obj) {
        if (obj->records) {
            free_all_omf_records(obj);
        }
        if (obj->sections) {
            free_all_omf_sections(obj);
        }
        if (obj->symbols) {
            free_all_omf_symbols(obj);
        }
        if (obj->names) {
            free_all_omf_names(obj);
        }
        free(obj);
    }
}

References free(), free_all_omf_names(), free_all_omf_records(), free_all_omf_sections(), free_all_omf_symbols(), rz_bin_omf_obj::names, rz_bin_omf_obj::records, rz_bin_omf_obj::sections, and rz_bin_omf_obj::symbols.

Referenced by destroy(), and rz_bin_internal_omf_load().

rz_bin_internal_omf_load()

rz_bin_omf_obj* rz_bin_internal_omf_load	(	const ut8 *	buf,
		ut64	size
	)

Definition at line 683 of file omf.c.

                                                                    {
    rz_bin_omf_obj *ret = NULL;
 
    if (!(ret = RZ_NEW0(rz_bin_omf_obj))) {
        return NULL;
    }
    if (!load_all_omf_records(ret, buf, size)) {
        rz_bin_free_all_omf_obj(ret);
        return NULL;
    }
    if (!(get_omf_infos(ret))) {
        rz_bin_free_all_omf_obj(ret);
        return NULL;
    }
    free_all_omf_records(ret);
    return ret;
}

References free_all_omf_records(), get_omf_infos(), load_all_omf_records(), NULL, rz_bin_free_all_omf_obj(), and RZ_NEW0.

Referenced by load_buffer().

rz_bin_omf_get_bits()

int rz_bin_omf_get_bits

(

rz_bin_omf_obj *

obj

)

Definition at line 731 of file omf.c.

                                             {
    ut32 ct_sec = 0;
    if (!obj) {
        return 32;
    }
 
    // we assume if one segdef define a 32 segment all opcodes are 32bits
    while (ct_sec < obj->nb_section) {
        if (obj->sections[ct_sec++]->bits == 32) {
            return 32;
        }
    }
    return 16;
}

References OMF_segment::bits, and rz_bin_omf_obj::sections.

Referenced by info().

rz_bin_omf_get_entry()

bool rz_bin_omf_get_entry	(	rz_bin_omf_obj *	obj,
		RzBinAddr *	addr
	)

Definition at line 701 of file omf.c.

                                                                {
    ut32 ct_sym = 0;
    OMF_data *data;
    ut32 offset = 0;
 
    if (!obj) {
        return false;
    }
    while (ct_sym < obj->nb_symbol) {
        if (!strcmp(obj->symbols[ct_sym]->name, "_start")) {
            if (obj->symbols[ct_sym]->seg_idx - 1 > obj->nb_section) {
                RZ_LOG_ERROR("Invalid segment index for symbol _start\n");
                return false;
            }
            addr->vaddr = obj->sections[obj->symbols[ct_sym]->seg_idx - 1]->vaddr + obj->symbols[ct_sym]->offset + OMF_BASE_ADDR;
            data = obj->sections[obj->symbols[ct_sym]->seg_idx - 1]->data;
            while (data) {
                offset += data->size;
                if (obj->symbols[ct_sym]->offset < offset) {
                    addr->paddr = (obj->symbols[ct_sym]->offset - data->offset) + data->paddr;
                    return true;
                }
                data = data->next;
            }
        }
        ct_sym++;
    }
    return false;
}

References addr, OMF_segment::data, OMF_symbol::name, rz_bin_omf_obj::nb_section, OMF_DATA::next, OMF_DATA::offset, OMF_symbol::offset, OMF_BASE_ADDR, OMF_DATA::paddr, RZ_LOG_ERROR, rz_bin_omf_obj::sections, OMF_symbol::seg_idx, OMF_DATA::size, rz_bin_omf_obj::symbols, and OMF_segment::vaddr.

Referenced by entries().

rz_bin_omf_get_paddr_sym()

ut64 rz_bin_omf_get_paddr_sym	(	rz_bin_omf_obj *	obj,
		OMF_symbol *	sym
	)

Definition at line 774 of file omf.c.

                                                                    {
    ut64 offset = 0;
    if (!obj->sections) {
        return 0LL;
    }
    if (sym->seg_idx - 1 > obj->nb_section) {
        return 0LL;
    }
    int sidx = sym->seg_idx - 1;
    if (sidx >= obj->nb_section) {
        return 0LL;
    }
    OMF_data *data = obj->sections[sidx]->data;
    while (data) {
        offset += data->size;
        if (sym->offset < offset) {
            return sym->offset - data->offset + data->paddr;
        }
        data = data->next;
    }
    return 0;
}

References OMF_segment::data, rz_bin_omf_obj::nb_section, OMF_DATA::next, OMF_DATA::offset, OMF_symbol::offset, OMF_DATA::paddr, rz_bin_omf_obj::sections, OMF_symbol::seg_idx, OMF_DATA::size, and ut64().

Referenced by symbols().

rz_bin_omf_get_vaddr_sym()

ut64 rz_bin_omf_get_vaddr_sym	(	rz_bin_omf_obj *	obj,
		OMF_symbol *	sym
	)

Definition at line 797 of file omf.c.

                                                                    {
    if (!obj->sections) {
        return 0LL;
    }
    if (sym->seg_idx >= obj->nb_section) {
        RZ_LOG_ERROR("Invalid segment index for symbol %s\n", sym->name);
        return 0;
    }
    if (sym->seg_idx == 0) {
        return 0;
    }
    return obj->sections[sym->seg_idx - 1]->vaddr + sym->offset + OMF_BASE_ADDR;
}

References OMF_symbol::name, rz_bin_omf_obj::nb_section, OMF_symbol::offset, OMF_BASE_ADDR, RZ_LOG_ERROR, rz_bin_omf_obj::sections, OMF_symbol::seg_idx, and OMF_segment::vaddr.

Referenced by symbols().

rz_bin_omf_send_sections()

int rz_bin_omf_send_sections	(	RzList *	list,
		OMF_segment *	section,
		rz_bin_omf_obj *	obj
	)

Definition at line 746 of file omf.c.

                                                                                      {
    RzBinSection *new;
    OMF_data *data = section->data;
    ut32 ct_name = 1;
 
    while (data) {
        if (!(new = RZ_NEW0(RzBinSection))) {
            return false;
        }
 
        // if index == 0, it's mean there is no name
        if (section->name_idx && section->name_idx - 1 < obj->nb_name) {
            new->name = rz_str_newf("%s_%d", obj->names[section->name_idx - 1], ct_name++);
        } else {
            new->name = rz_str_newf("no_name_%d", ct_name++);
        }
 
        new->size = data->size;
        new->vsize = data->size;
        new->paddr = data->paddr;
        new->vaddr = section->vaddr + data->offset + OMF_BASE_ADDR;
        new->perm = RZ_PERM_RWX;
        rz_list_append(list, new);
        data = data->next;
    }
    return true;
}

References list(), rz_bin_omf_obj::names, rz_bin_omf_obj::nb_name, OMF_DATA::next, OMF_DATA::offset, OMF_BASE_ADDR, OMF_DATA::paddr, rz_list_append(), RZ_NEW0, RZ_PERM_RWX, rz_str_newf(), and OMF_DATA::size.

Referenced by sections().