ldrEx.cpp@ 51770

Last change on this file since 51770 was 51770, checked in by vboxsync, 11 years ago
Merged in iprt++ dev branch.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 24.6 KB

Line
1	/* $Id: ldrEx.cpp 51770 2014-07-01 18:14:02Z vboxsync $ */
2	/** @file
3	* IPRT - Binary Image Loader, Extended Features.
4	*/
5
6	/*
7	* Copyright (C) 2006-2013 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.215389.xyz. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* The contents of this file may alternatively be used under the terms
18	* of the Common Development and Distribution License Version 1.0
19	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20	* VirtualBox OSE distribution, in which case the provisions of the
21	* CDDL are applicable instead of those of the GPL.
22	*
23	* You may elect to license modified versions of this file under the
24	* terms and conditions of either the GPL or the CDDL or both.
25	*/
26
27
28	/*******************************************************************************
29	* Header Files *
30	*******************************************************************************/
31	#define LOG_GROUP RTLOGGROUP_LDR
32	#include <iprt/ldr.h>
33	#include "internal/iprt.h"
34
35	#include <iprt/assert.h>
36	#include <iprt/err.h>
37	#include <iprt/log.h>
38	#include <iprt/md5.h>
39	#include <iprt/mem.h>
40	#include <iprt/sha.h>
41	#include <iprt/string.h>
42	#include "internal/ldr.h"
43	#include "internal/ldrMZ.h"
44
45	#ifdef LDR_ONLY_PE
46	# undef LDR_WITH_PE
47	# undef LDR_WITH_KLDR
48	# undef LDR_WITH_ELF
49	# undef LDR_WITH_LX
50	# undef LDR_WITH_LE
51	# undef LDR_WITH_NE
52	# undef LDR_WITH_MZ
53	# undef LDR_WITH_AOUT
54	# define LDR_WITH_PE
55	#endif
56
57
58	RTDECL(int) RTLdrOpenWithReader(PRTLDRREADER pReader, uint32_t fFlags, RTLDRARCH enmArch, PRTLDRMOD phMod, PRTERRINFO pErrInfo)
59	{
60	/*
61	* Resolve RTLDRARCH_HOST.
62	*/
63	if (enmArch == RTLDRARCH_HOST)
64	#if defined(RT_ARCH_AMD64)
65	enmArch = RTLDRARCH_AMD64;
66	#elif defined(RT_ARCH_X86)
67	enmArch = RTLDRARCH_X86_32;
68	#else
69	enmArch = RTLDRARCH_WHATEVER;
70	#endif
71
72	/*
73	* Read and verify the file signature.
74	*/
75	union
76	{
77	char ach[4];
78	uint16_t au16[2];
79	uint32_t u32;
80	} uSign;
81	int rc = pReader->pfnRead(pReader, &uSign, sizeof(uSign), 0);
82	if (RT_FAILURE(rc))
83	return rc;
84	#ifndef LDR_WITH_KLDR
85	if ( uSign.au16[0] != IMAGE_DOS_SIGNATURE
86	&& uSign.u32 != IMAGE_NT_SIGNATURE
87	&& uSign.u32 != IMAGE_ELF_SIGNATURE
88	&& uSign.au16[0] != IMAGE_LX_SIGNATURE)
89	{
90	Log(("rtldrOpenWithReader: %s: unknown magic %#x / '%.4s\n", pReader->pfnLogName(pReader), uSign.u32, &uSign.ach[0]));
91	return VERR_INVALID_EXE_SIGNATURE;
92	}
93	#endif
94	uint32_t offHdr = 0;
95	if (uSign.au16[0] == IMAGE_DOS_SIGNATURE)
96	{
97	rc = pReader->pfnRead(pReader, &offHdr, sizeof(offHdr), RT_OFFSETOF(IMAGE_DOS_HEADER, e_lfanew));
98	if (RT_FAILURE(rc))
99	return rc;
100
101	if (offHdr <= sizeof(IMAGE_DOS_HEADER))
102	{
103	Log(("rtldrOpenWithReader: %s: no new header / invalid offset %#RX32\n", pReader->pfnLogName(pReader), offHdr));
104	return VERR_INVALID_EXE_SIGNATURE;
105	}
106	rc = pReader->pfnRead(pReader, &uSign, sizeof(uSign), offHdr);
107	if (RT_FAILURE(rc))
108	return rc;
109	if ( uSign.u32 != IMAGE_NT_SIGNATURE
110	&& uSign.au16[0] != IMAGE_LX_SIGNATURE
111	&& uSign.au16[0] != IMAGE_LE_SIGNATURE
112	&& uSign.au16[0] != IMAGE_NE_SIGNATURE)
113	{
114	Log(("rtldrOpenWithReader: %s: unknown new magic %#x / '%.4s\n", pReader->pfnLogName(pReader), uSign.u32, &uSign.ach[0]));
115	return VERR_INVALID_EXE_SIGNATURE;
116	}
117	}
118
119	/*
120	* Create image interpreter instance depending on the signature.
121	*/
122	if (uSign.u32 == IMAGE_NT_SIGNATURE)
123	#ifdef LDR_WITH_PE
124	rc = rtldrPEOpen(pReader, fFlags, enmArch, offHdr, phMod, pErrInfo);
125	#else
126	rc = VERR_PE_EXE_NOT_SUPPORTED;
127	#endif
128	else if (uSign.u32 == IMAGE_ELF_SIGNATURE)
129	#if defined(LDR_WITH_ELF)
130	rc = rtldrELFOpen(pReader, fFlags, enmArch, phMod, pErrInfo);
131	#else
132	rc = VERR_ELF_EXE_NOT_SUPPORTED;
133	#endif
134	else if (uSign.au16[0] == IMAGE_LX_SIGNATURE)
135	#ifdef LDR_WITH_LX
136	rc = rtldrLXOpen(pReader, fFlags, enmArch, offHdr, phMod, pErrInfo);
137	#else
138	rc = VERR_LX_EXE_NOT_SUPPORTED;
139	#endif
140	else if (uSign.au16[0] == IMAGE_LE_SIGNATURE)
141	#ifdef LDR_WITH_LE
142	rc = rtldrLEOpen(pReader, fFlags, enmArch, phMod, pErrInfo);
143	#else
144	rc = VERR_LE_EXE_NOT_SUPPORTED;
145	#endif
146	else if (uSign.au16[0] == IMAGE_NE_SIGNATURE)
147	#ifdef LDR_WITH_NE
148	rc = rtldrNEOpen(pReader, fFlags, enmArch, phMod, pErrInfo);
149	#else
150	rc = VERR_NE_EXE_NOT_SUPPORTED;
151	#endif
152	else if (uSign.au16[0] == IMAGE_DOS_SIGNATURE)
153	#ifdef LDR_WITH_MZ
154	rc = rtldrMZOpen(pReader, fFlags, enmArch, phMod, pErrInfo);
155	#else
156	rc = VERR_MZ_EXE_NOT_SUPPORTED;
157	#endif
158	else if (/* uSign.u32 == IMAGE_AOUT_A_SIGNATURE
159	\|\| uSign.u32 == IMAGE_AOUT_Z_SIGNATURE/ /* @todo find the aout magics in emx or binutils. */
160	0)
161	#ifdef LDR_WITH_AOUT
162	rc = rtldrAOUTOpen(pReader, fFlags, enmArch, phMod, pErrInfo);
163	#else
164	rc = VERR_AOUT_EXE_NOT_SUPPORTED;
165	#endif
166	else
167	{
168	#ifndef LDR_WITH_KLDR
169	Log(("rtldrOpenWithReader: %s: the format isn't implemented %#x / '%.4s\n", pReader->pfnLogName(pReader), uSign.u32, &uSign.ach[0]));
170	#endif
171	rc = VERR_INVALID_EXE_SIGNATURE;
172	}
173
174	#ifdef LDR_WITH_KLDR
175	/* Try kLdr if it's a format we don't recognize. */
176	if (rc <= VERR_INVALID_EXE_SIGNATURE && rc > VERR_BAD_EXE_FORMAT)
177	{
178	int rc2 = rtldrkLdrOpen(pReader, fFlags, enmArch, phMod, pErrInfo);
179	if (rc2 == VERR_MZ_EXE_NOT_SUPPORTED) /* Quick fix for bad return code. */
180	rc = rc;
181	}
182	#endif
183
184	LogFlow(("rtldrOpenWithReader: %s: returns %Rrc phMod=%p\n", pReader->pfnLogName(pReader), rc, phMod));
185	return rc;
186	}
187
188
189	RTDECL(size_t) RTLdrSize(RTLDRMOD hLdrMod)
190	{
191	LogFlow(("RTLdrSize: hLdrMod=%RTldrm\n", hLdrMod));
192
193	/*
194	* Validate input.
195	*/
196	AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), ~(size_t)0);
197	PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
198	AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), ~(size_t)0);
199
200	/*
201	* Do it.
202	*/
203	size_t cb = pMod->pOps->pfnGetImageSize(pMod);
204	LogFlow(("RTLdrSize: returns %zu\n", cb));
205	return cb;
206	}
207	RT_EXPORT_SYMBOL(RTLdrSize);
208
209
210	/**
211	* Loads the image into a buffer provided by the user and applies fixups
212	* for the given base address.
213	*
214	* @returns iprt status code.
215	* @param hLdrMod The load module handle.
216	* @param pvBits Where to put the bits.
217	* Must be as large as RTLdrSize() suggests.
218	* @param BaseAddress The base address.
219	* @param pfnGetImport Callback function for resolving imports one by one.
220	* @param pvUser User argument for the callback.
221	* @remark Not supported for RTLdrLoad() images.
222	*/
223	RTDECL(int) RTLdrGetBits(RTLDRMOD hLdrMod, void pvBits, RTLDRADDR BaseAddress, PFNRTLDRIMPORT pfnGetImport, void pvUser)
224	{
225	LogFlow(("RTLdrGetBits: hLdrMod=%RTldrm pvBits=%p BaseAddress=%RTptr pfnGetImport=%p pvUser=%p\n",
226	hLdrMod, pvBits, BaseAddress, pfnGetImport, pvUser));
227
228	/*
229	* Validate input.
230	*/
231	AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
232	AssertMsgReturn(VALID_PTR(pvBits), ("pvBits=%p\n", pvBits), VERR_INVALID_PARAMETER);
233	AssertMsgReturn(VALID_PTR(pfnGetImport), ("pfnGetImport=%p\n", pfnGetImport), VERR_INVALID_PARAMETER);
234	PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
235	AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER);
236
237	/*
238	* Do it.
239	*/
240	int rc = pMod->pOps->pfnGetBits(pMod, pvBits, BaseAddress, pfnGetImport, pvUser);
241	LogFlow(("RTLdrGetBits: returns %Rrc\n",rc));
242	return rc;
243	}
244	RT_EXPORT_SYMBOL(RTLdrGetBits);
245
246
247	/**
248	* Relocates bits after getting them.
249	* Useful for code which moves around a bit.
250	*
251	* @returns iprt status code.
252	* @param hLdrMod The loader module handle.
253	* @param pvBits Where the image bits are.
254	* Must have been passed to RTLdrGetBits().
255	* @param NewBaseAddress The new base address.
256	* @param OldBaseAddress The old base address.
257	* @param pfnGetImport Callback function for resolving imports one by one.
258	* @param pvUser User argument for the callback.
259	* @remark Not supported for RTLdrLoad() images.
260	*/
261	RTDECL(int) RTLdrRelocate(RTLDRMOD hLdrMod, void *pvBits, RTLDRADDR NewBaseAddress, RTLDRADDR OldBaseAddress,
262	PFNRTLDRIMPORT pfnGetImport, void *pvUser)
263	{
264	LogFlow(("RTLdrRelocate: hLdrMod=%RTldrm pvBits=%p NewBaseAddress=%RTptr OldBaseAddress=%RTptr pfnGetImport=%p pvUser=%p\n",
265	hLdrMod, pvBits, NewBaseAddress, OldBaseAddress, pfnGetImport, pvUser));
266
267	/*
268	* Validate input.
269	*/
270	AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
271	AssertMsgReturn(VALID_PTR(pvBits), ("pvBits=%p\n", pvBits), VERR_INVALID_PARAMETER);
272	AssertMsgReturn(VALID_PTR(pfnGetImport), ("pfnGetImport=%p\n", pfnGetImport), VERR_INVALID_PARAMETER);
273	PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
274	AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER);
275
276	/*
277	* Do it.
278	*/
279	int rc = pMod->pOps->pfnRelocate(pMod, pvBits, NewBaseAddress, OldBaseAddress, pfnGetImport, pvUser);
280	LogFlow(("RTLdrRelocate: returns %Rrc\n", rc));
281	return rc;
282	}
283	RT_EXPORT_SYMBOL(RTLdrRelocate);
284
285
286	/**
287	* Gets the address of a named exported symbol.
288	*
289	* This function differs from the plain one in that it can deal with
290	* both GC and HC address sizes, and that it can calculate the symbol
291	* value relative to any given base address.
292	*
293	* @returns iprt status code.
294	* @param hLdrMod The loader module handle.
295	* @param pvBits Optional pointer to the loaded image.
296	* Set this to NULL if no RTLdrGetBits() processed image bits are available.
297	* Not supported for RTLdrLoad() images and must be NULL.
298	* @param BaseAddress Image load address.
299	* Not supported for RTLdrLoad() images and must be 0.
300	* @param pszSymbol Symbol name.
301	* @param pValue Where to store the symbol value.
302	*/
303	RTDECL(int) RTLdrGetSymbolEx(RTLDRMOD hLdrMod, const void pvBits, RTLDRADDR BaseAddress, const char pszSymbol,
304	PRTLDRADDR pValue)
305	{
306	LogFlow(("RTLdrGetSymbolEx: hLdrMod=%RTldrm pvBits=%p BaseAddress=%RTptr pszSymbol=%p:{%s} pValue\n",
307	hLdrMod, pvBits, BaseAddress, pszSymbol, pszSymbol, pValue));
308
309	/*
310	* Validate input.
311	*/
312	AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
313	AssertMsgReturn(!pvBits \|\| VALID_PTR(pvBits), ("pvBits=%p\n", pvBits), VERR_INVALID_PARAMETER);
314	AssertMsgReturn(pszSymbol, ("pszSymbol=%p\n", pszSymbol), VERR_INVALID_PARAMETER);
315	AssertMsgReturn(VALID_PTR(pValue), ("pValue=%p\n", pvBits), VERR_INVALID_PARAMETER);
316	PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
317	//AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER);
318
319	/*
320	* Do it.
321	*/
322	int rc;
323	if (pMod->pOps->pfnGetSymbolEx)
324	rc = pMod->pOps->pfnGetSymbolEx(pMod, pvBits, BaseAddress, pszSymbol, pValue);
325	else if (!BaseAddress && !pvBits)
326	{
327	void *pvValue;
328	rc = pMod->pOps->pfnGetSymbol(pMod, pszSymbol, &pvValue);
329	if (RT_SUCCESS(rc))
330	*pValue = (uintptr_t)pvValue;
331	}
332	else
333	AssertMsgFailedReturn(("BaseAddress=%RTptr pvBits=%p\n", BaseAddress, pvBits), VERR_INVALID_FUNCTION);
334	LogFlow(("RTLdrGetSymbolEx: returns %Rrc pValue=%p\n", rc, pValue));
335	return rc;
336	}
337	RT_EXPORT_SYMBOL(RTLdrGetSymbolEx);
338
339
340	/**
341	* Enumerates all symbols in a module.
342	*
343	* @returns iprt status code.
344	* @param hLdrMod The loader module handle.
345	* @param fFlags Flags indicating what to return and such.
346	* @param pvBits Optional pointer to the loaded image.
347	* Set this to NULL if no RTLdrGetBits() processed image bits are available.
348	* @param BaseAddress Image load address.
349	* @param pfnCallback Callback function.
350	* @param pvUser User argument for the callback.
351	* @remark Not supported for RTLdrLoad() images.
352	*/
353	RTDECL(int) RTLdrEnumSymbols(RTLDRMOD hLdrMod, unsigned fFlags, const void *pvBits, RTLDRADDR BaseAddress,
354	PFNRTLDRENUMSYMS pfnCallback, void *pvUser)
355	{
356	LogFlow(("RTLdrEnumSymbols: hLdrMod=%RTldrm fFlags=%#x pvBits=%p BaseAddress=%RTptr pfnCallback=%p pvUser=%p\n",
357	hLdrMod, fFlags, pvBits, BaseAddress, pfnCallback, pvUser));
358
359	/*
360	* Validate input.
361	*/
362	AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
363	AssertMsgReturn(!pvBits \|\| VALID_PTR(pvBits), ("pvBits=%p\n", pvBits), VERR_INVALID_PARAMETER);
364	AssertMsgReturn(VALID_PTR(pfnCallback), ("pfnCallback=%p\n", pfnCallback), VERR_INVALID_PARAMETER);
365	PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
366	//AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER);
367
368	/*
369	* Do it.
370	*/
371	int rc = pMod->pOps->pfnEnumSymbols(pMod, fFlags, pvBits, BaseAddress, pfnCallback, pvUser);
372	LogFlow(("RTLdrEnumSymbols: returns %Rrc\n", rc));
373	return rc;
374	}
375	RT_EXPORT_SYMBOL(RTLdrEnumSymbols);
376
377
378	RTDECL(int) RTLdrEnumDbgInfo(RTLDRMOD hLdrMod, const void pvBits, PFNRTLDRENUMDBG pfnCallback, void pvUser)
379	{
380	LogFlow(("RTLdrEnumDbgInfo: hLdrMod=%RTldrm pvBits=%p pfnCallback=%p pvUser=%p\n",
381	hLdrMod, pvBits, pfnCallback, pvUser));
382
383	/*
384	* Validate input.
385	*/
386	AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
387	AssertMsgReturn(!pvBits \|\| RT_VALID_PTR(pvBits), ("pvBits=%p\n", pvBits), VERR_INVALID_PARAMETER);
388	AssertMsgReturn(RT_VALID_PTR(pfnCallback), ("pfnCallback=%p\n", pfnCallback), VERR_INVALID_PARAMETER);
389	PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
390	//AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER);
391
392	/*
393	* Do it.
394	*/
395	int rc;
396	if (pMod->pOps->pfnEnumDbgInfo)
397	rc = pMod->pOps->pfnEnumDbgInfo(pMod, pvBits, pfnCallback, pvUser);
398	else
399	rc = VERR_NOT_SUPPORTED;
400
401	LogFlow(("RTLdrEnumDbgInfo: returns %Rrc\n", rc));
402	return rc;
403	}
404	RT_EXPORT_SYMBOL(RTLdrEnumDbgInfo);
405
406
407	RTDECL(int) RTLdrEnumSegments(RTLDRMOD hLdrMod, PFNRTLDRENUMSEGS pfnCallback, void *pvUser)
408	{
409	LogFlow(("RTLdrEnumSegments: hLdrMod=%RTldrm pfnCallback=%p pvUser=%p\n",
410	hLdrMod, pfnCallback, pvUser));
411
412	/*
413	* Validate input.
414	*/
415	AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
416	AssertMsgReturn(RT_VALID_PTR(pfnCallback), ("pfnCallback=%p\n", pfnCallback), VERR_INVALID_PARAMETER);
417	PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
418	//AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER);
419
420	/*
421	* Do it.
422	*/
423	int rc;
424	if (pMod->pOps->pfnEnumSegments)
425	rc = pMod->pOps->pfnEnumSegments(pMod, pfnCallback, pvUser);
426	else
427	rc = VERR_NOT_SUPPORTED;
428
429	LogFlow(("RTLdrEnumSegments: returns %Rrc\n", rc));
430	return rc;
431
432	}
433	RT_EXPORT_SYMBOL(RTLdrEnumSegments);
434
435
436	RTDECL(int) RTLdrLinkAddressToSegOffset(RTLDRMOD hLdrMod, RTLDRADDR LinkAddress, uint32_t *piSeg, PRTLDRADDR poffSeg)
437	{
438	LogFlow(("RTLdrLinkAddressToSegOffset: hLdrMod=%RTldrm LinkAddress=%RTptr piSeg=%p poffSeg=%p\n",
439	hLdrMod, LinkAddress, piSeg, poffSeg));
440
441	/*
442	* Validate input.
443	*/
444	AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
445	AssertPtrReturn(piSeg, VERR_INVALID_POINTER);
446	AssertPtrReturn(poffSeg, VERR_INVALID_POINTER);
447
448	PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
449	//AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER);
450
451	*piSeg = UINT32_MAX;
452	*poffSeg = ~(RTLDRADDR)0;
453
454	/*
455	* Do it.
456	*/
457	int rc;
458	if (pMod->pOps->pfnLinkAddressToSegOffset)
459	rc = pMod->pOps->pfnLinkAddressToSegOffset(pMod, LinkAddress, piSeg, poffSeg);
460	else
461	rc = VERR_NOT_SUPPORTED;
462
463	LogFlow(("RTLdrLinkAddressToSegOffset: returns %Rrc %#x:%RTptr\n", rc, piSeg, poffSeg));
464	return rc;
465	}
466	RT_EXPORT_SYMBOL(RTLdrLinkAddressToSegOffset);
467
468
469	RTDECL(int) RTLdrLinkAddressToRva(RTLDRMOD hLdrMod, RTLDRADDR LinkAddress, PRTLDRADDR pRva)
470	{
471	LogFlow(("RTLdrLinkAddressToRva: hLdrMod=%RTldrm LinkAddress=%RTptr pRva=%p\n",
472	hLdrMod, LinkAddress, pRva));
473
474	/*
475	* Validate input.
476	*/
477	AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
478	AssertPtrReturn(pRva, VERR_INVALID_POINTER);
479
480	PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
481	//AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER);
482
483	*pRva = ~(RTLDRADDR)0;
484
485	/*
486	* Do it.
487	*/
488	int rc;
489	if (pMod->pOps->pfnLinkAddressToRva)
490	rc = pMod->pOps->pfnLinkAddressToRva(pMod, LinkAddress, pRva);
491	else
492	rc = VERR_NOT_SUPPORTED;
493
494	LogFlow(("RTLdrLinkAddressToRva: returns %Rrc %RTptr\n", rc, *pRva));
495	return rc;
496	}
497	RT_EXPORT_SYMBOL(RTLdrLinkAddressToRva);
498
499
500	RTDECL(int) RTLdrSegOffsetToRva(RTLDRMOD hLdrMod, uint32_t iSeg, RTLDRADDR offSeg, PRTLDRADDR pRva)
501	{
502	LogFlow(("RTLdrSegOffsetToRva: hLdrMod=%RTldrm LinkAddress=%RTptr iSeg=%#x offSeg=%RTptr pRva=%p\n",
503	hLdrMod, iSeg, offSeg, pRva));
504
505	/*
506	* Validate input.
507	*/
508	AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
509	AssertPtrReturn(pRva, VERR_INVALID_POINTER);
510
511	PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
512	//AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER);
513
514	*pRva = ~(RTLDRADDR)0;
515
516	/*
517	* Do it.
518	*/
519	int rc;
520	if (pMod->pOps->pfnSegOffsetToRva)
521	rc = pMod->pOps->pfnSegOffsetToRva(pMod, iSeg, offSeg, pRva);
522	else
523	rc = VERR_NOT_SUPPORTED;
524
525	LogFlow(("RTLdrSegOffsetToRva: returns %Rrc %RTptr\n", rc, *pRva));
526	return rc;
527	}
528	RT_EXPORT_SYMBOL(RTLdrSegOffsetToRva);
529
530	RTDECL(int) RTLdrRvaToSegOffset(RTLDRMOD hLdrMod, RTLDRADDR Rva, uint32_t *piSeg, PRTLDRADDR poffSeg)
531	{
532	LogFlow(("RTLdrRvaToSegOffset: hLdrMod=%RTldrm Rva=%RTptr piSeg=%p poffSeg=%p\n",
533	hLdrMod, Rva, piSeg, poffSeg));
534
535	/*
536	* Validate input.
537	*/
538	AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
539	AssertPtrReturn(piSeg, VERR_INVALID_POINTER);
540	AssertPtrReturn(poffSeg, VERR_INVALID_POINTER);
541
542	PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
543	//AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER);
544
545	*piSeg = UINT32_MAX;
546	*poffSeg = ~(RTLDRADDR)0;
547
548	/*
549	* Do it.
550	*/
551	int rc;
552	if (pMod->pOps->pfnRvaToSegOffset)
553	rc = pMod->pOps->pfnRvaToSegOffset(pMod, Rva, piSeg, poffSeg);
554	else
555	rc = VERR_NOT_SUPPORTED;
556
557	LogFlow(("RTLdrRvaToSegOffset: returns %Rrc %#x:%RTptr\n", rc, piSeg, poffSeg));
558	return rc;
559	}
560	RT_EXPORT_SYMBOL(RTLdrRvaToSegOffset);
561
562
563	RTDECL(int) RTLdrQueryProp(RTLDRMOD hLdrMod, RTLDRPROP enmProp, void *pvBuf, size_t cbBuf)
564	{
565	return RTLdrQueryPropEx(hLdrMod, enmProp, pvBuf, cbBuf, NULL);
566	}
567	RT_EXPORT_SYMBOL(RTLdrQueryProp);
568
569
570	RTDECL(int) RTLdrQueryPropEx(RTLDRMOD hLdrMod, RTLDRPROP enmProp, void pvBuf, size_t cbBuf, size_t pcbRet)
571	{
572	AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), RTLDRENDIAN_INVALID);
573	PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
574
575	AssertPtrNullReturn(pcbRet, VERR_INVALID_POINTER);
576	size_t cbRet;
577	if (!pcbRet)
578	pcbRet = &cbRet;
579
580	/*
581	* Do some pre screening of the input
582	*/
583	switch (enmProp)
584	{
585	case RTLDRPROP_UUID:
586	*pcbRet = sizeof(RTUUID);
587	AssertReturn(cbBuf == sizeof(RTUUID), VERR_INVALID_PARAMETER);
588	break;
589	case RTLDRPROP_TIMESTAMP_SECONDS:
590	*pcbRet = sizeof(int64_t);
591	AssertReturn(cbBuf == sizeof(int32_t) \|\| cbBuf == sizeof(int64_t), VERR_INVALID_PARAMETER);
592	break;
593	case RTLDRPROP_IS_SIGNED:
594	*pcbRet = sizeof(bool);
595	AssertReturn(cbBuf == sizeof(bool), VERR_INVALID_PARAMETER);
596	break;
597	case RTLDRPROP_PKCS7_SIGNED_DATA:
598	*pcbRet = 0;
599	break;
600	case RTLDRPROP_SIGNATURE_CHECKS_ENFORCED:
601	*pcbRet = sizeof(bool);
602	AssertReturn(cbBuf == sizeof(bool), VERR_INVALID_PARAMETER);
603	break;
604
605	default:
606	AssertFailedReturn(VERR_INVALID_FUNCTION);
607	}
608	AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
609
610	/*
611	* Call the image specific worker, if there is one.
612	*/
613	if (!pMod->pOps->pfnQueryProp)
614	return VERR_NOT_SUPPORTED;
615	return pMod->pOps->pfnQueryProp(pMod, enmProp, pvBuf, cbBuf, pcbRet);
616	}
617	RT_EXPORT_SYMBOL(RTLdrQueryPropEx);
618
619
620	RTDECL(int) RTLdrVerifySignature(RTLDRMOD hLdrMod, PFNRTLDRVALIDATESIGNEDDATA pfnCallback, void *pvUser, PRTERRINFO pErrInfo)
621	{
622	AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
623	PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
624	AssertPtrReturn(pfnCallback, VERR_INVALID_POINTER);
625
626	/*
627	* Call the image specific worker, if there is one.
628	*/
629	if (!pMod->pOps->pfnVerifySignature)
630	return VERR_NOT_SUPPORTED;
631	return pMod->pOps->pfnVerifySignature(pMod, pfnCallback, pvUser, pErrInfo);
632	}
633	RT_EXPORT_SYMBOL(RTLdrVerifySignature);
634
635
636	RTDECL(int) RTLdrHashImage(RTLDRMOD hLdrMod, RTDIGESTTYPE enmDigest, char *pszDigest, size_t cbDigest)
637	{
638	AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
639	PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
640
641	/*
642	* Make sure there is sufficient space for the wanted digest and that
643	* it's supported.
644	*/
645	switch (enmDigest)
646	{
647	case RTDIGESTTYPE_MD5: AssertReturn(cbDigest >= RTMD5_DIGEST_LEN + 1, VERR_BUFFER_OVERFLOW); break;
648	case RTDIGESTTYPE_SHA1: AssertReturn(cbDigest >= RTSHA1_DIGEST_LEN + 1, VERR_BUFFER_OVERFLOW); break;
649	case RTDIGESTTYPE_SHA256: AssertReturn(cbDigest >= RTSHA256_DIGEST_LEN + 1, VERR_BUFFER_OVERFLOW); break;
650	case RTDIGESTTYPE_SHA512: AssertReturn(cbDigest >= RTSHA512_DIGEST_LEN + 1, VERR_BUFFER_OVERFLOW); break;
651	default:
652	if (enmDigest > RTDIGESTTYPE_INVALID && enmDigest < RTDIGESTTYPE_END)
653	return VERR_NOT_SUPPORTED;
654	AssertFailedReturn(VERR_INVALID_PARAMETER);
655	}
656	AssertPtrReturn(pszDigest, VERR_INVALID_POINTER);
657
658	/*
659	* Call the image specific worker, if there is one.
660	*/
661	if (!pMod->pOps->pfnHashImage)
662	return VERR_NOT_SUPPORTED;
663	return pMod->pOps->pfnHashImage(pMod, enmDigest, pszDigest, cbDigest);
664	}
665	RT_EXPORT_SYMBOL(RTLdrHashImage);
666
667
668	/**
669	* Internal method used by the IPRT debug bits.
670	*
671	* @returns IPRT status code.
672	* @param hLdrMod The loader handle which executable we wish to
673	* read from.
674	* @param pvBuf The output buffer.
675	* @param iDbgInfo The debug info ordinal number if the request
676	* corresponds exactly to a debug info part from
677	* pfnEnumDbgInfo. Otherwise, pass UINT32_MAX.
678	* @param off Where in the executable file to start reading.
679	* @param cb The number of bytes to read.
680	*
681	* @remarks Fixups will only be applied if @a iDbgInfo is specified.
682	*/
683	DECLHIDDEN(int) rtLdrReadAt(RTLDRMOD hLdrMod, void *pvBuf, uint32_t iDbgInfo, RTFOFF off, size_t cb)
684	{
685	AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
686	PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
687
688	if (iDbgInfo != UINT32_MAX)
689	{
690	AssertReturn(pMod->pOps->pfnReadDbgInfo, VERR_NOT_SUPPORTED);
691	return pMod->pOps->pfnReadDbgInfo(pMod, iDbgInfo, off, cb, pvBuf);
692	}
693
694	AssertReturn(pMod->pReader, VERR_NOT_SUPPORTED);
695	return pMod->pReader->pfnRead(pMod->pReader, pvBuf, cb, off);
696	}
697

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Runtime/common/ldr/ldrEx.cpp@ 51770

Download in other formats: