RTLdrCheckImports.cpp@ 98103

Last change on this file since 98103 was 98103, checked in by vboxsync, 23 months ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 27.5 KB

Line
1	/* $Id: RTLdrCheckImports.cpp 98103 2023-01-17 14:15:46Z vboxsync $ */
2	/** @file
3	* IPRT - Module dependency checker.
4	*/
5
6	/*
7	* Copyright (C) 2010-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* The contents of this file may alternatively be used under the terms
26	* of the Common Development and Distribution License Version 1.0
27	* (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
28	* in the VirtualBox distribution, in which case the provisions of the
29	* CDDL are applicable instead of those of the GPL.
30	*
31	* You may elect to license modified versions of this file under the
32	* terms and conditions of either the GPL or the CDDL or both.
33	*
34	* SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
35	*/
36
37
38	/*********************************************************************************************************************************
39	* Header Files *
40	*********************************************************************************************************************************/
41	#include <iprt/ctype.h>
42	#include <iprt/err.h>
43	#include <iprt/getopt.h>
44	#include <iprt/buildconfig.h>
45	#include <iprt/file.h>
46	#include <iprt/initterm.h>
47	#include <iprt/ldr.h>
48	#include <iprt/mem.h>
49	#include <iprt/message.h>
50	#include <iprt/path.h>
51	#include <iprt/string.h>
52	#include <iprt/stream.h>
53	#include <iprt/vfs.h>
54
55
56	/*********************************************************************************************************************************
57	* Structures and Typedefs *
58	*********************************************************************************************************************************/
59	/**
60	* Import checker options.
61	*/
62	typedef struct RTCHECKIMPORTSOPTS
63	{
64	/** Number of paths to search. */
65	size_t cPaths;
66	/** Search directories. */
67	char **papszPaths;
68	/** The loader architecture. */
69	RTLDRARCH enmLdrArch;
70	/** Verbosity level. */
71	unsigned cVerbosity;
72	/** Whether to also list orinals in the export listing. */
73	bool fListOrdinals;
74	} RTCHECKIMPORTSOPTS;
75	/** Pointer to the checker options. */
76	typedef RTCHECKIMPORTSOPTS *PRTCHECKIMPORTSOPTS;
77	/** Pointer to the const checker options. */
78	typedef RTCHECKIMPORTSOPTS const *PCRTCHECKIMPORTSOPTS;
79
80
81	/**
82	* Import module.
83	*/
84	typedef struct RTCHECKIMPORTMODULE
85	{
86	/** The module. If NIL, then we've got a export list (papszExports). */
87	RTLDRMOD hLdrMod;
88	/** Number of export in the export list. (Zero if hLdrMod is valid.) */
89	size_t cExports;
90	/** Export list. (NULL if hLdrMod is valid.) */
91	char **papszExports;
92	/** The module name. */
93	char szModule[256];
94	} RTCHECKIMPORTMODULE;
95	/** Pointer to an import module. */
96	typedef RTCHECKIMPORTMODULE *PRTCHECKIMPORTMODULE;
97
98
99	/**
100	* Import checker state (for each image being checked).
101	*/
102	typedef struct RTCHECKIMPORTSTATE
103	{
104	/** The image we're processing. */
105	const char *pszImage;
106	/** The image we're processing. */
107	PCRTCHECKIMPORTSOPTS pOpts;
108	/** Status code. */
109	int iRc;
110	/** Import hint. */
111	uint32_t iHint;
112	/** Number modules. */
113	uint32_t cImports;
114	/** Import modules. */
115	RT_FLEXIBLE_ARRAY_EXTENSION
116	RTCHECKIMPORTMODULE aImports[RT_FLEXIBLE_ARRAY];
117	} RTCHECKIMPORTSTATE;
118	/** Pointer to the import checker state. */
119	typedef RTCHECKIMPORTSTATE *PRTCHECKIMPORTSTATE;
120
121
122
123	/**
124	* Looks up a symbol/ordinal in the given import module.
125	*
126	* @returns IPRT status code.
127	* @param pModule The import module.
128	* @param pszSymbol The symbol name (NULL if not used).
129	* @param uSymbol The ordinal (~0 if unused).
130	* @param pValue Where to return a fake address.
131	*/
132	static int QuerySymbolFromImportModule(PRTCHECKIMPORTMODULE pModule, const char *pszSymbol, unsigned uSymbol, PRTLDRADDR pValue)
133	{
134	if (pModule->hLdrMod != NIL_RTLDRMOD)
135	return RTLdrGetSymbolEx(pModule->hLdrMod, NULL, _128M, uSymbol, pszSymbol, pValue);
136
137	/*
138	* Search the export list. Ordinal imports are stringified: #<ordinal>
139	*/
140	char szOrdinal[32];
141	if (!pszSymbol)
142	{
143	RTStrPrintf(szOrdinal, sizeof(szOrdinal), "#%u", uSymbol);
144	pszSymbol = szOrdinal;
145	}
146
147	size_t i = pModule->cExports;
148	while (i-- > 0)
149	if (strcmp(pModule->papszExports[i], pszSymbol) == 0)
150	{
151	pValue = _128M + i4;
152	return VINF_SUCCESS;
153	}
154	return VERR_SYMBOL_NOT_FOUND;
155	}
156
157
158	/**
159	* @callback_method_impl{FNRTLDRIMPORT}
160	*/
161	static DECLCALLBACK(int) GetImportCallback(RTLDRMOD hLdrMod, const char pszModule, const char pszSymbol,
162	unsigned uSymbol, PRTLDRADDR pValue, void *pvUser)
163	{
164	PRTCHECKIMPORTSTATE pState = (PRTCHECKIMPORTSTATE)pvUser;
165	int rc;
166	NOREF(hLdrMod);
167
168	/*
169	* If a module is given, lookup the symbol/ordinal there.
170	*/
171	if (pszModule)
172	{
173	uint32_t iModule = pState->iHint;
174	if ( iModule > pState->cImports
175	\|\| strcmp(pState->aImports[iModule].szModule, pszModule) != 0)
176	{
177	for (iModule = 0; iModule < pState->cImports; iModule++)
178	if (strcmp(pState->aImports[iModule].szModule, pszModule) == 0)
179	break;
180	if (iModule >= pState->cImports)
181	return RTMsgErrorRc(VERR_MODULE_NOT_FOUND, "%s: Failed to locate import module '%s'", pState->pszImage, pszModule);
182	pState->iHint = iModule;
183	}
184
185	rc = QuerySymbolFromImportModule(&pState->aImports[iModule], pszSymbol, uSymbol, pValue);
186	if (RT_SUCCESS(rc))
187	{ /* likely */ }
188	else if (rc == VERR_LDR_FORWARDER)
189	rc= VINF_SUCCESS;
190	else
191	{
192	if (pszSymbol)
193	RTMsgError("%s: Missing import '%s' from '%s'!", pState->pszImage, pszSymbol, pszModule);
194	else
195	RTMsgError("%s: Missing import #%u from '%s'!", pState->pszImage, uSymbol, pszModule);
196	pState->iRc = rc;
197	rc = VINF_SUCCESS;
198	*pValue = _128M + _4K;
199	}
200	}
201	/*
202	* Otherwise we need to scan all modules.
203	*/
204	else
205	{
206	Assert(pszSymbol);
207	uint32_t iModule = pState->iHint;
208	if (iModule < pState->cImports)
209	rc = QuerySymbolFromImportModule(&pState->aImports[iModule], pszSymbol, uSymbol, pValue);
210	else
211	rc = VERR_SYMBOL_NOT_FOUND;
212	if (rc == VERR_SYMBOL_NOT_FOUND)
213	{
214	for (iModule = 0; iModule < pState->cImports; iModule++)
215	{
216	rc = QuerySymbolFromImportModule(&pState->aImports[iModule], pszSymbol, uSymbol, pValue);
217	if (rc != VERR_SYMBOL_NOT_FOUND)
218	break;
219	}
220	}
221	if (RT_FAILURE(rc))
222	{
223	RTMsgError("%s: Missing import '%s'!", pState->pszImage, pszSymbol);
224	pState->iRc = rc;
225	rc = VINF_SUCCESS;
226	*pValue = _128M + _4K;
227	}
228	}
229	return rc;
230	}
231
232
233	/**
234	* Loads an imported module.
235	*
236	* @returns IPRT status code.
237	* @param pOpts The check program options.
238	* @param pModule The import module.
239	* @param pErrInfo Error buffer (to avoid wasting stack).
240	* @param pszImage The image we're processing (for error messages).
241	*/
242	static int LoadImportModule(PCRTCHECKIMPORTSOPTS pOpts, PRTCHECKIMPORTMODULE pModule, PRTERRINFO pErrInfo, const char *pszImage)
243
244	{
245	/*
246	* Look for real DLLs.
247	*/
248	for (uint32_t iPath = 0; iPath < pOpts->cPaths; iPath++)
249	{
250	char szPath[RTPATH_MAX];
251	int rc = RTPathJoin(szPath, sizeof(szPath), pOpts->papszPaths[iPath], pModule->szModule);
252	if (RT_SUCCESS(rc))
253	{
254	uint32_t offError;
255	RTFSOBJINFO ObjInfo;
256	rc = RTVfsChainQueryInfo(szPath, &ObjInfo, RTFSOBJATTRADD_NOTHING, RTPATH_F_FOLLOW_LINK, &offError, pErrInfo);
257	if (RT_SUCCESS(rc))
258	{
259	if (RTFS_IS_FILE(ObjInfo.Attr.fMode))
260	{
261	RTLDRMOD hLdrMod;
262	rc = RTLdrOpenVfsChain(szPath, RTLDR_O_FOR_DEBUG, pOpts->enmLdrArch, &hLdrMod, &offError, pErrInfo);
263	if (RT_SUCCESS(rc))
264	{
265	pModule->hLdrMod = hLdrMod;
266	if (pOpts->cVerbosity > 0)
267	RTMsgInfo("Import '%s' -> '%s'\n", pModule->szModule, szPath);
268	}
269	else if (RTErrInfoIsSet(pErrInfo))
270	RTMsgError("%s: Failed opening import image '%s': %Rrc - %s", pszImage, szPath, rc, pErrInfo->pszMsg);
271	else
272	RTMsgError("%s: Failed opening import image '%s': %Rrc", pszImage, szPath, rc);
273	return rc;
274	}
275	}
276	else if ( rc != VERR_PATH_NOT_FOUND
277	&& rc != VERR_FILE_NOT_FOUND)
278	RTVfsChainMsgError("RTVfsChainQueryInfo", szPath, rc, offError, pErrInfo);
279
280	/*
281	* Check for export file.
282	*/
283	RTStrCat(szPath, sizeof(szPath), ".exports");
284	RTVFSFILE hVfsFile;
285	rc = RTVfsChainOpenFile(szPath, RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE, &hVfsFile, &offError, pErrInfo);
286	if (RT_SUCCESS(rc))
287	{
288	/* Read it into a memory buffer. */
289	uint64_t cbFile;
290	rc = RTVfsFileQuerySize(hVfsFile, &cbFile);
291	if (RT_SUCCESS(rc))
292	{
293	if (cbFile < _4M)
294	{
295	char pszFile = (char )RTMemAlloc((size_t)cbFile + 1);
296	if (pszFile)
297	{
298	rc = RTVfsFileRead(hVfsFile, pszFile, (size_t)cbFile, NULL);
299	if (RT_SUCCESS(rc))
300	{
301	pszFile[(size_t)cbFile] = '\0';
302	rc = RTStrValidateEncoding(pszFile);
303	if (RT_SUCCESS(rc))
304	{
305	/*
306	* Parse it.
307	*/
308	size_t iLine = 1;
309	size_t off = 0;
310	while (off < cbFile)
311	{
312	size_t const offStartLine = off;
313
314	/* skip leading blanks */
315	while (RT_C_IS_BLANK(pszFile[off]))
316	off++;
317
318	char ch = pszFile[off];
319	if ( ch != ';' /* comment */
320	&& !RT_C_IS_CNTRL(ch))
321	{
322	/* find length of symbol */
323	size_t const offSymbol = off;
324	while ( (ch = pszFile[off]) != '\0'
325	&& !RT_C_IS_SPACE(ch))
326	off++;
327	size_t const cchSymbol = off - offSymbol;
328
329	/* add it. */
330	if ((pModule->cExports & 127) == 0)
331	{
332	void *pvNew = RTMemRealloc(pModule->papszExports,
333	(pModule->cExports + 128) * sizeof(char *));
334	if (!pvNew)
335	{
336	rc = RTMsgErrorRc(VERR_NO_MEMORY, "%s: %s:%u: out of memory!", pszImage, szPath, iLine);
337	break;
338	}
339	pModule->papszExports = (char **)pvNew;
340	}
341	pModule->papszExports[pModule->cExports] = RTStrDupN(&pszFile[offSymbol], cchSymbol);
342	if (pModule->papszExports[pModule->cExports])
343	pModule->cExports++;
344	else
345	{
346	rc = RTMsgErrorRc(VERR_NO_MEMORY, "%s: %s:%u: out of memory!", pszImage, szPath, iLine);
347	break;
348	}
349
350	/* check what comes next is a comment or end of line/file */
351	while (RT_C_IS_BLANK(pszFile[off]))
352	off++;
353	ch = pszFile[off];
354	if ( ch != '\0'
355	&& ch != '\n'
356	&& ch != '\r'
357	&& ch != ';')
358	rc = RTMsgErrorRc(VERR_PARSE_ERROR, "%s: %s:%u: Unexpected text at position %u!",
359	pszImage, szPath, iLine, off - offStartLine);
360	}
361
362	/* advance to the end of the the line */
363	while ( (ch = pszFile[off]) != '\0'
364	&& ch != '\n')
365	off++;
366	off++;
367	iLine++;
368	}
369
370	if (pOpts->cVerbosity > 0)
371	RTMsgInfo("Import '%s' -> '%s' (%u exports)\n",
372	pModule->szModule, szPath, pModule->cExports);
373	}
374	else
375	RTMsgError("%s: %s: Invalid UTF-8 encoding in export file: %Rrc", pszImage, szPath, rc);
376	}
377	RTMemFree(pszFile);
378	}
379	else
380	rc = RTMsgErrorRc(VERR_NO_MEMORY, "%s: %s: Out of memory reading export file (%#RX64 bytes)",
381	pszImage, szPath, cbFile + 1);
382	}
383	else
384	rc = RTMsgErrorRc(VERR_NO_MEMORY, "%s: %s: Export file is too big: %#RX64 bytes, max 4MiB",
385	pszImage, szPath, cbFile);
386	}
387	else
388	RTMsgError("%s: %s: RTVfsFileQuerySize failed on export file: %Rrc", pszImage, szPath, rc);
389	RTVfsFileRelease(hVfsFile);
390	return rc;
391	}
392	else if ( rc != VERR_PATH_NOT_FOUND
393	&& rc != VERR_FILE_NOT_FOUND)
394	RTVfsChainMsgError("RTVfsChainOpenFile", szPath, rc, offError, pErrInfo);
395	}
396	}
397
398	return RTMsgErrorRc(VERR_MODULE_NOT_FOUND, "%s: Import module '%s' was not found!", pszImage, pModule->szModule);
399	}
400
401
402	/**
403	* Checks the imports for the given image.
404	*
405	* @returns IPRT status code.
406	* @param pOpts The check program options.
407	* @param pszImage The image to check.
408	*/
409	static int rtCheckImportsForImage(PCRTCHECKIMPORTSOPTS pOpts, const char *pszImage)
410	{
411	if (pOpts->cVerbosity > 0)
412	RTMsgInfo("Checking '%s'...\n", pszImage);
413
414	/*
415	* Open the image.
416	*/
417	uint32_t offError;
418	RTERRINFOSTATIC ErrInfo;
419	RTLDRMOD hLdrMod;
420	int rc = RTLdrOpenVfsChain(pszImage, RTLDR_O_FOR_DEBUG, RTLDRARCH_WHATEVER,
421	&hLdrMod, &offError, RTErrInfoInitStatic(&ErrInfo));
422	if (RT_FAILURE(rc))
423	{
424	if (RT_FAILURE(rc) && RTErrInfoIsSet(&ErrInfo.Core))
425	return RTMsgErrorRc(rc, "Failed opening image '%s': %Rrc - %s", pszImage, rc, ErrInfo.Core.pszMsg);
426	return RTMsgErrorRc(rc, "Failed opening image '%s': %Rrc", pszImage, rc);
427	}
428
429	/*
430	* Do the import modules first.
431	*/
432	uint32_t cImports = 0;
433	rc = RTLdrQueryProp(hLdrMod, RTLDRPROP_IMPORT_COUNT, &cImports, sizeof(cImports));
434	if (RT_SUCCESS(rc))
435	{
436	RTCHECKIMPORTSTATE pState = (RTCHECKIMPORTSTATE )RTMemAllocZ(RT_UOFFSETOF_DYN(RTCHECKIMPORTSTATE, aImports[cImports + 1]));
437	if (pState)
438	{
439	pState->pszImage = pszImage;
440	pState->pOpts = pOpts;
441	pState->cImports = cImports;
442	for (uint32_t iImport = 0; iImport < cImports; iImport++)
443	pState->aImports[iImport].hLdrMod = NIL_RTLDRMOD;
444
445	for (uint32_t iImport = 0; iImport < cImports; iImport++)
446	{
447	(uint32_t )&pState->aImports[iImport].szModule[0] = iImport;
448	rc = RTLdrQueryProp(hLdrMod, RTLDRPROP_IMPORT_MODULE, pState->aImports[iImport].szModule,
449	sizeof(pState->aImports[iImport].szModule));
450	if (RT_FAILURE(rc))
451	{
452	RTMsgError("%s: Error querying import #%u: %Rrc", pszImage, iImport, rc);
453	break;
454	}
455	rc = LoadImportModule(pOpts, &pState->aImports[iImport], &ErrInfo.Core, pszImage);
456	if (RT_FAILURE(rc))
457	break;
458	}
459	if (RT_SUCCESS(rc))
460	{
461	/*
462	* Get the image bits, indirectly resolving imports.
463	*/
464	size_t cbImage = RTLdrSize(hLdrMod);
465	void *pvImage = RTMemAllocZ(cbImage);
466	if (pvImage)
467	{
468	pState->iRc = VINF_SUCCESS;
469	rc = RTLdrGetBits(hLdrMod, pvImage, _4M, GetImportCallback, pState);
470	if (RT_SUCCESS(rc))
471	rc = pState->iRc;
472	else
473	RTMsgError("%s: RTLdrGetBits failed: %Rrc", pszImage, rc);
474
475	RTMemFree(pvImage);
476	}
477	else
478	rc = RTMsgErrorRc(VERR_NO_MEMORY, "%s: out of memory", pszImage);
479	}
480
481	for (uint32_t iImport = 0; iImport < cImports; iImport++)
482	if (pState->aImports[iImport].hLdrMod != NIL_RTLDRMOD)
483	{
484	RTLdrClose(pState->aImports[iImport].hLdrMod);
485
486	size_t i = pState->aImports[iImport].cExports;
487	while (i-- > 0)
488	RTStrFree(pState->aImports[iImport].papszExports[i]);
489	RTMemFree(pState->aImports[iImport].papszExports);
490	}
491	RTMemFree(pState);
492	}
493	else
494	rc = RTMsgErrorRc(VERR_NO_MEMORY, "%s: out of memory", pszImage);
495	}
496	else
497	RTMsgError("%s: Querying RTLDRPROP_IMPORT_COUNT failed: %Rrc", pszImage, rc);
498	RTLdrClose(hLdrMod);
499	return rc;
500	}
501
502
503	/**
504	* @callback_method_impl{FNRTLDRENUMSYMS}
505	*/
506	static DECLCALLBACK(int) PrintSymbolForExportList(RTLDRMOD hLdrMod, const char *pszSymbol, unsigned uSymbol,
507	RTLDRADDR Value, void *pvUser)
508	{
509	if (pszSymbol)
510	RTPrintf("%s\n", pszSymbol);
511	if (uSymbol != ~(unsigned)0 && (!pszSymbol \|\| ((PCRTCHECKIMPORTSOPTS)pvUser)->fListOrdinals))
512	RTPrintf("#%u\n", uSymbol);
513	RT_NOREF(hLdrMod, Value, pvUser);
514	return VINF_SUCCESS;
515	}
516
517
518	/**
519	* Produces the export list for the given image.
520	*
521	* @returns IPRT status code.
522	* @param pOpts The check program options.
523	* @param pszImage Path to the image.
524	*/
525	static int ProduceExportList(PCRTCHECKIMPORTSOPTS pOpts, const char *pszImage)
526	{
527	/*
528	* Open the image.
529	*/
530	uint32_t offError;
531	RTERRINFOSTATIC ErrInfo;
532	RTLDRMOD hLdrMod;
533	int rc = RTLdrOpenVfsChain(pszImage, RTLDR_O_FOR_DEBUG, RTLDRARCH_WHATEVER, &hLdrMod, &offError, RTErrInfoInitStatic(&ErrInfo));
534	if (RT_SUCCESS(rc))
535	{
536	/*
537	* Some info about the file.
538	*/
539	RTPrintf(";\n"
540	"; Generated from: %s\n", pszImage);
541
542	RTFSOBJINFO ObjInfo;
543	rc = RTVfsChainQueryInfo(pszImage, &ObjInfo, RTFSOBJATTRADD_NOTHING, RTPATH_F_FOLLOW_LINK, NULL, NULL);
544	if (RT_SUCCESS(rc))
545	RTPrintf("; Size file: %#RX64 (%RU64)\n", ObjInfo.cbObject, ObjInfo.cbObject);
546
547	switch (RTLdrGetFormat(hLdrMod))
548	{
549	case RTLDRFMT_AOUT: RTPrintf("; Format: a.out\n"); break;
550	case RTLDRFMT_ELF: RTPrintf("; Format: ELF\n"); break;
551	case RTLDRFMT_LX: RTPrintf("; Format: LX\n"); break;
552	case RTLDRFMT_MACHO: RTPrintf("; Format: Mach-O\n"); break;
553	case RTLDRFMT_PE: RTPrintf("; Format: PE\n"); break;
554	default: RTPrintf("; Format: %u\n", RTLdrGetFormat(hLdrMod)); break;
555
556	}
557
558	RTPrintf("; Size of image: %#x (%u)\n", RTLdrSize(hLdrMod), RTLdrSize(hLdrMod));
559
560	switch (RTLdrGetArch(hLdrMod))
561	{
562	case RTLDRARCH_AMD64: RTPrintf("; Architecture: AMD64\n"); break;
563	case RTLDRARCH_X86_32: RTPrintf("; Architecture: X86\n"); break;
564	default: RTPrintf("; Architecture: %u\n", RTLdrGetArch(hLdrMod)); break;
565	}
566
567	uint64_t uTimestamp;
568	rc = RTLdrQueryProp(hLdrMod, RTLDRPROP_TIMESTAMP_SECONDS, &uTimestamp, sizeof(uTimestamp));
569	if (RT_SUCCESS(rc))
570	{
571	RTTIMESPEC Timestamp;
572	char szTime[128];
573	RTTimeSpecToString(RTTimeSpecSetSeconds(&Timestamp, uTimestamp), szTime, sizeof(szTime));
574	char *pszEnd = strchr(szTime, '\0');
575	while (pszEnd[0] != '.')
576	pszEnd--;
577	*pszEnd = '\0';
578	RTPrintf("; Timestamp: %#RX64 - %s\n", uTimestamp, szTime);
579	}
580
581	RTUUID ImageUuid;
582	rc = RTLdrQueryProp(hLdrMod, RTLDRPROP_UUID, &ImageUuid, sizeof(ImageUuid));
583	if (RT_SUCCESS(rc))
584	RTPrintf("; UUID: %RTuuid\n", &ImageUuid);
585
586	RTPrintf(";\n");
587
588	/*
589	* The list of exports.
590	*/
591	rc = RTLdrEnumSymbols(hLdrMod, 0 /fFlags/, NULL, _4M, PrintSymbolForExportList, (void *)pOpts);
592	if (RT_FAILURE(rc))
593	RTMsgError("%s: RTLdrEnumSymbols failed: %Rrc", pszImage, rc);
594
595	/* done */
596	RTLdrClose(hLdrMod);
597	}
598	else if (RTErrInfoIsSet(&ErrInfo.Core))
599	RTMsgError("Failed opening image '%s': %Rrc - %s", pszImage, rc, ErrInfo.Core.pszMsg);
600	else
601	RTMsgError("Failed opening image '%s': %Rrc", pszImage, rc);
602	return rc;
603	}
604
605
606	int main(int argc, char **argv)
607	{
608	int rc = RTR3InitExe(argc, &argv, 0);
609	if (RT_FAILURE(rc))
610	return RTMsgInitFailure(rc);
611
612	RTCHECKIMPORTSOPTS Opts;
613	Opts.cPaths = 0;
614	Opts.papszPaths = NULL;
615	Opts.enmLdrArch = RTLDRARCH_WHATEVER;
616	Opts.cVerbosity = 1;
617	Opts.fListOrdinals = false;
618
619	static const RTGETOPTDEF s_aOptions[] =
620	{
621	{ "--path", 'p', RTGETOPT_REQ_STRING },
622	{ "--export", 'e', RTGETOPT_REQ_STRING },
623	{ "--list-ordinals", 'O', RTGETOPT_REQ_NOTHING },
624	{ "--quiet", 'q', RTGETOPT_REQ_NOTHING },
625	{ "--verbose", 'v', RTGETOPT_REQ_NOTHING },
626	};
627	RTGETOPTSTATE State;
628	rc = RTGetOptInit(&State, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
629	AssertRCReturn(rc, RTEXITCODE_FAILURE);
630
631	RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
632	RTGETOPTUNION ValueUnion;
633	while ((rc = RTGetOpt(&State, &ValueUnion)) != 0)
634	{
635	switch (rc)
636	{
637	case 'p':
638	if ((Opts.cPaths % 16) == 0)
639	{
640	void pvNew = RTMemRealloc(Opts.papszPaths, sizeof(Opts.papszPaths[0]) (Opts.cPaths + 16));
641	AssertRCReturn(rc, RTEXITCODE_FAILURE);
642	Opts.papszPaths = (char **)pvNew;
643	}
644	Opts.papszPaths[Opts.cPaths] = RTStrDup(ValueUnion.psz);
645	AssertReturn(Opts.papszPaths[Opts.cPaths], RTEXITCODE_FAILURE);
646	Opts.cPaths++;
647	break;
648
649	case 'e':
650	rc = ProduceExportList(&Opts, ValueUnion.psz);
651	if (RT_FAILURE(rc))
652	rcExit = RTEXITCODE_FAILURE;
653	break;
654
655	case 'O':
656	Opts.fListOrdinals = true;
657	break;
658
659	case 'q':
660	Opts.cVerbosity = 0;
661	break;
662
663	case 'v':
664	Opts.cVerbosity = 0;
665	break;
666
667	case VINF_GETOPT_NOT_OPTION:
668	rc = rtCheckImportsForImage(&Opts, ValueUnion.psz);
669	if (RT_FAILURE(rc))
670	rcExit = RTEXITCODE_FAILURE;
671	break;
672
673	case 'h':
674	RTPrintf("Usage: RTCheckImports [-p\|--path <dir>] [-v\|--verbose] [-q\|--quiet] <image [..]>\n"
675	" or: RTCheckImports -e <image>\n"
676	" or: RTCheckImports <-h\|--help>\n"
677	" or: RTCheckImports <-V\|--version>\n"
678	"Checks library imports. VFS chain syntax supported.\n"
679	"\n"
680	"Options:\n"
681	" -p, --path <dir>\n"
682	" Search the specified directory for imported modules or their export lists.\n"
683	" -e, --export <image>\n"
684	" Write export list for the file to stdout. (Redirect to a .export file.)\n"
685	" -O, --list-ordinals\n"
686	" Whether to list ordinals as well as names in the export list.\n"
687	" -q, --quiet\n"
688	" Quiet execution.\n"
689	" -v, --verbose\n"
690	" Increases verbosity.\n"
691	""
692	);
693	return RTEXITCODE_SUCCESS;
694
695	#ifndef IPRT_IN_BUILD_TOOL
696	case 'V':
697	RTPrintf("%sr%s\n", RTBldCfgVersion(), RTBldCfgRevisionStr());
698	return RTEXITCODE_SUCCESS;
699	#endif
700
701	default:
702	return RTGetOptPrintError(rc, &ValueUnion);
703	}
704	}
705
706	return rcExit;
707	}
708

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

source: vbox/trunk/src/VBox/Runtime/tools/RTLdrCheckImports.cpp@ 98103

Download in other formats: