pdb.h File Reference

#include <rz_pdb.h>
#include "dbi.h"
#include "gdata.h"
#include "omap.h"
#include "stream_pe.h"
#include "tpi.h"

Go to the source code of this file.

Functions
RZ_IPI bool	parse_omap_stream (RzPdb *pdb, RzPdbMsfStream *stream)
RZ_IPI void	free_omap_stream (RzPdbOmapStream *stream)
RZ_IPI int	omap_remap (void *stream, int address)
RZ_IPI bool	parse_gdata_stream (RzPdb *pdb, RzPdbMsfStream *stream)
RZ_IPI void	free_gdata_stream (RzPdbGDataStream *stream)
RZ_IPI bool	parse_dbi_stream (RzPdb *pdb, RzPdbMsfStream *stream)
RZ_IPI void	free_dbi_stream (RzPdbDbiStream *stream)
RZ_IPI bool	parse_pe_stream (RzPdb *pdb, RzPdbMsfStream *stream)
RZ_IPI void	free_pe_stream (RzPdbPeStream *stream)
RZ_IPI bool	parse_tpi_stream (RzPdb *pdb, RzPdbMsfStream *stream)
RZ_IPI RzPdbTpiType *	parse_simple_type (RzPdbTpiStream *stream, ut32 idx)
	Parses simple type if the idx represents one. More...
RZ_IPI void	free_tpi_stream (RzPdbTpiStream *stream)

Function Documentation

free_dbi_stream()

RZ_IPI void free_dbi_stream

(

RzPdbDbiStream *

stream

)

Definition at line 7 of file dbi.c.

                                                    {
    if (!stream) {
        return;
    }
    RzPdbDbiStreamExHdr *ex_hdr;
    RzListIter *it;
    rz_list_foreach (stream->ex_hdrs, it, ex_hdr) {
        RZ_FREE(ex_hdr->ModuleName);
        RZ_FREE(ex_hdr->ObjFileName);
        RZ_FREE(ex_hdr);
    }
    rz_list_free(stream->ex_hdrs);
    free(stream);
}

References free(), dbi_stream_ex_header_t::ModuleName, dbi_stream_ex_header_t::ObjFileName, RZ_FREE, and rz_list_free().

Referenced by rz_bin_pdb_free().

free_gdata_stream()

RZ_IPI void free_gdata_stream

(

RzPdbGDataStream *

stream

)

Definition at line 80 of file gdata.c.

                                                        {
    if (!stream) {
        return;
    }
    GDataGlobal *global;
    RzListIter *it;
    rz_list_foreach (stream->global_list, it, global) {
        RZ_FREE(global->name);
        RZ_FREE(global);
    }
    rz_list_free(stream->global_list);
    free(stream);
}

References free(), GDataGlobal::name, RZ_FREE, and rz_list_free().

Referenced by rz_bin_pdb_free().

free_omap_stream()

RZ_IPI void free_omap_stream

(

RzPdbOmapStream *

stream

)

Definition at line 42 of file omap.c.

                                                      {
    if (!stream) {
        return;
    }
    OmapEntry *entry;
    RzListIter *it;
    rz_list_foreach (stream->entries, it, entry) { RZ_FREE(entry); }
    rz_list_free(stream->entries);
    free(stream);
}

References free(), RZ_FREE, and rz_list_free().

Referenced by rz_bin_pdb_free().

free_pe_stream()

RZ_IPI void free_pe_stream

(

RzPdbPeStream *

stream

)

Definition at line 53 of file stream_pe.c.

                                                  {
    if (!stream) {
        return;
    }
    rz_list_free(stream->sections_hdrs);
    free(stream);
};

References free(), and rz_list_free().

Referenced by rz_bin_pdb_free().

free_tpi_stream()

RZ_IPI void free_tpi_stream

(

RzPdbTpiStream *

stream

)

Definition at line 705 of file tpi.c.

                                                    {
    if (!stream) {
        return;
    }
    rz_rbtree_free(stream->types, free_tpi_rbtree, NULL);
    rz_list_free(stream->print_type);
    free(stream);
}

References free(), free_tpi_rbtree(), NULL, rz_list_free(), and rz_rbtree_free().

Referenced by rz_bin_pdb_free().

omap_remap()

RZ_IPI int omap_remap	(	void *	stream,
		int	address
	)

parse_dbi_stream()

RZ_IPI bool parse_dbi_stream	(	RzPdb *	pdb,
		RzPdbMsfStream *	stream
	)

Definition at line 151 of file dbi.c.

                                                                 {
    if (!pdb || !stream) {
        return false;
    }
    pdb->s_dbi = RZ_NEW0(RzPdbDbiStream);
    RzPdbDbiStream *s = pdb->s_dbi;
    if (!s) {
        RZ_LOG_ERROR("Error allocating memory.\n");
        return false;
    }
    RzBuffer *buf = stream->stream_data;
    // parse header
    if (!parse_dbi_stream_header(s, buf) || !parse_dbi_stream_ex_header(s, buf)) {
        return false;
    }
 
    // skip these streams
    ut64 seek = s->hdr.section_contribution_size + s->hdr.section_map_size +
        s->hdr.source_info_size + s->hdr.type_server_map_size +
        s->hdr.ec_substream_size;
    rz_buf_seek(buf, seek, RZ_BUF_CUR);
    if (!parse_dbi_dbg_header(s, buf)) {
        return false;
    }
    return true;
}

References parse_dbi_dbg_header(), parse_dbi_stream_ex_header(), parse_dbi_stream_header(), RZ_BUF_CUR, rz_buf_seek(), RZ_LOG_ERROR, RZ_NEW0, s, rz_pdb_t::s_dbi, seek(), and ut64().

Referenced by parse_streams().

parse_gdata_stream()

RZ_IPI bool parse_gdata_stream	(	RzPdb *	pdb,
		RzPdbMsfStream *	stream
	)

Definition at line 33 of file gdata.c.

                                                                   {
    rz_return_val_if_fail(pdb && stream, false);
    if (!pdb->s_gdata) {
        pdb->s_gdata = RZ_NEW0(RzPdbGDataStream);
    }
    RzPdbGDataStream *s = pdb->s_gdata;
    if (!s) {
        RZ_LOG_ERROR("Error allocating memory.\n");
        return false;
    }
    RzBuffer *buf = stream->stream_data;
    s->global_list = rz_list_new();
    if (!s->global_list) {
        return false;
    }
    ut16 len;
    while (true) {
        ut32 initial_seek = rz_buf_tell(buf);
        if (!rz_buf_read_le16(buf, &len)) {
            break;
        }
        if (len == 0 || len == UT16_MAX) {
            break;
        }
        ut16 leaf_type;
        if (!rz_buf_read_le16(buf, &leaf_type)) {
            return false;
        }
        if (leaf_type == 0x110E || leaf_type == 0x1009) {
            GDataGlobal *global = RZ_NEW0(GDataGlobal);
            if (!global) {
                goto skip;
            }
            global->leaf_type = leaf_type;
            if (!parse_gdata_global(global, buf, initial_seek)) {
                RZ_FREE(global);
                return false;
            }
            rz_list_append(s->global_list, global);
            continue;
        }
    skip:
        rz_buf_seek(buf, len - sizeof(ut16), RZ_BUF_CUR);
    }
    return true;
}

References GDataGlobal::leaf_type, len, parse_gdata_global(), RZ_BUF_CUR, rz_buf_read_le16, rz_buf_seek(), rz_buf_tell(), RZ_FREE, rz_list_append(), rz_list_new(), RZ_LOG_ERROR, RZ_NEW0, rz_return_val_if_fail, s, rz_pdb_t::s_gdata, skip(), and UT16_MAX.

Referenced by parse_streams().

parse_omap_stream()

RZ_IPI bool parse_omap_stream	(	RzPdb *	pdb,
		RzPdbMsfStream *	stream
	)

Definition at line 8 of file omap.c.

                                                                  {
    rz_return_val_if_fail(pdb && stream, false);
    if (!pdb->s_omap) {
        pdb->s_omap = RZ_NEW0(RzPdbOmapStream);
    }
    RzBuffer *buf = stream->stream_data;
    RzPdbOmapStream *s = pdb->s_omap;
    if (!s) {
        RZ_LOG_ERROR("Error allocating memory.\n");
        return false;
    }
    if (!s->entries) {
        s->entries = rz_list_new();
    }
    ut32 size = rz_buf_size(buf);
    ut32 read_len = 0;
    while (read_len < size) {
        OmapEntry *entry = RZ_NEW0(OmapEntry);
        if (!entry) {
            rz_list_free(s->entries);
            return false;
        }
        if (!rz_buf_read_le32(buf, &entry->from) ||
            !rz_buf_read_le32(buf, &entry->to)) {
            free(entry);
            rz_list_free(s->entries);
            return false;
        }
        read_len += sizeof(ut32) * 2;
        rz_list_append(s->entries, entry);
    }
    return true;
}

References free(), rz_buf_read_le32, rz_buf_size(), rz_list_append(), rz_list_free(), rz_list_new(), RZ_LOG_ERROR, RZ_NEW0, rz_return_val_if_fail, s, and rz_pdb_t::s_omap.

Referenced by parse_streams().

parse_pe_stream()

RZ_IPI bool parse_pe_stream	(	RzPdb *	pdb,
		RzPdbMsfStream *	stream
	)

Definition at line 20 of file stream_pe.c.

                                                                {
    rz_return_val_if_fail(pdb && stream, false);
    if (!pdb->s_pe) {
        pdb->s_pe = RZ_NEW0(RzPdbPeStream);
    }
    RzBuffer *buf = stream->stream_data;
    RzPdbPeStream *s = pdb->s_pe;
    if (!s) {
        RZ_LOG_ERROR("Error allocating memory.\n");
        return false;
    }
    if (!s->sections_hdrs) {
        s->sections_hdrs = rz_list_newf(free);
    }
    ut32 size = rz_buf_size(buf);
    ut32 read_len = 0;
    while (read_len < size) {
        PeImageSectionHeader *hdr = RZ_NEW0(PeImageSectionHeader);
        if (!hdr) {
            rz_list_free(s->sections_hdrs);
            return false;
        }
        if (!parse_image_header(hdr, buf)) {
            rz_list_free(s->sections_hdrs);
            free(hdr);
            return false;
        }
 
        read_len += sizeof(PeImageSectionHeader);
        rz_list_append(s->sections_hdrs, hdr);
    }
    return true;
}

References free(), parse_image_header(), rz_buf_size(), rz_list_append(), rz_list_free(), rz_list_newf(), RZ_LOG_ERROR, RZ_NEW0, rz_return_val_if_fail, s, and rz_pdb_t::s_pe.

Referenced by parse_streams().

parse_simple_type()

RZ_IPI RzPdbTpiType* parse_simple_type	(	RzPdbTpiStream *	stream,
		ut32	idx
	)

Parses simple type if the idx represents one.

Parameters

RzPdbTpiStream	TPI stream context
idx	leaf index

Returns

RzPdbTpiType, leaf_type = 0 -> error

