ApplianceImpl.h@ 51888

Last change on this file since 51888 was 50832, checked in by vboxsync, 11 years ago
pr6022. Support X509 certification during import OVF appliance.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 12.7 KB

Line
1	/* $Id: ApplianceImpl.h 50832 2014-03-21 06:08:32Z vboxsync $ */
2	/** @file
3	* VirtualBox COM class implementation
4	*/
5
6	/*
7	* Copyright (C) 2006-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
18	#ifndef ____H_APPLIANCEIMPL
19	#define ____H_APPLIANCEIMPL
20
21	/* VBox includes */
22	#include <VBox/settings.h>
23	#include "VirtualSystemDescriptionWrap.h"
24	#include "ApplianceWrap.h"
25	#include "MediumFormatImpl.h"
26
27	/* Todo: This file needs massive cleanup. Split IAppliance in a public and
28	* private classes. */
29	#include <iprt/tar.h>
30	#include "ovfreader.h"
31	#include <set>
32
33	/* VBox forward declarations */
34	class Progress;
35	class VirtualSystemDescription;
36	struct VirtualSystemDescriptionEntry;
37	struct LocationInfo;
38	typedef struct VDINTERFACE *PVDINTERFACE;
39	typedef struct VDINTERFACEIO *PVDINTERFACEIO;
40	typedef struct SHASTORAGE *PSHASTORAGE;
41
42	typedef enum applianceIOName { applianceIOTar, applianceIOFile, applianceIOSha } APPLIANCEIONAME;
43
44	namespace ovf
45	{
46	struct HardDiskController;
47	struct VirtualSystem;
48	class OVFReader;
49	struct DiskImage;
50	struct EnvelopeData;
51	}
52
53	namespace xml
54	{
55	class Document;
56	class ElementNode;
57	}
58
59	namespace settings
60	{
61	class MachineConfigFile;
62	}
63
64	class ATL_NO_VTABLE Appliance :
65	public ApplianceWrap
66	{
67	public:
68
69	DECLARE_EMPTY_CTOR_DTOR(Appliance)
70
71	HRESULT FinalConstruct();
72	void FinalRelease();
73
74
75	HRESULT init(VirtualBox *aVirtualBox);
76	void uninit();
77
78	/* public methods only for internal purposes */
79
80	static HRESULT i_setErrorStatic(HRESULT aResultCode,
81	const Utf8Str &aText)
82	{
83	return setErrorInternal(aResultCode, getStaticClassIID(), getStaticComponentName(), aText, false, true);
84	}
85
86	/* private instance data */
87	private:
88	// wrapped IAppliance properties
89	HRESULT getPath(com::Utf8Str &aPath);
90	HRESULT getDisks(std::vector<com::Utf8Str> &aDisks);
91	HRESULT getVirtualSystemDescriptions(std::vector<ComPtr<IVirtualSystemDescription> > &aVirtualSystemDescriptions);
92	HRESULT getMachines(std::vector<com::Utf8Str> &aMachines);
93
94	// wrapped IAppliance methods
95	HRESULT read(const com::Utf8Str &aFile,
96	ComPtr<IProgress> &aProgress);
97	HRESULT interpret();
98	HRESULT importMachines(const std::vector<ImportOptions_T> &aOptions,
99	ComPtr<IProgress> &aProgress);
100	HRESULT createVFSExplorer(const com::Utf8Str &aURI,
101	ComPtr<IVFSExplorer> &aExplorer);
102	HRESULT write(const com::Utf8Str &aFormat,
103	const std::vector<ExportOptions_T> &aOptions,
104	const com::Utf8Str &aPath,
105	ComPtr<IProgress> &aProgress);
106	HRESULT getWarnings(std::vector<com::Utf8Str> &aWarnings);
107
108	/** weak VirtualBox parent */
109	VirtualBox* const mVirtualBox;
110
111	struct ImportStack;
112	struct TaskOVF;
113	struct Data; // opaque, defined in ApplianceImpl.cpp
114	Data *m;
115
116	enum SetUpProgressMode { ImportFile, ImportS3, WriteFile, WriteS3 };
117
118	/** @name General stuff
119	* @{
120	*/
121	bool i_isApplianceIdle();
122	HRESULT i_searchUniqueVMName(Utf8Str& aName) const;
123	HRESULT i_searchUniqueDiskImageFilePath(Utf8Str& aName) const;
124	HRESULT i_setUpProgress(ComObjPtr<Progress> &pProgress,
125	const Bstr &bstrDescription,
126	SetUpProgressMode mode);
127	void i_waitForAsyncProgress(ComObjPtr<Progress> &pProgressThis, ComPtr<IProgress> &pProgressAsync);
128	void i_addWarning(const char* aWarning, ...);
129	void i_disksWeight();
130	void i_parseBucket(Utf8Str &aPath, Utf8Str &aBucket);
131
132	static DECLCALLBACK(int) i_taskThreadImportOrExport(RTTHREAD aThread, void *pvUser);
133
134	HRESULT i_initSetOfSupportedStandardsURI();
135
136	Utf8Str i_typeOfVirtualDiskFormatFromURI(Utf8Str type) const;
137
138	std::set<Utf8Str> i_URIFromTypeOfVirtualDiskFormat(Utf8Str type);
139
140	HRESULT i_initApplianceIONameMap();
141
142	Utf8Str i_applianceIOName(APPLIANCEIONAME type) const;
143
144	HRESULT i_findMediumFormatFromDiskImage(const ovf::DiskImage &di, ComObjPtr<MediumFormat>& mf);
145	/** @} */
146
147	/** @name Read stuff
148	* @{
149	*/
150	HRESULT i_readImpl(const LocationInfo &aLocInfo, ComObjPtr<Progress> &aProgress);
151
152	HRESULT i_readFS(TaskOVF *pTask);
153	HRESULT i_readFSOVF(TaskOVF *pTask);
154	HRESULT i_readFSOVA(TaskOVF *pTask);
155	HRESULT i_readFSImpl(TaskOVF *pTask, const RTCString &strFilename, PVDINTERFACEIO pCallbacks, PSHASTORAGE pStorage);
156	HRESULT i_readS3(TaskOVF *pTask);
157	/** @} */
158
159	/** @name Import stuff
160	* @}
161	*/
162	HRESULT i_importImpl(const LocationInfo &aLocInfo, ComObjPtr<Progress> &aProgress);
163
164	HRESULT i_importFS(TaskOVF *pTask);
165	HRESULT i_importFSOVF(TaskOVF *pTask, AutoWriteLockBase& writeLock);
166	HRESULT i_importFSOVA(TaskOVF *pTask, AutoWriteLockBase& writeLock);
167	HRESULT i_importS3(TaskOVF *pTask);
168
169	HRESULT i_readFileToBuf(const Utf8Str &strFile,
170	void **ppvBuf,
171	size_t *pcbSize,
172	bool fCreateDigest,
173	PVDINTERFACEIO pCallbacks,
174	PSHASTORAGE pStorage);
175	HRESULT i_readTarFileToBuf(struct FSSRDONLYINTERFACEIO *pTarIo,
176	const Utf8Str &strFile,
177	void **ppvBuf,
178	size_t *pcbSize,
179	bool fCreateDigest,
180	PVDINTERFACEIO pCallbacks,
181	PSHASTORAGE pStorage);
182	HRESULT i_verifyManifestFile(const Utf8Str &strFile, ImportStack &stack, void *pvBuf, size_t cbSize);
183
184	HRESULT i_verifyCertificateFile(void *pvBuf, size_t cbSize, PSHASTORAGE pStorage);
185
186	void i_convertDiskAttachmentValues(const ovf::HardDiskController &hdc,
187	uint32_t ulAddressOnParent,
188	Bstr &controllerType,
189	int32_t &lControllerPort,
190	int32_t &lDevice);
191
192	void i_importOneDiskImage(const ovf::DiskImage &di,
193	Utf8Str *strTargetPath,
194	ComObjPtr<Medium> &pTargetHD,
195	ImportStack &stack,
196	PVDINTERFACEIO pCallbacks,
197	PSHASTORAGE pStorage);
198
199	void i_importMachineGeneric(const ovf::VirtualSystem &vsysThis,
200	ComObjPtr<VirtualSystemDescription> &vsdescThis,
201	ComPtr<IMachine> &pNewMachine,
202	ImportStack &stack,
203	PVDINTERFACEIO pCallbacks,
204	PSHASTORAGE pStorage);
205	void i_importVBoxMachine(ComObjPtr<VirtualSystemDescription> &vsdescThis,
206	ComPtr<IMachine> &pNewMachine,
207	ImportStack &stack,
208	PVDINTERFACEIO pCallbacks,
209	PSHASTORAGE pStorage);
210	void i_importMachines(ImportStack &stack,
211	PVDINTERFACEIO pCallbacks,
212	PSHASTORAGE pStorage);
213
214	HRESULT i_preCheckImageAvailability(PSHASTORAGE pSHAStorage,
215	RTCString &availableImage);
216	/** @} */
217
218	/** @name Write stuff
219	* @{
220	*/
221	HRESULT i_writeImpl(ovf::OVFVersion_T aFormat, const LocationInfo &aLocInfo, ComObjPtr<Progress> &aProgress);
222
223	HRESULT i_writeFS(TaskOVF *pTask);
224	HRESULT i_writeFSOVF(TaskOVF *pTask, AutoWriteLockBase& writeLock);
225	HRESULT i_writeFSOVA(TaskOVF *pTask, AutoWriteLockBase& writeLock);
226	HRESULT i_writeFSImpl(TaskOVF *pTask, AutoWriteLockBase& writeLock, PVDINTERFACEIO pCallbacks, PSHASTORAGE pStorage);
227	HRESULT i_writeS3(TaskOVF *pTask);
228
229	struct XMLStack;
230
231	void i_buildXML(AutoWriteLockBase& writeLock,
232	xml::Document &doc,
233	XMLStack &stack,
234	const Utf8Str &strPath,
235	ovf::OVFVersion_T enFormat);
236	void i_buildXMLForOneVirtualSystem(AutoWriteLockBase& writeLock,
237	xml::ElementNode &elmToAddVirtualSystemsTo,
238	std::list<xml::ElementNode> pllElementsWithUuidAttributes,
239	ComObjPtr<VirtualSystemDescription> &vsdescThis,
240	ovf::OVFVersion_T enFormat,
241	XMLStack &stack);
242	/** @} */
243
244	friend class Machine;
245	};
246
247	void i_parseURI(Utf8Str strUri, LocationInfo &locInfo);
248
249	struct VirtualSystemDescriptionEntry
250	{
251	uint32_t ulIndex; ///< zero-based index of this entry within array
252	VirtualSystemDescriptionType_T type; ///< type of this entry
253	Utf8Str strRef; ///< reference number (hard disk controllers only)
254	Utf8Str strOvf; ///< original OVF value (type-dependent)
255	Utf8Str strVBoxSuggested; ///< configuration value (type-dependent); original value suggested by interpret()
256	Utf8Str strVBoxCurrent; ///< configuration value (type-dependent); current value, either from interpret() or setFinalValue()
257	Utf8Str strExtraConfigSuggested; ///< extra configuration key=value strings (type-dependent); original value suggested by interpret()
258	Utf8Str strExtraConfigCurrent; ///< extra configuration key=value strings (type-dependent); current value, either from interpret() or setFinalValue()
259
260	uint32_t ulSizeMB; ///< hard disk images only: a copy of ovf::DiskImage::ulSuggestedSizeMB
261	bool skipIt; ///< used during export to skip some parts if it's needed
262	};
263
264	class ATL_NO_VTABLE VirtualSystemDescription :
265	public VirtualSystemDescriptionWrap
266	{
267	friend class Appliance;
268
269	public:
270
271	DECLARE_EMPTY_CTOR_DTOR(VirtualSystemDescription)
272
273	HRESULT FinalConstruct();
274	void FinalRelease();
275
276	HRESULT init();
277	void uninit();
278
279	/* public methods only for internal purposes */
280	void i_addEntry(VirtualSystemDescriptionType_T aType,
281	const Utf8Str &strRef,
282	const Utf8Str &aOvfValue,
283	const Utf8Str &aVBoxValue,
284	uint32_t ulSizeMB = 0,
285	const Utf8Str &strExtraConfig = "");
286
287	std::list<VirtualSystemDescriptionEntry*> i_findByType(VirtualSystemDescriptionType_T aType);
288	const VirtualSystemDescriptionEntry* i_findControllerFromID(uint32_t id);
289
290	void i_importVBoxMachineXML(const xml::ElementNode &elmMachine);
291	const settings::MachineConfigFile* i_getMachineConfig() const;
292
293	/* private instance data */
294	private:
295
296	// wrapped IVirtualSystemDescription properties
297	HRESULT getCount(ULONG *aCount);
298
299	// wrapped IVirtualSystemDescription methods
300	HRESULT getDescription(std::vector<VirtualSystemDescriptionType_T> &aTypes,
301	std::vector<com::Utf8Str> &aRefs,
302	std::vector<com::Utf8Str> &aOVFValues,
303	std::vector<com::Utf8Str> &aVBoxValues,
304	std::vector<com::Utf8Str> &aExtraConfigValues);
305	HRESULT getDescriptionByType(VirtualSystemDescriptionType_T aType,
306	std::vector<VirtualSystemDescriptionType_T> &aTypes,
307	std::vector<com::Utf8Str> &aRefs,
308	std::vector<com::Utf8Str> &aOVFValues,
309	std::vector<com::Utf8Str> &aVBoxValues,
310	std::vector<com::Utf8Str> &aExtraConfigValues);
311	HRESULT getValuesByType(VirtualSystemDescriptionType_T aType,
312	VirtualSystemDescriptionValueType_T aWhich,
313	std::vector<com::Utf8Str> &aValues);
314	HRESULT setFinalValues(const std::vector<BOOL> &aEnabled,
315	const std::vector<com::Utf8Str> &aVBoxValues,
316	const std::vector<com::Utf8Str> &aExtraConfigValues);
317	HRESULT addDescription(VirtualSystemDescriptionType_T aType,
318	const com::Utf8Str &aVBoxValue,
319	const com::Utf8Str &aExtraConfigValue);
320	void i_removeByType(VirtualSystemDescriptionType_T aType);
321
322	struct Data;
323	Data *m;
324
325	friend class Machine;
326	};
327
328	#endif // !____H_APPLIANCEIMPL
329	/* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

source: vbox/trunk/src/VBox/Main/include/ApplianceImpl.h@ 51888

Download in other formats: