VirtualBox

source: vbox/trunk/src/VBox/Main/include/ovfreader.h@ 94521

Last change on this file since 94521 was 93115, checked in by vboxsync, 2 years ago

scm --update-copyright-year
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 25.9 KB
Line 
1/* $Id: ovfreader.h 93115 2022-01-01 11:31:46Z vboxsync $ */
2/** @file
3 * VirtualBox Main - OVF reader declarations.
4 *
5 * Depends only on IPRT, including the RTCString and IPRT XML classes.
6 */
7
8/*
9 * Copyright (C) 2008-2022 Oracle Corporation
10 *
11 * This file is part of VirtualBox Open Source Edition (OSE), as
12 * available from http://www.virtualbox.org. This file is free software;
13 * you can redistribute it and/or modify it under the terms of the GNU
14 * General Public License (GPL) as published by the Free Software
15 * Foundation, in version 2 as it comes in the "COPYING" file of the
16 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
17 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
18 */
19
20#ifndef MAIN_INCLUDED_ovfreader_h
21#define MAIN_INCLUDED_ovfreader_h
22#ifndef RT_WITHOUT_PRAGMA_ONCE
23# pragma once
24#endif
25
26#include "iprt/cpp/xml.h"
27#include <map>
28#include <vector>
29
30namespace ovf
31{
32
33////////////////////////////////////////////////////////////////////////////////
34//
35// Errors
36//
37////////////////////////////////////////////////////////////////////////////////
38
39/**
40 * Thrown by OVFReader for any kind of error that is not an XML error but
41 * still makes the OVF impossible to parse. Based on xml::LogicError so
42 * that one catch() for all xml::LogicError can handle all possible errors.
43 */
44class OVFLogicError : public xml::LogicError
45{
46public:
47 OVFLogicError(const char *aFormat, ...);
48};
49
50
51////////////////////////////////////////////////////////////////////////////////
52//
53// Enumerations
54//
55////////////////////////////////////////////////////////////////////////////////
56
57/**
58 * CIM OS values.
59 *
60 * The OVF 1.10 spec refers to some CIM_OperatingSystem.mof doc. Could this be it:
61 * http://cvs.opengroup.org/cgi-bin/cvsweb.cgi/pegasus/Schemas/CIM231/DMTF/System/CIM_OperatingSystem.mof
62 *
63 * @todo r=bird: Why are the values are repeating 'CIMOS'. CIMOSType_T is also
64 * repeating it self, 'Type' and '_T'. Why not call it kCIOMOpSys,
65 * easier to read as well.
66 * Then also apply: s/CIMOSType_CIMOS_/kCIMOpSys_/g
67 */
68enum CIMOSType_T
69{
70 CIMOSType_CIMOS_Unknown = 0,
71 CIMOSType_CIMOS_Other = 1,
72 CIMOSType_CIMOS_MACOS = 2,
73 CIMOSType_CIMOS_ATTUNIX = 3,
74 CIMOSType_CIMOS_DGUX = 4,
75 CIMOSType_CIMOS_DECNT = 5,
76 CIMOSType_CIMOS_Tru64UNIX = 6,
77 CIMOSType_CIMOS_OpenVMS = 7,
78 CIMOSType_CIMOS_HPUX = 8,
79 CIMOSType_CIMOS_AIX = 9,
80 CIMOSType_CIMOS_MVS = 10,
81 CIMOSType_CIMOS_OS400 = 11,
82 CIMOSType_CIMOS_OS2 = 12,
83 CIMOSType_CIMOS_JavaVM = 13,
84 CIMOSType_CIMOS_MSDOS = 14,
85 CIMOSType_CIMOS_WIN3x = 15,
86 CIMOSType_CIMOS_WIN95 = 16,
87 CIMOSType_CIMOS_WIN98 = 17,
88 CIMOSType_CIMOS_WINNT = 18,
89 CIMOSType_CIMOS_WINCE = 19,
90 CIMOSType_CIMOS_NCR3000 = 20,
91 CIMOSType_CIMOS_NetWare = 21,
92 CIMOSType_CIMOS_OSF = 22,
93 CIMOSType_CIMOS_DCOS = 23,
94 CIMOSType_CIMOS_ReliantUNIX = 24,
95 CIMOSType_CIMOS_SCOUnixWare = 25,
96 CIMOSType_CIMOS_SCOOpenServer = 26,
97 CIMOSType_CIMOS_Sequent = 27,
98 CIMOSType_CIMOS_IRIX = 28,
99 CIMOSType_CIMOS_Solaris = 29,
100 CIMOSType_CIMOS_SunOS = 30,
101 CIMOSType_CIMOS_U6000 = 31,
102 CIMOSType_CIMOS_ASERIES = 32,
103 CIMOSType_CIMOS_HPNonStopOS = 33,
104 CIMOSType_CIMOS_HPNonStopOSS = 34,
105 CIMOSType_CIMOS_BS2000 = 35,
106 CIMOSType_CIMOS_LINUX = 36,
107 CIMOSType_CIMOS_Lynx = 37,
108 CIMOSType_CIMOS_XENIX = 38,
109 CIMOSType_CIMOS_VM = 39,
110 CIMOSType_CIMOS_InteractiveUNIX = 40,
111 CIMOSType_CIMOS_BSDUNIX = 41,
112 CIMOSType_CIMOS_FreeBSD = 42,
113 CIMOSType_CIMOS_NetBSD = 43,
114 CIMOSType_CIMOS_GNUHurd = 44,
115 CIMOSType_CIMOS_OS9 = 45,
116 CIMOSType_CIMOS_MACHKernel = 46,
117 CIMOSType_CIMOS_Inferno = 47,
118 CIMOSType_CIMOS_QNX = 48,
119 CIMOSType_CIMOS_EPOC = 49,
120 CIMOSType_CIMOS_IxWorks = 50,
121 CIMOSType_CIMOS_VxWorks = 51,
122 CIMOSType_CIMOS_MiNT = 52,
123 CIMOSType_CIMOS_BeOS = 53,
124 CIMOSType_CIMOS_HPMPE = 54,
125 CIMOSType_CIMOS_NextStep = 55,
126 CIMOSType_CIMOS_PalmPilot = 56,
127 CIMOSType_CIMOS_Rhapsody = 57,
128 CIMOSType_CIMOS_Windows2000 = 58,
129 CIMOSType_CIMOS_Dedicated = 59,
130 CIMOSType_CIMOS_OS390 = 60,
131 CIMOSType_CIMOS_VSE = 61,
132 CIMOSType_CIMOS_TPF = 62,
133 CIMOSType_CIMOS_WindowsMe = 63,
134 CIMOSType_CIMOS_CalderaOpenUNIX = 64,
135 CIMOSType_CIMOS_OpenBSD = 65,
136 CIMOSType_CIMOS_NotApplicable = 66,
137 CIMOSType_CIMOS_WindowsXP = 67,
138 CIMOSType_CIMOS_zOS = 68,
139 CIMOSType_CIMOS_MicrosoftWindowsServer2003 = 69,
140 CIMOSType_CIMOS_MicrosoftWindowsServer2003_64 = 70,
141 CIMOSType_CIMOS_WindowsXP_64 = 71,
142 CIMOSType_CIMOS_WindowsXPEmbedded = 72,
143 CIMOSType_CIMOS_WindowsVista = 73,
144 CIMOSType_CIMOS_WindowsVista_64 = 74,
145 CIMOSType_CIMOS_WindowsEmbeddedforPointofService = 75,
146 CIMOSType_CIMOS_MicrosoftWindowsServer2008 = 76,
147 CIMOSType_CIMOS_MicrosoftWindowsServer2008_64 = 77,
148 CIMOSType_CIMOS_FreeBSD_64 = 78,
149 CIMOSType_CIMOS_RedHatEnterpriseLinux = 79,
150 CIMOSType_CIMOS_RedHatEnterpriseLinux_64 = 80,
151 CIMOSType_CIMOS_Solaris_64 = 81,
152 CIMOSType_CIMOS_SUSE = 82,
153 CIMOSType_CIMOS_SUSE_64 = 83,
154 CIMOSType_CIMOS_SLES = 84,
155 CIMOSType_CIMOS_SLES_64 = 85,
156 CIMOSType_CIMOS_NovellOES = 86,
157 CIMOSType_CIMOS_NovellLinuxDesktop = 87,
158 CIMOSType_CIMOS_SunJavaDesktopSystem = 88,
159 CIMOSType_CIMOS_Mandriva = 89,
160 CIMOSType_CIMOS_Mandriva_64 = 90,
161 CIMOSType_CIMOS_TurboLinux = 91,
162 CIMOSType_CIMOS_TurboLinux_64 = 92,
163 CIMOSType_CIMOS_Ubuntu = 93,
164 CIMOSType_CIMOS_Ubuntu_64 = 94,
165 CIMOSType_CIMOS_Debian = 95,
166 CIMOSType_CIMOS_Debian_64 = 96,
167 CIMOSType_CIMOS_Linux_2_4_x = 97,
168 CIMOSType_CIMOS_Linux_2_4_x_64 = 98,
169 CIMOSType_CIMOS_Linux_2_6_x = 99,
170 CIMOSType_CIMOS_Linux_2_6_x_64 = 100,
171 CIMOSType_CIMOS_Linux_64 = 101,
172 CIMOSType_CIMOS_Other_64 = 102,
173 // types added with CIM 2.25.0 follow:
174 CIMOSType_CIMOS_WindowsServer2008R2 = 103,
175 CIMOSType_CIMOS_VMwareESXi = 104,
176 CIMOSType_CIMOS_Windows7 = 105,
177 CIMOSType_CIMOS_CentOS = 106,
178 CIMOSType_CIMOS_CentOS_64 = 107,
179 CIMOSType_CIMOS_OracleLinux = 108,
180 CIMOSType_CIMOS_OracleLinux_64 = 109,
181 CIMOSType_CIMOS_eComStation = 110,
182 // no new types added with CIM 2.26.0
183 CIMOSType_CIMOS_WindowsServer2011 = 111,
184 CIMOSType_CIMOS_WindowsServer2012 = 112,
185 CIMOSType_CIMOS_Windows8 = 113,
186 CIMOSType_CIMOS_Windows8_64 = 114,
187 CIMOSType_CIMOS_WindowsServer2012R2 = 115,
188 CIMOSType_CIMOS_Windows8_1 = 116,
189 CIMOSType_CIMOS_Windows8_1_64 = 117,
190 CIMOSType_CIMOS_WindowsServer2016 = 118,
191 CIMOSType_CIMOS_Windows10 = 119,
192 CIMOSType_CIMOS_Windows10_64 = 120,
193 // the above covers up to CIM 2.52.0, without checking when it was added
194};
195
196enum OVFVersion_T
197{
198 OVFVersion_unknown,
199 OVFVersion_0_9,
200 OVFVersion_1_0,
201 OVFVersion_2_0
202};
203
204const char* const OVF09_URI_string = "http://www.vmware.com/schema/ovf/1/envelope";
205const char* const OVF10_URI_string = "http://schemas.dmtf.org/ovf/envelope/1";
206const char* const OVF20_URI_string = "http://schemas.dmtf.org/ovf/envelope/2";
207
208const char* const DTMF_SPECS_URI = "http://schemas.dmtf.org/wbem/cim-html/2/";
209
210////////////////////////////////////////////////////////////////////////////////
211//
212// Envelope data
213//
214////////////////////////////////////////////////////////////////////////////////
215struct EnvelopeData
216{
217 OVFVersion_T version;//OVF standard version, it is used internally only by VirtualBox
218 RTCString lang;//language
219
220 OVFVersion_T getOVFVersion() const
221 {
222 return version;
223 }
224
225
226 RTCString getStringOVFVersion() const
227 {
228 if (version == OVFVersion_0_9)
229 return "0.9";
230 else if (version == OVFVersion_1_0)
231 return "1.0";
232 else if (version == OVFVersion_2_0)
233 return "2.0";
234 else
235 return "";
236 }
237
238 void setOVFVersion(OVFVersion_T v)
239 {
240 version = v;
241 }
242};
243
244
245struct FileReference
246{
247 RTCString strHref; // value from /References/File/@href (filename)
248 RTCString strDiskId; // value from /References/File/@id ()
249};
250
251typedef std::map<uint32_t, FileReference> FileReferenceMap;
252
253////////////////////////////////////////////////////////////////////////////////
254//
255// Hardware definition structs
256//
257////////////////////////////////////////////////////////////////////////////////
258
259struct DiskImage
260{
261 // fields from /DiskSection/Disk
262 RTCString strDiskId; // value from DiskSection/Disk/@diskId
263 int64_t iCapacity; // value from DiskSection/Disk/@capacity;
264 // (maximum size for dynamic images, I guess; we always translate this to bytes)
265 int64_t iPopulatedSize; // optional value from DiskSection/Disk/@populatedSize
266 // (actual used size of disk, always in bytes; can be an estimate of used disk
267 // space, but cannot be larger than iCapacity; -1 if not set)
268 RTCString strFormat; // value from DiskSection/Disk/@format
269 // typically http://www.vmware.com/interfaces/specifications/vmdk.html#streamOptimized
270 RTCString uuidVBox; // optional; if the file was exported by VirtualBox >= 3.2,
271 // then this has the UUID with which the disk was registered
272
273 // fields from /References/File; the spec says the file reference from disk can be empty,
274 // so in that case, strFilename will be empty, then a new disk should be created
275 RTCString strHref; // value from /References/File/@href (filename); if empty, then the remaining fields are ignored
276 int64_t iSize; // value from /References/File/@size (optional according to spec; then we set -1 here)
277 int64_t iChunkSize; // value from /References/File/@chunkSize (optional, unsupported)
278 RTCString strCompression; // value from /References/File/@compression (optional, can be "gzip" according to spec)
279
280 // additional field which has a descriptive size in megabytes derived from the above; this can be used for progress reports
281 uint32_t ulSuggestedSizeMB;
282};
283
284enum ResourceType_T
285{
286 ResourceType_Other = 1,
287 ResourceType_ComputerSystem = 2,
288 ResourceType_Processor = 3,
289 ResourceType_Memory = 4,
290 ResourceType_IDEController = 5,
291 ResourceType_ParallelSCSIHBA = 6,
292 ResourceType_FCHBA = 7,
293 ResourceType_iSCSIHBA = 8,
294 ResourceType_IBHCA = 9,
295 ResourceType_EthernetAdapter = 10,
296 ResourceType_OtherNetworkAdapter = 11,
297 ResourceType_IOSlot = 12,
298 ResourceType_IODevice = 13,
299 ResourceType_FloppyDrive = 14,
300 ResourceType_CDDrive = 15,
301 ResourceType_DVDDrive = 16,
302 ResourceType_HardDisk = 17,
303 ResourceType_TapeDrive = 18,
304 ResourceType_StorageExtent = 19,
305 ResourceType_OtherStorageDevice = 20,
306 ResourceType_SerialPort = 21,
307 ResourceType_ParallelPort = 22,
308 ResourceType_USBController = 23,
309 ResourceType_GraphicsController = 24,
310 ResourceType_IEEE1394Controller = 25,
311 ResourceType_PartitionableUnit = 26,
312 ResourceType_BasePartitionableUnit = 27,
313 ResourceType_Power = 28,
314 ResourceType_CoolingCapacity = 29,
315 ResourceType_EthernetSwitchPort = 30,
316 ResourceType_LogicalDisk = 31,
317 ResourceType_StorageVolume = 32,
318 ResourceType_EthernetConnection = 33,
319 ResourceType_SoundCard = 35 /**< @todo r=klaus: Not part of OVF/CIM spec, should use "Other" or some value from 0x8000..0xffff. */
320};
321
322
323enum StorageAccessType_T
324{ StorageAccessType_Unknown = 0,
325 StorageAccessType_Readable = 1,
326 StorageAccessType_Writeable = 2,
327 StorageAccessType_ReadWrite = 3
328};
329
330enum ComplianceType_T
331{ ComplianceType_No = 0,
332 ComplianceType_Soft = 1,
333 ComplianceType_Medium = 2,
334 ComplianceType_Strong = 3
335};
336
337class VirtualHardwareItem
338{
339public:
340 RTCString strDescription;
341 RTCString strCaption;
342 RTCString strElementName;
343
344 RTCString strInstanceID;
345 RTCString strParent;
346
347 ResourceType_T resourceType;
348 RTCString strOtherResourceType;
349 RTCString strResourceSubType;
350 bool fResourceRequired;
351
352 RTCString strHostResource; ///< "Abstractly specifies how a device shall connect to a resource on the deployment platform.
353 /// Not all devices need a backing." Used with disk items, for which this
354 /// references a virtual disk from the Disks section.
355 bool fAutomaticAllocation;
356 bool fAutomaticDeallocation;
357 RTCString strConnection; ///< "All Ethernet adapters that specify the same abstract network connection name within an OVF
358 /// package shall be deployed on the same network. The abstract network connection name shall be
359 /// listed in the NetworkSection at the outermost envelope level." We ignore this and only set up
360 /// a network adapter depending on the network name.
361 RTCString strAddress; ///< "Device-specific. For an Ethernet adapter, this specifies the MAC address."
362 int32_t lAddress; ///< strAddress as an integer, if applicable.
363 RTCString strAddressOnParent;///< "For a device, this specifies its location on the controller."
364 RTCString strAllocationUnits;///< "Specifies the units of allocation used. For example, “byte * 2^20”."
365 uint64_t ullVirtualQuantity; ///< "Specifies the quantity of resources presented. For example, “256”."
366 uint64_t ullReservation; ///< "Specifies the minimum quantity of resources guaranteed to be available."
367 uint64_t ullLimit; ///< "Specifies the maximum quantity of resources that will be granted."
368 uint64_t ullWeight; ///< "Specifies a relative priority for this allocation in relation to other allocations."
369
370 RTCString strConsumerVisibility;
371 RTCString strMappingBehavior;
372 RTCString strPoolID;
373 uint32_t ulBusNumber; ///< seen with IDE controllers, but not listed in OVF spec
374
375 int m_iLineNumber; ///< line number of \<Item\> element in XML source; cached for error messages
376
377 VirtualHardwareItem()
378 : fResourceRequired(false)
379 , fAutomaticAllocation(false)
380 , fAutomaticDeallocation(false)
381 , ullVirtualQuantity(0)
382 , ullReservation(0)
383 , ullLimit(0)
384 , ullWeight(0)
385 , ulBusNumber(0)
386 , m_iLineNumber(0)
387 , fDefault(false)
388 {
389 itemName = "Item";
390 }
391
392 virtual ~VirtualHardwareItem() { /* Makes MSC happy. */ }
393
394 void fillItem(const xml::ElementNode *item);
395
396 void setDefaultFlag()
397 {
398 fDefault = true;
399 }
400
401 bool isThereDefaultValues() const
402 {
403 return fDefault;
404 }
405
406 void checkConsistencyAndCompliance() RT_THROW(OVFLogicError)
407 {
408 _checkConsistencyAndCompliance();
409 }
410
411protected:
412 virtual void _checkConsistencyAndCompliance() RT_THROW(OVFLogicError);
413 virtual const RTCString& getItemName()
414 {
415 return _getItemName();
416 }
417
418private:
419 RTCString itemName;
420 bool fDefault;//true means that some fields were absent in the XML and some default values were assigned to.
421
422 virtual const RTCString& _getItemName()
423 {
424 return itemName;
425 }
426};
427
428class StorageItem: public VirtualHardwareItem
429{
430 //see DMTF Schema Documentation http://schemas.dmtf.org/wbem/cim-html/2/
431 StorageAccessType_T accessType;
432 RTCString strHostExtentName;
433#if 0 /* unused */
434 int16_t hostExtentNameFormat;
435 int16_t hostExtentNameNamespace;
436 int64_t hostExtentStartingAddress;
437#endif
438 int64_t hostResourceBlockSize;
439 int64_t limit;
440 RTCString strOtherHostExtentNameFormat;
441 RTCString strOtherHostExtentNameNamespace;
442 int64_t reservation;
443 int64_t virtualQuantity;
444 RTCString strVirtualQuantityUnits;
445 int64_t virtualResourceBlockSize;
446
447public:
448 StorageItem()
449 : VirtualHardwareItem()
450 , accessType(StorageAccessType_Unknown)
451#if 0 /* unused */
452 , hostExtentNameFormat(-1)
453 , hostExtentNameNamespace(-1)
454 , hostExtentStartingAddress(-1)
455#endif
456 , hostResourceBlockSize(-1)
457 , limit(-1)
458 , reservation(-1)
459 , virtualQuantity(-1)
460 , virtualResourceBlockSize(-1)
461 {
462 itemName = "StorageItem";
463 };
464
465 void fillItem(const xml::ElementNode *item);
466
467protected:
468 virtual void _checkConsistencyAndCompliance() RT_THROW(OVFLogicError);
469private:
470 RTCString itemName;
471
472 virtual const RTCString& _getItemName()
473 {
474 return itemName;
475 }
476};
477
478
479class EthernetPortItem: public VirtualHardwareItem
480{
481 //see DMTF Schema Documentation http://schemas.dmtf.org/wbem/cim-html/2/
482#if 0 /* unused */
483 uint16_t DefaultPortVID;
484 uint16_t DefaultPriority;
485 uint16_t DesiredVLANEndpointMode;
486 uint32_t GroupID;
487 uint32_t ManagerID;
488 uint16_t NetworkPortProfileIDType;
489#endif
490 RTCString strNetworkPortProfileID;
491 RTCString strOtherEndpointMode;
492 RTCString strOtherNetworkPortProfileIDTypeInfo;
493 RTCString strPortCorrelationID;
494#if 0 /* unused */
495 uint16_t PortVID;
496 bool Promiscuous;
497 uint64_t ReceiveBandwidthLimit;
498 uint16_t ReceiveBandwidthReservation;
499 bool SourceMACFilteringEnabled;
500 uint32_t VSITypeID;
501 uint8_t VSITypeIDVersion;
502 uint16_t AllowedPriorities[256];
503 uint16_t AllowedToReceiveVLANs[256];
504 uint16_t AllowedToTransmitVLANs[256];
505#endif
506 RTCString strAllowedToReceiveMACAddresses;
507 RTCString strAllowedToTransmitMACAddresses;
508
509public:
510 EthernetPortItem() : VirtualHardwareItem()
511 {
512 itemName = "EthernetPortItem";
513 };
514
515 void fillItem(const xml::ElementNode *item);
516
517protected:
518 virtual void _checkConsistencyAndCompliance() RT_THROW(OVFLogicError);
519private:
520 RTCString itemName;
521
522 virtual const RTCString& _getItemName()
523 {
524 return itemName;
525 }
526};
527
528typedef std::map<RTCString, DiskImage> DiskImagesMap;
529
530struct VirtualSystem;
531
532
533/**
534 * VirtualHardwareItem pointer vector with safe cleanup.
535 *
536 * We need to use object pointers because we also want EthernetPortItem and
537 * StorageItems to go into the container.
538 */
539class HardwareItemVector : public std::vector<VirtualHardwareItem *>
540{
541public:
542 HardwareItemVector() : std::vector<VirtualHardwareItem *>() { }
543 ~HardwareItemVector()
544 {
545 for (iterator it = begin(); it != end(); ++it)
546 delete(*it);
547 clear();
548 }
549
550 /* There is no copying of this vector. We'd need something like shared_ptr for that. */
551private:
552 HardwareItemVector(const VirtualSystem &);
553
554};
555
556struct HardDiskController
557{
558 RTCString strIdController; // instance ID (Item/InstanceId); this gets referenced from VirtualDisk
559
560 enum ControllerSystemType { IDE, SATA, SCSI, VIRTIOSCSI };
561 ControllerSystemType system; // one of IDE, SATA, SCSI, VIRTIOSCSI
562
563 RTCString strControllerType;
564 // controller subtype (Item/ResourceSubType); e.g. "LsiLogic"; can be empty (esp. for IDE)
565 // note that we treat LsiLogicSAS as a SCSI controller (system == SCSI) even though VirtualBox
566 // treats it as a fourth class besides IDE, SATA, SCSI
567
568 int32_t lAddress; // value from OVF "Address" element
569 bool fPrimary; // controller index; this is determined heuristically by the OVF reader and will
570 // be true for the first controller of this type (e.g. IDE primary ctler) or
571 // false for the next (e.g. IDE secondary ctler)
572
573 HardDiskController()
574 : lAddress(0),
575 fPrimary(true)
576 { }
577};
578
579typedef std::map<RTCString, HardDiskController> ControllersMap;
580
581struct VirtualDisk
582{
583 RTCString strIdController; // SCSI (or IDE) controller this disk is connected to;
584 // this must match HardDiskController.strIdController and
585 // points into VirtualSystem.mapControllers
586 uint32_t ulAddressOnParent; // parsed strAddressOnParent of hardware item; will be 0 or 1 for IDE
587 // and possibly higher for disks attached to SCSI controllers (untested)
588 RTCString strDiskId; // if the hard disk has an ovf:/disk/<id> reference,
589 // this receives the <id> component; points to one of the
590 // references in Appliance::Data.mapDisks
591 bool fEmpty; //true - empty disk, e.g. the component <rasd:HostResource>...</rasd:HostResource> is absent.
592};
593
594typedef std::map<RTCString, VirtualDisk> VirtualDisksMap;
595
596/**
597 * A list of EthernetAdapters is contained in VirtualSystem, representing the
598 * ethernet adapters in the virtual system.
599 */
600struct EthernetAdapter
601{
602 RTCString strAdapterType; // "PCNet32" or "E1000" or whatever; from <rasd:ResourceSubType>
603 RTCString strNetworkName; // from <rasd:Connection>
604};
605
606typedef std::list<EthernetAdapter> EthernetAdaptersList;
607
608/**
609 * A list of VirtualSystem structs is created by OVFReader::read(). Each refers to
610 * a \<VirtualSystem\> block in the OVF file.
611 */
612struct VirtualSystem
613{
614 RTCString strName; // copy of VirtualSystem/@id
615
616 RTCString strDescription; // copy of VirtualSystem/AnnotationSection content, if any
617
618 CIMOSType_T cimos;
619 RTCString strCimosDesc; // readable description of the cimos type in the case of cimos = 0/1/102
620 RTCString strTypeVBox; // optional type from @vbox:ostype attribute (VirtualBox 4.0 or higher)
621
622 RTCString strVirtualSystemType; // generic hardware description; OVF says this can be something like "vmx-4" or "xen";
623 // VMware Workstation 6.5 is "vmx-07"
624
625 HardwareItemVector vecHardwareItems; //< vector containing all virtual hardware items in parsing order.
626
627 uint64_t ullMemorySize; // always in bytes, copied from llHardwareItems; default = 0 (unspecified)
628 uint16_t cCPUs; // no. of CPUs, copied from llHardwareItems; default = 1
629
630 EthernetAdaptersList llEthernetAdapters; // (one for each VirtualSystem/Item[@ResourceType=10]element)
631
632 ControllersMap mapControllers;
633 // list of hard disk controllers
634 // (one for each VirtualSystem/Item[@ResourceType=6] element with accumulated data from children)
635
636 VirtualDisksMap mapVirtualDisks;
637 // (one for each VirtualSystem/Item[@ResourceType=17] element with accumulated data from children)
638
639 bool fHasFloppyDrive; // true if there's a floppy item in mapHardwareItems
640 bool fHasCdromDrive; // true if there's a CD-ROM item in mapHardwareItems; ISO images are not yet supported by OVFtool
641 bool fHasUsbController; // true if there's a USB controller item in mapHardwareItems
642
643 RTCString strSoundCardType; // if not empty, then the system wants a soundcard; this then specifies the hardware;
644 // VMware Workstation 6.5 uses "ensoniq1371" for example
645
646 RTCString strLicenseText; // license info if any; receives contents of VirtualSystem/EulaSection/License
647
648 RTCString strProduct; // product info if any; receives contents of VirtualSystem/ProductSection/Product
649 RTCString strVendor; // product info if any; receives contents of VirtualSystem/ProductSection/Vendor
650 RTCString strVersion; // product info if any; receives contents of VirtualSystem/ProductSection/Version
651 RTCString strProductUrl; // product info if any; receives contents of VirtualSystem/ProductSection/ProductUrl
652 RTCString strVendorUrl; // product info if any; receives contents of VirtualSystem/ProductSection/VendorUrl
653
654 const xml::ElementNode *pelmVBoxMachine; // pointer to <vbox:Machine> element under <VirtualSystem> element or NULL if not present
655
656 VirtualSystem()
657 : cimos(CIMOSType_CIMOS_Unknown),
658 ullMemorySize(0),
659 cCPUs(1),
660 fHasFloppyDrive(false),
661 fHasCdromDrive(false),
662 fHasUsbController(false),
663 pelmVBoxMachine(NULL)
664 {
665 }
666};
667
668////////////////////////////////////////////////////////////////////////////////
669//
670// Class OVFReader
671//
672////////////////////////////////////////////////////////////////////////////////
673
674/**
675 * OVFReader attempts to open, read in and parse an OVF XML file. This is all done
676 * in the constructor; if there is any kind of error in the file -- filesystem error
677 * from IPRT, XML parsing errors from libxml, or OVF logical errors --, exceptions
678 * are thrown. These are all based on xml::Error.
679 *
680 * Hence, use this class as follows:
681<code>
682 OVFReader *pReader = NULL;
683 try
684 {
685 pReader = new("/path/to/file.ovf");
686 }
687 catch (xml::Error &e)
688 {
689 printf("A terrible thing happened: %s", e.what());
690 }
691 // now go look at pReader->m_llVirtualSystem and what's in there
692 if (pReader)
693 delete pReader;
694</code>
695 */
696class OVFReader
697{
698public:
699 OVFReader();
700 OVFReader(const void *pvBuf, size_t cbSize, const RTCString &path);
701 OVFReader(const RTCString &path);
702
703 // Data fields
704 EnvelopeData m_envelopeData; //data of root element "Envelope"
705 RTCString m_strPath; // file name given to constructor
706 DiskImagesMap m_mapDisks; // map of DiskImage structs, sorted by DiskImage.strDiskId
707 std::list<VirtualSystem> m_llVirtualSystems; // list of virtual systems, created by and valid after read()
708
709private:
710 xml::Document m_doc;
711
712 void parse();
713 void LoopThruSections(const xml::ElementNode *pReferencesElem, const xml::ElementNode *pCurElem);
714 void HandleDiskSection(const xml::ElementNode *pReferencesElem, const xml::ElementNode *pSectionElem);
715 void HandleNetworkSection(const xml::ElementNode *pSectionElem);
716 void HandleVirtualSystemContent(const xml::ElementNode *pContentElem);
717};
718
719} // end namespace ovf
720
721#endif /* !MAIN_INCLUDED_ovfreader_h */
722
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use