VBoxBugReport.cpp@ 107044

Last change on this file since 107044 was 106061, checked in by vboxsync, 2 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.1 KB

Line
1	/* $Id: VBoxBugReport.cpp 106061 2024-09-16 14:03:52Z vboxsync $ */
2	/** @file
3	* VBoxBugReport - VirtualBox command-line diagnostics tool, main file.
4	*/
5
6	/*
7	* Copyright (C) 2006-2024 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	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	#include <VBox/com/com.h>
30	#include <VBox/com/string.h>
31	#include <VBox/com/array.h>
32	#include <VBox/com/ErrorInfo.h>
33	#include <VBox/com/errorprint.h>
34	#include <VBox/com/VirtualBox.h>
35
36	#include <VBox/version.h>
37
38	#include <iprt/buildconfig.h>
39	#include <iprt/err.h>
40	#include <iprt/env.h>
41	#include <iprt/file.h>
42	#include <iprt/getopt.h>
43	#include <iprt/initterm.h>
44	#include <iprt/path.h>
45	#include <iprt/process.h>
46	#include <iprt/zip.h>
47	#include <iprt/cpp/exception.h>
48
49	#include <list>
50
51	#include "VBoxBugReport.h"
52
53	/* Implementation - Base */
54
55	#ifndef RT_OS_WINDOWS
56	/** @todo Replace with platform-specific implementations. */
57	void createBugReportOsSpecific(BugReport pReport, const char pszHome)
58	{
59	RT_NOREF(pReport, pszHome);
60	}
61	#endif /* !RT_OS_WINDOWS */
62
63
64	/* Globals */
65
66	static char *g_pszVBoxManage = NULL;
67
68	static const RTGETOPTDEF g_aOptions[] =
69	{
70	{ "-all", 'A', RTGETOPT_REQ_NOTHING },
71	{ "--all", 'A', RTGETOPT_REQ_NOTHING },
72	{ "-output", 'o', RTGETOPT_REQ_STRING },
73	{ "--output", 'o', RTGETOPT_REQ_STRING },
74	{ "-text", 't', RTGETOPT_REQ_NOTHING },
75	{ "--text", 't', RTGETOPT_REQ_NOTHING }
76	};
77
78	static const char g_szUsage[] =
79	"Usage: %s [-h\|-?\|--help] [-A\|--all\|<vmname>...] [-o <file>\|--output=<file>]\n"
80	" Several VM names can be specified at once to be included into single report.\n"
81	" If none is given then no machines will be included. Specifying -A overrides\n"
82	" any VM names provided and includes all registered machines.\n"
83	"Options:\n"
84	" -h, -help, --help Print usage information\n"
85	" -A, -all, --all Include all registered machines\n"
86	" -o, -output, --output Specifies the name of the output file\n"
87	" -t, -text, --text Produce a single text file instead of compressed TAR\n"
88	" -V, -version, --version Print version information\n"
89	"\n";
90
91
92	/*
93	* This class stores machine-specific file paths that are obtained via
94	* VirtualBox API. In case API is not functioning properly these paths
95	* will be deduced on the best effort basis.
96	*/
97	class MachineInfo
98	{
99	public:
100	MachineInfo(const char name, const char logFolder, const char *settingsFile);
101	~MachineInfo();
102	const char *getName() const { return m_name; };
103	const char *getLogPath() const { return m_logpath; };
104	const char *getSettingsFile() const { return m_settings; };
105	private:
106	char *m_name;
107	char *m_logpath;
108	char *m_settings;
109	};
110
111	MachineInfo::MachineInfo(const char name, const char logFolder, const char *settingsFile)
112	{
113	m_name = RTStrDup(name);
114	m_logpath = RTStrDup(logFolder);
115	m_settings = RTStrDup(settingsFile);
116	}
117
118	MachineInfo::~MachineInfo()
119	{
120	RTStrFree(m_logpath);
121	RTStrFree(m_name);
122	RTStrFree(m_settings);
123	m_logpath = m_name = m_settings = 0;
124	}
125
126	typedef std::list<MachineInfo*> MachineInfoList;
127
128
129	class VBRDir
130	{
131	public:
132	VBRDir(const char *pcszPath) : m_hDir(NIL_RTDIR)
133	{
134	int rc = RTDirOpenFiltered(&m_hDir, pcszPath, RTDIRFILTER_WINNT, 0);
135	if (RT_FAILURE(rc) && rc != VERR_FILE_NOT_FOUND && rc != VERR_PATH_NOT_FOUND)
136	throw RTCError(com::Utf8StrFmt("Failed to open directory '%s'\n", pcszPath));
137	};
138	~VBRDir()
139	{
140	if (RT_VALID_PTR(m_hDir))
141	{
142	int rc = RTDirClose(m_hDir);
143	AssertRC(rc);
144	}
145	};
146	const char *next(void)
147	{
148	if (!RT_VALID_PTR(m_hDir))
149	return NULL;
150
151	int rc = RTDirRead(m_hDir, &m_DirEntry, NULL);
152	if (RT_SUCCESS(rc))
153	return m_DirEntry.szName;
154	if (rc == VERR_NO_MORE_FILES)
155	return NULL;
156	throw RTCError("Failed to read directory element\n");
157	};
158
159	private:
160	RTDIR m_hDir;
161	RTDIRENTRY m_DirEntry;
162	};
163
164
165	BugReportFilter::BugReportFilter() : m_pvBuffer(0), m_cbBuffer(0)
166	{
167	}
168
169	BugReportFilter::~BugReportFilter()
170	{
171	if (m_pvBuffer)
172	RTMemFree(m_pvBuffer);
173	}
174
175	void *BugReportFilter::allocateBuffer(size_t cbNeeded)
176	{
177	if (m_pvBuffer)
178	{
179	if (cbNeeded > m_cbBuffer)
180	RTMemFree(m_pvBuffer);
181	else
182	return m_pvBuffer;
183	}
184	m_pvBuffer = RTMemAlloc(cbNeeded);
185	if (!m_pvBuffer)
186	throw RTCError(com::Utf8StrFmt("Failed to allocate %ld bytes\n", cbNeeded));
187	m_cbBuffer = cbNeeded;
188	return m_pvBuffer;
189	}
190
191
192	/*
193	* An abstract class serving as the root of the bug report item tree.
194	*/
195	BugReportItem::BugReportItem(const char *pszTitle)
196	{
197	m_pszTitle = RTStrDup(pszTitle);
198	m_filter = 0;
199	}
200
201	BugReportItem::~BugReportItem()
202	{
203	if (m_filter)
204	delete m_filter;
205	RTStrFree(m_pszTitle);
206	}
207
208	void BugReportItem::addFilter(BugReportFilter *filter)
209	{
210	m_filter = filter;
211	}
212
213	void BugReportItem::applyFilter(void pvSource, size_t *pcbInOut)
214	{
215	if (m_filter)
216	return m_filter->apply(pvSource, pcbInOut);
217	return pvSource;
218	}
219
220	const char * BugReportItem::getTitle(void)
221	{
222	return m_pszTitle;
223	}
224
225
226	BugReport::BugReport(const char *pszFileName)
227	{
228	m_pszFileName = RTStrDup(pszFileName);
229	}
230
231	BugReport::~BugReport()
232	{
233	for (unsigned i = 0; i < m_Items.size(); ++i)
234	{
235	delete m_Items[i];
236	}
237	RTStrFree(m_pszFileName);
238	}
239
240	int BugReport::getItemCount(void)
241	{
242	return (int)m_Items.size();
243	}
244
245	void BugReport::addItem(BugReportItem* item, BugReportFilter *filter)
246	{
247	if (filter)
248	item->addFilter(filter);
249	if (item)
250	m_Items.append(item);
251	}
252
253	void BugReport::process(void)
254	{
255	for (unsigned i = 0; i < m_Items.size(); ++i)
256	{
257	BugReportItem *pItem = m_Items[i];
258	RTPrintf("%3u%% - collecting %s...\n", i * 100 / m_Items.size(), pItem->getTitle());
259	processItem(pItem);
260	}
261	RTPrintf("100%% - compressing...\n\n");
262	}
263
264	void BugReport::applyFilters(BugReportItem item, void pvSource, size_t pcbInOut)
265	{
266	return item->applyFilter(pvSource, pcbInOut);
267	}
268
269
270	BugReportStream::BugReportStream(const char *pszTitle) : BugReportItem(pszTitle)
271	{
272	m_hVfsIos = NIL_RTVFSIOSTREAM;
273	handleRtError(RTPathTemp(m_szFileName, RTPATH_MAX),
274	"Failed to obtain path to temporary folder");
275	handleRtError(RTPathAppend(m_szFileName, RTPATH_MAX, "BugRepXXXXX.tmp"),
276	"Failed to append path");
277	handleRtError(RTFileCreateTemp(m_szFileName, 0600),
278	"Failed to create temporary file '%s'", m_szFileName);
279	handleRtError(RTVfsIoStrmOpenNormal(m_szFileName, RTFILE_O_OPEN \| RTFILE_O_WRITE \| RTFILE_O_DENY_NONE, &m_hVfsIos),
280	"Failed to open '%s'", m_szFileName);
281	}
282
283	BugReportStream::~BugReportStream()
284	{
285	if (m_hVfsIos != NIL_RTVFSIOSTREAM)
286	RTVfsIoStrmRelease(m_hVfsIos);
287	RTFileDelete(m_szFileName);
288	}
289
290	int BugReportStream::printf(const char *pszFmt, ...)
291	{
292	va_list va;
293	va_start(va, pszFmt);
294	int cb = RTVfsIoStrmPrintfV(m_hVfsIos, pszFmt, va);
295	va_end(va);
296	return cb;
297	}
298
299	int BugReportStream::putStr(const char *pszString)
300	{
301	return RTVfsIoStrmPrintf(m_hVfsIos, "%s", pszString);
302	}
303
304	RTVFSIOSTREAM BugReportStream::getStream(void)
305	{
306	RTVfsIoStrmRelease(m_hVfsIos);
307	handleRtError(RTVfsIoStrmOpenNormal(m_szFileName, RTFILE_O_OPEN \| RTFILE_O_READ \| RTFILE_O_DENY_NONE, &m_hVfsIos),
308	"Failed to open '%s'", m_szFileName);
309	return m_hVfsIos;
310	}
311
312
313	/* Implementation - Generic */
314
315	BugReportFile::BugReportFile(const char pszPath, const char pszShortName) : BugReportItem(pszShortName)
316	{
317	m_hVfsIos = NIL_RTVFSIOSTREAM;
318	m_pszPath = RTStrDup(pszPath);
319	}
320
321	BugReportFile::~BugReportFile()
322	{
323	if (m_hVfsIos != NIL_RTVFSIOSTREAM)
324	RTVfsIoStrmRelease(m_hVfsIos);
325	if (m_pszPath)
326	RTStrFree(m_pszPath);
327	}
328
329	RTVFSIOSTREAM BugReportFile::getStream(void)
330	{
331	handleRtError(RTVfsIoStrmOpenNormal(m_pszPath, RTFILE_O_OPEN \| RTFILE_O_READ \| RTFILE_O_DENY_NONE, &m_hVfsIos),
332	"Failed to open '%s'", m_pszPath);
333	return m_hVfsIos;
334	}
335
336
337	BugReportCommand::BugReportCommand(const char pszTitle, const char pszExec, ...)
338	: BugReportItem(pszTitle), m_hVfsIos(NIL_RTVFSIOSTREAM)
339	{
340	unsigned cArgs = 0;
341	m_papszArgs[cArgs++] = RTStrDup(pszExec);
342
343	const char *pszArg;
344	va_list va;
345	va_start(va, pszExec);
346	do
347	{
348	if (cArgs >= RT_ELEMENTS(m_papszArgs))
349	{
350	va_end(va);
351	throw RTCError(com::Utf8StrFmt("Too many arguments (%u > %u)\n", cArgs+1, RT_ELEMENTS(m_papszArgs)));
352	}
353	pszArg = va_arg(va, const char *);
354	m_papszArgs[cArgs++] = pszArg ? RTStrDup(pszArg) : NULL;
355	} while (pszArg);
356	va_end(va);
357	}
358
359	BugReportCommand::~BugReportCommand()
360	{
361	if (m_hVfsIos != NIL_RTVFSIOSTREAM)
362	RTVfsIoStrmRelease(m_hVfsIos);
363	RTFileDelete(m_szFileName);
364	for (size_t i = 0; i < RT_ELEMENTS(m_papszArgs) && m_papszArgs[i]; ++i)
365	RTStrFree(m_papszArgs[i]);
366	}
367
368	RTVFSIOSTREAM BugReportCommand::getStream(void)
369	{
370	handleRtError(RTPathTemp(m_szFileName, RTPATH_MAX),
371	"Failed to obtain path to temporary folder");
372	handleRtError(RTPathAppend(m_szFileName, RTPATH_MAX, "BugRepXXXXX.tmp"),
373	"Failed to append path");
374	handleRtError(RTFileCreateTemp(m_szFileName, 0600),
375	"Failed to create temporary file '%s'", m_szFileName);
376
377	RTHANDLE hStdOutErr;
378	hStdOutErr.enmType = RTHANDLETYPE_FILE;
379	handleRtError(RTFileOpen(&hStdOutErr.u.hFile, m_szFileName,
380	RTFILE_O_WRITE \| RTFILE_O_CREATE_REPLACE \| RTFILE_O_DENY_WRITE),
381	"Failed to open temporary file '%s'", m_szFileName);
382
383	RTPROCESS hProcess;
384	handleRtError(RTProcCreateEx(m_papszArgs[0], m_papszArgs, RTENV_DEFAULT, 0,
385	NULL, &hStdOutErr, &hStdOutErr,
386	NULL, NULL, NULL, &hProcess),
387	"Failed to create process '%s'", m_papszArgs[0]);
388	RTPROCSTATUS status;
389	handleRtError(RTProcWait(hProcess, RTPROCWAIT_FLAGS_BLOCK, &status),
390	"Process wait failed");
391	//if (status.enmReason == RTPROCEXITREASON_NORMAL) {}
392	RTFileClose(hStdOutErr.u.hFile);
393
394	handleRtError(RTVfsIoStrmOpenNormal(m_szFileName, RTFILE_O_OPEN \| RTFILE_O_READ \| RTFILE_O_DENY_NONE, &m_hVfsIos),
395	"Failed to open '%s'", m_szFileName);
396	return m_hVfsIos;
397	}
398
399
400	BugReportCommandTemp::BugReportCommandTemp(const char pszTitle, const char pszExec, ...)
401	: BugReportItem(pszTitle), m_hVfsIos(NIL_RTVFSIOSTREAM)
402	{
403	handleRtError(RTPathTemp(m_szFileName, RTPATH_MAX),
404	"Failed to obtain path to temporary folder");
405	handleRtError(RTPathAppend(m_szFileName, RTPATH_MAX, "BugRepXXXXX.tmp"),
406	"Failed to append path");
407	handleRtError(RTFileCreateTemp(m_szFileName, 0600),
408	"Failed to create temporary file '%s'", m_szFileName);
409
410	unsigned cArgs = 0;
411	m_papszArgs[cArgs++] = RTStrDup(pszExec);
412
413	const char *pszArg;
414	va_list va;
415	va_start(va, pszExec);
416	do
417	{
418	if (cArgs >= RT_ELEMENTS(m_papszArgs) - 1)
419	{
420	va_end(va);
421	throw RTCError(com::Utf8StrFmt("Too many arguments (%u > %u)\n", cArgs+1, RT_ELEMENTS(m_papszArgs)));
422	}
423	pszArg = va_arg(va, const char *);
424	m_papszArgs[cArgs++] = RTStrDup(pszArg ? pszArg : m_szFileName);
425	} while (pszArg);
426	va_end(va);
427
428	m_papszArgs[cArgs++] = NULL;
429	}
430
431	BugReportCommandTemp::~BugReportCommandTemp()
432	{
433	if (m_hVfsIos != NIL_RTVFSIOSTREAM)
434	RTVfsIoStrmRelease(m_hVfsIos);
435	RTFileDelete(m_szErrFileName);
436	RTFileDelete(m_szFileName);
437	for (size_t i = 0; i < RT_ELEMENTS(m_papszArgs) && m_papszArgs[i]; ++i)
438	RTStrFree(m_papszArgs[i]);
439	}
440
441	RTVFSIOSTREAM BugReportCommandTemp::getStream(void)
442	{
443	handleRtError(RTPathTemp(m_szErrFileName, RTPATH_MAX),
444	"Failed to obtain path to temporary folder");
445	handleRtError(RTPathAppend(m_szErrFileName, RTPATH_MAX, "BugRepErrXXXXX.tmp"),
446	"Failed to append path");
447	handleRtError(RTFileCreateTemp(m_szErrFileName, 0600),
448	"Failed to create temporary file '%s'", m_szErrFileName);
449
450	RTHANDLE hStdOutErr;
451	hStdOutErr.enmType = RTHANDLETYPE_FILE;
452	handleRtError(RTFileOpen(&hStdOutErr.u.hFile, m_szErrFileName,
453	RTFILE_O_WRITE \| RTFILE_O_CREATE_REPLACE \| RTFILE_O_DENY_WRITE),
454	"Failed to open temporary file '%s'", m_szErrFileName);
455
456	/* Remove the output file to prevent errors or confirmation prompts */
457	handleRtError(RTFileDelete(m_szFileName),
458	"Failed to delete temporary file '%s'", m_szFileName);
459
460	RTPROCESS hProcess;
461	handleRtError(RTProcCreateEx(m_papszArgs[0], m_papszArgs, RTENV_DEFAULT, 0,
462	NULL, &hStdOutErr, &hStdOutErr,
463	NULL, NULL, NULL, &hProcess),
464	"Failed to create process '%s'", m_papszArgs[0]);
465	RTPROCSTATUS status;
466	handleRtError(RTProcWait(hProcess, RTPROCWAIT_FLAGS_BLOCK, &status),
467	"Process wait failed");
468	RTFileClose(hStdOutErr.u.hFile);
469
470	if (status.enmReason == RTPROCEXITREASON_NORMAL && status.iStatus == 0)
471	handleRtError(RTVfsIoStrmOpenNormal(m_szFileName, RTFILE_O_OPEN \| RTFILE_O_READ \| RTFILE_O_DENY_NONE, &m_hVfsIos),
472	"Failed to open '%s'", m_szFileName);
473	else
474	handleRtError(RTVfsIoStrmOpenNormal(m_szErrFileName, RTFILE_O_OPEN \| RTFILE_O_READ \| RTFILE_O_DENY_NONE, &m_hVfsIos),
475	"Failed to open '%s'", m_szErrFileName);
476	return m_hVfsIos;
477	}
478
479
480	BugReportText::BugReportText(const char *pszFileName) : BugReport(pszFileName)
481	{
482	handleRtError(RTStrmOpen(pszFileName, "w", &m_StrmTxt),
483	"Failed to open '%s'", pszFileName);
484	}
485
486	BugReportText::~BugReportText()
487	{
488	if (m_StrmTxt)
489	RTStrmClose(m_StrmTxt);
490	}
491
492	void BugReportText::processItem(BugReportItem* item)
493	{
494	int cb = RTStrmPrintf(m_StrmTxt, "[ %s ] -------------------------------------------\n", item->getTitle());
495	if (!cb)
496	throw RTCError(com::Utf8StrFmt("Write failure (cb=%d)\n", cb));
497
498	RTVFSIOSTREAM hVfsIos = NIL_RTVFSIOSTREAM;
499	try
500	{
501	hVfsIos = item->getStream();
502	}
503	catch (RTCError &e)
504	{
505	hVfsIos = NIL_RTVFSIOSTREAM;
506	RTStrmPutStr(m_StrmTxt, e.what());
507	}
508
509	int rc = VINF_SUCCESS;
510
511	if (hVfsIos != NIL_RTVFSIOSTREAM)
512	{
513	char buf[64*1024];
514	size_t cbRead, cbWritten;
515	cbRead = cbWritten = 0;
516	while (RT_SUCCESS(rc = RTVfsIoStrmRead(hVfsIos, buf, sizeof(buf), true /fBlocking/, &cbRead)) && cbRead)
517	{
518	rc = RTStrmWriteEx(m_StrmTxt, applyFilters(item, buf, &cbRead), cbRead, &cbWritten);
519	if (RT_FAILURE(rc) \|\| cbRead != cbWritten)
520	throw RTCError(com::Utf8StrFmt("Write failure (rc=%d, cbRead=%lu, cbWritten=%lu)\n",
521	rc, cbRead, cbWritten));
522	}
523	}
524
525	handleRtError(RTStrmPutCh(m_StrmTxt, '\n'), "Write failure");
526	}
527
528
529	BugReportTarGzip::BugReportTarGzip(const char *pszFileName)
530	: BugReport(pszFileName), m_hTarFss(NIL_RTVFSFSSTREAM)
531	{
532	VfsIoStreamHandle hVfsOut;
533	handleRtError(RTVfsIoStrmOpenNormal(pszFileName, RTFILE_O_WRITE \| RTFILE_O_CREATE \| RTFILE_O_DENY_WRITE,
534	hVfsOut.getPtr()),
535	"Failed to create output file '%s'", pszFileName);
536	handleRtError(RTZipGzipCompressIoStream(hVfsOut.get(), 0, 6, m_hVfsGzip.getPtr()),
537	"Failed to create compressed stream for '%s'", pszFileName);
538
539	int rc = RTZipTarFsStreamToIoStream(m_hVfsGzip.get(), RTZIPTARFORMAT_DEFAULT, RTZIPTAR_C_SPARSE, &m_hTarFss);
540	handleRtError(rc, "Failed to create TAR file '%s'", m_szTarName);
541	}
542
543	BugReportTarGzip::~BugReportTarGzip()
544	{
545	if (m_hTarFss != NIL_RTVFSFSSTREAM)
546	RTVfsFsStrmRelease(m_hTarFss);
547	}
548
549	void BugReportTarGzip::dumpExceptionToArchive(RTCString &strTarFile, RTCError &e)
550	{
551	RTVFSFILE hVfsFile;
552	int rc = RTVfsMemFileCreate(NIL_RTVFSIOSTREAM, _1K/cbEstimate/, &hVfsFile);
553	if (RT_SUCCESS(rc))
554	{
555	rc = RTVfsFileWrite(hVfsFile, e.what(), RTStrNLen(e.what(), 1024), NULL /pcbWritten/);
556	if (RT_SUCCESS(rc))
557	{
558	rc = RTVfsFileSeek(hVfsFile, 0 /offSeek/, RTFILE_SEEK_BEGIN, NULL /poffActual/);
559	if (RT_SUCCESS(rc))
560	{
561	RTVFSOBJ hVfsObj = RTVfsObjFromFile(hVfsFile);
562	rc = RTVfsFsStrmAdd(m_hTarFss, strTarFile.c_str(), hVfsObj, 0 /fFlags/);
563	RTVfsObjRelease(hVfsObj);
564	}
565	}
566	RTVfsFileRelease(hVfsFile);
567	}
568	handleRtError(rc, "Failed to add exception text to TAR archive '%s'", m_szTarName);
569	}
570
571	void BugReportTarGzip::processItem(BugReportItem* item)
572	{
573	/*
574	* @todo Our TAR implementation does not support names larger than 100 characters.
575	* We truncate the title to make sure it will fit into 100-character field of TAR header.
576	*/
577	RTCString strTarFile = RTCString(item->getTitle()).substr(0, RTStrNLen(item->getTitle(), 99));
578	RTVFSIOSTREAM hVfsIos = NIL_RTVFSIOSTREAM;
579	try
580	{
581	hVfsIos = item->getStream();
582	}
583	catch (RTCError &e)
584	{
585	hVfsIos = NIL_RTVFSIOSTREAM;
586	dumpExceptionToArchive(strTarFile, e);
587	}
588
589	if (hVfsIos != NIL_RTVFSIOSTREAM)
590	{
591	RTVFSOBJ hVfsObjIos = RTVfsObjFromIoStream(hVfsIos);
592	int rc = RTVfsFsStrmAdd(m_hTarFss, strTarFile.c_str(), hVfsObjIos, 0 /fFlags/);
593	RTVfsObjRelease(hVfsObjIos);
594	handleRtError(rc, "Failed to add file to TAR archive '%s'", m_szTarName);
595	}
596	}
597
598	void BugReportTarGzip::complete(void)
599	{
600	if (m_hTarFss != NIL_RTVFSFSSTREAM)
601	{
602	RTVfsFsStrmRelease(m_hTarFss);
603	m_hTarFss = NIL_RTVFSFSSTREAM;
604	}
605	handleRtError(RTVfsIoStrmFlush(m_hVfsGzip.get()), "Failed to flush output stream");
606	m_hVfsGzip.release();
607	}
608
609
610	/* Implementation - Main */
611
612	static void createBugReport(BugReport* report, const char *pszHome, MachineInfoList& machines)
613	{
614	/* Collect all log files from VBoxSVC */
615	VBRDir HomeDir(PathJoin(pszHome, "VBoxSVC.log*"));
616	const char *pcszSvcLogFile = HomeDir.next();
617	while (pcszSvcLogFile)
618	{
619	report->addItem(new BugReportFile(PathJoin(pszHome, pcszSvcLogFile), pcszSvcLogFile));
620	pcszSvcLogFile = HomeDir.next();
621	}
622
623	report->addItem(new BugReportFile(PathJoin(pszHome, "VirtualBox.xml"), "VirtualBox.xml"));
624	report->addItem(new BugReportCommand("HostUsbDevices", g_pszVBoxManage, "list", "usbhost", NULL));
625	report->addItem(new BugReportCommand("HostUsbFilters", g_pszVBoxManage, "list", "usbfilters", NULL));
626
627	for (MachineInfoList::iterator it = machines.begin(); it != machines.end(); ++it)
628	{
629	static const char * const s_apszLogFilePatterns[] = { "VBox.log*", "VBoxHardening.log" };
630	for (size_t iPat = 0; iPat < RT_ELEMENTS(s_apszLogFilePatterns); iPat++)
631	{
632	VBRDir VmLogFiles(PathJoin((*it)->getLogPath(), s_apszLogFilePatterns[iPat]));
633	const char *pcszVmLogFile = VmLogFiles.next();
634	while (pcszVmLogFile)
635	{
636	report->addItem(new BugReportFile(PathJoin((*it)->getLogPath(), pcszVmLogFile),
637	PathJoin((*it)->getName(), pcszVmLogFile)));
638	pcszVmLogFile = VmLogFiles.next();
639	}
640	}
641	report->addItem(new BugReportFile((*it)->getSettingsFile(),
642	PathJoin((it)->getName(), RTPathFilename((it)->getSettingsFile()))));
643	report->addItem(new BugReportCommand(PathJoin((*it)->getName(), "GuestProperties"),
644	g_pszVBoxManage, "guestproperty", "enumerate",
645	(*it)->getName(), NULL));
646	}
647
648	createBugReportOsSpecific(report, pszHome);
649	}
650
651
652	static void addMachine(MachineInfoList& list, ComPtr<IMachine> machine)
653	{
654	BOOL fAccessible = FALSE;
655	HRESULT hrc = machine->COMGETTER(Accessible)(&fAccessible);
656	if (SUCCEEDED(hrc) && !fAccessible)
657	return
658	handleComError(hrc, "Failed to get accessible status of VM");
659
660	com::Bstr name, logFolder, settingsFile;
661	handleComError(machine->COMGETTER(Name)(name.asOutParam()),
662	"Failed to get VM name");
663	handleComError(machine->COMGETTER(LogFolder)(logFolder.asOutParam()),
664	"Failed to get VM log folder");
665	handleComError(machine->COMGETTER(SettingsFilePath)(settingsFile.asOutParam()),
666	"Failed to get VM settings file path");
667	list.push_back(new MachineInfo(com::Utf8Str(name).c_str(),
668	com::Utf8Str(logFolder).c_str(),
669	com::Utf8Str(settingsFile).c_str()));
670	}
671
672
673	static void printHeader(void)
674	{
675	RTStrmPrintf(g_pStdErr, VBOX_PRODUCT " Bug Report Tool " VBOX_VERSION_STRING "\n"
676	"Copyright (C) " VBOX_C_YEAR " " VBOX_VENDOR "\n\n");
677	}
678
679	int main(int argc, char *argv[])
680	{
681	/*
682	* Initialize the VBox runtime without loading
683	* the support driver.
684	*/
685	RTR3InitExe(argc, &argv, 0);
686
687	bool fAllMachines = false;
688	bool fTextOutput = false;
689	const char *pszOutputFile = NULL;
690	std::list<const char *> nameList;
691	RTGETOPTUNION ValueUnion;
692	RTGETOPTSTATE GetState;
693	int ret = RTGetOptInit(&GetState, argc, argv,
694	g_aOptions, RT_ELEMENTS(g_aOptions),
695	1 /* First /, 0 /fFlags*/);
696	if (RT_FAILURE(ret))
697	return ret;
698	int ch;
699	while ((ch = RTGetOpt(&GetState, &ValueUnion)))
700	{
701	switch(ch)
702	{
703	case 'h':
704	printHeader();
705	RTStrmPrintf(g_pStdErr, g_szUsage, argv[0]);
706	return 0;
707	case 'A':
708	fAllMachines = true;
709	break;
710	case 'o':
711	pszOutputFile = ValueUnion.psz;
712	break;
713	case 't':
714	fTextOutput = true;
715	break;
716	case 'V':
717	RTPrintf("%sr%s\n", RTBldCfgVersion(), RTBldCfgRevisionStr());
718	return 0;
719	case VINF_GETOPT_NOT_OPTION:
720	nameList.push_back(ValueUnion.psz);
721	break;
722	default:
723	return RTGetOptPrintError(ch, &ValueUnion);
724	}
725	}
726
727	printHeader();
728
729	HRESULT hr = S_OK;
730	char homeDir[RTPATH_MAX];
731	com::GetVBoxUserHomeDirectory(homeDir, sizeof(homeDir));
732
733	try
734	{
735	/* Figure out the full path to VBoxManage */
736	char szVBoxBin[RTPATH_MAX];
737	if (!RTProcGetExecutablePath(szVBoxBin, sizeof(szVBoxBin)))
738	throw RTCError("RTProcGetExecutablePath failed\n");
739	RTPathStripFilename(szVBoxBin);
740	g_pszVBoxManage = RTPathJoinA(szVBoxBin, VBOXMANAGE);
741	if (!g_pszVBoxManage)
742	throw RTCError("Out of memory\n");
743
744	handleComError(com::Initialize(VBOX_COM_INIT_F_DEFAULT \| VBOX_COM_INIT_F_NO_COM_PATCHING), "Failed to initialize COM");
745
746	MachineInfoList list;
747
748	do
749	{
750	ComPtr<IVirtualBoxClient> virtualBoxClient;
751	ComPtr<IVirtualBox> virtualBox;
752	ComPtr<ISession> session;
753
754	hr = virtualBoxClient.createLocalObject(CLSID_VirtualBoxClient);
755	if (SUCCEEDED(hr))
756	hr = virtualBoxClient->COMGETTER(VirtualBox)(virtualBox.asOutParam());
757	else
758	hr = virtualBox.createLocalObject(CLSID_VirtualBox);
759	if (FAILED(hr))
760	RTStrmPrintf(g_pStdErr, "WARNING: Failed to create the VirtualBox object (hr=0x%x)\n", hr);
761	else
762	{
763	hr = session.createInprocObject(CLSID_Session);
764	if (FAILED(hr))
765	RTStrmPrintf(g_pStdErr, "WARNING: Failed to create a session object (hr=0x%x)\n", hr);
766	}
767
768	if (SUCCEEDED(hr))
769	{
770	if (fAllMachines)
771	{
772	com::SafeIfaceArray<IMachine> machines;
773	hr = virtualBox->COMGETTER(Machines)(ComSafeArrayAsOutParam(machines));
774	if (SUCCEEDED(hr))
775	{
776	for (size_t i = 0; i < machines.size(); ++i)
777	{
778	if (machines[i])
779	addMachine(list, machines[i]);
780	}
781	}
782	}
783	else
784	{
785	for ( std::list<const char *>::iterator it = nameList.begin(); it != nameList.end(); ++it)
786	{
787	ComPtr<IMachine> machine;
788	handleComError(virtualBox->FindMachine(com::Bstr(*it).raw(), machine.asOutParam()),
789	"No such machine '%s'", *it);
790	addMachine(list, machine);
791	}
792	}
793	}
794
795	}
796	while(0);
797
798	RTTIMESPEC TimeSpec;
799	RTTIME Time;
800	RTTimeExplode(&Time, RTTimeNow(&TimeSpec));
801	RTCStringFmt strOutFile("%04d-%02d-%02d-%02d-%02d-%02d-bugreport.%s",
802	Time.i32Year, Time.u8Month, Time.u8MonthDay,
803	Time.u8Hour, Time.u8Minute, Time.u8Second,
804	fTextOutput ? "txt" : "tgz");
805	RTCString strFallbackOutFile;
806	if (!pszOutputFile)
807	{
808	RTFILE tmp;
809	pszOutputFile = strOutFile.c_str();
810	int rc = RTFileOpen(&tmp, pszOutputFile, RTFILE_O_WRITE \| RTFILE_O_CREATE \| RTFILE_O_DENY_WRITE);
811	if (rc == VERR_ACCESS_DENIED)
812	{
813	char szUserHome[RTPATH_MAX];
814	handleRtError(RTPathUserHome(szUserHome, sizeof(szUserHome)), "Failed to obtain home directory");
815	strFallbackOutFile.printf("%s/%s", szUserHome, strOutFile.c_str());
816	pszOutputFile = strFallbackOutFile.c_str();
817	}
818	else if (RT_SUCCESS(rc))
819	{
820	RTFileClose(tmp);
821	RTFileDelete(pszOutputFile);
822	}
823	}
824	BugReport *pReport;
825	if (fTextOutput)
826	pReport = new BugReportText(pszOutputFile);
827	else
828	pReport = new BugReportTarGzip(pszOutputFile);
829	createBugReport(pReport, homeDir, list);
830	pReport->process();
831	pReport->complete();
832	RTPrintf("Report was written to '%s'\n", pszOutputFile);
833	delete pReport;
834	}
835	catch (RTCError &e)
836	{
837	RTStrmPrintf(g_pStdErr, "ERROR: %s\n", e.what());
838	}
839
840	com::Shutdown();
841
842	if (g_pszVBoxManage)
843	RTStrFree(g_pszVBoxManage);
844
845	return SUCCEEDED(hr) ? 0 : 1;
846	}

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

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

Download in other formats: