pe.c

Go to the documentation of this file.

 
#include <ntifs.h>
#include <ndk/ntndk.h>
#include <reactos/rossym.h>
#include "rossympriv.h"
#include <ntimage.h>
 
#define NDEBUG
#include <debug.h>
 
#include "dwarf.h"
#include "pe.h"
#include "rossympriv.h"
 
PeSect *pesection(Pe *pe, const char *name)
{
    int i;
    ANSI_STRING WantName;
    RtlInitAnsiString(&WantName, name);
    DPRINT("Searching for section %s\n", name);
    for (i = 0; i < pe->nsections; i++) {
        PANSI_STRING AnsiString = ANSI_NAME_STRING(&pe->sect[i]);
        if (WantName.Length == AnsiString->Length &&
            !memcmp(AnsiString->Buffer, name, WantName.Length)) {
            DPRINT("Found %s (%d) @ %x (%x)\n", name, i,
                   ((PCHAR)pe->imagebase)+pe->sect[i].VirtualAddress,
                   pe->sect[i].SizeOfRawData);
            return &pe->sect[i];
        }
    }
    DPRINT("%s not found\n", name);
    return nil;
}
 
u16int peget2(const unsigned char *ptr) {
    return *((u16int*)ptr);
}
 
u32int peget4(const unsigned char *ptr) {
    return *((u32int*)ptr);
}
 
u64int peget8(const unsigned char *ptr) {
    return *((u64int*)ptr);
}
 
int readn(void *filectx, char *buffer, ulong size) {
    return RosSymReadFile(filectx, buffer, size);
}
 
int seek(void *filectx, ulong position, int origin) {
    assert(origin == 0);
    return RosSymSeekFile(filectx, position);
}
 
static int
readblock(void *fd, DwarfBlock *b, ulong off, ulong len)
{
    b->data = malloc(len);
    if(b->data == nil)
        return -1;
    if(!seek(fd, off, 0) || !readn(fd, (char *)b->data, len)){
        free(b->data);
        b->data = nil;
        return -1;
    }
    b->len = len;
    return 0;
}
 
int
loaddisksection(Pe *pe, char *name, DwarfBlock *b)
{
    PeSect *s;
    if((s = pesection(pe, name)) == nil)
        return -1;
    return readblock(pe->fd, b, s->PointerToRawData, s->SizeOfRawData);
}
 
int
loadmemsection(Pe *pe, char *name, DwarfBlock *b)
{
    PeSect *s;
 
    if((s = pesection(pe, name)) == nil)
        return -1;
    DPRINT("Loading section %s (ImageBase %x RVA %x)\n", name, pe->fd, s->VirtualAddress);
    b->data = RosSymAllocMem(s->SizeOfRawData);
    b->len = s->SizeOfRawData;
    PCHAR DataSource = ((char *)pe->fd) + s->VirtualAddress;
    DPRINT("Copying to %x from %x (%x)\n", DataSource, b->data, b->len);
    RtlCopyMemory(b->data, DataSource, s->SizeOfRawData);
 
    return s->SizeOfRawData;
}
 
void *RosSymAllocMemZero(ulong size, ulong count) {
    void *res = RosSymAllocMem(size * count);
    if (res) memset(res, 0, size * count);
    return res;
}
 
int GetStrnlen(const char *string, int maxlen) {
    int i;
    for (i = 0; i < maxlen && string[i]; i++);
    return i;
}
 
void pefree(Pe *pe) {
    int i;
    for (i = 0; i < pe->nsections; i++) {
        RtlFreeAnsiString(ANSI_NAME_STRING(&pe->sect[i]));
    }
    for (i = 0; i < pe->nsymbols; i++) {
        free(pe->symtab[i].name);
    }
    free(pe->symtab);
    free(pe->sect);
    free(pe);
}
 
void xfree(void *v) {
    if (v) RosSymFreeMem(v);
}
 
ulong pefindrva(struct _IMAGE_SECTION_HEADER *SectionHeaders, int NumberOfSections, ulong TargetPhysical) {
    int i;
    DPRINT("Finding RVA for Physical %x\n", TargetPhysical);
    for (i = 0; i < NumberOfSections; i++) {
        DPRINT("Section %d name %s Raw %x Virt %x\n",
               i,
               ANSI_NAME_STRING(&SectionHeaders[i])->Buffer,
               SectionHeaders[i].PointerToRawData,
               SectionHeaders[i].VirtualAddress);
        if (TargetPhysical >= SectionHeaders[i].PointerToRawData &&
            TargetPhysical < SectionHeaders[i].PointerToRawData + SectionHeaders[i].SizeOfRawData) {
            DPRINT("RVA %x\n", TargetPhysical - SectionHeaders[i].PointerToRawData + SectionHeaders[i].VirtualAddress);
            return TargetPhysical - SectionHeaders[i].PointerToRawData + SectionHeaders[i].VirtualAddress;
        }
    }
    return nil;
}