VirtualBox

source: vbox/trunk/src/VBox/Frontends/VBoxBugReport/VBoxBugReport.h@ 67954

Last change on this file since 67954 was 65478, checked in by vboxsync, 8 years ago

BugReportTool: rudimentary filtering support for Windows registry files, memory leak fixes (bugref:8169)

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 6.9 KB
Line 
1/* $Id: VBoxBugReport.h 65478 2017-01-27 10:00:44Z vboxsync $ */
2/** @file
3 * VBoxBugReport - VirtualBox command-line diagnostics tool, internal header file.
4 */
5
6/*
7 * Copyright (C) 2006-2016 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#ifndef ___H_VBOXBUGREPORT
19#define ___H_VBOXBUGREPORT
20
21/*
22 * Introduction.
23 *
24 * In the most general sense a bug report is a collection of data obtained from
25 * the user's host system. It may include files common for all VMs, like the
26 * VBoxSVC.log file, as well as files related to particular machines. It may
27 * also contain the output of commands executed on the host, as well as data
28 * collected via OS APIs.
29 */
30
31/* @todo not sure if using a separate namespace would be beneficial */
32
33#include <iprt/path.h>
34#include <iprt/stream.h>
35#include <iprt/tar.h>
36#include <iprt/vfs.h>
37#include <iprt/cpp/list.h>
38
39#ifdef RT_OS_WINDOWS
40#define VBOXMANAGE "VBoxManage.exe"
41#else /* !RT_OS_WINDOWS */
42#define VBOXMANAGE "VBoxManage"
43#endif /* !RT_OS_WINDOWS */
44
45/* Base */
46
47inline void handleRtError(int rc, const char *pszMsgFmt, ...)
48{
49 if (RT_FAILURE(rc))
50 {
51 va_list va;
52 va_start(va, pszMsgFmt);
53 RTCString msgArgs(pszMsgFmt, va);
54 va_end(va);
55 RTCStringFmt msg("%s. %s (%d)\n", msgArgs.c_str(), RTErrGetFull(rc), rc);
56 throw RTCError(msg.c_str());
57 }
58}
59
60inline void handleComError(HRESULT hr, const char *pszMsgFmt, ...)
61{
62 if (FAILED(hr))
63 {
64 va_list va;
65 va_start(va, pszMsgFmt);
66 RTCString msgArgs(pszMsgFmt, va);
67 va_end(va);
68 RTCStringFmt msg("%s (hr=0x%x)\n", msgArgs.c_str(), hr);
69 throw RTCError(msg.c_str());
70 }
71}
72
73/*
74 * An auxiliary class to facilitate in-place path joins.
75 */
76class PathJoin
77{
78public:
79 PathJoin(const char *folder, const char *file) { m_path = RTPathJoinA(folder, file); }
80 ~PathJoin() { RTStrFree(m_path); };
81 operator char*() const { return m_path; };
82private:
83 char *m_path;
84};
85
86
87/*
88 * An abstract class serving as the root of the bug report filter tree.
89 * A child provides an implementation of the 'apply' method. A child
90 * should modify the input buffer (provided via pvSource) in place, or
91 * allocate a new buffer via 'allocateBuffer'. Allocated buffers are
92 * released automatically when another buffer is allocated, which means
93 * that NEXT CALL TO 'APPLY' INVALIDATES BUFFERS RETURNED IN PREVIOUS
94 * CALLS!
95 */
96class BugReportFilter
97{
98public:
99 BugReportFilter();
100 virtual ~BugReportFilter();
101 virtual void *apply(void *pvSource, size_t *pcbInOut) = 0;
102protected:
103 void *allocateBuffer(size_t cbNeeded);
104private:
105 void *m_pvBuffer;
106 size_t m_cbBuffer;
107};
108
109
110/*
111 * An abstract class serving as the root of the bug report item tree.
112 */
113class BugReportItem
114{
115public:
116 BugReportItem(const char *pszTitle);
117 virtual ~BugReportItem();
118 virtual const char *getTitle(void);
119 virtual PRTSTREAM getStream(void) = 0;
120 void addFilter(BugReportFilter *filter);
121 void *applyFilter(void *pvSource, size_t *pcbInOut);
122private:
123 char *m_pszTitle;
124 BugReportFilter *m_filter;
125};
126
127/*
128 * An abstract class to serve as a base class for all report types.
129 */
130class BugReport
131{
132public:
133 BugReport(const char *pszFileName);
134 virtual ~BugReport();
135
136 void addItem(BugReportItem* item, BugReportFilter *filter = 0);
137 int getItemCount(void);
138 void process();
139 void *applyFilters(BugReportItem* item, void *pvSource, size_t *pcbInOut);
140
141 virtual void processItem(BugReportItem* item) = 0;
142 virtual void complete(void) = 0;
143
144protected:
145 char *m_pszFileName;
146 RTCList<BugReportItem*> m_Items;
147};
148
149/*
150 * An auxiliary class providing formatted output into a temporary file for item
151 * classes that obtain data via host OS APIs.
152 */
153class BugReportStream : public BugReportItem
154{
155public:
156 BugReportStream(const char *pszTitle);
157 virtual ~BugReportStream();
158 virtual PRTSTREAM getStream(void);
159protected:
160 int printf(const char *pszFmt, ...);
161 int putStr(const char *pszString);
162private:
163 PRTSTREAM m_Strm;
164 char m_szFileName[RTPATH_MAX];
165};
166
167
168/* Generic */
169
170/*
171 * This class reports everything into a single text file.
172 */
173class BugReportText : public BugReport
174{
175public:
176 BugReportText(const char *pszFileName);
177 virtual ~BugReportText();
178 virtual void processItem(BugReportItem* item);
179 virtual void complete(void) {};
180private:
181 PRTSTREAM m_StrmTxt;
182};
183
184/*
185 * This class reports items as individual files archived into a single compressed TAR file.
186 */
187class BugReportTarGzip : public BugReport
188{
189public:
190 BugReportTarGzip(const char *pszFileName);
191 virtual ~BugReportTarGzip();
192 virtual void processItem(BugReportItem* item);
193 virtual void complete(void);
194private:
195 /*
196 * Helper class to release handles going out of scope.
197 */
198 class VfsIoStreamHandle
199 {
200 public:
201 VfsIoStreamHandle() : m_hVfsStream(NIL_RTVFSIOSTREAM) {};
202 ~VfsIoStreamHandle() { release(); }
203 PRTVFSIOSTREAM getPtr(void) { return &m_hVfsStream; };
204 RTVFSIOSTREAM get(void) { return m_hVfsStream; };
205 void release(void)
206 {
207 if (m_hVfsStream != NIL_RTVFSIOSTREAM)
208 RTVfsIoStrmRelease(m_hVfsStream);
209 m_hVfsStream = NIL_RTVFSIOSTREAM;
210 };
211 private:
212 RTVFSIOSTREAM m_hVfsStream;
213 };
214
215 VfsIoStreamHandle m_hVfsGzip;
216
217 RTTAR m_hTar;
218 RTTARFILE m_hTarFile;
219 char m_szTarName[RTPATH_MAX];
220};
221
222
223/*
224 * BugReportFile adds a file as an item to a report.
225 */
226class BugReportFile : public BugReportItem
227{
228public:
229 BugReportFile(const char *pszPath, const char *pcszName);
230 virtual ~BugReportFile();
231 virtual PRTSTREAM getStream(void);
232
233private:
234 char *m_pszPath;
235 PRTSTREAM m_Strm;
236};
237
238/*
239 * A base class for item classes that collect CLI output.
240 */
241class BugReportCommand : public BugReportItem
242{
243public:
244 BugReportCommand(const char *pszTitle, const char *pszExec, ...);
245 virtual ~BugReportCommand();
246 virtual PRTSTREAM getStream(void);
247private:
248 PRTSTREAM m_Strm;
249 char m_szFileName[RTPATH_MAX];
250 char *m_papszArgs[32];
251};
252
253/*
254 * A base class for item classes that provide temp output file to a command.
255 */
256class BugReportCommandTemp : public BugReportItem
257{
258public:
259 BugReportCommandTemp(const char *pszTitle, const char *pszExec, ...);
260 virtual ~BugReportCommandTemp();
261 virtual PRTSTREAM getStream(void);
262private:
263 PRTSTREAM m_Strm;
264 char m_szFileName[RTPATH_MAX];
265 char m_szErrFileName[RTPATH_MAX];
266 char *m_papszArgs[32];
267};
268
269/* Platform-specific */
270
271void createBugReportOsSpecific(BugReport* report, const char *pszHome);
272
273#endif /* !___H_VBOXBUGREPORT */
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette