ovfreader.h@ 94368

Last change on this file since 94368 was 93115, checked in by vboxsync, 3 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
30	namespace 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	*/
44	class OVFLogicError : public xml::LogicError
45	{
46	public:
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	*/
68	enum 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
196	enum OVFVersion_T
197	{
198	OVFVersion_unknown,
199	OVFVersion_0_9,
200	OVFVersion_1_0,
201	OVFVersion_2_0
202	};
203
204	const char* const OVF09_URI_string = "http://www.vmware.com/schema/ovf/1/envelope";
205	const char* const OVF10_URI_string = "http://schemas.dmtf.org/ovf/envelope/1";
206	const char* const OVF20_URI_string = "http://schemas.dmtf.org/ovf/envelope/2";
207
208	const char* const DTMF_SPECS_URI = "http://schemas.dmtf.org/wbem/cim-html/2/";
209
210	////////////////////////////////////////////////////////////////////////////////
211	//
212	// Envelope data
213	//
214	////////////////////////////////////////////////////////////////////////////////
215	struct 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
245	struct FileReference
246	{
247	RTCString strHref; // value from /References/File/@href (filename)
248	RTCString strDiskId; // value from /References/File/@id ()
249	};
250
251	typedef std::map<uint32_t, FileReference> FileReferenceMap;
252
253	////////////////////////////////////////////////////////////////////////////////
254	//
255	// Hardware definition structs
256	//
257	////////////////////////////////////////////////////////////////////////////////
258
259	struct 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
284	enum 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
323	enum StorageAccessType_T
324	{ StorageAccessType_Unknown = 0,
325	StorageAccessType_Readable = 1,
326	StorageAccessType_Writeable = 2,
327	StorageAccessType_ReadWrite = 3
328	};
329
330	enum ComplianceType_T
331	{ ComplianceType_No = 0,
332	ComplianceType_Soft = 1,
333	ComplianceType_Medium = 2,
334	ComplianceType_Strong = 3
335	};
336
337	class VirtualHardwareItem
338	{
339	public:
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
411	protected:
412	virtual void _checkConsistencyAndCompliance() RT_THROW(OVFLogicError);
413	virtual const RTCString& getItemName()
414	{
415	return _getItemName();
416	}
417
418	private:
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
428	class 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
447	public:
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
467	protected:
468	virtual void _checkConsistencyAndCompliance() RT_THROW(OVFLogicError);
469	private:
470	RTCString itemName;
471
472	virtual const RTCString& _getItemName()
473	{
474	return itemName;
475	}
476	};
477
478
479	class 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
509	public:
510	EthernetPortItem() : VirtualHardwareItem()
511	{
512	itemName = "EthernetPortItem";
513	};
514
515	void fillItem(const xml::ElementNode *item);
516
517	protected:
518	virtual void _checkConsistencyAndCompliance() RT_THROW(OVFLogicError);
519	private:
520	RTCString itemName;
521
522	virtual const RTCString& _getItemName()
523	{
524	return itemName;
525	}
526	};
527
528	typedef std::map<RTCString, DiskImage> DiskImagesMap;
529
530	struct 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	*/
539	class HardwareItemVector : public std::vector<VirtualHardwareItem *>
540	{
541	public:
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. */
551	private:
552	HardwareItemVector(const VirtualSystem &);
553
554	};
555
556	struct 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
579	typedef std::map<RTCString, HardDiskController> ControllersMap;
580
581	struct 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
594	typedef 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	*/
600	struct EthernetAdapter
601	{
602	RTCString strAdapterType; // "PCNet32" or "E1000" or whatever; from <rasd:ResourceSubType>
603	RTCString strNetworkName; // from <rasd:Connection>
604	};
605
606	typedef 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	*/
612	struct 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	*/
696	class OVFReader
697	{
698	public:
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
709	private:
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.

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

Download in other formats: