ldrEx.cpp revision 13493ab7596e827b8d0caab2c89e635dd65f78f9
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync/* $Id$ */
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync/** @file
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync * IPRT - Binary Image Loader, Extended Features.
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync */
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync/*
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync * Copyright (C) 2006-2013 Oracle Corporation
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync *
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync * This file is part of VirtualBox Open Source Edition (OSE), as
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync * available from http://www.virtualbox.org. This file is free software;
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync * you can redistribute it and/or modify it under the terms of the GNU
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync * General Public License (GPL) as published by the Free Software
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync * Foundation, in version 2 as it comes in the "COPYING" file of the
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync *
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync * The contents of this file may alternatively be used under the terms
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync * of the Common Development and Distribution License Version 1.0
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync * VirtualBox OSE distribution, in which case the provisions of the
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync * CDDL are applicable instead of those of the GPL.
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync *
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync * You may elect to license modified versions of this file under the
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync * terms and conditions of either the GPL or the CDDL or both.
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync */
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync/*******************************************************************************
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync* Header Files *
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync*******************************************************************************/
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync#define LOG_GROUP RTLOGGROUP_LDR
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync#include <iprt/ldr.h>
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync#include "internal/iprt.h"
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync#include <iprt/assert.h>
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync#include <iprt/err.h>
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync#include <iprt/log.h>
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync#include <iprt/md5.h>
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync#include <iprt/mem.h>
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync#include <iprt/sha.h>
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync#include <iprt/string.h>
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync#include "internal/ldr.h"
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync#include "internal/ldrMZ.h"
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync#ifdef LDR_ONLY_PE
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync# undef LDR_WITH_PE
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync# undef LDR_WITH_KLDR
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync# undef LDR_WITH_ELF
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync# undef LDR_WITH_LX
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync# undef LDR_WITH_LE
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync# undef LDR_WITH_NE
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync# undef LDR_WITH_MZ
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync# undef LDR_WITH_AOUT
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync# define LDR_WITH_PE
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync#endif
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsyncRTDECL(int) RTLdrOpenWithReader(PRTLDRREADER pReader, uint32_t fFlags, RTLDRARCH enmArch, PRTLDRMOD phMod, PRTERRINFO pErrInfo)
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync{
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync /*
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync * Resolve RTLDRARCH_HOST.
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync */
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync if (enmArch == RTLDRARCH_HOST)
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync#if defined(RT_ARCH_AMD64)
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync enmArch = RTLDRARCH_AMD64;
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync#elif defined(RT_ARCH_X86)
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync enmArch = RTLDRARCH_X86_32;
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync#else
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync enmArch = RTLDRARCH_WHATEVER;
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync#endif
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync /*
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync * Read and verify the file signature.
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync */
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync union
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync {
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync char ach[4];
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync uint16_t au16[2];
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync uint32_t u32;
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync } uSign;
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync int rc = pReader->pfnRead(pReader, &uSign, sizeof(uSign), 0);
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync if (RT_FAILURE(rc))
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync return rc;
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync#ifndef LDR_WITH_KLDR
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync if ( uSign.au16[0] != IMAGE_DOS_SIGNATURE
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync && uSign.u32 != IMAGE_NT_SIGNATURE
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync && uSign.u32 != IMAGE_ELF_SIGNATURE
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync && uSign.au16[0] != IMAGE_LX_SIGNATURE)
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync {
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync Log(("rtldrOpenWithReader: %s: unknown magic %#x / '%.4s\n", pReader->pfnLogName(pReader), uSign.u32, &uSign.ach[0]));
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync return VERR_INVALID_EXE_SIGNATURE;
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync }
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync#endif
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync uint32_t offHdr = 0;
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync if (uSign.au16[0] == IMAGE_DOS_SIGNATURE)
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync {
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync rc = pReader->pfnRead(pReader, &offHdr, sizeof(offHdr), RT_OFFSETOF(IMAGE_DOS_HEADER, e_lfanew));
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync if (RT_FAILURE(rc))
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync return rc;
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync if (offHdr <= sizeof(IMAGE_DOS_HEADER))
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync {
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync Log(("rtldrOpenWithReader: %s: no new header / invalid offset %#RX32\n", pReader->pfnLogName(pReader), offHdr));
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync return VERR_INVALID_EXE_SIGNATURE;
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync }
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync rc = pReader->pfnRead(pReader, &uSign, sizeof(uSign), offHdr);
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync if (RT_FAILURE(rc))
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync return rc;
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync if ( uSign.u32 != IMAGE_NT_SIGNATURE
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync && uSign.au16[0] != IMAGE_LX_SIGNATURE
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync && uSign.au16[0] != IMAGE_LE_SIGNATURE
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync && uSign.au16[0] != IMAGE_NE_SIGNATURE)
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync {
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync Log(("rtldrOpenWithReader: %s: unknown new magic %#x / '%.4s\n", pReader->pfnLogName(pReader), uSign.u32, &uSign.ach[0]));
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync return VERR_INVALID_EXE_SIGNATURE;
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync }
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync }
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync /*
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync * Create image interpreter instance depending on the signature.
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync */
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync if (uSign.u32 == IMAGE_NT_SIGNATURE)
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync#ifdef LDR_WITH_PE
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync rc = rtldrPEOpen(pReader, fFlags, enmArch, offHdr, phMod, pErrInfo);
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync#else
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync rc = VERR_PE_EXE_NOT_SUPPORTED;
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync#endif
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync else if (uSign.u32 == IMAGE_ELF_SIGNATURE)
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync#if defined(LDR_WITH_ELF)
320484435d67c1fb90dca3e8836d81bf939c8ba2vboxsync rc = rtldrELFOpen(pReader, fFlags, enmArch, phMod, pErrInfo);
#else
rc = VERR_ELF_EXE_NOT_SUPPORTED;
#endif
else if (uSign.au16[0] == IMAGE_LX_SIGNATURE)
#ifdef LDR_WITH_LX
rc = rtldrLXOpen(pReader, fFlags, enmArch, offHdr, phMod, pErrInfo);
#else
rc = VERR_LX_EXE_NOT_SUPPORTED;
#endif
else if (uSign.au16[0] == IMAGE_LE_SIGNATURE)
#ifdef LDR_WITH_LE
rc = rtldrLEOpen(pReader, fFlags, enmArch, phMod, pErrInfo);
#else
rc = VERR_LE_EXE_NOT_SUPPORTED;
#endif
else if (uSign.au16[0] == IMAGE_NE_SIGNATURE)
#ifdef LDR_WITH_NE
rc = rtldrNEOpen(pReader, fFlags, enmArch, phMod, pErrInfo);
#else
rc = VERR_NE_EXE_NOT_SUPPORTED;
#endif
else if (uSign.au16[0] == IMAGE_DOS_SIGNATURE)
#ifdef LDR_WITH_MZ
rc = rtldrMZOpen(pReader, fFlags, enmArch, phMod, pErrInfo);
#else
rc = VERR_MZ_EXE_NOT_SUPPORTED;
#endif
else if (/* uSign.u32 == IMAGE_AOUT_A_SIGNATURE
|| uSign.u32 == IMAGE_AOUT_Z_SIGNATURE*/ /** @todo find the aout magics in emx or binutils. */
0)
#ifdef LDR_WITH_AOUT
rc = rtldrAOUTOpen(pReader, fFlags, enmArch, phMod, pErrInfo);
#else
rc = VERR_AOUT_EXE_NOT_SUPPORTED;
#endif
else
{
#ifndef LDR_WITH_KLDR
Log(("rtldrOpenWithReader: %s: the format isn't implemented %#x / '%.4s\n", pReader->pfnLogName(pReader), uSign.u32, &uSign.ach[0]));
#endif
rc = VERR_INVALID_EXE_SIGNATURE;
}
#ifdef LDR_WITH_KLDR
/* Try kLdr if it's a format we don't recognize. */
if (rc <= VERR_INVALID_EXE_SIGNATURE && rc > VERR_BAD_EXE_FORMAT)
{
int rc2 = rtldrkLdrOpen(pReader, fFlags, enmArch, phMod, pErrInfo);
if (rc2 == VERR_MZ_EXE_NOT_SUPPORTED) /* Quick fix for bad return code. */
rc = rc;
}
#endif
LogFlow(("rtldrOpenWithReader: %s: returns %Rrc *phMod=%p\n", pReader->pfnLogName(pReader), rc, *phMod));
return rc;
}
RTDECL(size_t) RTLdrSize(RTLDRMOD hLdrMod)
{
LogFlow(("RTLdrSize: hLdrMod=%RTldrm\n", hLdrMod));
/*
* Validate input.
*/
AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), ~(size_t)0);
PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), ~(size_t)0);
/*
* Do it.
*/
size_t cb = pMod->pOps->pfnGetImageSize(pMod);
LogFlow(("RTLdrSize: returns %zu\n", cb));
return cb;
}
RT_EXPORT_SYMBOL(RTLdrSize);
/**
* Loads the image into a buffer provided by the user and applies fixups
* for the given base address.
*
* @returns iprt status code.
* @param hLdrMod The load module handle.
* @param pvBits Where to put the bits.
* Must be as large as RTLdrSize() suggests.
* @param BaseAddress The base address.
* @param pfnGetImport Callback function for resolving imports one by one.
* @param pvUser User argument for the callback.
* @remark Not supported for RTLdrLoad() images.
*/
RTDECL(int) RTLdrGetBits(RTLDRMOD hLdrMod, void *pvBits, RTLDRADDR BaseAddress, PFNRTLDRIMPORT pfnGetImport, void *pvUser)
{
LogFlow(("RTLdrGetBits: hLdrMod=%RTldrm pvBits=%p BaseAddress=%RTptr pfnGetImport=%p pvUser=%p\n",
hLdrMod, pvBits, BaseAddress, pfnGetImport, pvUser));
/*
* Validate input.
*/
AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
AssertMsgReturn(VALID_PTR(pvBits), ("pvBits=%p\n", pvBits), VERR_INVALID_PARAMETER);
AssertMsgReturn(VALID_PTR(pfnGetImport), ("pfnGetImport=%p\n", pfnGetImport), VERR_INVALID_PARAMETER);
PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER);
/*
* Do it.
*/
int rc = pMod->pOps->pfnGetBits(pMod, pvBits, BaseAddress, pfnGetImport, pvUser);
LogFlow(("RTLdrGetBits: returns %Rrc\n",rc));
return rc;
}
RT_EXPORT_SYMBOL(RTLdrGetBits);
/**
* Relocates bits after getting them.
* Useful for code which moves around a bit.
*
* @returns iprt status code.
* @param hLdrMod The loader module handle.
* @param pvBits Where the image bits are.
* Must have been passed to RTLdrGetBits().
* @param NewBaseAddress The new base address.
* @param OldBaseAddress The old base address.
* @param pfnGetImport Callback function for resolving imports one by one.
* @param pvUser User argument for the callback.
* @remark Not supported for RTLdrLoad() images.
*/
RTDECL(int) RTLdrRelocate(RTLDRMOD hLdrMod, void *pvBits, RTLDRADDR NewBaseAddress, RTLDRADDR OldBaseAddress,
PFNRTLDRIMPORT pfnGetImport, void *pvUser)
{
LogFlow(("RTLdrRelocate: hLdrMod=%RTldrm pvBits=%p NewBaseAddress=%RTptr OldBaseAddress=%RTptr pfnGetImport=%p pvUser=%p\n",
hLdrMod, pvBits, NewBaseAddress, OldBaseAddress, pfnGetImport, pvUser));
/*
* Validate input.
*/
AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
AssertMsgReturn(VALID_PTR(pvBits), ("pvBits=%p\n", pvBits), VERR_INVALID_PARAMETER);
AssertMsgReturn(VALID_PTR(pfnGetImport), ("pfnGetImport=%p\n", pfnGetImport), VERR_INVALID_PARAMETER);
PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER);
/*
* Do it.
*/
int rc = pMod->pOps->pfnRelocate(pMod, pvBits, NewBaseAddress, OldBaseAddress, pfnGetImport, pvUser);
LogFlow(("RTLdrRelocate: returns %Rrc\n", rc));
return rc;
}
RT_EXPORT_SYMBOL(RTLdrRelocate);
/**
* Gets the address of a named exported symbol.
*
* This function differs from the plain one in that it can deal with
* both GC and HC address sizes, and that it can calculate the symbol
* value relative to any given base address.
*
* @returns iprt status code.
* @param hLdrMod The loader module handle.
* @param pvBits Optional pointer to the loaded image.
* Set this to NULL if no RTLdrGetBits() processed image bits are available.
* Not supported for RTLdrLoad() images and must be NULL.
* @param BaseAddress Image load address.
* Not supported for RTLdrLoad() images and must be 0.
* @param pszSymbol Symbol name.
* @param pValue Where to store the symbol value.
*/
RTDECL(int) RTLdrGetSymbolEx(RTLDRMOD hLdrMod, const void *pvBits, RTLDRADDR BaseAddress, const char *pszSymbol,
PRTLDRADDR pValue)
{
LogFlow(("RTLdrGetSymbolEx: hLdrMod=%RTldrm pvBits=%p BaseAddress=%RTptr pszSymbol=%p:{%s} pValue\n",
hLdrMod, pvBits, BaseAddress, pszSymbol, pszSymbol, pValue));
/*
* Validate input.
*/
AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
AssertMsgReturn(!pvBits || VALID_PTR(pvBits), ("pvBits=%p\n", pvBits), VERR_INVALID_PARAMETER);
AssertMsgReturn(pszSymbol, ("pszSymbol=%p\n", pszSymbol), VERR_INVALID_PARAMETER);
AssertMsgReturn(VALID_PTR(pValue), ("pValue=%p\n", pvBits), VERR_INVALID_PARAMETER);
PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
//AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER);
/*
* Do it.
*/
int rc;
if (pMod->pOps->pfnGetSymbolEx)
rc = pMod->pOps->pfnGetSymbolEx(pMod, pvBits, BaseAddress, pszSymbol, pValue);
else if (!BaseAddress && !pvBits)
{
void *pvValue;
rc = pMod->pOps->pfnGetSymbol(pMod, pszSymbol, &pvValue);
if (RT_SUCCESS(rc))
*pValue = (uintptr_t)pvValue;
}
else
AssertMsgFailedReturn(("BaseAddress=%RTptr pvBits=%p\n", BaseAddress, pvBits), VERR_INVALID_FUNCTION);
LogFlow(("RTLdrGetSymbolEx: returns %Rrc *pValue=%p\n", rc, *pValue));
return rc;
}
RT_EXPORT_SYMBOL(RTLdrGetSymbolEx);
/**
* Enumerates all symbols in a module.
*
* @returns iprt status code.
* @param hLdrMod The loader module handle.
* @param fFlags Flags indicating what to return and such.
* @param pvBits Optional pointer to the loaded image.
* Set this to NULL if no RTLdrGetBits() processed image bits are available.
* @param BaseAddress Image load address.
* @param pfnCallback Callback function.
* @param pvUser User argument for the callback.
* @remark Not supported for RTLdrLoad() images.
*/
RTDECL(int) RTLdrEnumSymbols(RTLDRMOD hLdrMod, unsigned fFlags, const void *pvBits, RTLDRADDR BaseAddress,
PFNRTLDRENUMSYMS pfnCallback, void *pvUser)
{
LogFlow(("RTLdrEnumSymbols: hLdrMod=%RTldrm fFlags=%#x pvBits=%p BaseAddress=%RTptr pfnCallback=%p pvUser=%p\n",
hLdrMod, fFlags, pvBits, BaseAddress, pfnCallback, pvUser));
/*
* Validate input.
*/
AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
AssertMsgReturn(!pvBits || VALID_PTR(pvBits), ("pvBits=%p\n", pvBits), VERR_INVALID_PARAMETER);
AssertMsgReturn(VALID_PTR(pfnCallback), ("pfnCallback=%p\n", pfnCallback), VERR_INVALID_PARAMETER);
PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
//AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER);
/*
* Do it.
*/
int rc = pMod->pOps->pfnEnumSymbols(pMod, fFlags, pvBits, BaseAddress, pfnCallback, pvUser);
LogFlow(("RTLdrEnumSymbols: returns %Rrc\n", rc));
return rc;
}
RT_EXPORT_SYMBOL(RTLdrEnumSymbols);
RTDECL(int) RTLdrEnumDbgInfo(RTLDRMOD hLdrMod, const void *pvBits, PFNRTLDRENUMDBG pfnCallback, void *pvUser)
{
LogFlow(("RTLdrEnumDbgInfo: hLdrMod=%RTldrm pvBits=%p pfnCallback=%p pvUser=%p\n",
hLdrMod, pvBits, pfnCallback, pvUser));
/*
* Validate input.
*/
AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
AssertMsgReturn(!pvBits || RT_VALID_PTR(pvBits), ("pvBits=%p\n", pvBits), VERR_INVALID_PARAMETER);
AssertMsgReturn(RT_VALID_PTR(pfnCallback), ("pfnCallback=%p\n", pfnCallback), VERR_INVALID_PARAMETER);
PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
//AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER);
/*
* Do it.
*/
int rc;
if (pMod->pOps->pfnEnumDbgInfo)
rc = pMod->pOps->pfnEnumDbgInfo(pMod, pvBits, pfnCallback, pvUser);
else
rc = VERR_NOT_SUPPORTED;
LogFlow(("RTLdrEnumDbgInfo: returns %Rrc\n", rc));
return rc;
}
RT_EXPORT_SYMBOL(RTLdrEnumDbgInfo);
RTDECL(int) RTLdrEnumSegments(RTLDRMOD hLdrMod, PFNRTLDRENUMSEGS pfnCallback, void *pvUser)
{
LogFlow(("RTLdrEnumSegments: hLdrMod=%RTldrm pfnCallback=%p pvUser=%p\n",
hLdrMod, pfnCallback, pvUser));
/*
* Validate input.
*/
AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
AssertMsgReturn(RT_VALID_PTR(pfnCallback), ("pfnCallback=%p\n", pfnCallback), VERR_INVALID_PARAMETER);
PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
//AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER);
/*
* Do it.
*/
int rc;
if (pMod->pOps->pfnEnumSegments)
rc = pMod->pOps->pfnEnumSegments(pMod, pfnCallback, pvUser);
else
rc = VERR_NOT_SUPPORTED;
LogFlow(("RTLdrEnumSegments: returns %Rrc\n", rc));
return rc;
}
RT_EXPORT_SYMBOL(RTLdrEnumSegments);
RTDECL(int) RTLdrLinkAddressToSegOffset(RTLDRMOD hLdrMod, RTLDRADDR LinkAddress, uint32_t *piSeg, PRTLDRADDR poffSeg)
{
LogFlow(("RTLdrLinkAddressToSegOffset: hLdrMod=%RTldrm LinkAddress=%RTptr piSeg=%p poffSeg=%p\n",
hLdrMod, LinkAddress, piSeg, poffSeg));
/*
* Validate input.
*/
AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
AssertPtrReturn(piSeg, VERR_INVALID_POINTER);
AssertPtrReturn(poffSeg, VERR_INVALID_POINTER);
PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
//AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER);
*piSeg = UINT32_MAX;
*poffSeg = ~(RTLDRADDR)0;
/*
* Do it.
*/
int rc;
if (pMod->pOps->pfnLinkAddressToSegOffset)
rc = pMod->pOps->pfnLinkAddressToSegOffset(pMod, LinkAddress, piSeg, poffSeg);
else
rc = VERR_NOT_SUPPORTED;
LogFlow(("RTLdrLinkAddressToSegOffset: returns %Rrc %#x:%RTptr\n", rc, *piSeg, *poffSeg));
return rc;
}
RT_EXPORT_SYMBOL(RTLdrLinkAddressToSegOffset);
RTDECL(int) RTLdrLinkAddressToRva(RTLDRMOD hLdrMod, RTLDRADDR LinkAddress, PRTLDRADDR pRva)
{
LogFlow(("RTLdrLinkAddressToRva: hLdrMod=%RTldrm LinkAddress=%RTptr pRva=%p\n",
hLdrMod, LinkAddress, pRva));
/*
* Validate input.
*/
AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
AssertPtrReturn(pRva, VERR_INVALID_POINTER);
PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
//AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER);
*pRva = ~(RTLDRADDR)0;
/*
* Do it.
*/
int rc;
if (pMod->pOps->pfnLinkAddressToRva)
rc = pMod->pOps->pfnLinkAddressToRva(pMod, LinkAddress, pRva);
else
rc = VERR_NOT_SUPPORTED;
LogFlow(("RTLdrLinkAddressToRva: returns %Rrc %RTptr\n", rc, *pRva));
return rc;
}
RT_EXPORT_SYMBOL(RTLdrLinkAddressToRva);
RTDECL(int) RTLdrSegOffsetToRva(RTLDRMOD hLdrMod, uint32_t iSeg, RTLDRADDR offSeg, PRTLDRADDR pRva)
{
LogFlow(("RTLdrSegOffsetToRva: hLdrMod=%RTldrm LinkAddress=%RTptr iSeg=%#x offSeg=%RTptr pRva=%p\n",
hLdrMod, iSeg, offSeg, pRva));
/*
* Validate input.
*/
AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
AssertPtrReturn(pRva, VERR_INVALID_POINTER);
PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
//AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER);
*pRva = ~(RTLDRADDR)0;
/*
* Do it.
*/
int rc;
if (pMod->pOps->pfnSegOffsetToRva)
rc = pMod->pOps->pfnSegOffsetToRva(pMod, iSeg, offSeg, pRva);
else
rc = VERR_NOT_SUPPORTED;
LogFlow(("RTLdrSegOffsetToRva: returns %Rrc %RTptr\n", rc, *pRva));
return rc;
}
RT_EXPORT_SYMBOL(RTLdrSegOffsetToRva);
RTDECL(int) RTLdrRvaToSegOffset(RTLDRMOD hLdrMod, RTLDRADDR Rva, uint32_t *piSeg, PRTLDRADDR poffSeg)
{
LogFlow(("RTLdrRvaToSegOffset: hLdrMod=%RTldrm Rva=%RTptr piSeg=%p poffSeg=%p\n",
hLdrMod, Rva, piSeg, poffSeg));
/*
* Validate input.
*/
AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
AssertPtrReturn(piSeg, VERR_INVALID_POINTER);
AssertPtrReturn(poffSeg, VERR_INVALID_POINTER);
PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
//AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER);
*piSeg = UINT32_MAX;
*poffSeg = ~(RTLDRADDR)0;
/*
* Do it.
*/
int rc;
if (pMod->pOps->pfnRvaToSegOffset)
rc = pMod->pOps->pfnRvaToSegOffset(pMod, Rva, piSeg, poffSeg);
else
rc = VERR_NOT_SUPPORTED;
LogFlow(("RTLdrRvaToSegOffset: returns %Rrc %#x:%RTptr\n", rc, *piSeg, *poffSeg));
return rc;
}
RT_EXPORT_SYMBOL(RTLdrRvaToSegOffset);
RTDECL(int) RTLdrQueryProp(RTLDRMOD hLdrMod, RTLDRPROP enmProp, void *pvBuf, size_t cbBuf)
{
return RTLdrQueryPropEx(hLdrMod, enmProp, pvBuf, cbBuf, NULL);
}
RT_EXPORT_SYMBOL(RTLdrQueryProp);
RTDECL(int) RTLdrQueryPropEx(RTLDRMOD hLdrMod, RTLDRPROP enmProp, void *pvBuf, size_t cbBuf, size_t *pcbRet)
{
AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), RTLDRENDIAN_INVALID);
PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
AssertPtrNullReturn(pcbRet, VERR_INVALID_POINTER);
size_t cbRet;
if (!pcbRet)
pcbRet = &cbRet;
/*
* Do some pre screening of the input
*/
switch (enmProp)
{
case RTLDRPROP_UUID:
*pcbRet = sizeof(RTUUID);
AssertReturn(cbBuf == sizeof(RTUUID), VERR_INVALID_PARAMETER);
break;
case RTLDRPROP_TIMESTAMP_SECONDS:
*pcbRet = sizeof(int64_t);
AssertReturn(cbBuf == sizeof(int32_t) || cbBuf == sizeof(int64_t), VERR_INVALID_PARAMETER);
break;
case RTLDRPROP_IS_SIGNED:
*pcbRet = sizeof(bool);
AssertReturn(cbBuf == sizeof(bool), VERR_INVALID_PARAMETER);
break;
case RTLDRPROP_PKCS7_SIGNED_DATA:
*pcbRet = 0;
break;
case RTLDRPROP_SIGNATURE_CHECKS_ENFORCED:
*pcbRet = sizeof(bool);
AssertReturn(cbBuf == sizeof(bool), VERR_INVALID_PARAMETER);
break;
default:
AssertFailedReturn(VERR_INVALID_FUNCTION);
}
AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
/*
* Call the image specific worker, if there is one.
*/
if (!pMod->pOps->pfnQueryProp)
return VERR_NOT_SUPPORTED;
return pMod->pOps->pfnQueryProp(pMod, enmProp, pvBuf, cbBuf, pcbRet);
}
RT_EXPORT_SYMBOL(RTLdrQueryPropEx);
RTDECL(int) RTLdrVerifySignature(RTLDRMOD hLdrMod, PFNRTLDRVALIDATESIGNEDDATA pfnCallback, void *pvUser, PRTERRINFO pErrInfo)
{
AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
AssertPtrReturn(pfnCallback, VERR_INVALID_POINTER);
/*
* Call the image specific worker, if there is one.
*/
if (!pMod->pOps->pfnVerifySignature)
return VERR_NOT_SUPPORTED;
return pMod->pOps->pfnVerifySignature(pMod, pfnCallback, pvUser, pErrInfo);
}
RT_EXPORT_SYMBOL(RTLdrVerifySignature);
RTDECL(int) RTLdrHashImage(RTLDRMOD hLdrMod, RTDIGESTTYPE enmDigest, char *pszDigest, size_t cbDigest)
{
AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
/*
* Make sure there is sufficient space for the wanted digest and that
* it's supported.
*/
switch (enmDigest)
{
case RTDIGESTTYPE_MD5: AssertReturn(cbDigest >= RTMD5_DIGEST_LEN + 1, VERR_BUFFER_OVERFLOW); break;
case RTDIGESTTYPE_SHA1: AssertReturn(cbDigest >= RTSHA1_DIGEST_LEN + 1, VERR_BUFFER_OVERFLOW); break;
case RTDIGESTTYPE_SHA256: AssertReturn(cbDigest >= RTSHA256_DIGEST_LEN + 1, VERR_BUFFER_OVERFLOW); break;
case RTDIGESTTYPE_SHA512: AssertReturn(cbDigest >= RTSHA512_DIGEST_LEN + 1, VERR_BUFFER_OVERFLOW); break;
default:
if (enmDigest > RTDIGESTTYPE_INVALID && enmDigest < RTDIGESTTYPE_END)
return VERR_NOT_SUPPORTED;
AssertFailedReturn(VERR_INVALID_PARAMETER);
}
AssertPtrReturn(pszDigest, VERR_INVALID_POINTER);
/*
* Call the image specific worker, if there is one.
*/
if (!pMod->pOps->pfnHashImage)
return VERR_NOT_SUPPORTED;
return pMod->pOps->pfnHashImage(pMod, enmDigest, pszDigest, cbDigest);
}
RT_EXPORT_SYMBOL(RTLdrHashImage);
/**
* Internal method used by the IPRT debug bits.
*
* @returns IPRT status code.
* @param hLdrMod The loader handle which executable we wish to
* read from.
* @param pvBuf The output buffer.
* @param iDbgInfo The debug info ordinal number if the request
* corresponds exactly to a debug info part from
* pfnEnumDbgInfo. Otherwise, pass UINT32_MAX.
* @param off Where in the executable file to start reading.
* @param cb The number of bytes to read.
*
* @remarks Fixups will only be applied if @a iDbgInfo is specified.
*/
DECLHIDDEN(int) rtLdrReadAt(RTLDRMOD hLdrMod, void *pvBuf, uint32_t iDbgInfo, RTFOFF off, size_t cb)
{
AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
if (iDbgInfo != UINT32_MAX)
{
AssertReturn(pMod->pOps->pfnReadDbgInfo, VERR_NOT_SUPPORTED);
return pMod->pOps->pfnReadDbgInfo(pMod, iDbgInfo, off, cb, pvBuf);
}
AssertReturn(pMod->pReader, VERR_NOT_SUPPORTED);
return pMod->pReader->pfnRead(pMod->pReader, pvBuf, cb, off);
}