ntBldSymDb.cpp@ 49221

Last change on this file since 49221 was 45633, checked in by vboxsync, 12 years ago
Updated ntBldSymDb.cpp to handle w2k symbols and correctly detect some checked xp sympacks.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 44.5 KB

Line
1	/* $Id: ntBldSymDb.cpp 45633 2013-04-19 08:56:59Z vboxsync $ */
2	/** @file
3	* IPRT - RTDirCreateUniqueNumbered, generic implementation.
4	*/
5
6	/*
7	* Copyright (C) 2013 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	#include <Windows.h>
32	#include <Dbghelp.h>
33
34	#include <iprt/alloca.h>
35	#include <iprt/dir.h>
36	#include <iprt/file.h>
37	#include <iprt/getopt.h>
38	#include <iprt/initterm.h>
39	#include <iprt/list.h>
40	#include <iprt/mem.h>
41	#include <iprt/message.h>
42	#include <iprt/path.h>
43	#include <iprt/stream.h>
44	#include <iprt/string.h>
45	#include <iprt/err.h>
46
47	#include "r0drv/nt/symdb.h"
48
49
50	/*******************************************************************************
51	* Structures and Typedefs *
52	*******************************************************************************/
53	/** A structure member we're interested in. */
54	typedef struct MYMEMBER
55	{
56	/** The member name. */
57	const char * const pszName;
58	/** Reserved. */
59	uint32_t const fFlags;
60	/** The offset of the member. UINT32_MAX if not found. */
61	uint32_t off;
62	/** The size of the member. */
63	uint32_t cb;
64	/** Alternative names, optional.
65	* This is a string of zero terminated strings, ending with an zero length
66	* string (or double '\\0' if you like). */
67	const char * const pszzAltNames;
68	} MYMEMBER;
69	/** Pointer to a member we're interested. */
70	typedef MYMEMBER *PMYMEMBER;
71
72	/** Members we're interested in. */
73	typedef struct MYSTRUCT
74	{
75	/** The structure name. */
76	const char * const pszName;
77	/** Array of members we're interested in. */
78	MYMEMBER *paMembers;
79	/** The number of members we're interested in. */
80	uint32_t const cMembers;
81	/** Reserved. */
82	uint32_t const fFlags;
83	} MYSTRUCT;
84
85	/** Architecture. */
86	typedef enum MYARCH
87	{
88	MYARCH_X86,
89	MYARCH_AMD64,
90	MYARCH_DETECT
91	} MYARCH;
92
93	/** Set of structures for one kernel. */
94	typedef struct MYSET
95	{
96	/** The list entry. */
97	RTLISTNODE ListEntry;
98	/** The source PDB. */
99	char *pszPdb;
100	/** The OS version we've harvested structs for */
101	RTNTSDBOSVER OsVerInfo;
102	/** The architecture. */
103	MYARCH enmArch;
104	/** The structures and their member. */
105	MYSTRUCT aStructs[1];
106	} MYSET;
107	/** Pointer a set of structures for one kernel. */
108	typedef MYSET *PMYSET;
109
110
111	/*******************************************************************************
112	* Global Variables *
113	*******************************************************************************/
114	/** Verbosity level (-v, --verbose). */
115	static uint32_t g_iOptVerbose = 1;
116	/** Set if we should force ahead despite errors. */
117	static bool g_fOptForce = false;
118
119	/** The members of the KPRCB structure that we're interested in. */
120	static MYMEMBER g_aKprcbMembers[] =
121	{
122	{ "QuantumEnd", 0, UINT32_MAX, UINT32_MAX, NULL },
123	{ "DpcQueueDepth", 0, UINT32_MAX, UINT32_MAX, "DpcData[0].DpcQueueDepth\0" },
124	{ "VendorString", 0, UINT32_MAX, UINT32_MAX, NULL },
125	};
126
127	/** The structures we're interested in. */
128	static MYSTRUCT g_aStructs[] =
129	{
130	{ "_KPRCB", &g_aKprcbMembers[0], RT_ELEMENTS(g_aKprcbMembers), 0 },
131	};
132
133	/** List of data we've found. This is sorted by version info. */
134	static RTLISTANCHOR g_SetList;
135
136
137
138
139
140	/**
141	* For debug/verbose output.
142	*
143	* @param pszFormat The format string.
144	* @param ... The arguments referenced in the format string.
145	*/
146	static void MyDbgPrintf(const char *pszFormat, ...)
147	{
148	if (g_iOptVerbose > 1)
149	{
150	va_list va;
151	va_start(va, pszFormat);
152	RTPrintf("debug: ");
153	RTPrintfV(pszFormat, va);
154	va_end(va);
155	}
156	}
157
158
159	/**
160	* Returns the name we wish to use in the C code.
161	* @returns Structure name.
162	* @param pStruct The structure descriptor.
163	*/
164	static const char figureCStructName(MYSTRUCT const pStruct)
165	{
166	const char *psz = pStruct->pszName;
167	while (*psz == '_')
168	psz++;
169	return psz;
170	}
171
172
173	/**
174	* Returns the name we wish to use in the C code.
175	* @returns Member name.
176	* @param pStruct The member descriptor.
177	*/
178	static const char figureCMemberName(MYMEMBER const pMember)
179	{
180	return pMember->pszName;
181	}
182
183
184	/**
185	* Creates a MYSET with copies of all the data and inserts it into the
186	* g_SetList in a orderly fashion.
187	*
188	* @param pOut The output stream.
189	*/
190	static void generateHeader(PRTSTREAM pOut)
191	{
192	RTStrmPrintf(pOut,
193	"/* $" "I" "d" ": $ /\n" / avoid it being expanded */
194	"/** @file\n"
195	" * IPRT - NT kernel type helpers - Autogenerated, do NOT edit.\n"
196	" */\n"
197	"\n"
198	"/*\n"
199	" * Copyright (C) 2013 Oracle Corporation\n"
200	" *\n"
201	" * This file is part of VirtualBox Open Source Edition (OSE), as\n"
202	" * available from http://www.virtualbox.org. This file is free software;\n"
203	" * you can redistribute it and/or modify it under the terms of the GNU\n"
204	" * General Public License (GPL) as published by the Free Software\n"
205	" * Foundation, in version 2 as it comes in the \"COPYING\" file of the\n"
206	" * VirtualBox OSE distribution. VirtualBox OSE is distributed in the\n"
207	" * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.\n"
208	" *\n"
209	" * The contents of this file may alternatively be used under the terms\n"
210	" * of the Common Development and Distribution License Version 1.0\n"
211	" * (CDDL) only, as it comes in the \"COPYING.CDDL\" file of the\n"
212	" * VirtualBox OSE distribution, in which case the provisions of the\n"
213	" * CDDL are applicable instead of those of the GPL.\n"
214	" *\n"
215	" * You may elect to license modified versions of this file under the\n"
216	" * terms and conditions of either the GPL or the CDDL or both.\n"
217	" */\n"
218	"\n"
219	"\n"
220	"#ifndef ___r0drv_nt_symdbdata_h\n"
221	"#define ___r0drv_nt_symdbdata_h\n"
222	"\n"
223	"#include \"r0drv/nt/symdb.h\"\n"
224	"\n"
225	);
226
227	/*
228	* Generate types.
229	*/
230	for (uint32_t i = 0; i < RT_ELEMENTS(g_aStructs); i++)
231	{
232	const char *pszStructName = figureCStructName(&g_aStructs[i]);
233
234	RTStrmPrintf(pOut,
235	"typedef struct RTNTSDBTYPE_%s\n"
236	"{\n",
237	pszStructName);
238	PMYMEMBER paMembers = g_aStructs[i].paMembers;
239	for (uint32_t j = 0; j < g_aStructs->cMembers; j++)
240	{
241	const char *pszMemName = figureCMemberName(&paMembers[j]);
242	RTStrmPrintf(pOut,
243	" uint32_t off%s;\n"
244	" uint32_t cb%s;\n",
245	pszMemName, pszMemName);
246	}
247
248	RTStrmPrintf(pOut,
249	"} RTNTSDBTYPE_%s;\n"
250	"\n",
251	pszStructName);
252	}
253
254	RTStrmPrintf(pOut,
255	"\n"
256	"typedef struct RTNTSDBSET\n"
257	"{\n"
258	" RTNTSDBOSVER%-20s OsVerInfo;\n", "");
259	for (uint32_t i = 0; i < RT_ELEMENTS(g_aStructs); i++)
260	{
261	const char *pszStructName = figureCStructName(&g_aStructs[i]);
262	RTStrmPrintf(pOut, " RTNTSDBTYPE_%-20s %s;\n", pszStructName, pszStructName);
263	}
264	RTStrmPrintf(pOut,
265	"} RTNTSDBSET;\n"
266	"typedef RTNTSDBSET const *PCRTNTSDBSET;\n"
267	"\n");
268
269	/*
270	* Output the data.
271	*/
272	RTStrmPrintf(pOut,
273	"\n"
274	"#ifndef RTNTSDB_NO_DATA\n"
275	"const RTNTSDBSET g_artNtSdbSets[] = \n"
276	"{\n");
277	PMYSET pSet;
278	RTListForEach(&g_SetList, pSet, MYSET, ListEntry)
279	{
280	const char *pszArch = pSet->enmArch == MYARCH_AMD64 ? "AMD64" : "X86";
281	RTStrmPrintf(pOut,
282	"# ifdef RT_ARCH_%s\n"
283	" { /* Source: %s */\n"
284	" /.OsVerInfo = /\n"
285	" {\n"
286	" /* .uMajorVer = */ %u,\n"
287	" /* .uMinorVer = */ %u,\n"
288	" /* .fChecked = */ %s,\n"
289	" /* .fSmp = */ %s,\n"
290	" /* .uCsdNo = */ %u,\n"
291	" /* .uBuildNo = */ %u,\n"
292	" },\n",
293	pszArch,
294	pSet->pszPdb,
295	pSet->OsVerInfo.uMajorVer,
296	pSet->OsVerInfo.uMinorVer,
297	pSet->OsVerInfo.fChecked ? "true" : "false",
298	pSet->OsVerInfo.fSmp ? "true" : "false",
299	pSet->OsVerInfo.uCsdNo,
300	pSet->OsVerInfo.uBuildNo);
301	for (uint32_t i = 0; i < RT_ELEMENTS(pSet->aStructs); i++)
302	{
303	const char *pszStructName = figureCStructName(&pSet->aStructs[i]);
304	RTStrmPrintf(pOut,
305	" /* .%s = */\n"
306	" {\n", pszStructName);
307	PMYMEMBER paMembers = pSet->aStructs[i].paMembers;
308	for (uint32_t j = 0; j < pSet->aStructs[i].cMembers; j++)
309	{
310	const char *pszMemName = figureCMemberName(&paMembers[j]);
311	RTStrmPrintf(pOut,
312	" /* .off%-25s = */ %#06x,\n"
313	" /* .cb%-26s = */ %#06x,\n",
314	pszMemName, paMembers[j].off,
315	pszMemName, paMembers[j].cb);
316	}
317	RTStrmPrintf(pOut,
318	" },\n");
319	}
320	RTStrmPrintf(pOut,
321	" },\n"
322	"# endif\n"
323	);
324	}
325
326	RTStrmPrintf(pOut,
327	"};\n"
328	"#endif /* !RTNTSDB_NO_DATA */\n"
329	"\n");
330
331	RTStrmPrintf(pOut, "\n#endif\n\n");
332	}
333
334
335	/**
336	* Creates a MYSET with copies of all the data and inserts it into the
337	* g_SetList in a orderly fashion.
338	*
339	* @returns Fully complained exit code.
340	* @param pOsVerInfo The OS version info.
341	*/
342	static RTEXITCODE saveStructures(PRTNTSDBOSVER pOsVerInfo, MYARCH enmArch, const char *pszPdb)
343	{
344	/*
345	* Allocate one big chunk, figure it's size once.
346	*/
347	static size_t s_cbNeeded = 0;
348	if (s_cbNeeded == 0)
349	{
350	s_cbNeeded = RT_OFFSETOF(MYSET, aStructs[RT_ELEMENTS(g_aStructs)]);
351	for (uint32_t i = 0; i < RT_ELEMENTS(g_aStructs); i++)
352	s_cbNeeded += sizeof(MYMEMBER) * g_aStructs[i].cMembers;
353	}
354
355	size_t cbPdb = strlen(pszPdb) + 1;
356	PMYSET pSet = (PMYSET)RTMemAlloc(s_cbNeeded + cbPdb);
357	if (!pSet)
358	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Out of memory!\n");
359
360	/*
361	* Copy over the data.
362	*/
363	pSet->enmArch = enmArch;
364	memcpy(&pSet->OsVerInfo, pOsVerInfo, sizeof(pSet->OsVerInfo));
365	memcpy(&pSet->aStructs[0], g_aStructs, sizeof(g_aStructs));
366
367	PMYMEMBER pDst = (PMYMEMBER)&pSet->aStructs[RT_ELEMENTS(g_aStructs)];
368	for (uint32_t i = 0; i < RT_ELEMENTS(g_aStructs); i++)
369	{
370	pSet->aStructs[i].paMembers = pDst;
371	memcpy(pDst, g_aStructs[i].paMembers, g_aStructs[i].cMembers * sizeof(*pDst));
372	pDst += g_aStructs[i].cMembers;
373	}
374
375	pSet->pszPdb = (char *)pDst;
376	memcpy(pDst, pszPdb, cbPdb);
377
378	/*
379	* Link it.
380	*/
381	PMYSET pInsertBefore;
382	RTListForEach(&g_SetList, pInsertBefore, MYSET, ListEntry)
383	{
384	int iDiff = rtNtOsVerInfoCompare(&pInsertBefore->OsVerInfo, &pSet->OsVerInfo);
385	if (iDiff >= 0)
386	{
387	if (iDiff > 0 \|\| pInsertBefore->enmArch > pSet->enmArch)
388	{
389	RTListNodeInsertBefore(&pInsertBefore->ListEntry, &pSet->ListEntry);
390	return RTEXITCODE_SUCCESS;
391	}
392	}
393	}
394
395	RTListAppend(&g_SetList, &pSet->ListEntry);
396	return RTEXITCODE_SUCCESS;
397	}
398
399
400	/**
401	* Checks that we found everything.
402	*
403	* @returns Fully complained exit code.
404	*/
405	static RTEXITCODE checkThatWeFoundEverything(void)
406	{
407	RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
408	for (uint32_t i = 0; i < RT_ELEMENTS(g_aStructs); i++)
409	{
410	PMYMEMBER paMembers = g_aStructs[i].paMembers;
411	uint32_t j = g_aStructs[i].cMembers;
412	while (j-- > 0)
413	{
414	if (paMembers[j].off == UINT32_MAX)
415	rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, " Missing %s::%s\n", g_aStructs[i].pszName, paMembers[j].pszName);
416	}
417	}
418	return rcExit;
419	}
420
421
422	/**
423	* Matches the member against what we're looking for.
424	*
425	* @returns Number of hits.
426	* @param cWantedMembers The number members in paWantedMembers.
427	* @param paWantedMembers The members we're looking for.
428	* @param pszPrefix The member name prefix.
429	* @param pszMember The member name.
430	* @param offMember The member offset.
431	* @param cbMember The member size.
432	*/
433	static uint32_t matchUpStructMembers(unsigned cWantedMembers, PMYMEMBER paWantedMembers,
434	const char pszPrefix, const char pszMember,
435	uint32_t offMember, uint32_t cbMember)
436	{
437	size_t cchPrefix = strlen(pszPrefix);
438	uint32_t cHits = 0;
439	uint32_t iMember = cWantedMembers;
440	while (iMember-- > 0)
441	{
442	if ( !strncmp(pszPrefix, paWantedMembers[iMember].pszName, cchPrefix)
443	&& !strcmp(pszMember, paWantedMembers[iMember].pszName + cchPrefix))
444	{
445	paWantedMembers[iMember].off = offMember;
446	paWantedMembers[iMember].cb = cbMember;
447	cHits++;
448	}
449	else if (paWantedMembers[iMember].pszzAltNames)
450	{
451	char const *pszCur = paWantedMembers[iMember].pszzAltNames;
452	while (*pszCur)
453	{
454	size_t cchCur = strlen(pszCur);
455	if ( !strncmp(pszPrefix, pszCur, cchPrefix)
456	&& !strcmp(pszMember, pszCur + cchPrefix))
457	{
458	paWantedMembers[iMember].off = offMember;
459	paWantedMembers[iMember].cb = cbMember;
460	cHits++;
461	break;
462	}
463	pszCur += cchCur + 1;
464	}
465	}
466	}
467	return cHits;
468	}
469
470
471	/**
472	* Resets the writable structure members prior to processing a PDB.
473	*
474	* While processing the PDB, will fill in the sizes and offsets of what we find.
475	* Afterwards we'll use look for reset values to see that every structure and
476	* member was located successfully.
477	*/
478	static void resetMyStructs(void)
479	{
480	for (uint32_t i = 0; i < RT_ELEMENTS(g_aStructs); i++)
481	{
482	PMYMEMBER paMembers = g_aStructs[i].paMembers;
483	uint32_t j = g_aStructs[i].cMembers;
484	while (j-- > 0)
485	{
486	paMembers[j].off = UINT32_MAX;
487	paMembers[j].cb = UINT32_MAX;
488	}
489	}
490	}
491
492
493	/**
494	* Find members in the specified structure type (@a idxType).
495	*
496	* @returns Fully bitched exit code.
497	* @param hFake Fake process handle.
498	* @param uModAddr The module address.
499	* @param idxType The type index of the structure which members we're
500	* going to process.
501	* @param cWantedMembers The number of wanted members.
502	* @param paWantedMembers The wanted members. This will be modified.
503	* @param offDisp Displacement when calculating member offsets.
504	* @param pszStructNm The top level structure name.
505	* @param pszPrefix The member name prefix.
506	* @param pszLogTag The log tag.
507	*/
508	static RTEXITCODE findMembers(HANDLE hFake, uint64_t uModAddr, uint32_t idxType,
509	uint32_t cWantedMembers, PMYMEMBER paWantedMembers,
510	uint32_t offDisp, const char pszStructNm, const char pszPrefix, const char *pszLogTag)
511	{
512	RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
513
514	DWORD cChildren = 0;
515	if (!SymGetTypeInfo(hFake, uModAddr, idxType, TI_GET_CHILDRENCOUNT, &cChildren))
516	return RTMsgErrorExit(RTEXITCODE_FAILURE, "%s: TI_GET_CHILDRENCOUNT failed on _KPRCB: %u\n", pszLogTag, GetLastError());
517
518	MyDbgPrintf(" %s: cChildren=%u (%#x)\n", pszStructNm, cChildren);
519	TI_FINDCHILDREN_PARAMS *pChildren;
520	pChildren = (TI_FINDCHILDREN_PARAMS *)alloca(RT_OFFSETOF(TI_FINDCHILDREN_PARAMS, ChildId[cChildren]));
521	pChildren->Start = 0;
522	pChildren->Count = cChildren;
523	if (!SymGetTypeInfo(hFake, uModAddr, idxType, TI_FINDCHILDREN, pChildren))
524	return RTMsgErrorExit(RTEXITCODE_FAILURE, "%s: TI_FINDCHILDREN failed on _KPRCB: %u\n", pszLogTag, GetLastError());
525
526	for (uint32_t i = 0; i < cChildren; i++)
527	{
528	//MyDbgPrintf(" %s: child#%u: TypeIndex=%u\n", pszStructNm, i, pChildren->ChildId[i]);
529	IMAGEHLP_SYMBOL_TYPE_INFO enmErr;
530	PWCHAR pwszMember = NULL;
531	uint32_t idxRefType = 0;
532	uint32_t offMember = 0;
533	uint64_t cbMember = 0;
534	uint32_t cMemberChildren = 0;
535	if ( SymGetTypeInfo(hFake, uModAddr, pChildren->ChildId[i], enmErr = TI_GET_SYMNAME, &pwszMember)
536	&& SymGetTypeInfo(hFake, uModAddr, pChildren->ChildId[i], enmErr = TI_GET_OFFSET, &offMember)
537	&& SymGetTypeInfo(hFake, uModAddr, pChildren->ChildId[i], enmErr = TI_GET_TYPE, &idxRefType)
538	&& SymGetTypeInfo(hFake, uModAddr, idxRefType, enmErr = TI_GET_LENGTH, &cbMember)
539	&& SymGetTypeInfo(hFake, uModAddr, idxRefType, enmErr = TI_GET_CHILDRENCOUNT, &cMemberChildren)
540	)
541	{
542	offMember += offDisp;
543
544	char *pszMember;
545	int rc = RTUtf16ToUtf8(pwszMember, &pszMember);
546	if (RT_SUCCESS(rc))
547	{
548	matchUpStructMembers(cWantedMembers, paWantedMembers, pszPrefix, pszMember, offMember, cbMember);
549
550	/*
551	* Gather more info and do some debug printing. We'll use some
552	* of this info below when recursing into sub-structures
553	* and arrays.
554	*/
555	uint32_t fNested = 0; SymGetTypeInfo(hFake, uModAddr, idxRefType, TI_GET_NESTED, &fNested);
556	uint32_t uDataKind = 0; SymGetTypeInfo(hFake, uModAddr, idxRefType, TI_GET_DATAKIND, &uDataKind);
557	uint32_t uBaseType = 0; SymGetTypeInfo(hFake, uModAddr, idxRefType, TI_GET_BASETYPE, &uBaseType);
558	uint32_t uMembTag = 0; SymGetTypeInfo(hFake, uModAddr, pChildren->ChildId[i], TI_GET_SYMTAG, &uMembTag);
559	uint32_t uBaseTag = 0; SymGetTypeInfo(hFake, uModAddr, idxRefType, TI_GET_SYMTAG, &uBaseTag);
560	uint32_t cElements = 0; SymGetTypeInfo(hFake, uModAddr, idxRefType, TI_GET_COUNT, &cElements);
561	uint32_t idxArrayType = 0; SymGetTypeInfo(hFake, uModAddr, idxRefType, TI_GET_ARRAYINDEXTYPEID, &idxArrayType);
562	MyDbgPrintf(" %#06x LB %#06llx %c%c %2d %2d %2d %2d %2d %4d %s::%s%s\n",
563	offMember, cbMember,
564	cMemberChildren > 0 ? 'c' : '-',
565	fNested != 0 ? 'n' : '-',
566	uDataKind,
567	uBaseType,
568	uMembTag,
569	uBaseTag,
570	cElements,
571	idxArrayType,
572	pszStructNm,
573	pszPrefix,
574	pszMember);
575
576	/*
577	* Recurse into children.
578	*/
579	if (cMemberChildren > 0)
580	{
581	size_t cbNeeded = strlen(pszMember) + strlen(pszPrefix) + sizeof(".");
582	char pszSubPrefix = (char )RTMemTmpAlloc(cbNeeded);
583	if (pszSubPrefix)
584	{
585	strcat(strcat(strcpy(pszSubPrefix, pszPrefix), pszMember), ".");
586	RTEXITCODE rcExit2 = findMembers(hFake, uModAddr, idxRefType, cWantedMembers,
587	paWantedMembers, offMember,
588	pszStructNm,
589	pszSubPrefix,
590	pszLogTag);
591	if (rcExit2 != RTEXITCODE_SUCCESS)
592	rcExit = rcExit2;
593	RTMemTmpFree(pszSubPrefix);
594	}
595	else
596	rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "out of memory\n");
597	}
598	/*
599	* Recurse into arrays too.
600	*/
601	else if (cElements > 0 && idxArrayType > 0)
602	{
603	BOOL fRc;
604	uint32_t idxElementRefType = 0;
605	fRc = SymGetTypeInfo(hFake, uModAddr, idxRefType, TI_GET_TYPE, &idxElementRefType); Assert(fRc);
606	uint64_t cbElement = cbMember / cElements;
607	fRc = SymGetTypeInfo(hFake, uModAddr, idxElementRefType, TI_GET_LENGTH, &cbElement); Assert(fRc);
608	MyDbgPrintf("idxArrayType=%u idxElementRefType=%u cbElement=%u\n", idxArrayType, idxElementRefType, cbElement);
609
610	size_t cbNeeded = strlen(pszMember) + strlen(pszPrefix) + sizeof("[xxxxxxxxxxxxxxxx].");
611	char pszSubPrefix = (char )RTMemTmpAlloc(cbNeeded);
612	if (pszSubPrefix)
613	{
614	for (uint32_t iElement = 0; iElement < cElements; iElement++)
615	{
616	RTStrPrintf(pszSubPrefix, cbNeeded, "%s%s[%u].", pszPrefix, pszMember, iElement);
617	RTEXITCODE rcExit2 = findMembers(hFake, uModAddr, idxElementRefType, cWantedMembers,
618	paWantedMembers,
619	offMember + iElement * cbElement,
620	pszStructNm,
621	pszSubPrefix,
622	pszLogTag);
623	if (rcExit2 != RTEXITCODE_SUCCESS)
624	rcExit = rcExit2;
625	}
626	RTMemTmpFree(pszSubPrefix);
627	}
628	else
629	rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "out of memory\n");
630	}
631
632	RTStrFree(pszMember);
633	}
634	else
635	rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "%s: RTUtf16ToUtf8 failed on %s child#%u: %Rrc\n",
636	pszLogTag, pszStructNm, i, rc);
637	}
638	/* TI_GET_OFFSET fails on bitfields, so just ignore+skip those. */
639	else if (enmErr != TI_GET_OFFSET \|\| GetLastError() != ERROR_INVALID_FUNCTION)
640	rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "%s: SymGetTypeInfo(,,,%d,) failed on %s child#%u: %u\n",
641	pszLogTag, enmErr, pszStructNm, i, GetLastError());
642	LocalFree(pwszMember);
643	} /* For each child. */
644
645	return rcExit;
646	}
647
648
649	/**
650	* Lookup up structures and members in the given module.
651	*
652	* @returns Fully bitched exit code.
653	* @param hFake Fake process handle.
654	* @param uModAddr The module address.
655	* @param pszLogTag The log tag.
656	* @param pszPdb The full PDB path.
657	* @param pOsVerInfo The OS version info for altering the error handling
658	* for older OSes.
659	*/
660	static RTEXITCODE findStructures(HANDLE hFake, uint64_t uModAddr, const char pszLogTag, const char pszPdb,
661	PCRTNTSDBOSVER pOsVerInfo)
662	{
663	RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
664	PSYMBOL_INFO pSymInfo = (PSYMBOL_INFO)alloca(sizeof(*pSymInfo));
665	for (uint32_t iStruct = 0; iStruct < RT_ELEMENTS(g_aStructs); iStruct++)
666	{
667	pSymInfo->SizeOfStruct = sizeof(*pSymInfo);
668	pSymInfo->MaxNameLen = 0;
669	if (!SymGetTypeFromName(hFake, uModAddr, g_aStructs[iStruct].pszName, pSymInfo))
670	{
671	if (!(pOsVerInfo->uMajorVer == 5 && pOsVerInfo->uMinorVer == 0) /* w2k */)
672	return RTMsgErrorExit(RTEXITCODE_FAILURE, "%s: Failed to find _KPRCB: %u\n", pszPdb, GetLastError());
673	RTMsgInfo("%s: Skipping - failed to find _KPRCB: %u\n", pszPdb, GetLastError());
674	return RTEXITCODE_SKIPPED;
675	}
676
677	MyDbgPrintf(" %s: TypeIndex=%u\n", g_aStructs[iStruct].pszName, pSymInfo->TypeIndex);
678	MyDbgPrintf(" %s: Size=%u (%#x)\n", g_aStructs[iStruct].pszName, pSymInfo->Size, pSymInfo->Size);
679
680	rcExit = findMembers(hFake, uModAddr, pSymInfo->TypeIndex,
681	g_aStructs[iStruct].cMembers, g_aStructs[iStruct].paMembers, 0 /* offDisp */,
682	g_aStructs[iStruct].pszName, "", pszLogTag);
683	if (rcExit != RTEXITCODE_SUCCESS)
684	return rcExit;
685	} /* for each struct we want */
686	return rcExit;
687	}
688
689
690	static bool strIEndsWith(const char pszString, const char pszSuffix)
691	{
692	size_t cchString = strlen(pszString);
693	size_t cchSuffix = strlen(pszSuffix);
694	if (cchString < cchSuffix)
695	return false;
696	return RTStrICmp(pszString + cchString - cchSuffix, pszSuffix) == 0;
697	}
698
699
700	/**
701	* Use various hysterics to figure out the OS version details from the PDB path.
702	*
703	* This ASSUMES quite a bunch of things:
704	* -# Working on unpacked symbol packages. This does not work for
705	* windbg symbol stores/caches.
706	* -# The symbol package has been unpacked into a directory with the same
707	* name as the symbol package (sans suffixes).
708	*
709	* @returns Fully complained exit code.
710	* @param pszPdb The path to the PDB.
711	* @param pVerInfo Where to return the version info.
712	* @param penmArch Where to return the architecture.
713	*/
714	static RTEXITCODE FigurePdbVersionInfo(const char pszPdb, PRTNTSDBOSVER pVerInfo, MYARCH penmArch)
715	{
716	/*
717	* Split the path.
718	*/
719	union
720	{
721	RTPATHSPLIT Split;
722	uint8_t abPad[RTPATH_MAX + 1024];
723	} u;
724	int rc = RTPathSplit(pszPdb, &u.Split, sizeof(u), 0);
725	if (RT_FAILURE(rc))
726	return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTPathSplit failed on '%s': %Rrc", pszPdb, rc);
727	if (!(u.Split.fProps & RTPATH_PROP_FILENAME))
728	return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTPATH_PROP_FILENAME not set for: '%s'", pszPdb);
729	const char *pszFilename = u.Split.apszComps[u.Split.cComps - 1];
730
731	/*
732	* SMP or UNI kernel?
733	*/
734	if ( !RTStrICmp(pszFilename, "ntkrnlmp.pdb")
735	\|\| !RTStrICmp(pszFilename, "ntkrpamp.pdb")
736	)
737	pVerInfo->fSmp = true;
738	else if ( !RTStrICmp(pszFilename, "ntoskrnl.pdb")
739	\|\| !RTStrICmp(pszFilename, "ntkrnlpa.pdb")
740	)
741	pVerInfo->fSmp = false;
742	else
743	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Doesn't recognize the filename '%s'...", pszFilename);
744
745	/*
746	* Look for symbol pack names in the path. This is stuff like:
747	* - WindowsVista.6002.090410-1830.x86fre
748	* - WindowsVista.6002.090410-1830.amd64chk
749	* - Windows_Win7.7600.16385.090713-1255.X64CHK
750	* - Windows_Win7SP1.7601.17514.101119-1850.AMD64FRE
751	* - Windows_Win8.9200.16384.120725-1247.X86CHK
752	*/
753	bool fFound = false;
754	uint32_t i = u.Split.cComps - 1;
755	while (i-- > 0)
756	{
757	static struct
758	{
759	const char *pszPrefix;
760	size_t cchPrefix;
761	uint8_t uMajorVer;
762	uint8_t uMinorVer;
763	uint8_t uCsdNo;
764	uint32_t uBuildNo; /*< UINT32_MAX means the number immediately after the prefix. /
765	} const s_aSymPacks[] =
766	{
767	{ RT_STR_TUPLE("w2kSP1SYM"), 5, 0, 1, 2195 },
768	{ RT_STR_TUPLE("w2ksp2srp1"), 5, 0, 2, 2195 },
769	{ RT_STR_TUPLE("w2ksp2sym"), 5, 0, 2, 2195 },
770	{ RT_STR_TUPLE("w2ksp3sym"), 5, 0, 3, 2195 },
771	{ RT_STR_TUPLE("w2ksp4sym"), 5, 0, 4, 2195 },
772	{ RT_STR_TUPLE("Windows2000-KB891861"), 5, 0, 4, 2195 },
773	{ RT_STR_TUPLE("windowsxp"), 5, 1, 0, 2600 },
774	{ RT_STR_TUPLE("xpsp1sym"), 5, 1, 1, 2600 },
775	{ RT_STR_TUPLE("WindowsXP-KB835935-SP2-"), 5, 1, 2, 2600 },
776	{ RT_STR_TUPLE("WindowsXP-KB936929-SP3-"), 5, 1, 3, 2600 },
777	{ RT_STR_TUPLE("Windows2003."), 5, 2, 0, 3790 },
778	{ RT_STR_TUPLE("Windows2003_sp1."), 5, 2, 1, 3790 },
779	{ RT_STR_TUPLE("WindowsServer2003-KB933548-v1"), 5, 2, 1, 3790 },
780	{ RT_STR_TUPLE("WindowsVista.6000."), 6, 0, 0, 6000 },
781	{ RT_STR_TUPLE("Windows_Longhorn.6001."), 6, 0, 1, 6001 }, /* incl w2k8 */
782	{ RT_STR_TUPLE("WindowsVista.6002."), 6, 0, 2, 6002 }, /* incl w2k8 */
783	{ RT_STR_TUPLE("Windows_Winmain.7000"), 6, 1, 0, 7000 }, /* Beta */
784	{ RT_STR_TUPLE("Windows_Winmain.7100"), 6, 1, 0, 7100 }, /* RC */
785	{ RT_STR_TUPLE("Windows_Win7.7600"), 6, 1, 0, 7600 }, /* RC */
786	{ RT_STR_TUPLE("Windows_Win7SP1.7601"), 6, 1, 1, 7601 }, /* RC */
787	{ RT_STR_TUPLE("Windows_Winmain.8102"), 6, 1, 0, 8102 }, /* preview */
788	{ RT_STR_TUPLE("Windows_Winmain.8250"), 6, 1, 0, 8250 }, /* beta */
789	{ RT_STR_TUPLE("Windows_Winmain.8400"), 6, 1, 0, 8400 }, /* RC */
790	{ RT_STR_TUPLE("Windows_Win8.9200"), 6, 1, 0, 9200 }, /* RTM */
791	};
792
793	const char *pszComp = u.Split.apszComps[i];
794	uint32_t iSymPack = RT_ELEMENTS(s_aSymPacks);
795	while (iSymPack-- > 0)
796	if (!RTStrNICmp(pszComp, s_aSymPacks[iSymPack].pszPrefix, s_aSymPacks[iSymPack].cchPrefix))
797	break;
798	if (iSymPack >= RT_ELEMENTS(s_aSymPacks))
799	continue;
800
801	pVerInfo->uMajorVer = s_aSymPacks[iSymPack].uMajorVer;
802	pVerInfo->uMinorVer = s_aSymPacks[iSymPack].uMinorVer;
803	pVerInfo->uCsdNo = s_aSymPacks[iSymPack].uCsdNo;
804	pVerInfo->fChecked = false;
805	pVerInfo->uBuildNo = s_aSymPacks[iSymPack].uBuildNo;
806
807	/* Parse build number if necessary. */
808	if (s_aSymPacks[iSymPack].uBuildNo == UINT32_MAX)
809	{
810	char *pszNext;
811	rc = RTStrToUInt32Ex(pszComp + s_aSymPacks[iSymPack].cchPrefix, &pszNext, 10, &pVerInfo->uBuildNo);
812	if (RT_FAILURE(rc))
813	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to decode build number in '%s': %Rrc", pszComp, rc);
814	if (pszNext != '.' && pszNext != '_' && *pszNext != '-')
815	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to decode build number in '%s': '%c'", pszComp, *pszNext);
816	}
817
818	/* Look for build arch and checked/free. */
819	if ( RTStrIStr(pszComp, ".x86.chk.")
820	\|\| RTStrIStr(pszComp, ".x86chk.")
821	\|\| RTStrIStr(pszComp, "_x86_chk_")
822	\|\| RTStrIStr(pszComp, "_x86chk_")
823	\|\| RTStrIStr(pszComp, "-x86-DEBUG")
824	\|\| (RTStrIStr(pszComp, "-x86-") && RTStrIStr(pszComp, "-DEBUG"))
825	)
826	{
827	pVerInfo->fChecked = true;
828	*penmArch = MYARCH_X86;
829	}
830	else if ( RTStrIStr(pszComp, ".amd64.chk.")
831	\|\| RTStrIStr(pszComp, ".amd64chk.")
832	\|\| RTStrIStr(pszComp, ".x64.chk.")
833	\|\| RTStrIStr(pszComp, ".x64chk.")
834	)
835	{
836	pVerInfo->fChecked = true;
837	*penmArch = MYARCH_AMD64;
838	}
839	else if ( RTStrIStr(pszComp, ".amd64.fre.")
840	\|\| RTStrIStr(pszComp, ".amd64fre.")
841	\|\| RTStrIStr(pszComp, ".x64.fre.")
842	\|\| RTStrIStr(pszComp, ".x64fre.")
843	)
844	{
845	pVerInfo->fChecked = false;
846	*penmArch = MYARCH_AMD64;
847	}
848	else if ( RTStrIStr(pszComp, "DEBUG")
849	\|\| RTStrIStr(pszComp, "_chk")
850	)
851	{
852	pVerInfo->fChecked = true;
853	*penmArch = MYARCH_X86;
854	}
855	else
856	{
857	pVerInfo->fChecked = false;
858	*penmArch = MYARCH_X86;
859	}
860	return RTEXITCODE_SUCCESS;
861	}
862
863	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Giving up on '%s'...\n", pszPdb);
864	}
865
866
867	/**
868	* Process one PDB.
869	*
870	* @returns Fully bitched exit code.
871	* @param pszPdb The path to the PDB.
872	*/
873	static RTEXITCODE processPdb(const char *pszPdb)
874	{
875	/*
876	* We need the size later on, so get that now and present proper IPRT error
877	* info if the file is missing or inaccessible.
878	*/
879	RTFSOBJINFO ObjInfo;
880	int rc = RTPathQueryInfoEx(pszPdb, &ObjInfo, RTFSOBJATTRADD_NOTHING, RTPATH_F_FOLLOW_LINK);
881	if (RT_FAILURE(rc))
882	return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTPathQueryInfo fail on '%s': %Rrc\n", pszPdb, rc);
883
884	/*
885	* Figure the windows version details for the given PDB.
886	*/
887	MYARCH enmArch;
888	RTNTSDBOSVER OsVerInfo;
889	RTEXITCODE rcExit = FigurePdbVersionInfo(pszPdb, &OsVerInfo, &enmArch);
890	if (rcExit != RTEXITCODE_SUCCESS)
891	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to figure the OS version info for '%s'.\n'", pszPdb);
892
893	/*
894	* Create a fake handle and open the PDB.
895	*/
896	static uintptr_t s_iHandle = 0;
897	HANDLE hFake = (HANDLE)++s_iHandle;
898	if (!SymInitialize(hFake, NULL, FALSE))
899	return RTMsgErrorExit(RTEXITCODE_FAILURE, "SymInitialied failed: %u\n", GetLastError());
900
901	uint64_t uModAddr = UINT64_C(0x1000000);
902	uModAddr = SymLoadModuleEx(hFake, NULL /hFile/, pszPdb, NULL /pszModuleName/,
903	uModAddr, ObjInfo.cbObject, NULL /pData/, 0 /fFlags/);
904	if (uModAddr != 0)
905	{
906	MyDbgPrintf("* uModAddr=%#llx \"%s\" *\n", uModAddr, pszPdb);
907
908	char szLogTag[32];
909	RTStrCopy(szLogTag, sizeof(szLogTag), RTPathFilename(pszPdb));
910
911	/*
912	* Find the structures.
913	*/
914	rcExit = findStructures(hFake, uModAddr, szLogTag, pszPdb, &OsVerInfo);
915	if (rcExit == RTEXITCODE_SUCCESS)
916	rcExit = checkThatWeFoundEverything();
917	if (rcExit == RTEXITCODE_SUCCESS)
918	{
919	/*
920	* Save the details for later when we produce the header.
921	*/
922	rcExit = saveStructures(&OsVerInfo, enmArch, pszPdb);
923	}
924	}
925	else
926	rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "SymLoadModuleEx failed: %u\n", GetLastError());
927
928	if (!SymCleanup(hFake))
929	rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "SymCleanup failed: %u\n", GetLastError());
930
931	if (rcExit == RTEXITCODE_SKIPPED)
932	rcExit = RTEXITCODE_SUCCESS;
933	return rcExit;
934	}
935
936
937	/** The size of the directory entry buffer we're using. */
938	#define MY_DIRENTRY_BUF_SIZE (sizeof(RTDIRENTRYEX) + RTPATH_MAX)
939
940	/**
941	* Checks if the name is of interest to us.
942	*
943	* @returns true/false.
944	* @param pszName The name.
945	* @param cchName The length of the name.
946	*/
947	static bool isInterestingName(const char *pszName, size_t cchName)
948	{
949	static struct { const char *psz; size_t cch; } const s_aNames[] =
950	{
951	RT_STR_TUPLE("ntoskrnl.pdb"),
952	RT_STR_TUPLE("ntkrnlmp.pdb"),
953	RT_STR_TUPLE("ntkrnlpa.pdb"),
954	RT_STR_TUPLE("ntkrpamp.pdb"),
955	};
956
957	if ( cchName == s_aNames[0].cch
958	&& (pszName[0] == 'n' \|\| pszName[0] == 'N')
959	&& (pszName[1] == 't' \|\| pszName[1] == 'T')
960	)
961	{
962	int i = RT_ELEMENTS(s_aNames);
963	while (i-- > 0)
964	if ( s_aNames[i].cch == cchName
965	&& !RTStrICmp(s_aNames[i].psz, pszName))
966	return true;
967	}
968	return false;
969	}
970
971
972	/**
973	* Recursively processes relevant files in the specified directory.
974	*
975	* @returns Fully complained exit code.
976	* @param pszDir Pointer to the directory buffer.
977	* @param cchDir The length of pszDir in pszDir.
978	* @param pDirEntry Pointer to the directory buffer.
979	*/
980	static RTEXITCODE processDirSub(char *pszDir, size_t cchDir, PRTDIRENTRYEX pDirEntry, int iLogDepth)
981	{
982	Assert(cchDir > 0); Assert(pszDir[cchDir] == '\0');
983
984	/* Make sure we've got some room in the path, to save us extra work further down. */
985	if (cchDir + 3 >= RTPATH_MAX)
986	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Path too long: '%s'\n", pszDir);
987
988	/* Open directory. */
989	PRTDIR pDir;
990	int rc = RTDirOpen(&pDir, pszDir);
991	if (RT_FAILURE(rc))
992	return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTDirOpen failed on '%s': %Rrc\n", pszDir, rc);
993
994	/* Ensure we've got a trailing slash (there is space for it see above). */
995	if (!RTPATH_IS_SEP(pszDir[cchDir - 1]))
996	{
997	pszDir[cchDir++] = RTPATH_SLASH;
998	pszDir[cchDir] = '\0';
999	}
1000
1001	/*
1002	* Process the files and subdirs.
1003	*/
1004	RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
1005	for (;;)
1006	{
1007	/* Get the next directory. */
1008	size_t cbDirEntry = MY_DIRENTRY_BUF_SIZE;
1009	rc = RTDirReadEx(pDir, pDirEntry, &cbDirEntry, RTFSOBJATTRADD_UNIX, RTPATH_F_ON_LINK);
1010	if (RT_FAILURE(rc))
1011	break;
1012
1013	/* Skip the dot and dot-dot links. */
1014	if ( (pDirEntry->cbName == 1 && pDirEntry->szName[0] == '.')
1015	\|\| (pDirEntry->cbName == 2 && pDirEntry->szName[0] == '.' && pDirEntry->szName[1] == '.'))
1016	continue;
1017
1018	/* Check length. */
1019	if (pDirEntry->cbName + cchDir + 3 >= RTPATH_MAX)
1020	{
1021	rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "Path too long: '%s' in '%.*s'\n", pDirEntry->szName, cchDir, pszDir);
1022	break;
1023	}
1024
1025	if (RTFS_IS_FILE(pDirEntry->Info.Attr.fMode))
1026	{
1027	/*
1028	* Process debug info files of interest.
1029	*/
1030	if (isInterestingName(pDirEntry->szName, pDirEntry->cbName))
1031	{
1032	memcpy(&pszDir[cchDir], pDirEntry->szName, pDirEntry->cbName + 1);
1033	RTEXITCODE rcExit2 = processPdb(pszDir);
1034	if (rcExit2 != RTEXITCODE_SUCCESS)
1035	rcExit = rcExit2;
1036	}
1037	}
1038	else if (RTFS_IS_DIRECTORY(pDirEntry->Info.Attr.fMode))
1039	{
1040	/*
1041	* Recurse into the subdirectory. In order to speed up Win7+
1042	* symbol pack traversals, we skip directories with ".pdb" suffixes
1043	* unless they match any of the .pdb files we're looking for.
1044	*
1045	* Note! When we get back pDirEntry will be invalid.
1046	*/
1047	if ( pDirEntry->cbName <= 4
1048	\|\| RTStrICmp(&pDirEntry->szName[pDirEntry->cbName - 4], ".pdb")
1049	\|\| isInterestingName(pDirEntry->szName, pDirEntry->cbName))
1050	{
1051	memcpy(&pszDir[cchDir], pDirEntry->szName, pDirEntry->cbName + 1);
1052	if (iLogDepth > 0)
1053	RTMsgInfo("%s%s ...\n", pszDir, RTPATH_SLASH_STR);
1054	RTEXITCODE rcExit2 = processDirSub(pszDir, cchDir + pDirEntry->cbName, pDirEntry, iLogDepth - 1);
1055	if (rcExit2 != RTEXITCODE_SUCCESS)
1056	rcExit = rcExit2;
1057	}
1058	}
1059	}
1060	if (rc != VERR_NO_MORE_FILES)
1061	rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "RTDirReadEx failed: %Rrc\npszDir=%.*s", rc, cchDir, pszDir);
1062
1063	rc = RTDirClose(pDir);
1064	if (RT_FAILURE(rc))
1065	rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "RTDirClose failed: %Rrc\npszDir=%.*s", rc, cchDir, pszDir);
1066	return rcExit;
1067	}
1068
1069
1070	/**
1071	* Recursively processes relevant files in the specified directory.
1072	*
1073	* @returns Fully complained exit code.
1074	* @param pszDir The directory to search.
1075	*/
1076	static RTEXITCODE processDir(const char *pszDir)
1077	{
1078	char szPath[RTPATH_MAX];
1079	int rc = RTPathAbs(pszDir, szPath, sizeof(szPath));
1080	if (RT_FAILURE(rc))
1081	return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTPathAbs failed on '%s': %Rrc\n", pszDir, rc);
1082
1083	union
1084	{
1085	uint8_t abPadding[MY_DIRENTRY_BUF_SIZE];
1086	RTDIRENTRYEX DirEntry;
1087	} uBuf;
1088	return processDirSub(szPath, strlen(szPath), &uBuf.DirEntry, g_iOptVerbose);
1089	}
1090
1091
1092	int main(int argc, char **argv)
1093	{
1094	int rc = RTR3InitExe(argc, &argv, 0 /fFlags/);
1095	if (RT_FAILURE(rc))
1096	return RTMsgInitFailure(rc);
1097
1098	RTListInit(&g_SetList);
1099
1100	/*
1101	* Parse options.
1102	*/
1103	static const RTGETOPTDEF s_aOptions[] =
1104	{
1105	{ "--force", 'f', RTGETOPT_REQ_NOTHING },
1106	{ "--output", 'o', RTGETOPT_REQ_STRING },
1107	{ "--verbose", 'v', RTGETOPT_REQ_NOTHING },
1108	{ "--quiet", 'q', RTGETOPT_REQ_NOTHING },
1109	};
1110
1111	RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
1112	const char *pszOutput = "-";
1113
1114	int ch;
1115	RTGETOPTUNION ValueUnion;
1116	RTGETOPTSTATE GetState;
1117	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1,
1118	RTGETOPTINIT_FLAGS_OPTS_FIRST);
1119	while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
1120	{
1121	switch (ch)
1122	{
1123	case 'f':
1124	g_fOptForce = true;
1125	break;
1126
1127	case 'v':
1128	g_iOptVerbose++;
1129	break;
1130
1131	case 'q':
1132	g_iOptVerbose++;
1133	break;
1134
1135	case 'o':
1136	pszOutput = ValueUnion.psz;
1137	break;
1138
1139	case 'V':
1140	RTPrintf("$Revision: 45633 $");
1141	break;
1142
1143	case 'h':
1144	RTPrintf("usage: %s [-v\|--verbose] [-q\|--quiet] [-f\|--force] [-o\|--output <file.h>] <dir1\|pdb1> [...]\n"
1145	" or: %s [-V\|--version]\n"
1146	" or: %s [-h\|--help]\n",
1147	argv[0], argv[0], argv[0]);
1148	return RTEXITCODE_SUCCESS;
1149
1150	case VINF_GETOPT_NOT_OPTION:
1151	{
1152	RTEXITCODE rcExit2;
1153	if (RTFileExists(ValueUnion.psz))
1154	rcExit2 = processPdb(ValueUnion.psz);
1155	else
1156	rcExit2 = processDir(ValueUnion.psz);
1157	if (rcExit2 != RTEXITCODE_SUCCESS)
1158	{
1159	if (!g_fOptForce)
1160	return rcExit2;
1161	rcExit = rcExit2;
1162	}
1163	break;
1164	}
1165
1166	default:
1167	return RTGetOptPrintError(ch, &ValueUnion);
1168	}
1169	}
1170	if (RTListIsEmpty(&g_SetList))
1171	return RTMsgErrorExit(RTEXITCODE_FAILURE, "No usable debug files found.\n");
1172
1173	/*
1174	* Generate the output.
1175	*/
1176	PRTSTREAM pOut = g_pStdOut;
1177	if (strcmp(pszOutput, "-"))
1178	{
1179	rc = RTStrmOpen(pszOutput, "w", &pOut);
1180	if (RT_FAILURE(rc))
1181	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Error opening '%s' for writing: %Rrc\n", pszOutput, rc);
1182	}
1183
1184	generateHeader(pOut);
1185
1186	if (pOut != g_pStdOut)
1187	rc = RTStrmClose(pOut);
1188	else
1189	rc = RTStrmFlush(pOut);
1190	if (RT_FAILURE(rc))
1191	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Error %s '%s': %Rrc\n", pszOutput,
1192	pOut != g_pStdOut ? "closing" : "flushing", rc);
1193	return rcExit;
1194	}

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

source: vbox/trunk/src/VBox/Runtime/r0drv/nt/ntBldSymDb.cpp@ 49221

Download in other formats: