htpef.cc

Go to the documentation of this file.

/* 
 *      HT Editor
 *      htpef.cc
 *
 *      Copyright (C) 1999-2002 Stefan Weyergraf (stefan@weyergraf.de)
 *
 *      This program is free software; you can redistribute it and/or modify
 *      it under the terms of the GNU General Public License version 2 as
 *      published by the Free Software Foundation.
 *
 *      This program is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *      GNU General Public License for more details.
 *
 *      You should have received a copy of the GNU General Public License
 *      along with this program; if not, write to the Free Software
 *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include "pefstruc.h"
#include "log.h"
#include "htpef.h"
#include "htpefhd.h"
#include "htpefimp.h"
#include "htpefimg.h"
#include "htendian.h"
#include "stream.h"
#include "tools.h"

#include <stdlib.h>

format_viewer_if *htpef_ifs[] = {
        &htpefheader_if,
        &htpefimports_if,
        &htpefimage_if,
        0
};

static ht_view *htpef_init(bounds *b, ht_streamfile *file, ht_format_group *format_group)
{
        byte id[12];
        file->seek(0);
        file->read(&id, sizeof id);
        if (memcmp(id, "Joy!peff", 8)) return NULL;
        PEF_ARCH arch;
        if (memcmp(id+8, "pwpc", 4) == 0) {
                arch = PEFARCH_PowerPC;
        } else if (memcmp(id+8, "m68k", 4) == 0) {
                arch = PEFARCH_M68K;
        } else return NULL;

        ht_pef *g = new ht_pef();
        g->init(b, file, htpef_ifs, format_group, 0);
        return g;
}

format_viewer_if htpef_if = {
        htpef_init,
        0
};

/*
 *      CLASS ht_pef
 */
void ht_pef::init(bounds *b, ht_streamfile *f, format_viewer_if **ifs, ht_format_group *format_group, FILEOFS header_ofs)
{
        ht_format_group::init(b, VO_SELECTABLE | VO_BROWSABLE | VO_RESIZE, DESC_PEF, f, false, true, 0, format_group);
        VIEW_DEBUG_NAME("ht_pef");

        LOG("%s: PEF: found header at %08x", file->get_filename(), header_ofs);

        ht_pef_shared_data *pef_shared=(ht_pef_shared_data *)malloc(sizeof(ht_pef_shared_data));
        memset(pef_shared, 0, sizeof *pef_shared);
        
        shared_data = pef_shared;
        /* always big-endian */
        pef_shared->byte_order = big_endian;
        pef_shared->header_ofs = 0;

        pef_shared->imports.funcs = new ht_clist();
        pef_shared->imports.funcs->init();

        pef_shared->imports.libs = new ht_clist();
        pef_shared->imports.libs->init();

        pef_shared->v_imports = NULL;
        
        /* read (container) header */
        file->seek(header_ofs);
        file->read(&pef_shared->contHeader, sizeof pef_shared->contHeader);
        create_host_struct(&pef_shared->contHeader, PEF_CONTAINER_HEADER_struct, pef_shared->byte_order);

        if (memcmp(pef_shared->contHeader.architecture, "pwpc", 4) == 0) {
                pef_shared->arch = PEFARCH_PowerPC;
        } else if (memcmp(pef_shared->contHeader.architecture, "m68k", 4) == 0) {
                pef_shared->arch = PEFARCH_M68K;
        } else return;

        /* read section headers */
        pef_shared->sheaders.count = pef_shared->contHeader.sectionCount;
        pef_shared->sheaders.sheaders = (PEF_SECTION_HEADER*)
                malloc(pef_shared->sheaders.count*sizeof (PEF_SECTION_HEADER));
        for (uint i=0; i<pef_shared->sheaders.count; i++) {
                file->read(&pef_shared->sheaders.sheaders[i], sizeof pef_shared->sheaders.sheaders[i]);
                create_host_struct(&pef_shared->sheaders.sheaders[i], PEF_SECTION_HEADER_struct, pef_shared->byte_order);
                // FIXME: hack
                pef_shared->sheaders.sheaders[i].defaultAddress = i*0x100000;
                if (!pef_shared->loader_info_header_ofs
                && pef_shared->sheaders.sheaders[i].sectionKind == PEF_SK_Loader) {
                        pef_shared->loader_info_header_ofs = pef_shared->sheaders.sheaders[i].containerOffset;
                }
        }

        if (pef_shared->loader_info_header_ofs) {
                file->seek(pef_shared->loader_info_header_ofs);
                file->read(&pef_shared->loader_info_header, sizeof pef_shared->loader_info_header);
                create_host_struct(&pef_shared->loader_info_header, PEF_LOADER_INFO_HEADER_struct, pef_shared->byte_order);
        }

        /* init ifs */
        ht_format_group::init_ifs(ifs);
}

void ht_pef::done()
{
        ht_format_group::done();
        
        ht_pef_shared_data *pef_shared = (ht_pef_shared_data*)shared_data;
        if (pef_shared->imports.funcs) {
                pef_shared->imports.funcs->destroy();
                delete pef_shared->imports.funcs;
        }
        if (pef_shared->imports.libs) {
                pef_shared->imports.libs->destroy();
                delete pef_shared->imports.libs;
        }
        free(shared_data);
}

#define RELOC_BASE              0x10000000
#define RELOC_STEPPING  0x100000
#define RELOC_LIMIT             0xffffffff
                        
/*static uint32 pef_invent_reloc_address(uint si, PEF_SECTION_HEADER *s, uint scount)
{
        elf32_addr a=RELOC_BASE;
        while (a<RELOC_LIMIT-s[si].sh_size) {
                bool ok=true;
                for (UINT i=0; i<scount; i++) {
                        if ((s[i].sh_type==ELF_SHT_PROGBITS) && (s[i].sh_addr) &&
                        ((a>=s[i].sh_addr) && (a<s[i].sh_addr+s[i].sh_size))) {
                                ok=false;
                                break;
                        }
                }
                if (ok) return a;
                a+=RELOC_STEPPING;
        }
        return 0;
}*/

/*
 *      address conversion routines
 */

bool pef_phys_and_mem_section(PEF_SECTION_HEADER *s)
{
        return (s->sectionKind <= 1) || (s->sectionKind == 3) || (s->sectionKind == 6);
}

bool pef_valid_section(PEF_SECTION_HEADER *s)
{
        return (s->sectionKind <= 3) || (s->sectionKind == 6);
}

bool pef_addr_to_ofs(pef_section_headers *section_headers, PEFAddress addr, dword *ofs)
{
        PEF_SECTION_HEADER *s = section_headers->sheaders;
        for (UINT i=0; i < section_headers->count; i++) {
                if ((pef_phys_and_mem_section(s)) &&
                (addr.a32 >= s->defaultAddress) && (addr.a32 < s->defaultAddress+s->packedSize)) {
                        *ofs = addr.a32 - s->defaultAddress + s->containerOffset;
                        return true;
                }
                s++;
        }
        return false;
}

bool pef_addr_to_section(pef_section_headers *section_headers, PEFAddress addr, int *section)
{
        PEF_SECTION_HEADER *s = section_headers->sheaders;
        for (UINT i = 0; i < section_headers->count; i++) {
                if ((pef_valid_section(s)) &&
                (addr.a32 >= s->defaultAddress) && (addr.a32 < s->defaultAddress + s->totalSize)) {
                        *section = i;
                        return true;
                }
                s++;
        }
        return false;
}

bool pef_addr_is_valid(pef_section_headers *section_headers, PEFAddress addr)
{
        PEF_SECTION_HEADER *s = section_headers->sheaders;
        for (UINT i=0; i<section_headers->count; i++) {
                if ((pef_valid_section(s)) &&
                (addr.a32 >= s->defaultAddress) && (addr.a32 < s->defaultAddress + s->totalSize)) {
                        return true;
                }
                s++;
        }
        return false;
}

/*
 *      offset conversion routines
 */

bool pef_ofs_to_addr(pef_section_headers *section_headers, dword ofs, PEFAddress *addr)
{
        PEF_SECTION_HEADER *s = section_headers->sheaders;
        for (UINT i = 0; i < section_headers->count; i++) {
                if ((pef_phys_and_mem_section(s)) &&
                (ofs>=s->containerOffset) && (ofs<s->containerOffset+s->packedSize)) {
                        addr->a32 = ofs - s->containerOffset + s->defaultAddress;
                        return true;
                }
                s++;
        }
        return false;
}

bool pef_ofs_to_section(pef_section_headers *section_headers, dword ofs, int *section)
{
        PEF_SECTION_HEADER *s=section_headers->sheaders;
        for (UINT i=0; i<section_headers->count; i++) {
                if ((pef_valid_section(s)) &&
                (ofs >= s->containerOffset) && (ofs<s->containerOffset+s->packedSize)) {
                        *section = i;
                        return true;
                }
                s++;
        }
        return false;
}

/*
 *      ht_pef_reloc_entry
 */
#include "relfile.h"
class ht_pef_reloc_entry: public Object {
public:
        
//      ht_elf32_reloc_entry(UINT symtabidx, elf32_addr offset, UINT type, UINT symbolidx, elf32_addr addend, ht_elf_shared_data *data, ht_streamfile *file);
};

/*
 *      ht_pef_reloc_file
 */

class ht_pef_reloc_file: public ht_reloc_file {
protected:
        ht_pef_shared_data *data;
/* overwritten */
        virtual void    reloc_apply(Object *reloc, byte *data);
        virtual bool    reloc_unapply(Object *reloc, byte *data);
public:

void init(ht_streamfile *s, bool own_s, ht_pef_shared_data *d)
{
        ht_reloc_file::init(s, own_s);
        data = d;
}

};

---