Definition at line 142 of file tpi.c.

                                                                         {
    RzPdbTpiType *type = RZ_NEW0(RzPdbTpiType);
    if (!type) {
        RZ_LOG_ERROR("Error allocating memory.\n");
        return NULL;
    }
    type->leaf_type = LF_SIMPLE_TYPE;
    type->type_index = idx;
    // For simple type we don't set length
    type->length = 0;
    Tpi_LF_SimpleType *simple_type = RZ_NEW0(Tpi_LF_SimpleType);
    if (!simple_type) {
        RZ_LOG_ERROR("Error allocating memory.\n");
        free(type);
        return NULL;
    }
    type->type_data = simple_type;
    RzStrBuf *buf;
    TpiSimpleTypeKind kind = get_simple_type_kind(idx);
    switch (kind) {
    case PDB_NONE:
        simple_type->size = 0;
        buf = rz_strbuf_new("notype_t");
        break;
    case PDB_VOID:
        simple_type->size = 0;
        buf = rz_strbuf_new("void");
        break;
    case PDB_SIGNED_CHAR:
    case PDB_NARROW_CHAR:
        simple_type->size = 1;
        buf = rz_strbuf_new("char");
        break;
    case PDB_UNSIGNED_CHAR:
        simple_type->size = 1;
        buf = rz_strbuf_new("unsigned char");
        break;
    case PDB_WIDE_CHAR:
        simple_type->size = 4;
        buf = rz_strbuf_new("wchar_t");
        break;
    case PDB_CHAR16:
        simple_type->size = 2;
        buf = rz_strbuf_new("char16_t");
        break;
    case PDB_CHAR32:
        simple_type->size = 4;
        buf = rz_strbuf_new("char32_t");
        break;
    case PDB_BYTE:
        simple_type->size = 1;
        buf = rz_strbuf_new("uint8_t");
        break;
    case PDB_SBYTE:
        simple_type->size = 1;
        buf = rz_strbuf_new("int8_t");
        break;
    case PDB_INT16:
    case PDB_INT16_SHORT:
        simple_type->size = 2;
        buf = rz_strbuf_new("int16_t");
        break;
    case PDB_UINT16:
    case PDB_UINT16_SHORT:
        simple_type->size = 2;
        buf = rz_strbuf_new("uint16_t");
        break;
    case PDB_INT32:
    case PDB_INT32_LONG:
        simple_type->size = 4;
        buf = rz_strbuf_new("int32_t");
        break;
    case PDB_UINT32:
    case PDB_UINT32_LONG:
        simple_type->size = 4;
        buf = rz_strbuf_new("uint32_t");
        break;
    case PDB_INT64:
    case PDB_INT64_QUAD:
        simple_type->size = 8;
        buf = rz_strbuf_new("int64_t");
        break;
    case PDB_UINT64:
    case PDB_UINT64_QUAD:
        simple_type->size = 8;
        buf = rz_strbuf_new("uint64_t");
        break;
    case PDB_INT128:
    case PDB_INT128_OCT:
        simple_type->size = 16;
        buf = rz_strbuf_new("int128_t");
        break;
    case PDB_UINT128:
    case PDB_UINT128_OCT:
        simple_type->size = 16;
        buf = rz_strbuf_new("uint128_t");
        break;
    case PDB_FLOAT16:
        simple_type->size = 2;
        buf = rz_strbuf_new("float");
        break;
    case PDB_FLOAT32:
    case PDB_FLOAT32_PP:
        simple_type->size = 4;
        buf = rz_strbuf_new("float");
        break;
    case PDB_FLOAT48:
        simple_type->size = 6;
        buf = rz_strbuf_new("float");
        break;
    case PDB_FLOAT64:
        simple_type->size = 8;
        buf = rz_strbuf_new("double");
        break;
    case PDB_FLOAT80:
        simple_type->size = 10;
        buf = rz_strbuf_new("long double");
        break;
    case PDB_FLOAT128:
        simple_type->size = 16;
        buf = rz_strbuf_new("long double");
        break;
    case PDB_COMPLEX16:
        simple_type->size = 2;
        buf = rz_strbuf_new("float _Complex");
        break;
    case PDB_COMPLEX32:
    case PDB_COMPLEX32_PP:
        simple_type->size = 4;
        buf = rz_strbuf_new("float _Complex");
        break;
    case PDB_COMPLEX48:
        simple_type->size = 6;
        buf = rz_strbuf_new("float _Complex");
        break;
    case PDB_COMPLEX64:
        simple_type->size = 8;
        buf = rz_strbuf_new("double _Complex");
        break;
    case PDB_COMPLEX80:
        simple_type->size = 10;
        buf = rz_strbuf_new("long double _Complex");
        break;
    case PDB_COMPLEX128:
        simple_type->size = 16;
        buf = rz_strbuf_new("long double _Complex");
        break;
    case PDB_BOOL8:
        simple_type->size = 1;
        buf = rz_strbuf_new("bool");
        break;
    case PDB_BOOL16:
        simple_type->size = 2;
        buf = rz_strbuf_new("bool");
        break;
    case PDB_BOOL32:
        simple_type->size = 4;
        buf = rz_strbuf_new("bool");
        break;
    case PDB_BOOL64:
        simple_type->size = 8;
        buf = rz_strbuf_new("bool");
        break;
    case PDB_BOOL128:
        simple_type->size = 16;
        buf = rz_strbuf_new("bool");
        break;
    default:
        simple_type->size = 0;
        buf = rz_strbuf_new("unknown_t");
        break;
    }
    TpiSimpleTypeMode mode = get_simple_type_mode(idx);
    if (mode) {
        rz_strbuf_append(buf, " *");
    }
    switch (mode) {
    case NEAR_POINTER:
        simple_type->size = 2;
        break;
    case FAR_POINTER:
    case HUGE_POINTER:
    case NEAR_POINTER32:
    case FAR_POINTER32:
        simple_type->size = 4;
        break;
    case NEAR_POINTER64:
        simple_type->size = 8;
        break;
    case NEAR_POINTER128:
        simple_type->size = 16;
        break;
    default:
        break;
    }
    simple_type->type = rz_strbuf_drain(buf);
    // We just insert once
    rz_rbtree_insert(&stream->types, &type->type_index, &type->rb, tpi_type_node_cmp, NULL);
    return type;
}

References FAR_POINTER, FAR_POINTER32, free(), get_simple_type_kind(), get_simple_type_mode(), HUGE_POINTER, setup::idx, LF_SIMPLE_TYPE, NEAR_POINTER, NEAR_POINTER128, NEAR_POINTER32, NEAR_POINTER64, NULL, PDB_BOOL128, PDB_BOOL16, PDB_BOOL32, PDB_BOOL64, PDB_BOOL8, PDB_BYTE, PDB_CHAR16, PDB_CHAR32, PDB_COMPLEX128, PDB_COMPLEX16, PDB_COMPLEX32, PDB_COMPLEX32_PP, PDB_COMPLEX48, PDB_COMPLEX64, PDB_COMPLEX80, PDB_FLOAT128, PDB_FLOAT16, PDB_FLOAT32, PDB_FLOAT32_PP, PDB_FLOAT48, PDB_FLOAT64, PDB_FLOAT80, PDB_INT128, PDB_INT128_OCT, PDB_INT16, PDB_INT16_SHORT, PDB_INT32, PDB_INT32_LONG, PDB_INT64, PDB_INT64_QUAD, PDB_NARROW_CHAR, PDB_NONE, PDB_SBYTE, PDB_SIGNED_CHAR, PDB_UINT128, PDB_UINT128_OCT, PDB_UINT16, PDB_UINT16_SHORT, PDB_UINT32, PDB_UINT32_LONG, PDB_UINT64, PDB_UINT64_QUAD, PDB_UNSIGNED_CHAR, PDB_VOID, PDB_WIDE_CHAR, RZ_LOG_ERROR, RZ_NEW0, rz_rbtree_insert(), rz_strbuf_append(), rz_strbuf_drain(), rz_strbuf_new(), Tpi_LF_SimpleType::size, tpi_type_node_cmp(), type, and Tpi_LF_SimpleType::type.

Referenced by rz_bin_pdb_get_type_by_index().

parse_tpi_stream()

RZ_IPI bool parse_tpi_stream	(	RzPdb *	pdb,
		RzPdbMsfStream *	stream
	)

Definition at line 1799 of file tpi.c.

                                                                 {
    if (!pdb || !stream) {
        return false;
    }
    if (stream->stream_idx != PDB_STREAM_TPI) {
        RZ_LOG_ERROR("Error TPI stream index.\n");
        return false;
    }
    pdb->s_tpi = RZ_NEW0(RzPdbTpiStream);
    RzPdbTpiStream *s = pdb->s_tpi;
    if (!s) {
        RZ_LOG_ERROR("Error allocating memory.\n");
        return false;
    }
    s->types = NULL;
    RzBuffer *buf = stream->stream_data;
    if (!parse_tpi_stream_header(s, buf)) {
        return false;
    }
    if (s->header.HeaderSize != sizeof(RzPdbTpiStreamHeader)) {
        RZ_LOG_ERROR("Corrupted TPI stream.\n");
        return false;
    }
    RzPdbTpiType *type;
    for (ut32 i = s->header.TypeIndexBegin; i < s->header.TypeIndexEnd; i++) {
        type = RZ_NEW0(RzPdbTpiType);
        if (!type) {
            continue;
        }
        type->type_index = i;
        if (!parse_tpi_types(buf, type) || !type->type_data) {
            RZ_LOG_ERROR("Parse TPI type error. idx in stream: 0x%" PFMT32x "\n", i);
            RZ_FREE(type);
            return false;
        }
        rz_rbtree_insert(&s->types, &type->type_index, &type->rb, tpi_type_node_cmp, NULL);
    }
    return true;
}

References header, i, NULL, parse_tpi_stream_header(), parse_tpi_types(), PDB_STREAM_TPI, PFMT32x, RZ_FREE, RZ_LOG_ERROR, RZ_NEW0, rz_rbtree_insert(), s, rz_pdb_t::s_tpi, tpi_type_node_cmp(), and type.

Referenced by parse_streams().