VBoxBugReportWin.cpp@ 88205

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

Line
1	/* $Id: VBoxBugReportWin.cpp 82968 2020-02-04 10:35:17Z vboxsync $ */
2	/** @file
3	* VBoxBugReportWin - VirtualBox command-line diagnostics tool, Windows-specific part.
4	*/
5
6	/*
7	* Copyright (C) 2006-2020 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
18	#include <VBox/com/com.h>
19	#include <VBox/com/string.h>
20
21	#include <iprt/cpp/exception.h>
22
23	#include "VBoxBugReport.h"
24
25	#include <netcfgx.h>
26	#include <iprt/win/setupapi.h>
27	#include <initguid.h>
28	#include <devguid.h>
29	#include <usbiodef.h>
30	#include <usbioctl.h>
31	#include <psapi.h>
32
33	#define ReleaseAndReset(obj) \
34	if (obj) \
35	obj->Release(); \
36	obj = NULL;
37
38
39	class BugReportNetworkAdaptersWin : public BugReportStream
40	{
41	public:
42	BugReportNetworkAdaptersWin() : BugReportStream("NetworkAdapters") {};
43	virtual ~BugReportNetworkAdaptersWin() {};
44	virtual PRTSTREAM getStream(void) { collect(); return BugReportStream::getStream(); };
45	private:
46	struct CharacteristicsName
47	{
48	DWORD dwChar;
49	const char *szName;
50	};
51	void printCharteristics(DWORD dwChars);
52	void collect();
53	void collectNetCfgComponentInfo(int ident, bool fEnabled, INetCfgComponent *pComponent);
54	};
55
56
57
58	void BugReportNetworkAdaptersWin::printCharteristics(DWORD dwChars)
59	{
60	static CharacteristicsName cMap[] =
61	{
62	{ NCF_VIRTUAL, "virtual" },
63	{ NCF_SOFTWARE_ENUMERATED, "software_enumerated" },
64	{ NCF_PHYSICAL, "physical" },
65	{ NCF_HIDDEN, "hidden" },
66	{ NCF_NO_SERVICE, "no_service" },
67	{ NCF_NOT_USER_REMOVABLE, "not_user_removable" },
68	{ NCF_MULTIPORT_INSTANCED_ADAPTER, "multiport_instanced_adapter" },
69	{ NCF_HAS_UI, "has_ui" },
70	{ NCF_SINGLE_INSTANCE, "single_instance" },
71	{ NCF_FILTER, "filter" },
72	{ NCF_DONTEXPOSELOWER, "dontexposelower" },
73	{ NCF_HIDE_BINDING, "hide_binding" },
74	{ NCF_NDIS_PROTOCOL, "ndis_protocol" },
75	{ NCF_FIXED_BINDING, "fixed_binding" },
76	{ NCF_LW_FILTER, "lw_filter" }
77	};
78	bool fPrintDelim = false;
79
80	for (int i = 0; i < RT_ELEMENTS(cMap); ++i)
81	{
82	if (dwChars & cMap[i].dwChar)
83	{
84	if (fPrintDelim)
85	{
86	putStr(", ");
87	fPrintDelim = false;
88	}
89	putStr(cMap[i].szName);
90	fPrintDelim = true;
91	}
92	}
93	}
94
95	void BugReportNetworkAdaptersWin::collectNetCfgComponentInfo(int ident, bool fEnabled, INetCfgComponent *pComponent)
96	{
97	LPWSTR pwszName = NULL;
98	HRESULT hr = pComponent->GetDisplayName(&pwszName);
99	if (FAILED(hr))
100	throw RTCError(com::Utf8StrFmt("Failed to get component display name, hr=0x%x.\n", hr));
101	printf("%s%c %ls [", RTCString(ident, ' ').c_str(), fEnabled ? '+' : '-', pwszName);
102	if (pwszName)
103	CoTaskMemFree(pwszName);
104
105	DWORD dwChars = 0;
106	hr = pComponent->GetCharacteristics(&dwChars);
107	if (FAILED(hr))
108	throw RTCError(com::Utf8StrFmt("Failed to get component characteristics, hr=0x%x.\n", hr));
109	printCharteristics(dwChars);
110	putStr("]\n");
111	}
112
113	void BugReportNetworkAdaptersWin::collect(void)
114	{
115	INetCfg *pNetCfg = NULL;
116	IEnumNetCfgComponent *pEnumAdapters = NULL;
117	INetCfgComponent *pNetCfgAdapter = NULL;
118	INetCfgComponentBindings *pAdapterBindings = NULL;
119	IEnumNetCfgBindingPath *pEnumBp = NULL;
120	INetCfgBindingPath *pBp = NULL;
121	IEnumNetCfgBindingInterface *pEnumBi = NULL;
122	INetCfgBindingInterface *pBi = NULL;
123	INetCfgComponent *pUpperComponent = NULL;
124
125	try
126	{
127	HRESULT hr = CoCreateInstance(CLSID_CNetCfg, NULL, CLSCTX_INPROC_SERVER, IID_INetCfg, (PVOID*)&pNetCfg);
128	if (FAILED(hr))
129	throw RTCError(com::Utf8StrFmt("Failed to create instance of INetCfg, hr=0x%x.\n", hr));
130	hr = pNetCfg->Initialize(NULL);
131	if (FAILED(hr))
132	throw RTCError(com::Utf8StrFmt("Failed to initialize instance of INetCfg, hr=0x%x.\n", hr));
133
134	hr = pNetCfg->EnumComponents(&GUID_DEVCLASS_NET, &pEnumAdapters);
135	if (FAILED(hr))
136	throw RTCError(com::Utf8StrFmt("Failed enumerate network adapters, hr=0x%x.\n", hr));
137
138	hr = pEnumAdapters->Reset();
139	Assert(SUCCEEDED(hr));
140	do
141	{
142	hr = pEnumAdapters->Next(1, &pNetCfgAdapter, NULL);
143	if (hr == S_FALSE)
144	break;
145	if (hr != S_OK)
146	throw RTCError(com::Utf8StrFmt("Failed to get next network adapter, hr=0x%x.\n", hr));
147	hr = pNetCfgAdapter->QueryInterface(IID_INetCfgComponentBindings, (PVOID*)&pAdapterBindings);
148	if (FAILED(hr))
149	throw RTCError(com::Utf8StrFmt("Failed to query INetCfgComponentBindings, hr=0x%x.\n", hr));
150	hr = pAdapterBindings->EnumBindingPaths(EBP_ABOVE, &pEnumBp);
151	if (FAILED(hr))
152	throw RTCError(com::Utf8StrFmt("Failed to enumerate binding paths, hr=0x%x.\n", hr));
153	hr = pEnumBp->Reset();
154	if (FAILED(hr))
155	throw RTCError(com::Utf8StrFmt("Failed to reset enumeration of binding paths (0x%x)\n", hr));
156	do
157	{
158	hr = pEnumBp->Next(1, &pBp, NULL);
159	if (hr == S_FALSE)
160	break;
161	if (hr != S_OK)
162	throw RTCError(com::Utf8StrFmt("Failed to get next network adapter, hr=0x%x.\n", hr));
163	bool fBpEnabled;
164	hr = pBp->IsEnabled();
165	if (hr == S_FALSE)
166	fBpEnabled = false;
167	else if (hr != S_OK)
168	throw RTCError(com::Utf8StrFmt("Failed to check if bind path is enabled, hr=0x%x.\n", hr));
169	else
170	fBpEnabled = true;
171	hr = pBp->EnumBindingInterfaces(&pEnumBi);
172	if (FAILED(hr))
173	throw RTCError(com::Utf8StrFmt("Failed to enumerate binding interfaces (0x%x)\n", hr));
174	hr = pEnumBi->Reset();
175	if (FAILED(hr))
176	throw RTCError(com::Utf8StrFmt("Failed to reset enumeration of binding interfaces (0x%x)\n", hr));
177	int ident;
178	for (ident = 0;; ++ident)
179	{
180	hr = pEnumBi->Next(1, &pBi, NULL);
181	if (hr == S_FALSE)
182	break;
183	if (hr != S_OK)
184	throw RTCError(com::Utf8StrFmt("Failed to get next binding interface, hr=0x%x.\n", hr));
185	hr = pBi->GetUpperComponent(&pUpperComponent);
186	if (FAILED(hr))
187	throw RTCError(com::Utf8StrFmt("Failed to get upper component, hr=0x%x.\n", hr));
188	collectNetCfgComponentInfo(ident, fBpEnabled, pUpperComponent);
189	ReleaseAndReset(pUpperComponent);
190	ReleaseAndReset(pBi);
191	}
192	collectNetCfgComponentInfo(ident, fBpEnabled, pNetCfgAdapter);
193	ReleaseAndReset(pEnumBi);
194	ReleaseAndReset(pBp);
195	} while (true);
196
197	ReleaseAndReset(pEnumBp);
198	ReleaseAndReset(pAdapterBindings);
199	ReleaseAndReset(pNetCfgAdapter);
200	} while (true);
201	ReleaseAndReset(pEnumAdapters);
202	ReleaseAndReset(pNetCfg);
203	}
204
205	catch (RTCError &e)
206	{
207	ReleaseAndReset(pUpperComponent);
208	ReleaseAndReset(pBi);
209	ReleaseAndReset(pEnumBi);
210	ReleaseAndReset(pBp);
211	ReleaseAndReset(pEnumBp);
212	ReleaseAndReset(pAdapterBindings);
213	ReleaseAndReset(pNetCfgAdapter);
214	ReleaseAndReset(pEnumAdapters);
215	ReleaseAndReset(pNetCfg);
216	RTPrintf("ERROR in osCollect: %s\n", e.what());
217	throw;
218	}
219
220	}
221
222
223	class ErrorHandler
224	{
225	public:
226	ErrorHandler(const char *pszFunction, int iLine)
227	: m_function(pszFunction), m_line(iLine)
228	{ }
229
230	void handleWinError(DWORD uError, const char *pszMsgFmt, ...)
231	{
232	if (uError != ERROR_SUCCESS)
233	{
234	va_list va;
235	va_start(va, pszMsgFmt);
236	RTCString msgArgs(pszMsgFmt, va);
237	va_end(va);
238
239	LPSTR pBuf = NULL;
240	FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER \| FORMAT_MESSAGE_FROM_SYSTEM \| FORMAT_MESSAGE_IGNORE_INSERTS,
241	NULL, uError, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&pBuf, 0, NULL);
242	RTCStringFmt msg("%s at %s(%d): err=%u %s", msgArgs.c_str(), m_function, m_line, uError, pBuf);
243	LocalFree(pBuf);
244	throw RTCError(msg.c_str());
245	}
246	}
247
248	private:
249	const char *m_function;
250	int m_line;
251	};
252	#define handleWinError ErrorHandler(__FUNCTION__, __LINE__).handleWinError
253
254
255	class BugReportUsbTreeWin : public BugReportStream
256	{
257	public:
258	BugReportUsbTreeWin();
259	virtual ~BugReportUsbTreeWin();
260	virtual PRTSTREAM getStream(void) { enumerate(); return BugReportStream::getStream(); }
261	private:
262	class AutoHandle {
263	public:
264	AutoHandle(HANDLE h) { m_h = h; }
265	~AutoHandle() { close(); }
266	bool isValid() { return m_h != INVALID_HANDLE_VALUE; }
267	operator HANDLE() { return m_h; }
268	void close(void) { if (isValid()) { CloseHandle(m_h); m_h = INVALID_HANDLE_VALUE; } }
269	private:
270	HANDLE m_h;
271	};
272	void enumerate();
273
274	void enumerateController(PSP_DEVINFO_DATA pInfoData, PSP_DEVICE_INTERFACE_DATA pInterfaceData);
275	void enumerateHub(RTCString strFullName, RTCString strPrefix);
276	void enumeratePorts(HANDLE hHub, unsigned cPorts, RTCString strPrefix);
277	PBYTE getDeviceRegistryProperty(HDEVINFO hDev, PSP_DEVINFO_DATA pInfoData, DWORD uProperty,
278	DWORD uExpectedType, PDWORD puSize);
279	RTCString getDeviceRegistryPropertyString(HDEVINFO hDev, PSP_DEVINFO_DATA pInfoData, DWORD uProperty);
280
281	RTCString getDeviceDescByDriverName(RTCString strDrvName);
282	RTCString getDriverKeyName(HANDLE hHub, int iPort);
283	RTCString getExternalHubName(HANDLE hHub, int iPort);
284
285	HDEVINFO m_hDevInfo;
286	PSP_DEVICE_INTERFACE_DETAIL_DATA m_pDetailData;
287	HANDLE m_hHostCtrlDev;
288	};
289
290	BugReportUsbTreeWin::BugReportUsbTreeWin() : BugReportStream("HostUsbTree")
291	{
292	m_hDevInfo = INVALID_HANDLE_VALUE;
293	m_pDetailData = NULL;
294	m_hHostCtrlDev = INVALID_HANDLE_VALUE;
295	}
296
297	BugReportUsbTreeWin::~BugReportUsbTreeWin()
298	{
299	if (m_hHostCtrlDev != INVALID_HANDLE_VALUE)
300	CloseHandle(m_hHostCtrlDev);
301	if (m_pDetailData)
302	RTMemFree(m_pDetailData);
303	if (m_hDevInfo != INVALID_HANDLE_VALUE)
304	SetupDiDestroyDeviceInfoList(m_hDevInfo);
305	}
306
307
308	PBYTE BugReportUsbTreeWin::getDeviceRegistryProperty(HDEVINFO hDev,
309	PSP_DEVINFO_DATA pInfoData,
310	DWORD uProperty,
311	DWORD uExpectedType,
312	PDWORD puSize)
313	{
314	DWORD uActualType, cbNeeded = 0;
315	if (!SetupDiGetDeviceRegistryProperty(hDev, pInfoData, uProperty, &uActualType,
316	NULL, 0, &cbNeeded)
317	&& GetLastError() != ERROR_INSUFFICIENT_BUFFER)
318	{
319	if (GetLastError() == ERROR_INVALID_DATA)
320	return NULL;
321	handleWinError(GetLastError(), "SetupDiGetDeviceRegistryProperty(0x%x) failed", uProperty);
322	}
323	if (uExpectedType != REG_NONE && uActualType != uExpectedType)
324	throw RTCError(RTCStringFmt("SetupDiGetDeviceRegistryProperty(0x%x) returned type %d instead of %d",
325	uActualType, uExpectedType).c_str());
326	PBYTE pBuffer = (PBYTE)RTMemAlloc(cbNeeded);
327	if (!pBuffer)
328	throw RTCError(RTCStringFmt("Failed to allocate %u bytes", cbNeeded).c_str());
329	if (!SetupDiGetDeviceRegistryProperty(hDev, pInfoData, uProperty, NULL,
330	pBuffer, cbNeeded, &cbNeeded))
331	{
332	DWORD dwErr = GetLastError();
333	RTMemFree(pBuffer);
334	pBuffer = NULL;
335	handleWinError(dwErr, "SetupDiGetDeviceRegistryProperty(0x%x) failed", uProperty);
336	}
337	if (puSize)
338	*puSize = cbNeeded;
339
340	return pBuffer;
341	}
342
343	RTCString BugReportUsbTreeWin::getDeviceRegistryPropertyString(HDEVINFO hDev, PSP_DEVINFO_DATA pInfoData, DWORD uProperty)
344	{
345	PWSTR pUnicodeString = (PWSTR)getDeviceRegistryProperty(hDev, pInfoData, uProperty, REG_SZ, NULL);
346
347	if (!pUnicodeString)
348	return RTCString();
349
350	RTCStringFmt utf8string("%ls", pUnicodeString);
351	RTMemFree(pUnicodeString);
352	return utf8string;
353	}
354
355
356	RTCString BugReportUsbTreeWin::getDeviceDescByDriverName(RTCString strDrvName)
357	{
358	DWORD dwErr;
359	SP_DEVINFO_DATA devInfoData;
360	HDEVINFO hDevInfo = SetupDiGetClassDevs(NULL, NULL, NULL, DIGCF_ALLCLASSES \| DIGCF_PRESENT);
361
362	if (hDevInfo == INVALID_HANDLE_VALUE)
363	handleWinError(GetLastError(), "SetupDiGetClassDevs failed");
364
365	bool fFound = false;
366	devInfoData.cbSize = sizeof(devInfoData);
367	for (int i = 0; SetupDiEnumDeviceInfo(hDevInfo, i, &devInfoData); ++i)
368	{
369	if (getDeviceRegistryPropertyString(hDevInfo, &devInfoData, SPDRP_DRIVER).equals(strDrvName))
370	{
371	fFound = true;
372	break;
373	}
374	}
375	if (!fFound)
376	{
377	dwErr = GetLastError();
378	SetupDiDestroyDeviceInfoList(hDevInfo);
379	handleWinError(dwErr, "SetupDiEnumDeviceInfo failed");
380	}
381
382	RTCString strDesc = getDeviceRegistryPropertyString(hDevInfo, &devInfoData, SPDRP_DEVICEDESC);
383	SetupDiDestroyDeviceInfoList(hDevInfo);
384	return strDesc;
385	}
386
387
388	RTCString BugReportUsbTreeWin::getDriverKeyName(HANDLE hHub, int iPort)
389	{
390	USB_NODE_CONNECTION_DRIVERKEY_NAME name;
391	ULONG cbNeeded = 0;
392
393	name.ConnectionIndex = iPort;
394	if (!DeviceIoControl(hHub, IOCTL_USB_GET_NODE_CONNECTION_DRIVERKEY_NAME,
395	&name, sizeof(name), &name, sizeof(name), &cbNeeded, NULL))
396	handleWinError(GetLastError(), "DeviceIoControl(IOCTL_USB_GET_NODE_CONNECTION_DRIVERKEY_NAME) failed");
397	cbNeeded = name.ActualLength;
398	PUSB_NODE_CONNECTION_DRIVERKEY_NAME pName = (PUSB_NODE_CONNECTION_DRIVERKEY_NAME)RTMemAlloc(cbNeeded);
399	if (!pName)
400	throw RTCError(RTCStringFmt("Failed to allocate %u bytes", cbNeeded).c_str());
401	pName->ConnectionIndex = iPort;
402	if (!DeviceIoControl(hHub, IOCTL_USB_GET_NODE_CONNECTION_DRIVERKEY_NAME,
403	pName, cbNeeded, pName, cbNeeded, &cbNeeded, NULL))
404	{
405	DWORD dwErr = GetLastError();
406	RTMemFree(pName);
407	handleWinError(dwErr, "DeviceIoControl(IOCTL_USB_GET_NODE_CONNECTION_DRIVERKEY_NAME) failed");
408	}
409	RTCStringFmt strName("%ls", pName->DriverKeyName);
410	RTMemFree(pName);
411	return strName;
412	}
413
414
415	RTCString BugReportUsbTreeWin::getExternalHubName(HANDLE hHub, int iPort)
416	{
417	USB_NODE_CONNECTION_NAME name;
418	ULONG cbNeeded = 0;
419
420	name.ConnectionIndex = iPort;
421	if (!DeviceIoControl(hHub, IOCTL_USB_GET_NODE_CONNECTION_NAME,
422	&name, sizeof(name), &name, sizeof(name), &cbNeeded, NULL))
423	handleWinError(GetLastError(), "DeviceIoControl(IOCTL_USB_GET_NODE_CONNECTION_NAME) failed");
424	cbNeeded = name.ActualLength;
425	PUSB_NODE_CONNECTION_NAME pName = (PUSB_NODE_CONNECTION_NAME)RTMemAlloc(cbNeeded);
426	if (!pName)
427	throw RTCError(RTCStringFmt("Failed to allocate %u bytes", cbNeeded).c_str());
428	pName->ConnectionIndex = iPort;
429	if (!DeviceIoControl(hHub, IOCTL_USB_GET_NODE_CONNECTION_NAME,
430	pName, cbNeeded, pName, cbNeeded, &cbNeeded, NULL))
431	{
432	DWORD dwErr = GetLastError();
433	RTMemFree(pName);
434	handleWinError(dwErr, "DeviceIoControl(IOCTL_USB_GET_NODE_CONNECTION_NAME) failed");
435	}
436	RTCStringFmt strName("%ls", pName->NodeName);
437	RTMemFree(pName);
438	return strName;
439	}
440
441
442	void BugReportUsbTreeWin::enumeratePorts(HANDLE hHub, unsigned cPorts, RTCString strPrefix)
443	{
444	DWORD cbInfo = sizeof(USB_NODE_CONNECTION_INFORMATION_EX) + 30 * sizeof(USB_PIPE_INFO);
445	PUSB_NODE_CONNECTION_INFORMATION_EX pInfo = (PUSB_NODE_CONNECTION_INFORMATION_EX)RTMemAlloc(cbInfo);
446	if (!pInfo)
447	throw RTCError(RTCStringFmt("Failed to allocate %u bytes", cbInfo).c_str());
448	for (unsigned i = 1; i <= cPorts; ++i)
449	{
450	pInfo->ConnectionIndex = i;
451	if (!DeviceIoControl(hHub, IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX,
452	pInfo, cbInfo, pInfo, cbInfo, &cbInfo, NULL))
453	{
454	DWORD dwErr = GetLastError();
455	RTMemFree(pInfo);
456	handleWinError(dwErr, "DeviceIoControl(IOCTL_USB_GET_NODE_CONNECTION_INFORMATION) failed");
457	}
458	if (pInfo->ConnectionStatus == NoDeviceConnected)
459	printf("%s[Port %d]\n", strPrefix.c_str(), i);
460	else
461	{
462	RTCString strName = getDeviceDescByDriverName(getDriverKeyName(hHub, i));
463	printf("%s[Port %d] %s\n", strPrefix.c_str(), i, strName.c_str());
464	if (pInfo->DeviceIsHub)
465	enumerateHub(getExternalHubName(hHub, i), strPrefix + " ");
466	}
467	}
468	RTMemFree(pInfo);
469	}
470
471	void BugReportUsbTreeWin::enumerateHub(RTCString strFullName, RTCString strPrefix)
472	{
473	AutoHandle hHubDev(CreateFileA(RTCString("\\\\.\\").append(strFullName).c_str(),
474	GENERIC_WRITE, FILE_SHARE_WRITE,
475	NULL, OPEN_EXISTING, 0, NULL));
476	if (!hHubDev.isValid())
477	handleWinError(GetLastError(), "CreateFile(%s) failed", strFullName.c_str());
478	ULONG cb;
479	USB_NODE_INFORMATION hubInfo;
480	if (!DeviceIoControl(hHubDev,
481	IOCTL_USB_GET_NODE_INFORMATION,
482	&hubInfo,
483	sizeof(USB_NODE_INFORMATION),
484	&hubInfo,
485	sizeof(USB_NODE_INFORMATION),
486	&cb,
487	NULL))
488	handleWinError(GetLastError(), "DeviceIoControl(IOCTL_USB_GET_NODE_INFORMATION) failed");
489	enumeratePorts(hHubDev, hubInfo.u.HubInformation.HubDescriptor.bNumberOfPorts, strPrefix);
490	}
491
492	void BugReportUsbTreeWin::enumerateController(PSP_DEVINFO_DATA pInfoData, PSP_DEVICE_INTERFACE_DATA pInterfaceData)
493	{
494	RT_NOREF(pInterfaceData);
495	RTCString strCtrlDesc = getDeviceRegistryPropertyString(m_hDevInfo, pInfoData, SPDRP_DEVICEDESC);
496	printf("%s\n", strCtrlDesc.c_str());
497
498	ULONG cbNeeded;
499	USB_ROOT_HUB_NAME rootHub;
500	/* Find out the name length first */
501	if (!DeviceIoControl(m_hHostCtrlDev, IOCTL_USB_GET_ROOT_HUB_NAME, NULL, 0,
502	&rootHub, sizeof(rootHub),
503	&cbNeeded, NULL))
504	handleWinError(GetLastError(), "DeviceIoControl(IOCTL_USB_GET_ROOT_HUB_NAME) failed");
505	cbNeeded = rootHub.ActualLength;
506	PUSB_ROOT_HUB_NAME pUnicodeName = (PUSB_ROOT_HUB_NAME)RTMemAlloc(cbNeeded);
507	if (!pUnicodeName)
508	throw RTCError(RTCStringFmt("Failed to allocate %u bytes", cbNeeded).c_str());
509
510	if (!DeviceIoControl(m_hHostCtrlDev, IOCTL_USB_GET_ROOT_HUB_NAME, NULL, 0,
511	pUnicodeName, cbNeeded,
512	&cbNeeded, NULL))
513	{
514	DWORD dwErr = GetLastError();
515	RTMemFree(pUnicodeName);
516	handleWinError(dwErr, "DeviceIoControl(IOCTL_USB_GET_ROOT_HUB_NAME) failed");
517	}
518
519	RTCStringFmt strRootHubName("%ls", pUnicodeName->RootHubName);
520	RTMemFree(pUnicodeName);
521	printf(" Root Hub\n");
522	enumerateHub(strRootHubName, " ");
523	}
524
525	void BugReportUsbTreeWin::enumerate()
526	{
527	m_hDevInfo = SetupDiGetClassDevs((LPGUID)&GUID_DEVINTERFACE_USB_HOST_CONTROLLER, NULL, NULL,
528	DIGCF_PRESENT \| DIGCF_DEVICEINTERFACE);
529	if (m_hDevInfo == INVALID_HANDLE_VALUE)
530	handleWinError(GetLastError(), "SetupDiGetClassDevs(GUID_DEVINTERFACE_USB_HOST_CONTROLLER) failed");
531
532	SP_DEVINFO_DATA deviceInfoData;
533	deviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
534	for (int i = 0; SetupDiEnumDeviceInfo(m_hDevInfo, i, &deviceInfoData); ++i)
535	{
536	if (m_hHostCtrlDev != INVALID_HANDLE_VALUE)
537	CloseHandle(m_hHostCtrlDev);
538	if (m_pDetailData)
539	RTMemFree(m_pDetailData);
540
541	SP_DEVICE_INTERFACE_DATA deviceInterfaceData;
542	deviceInterfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
543	if (!SetupDiEnumDeviceInterfaces(m_hDevInfo, 0, (LPGUID)&GUID_DEVINTERFACE_USB_HOST_CONTROLLER,
544	i, &deviceInterfaceData))
545	handleWinError(GetLastError(), "SetupDiEnumDeviceInterfaces(GUID_DEVINTERFACE_USB_HOST_CONTROLLER) failed");
546
547	ULONG cbNeeded = 0;
548	if (!SetupDiGetDeviceInterfaceDetail(m_hDevInfo, &deviceInterfaceData, NULL, 0, &cbNeeded, NULL)
549	&& GetLastError() != ERROR_INSUFFICIENT_BUFFER)
550	handleWinError(GetLastError(), "SetupDiGetDeviceInterfaceDetail failed");
551
552	m_pDetailData = (PSP_DEVICE_INTERFACE_DETAIL_DATA)RTMemAlloc(cbNeeded);
553	if (!m_pDetailData)
554	throw RTCError(RTCStringFmt("Failed to allocate %u bytes", cbNeeded).c_str());
555
556	m_pDetailData->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
557	if (!SetupDiGetDeviceInterfaceDetail(m_hDevInfo, &deviceInterfaceData, m_pDetailData, cbNeeded, &cbNeeded, NULL))
558	handleWinError(GetLastError(), "SetupDiGetDeviceInterfaceDetail failed");
559
560	m_hHostCtrlDev = CreateFile(m_pDetailData->DevicePath, GENERIC_WRITE, FILE_SHARE_WRITE,
561	NULL, OPEN_EXISTING, 0, NULL);
562	if (m_hHostCtrlDev == INVALID_HANDLE_VALUE)
563	handleWinError(GetLastError(), "CreateFile(%ls) failed", m_pDetailData);
564
565	enumerateController(&deviceInfoData, &deviceInterfaceData);
566	}
567	}
568
569	class BugReportDriversWin : public BugReportStream
570	{
571	public:
572	BugReportDriversWin();
573	virtual ~BugReportDriversWin();
574	virtual PRTSTREAM getStream(void) { enumerateDrivers(); return BugReportStream::getStream(); }
575	private:
576	void enumerateDrivers(void);
577
578	WCHAR *m_pwszSystemRoot;
579	UINT m_cSystemRoot;
580	LPVOID *m_pDrivers;
581	DWORD m_cDrivers;
582	LPVOID m_pVerInfo;
583	DWORD m_cbVerInfo;
584	};
585
586	BugReportDriversWin::BugReportDriversWin() : BugReportStream("DriverVersions")
587	{
588	m_cSystemRoot = MAX_PATH;
589	m_pwszSystemRoot = new WCHAR[MAX_PATH];
590	m_cDrivers = 1024;
591	m_pDrivers = new LPVOID[m_cDrivers];
592	m_pVerInfo = NULL;
593	m_cbVerInfo = 0;
594	}
595
596	BugReportDriversWin::~BugReportDriversWin()
597	{
598	if (m_pVerInfo)
599	RTMemTmpFree(m_pVerInfo);
600	delete[] m_pDrivers;
601	delete[] m_pwszSystemRoot;
602	}
603
604	void BugReportDriversWin::enumerateDrivers()
605	{
606	UINT cNeeded = GetWindowsDirectory(m_pwszSystemRoot, m_cSystemRoot);
607	if (cNeeded > m_cSystemRoot)
608	{
609	/* Re-allocate and try again */
610	m_cSystemRoot = cNeeded;
611	delete[] m_pwszSystemRoot;
612	m_pwszSystemRoot = new WCHAR[m_cSystemRoot];
613	cNeeded = GetWindowsDirectory(m_pwszSystemRoot, m_cSystemRoot);
614	}
615	if (cNeeded == 0)
616	handleWinError(GetLastError(), "GetWindowsDirectory failed");
617
618	DWORD cbNeeded = 0;
619	if ( !EnumDeviceDrivers(m_pDrivers, m_cDrivers * sizeof(m_pDrivers[0]), &cbNeeded)
620	\|\| cbNeeded > m_cDrivers * sizeof(m_pDrivers[0]))
621	{
622	/* Re-allocate and try again */
623	m_cDrivers = cbNeeded / sizeof(m_pDrivers[0]);
624	delete[] m_pDrivers;
625	m_pDrivers = new LPVOID[m_cDrivers];
626	if (!EnumDeviceDrivers(m_pDrivers, cbNeeded, &cbNeeded))
627	handleWinError(GetLastError(), "EnumDeviceDrivers failed (%p, %u)", m_pDrivers, cbNeeded);
628	}
629
630	WCHAR wszDriver[1024];
631	for (unsigned i = 0; i < m_cDrivers; i++)
632	{
633	if (GetDeviceDriverBaseName(m_pDrivers[i], wszDriver, RT_ELEMENTS(wszDriver)))
634	{
635	if (_wcsnicmp(L"vbox", wszDriver, 4))
636	continue;
637	}
638	else
639	continue;
640	if (GetDeviceDriverFileName(m_pDrivers[i], wszDriver, RT_ELEMENTS(wszDriver)))
641	{
642	WCHAR wszTmpDrv[1024];
643	WCHAR *pwszDrv = wszDriver;
644	if (!wcsncmp(L"\\SystemRoot", wszDriver, 11))
645	{
646	wcsncpy_s(wszTmpDrv, m_pwszSystemRoot, m_cSystemRoot);
647	wcsncat_s(wszTmpDrv, wszDriver + 11, RT_ELEMENTS(wszTmpDrv) - m_cSystemRoot);
648	pwszDrv = wszTmpDrv;
649	}
650	else if (!wcsncmp(L"\\??\\", wszDriver, 4))
651	pwszDrv = wszDriver + 4;
652
653
654	/* Allocate a buffer for version info. Reuse if large enough. */
655	DWORD cbNewVerInfo = GetFileVersionInfoSize(pwszDrv, NULL);
656	if (cbNewVerInfo > m_cbVerInfo)
657	{
658	if (m_pVerInfo)
659	RTMemTmpFree(m_pVerInfo);
660	m_cbVerInfo = cbNewVerInfo;
661	m_pVerInfo = RTMemTmpAlloc(m_cbVerInfo);
662	if (!m_pVerInfo)
663	throw RTCError(RTCStringFmt("Failed to allocate %u bytes", m_cbVerInfo).c_str());
664	}
665
666	if (GetFileVersionInfo(pwszDrv, NULL, m_cbVerInfo, m_pVerInfo))
667	{
668	UINT cbSize = 0;
669	LPBYTE lpBuffer = NULL;
670	if (VerQueryValue(m_pVerInfo, L"\\", (VOID FAR* FAR*)&lpBuffer, &cbSize))
671	{
672	if (cbSize)
673	{
674	VS_FIXEDFILEINFO pFileInfo = (VS_FIXEDFILEINFO )lpBuffer;
675	if (pFileInfo->dwSignature == 0xfeef04bd)
676	{
677	printf("%ls (Version: %d.%d.%d.%d)\n", pwszDrv,
678	(pFileInfo->dwFileVersionMS >> 16) & 0xffff,
679	(pFileInfo->dwFileVersionMS >> 0) & 0xffff,
680	(pFileInfo->dwFileVersionLS >> 16) & 0xffff,
681	(pFileInfo->dwFileVersionLS >> 0) & 0xffff);
682	}
683	else
684	printf("%ls - invalid signature\n", pwszDrv);
685	}
686	else
687	printf("%ls - version info size is 0\n", pwszDrv);
688	}
689	else
690	printf("%ls - failed to query version info size\n", pwszDrv);
691	}
692	else
693	printf("%ls - failed to get version info with 0x%x\n", pwszDrv, GetLastError());
694	}
695	else
696	printf("%ls - GetDeviceDriverFileName failed with 0x%x\n", wszDriver, GetLastError());
697	}
698	}
699
700
701	class BugReportFilterRegistryWin : public BugReportFilter
702	{
703	public:
704	BugReportFilterRegistryWin() {};
705	virtual ~BugReportFilterRegistryWin() {};
706	virtual void apply(void pvSource, size_t *pcbInOut);
707	};
708
709	void BugReportFilterRegistryWin::apply(void pvSource, size_t *pcbInOut)
710	{
711	/*
712	* The following implementation is not optimal by any means. It serves to
713	* illustrate and test the case when filter's output is longer than its
714	* input.
715	*/
716	RT_NOREF(pcbInOut);
717	/* Registry export files are encoded in UTF-16 (little endian on Intel x86). */
718	void *pvDest = pvSource;
719	uint16_t pwsSource = (uint16_t )pvSource;
720	if (pwsSource++ == 0xFEFF && pcbInOut > 48)
721	{
722	if (!memcmp(pwsSource, L"Windows Registry Editor", 46))
723	{
724	*pcbInOut += 2;
725	pvDest = allocateBuffer(*pcbInOut);
726	uint16_t pwsDest = (uint16_t )pvDest;
727	*pwsDest++ = 0xFEFF;
728	*pwsDest++ = '#';
729	/* Leave space for 0xFEFF and '#' */
730	memcpy(pwsDest, pwsSource, *pcbInOut - 4);
731	}
732	}
733	return pvDest;
734	}
735
736
737	void createBugReportOsSpecific(BugReport* report, const char *pszHome)
738	{
739	RT_NOREF(pszHome);
740	WCHAR szWinDir[MAX_PATH];
741
742	int cbNeeded = GetWindowsDirectory(szWinDir, RT_ELEMENTS(szWinDir));
743	if (cbNeeded == 0)
744	throw RTCError(RTCStringFmt("Failed to get Windows directory (err=%d)\n", GetLastError()));
745	if (cbNeeded > MAX_PATH)
746	throw RTCError(RTCStringFmt("Failed to get Windows directory (needed %d-byte buffer)\n", cbNeeded));
747	RTCStringFmt WinInfDir("%ls/inf", szWinDir);
748	report->addItem(new BugReportFile(PathJoin(WinInfDir.c_str(), "setupapi.app.log"), "setupapi.app.log"));
749	report->addItem(new BugReportFile(PathJoin(WinInfDir.c_str(), "setupapi.dev.log"), "setupapi.dev.log"));
750	report->addItem(new BugReportNetworkAdaptersWin);
751	RTCStringFmt WinSysDir("%ls/System32", szWinDir);
752	report->addItem(new BugReportCommand("IpConfig", PathJoin(WinSysDir.c_str(), "ipconfig.exe"), "/all", NULL));
753	report->addItem(new BugReportCommand("RouteTable", PathJoin(WinSysDir.c_str(), "netstat.exe"), "-rn", NULL));
754	report->addItem(new BugReportCommand("SystemEvents", PathJoin(WinSysDir.c_str(), "wevtutil.exe"),
755	"qe", "System",
756	"/q:*[System[Provider[@Name='VBoxUSBMon' or @Name='VBoxNetLwf']]]", NULL));
757	report->addItem(new BugReportCommand("UpdateHistory", PathJoin(WinSysDir.c_str(), "wbem/wmic.exe"),
758	"qfe", "list", "brief", NULL));
759	report->addItem(new BugReportCommand("DriverServices", PathJoin(WinSysDir.c_str(), "sc.exe"),
760	"query", "type=", "driver", "state=", "all", NULL));
761	report->addItem(new BugReportCommand("DriverStore", PathJoin(WinSysDir.c_str(), "pnputil.exe"), "-e", NULL));
762	report->addItem(new BugReportCommandTemp("RegDevKeys", PathJoin(WinSysDir.c_str(), "reg.exe"), "export",
763	"HKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet\\Enum\\Root\\NET", NULL),
764	new BugReportFilterRegistryWin());
765	report->addItem(new BugReportCommandTemp("RegDrvKeys", PathJoin(WinSysDir.c_str(), "reg.exe"), "export",
766	"HKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet\\Control\\Class\\{4D36E972-E325-11CE-BFC1-08002BE10318}", NULL),
767	new BugReportFilterRegistryWin());
768	report->addItem(new BugReportCommandTemp("RegNetwork", PathJoin(WinSysDir.c_str(), "reg.exe"), "export",
769	"HKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet\\Control\\Network", NULL),
770	new BugReportFilterRegistryWin());
771	report->addItem(new BugReportCommandTemp("RegNetFltNobj", PathJoin(WinSysDir.c_str(), "reg.exe"), "export",
772	"HKEY_LOCAL_MACHINE\\SOFTWARE\\Classes\\CLSID\\{f374d1a0-bf08-4bdc-9cb2-c15ddaeef955}", NULL),
773	new BugReportFilterRegistryWin());
774	report->addItem(new BugReportUsbTreeWin);
775	report->addItem(new BugReportDriversWin);
776	}

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

source: vbox/trunk/src/VBox/Frontends/VBoxBugReport/VBoxBugReportWin.cpp@ 88205

Download in other formats: