VirtualBox

source: vbox/trunk/src/VBox/Runtime/ldrEx.cpp@ 4953

Last change on this file since 4953 was 4071, checked in by vboxsync, 17 years ago

Biggest check-in ever. New source code headers for all (C) innotek files.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 12.7 KB
Line 
1/* $Id: ldrEx.cpp 4071 2007-08-07 17:07:59Z vboxsync $ */
2/** @file
3 * innotek Portable Runtime - Binary Image Loader, Extended Features.
4 */
5
6/*
7 * Copyright (C) 2006-2007 innotek GmbH
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License as published by the Free Software Foundation,
13 * in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
14 * distribution. VirtualBox OSE is distributed in the hope that it will
15 * be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18
19/*******************************************************************************
20* Header Files *
21*******************************************************************************/
22#define LOG_GROUP RTLOGGROUP_LDR
23#include <iprt/ldr.h>
24#include <iprt/alloc.h>
25#include <iprt/assert.h>
26#include <iprt/log.h>
27#include <iprt/string.h>
28#include <iprt/err.h>
29#include "internal/ldr.h"
30#include "internal/ldrMZ.h"
31
32
33/**
34 * Open part with reader.
35 *
36 * @returns iprt status code.
37 * @param pReader The loader reader instance which will provide the raw image bits.
38 * @param phMod Where to store the handle.
39 */
40int rtldrOpenWithReader(PRTLDRREADER pReader, PRTLDRMOD phMod)
41{
42 /*
43 * Read and verify the file signature.
44 */
45 union
46 {
47 char ach[4];
48 uint16_t au16[2];
49 uint32_t u32;
50 } uSign;
51 int rc = pReader->pfnRead(pReader, &uSign, sizeof(uSign), 0);
52 if (RT_FAILURE(rc))
53 return rc;
54#ifndef LDR_WITH_KLDR
55 if ( uSign.au16[0] != IMAGE_DOS_SIGNATURE
56 && uSign.u32 != IMAGE_NT_SIGNATURE
57 && uSign.u32 != IMAGE_ELF_SIGNATURE
58 && uSign.au16[0] != IMAGE_LX_SIGNATURE)
59 {
60 Log(("rtldrOpenWithReader: %s: unknown magic %#x / '%.4s\n", pReader->pfnLogName(pReader), uSign.u32, &uSign.ach[0]));
61 return VERR_INVALID_EXE_SIGNATURE;
62 }
63#endif
64 uint32_t offHdr = 0;
65 if (uSign.au16[0] == IMAGE_DOS_SIGNATURE)
66 {
67 rc = pReader->pfnRead(pReader, &offHdr, sizeof(offHdr), RT_OFFSETOF(IMAGE_DOS_HEADER, e_lfanew));
68 if (RT_FAILURE(rc))
69 return rc;
70
71 if (offHdr <= sizeof(IMAGE_DOS_HEADER))
72 {
73 Log(("rtldrOpenWithReader: %s: no new header / invalid offset %#RX32\n", pReader->pfnLogName(pReader), offHdr));
74 return VERR_INVALID_EXE_SIGNATURE;
75 }
76 rc = pReader->pfnRead(pReader, &uSign, sizeof(uSign), offHdr);
77 if (RT_FAILURE(rc))
78 return rc;
79 if ( uSign.u32 != IMAGE_NT_SIGNATURE
80 && uSign.au16[0] != IMAGE_LX_SIGNATURE
81 && uSign.au16[0] != IMAGE_LE_SIGNATURE
82 && uSign.au16[0] != IMAGE_NE_SIGNATURE)
83 {
84 Log(("rtldrOpenWithReader: %s: unknown new magic %#x / '%.4s\n", pReader->pfnLogName(pReader), uSign.u32, &uSign.ach[0]));
85 return VERR_INVALID_EXE_SIGNATURE;
86 }
87 }
88
89 /*
90 * Create image intepreter instance depending on the signature.
91 */
92 if (uSign.u32 == IMAGE_NT_SIGNATURE)
93#ifdef LDR_WITH_PE
94 rc = rtldrPEOpen(pReader, offHdr, phMod);
95#else
96 rc = VERR_PE_EXE_NOT_SUPPORTED;
97#endif
98 else if (uSign.u32 == IMAGE_ELF_SIGNATURE)
99#if defined(LDR_WITH_ELF)
100 rc = rtldrELFOpen(pReader, phMod);
101#else
102 rc = VERR_ELF_EXE_NOT_SUPPORTED;
103#endif
104 else if (uSign.au16[0] == IMAGE_LX_SIGNATURE)
105#ifdef LDR_WITH_LX
106 rc = rtldrLXOpen(pReader, offHdr, phMod);
107#else
108 rc = VERR_LX_EXE_NOT_SUPPORTED;
109#endif
110 else if (uSign.au16[0] == IMAGE_LE_SIGNATURE)
111#ifdef LDR_WITH_LE
112 rc = rtldrLEOpen(pReader, phMod);
113#else
114 rc = VERR_LE_EXE_NOT_SUPPORTED;
115#endif
116 else if (uSign.au16[0] == IMAGE_NE_SIGNATURE)
117#ifdef LDR_WITH_NE
118 rc = rtldrNEOpen(pReader, phMod);
119#else
120 rc = VERR_NE_EXE_NOT_SUPPORTED;
121#endif
122 else if (uSign.au16[0] == IMAGE_DOS_SIGNATURE)
123#ifdef LDR_WITH_MZ
124 rc = rtldrMZOpen(pReader, phMod);
125#else
126 rc = VERR_MZ_EXE_NOT_SUPPORTED;
127#endif
128 else if (/* uSign.u32 == IMAGE_AOUT_A_SIGNATURE
129 || uSign.u32 == IMAGE_AOUT_Z_SIGNATURE*/ /** @todo find the aout magics in emx or binutils. */
130 0)
131#ifdef LDR_WITH_AOUT
132 rc = rtldrAOUTOpen(pReader, phMod);
133#else
134 rc = VERR_AOUT_EXE_NOT_SUPPORTED;
135#endif
136 else
137 {
138#ifndef LDR_WITH_KLDR
139 Log(("rtldrOpenWithReader: %s: the format isn't implemented %#x / '%.4s\n", pReader->pfnLogName(pReader), uSign.u32, &uSign.ach[0]));
140#endif
141 rc = VERR_INVALID_EXE_SIGNATURE;
142 }
143
144#ifdef LDR_WITH_KLDR
145 /* Try kLdr if it's a format we don't recognize. */
146 if (rc <= VERR_INVALID_EXE_SIGNATURE && rc > VERR_BAD_EXE_FORMAT)
147 rc = rtldrkLdrOpen(pReader, phMod);
148#endif
149
150 LogFlow(("rtldrOpenWithReader: %s: returns %Rrc *phMod=%p\n", pReader->pfnLogName(pReader), rc, *phMod));
151 return rc;
152}
153
154
155/**
156 * Gets the size of the loaded image.
157 * This is only supported for modules which has been opened using RTLdrOpen() and RTLdrOpenBits().
158 *
159 * @returns image size (in bytes).
160 * @returns ~(size_t)0 on if not opened by RTLdrOpen().
161 * @param hLdrMod Handle to the loader module.
162 * @remark Not supported for RTLdrLoad() images.
163 */
164RTDECL(size_t) RTLdrSize(RTLDRMOD hLdrMod)
165{
166 LogFlow(("RTLdrSize: hLdrMod=%RTldrm\n", hLdrMod));
167
168 /*
169 * Validate input.
170 */
171 AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), ~(size_t)0);
172 PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
173 AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), ~(size_t)0);
174
175 /*
176 * Do it.
177 */
178 size_t cb = pMod->pOps->pfnGetImageSize(pMod);
179 LogFlow(("RTLdrSize: returns %zu\n", cb));
180 return cb;
181}
182
183
184/**
185 * Loads the image into a buffer provided by the user and applies fixups
186 * for the given base address.
187 *
188 * @returns iprt status code.
189 * @param hLdrMod The load module handle.
190 * @param pvBits Where to put the bits.
191 * Must be as large as RTLdrSize() suggests.
192 * @param BaseAddress The base address.
193 * @param pfnGetImport Callback function for resolving imports one by one.
194 * @param pvUser User argument for the callback.
195 * @remark Not supported for RTLdrLoad() images.
196 */
197RTDECL(int) RTLdrGetBits(RTLDRMOD hLdrMod, void *pvBits, RTUINTPTR BaseAddress, PFNRTLDRIMPORT pfnGetImport, void *pvUser)
198{
199 LogFlow(("RTLdrGetBits: hLdrMod=%RTldrm pvBits=%p BaseAddress=%RTptr pfnGetImport=%p pvUser=%p\n",
200 hLdrMod, pvBits, BaseAddress, pfnGetImport, pvUser));
201
202 /*
203 * Validate input.
204 */
205 AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
206 AssertMsgReturn(VALID_PTR(pvBits), ("pvBits=%p\n", pvBits), VERR_INVALID_PARAMETER);
207 AssertMsgReturn(VALID_PTR(pfnGetImport), ("pfnGetImport=%p\n", pfnGetImport), VERR_INVALID_PARAMETER);
208 PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
209 AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER);
210
211 /*
212 * Do it.
213 */
214 int rc = pMod->pOps->pfnGetBits(pMod, pvBits, BaseAddress, pfnGetImport, pvUser);
215 LogFlow(("RTLdrGetBits: returns %Rrc\n",rc));
216 return rc;
217}
218
219
220/**
221 * Relocates bits after getting them.
222 * Useful for code which moves around a bit.
223 *
224 * @returns iprt status code.
225 * @param hLdrMod The loader module handle.
226 * @param pvBits Where the image bits are.
227 * Must've been passed to RTLdrGetBits().
228 * @param NewBaseAddress The new base address.
229 * @param OldBaseAddress The old base address.
230 * @param pfnGetImport Callback function for resolving imports one by one.
231 * @param pvUser User argument for the callback.
232 * @remark Not supported for RTLdrLoad() images.
233 */
234RTDECL(int) RTLdrRelocate(RTLDRMOD hLdrMod, void *pvBits, RTUINTPTR NewBaseAddress, RTUINTPTR OldBaseAddress,
235 PFNRTLDRIMPORT pfnGetImport, void *pvUser)
236{
237 LogFlow(("RTLdrRelocate: hLdrMod=%RTldrm pvBits=%p NewBaseAddress=%RTptr OldBaseAddress=%RTptr pfnGetImport=%p pvUser=%p\n",
238 hLdrMod, pvBits, NewBaseAddress, OldBaseAddress, pfnGetImport, pvUser));
239
240 /*
241 * Validate input.
242 */
243 AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
244 AssertMsgReturn(VALID_PTR(pvBits), ("pvBits=%p\n", pvBits), VERR_INVALID_PARAMETER);
245 AssertMsgReturn(VALID_PTR(pfnGetImport), ("pfnGetImport=%p\n", pfnGetImport), VERR_INVALID_PARAMETER);
246 PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
247 AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER);
248
249 /*
250 * Do it.
251 */
252 int rc = pMod->pOps->pfnRelocate(pMod, pvBits, NewBaseAddress, OldBaseAddress, pfnGetImport, pvUser);
253 LogFlow(("RTLdrRelocate: returns %Vrc\n", rc));
254 return rc;
255}
256
257
258/**
259 * Gets the address of a named exported symbol.
260 *
261 * This function differs from the plain one in that it can deal with
262 * both GC and HC address sizes, and that it can calculate the symbol
263 * value relative to any given base address.
264 *
265 * @returns iprt status code.
266 * @param hLdrMod The loader module handle.
267 * @param pvBits Optional pointer to the loaded image.
268 * Set this to NULL if no RTLdrGetBits() processed image bits are available.
269 * Not supported for RTLdrLoad() images and must be NULL.
270 * @param BaseAddress Image load address.
271 * Not supported for RTLdrLoad() images and must be 0.
272 * @param pszSymbol Symbol name.
273 * @param pValue Where to store the symbol value.
274 */
275RTDECL(int) RTLdrGetSymbolEx(RTLDRMOD hLdrMod, const void *pvBits, RTUINTPTR BaseAddress, const char *pszSymbol, RTUINTPTR *pValue)
276{
277 LogFlow(("RTLdrGetSymbolEx: hLdrMod=%RTldrm pvBits=%p BaseAddress=%RTptr pszSymbol=%p:{%s} pValue\n",
278 hLdrMod, pvBits, BaseAddress, pszSymbol, pszSymbol, pValue));
279
280 /*
281 * Validate input.
282 */
283 AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
284 AssertMsgReturn(!pvBits || VALID_PTR(pvBits), ("pvBits=%p\n", pvBits), VERR_INVALID_PARAMETER);
285 AssertMsgReturn(pszSymbol, ("pszSymbol=%p\n", pszSymbol), VERR_INVALID_PARAMETER);
286 AssertMsgReturn(VALID_PTR(pValue), ("pValue=%p\n", pvBits), VERR_INVALID_PARAMETER);
287 PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
288 //AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER);
289
290 /*
291 * Do it.
292 */
293 int rc;
294 if (pMod->pOps->pfnGetSymbolEx)
295 rc = pMod->pOps->pfnGetSymbolEx(pMod, pvBits, BaseAddress, pszSymbol, pValue);
296 else if (!BaseAddress && !pvBits)
297 {
298 void *pvValue;
299 rc = pMod->pOps->pfnGetSymbol(pMod, pszSymbol, &pvValue);
300 if (RT_SUCCESS(rc))
301 *pValue = (uintptr_t)pvValue;
302 }
303 else
304 AssertMsgFailedReturn(("BaseAddress=%RTptr pvBits=%p\n", BaseAddress, pvBits), VERR_INVALID_FUNCTION);
305 LogFlow(("RTLdrGetSymbolEx: returns %Rrc *pValue=%p\n", rc, *pValue));
306 return rc;
307}
308
309
310/**
311 * Enumerates all symbols in a module.
312 *
313 * @returns iprt status code.
314 * @param hLdrMod The loader module handle.
315 * @param fFlags Flags indicating what to return and such.
316 * @param pvBits Optional pointer to the loaded image.
317 * Set this to NULL if no RTLdrGetBits() processed image bits are available.
318 * @param BaseAddress Image load address.
319 * @param pfnCallback Callback function.
320 * @param pvUser User argument for the callback.
321 * @remark Not supported for RTLdrLoad() images.
322 */
323RTDECL(int) RTLdrEnumSymbols(RTLDRMOD hLdrMod, unsigned fFlags, const void *pvBits, RTUINTPTR BaseAddress, PFNRTLDRENUMSYMS pfnCallback, void *pvUser)
324{
325 LogFlow(("RTLdrEnumSymbols: hLdrMod=%RTldrm fFlags=%#x pvBit=%p BaseAddress=%RTptr pfnCallback=%p pvUser=%p\n",
326 hLdrMod, fFlags, pvBits, BaseAddress, pfnCallback, pvUser));
327
328 /*
329 * Validate input.
330 */
331 AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
332 AssertMsgReturn(!pvBits || VALID_PTR(pvBits), ("pvBits=%p\n", pvBits), VERR_INVALID_PARAMETER);
333 AssertMsgReturn(VALID_PTR(pfnCallback), ("pfnCallback=%p\n", pfnCallback), VERR_INVALID_PARAMETER);
334 PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
335 //AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER);
336
337 /*
338 * Do it.
339 */
340 int rc = pMod->pOps->pfnEnumSymbols(pMod, fFlags, pvBits, BaseAddress, pfnCallback, pvUser);
341 LogFlow(("RTLdrEnumSymbols: returns %Rrc\n", rc));
342 return rc;
343}
344
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette