ldrEx.cpp@ 59665

Last change on this file since 59665 was 58742, checked in by vboxsync, 9 years ago
Various: Use our pecoff.h and mz.h instead of the internal IPRT headers.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 26.5 KB

Line
1	/* $Id: ldrEx.cpp 58742 2015-11-18 12:39:05Z vboxsync $ */
2	/** @file
3	* IPRT - Binary Image Loader, Extended Features.
4	*/
5
6	/*
7	* Copyright (C) 2006-2015 Oracle Corporation
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 (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 <iprt/formats/mz.h>
43	#include "internal/ldr.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 ( RT_SUCCESS(rc2)
180	\|\| (rc == VERR_INVALID_EXE_SIGNATURE && rc2 != VERR_MZ_EXE_NOT_SUPPORTED /* Quick fix for bad return code. */)
181	\|\| rc2 > VERR_INVALID_EXE_SIGNATURE
182	\|\| rc2 <= VERR_BAD_EXE_FORMAT)
183	rc = rc2;
184	}
185	#endif
186
187	LogFlow(("rtldrOpenWithReader: %s: returns %Rrc phMod=%p\n", pReader->pfnLogName(pReader), rc, phMod));
188	return rc;
189	}
190
191
192	RTDECL(size_t) RTLdrSize(RTLDRMOD hLdrMod)
193	{
194	LogFlow(("RTLdrSize: hLdrMod=%RTldrm\n", hLdrMod));
195
196	/*
197	* Validate input.
198	*/
199	AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), ~(size_t)0);
200	PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
201	AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), ~(size_t)0);
202
203	/*
204	* Do it.
205	*/
206	size_t cb = pMod->pOps->pfnGetImageSize(pMod);
207	LogFlow(("RTLdrSize: returns %zu\n", cb));
208	return cb;
209	}
210	RT_EXPORT_SYMBOL(RTLdrSize);
211
212
213	/**
214	* Loads the image into a buffer provided by the user and applies fixups
215	* for the given base address.
216	*
217	* @returns iprt status code.
218	* @param hLdrMod The load module handle.
219	* @param pvBits Where to put the bits.
220	* Must be as large as RTLdrSize() suggests.
221	* @param BaseAddress The base address.
222	* @param pfnGetImport Callback function for resolving imports one by one.
223	* If this is NULL, imports will not be resolved.
224	* @param pvUser User argument for the callback.
225	* @remark Not supported for RTLdrLoad() images.
226	*/
227	RTDECL(int) RTLdrGetBits(RTLDRMOD hLdrMod, void pvBits, RTLDRADDR BaseAddress, PFNRTLDRIMPORT pfnGetImport, void pvUser)
228	{
229	LogFlow(("RTLdrGetBits: hLdrMod=%RTldrm pvBits=%p BaseAddress=%RTptr pfnGetImport=%p pvUser=%p\n",
230	hLdrMod, pvBits, BaseAddress, pfnGetImport, pvUser));
231
232	/*
233	* Validate input.
234	*/
235	AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
236	AssertPtrReturn(pvBits, VERR_INVALID_POINTER);
237	AssertPtrNullReturn(pfnGetImport, VERR_INVALID_POINTER);
238	PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
239	AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER);
240
241	/*
242	* Do it.
243	*/
244	int rc = pMod->pOps->pfnGetBits(pMod, pvBits, BaseAddress, pfnGetImport, pvUser);
245	LogFlow(("RTLdrGetBits: returns %Rrc\n",rc));
246	return rc;
247	}
248	RT_EXPORT_SYMBOL(RTLdrGetBits);
249
250
251	/**
252	* Relocates bits after getting them.
253	* Useful for code which moves around a bit.
254	*
255	* @returns iprt status code.
256	* @param hLdrMod The loader module handle.
257	* @param pvBits Where the image bits are.
258	* Must have been passed to RTLdrGetBits().
259	* @param NewBaseAddress The new base address.
260	* @param OldBaseAddress The old base address.
261	* @param pfnGetImport Callback function for resolving imports one by one.
262	* @param pvUser User argument for the callback.
263	* @remark Not supported for RTLdrLoad() images.
264	*/
265	RTDECL(int) RTLdrRelocate(RTLDRMOD hLdrMod, void *pvBits, RTLDRADDR NewBaseAddress, RTLDRADDR OldBaseAddress,
266	PFNRTLDRIMPORT pfnGetImport, void *pvUser)
267	{
268	LogFlow(("RTLdrRelocate: hLdrMod=%RTldrm pvBits=%p NewBaseAddress=%RTptr OldBaseAddress=%RTptr pfnGetImport=%p pvUser=%p\n",
269	hLdrMod, pvBits, NewBaseAddress, OldBaseAddress, pfnGetImport, pvUser));
270
271	/*
272	* Validate input.
273	*/
274	AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
275	AssertMsgReturn(VALID_PTR(pvBits), ("pvBits=%p\n", pvBits), VERR_INVALID_PARAMETER);
276	AssertMsgReturn(VALID_PTR(pfnGetImport), ("pfnGetImport=%p\n", pfnGetImport), VERR_INVALID_PARAMETER);
277	PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
278	AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER);
279
280	/*
281	* Do it.
282	*/
283	int rc = pMod->pOps->pfnRelocate(pMod, pvBits, NewBaseAddress, OldBaseAddress, pfnGetImport, pvUser);
284	LogFlow(("RTLdrRelocate: returns %Rrc\n", rc));
285	return rc;
286	}
287	RT_EXPORT_SYMBOL(RTLdrRelocate);
288
289
290	RTDECL(int) RTLdrGetSymbolEx(RTLDRMOD hLdrMod, const void *pvBits, RTLDRADDR BaseAddress,
291	uint32_t iOrdinal, const char *pszSymbol, PRTLDRADDR pValue)
292	{
293	LogFlow(("RTLdrGetSymbolEx: hLdrMod=%RTldrm pvBits=%p BaseAddress=%RTptr iOrdinal=%#x pszSymbol=%p:{%s} pValue=%p\n",
294	hLdrMod, pvBits, BaseAddress, iOrdinal, pszSymbol, pszSymbol, pValue));
295
296	/*
297	* Validate input.
298	*/
299	AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
300	AssertPtrNullReturn(pvBits, VERR_INVALID_POINTER);
301	AssertPtrNullReturn(pszSymbol, VERR_INVALID_POINTER);
302	AssertReturn(pszSymbol \|\| iOrdinal != UINT32_MAX, VERR_INVALID_PARAMETER);
303	AssertPtrReturn(pValue, VERR_INVALID_POINTER);
304	PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
305
306	/*
307	* Do it.
308	*/
309	int rc;
310	if (pMod->pOps->pfnGetSymbolEx)
311	rc = pMod->pOps->pfnGetSymbolEx(pMod, pvBits, BaseAddress, iOrdinal, pszSymbol, pValue);
312	else if (!BaseAddress && !pvBits && iOrdinal == UINT32_MAX)
313	{
314	void *pvValue;
315	rc = pMod->pOps->pfnGetSymbol(pMod, pszSymbol, &pvValue);
316	if (RT_SUCCESS(rc))
317	*pValue = (uintptr_t)pvValue;
318	}
319	else
320	AssertMsgFailedReturn(("BaseAddress=%RTptr pvBits=%p\n", BaseAddress, pvBits), VERR_INVALID_FUNCTION);
321	LogFlow(("RTLdrGetSymbolEx: returns %Rrc pValue=%p\n", rc, pValue));
322	return rc;
323	}
324	RT_EXPORT_SYMBOL(RTLdrGetSymbolEx);
325
326
327	RTDECL(int) RTLdrQueryForwarderInfo(RTLDRMOD hLdrMod, const void pvBits, uint32_t iOrdinal, const char pszSymbol,
328	PRTLDRIMPORTINFO pInfo, size_t cbInfo)
329	{
330	LogFlow(("RTLdrQueryForwarderInfo: hLdrMod=%RTldrm pvBits=%p iOrdinal=%#x pszSymbol=%p:{%s} pInfo=%p cbInfo=%zu\n",
331	hLdrMod, pvBits, iOrdinal, pszSymbol, pszSymbol, pInfo, cbInfo));
332
333	/*
334	* Validate input.
335	*/
336	AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
337	AssertPtrNullReturn(pvBits, VERR_INVALID_POINTER);
338	AssertMsgReturn(pszSymbol, ("pszSymbol=%p\n", pszSymbol), VERR_INVALID_PARAMETER);
339	AssertPtrReturn(pInfo, VERR_INVALID_PARAMETER);
340	AssertReturn(cbInfo >= sizeof(*pInfo), VERR_INVALID_PARAMETER);
341	PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
342
343	/*
344	* Do it.
345	*/
346	int rc;
347	if (pMod->pOps->pfnQueryForwarderInfo)
348	{
349	rc = pMod->pOps->pfnQueryForwarderInfo(pMod, pvBits, iOrdinal, pszSymbol, pInfo, cbInfo);
350	if (RT_SUCCESS(rc))
351	LogFlow(("RTLdrQueryForwarderInfo: returns %Rrc pInfo={%#x,%#x,%s,%s}\n", rc,
352	pInfo->iSelfOrdinal, pInfo->iOrdinal, pInfo->pszSymbol, pInfo->szModule));
353	else
354	LogFlow(("RTLdrQueryForwarderInfo: returns %Rrc\n", rc));
355	}
356	else
357	{
358	LogFlow(("RTLdrQueryForwarderInfo: returns VERR_NOT_SUPPORTED\n"));
359	rc = VERR_NOT_SUPPORTED;
360	}
361	return rc;
362
363	}
364	RT_EXPORT_SYMBOL(RTLdrQueryForwarderInfo);
365
366
367	/**
368	* Enumerates all symbols in a module.
369	*
370	* @returns iprt status code.
371	* @param hLdrMod The loader module handle.
372	* @param fFlags Flags indicating what to return and such.
373	* @param pvBits Optional pointer to the loaded image.
374	* Set this to NULL if no RTLdrGetBits() processed image bits are available.
375	* @param BaseAddress Image load address.
376	* @param pfnCallback Callback function.
377	* @param pvUser User argument for the callback.
378	* @remark Not supported for RTLdrLoad() images.
379	*/
380	RTDECL(int) RTLdrEnumSymbols(RTLDRMOD hLdrMod, unsigned fFlags, const void *pvBits, RTLDRADDR BaseAddress,
381	PFNRTLDRENUMSYMS pfnCallback, void *pvUser)
382	{
383	LogFlow(("RTLdrEnumSymbols: hLdrMod=%RTldrm fFlags=%#x pvBits=%p BaseAddress=%RTptr pfnCallback=%p pvUser=%p\n",
384	hLdrMod, fFlags, pvBits, BaseAddress, pfnCallback, pvUser));
385
386	/*
387	* Validate input.
388	*/
389	AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
390	AssertMsgReturn(!pvBits \|\| VALID_PTR(pvBits), ("pvBits=%p\n", pvBits), VERR_INVALID_PARAMETER);
391	AssertMsgReturn(VALID_PTR(pfnCallback), ("pfnCallback=%p\n", pfnCallback), VERR_INVALID_PARAMETER);
392	PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
393	//AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER);
394
395	/*
396	* Do it.
397	*/
398	int rc = pMod->pOps->pfnEnumSymbols(pMod, fFlags, pvBits, BaseAddress, pfnCallback, pvUser);
399	LogFlow(("RTLdrEnumSymbols: returns %Rrc\n", rc));
400	return rc;
401	}
402	RT_EXPORT_SYMBOL(RTLdrEnumSymbols);
403
404
405	RTDECL(int) RTLdrEnumDbgInfo(RTLDRMOD hLdrMod, const void pvBits, PFNRTLDRENUMDBG pfnCallback, void pvUser)
406	{
407	LogFlow(("RTLdrEnumDbgInfo: hLdrMod=%RTldrm pvBits=%p pfnCallback=%p pvUser=%p\n",
408	hLdrMod, pvBits, pfnCallback, pvUser));
409
410	/*
411	* Validate input.
412	*/
413	AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
414	AssertMsgReturn(!pvBits \|\| RT_VALID_PTR(pvBits), ("pvBits=%p\n", pvBits), VERR_INVALID_PARAMETER);
415	AssertMsgReturn(RT_VALID_PTR(pfnCallback), ("pfnCallback=%p\n", pfnCallback), VERR_INVALID_PARAMETER);
416	PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
417	//AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER);
418
419	/*
420	* Do it.
421	*/
422	int rc;
423	if (pMod->pOps->pfnEnumDbgInfo)
424	rc = pMod->pOps->pfnEnumDbgInfo(pMod, pvBits, pfnCallback, pvUser);
425	else
426	rc = VERR_NOT_SUPPORTED;
427
428	LogFlow(("RTLdrEnumDbgInfo: returns %Rrc\n", rc));
429	return rc;
430	}
431	RT_EXPORT_SYMBOL(RTLdrEnumDbgInfo);
432
433
434	RTDECL(int) RTLdrEnumSegments(RTLDRMOD hLdrMod, PFNRTLDRENUMSEGS pfnCallback, void *pvUser)
435	{
436	LogFlow(("RTLdrEnumSegments: hLdrMod=%RTldrm pfnCallback=%p pvUser=%p\n",
437	hLdrMod, pfnCallback, pvUser));
438
439	/*
440	* Validate input.
441	*/
442	AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
443	AssertMsgReturn(RT_VALID_PTR(pfnCallback), ("pfnCallback=%p\n", pfnCallback), VERR_INVALID_PARAMETER);
444	PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
445	//AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER);
446
447	/*
448	* Do it.
449	*/
450	int rc;
451	if (pMod->pOps->pfnEnumSegments)
452	rc = pMod->pOps->pfnEnumSegments(pMod, pfnCallback, pvUser);
453	else
454	rc = VERR_NOT_SUPPORTED;
455
456	LogFlow(("RTLdrEnumSegments: returns %Rrc\n", rc));
457	return rc;
458
459	}
460	RT_EXPORT_SYMBOL(RTLdrEnumSegments);
461
462
463	RTDECL(int) RTLdrLinkAddressToSegOffset(RTLDRMOD hLdrMod, RTLDRADDR LinkAddress, uint32_t *piSeg, PRTLDRADDR poffSeg)
464	{
465	LogFlow(("RTLdrLinkAddressToSegOffset: hLdrMod=%RTldrm LinkAddress=%RTptr piSeg=%p poffSeg=%p\n",
466	hLdrMod, LinkAddress, piSeg, poffSeg));
467
468	/*
469	* Validate input.
470	*/
471	AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
472	AssertPtrReturn(piSeg, VERR_INVALID_POINTER);
473	AssertPtrReturn(poffSeg, VERR_INVALID_POINTER);
474
475	PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
476	//AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER);
477
478	*piSeg = UINT32_MAX;
479	*poffSeg = ~(RTLDRADDR)0;
480
481	/*
482	* Do it.
483	*/
484	int rc;
485	if (pMod->pOps->pfnLinkAddressToSegOffset)
486	rc = pMod->pOps->pfnLinkAddressToSegOffset(pMod, LinkAddress, piSeg, poffSeg);
487	else
488	rc = VERR_NOT_SUPPORTED;
489
490	LogFlow(("RTLdrLinkAddressToSegOffset: returns %Rrc %#x:%RTptr\n", rc, piSeg, poffSeg));
491	return rc;
492	}
493	RT_EXPORT_SYMBOL(RTLdrLinkAddressToSegOffset);
494
495
496	RTDECL(int) RTLdrLinkAddressToRva(RTLDRMOD hLdrMod, RTLDRADDR LinkAddress, PRTLDRADDR pRva)
497	{
498	LogFlow(("RTLdrLinkAddressToRva: hLdrMod=%RTldrm LinkAddress=%RTptr pRva=%p\n",
499	hLdrMod, LinkAddress, pRva));
500
501	/*
502	* Validate input.
503	*/
504	AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
505	AssertPtrReturn(pRva, VERR_INVALID_POINTER);
506
507	PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
508	//AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER);
509
510	*pRva = ~(RTLDRADDR)0;
511
512	/*
513	* Do it.
514	*/
515	int rc;
516	if (pMod->pOps->pfnLinkAddressToRva)
517	rc = pMod->pOps->pfnLinkAddressToRva(pMod, LinkAddress, pRva);
518	else
519	rc = VERR_NOT_SUPPORTED;
520
521	LogFlow(("RTLdrLinkAddressToRva: returns %Rrc %RTptr\n", rc, *pRva));
522	return rc;
523	}
524	RT_EXPORT_SYMBOL(RTLdrLinkAddressToRva);
525
526
527	RTDECL(int) RTLdrSegOffsetToRva(RTLDRMOD hLdrMod, uint32_t iSeg, RTLDRADDR offSeg, PRTLDRADDR pRva)
528	{
529	LogFlow(("RTLdrSegOffsetToRva: hLdrMod=%RTldrm iSeg=%#x offSeg=%RTptr pRva=%p\n", hLdrMod, iSeg, offSeg, pRva));
530
531	/*
532	* Validate input.
533	*/
534	AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
535	AssertPtrReturn(pRva, VERR_INVALID_POINTER);
536
537	PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
538	//AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER);
539
540	*pRva = ~(RTLDRADDR)0;
541
542	/*
543	* Do it.
544	*/
545	int rc;
546	if (pMod->pOps->pfnSegOffsetToRva)
547	rc = pMod->pOps->pfnSegOffsetToRva(pMod, iSeg, offSeg, pRva);
548	else
549	rc = VERR_NOT_SUPPORTED;
550
551	LogFlow(("RTLdrSegOffsetToRva: returns %Rrc %RTptr\n", rc, *pRva));
552	return rc;
553	}
554	RT_EXPORT_SYMBOL(RTLdrSegOffsetToRva);
555
556	RTDECL(int) RTLdrRvaToSegOffset(RTLDRMOD hLdrMod, RTLDRADDR Rva, uint32_t *piSeg, PRTLDRADDR poffSeg)
557	{
558	LogFlow(("RTLdrRvaToSegOffset: hLdrMod=%RTldrm Rva=%RTptr piSeg=%p poffSeg=%p\n",
559	hLdrMod, Rva, piSeg, poffSeg));
560
561	/*
562	* Validate input.
563	*/
564	AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
565	AssertPtrReturn(piSeg, VERR_INVALID_POINTER);
566	AssertPtrReturn(poffSeg, VERR_INVALID_POINTER);
567
568	PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
569	//AssertMsgReturn(pMod->eState == LDR_STATE_OPENED, ("eState=%d\n", pMod->eState), VERR_WRONG_ORDER);
570
571	*piSeg = UINT32_MAX;
572	*poffSeg = ~(RTLDRADDR)0;
573
574	/*
575	* Do it.
576	*/
577	int rc;
578	if (pMod->pOps->pfnRvaToSegOffset)
579	rc = pMod->pOps->pfnRvaToSegOffset(pMod, Rva, piSeg, poffSeg);
580	else
581	rc = VERR_NOT_SUPPORTED;
582
583	LogFlow(("RTLdrRvaToSegOffset: returns %Rrc %#x:%RTptr\n", rc, piSeg, poffSeg));
584	return rc;
585	}
586	RT_EXPORT_SYMBOL(RTLdrRvaToSegOffset);
587
588
589	RTDECL(int) RTLdrQueryProp(RTLDRMOD hLdrMod, RTLDRPROP enmProp, void *pvBuf, size_t cbBuf)
590	{
591	return RTLdrQueryPropEx(hLdrMod, enmProp, NULL /pvBits/, pvBuf, cbBuf, NULL);
592	}
593	RT_EXPORT_SYMBOL(RTLdrQueryProp);
594
595
596	RTDECL(int) RTLdrQueryPropEx(RTLDRMOD hLdrMod, RTLDRPROP enmProp, void pvBits, void pvBuf, size_t cbBuf, size_t *pcbRet)
597	{
598	AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), RTLDRENDIAN_INVALID);
599	PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
600
601	AssertPtrNullReturn(pcbRet, VERR_INVALID_POINTER);
602	size_t cbRet;
603	if (!pcbRet)
604	pcbRet = &cbRet;
605
606	/*
607	* Do some pre screening of the input
608	*/
609	switch (enmProp)
610	{
611	case RTLDRPROP_UUID:
612	*pcbRet = sizeof(RTUUID);
613	AssertReturn(cbBuf == sizeof(RTUUID), VERR_INVALID_PARAMETER);
614	break;
615	case RTLDRPROP_TIMESTAMP_SECONDS:
616	*pcbRet = sizeof(int64_t);
617	AssertReturn(cbBuf == sizeof(int32_t) \|\| cbBuf == sizeof(int64_t), VERR_INVALID_PARAMETER);
618	break;
619	case RTLDRPROP_IS_SIGNED:
620	*pcbRet = sizeof(bool);
621	AssertReturn(cbBuf == sizeof(bool), VERR_INVALID_PARAMETER);
622	break;
623	case RTLDRPROP_PKCS7_SIGNED_DATA:
624	*pcbRet = 0;
625	break;
626	case RTLDRPROP_SIGNATURE_CHECKS_ENFORCED:
627	*pcbRet = sizeof(bool);
628	AssertReturn(cbBuf == sizeof(bool), VERR_INVALID_PARAMETER);
629	break;
630	case RTLDRPROP_IMPORT_COUNT:
631	*pcbRet = sizeof(uint32_t);
632	AssertReturn(cbBuf == sizeof(uint32_t), VERR_INVALID_PARAMETER);
633	break;
634	case RTLDRPROP_IMPORT_MODULE:
635	*pcbRet = sizeof(uint32_t);
636	AssertReturn(cbBuf >= sizeof(uint32_t), VERR_INVALID_PARAMETER);
637	break;
638
639	default:
640	AssertFailedReturn(VERR_INVALID_FUNCTION);
641	}
642	AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
643
644	/*
645	* Call the image specific worker, if there is one.
646	*/
647	if (!pMod->pOps->pfnQueryProp)
648	return VERR_NOT_SUPPORTED;
649	return pMod->pOps->pfnQueryProp(pMod, enmProp, pvBits, pvBuf, cbBuf, pcbRet);
650	}
651	RT_EXPORT_SYMBOL(RTLdrQueryPropEx);
652
653
654	RTDECL(int) RTLdrVerifySignature(RTLDRMOD hLdrMod, PFNRTLDRVALIDATESIGNEDDATA pfnCallback, void *pvUser, PRTERRINFO pErrInfo)
655	{
656	AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
657	PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
658	AssertPtrReturn(pfnCallback, VERR_INVALID_POINTER);
659
660	/*
661	* Call the image specific worker, if there is one.
662	*/
663	if (!pMod->pOps->pfnVerifySignature)
664	return VERR_NOT_SUPPORTED;
665	return pMod->pOps->pfnVerifySignature(pMod, pfnCallback, pvUser, pErrInfo);
666	}
667	RT_EXPORT_SYMBOL(RTLdrVerifySignature);
668
669
670	RTDECL(int) RTLdrHashImage(RTLDRMOD hLdrMod, RTDIGESTTYPE enmDigest, char *pszDigest, size_t cbDigest)
671	{
672	AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
673	PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
674
675	/*
676	* Make sure there is sufficient space for the wanted digest and that
677	* it's supported.
678	*/
679	switch (enmDigest)
680	{
681	case RTDIGESTTYPE_MD5: AssertReturn(cbDigest >= RTMD5_DIGEST_LEN + 1, VERR_BUFFER_OVERFLOW); break;
682	case RTDIGESTTYPE_SHA1: AssertReturn(cbDigest >= RTSHA1_DIGEST_LEN + 1, VERR_BUFFER_OVERFLOW); break;
683	case RTDIGESTTYPE_SHA256: AssertReturn(cbDigest >= RTSHA256_DIGEST_LEN + 1, VERR_BUFFER_OVERFLOW); break;
684	case RTDIGESTTYPE_SHA512: AssertReturn(cbDigest >= RTSHA512_DIGEST_LEN + 1, VERR_BUFFER_OVERFLOW); break;
685	default:
686	if (enmDigest > RTDIGESTTYPE_INVALID && enmDigest < RTDIGESTTYPE_END)
687	return VERR_NOT_SUPPORTED;
688	AssertFailedReturn(VERR_INVALID_PARAMETER);
689	}
690	AssertPtrReturn(pszDigest, VERR_INVALID_POINTER);
691
692	/*
693	* Call the image specific worker, if there is one.
694	*/
695	if (!pMod->pOps->pfnHashImage)
696	return VERR_NOT_SUPPORTED;
697	return pMod->pOps->pfnHashImage(pMod, enmDigest, pszDigest, cbDigest);
698	}
699	RT_EXPORT_SYMBOL(RTLdrHashImage);
700
701
702	/**
703	* Internal method used by the IPRT debug bits.
704	*
705	* @returns IPRT status code.
706	* @param hLdrMod The loader handle which executable we wish to
707	* read from.
708	* @param pvBuf The output buffer.
709	* @param iDbgInfo The debug info ordinal number if the request
710	* corresponds exactly to a debug info part from
711	* pfnEnumDbgInfo. Otherwise, pass UINT32_MAX.
712	* @param off Where in the executable file to start reading.
713	* @param cb The number of bytes to read.
714	*
715	* @remarks Fixups will only be applied if @a iDbgInfo is specified.
716	*/
717	DECLHIDDEN(int) rtLdrReadAt(RTLDRMOD hLdrMod, void *pvBuf, uint32_t iDbgInfo, RTFOFF off, size_t cb)
718	{
719	AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
720	PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
721
722	if (iDbgInfo != UINT32_MAX)
723	{
724	AssertReturn(pMod->pOps->pfnReadDbgInfo, VERR_NOT_SUPPORTED);
725	return pMod->pOps->pfnReadDbgInfo(pMod, iDbgInfo, off, cb, pvBuf);
726	}
727
728	AssertReturn(pMod->pReader, VERR_NOT_SUPPORTED);
729	return pMod->pReader->pfnRead(pMod->pReader, pvBuf, cb, off);
730	}
731
732
733	/**
734	* Translates a RTLDRARCH value to a string.
735	*
736	* @returns Name corresponding to @a enmArch
737	* @param enmArch The value to name.
738	*/
739	DECLHIDDEN(const char *) rtLdrArchName(RTLDRARCH enmArch)
740	{
741	switch (enmArch)
742	{
743	case RTLDRARCH_INVALID: return "INVALID";
744	case RTLDRARCH_WHATEVER: return "WHATEVER";
745	case RTLDRARCH_HOST: return "HOST";
746	case RTLDRARCH_AMD64: return "AMD64";
747	case RTLDRARCH_X86_32: return "X86_32";
748
749	case RTLDRARCH_END:
750	case RTLDRARCH_32BIT_HACK:
751	break;
752	}
753	return "UNKNOWN";
754	}

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

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

Download in other formats: