VirtualBox

source: vbox/trunk/src/VBox/Main/include/ApplianceImplPrivate.h@ 61003

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

Main/Appliance: get rid of "Controller" in storage controller names (following the convention established in 4.x) for importing true OVF appliances, and clean up settings.h including, as it limits recompilation
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 15.2 KB
Line 
1/* $Id: ApplianceImplPrivate.h 61003 2016-05-17 13:41:19Z vboxsync $ */
2/** @file
3 * VirtualBox Appliance private data definitions
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_APPLIANCEIMPLPRIVATE
19#define ____H_APPLIANCEIMPLPRIVATE
20
21class VirtualSystemDescription;
22
23#include "ovfreader.h"
24#include "SecretKeyStore.h"
25#include "ThreadTask.h"
26#include "CertificateImpl.h"
27#include <map>
28#include <vector>
29#include <iprt/manifest.h>
30#include <iprt/vfs.h>
31#include <iprt/crypto/x509.h>
32
33////////////////////////////////////////////////////////////////////////////////
34//
35// Appliance data definition
36//
37////////////////////////////////////////////////////////////////////////////////
38
39namespace settings
40{
41 struct AttachedDevice;
42}
43
44typedef std::pair<Utf8Str, Utf8Str> STRPAIR;
45
46typedef std::vector<com::Guid> GUIDVEC;
47
48/* Describe a location for the import/export. The location could be a file on a
49 * local hard disk or a remote target based on the supported inet protocols. */
50struct LocationInfo
51{
52 LocationInfo()
53 : storageType(VFSType_File) {}
54 VFSType_T storageType; /* Which type of storage should be handled */
55 Utf8Str strPath; /* File path for the import/export */
56 Utf8Str strHostname; /* Hostname on remote storage locations (could be empty) */
57 Utf8Str strUsername; /* Username on remote storage locations (could be empty) */
58 Utf8Str strPassword; /* Password on remote storage locations (could be empty) */
59};
60
61// opaque private instance data of Appliance class
62struct Appliance::Data
63{
64 enum ApplianceState { ApplianceIdle, ApplianceImporting, ApplianceExporting };
65 enum digest_T {SHA1, SHA256};
66
67 Data()
68 : state(ApplianceIdle)
69 , fDigestTypes(0)
70 , hOurManifest(NIL_RTMANIFEST)
71 , fManifest(true)
72 , fSha256(false)
73 , fDeterminedDigestTypes(false)
74 , hTheirManifest(NIL_RTMANIFEST)
75 , hMemFileTheirManifest(NIL_RTVFSFILE)
76 , fSignerCertLoaded(false)
77 , fCertificateIsSelfSigned(false)
78 , fSignatureValid(false)
79 , fCertificateValid(false)
80 , fCertificateMissingPath(true)
81 , fCertificateValidTime(false)
82 , pbSignedDigest(NULL)
83 , cbSignedDigest(0)
84 , enmSignedDigestType(RTDIGESTTYPE_INVALID)
85 , fExportISOImages(false)
86 , pReader(NULL)
87 , ulWeightForXmlOperation(0)
88 , ulWeightForManifestOperation(0)
89 , ulTotalDisksMB(0)
90 , cDisks(0)
91 , m_cPwProvided(0)
92 {
93 }
94
95 ~Data()
96 {
97 if (pReader)
98 {
99 delete pReader;
100 pReader = NULL;
101 }
102 resetReadData();
103 }
104
105 /**
106 * Resets data used by read.
107 */
108 void resetReadData(void)
109 {
110 strOvfManifestEntry.setNull();
111 if (hOurManifest != NIL_RTMANIFEST)
112 {
113 RTManifestRelease(hOurManifest);
114 hOurManifest = NIL_RTMANIFEST;
115 }
116 if (hTheirManifest != NIL_RTMANIFEST)
117 {
118 RTManifestRelease(hTheirManifest);
119 hTheirManifest = NIL_RTMANIFEST;
120 }
121 if (hMemFileTheirManifest)
122 {
123 RTVfsFileRelease(hMemFileTheirManifest);
124 hMemFileTheirManifest = NIL_RTVFSFILE;
125 }
126 if (pbSignedDigest)
127 {
128 RTMemFree(pbSignedDigest);
129 pbSignedDigest = NULL;
130 cbSignedDigest = 0;
131 }
132 if (fSignerCertLoaded)
133 {
134 RTCrX509Certificate_Delete(&SignerCert);
135 fSignerCertLoaded = false;
136 }
137 enmSignedDigestType = RTDIGESTTYPE_INVALID;
138 fCertificateIsSelfSigned = false;
139 fSignatureValid = false;
140 fCertificateValid = false;
141 fCertificateMissingPath = true;
142 fCertificateValidTime = false;
143 fDeterminedDigestTypes = false;
144 fDigestTypes = RTMANIFEST_ATTR_SHA1 | RTMANIFEST_ATTR_SHA256 | RTMANIFEST_ATTR_SHA512;
145 ptrCertificateInfo.setNull();
146 strCertError.setNull();
147 }
148
149 ApplianceState state;
150
151 LocationInfo locInfo; // location info for the currently processed OVF
152 /** The digests types to calculate (RTMANIFEST_ATTR_XXX) for the manifest.
153 * This will be a single value when exporting. Zero, one or two. */
154 uint32_t fDigestTypes;
155 /** Manifest created while importing or exporting. */
156 RTMANIFEST hOurManifest;
157
158 /** @name Write data
159 * @{ */
160 bool fManifest; // Create a manifest file on export
161 bool fSha256; // true = SHA256 (OVF 2.0), false = SHA1 (OVF 1.0)
162 /** @} */
163
164 /** @name Read data
165 * @{ */
166 /** The manifest entry name of the OVF-file. */
167 Utf8Str strOvfManifestEntry;
168
169 /** Set if we've parsed the manifest and determined the digest types. */
170 bool fDeterminedDigestTypes;
171
172 /** Manifest read in during read() and kept around for later verification. */
173 RTMANIFEST hTheirManifest;
174 /** Memorized copy of the manifest file for signature checking purposes. */
175 RTVFSFILE hMemFileTheirManifest;
176
177 /** The signer certificate from the signature file (.cert).
178 * This will be used in the future provide information about the signer via
179 * the API. */
180 RTCRX509CERTIFICATE SignerCert;
181 /** Set if the SignerCert member contains usable data. */
182 bool fSignerCertLoaded;
183 /** Cached RTCrX509Validity_IsValidAtTimeSpec result set by read(). */
184 bool fCertificateIsSelfSigned;
185 /** Set by read() if pbSignedDigest verified correctly against SignerCert. */
186 bool fSignatureValid;
187 /** Set by read() when the SignerCert checked out fine. */
188 bool fCertificateValid;
189 /** Set by read() when the SignerCert certificate path couldn't be built. */
190 bool fCertificateMissingPath;
191 /** Set by read() when the SignerCert (+path) is valid in the temporal sense. */
192 bool fCertificateValidTime;
193 /** For keeping certificate error messages we delay from read() to import(). */
194 Utf8Str strCertError;
195 /** The signed digest of the manifest. */
196 uint8_t *pbSignedDigest;
197 /** The size of the signed digest. */
198 size_t cbSignedDigest;
199 /** The digest type used to sign the manifest. */
200 RTDIGESTTYPE enmSignedDigestType;
201 /** The certificate info object. This is NULL if no signature and
202 * successfully loaded certificate. */
203 ComObjPtr<Certificate> ptrCertificateInfo;
204 /** @} */
205
206 bool fExportISOImages;// when 1 the ISO images are exported
207
208 RTCList<ImportOptions_T> optListImport;
209 RTCList<ExportOptions_T> optListExport;
210
211 ovf::OVFReader *pReader;
212
213 std::list< ComObjPtr<VirtualSystemDescription> >
214 virtualSystemDescriptions;
215
216 std::list<Utf8Str> llWarnings;
217
218 ULONG ulWeightForXmlOperation;
219 ULONG ulWeightForManifestOperation;
220 ULONG ulTotalDisksMB;
221 ULONG cDisks;
222
223 std::list<Guid> llGuidsMachinesCreated;
224
225 /** Sequence of password identifiers to encrypt disk images during export. */
226 std::vector<com::Utf8Str> m_vecPasswordIdentifiers;
227 /** Map to get all medium identifiers assoicated with a given password identifier. */
228 std::map<com::Utf8Str, GUIDVEC> m_mapPwIdToMediumIds;
229 /** Secret key store used to hold the passwords during export. */
230 SecretKeyStore *m_pSecretKeyStore;
231 /** Number of passwords provided. */
232 uint32_t m_cPwProvided;
233};
234
235struct Appliance::XMLStack
236{
237 std::map<Utf8Str, const VirtualSystemDescriptionEntry*> mapDisks;
238 std::map<Utf8Str, bool> mapNetworks;
239};
240
241class Appliance::TaskOVF: public ThreadTask
242{
243public:
244 enum TaskType
245 {
246 Read,
247 Import,
248 Write
249 };
250
251 TaskOVF(Appliance *aThat,
252 TaskType aType,
253 LocationInfo aLocInfo,
254 ComObjPtr<Progress> &aProgress)
255 : ThreadTask("TaskOVF"),
256 pAppliance(aThat),
257 taskType(aType),
258 locInfo(aLocInfo),
259 pProgress(aProgress),
260 enFormat(ovf::OVFVersion_unknown),
261 rc(S_OK)
262 {
263 switch (taskType)
264 {
265 case TaskOVF::Read: m_strTaskName = "ApplRead"; break;
266 case TaskOVF::Import: m_strTaskName = "ApplImp"; break;
267 case TaskOVF::Write: m_strTaskName = "ApplWrit"; break;
268 default: m_strTaskName = "ApplTask"; break;
269 }
270 }
271
272 static DECLCALLBACK(int) updateProgress(unsigned uPercent, void *pvUser);
273
274 Appliance *pAppliance;
275 TaskType taskType;
276 const LocationInfo locInfo;
277 ComObjPtr<Progress> pProgress;
278
279 ovf::OVFVersion_T enFormat;
280
281 HRESULT rc;
282
283 void handler()
284 {
285 int vrc = Appliance::i_taskThreadImportOrExport(NULL, this); NOREF(vrc);
286 }
287};
288
289struct MyHardDiskAttachment
290{
291 ComPtr<IMachine> pMachine;
292 Utf8Str controllerName;
293 int32_t lControllerPort; // 0-29 for SATA
294 int32_t lDevice; // IDE: 0 or 1, otherwise 0 always
295};
296
297/**
298 * Used by Appliance::importMachineGeneric() to store
299 * input parameters and rollback information.
300 */
301struct Appliance::ImportStack
302{
303 // input pointers
304 const LocationInfo &locInfo; // ptr to location info from Appliance::importFS()
305 Utf8Str strSourceDir; // directory where source files reside
306 const ovf::DiskImagesMap &mapDisks; // ptr to disks map in OVF
307 ComObjPtr<Progress> &pProgress; // progress object passed into Appliance::importFS()
308
309 // input parameters from VirtualSystemDescriptions
310 Utf8Str strNameVBox; // VM name
311 Utf8Str strMachineFolder; // FQ host folder where the VirtualBox machine would be created
312 Utf8Str strOsTypeVBox; // VirtualBox guest OS type as string
313 Utf8Str strDescription;
314 uint32_t cCPUs; // CPU count
315 bool fForceHWVirt; // if true, we force enabling hardware virtualization
316 bool fForceIOAPIC; // if true, we force enabling the IOAPIC
317 uint32_t ulMemorySizeMB; // virtual machine RAM in megabytes
318#ifdef VBOX_WITH_USB
319 bool fUSBEnabled;
320#endif
321 Utf8Str strAudioAdapter; // if not empty, then the guest has audio enabled, and this is the decimal
322 // representation of the audio adapter (should always be "0" for AC97 presently)
323
324 // session (not initially created)
325 ComPtr<ISession> pSession; // session opened in Appliance::importFS() for machine manipulation
326 bool fSessionOpen; // true if the pSession is currently open and needs closing
327
328 /** @name File access related stuff (TAR stream)
329 * @{ */
330 /** OVA file system stream handle. NIL if not OVA. */
331 RTVFSFSSTREAM hVfsFssOva;
332 /** OVA lookahead I/O stream object. */
333 RTVFSIOSTREAM hVfsIosOvaLookAhead;
334 /** OVA lookahead I/O stream object name. */
335 char *pszOvaLookAheadName;
336 /** @} */
337
338 // a list of images that we created/imported; this is initially empty
339 // and will be cleaned up on errors
340 std::list<MyHardDiskAttachment> llHardDiskAttachments; // disks that were attached
341 std::map<Utf8Str , Utf8Str> mapNewUUIDsToOriginalUUIDs;
342
343 ImportStack(const LocationInfo &aLocInfo,
344 const ovf::DiskImagesMap &aMapDisks,
345 ComObjPtr<Progress> &aProgress,
346 RTVFSFSSTREAM aVfsFssOva)
347 : locInfo(aLocInfo),
348 mapDisks(aMapDisks),
349 pProgress(aProgress),
350 cCPUs(1),
351 fForceHWVirt(false),
352 fForceIOAPIC(false),
353 ulMemorySizeMB(0),
354 fSessionOpen(false),
355 hVfsFssOva(aVfsFssOva),
356 hVfsIosOvaLookAhead(NIL_RTVFSIOSTREAM),
357 pszOvaLookAheadName(NULL)
358 {
359 if (hVfsFssOva != NIL_RTVFSFSSTREAM)
360 RTVfsFsStrmRetain(hVfsFssOva);
361
362 // disk images have to be on the same place as the OVF file. So
363 // strip the filename out of the full file path
364 strSourceDir = aLocInfo.strPath;
365 strSourceDir.stripFilename();
366 }
367
368 ~ImportStack()
369 {
370 if (hVfsFssOva != NIL_RTVFSFSSTREAM)
371 {
372 RTVfsFsStrmRelease(hVfsFssOva);
373 hVfsFssOva = NIL_RTVFSFSSTREAM;
374 }
375 if (hVfsIosOvaLookAhead != NIL_RTVFSIOSTREAM)
376 {
377 RTVfsIoStrmRelease(hVfsIosOvaLookAhead);
378 hVfsIosOvaLookAhead = NIL_RTVFSIOSTREAM;
379 }
380 if (pszOvaLookAheadName)
381 {
382 RTStrFree(pszOvaLookAheadName);
383 pszOvaLookAheadName = NULL;
384 }
385 }
386
387 HRESULT restoreOriginalUUIDOfAttachedDevice(settings::MachineConfigFile *config);
388 HRESULT saveOriginalUUIDOfAttachedDevice(settings::AttachedDevice &device,
389 const Utf8Str &newlyUuid);
390 RTVFSIOSTREAM claimOvaLookAHead(void);
391
392};
393
394////////////////////////////////////////////////////////////////////////////////
395//
396// VirtualSystemDescription data definition
397//
398////////////////////////////////////////////////////////////////////////////////
399
400struct VirtualSystemDescription::Data
401{
402 std::vector<VirtualSystemDescriptionEntry>
403 maDescriptions; // item descriptions
404
405 ComPtr<Machine> pMachine; // VirtualBox machine this description was exported from (export only)
406
407 settings::MachineConfigFile
408 *pConfig; // machine config created from <vbox:Machine> element if found (import only)
409};
410
411////////////////////////////////////////////////////////////////////////////////
412//
413// Internal helpers
414//
415////////////////////////////////////////////////////////////////////////////////
416
417void convertCIMOSType2VBoxOSType(Utf8Str &strType, ovf::CIMOSType_T c, const Utf8Str &cStr);
418
419ovf::CIMOSType_T convertVBoxOSType2CIMOSType(const char *pcszVBox, BOOL fLongMode);
420
421Utf8Str convertNetworkAttachmentTypeToString(NetworkAttachmentType_T type);
422
423
424typedef struct SHASTORAGE
425{
426 PVDINTERFACE pVDImageIfaces;
427 bool fCreateDigest;
428 bool fSha256; /* false = SHA1 (OVF 1.x), true = SHA256 (OVF 2.0) */
429 Utf8Str strDigest;
430} SHASTORAGE, *PSHASTORAGE;
431
432PVDINTERFACEIO ShaCreateInterface();
433PVDINTERFACEIO FileCreateInterface();
434PVDINTERFACEIO tarWriterCreateInterface(void);
435
436int writeBufferToFile(const char *pcszFilename, void *pvBuf, size_t cbSize, PVDINTERFACEIO pIfIo, void *pvUser);
437
438#endif // !____H_APPLIANCEIMPLPRIVATE
439
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