pdb.c File Reference

#include <rz_bin.h>
#include <rz_type.h>
#include <string.h>
#include <rz_demangler.h>
#include <mspack.h>
#include "pdb.h"

Go to the source code of this file.

Functions
static bool	parse_pdb_stream (RzPdb *pdb, RzPdbMsfStream *stream)
static bool	parse_streams (RzPdb *pdb)
static void	msf_stream_free (void *data)
static void	msf_stream_directory_free (void *data)
static ut64	count_blocks (ut64 length, ut64 block_size)
static RzList *	pdb7_extract_streams (RzPdb *pdb, RzPdbMsfStreamDirectory *msd)
static RzPdbMsfStreamDirectory *	pdb7_extract_msf_stream_directory (RzPdb *pdb)
static bool	pdb7_parse (RzPdb *pdb)
bool	is_compressed_pdb (RzBuffer *buf)
RZ_API RZ_OWN RzPdb *	rz_bin_pdb_parse_from_file (RZ_NONNULL const char *filename)
	Parse PDB file given the path. More...
RZ_API RZ_OWN RzPdb *	rz_bin_pdb_parse_from_buf (RZ_NONNULL const RzBuffer *buf)
	Parse PDB from the buffer. More...
RZ_API void	rz_bin_pdb_free (RzPdb *pdb)
	Free PDB instance. More...

Function Documentation

count_blocks()

static ut64 count_blocks ( ut64  length, ut64  block_size  )

static

Definition at line 105 of file pdb.c.

                                                       {
    ut64 num_blocks = 0;
    if (block_size > 0) {
        num_blocks = length / block_size;
        if (length % block_size) {
            num_blocks++;
        }
    }
    return num_blocks;
}

References length, and ut64().

Referenced by pdb7_extract_msf_stream_directory(), and pdb7_extract_streams().

is_compressed_pdb()

bool is_compressed_pdb

(

RzBuffer *

buf

)

Definition at line 275 of file pdb.c.

                                      {
    ut8 magic[4] = { 0 };
    // avoids to seek back, when using rz_buf_read_at
    if (rz_buf_read_at(buf, 0, magic, sizeof(magic)) != sizeof(magic)) {
        return false;
    } else if (memcmp(magic, CAB_SIGNATURE, sizeof(magic))) {
        return false;
    }
    return true;
}

References CAB_SIGNATURE, and rz_buf_read_at().

Referenced by rz_bin_pdb_parse_from_file().

msf_stream_directory_free()

static void msf_stream_directory_free ( void *  data )

static

Definition at line 98 of file pdb.c.

                                                  {
    RzPdbMsfStreamDirectory *msd = data;
    RZ_FREE(msd->StreamSizes);
    rz_buf_free(msd->sd);
    RZ_FREE(msd);
}

References rz_buf_free(), RZ_FREE, RzPdbMsfStreamDirectory::sd, and RzPdbMsfStreamDirectory::StreamSizes.

Referenced by pdb7_extract_streams(), and pdb7_parse().

msf_stream_free()

static void msf_stream_free ( void *  data )

static

Definition at line 92 of file pdb.c.

                                        {
    RzPdbMsfStream *msfstream = data;
    rz_buf_free(msfstream->stream_data);
    RZ_FREE(msfstream);
}

References rz_buf_free(), RZ_FREE, and RzPdbMsfStream::stream_data.

Referenced by pdb7_extract_streams().

parse_pdb_stream()

static bool parse_pdb_stream ( RzPdb *  pdb, RzPdbMsfStream *  stream  )

static

Definition at line 13 of file pdb.c.

                                                                 {
    if (!pdb || !stream) {
        return false;
    }
 
    pdb->s_pdb = RZ_NEW0(RzPdbStream);
    RzPdbStream *s = pdb->s_pdb;
    RzBuffer *buf = stream->stream_data;
    if (!rz_buf_read_le32(buf, &s->hdr.version) ||
        !rz_buf_read_le32(buf, &s->hdr.signature) ||
        !rz_buf_read_le32(buf, &s->hdr.age) ||
        !rz_buf_read_le32(buf, &s->hdr.unique_id.data1) ||
        !rz_buf_read_le16(buf, &s->hdr.unique_id.data2) ||
        !rz_buf_read_le16(buf, &s->hdr.unique_id.data3) ||
        rz_buf_read(buf, s->hdr.unique_id.data4, 8) != 8) {
        return false;
    }
 
    if (s->hdr.version != VC70) {
        RZ_LOG_ERROR("Error Unsupported PDB version.\n");
        return false;
    }
    return true;
}

References rz_buf_read(), rz_buf_read_le16, rz_buf_read_le32, RZ_LOG_ERROR, RZ_NEW0, s, rz_pdb_t::s_pdb, and VC70.

Referenced by parse_streams().

parse_streams()

static bool parse_streams ( RzPdb *  pdb )

static

Definition at line 38 of file pdb.c.

                                      {
    RzListIter *it;
    RzPdbMsfStream *ms;
    rz_list_foreach (pdb->streams, it, ms) {
        switch (ms->stream_idx) {
        case PDB_STREAM_ROOT:
            break;
        case PDB_STREAM_PDB:
            if (!parse_pdb_stream(pdb, ms)) {
                RZ_LOG_ERROR("Parse pdb stream failed.");
                return false;
            }
            break;
        case PDB_STREAM_TPI:
            if (!parse_tpi_stream(pdb, ms)) {
                RZ_LOG_ERROR("Parse tpi stream failed.");
                return false;
            }
            break;
        case PDB_STREAM_DBI:
            if (!parse_dbi_stream(pdb, ms)) {
                RZ_LOG_ERROR("Parse dbi stream failed.");
                return false;
            }
            break;
        default: {
            if (!pdb->s_dbi) {
                break;
            }
            if (ms->stream_idx == pdb->s_dbi->hdr.sym_record_stream) {
                if (!parse_gdata_stream(pdb, ms)) {
                    RZ_LOG_ERROR("Parse gdata stream failed.");
                    return false;
                }
            } else if (ms->stream_idx == pdb->s_dbi->dbg_hdr.sn_section_hdr ||
                ms->stream_idx == pdb->s_dbi->dbg_hdr.sn_section_hdr_orig) {
                if (!parse_pe_stream(pdb, ms)) {
                    RZ_LOG_ERROR("Parse pe stream failed.");
                    return false;
                }
            } else if (ms->stream_idx == pdb->s_dbi->dbg_hdr.sn_omap_to_src ||
                ms->stream_idx == pdb->s_dbi->dbg_hdr.sn_omap_from_src) {
                if (!parse_omap_stream(pdb, ms)) {
                    RZ_LOG_ERROR("Parse omap stream failed.");
                    return false;
                }
            }
            break;
        }
        }
    }
    return true;
}

References dbi_stream_t::dbg_hdr, dbi_stream_t::hdr, parse_dbi_stream(), parse_gdata_stream(), parse_omap_stream(), parse_pdb_stream(), parse_pe_stream(), parse_tpi_stream(), PDB_STREAM_DBI, PDB_STREAM_PDB, PDB_STREAM_ROOT, PDB_STREAM_TPI, RZ_LOG_ERROR, rz_pdb_t::s_dbi, RzPdbRzPdbDbiStreamDbgHeader::sn_omap_from_src, RzPdbRzPdbDbiStreamDbgHeader::sn_omap_to_src, RzPdbRzPdbDbiStreamDbgHeader::sn_section_hdr, RzPdbRzPdbDbiStreamDbgHeader::sn_section_hdr_orig, RzPdbMsfStream::stream_idx, rz_pdb_t::streams, and dbi_stream_header_t::sym_record_stream.

Referenced by pdb7_parse().

pdb7_extract_msf_stream_directory()

static RzPdbMsfStreamDirectory* pdb7_extract_msf_stream_directory ( RzPdb *  pdb )

static

