VirtualBox

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

Last change on this file since 59555 was 59555, checked in by vboxsync, 9 years ago

ApplianceImpl: Use the other manifest API to do verification.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 13.1 KB
Line 
1/* $Id: ApplianceImpl.h 59555 2016-02-02 02:03:30Z 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 */
34class Progress;
35class VirtualSystemDescription;
36struct VirtualSystemDescriptionEntry;
37struct LocationInfo;
38typedef struct VDINTERFACE *PVDINTERFACE;
39typedef struct VDINTERFACEIO *PVDINTERFACEIO;
40typedef struct SHASTORAGE *PSHASTORAGE;
41
42typedef enum applianceIOName { applianceIOTar, applianceIOFile, applianceIOSha } APPLIANCEIONAME;
43
44namespace ovf
45{
46 struct HardDiskController;
47 struct VirtualSystem;
48 class OVFReader;
49 struct DiskImage;
50 struct EnvelopeData;
51}
52
53namespace xml
54{
55 class Document;
56 class ElementNode;
57}
58
59namespace settings
60{
61 class MachineConfigFile;
62}
63
64class ATL_NO_VTABLE Appliance :
65 public ApplianceWrap
66{
67public:
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 */
87private:
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 HRESULT getPasswordIds(std::vector<com::Utf8Str> &aIdentifiers);
108 HRESULT getMediumIdsForPasswordId(const com::Utf8Str &aPasswordId, std::vector<com::Guid> &aIdentifiers);
109 HRESULT addPasswords(const std::vector<com::Utf8Str> &aIdentifiers,
110 const std::vector<com::Utf8Str> &aPasswords);
111
112 /** weak VirtualBox parent */
113 VirtualBox* const mVirtualBox;
114
115 struct ImportStack;
116 class TaskOVF;
117 struct Data; // opaque, defined in ApplianceImpl.cpp
118 Data *m;
119
120 enum SetUpProgressMode { ImportFile, ImportS3, WriteFile, WriteS3 };
121
122 /** @name General stuff
123 * @{
124 */
125 bool i_isApplianceIdle();
126 HRESULT i_searchUniqueVMName(Utf8Str& aName) const;
127 HRESULT i_searchUniqueDiskImageFilePath(Utf8Str& aName) const;
128 HRESULT i_setUpProgress(ComObjPtr<Progress> &pProgress,
129 const Bstr &bstrDescription,
130 SetUpProgressMode mode);
131 void i_waitForAsyncProgress(ComObjPtr<Progress> &pProgressThis, ComPtr<IProgress> &pProgressAsync);
132 void i_addWarning(const char* aWarning, ...);
133 void i_disksWeight();
134 void i_parseBucket(Utf8Str &aPath, Utf8Str &aBucket);
135
136 static DECLCALLBACK(int) i_taskThreadImportOrExport(RTTHREAD aThread, void *pvUser);
137
138 HRESULT i_initSetOfSupportedStandardsURI();
139
140 Utf8Str i_typeOfVirtualDiskFormatFromURI(Utf8Str type) const;
141
142 std::set<Utf8Str> i_URIFromTypeOfVirtualDiskFormat(Utf8Str type);
143
144 HRESULT i_initApplianceIONameMap();
145
146 Utf8Str i_applianceIOName(APPLIANCEIONAME type) const;
147
148 HRESULT i_findMediumFormatFromDiskImage(const ovf::DiskImage &di, ComObjPtr<MediumFormat>& mf);
149 /** @} */
150
151 /** @name Read stuff
152 * @{
153 */
154 HRESULT i_readImpl(const LocationInfo &aLocInfo, ComObjPtr<Progress> &aProgress);
155
156 HRESULT i_readFS(TaskOVF *pTask);
157 HRESULT i_readFSOVF(TaskOVF *pTask);
158 HRESULT i_readFSOVA(TaskOVF *pTask);
159 HRESULT i_readFSImpl(TaskOVF *pTask, const RTCString &strFilename, PVDINTERFACEIO pCallbacks, PSHASTORAGE pStorage);
160 HRESULT i_readS3(TaskOVF *pTask);
161 /** @} */
162
163 /** @name Import stuff
164 * @}
165 */
166 HRESULT i_importImpl(const LocationInfo &aLocInfo, ComObjPtr<Progress> &aProgress);
167
168 HRESULT i_importFS(TaskOVF *pTask);
169 HRESULT i_importFSOVF(TaskOVF *pTask, AutoWriteLockBase& writeLock);
170 HRESULT i_importFSOVA(TaskOVF *pTask, AutoWriteLockBase& writeLock);
171 HRESULT i_importS3(TaskOVF *pTask);
172
173 HRESULT i_readFileToBuf(const Utf8Str &strFile,
174 void **ppvBuf,
175 size_t *pcbSize,
176 bool fCreateDigest,
177 PVDINTERFACEIO pCallbacks,
178 PSHASTORAGE pStorage);
179 HRESULT i_readTarFileToBuf(struct FSSRDONLYINTERFACEIO *pTarIo,
180 const Utf8Str &strFile,
181 void **ppvBuf,
182 size_t *pcbSize,
183 bool fCreateDigest,
184 PVDINTERFACEIO pCallbacks,
185 PSHASTORAGE pStorage);
186 HRESULT i_verifyManifestFile(const Utf8Str &strFile, ImportStack &stack,
187 RTVFSFILE hManifestVfsFile, const char *pszOvfEntry);
188
189 HRESULT i_verifyCertificateFile(void *pvBuf, size_t cbSize, PSHASTORAGE pStorage);
190
191 void i_convertDiskAttachmentValues(const ovf::HardDiskController &hdc,
192 uint32_t ulAddressOnParent,
193 Bstr &controllerType,
194 int32_t &lControllerPort,
195 int32_t &lDevice);
196
197 void i_importOneDiskImage(const ovf::DiskImage &di,
198 Utf8Str *strTargetPath,
199 ComObjPtr<Medium> &pTargetHD,
200 ImportStack &stack,
201 PVDINTERFACEIO pCallbacks,
202 PSHASTORAGE pStorage);
203
204 void i_importMachineGeneric(const ovf::VirtualSystem &vsysThis,
205 ComObjPtr<VirtualSystemDescription> &vsdescThis,
206 ComPtr<IMachine> &pNewMachine,
207 ImportStack &stack,
208 PVDINTERFACEIO pCallbacks,
209 PSHASTORAGE pStorage);
210 void i_importVBoxMachine(ComObjPtr<VirtualSystemDescription> &vsdescThis,
211 ComPtr<IMachine> &pNewMachine,
212 ImportStack &stack,
213 PVDINTERFACEIO pCallbacks,
214 PSHASTORAGE pStorage);
215 void i_importMachines(ImportStack &stack,
216 PVDINTERFACEIO pCallbacks,
217 PSHASTORAGE pStorage);
218
219 HRESULT i_preCheckImageAvailability(PSHASTORAGE pSHAStorage,
220 RTCString &availableImage);
221 /** @} */
222
223 /** @name Write stuff
224 * @{
225 */
226 HRESULT i_writeImpl(ovf::OVFVersion_T aFormat, const LocationInfo &aLocInfo, ComObjPtr<Progress> &aProgress);
227
228 HRESULT i_writeFS(TaskOVF *pTask);
229 HRESULT i_writeFSOVF(TaskOVF *pTask, AutoWriteLockBase& writeLock);
230 HRESULT i_writeFSOVA(TaskOVF *pTask, AutoWriteLockBase& writeLock);
231 HRESULT i_writeFSImpl(TaskOVF *pTask, AutoWriteLockBase& writeLock, PVDINTERFACEIO pCallbacks, PSHASTORAGE pStorage);
232 HRESULT i_writeS3(TaskOVF *pTask);
233
234 struct XMLStack;
235
236 void i_buildXML(AutoWriteLockBase& writeLock,
237 xml::Document &doc,
238 XMLStack &stack,
239 const Utf8Str &strPath,
240 ovf::OVFVersion_T enFormat);
241 void i_buildXMLForOneVirtualSystem(AutoWriteLockBase& writeLock,
242 xml::ElementNode &elmToAddVirtualSystemsTo,
243 std::list<xml::ElementNode*> *pllElementsWithUuidAttributes,
244 ComObjPtr<VirtualSystemDescription> &vsdescThis,
245 ovf::OVFVersion_T enFormat,
246 XMLStack &stack);
247 /** @} */
248
249 friend class Machine;
250};
251
252void i_parseURI(Utf8Str strUri, LocationInfo &locInfo);
253
254struct VirtualSystemDescriptionEntry
255{
256 uint32_t ulIndex; ///< zero-based index of this entry within array
257 VirtualSystemDescriptionType_T type; ///< type of this entry
258 Utf8Str strRef; ///< reference number (hard disk controllers only)
259 Utf8Str strOvf; ///< original OVF value (type-dependent)
260 Utf8Str strVBoxSuggested; ///< configuration value (type-dependent); original value suggested by interpret()
261 Utf8Str strVBoxCurrent; ///< configuration value (type-dependent); current value, either from interpret() or setFinalValue()
262 Utf8Str strExtraConfigSuggested; ///< extra configuration key=value strings (type-dependent); original value suggested by interpret()
263 Utf8Str strExtraConfigCurrent; ///< extra configuration key=value strings (type-dependent); current value, either from interpret() or setFinalValue()
264
265 uint32_t ulSizeMB; ///< hard disk images only: a copy of ovf::DiskImage::ulSuggestedSizeMB
266 bool skipIt; ///< used during export to skip some parts if it's needed
267};
268
269class ATL_NO_VTABLE VirtualSystemDescription :
270 public VirtualSystemDescriptionWrap
271{
272 friend class Appliance;
273
274public:
275
276 DECLARE_EMPTY_CTOR_DTOR(VirtualSystemDescription)
277
278 HRESULT FinalConstruct();
279 void FinalRelease();
280
281 HRESULT init();
282 void uninit();
283
284 /* public methods only for internal purposes */
285 void i_addEntry(VirtualSystemDescriptionType_T aType,
286 const Utf8Str &strRef,
287 const Utf8Str &aOvfValue,
288 const Utf8Str &aVBoxValue,
289 uint32_t ulSizeMB = 0,
290 const Utf8Str &strExtraConfig = "");
291
292 std::list<VirtualSystemDescriptionEntry*> i_findByType(VirtualSystemDescriptionType_T aType);
293 const VirtualSystemDescriptionEntry* i_findControllerFromID(uint32_t id);
294
295 void i_importVBoxMachineXML(const xml::ElementNode &elmMachine);
296 const settings::MachineConfigFile* i_getMachineConfig() const;
297
298 /* private instance data */
299private:
300
301 // wrapped IVirtualSystemDescription properties
302 HRESULT getCount(ULONG *aCount);
303
304 // wrapped IVirtualSystemDescription methods
305 HRESULT getDescription(std::vector<VirtualSystemDescriptionType_T> &aTypes,
306 std::vector<com::Utf8Str> &aRefs,
307 std::vector<com::Utf8Str> &aOVFValues,
308 std::vector<com::Utf8Str> &aVBoxValues,
309 std::vector<com::Utf8Str> &aExtraConfigValues);
310 HRESULT getDescriptionByType(VirtualSystemDescriptionType_T aType,
311 std::vector<VirtualSystemDescriptionType_T> &aTypes,
312 std::vector<com::Utf8Str> &aRefs,
313 std::vector<com::Utf8Str> &aOVFValues,
314 std::vector<com::Utf8Str> &aVBoxValues,
315 std::vector<com::Utf8Str> &aExtraConfigValues);
316 HRESULT getValuesByType(VirtualSystemDescriptionType_T aType,
317 VirtualSystemDescriptionValueType_T aWhich,
318 std::vector<com::Utf8Str> &aValues);
319 HRESULT setFinalValues(const std::vector<BOOL> &aEnabled,
320 const std::vector<com::Utf8Str> &aVBoxValues,
321 const std::vector<com::Utf8Str> &aExtraConfigValues);
322 HRESULT addDescription(VirtualSystemDescriptionType_T aType,
323 const com::Utf8Str &aVBoxValue,
324 const com::Utf8Str &aExtraConfigValue);
325 void i_removeByType(VirtualSystemDescriptionType_T aType);
326
327 struct Data;
328 Data *m;
329
330 friend class Machine;
331};
332
333#endif // !____H_APPLIANCEIMPL
334/* vi: set tabstop=4 shiftwidth=4 expandtab: */
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