Definition at line 170 of file pdb.c.

                                                                              {
    // Get block map
    ut32 block_num = count_blocks(pdb->super_block->num_directory_bytes, pdb->super_block->block_size);
    if (!block_num) {
        RZ_LOG_ERROR("Error block map size.\n");
        goto error;
    }
    rz_buf_seek(pdb->buf, (long long)pdb->super_block->block_size * pdb->super_block->block_map_addr, RZ_BUF_SET);
    ut32 *block_map = (ut32 *)malloc(sizeof(ut32) * block_num);
    if (!block_map) {
        goto error_memory;
    }
    for (size_t i = 0; i < block_num; i++) {
        ut32 block_idx;
        if (!rz_buf_read_le32(pdb->buf, &block_idx)) {
            RZ_FREE(block_map);
            goto error;
        }
        if (block_idx > pdb->super_block->num_blocks) {
            RZ_LOG_ERROR("Error block index.\n");
            RZ_FREE(block_map);
            goto error;
        }
        block_map[i] = block_idx;
    }
 
    ut32 stream_directory_len = block_num * pdb->super_block->block_size;
    ut8 *stream_directory = (ut8 *)malloc(stream_directory_len);
    if (!stream_directory) {
        RZ_FREE(block_map);
        goto error_memory;
    }
    for (size_t i = 0; i < block_num; i++) {
        rz_buf_seek(pdb->buf, (long long)block_map[i] * pdb->super_block->block_size, RZ_BUF_SET);
        rz_buf_read(pdb->buf, stream_directory + i * pdb->super_block->block_size, pdb->super_block->block_size);
    }
    RzBuffer *sd = rz_buf_new_with_pointers(stream_directory, stream_directory_len, true);
    if (!sd) {
        RZ_FREE(stream_directory);
        RZ_FREE(block_map);
        goto error_memory;
    }
    RZ_FREE(block_map);
 
    RzPdbMsfStreamDirectory *msd = RZ_NEW0(RzPdbMsfStreamDirectory);
    if (!msd) {
        goto error_memory;
    }
    if (!rz_buf_read_le32(sd, &msd->NumStreams)) {
        RZ_FREE(msd);
        goto error;
    }
    msd->StreamSizes = (ut32 *)malloc(msd->NumStreams * sizeof(ut32));
    msd->sd = sd;
    if (!msd->StreamSizes) {
        RZ_FREE(msd);
        goto error_memory;
    }
    ut32 total_blocks = 0;
    for (size_t i = 0; i < msd->NumStreams; i++) {
        ut32 stream_size;
        if (!rz_buf_read_le32(sd, &stream_size)) {
            RZ_FREE(msd);
            goto error;
        }
        if (stream_size == UT32_MAX) {
            msd->StreamSizes[i] = 0;
            continue;
        }
        msd->StreamSizes[i] = stream_size;
        ut32 blocks = count_blocks(stream_size, pdb->super_block->block_size);
        total_blocks += blocks;
    }
    //              NumStreams                      StreamsSizes                StreamsBlockMap
    ut32 msd_size = sizeof(ut32) + msd->NumStreams * sizeof(ut32) + total_blocks * sizeof(ut32);
    if (msd_size != pdb->super_block->num_directory_bytes) {
        RZ_LOG_ERROR("Error stream directory size.\n");
        RZ_FREE(msd);
        goto error;
    }
    return msd;
 
error_memory:
    RZ_LOG_ERROR("Error memory allocation.\n");
error:
    return NULL;
}

References RzPdbMsfSuperBlock::block_map_addr, RzPdbMsfSuperBlock::block_size, blocks, rz_pdb_t::buf, count_blocks(), error(), i, malloc(), NULL, RzPdbMsfSuperBlock::num_blocks, RzPdbMsfSuperBlock::num_directory_bytes, RzPdbMsfStreamDirectory::NumStreams, rz_buf_new_with_pointers(), rz_buf_read(), rz_buf_read_le32, rz_buf_seek(), RZ_BUF_SET, RZ_FREE, RZ_LOG_ERROR, RZ_NEW0, RzPdbMsfStreamDirectory::sd, RzPdbMsfStreamDirectory::StreamSizes, rz_pdb_t::super_block, and UT32_MAX.

Referenced by pdb7_parse().

pdb7_extract_streams()

static RzList* pdb7_extract_streams ( RzPdb *  pdb, RzPdbMsfStreamDirectory *  msd  )

static

Definition at line 116 of file pdb.c.

                                                                              {
    RzList *streams = rz_list_newf(msf_stream_free);
    if (!streams) {
        goto error_memory;
    }
    for (size_t i = 0; i < msd->NumStreams; i++) {
        RzPdbMsfStream *stream = RZ_NEW0(RzPdbMsfStream);
        if (!stream) {
            rz_list_free(streams);
            goto error_memory;
        }
        stream->stream_idx = i;
        stream->stream_size = msd->StreamSizes[i];
        stream->blocks_num = count_blocks(stream->stream_size, pdb->super_block->block_size);
        if (!stream->stream_size) {
            stream->stream_data = NULL;
            rz_list_append(streams, stream);
            continue;
        }
        ut8 *stream_data = (ut8 *)malloc((size_t)stream->blocks_num * pdb->super_block->block_size);
        if (!stream_data) {
            RZ_FREE(stream);
            rz_list_free(streams);
            RZ_LOG_ERROR("Error allocating memory.\n");
            return NULL;
        }
        for (size_t j = 0; j < stream->blocks_num; j++) {
            ut32 block_idx;
            if (!rz_buf_read_le32(msd->sd, &block_idx)) {
                RZ_FREE(stream);
                RZ_FREE(stream_data);
                rz_list_free(streams);
                return NULL;
            }
            rz_buf_seek(pdb->buf, (long long)block_idx * pdb->super_block->block_size, RZ_BUF_SET);
            rz_buf_read(pdb->buf, stream_data + j * pdb->super_block->block_size, pdb->super_block->block_size);
        }
        stream->stream_data = rz_buf_new_with_pointers(stream_data, stream->stream_size, true);
        if (!stream->stream_data) {
            RZ_FREE(stream);
            RZ_FREE(stream_data);
            rz_list_free(streams);
            goto error_memory;
        }
        rz_list_append(streams, stream);
    }
    msf_stream_directory_free(msd);
    return streams;
 
error_memory:
    RZ_LOG_ERROR("Error memory allocation.\n");
    return NULL;
}

References RzPdbMsfSuperBlock::block_size, rz_pdb_t::buf, count_blocks(), i, malloc(), msf_stream_directory_free(), msf_stream_free(), NULL, RzPdbMsfStreamDirectory::NumStreams, rz_buf_new_with_pointers(), rz_buf_read(), rz_buf_read_le32, rz_buf_seek(), RZ_BUF_SET, RZ_FREE, rz_list_append(), rz_list_free(), rz_list_newf(), RZ_LOG_ERROR, RZ_NEW0, RzPdbMsfStreamDirectory::sd, streams, RzPdbMsfStreamDirectory::StreamSizes, and rz_pdb_t::super_block.

Referenced by pdb7_parse().

pdb7_parse()

static bool pdb7_parse ( RzPdb *  pdb )

static

Definition at line 258 of file pdb.c.

                                   {
    RzPdbMsfStreamDirectory *msd = pdb7_extract_msf_stream_directory(pdb);
    if (!msd) {
        RZ_LOG_ERROR("Error extracting stream directory.\n");
        goto error;
    }
    pdb->streams = pdb7_extract_streams(pdb, msd);
    if (!pdb->streams) {
        msf_stream_directory_free(msd);
        RZ_LOG_ERROR("Error extracting streams.\n");
        goto error;
    }
    return parse_streams(pdb);
error:
    return false;
}

References error(), msf_stream_directory_free(), parse_streams(), pdb7_extract_msf_stream_directory(), pdb7_extract_streams(), RZ_LOG_ERROR, and rz_pdb_t::streams.

Referenced by rz_bin_pdb_parse_from_buf().

rz_bin_pdb_free()

RZ_API void rz_bin_pdb_free

(

RzPdb *

pdb

)

Free PDB instance.

Parameters

pdb	PDB instance

Returns

void

Definition at line 366 of file pdb.c.

                                        {
    if (!pdb) {
        return;
    }
    rz_buf_free(pdb->buf);
    free(pdb->super_block);
    rz_list_free(pdb->streams);
    free(pdb->s_pdb);
    free_dbi_stream(pdb->s_dbi);
    free_gdata_stream(pdb->s_gdata);
    free_omap_stream(pdb->s_omap);
    free_tpi_stream(pdb->s_tpi);
    free_pe_stream(pdb->s_pe);
    free(pdb);
}

References rz_pdb_t::buf, free(), free_dbi_stream(), free_gdata_stream(), free_omap_stream(), free_pe_stream(), free_tpi_stream(), rz_buf_free(), rz_list_free(), rz_pdb_t::s_dbi, rz_pdb_t::s_gdata, rz_pdb_t::s_omap, rz_pdb_t::s_pdb, rz_pdb_t::s_pe, rz_pdb_t::s_tpi, rz_pdb_t::streams, and rz_pdb_t::super_block.

Referenced by GetHeapGlobalsOffset(), rz_bin_pdb_parse_from_buf(), rz_cmd_info_pdb_show_handler(), rz_core_bin_pdb_load(), and rz_core_bin_print().

rz_bin_pdb_parse_from_buf()

RZ_API RZ_OWN RzPdb* rz_bin_pdb_parse_from_buf

(

RZ_NONNULL const RzBuffer *

buf

)

Parse PDB from the buffer.

Parameters

buf	mmap of the PDB file

Returns

RzPdb *

Definition at line 315 of file pdb.c.

                                                                               {
    rz_return_val_if_fail(buf, NULL);
    RzPdb *pdb = RZ_NEW0(RzPdb);
    if (!pdb) {
        goto error;
    }
    pdb->buf = (RzBuffer *)buf;
    pdb->super_block = RZ_NEW0(RzPdbMsfSuperBlock);
    st64 len = rz_buf_read(pdb->buf, (ut8 *)pdb->super_block->file_magic, PDB_SIGNATURE_LEN);
    if (len != PDB_SIGNATURE_LEN) {
        RZ_LOG_ERROR("Wrong magic length!\n");
        goto error;
    }
    if (memcmp(pdb->super_block->file_magic, PDB_SIGNATURE, PDB_SIGNATURE_LEN)) {
        RZ_LOG_ERROR("PDB Signature Error!\n");
        goto error;
    }
    if (!rz_buf_read_le32(pdb->buf, &pdb->super_block->block_size) ||
        !rz_buf_read_le32(pdb->buf, &pdb->super_block->free_block_map_block) ||
        !rz_buf_read_le32(pdb->buf, &pdb->super_block->num_blocks) ||
        !rz_buf_read_le32(pdb->buf, &pdb->super_block->num_directory_bytes) ||
        !rz_buf_read_le32(pdb->buf, &pdb->super_block->unknown) ||
        !rz_buf_read_le32(pdb->buf, &pdb->super_block->block_map_addr)) {
        goto error;
    }
    ut64 bufsize = rz_buf_size((RzBuffer *)buf); // length of whole PDB file
    bool valid =
        pdb->super_block->num_blocks > 0 &&
        (ut64)pdb->super_block->num_blocks * pdb->super_block->block_size == bufsize &&
        pdb->super_block->free_block_map_block < pdb->super_block->num_blocks &&
        pdb->super_block->num_directory_bytes > 0;
    if (!valid) {
        RZ_LOG_ERROR("Invalid MSF superblock!\n");
        goto error;
    }
    if (!pdb7_parse(pdb)) {
        goto error;
    }
    return pdb;
error:
 
    rz_bin_pdb_free(pdb);
    return NULL;
}

References RzPdbMsfSuperBlock::block_map_addr, RzPdbMsfSuperBlock::block_size, rz_pdb_t::buf, error(), RzPdbMsfSuperBlock::file_magic, RzPdbMsfSuperBlock::free_block_map_block, if(), len, NULL, RzPdbMsfSuperBlock::num_blocks, RzPdbMsfSuperBlock::num_directory_bytes, pdb7_parse(), PDB_SIGNATURE, PDB_SIGNATURE_LEN, rz_bin_pdb_free(), rz_buf_read(), rz_buf_read_le32, rz_buf_size(), RZ_LOG_ERROR, RZ_NEW0, rz_return_val_if_fail, st64, rz_pdb_t::super_block, RzPdbMsfSuperBlock::unknown, ut64(), and valid.

Referenced by rz_bin_pdb_parse_from_file().

rz_bin_pdb_parse_from_file()

RZ_API RZ_OWN RzPdb* rz_bin_pdb_parse_from_file

(

RZ_NONNULL const char *

filename

)

Parse PDB file given the path.

Parameters

filename

path of the PDB file

Returns

RzPdb *

Definition at line 292 of file pdb.c.

                                                                                 {
    rz_return_val_if_fail(filename, NULL);
    RzBuffer *buf = rz_buf_new_slurp(filename);
    if (!buf) {
        RZ_LOG_ERROR("%s: Error reading file \"%s\"\n", __FUNCTION__, filename);
        return false;
    }
 
    if (is_compressed_pdb(buf)) {
        rz_buf_free(buf);
        RZ_LOG_ERROR("The pdb file %s seems to be compressed, please use idpx command to extract the contents.\n", filename);
        return NULL;
    }
 
    return rz_bin_pdb_parse_from_buf(buf);
}

References is_compressed_pdb(), NULL, rz_bin_pdb_parse_from_buf(), rz_buf_free(), rz_buf_new_slurp(), RZ_LOG_ERROR, and rz_return_val_if_fail.

Referenced by GetHeapGlobalsOffset(), and rz_core_pdb_load_info().