ovfreader.cpp@ 28032

Last change on this file since 28032 was 27918, checked in by vboxsync, 15 years ago
Main/OVF: import vbox:Machine XML within OVF, first batch (XML is parsed and machine config created, but COM Machine can't handle it yet)
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 34.7 KB

Line
1	/* $Id: ovfreader.cpp 27918 2010-03-31 17:10:40Z vboxsync $ */
2	/** @file
3	*
4	* OVF reader declarations. Depends only on IPRT, including the iprt::MiniString
5	* and IPRT XML classes.
6	*/
7
8	/*
9	* Copyright (C) 2008-2009 Sun Microsystems, Inc.
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	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
20	* Clara, CA 95054 USA or visit http://www.sun.com if you need
21	* additional information or have any questions.
22	*/
23
24	#include "ovfreader.h"
25
26	using namespace std;
27	using namespace iprt;
28	using namespace ovf;
29
30	////////////////////////////////////////////////////////////////////////////////
31	//
32	// OVF reader implemenation
33	//
34	////////////////////////////////////////////////////////////////////////////////
35
36	/**
37	* Constructor. This opens the given XML file and parses it. Throws lots of exceptions
38	* on XML or OVF invalidity.
39	* @param path
40	*/
41	OVFReader::OVFReader(const MiniString &path)
42	: m_strPath(path)
43	{
44	xml::XmlFileParser parser;
45	parser.read(m_strPath,
46	m_doc);
47
48	const xml::ElementNode *pRootElem = m_doc.getRootElement();
49	if ( !pRootElem
50	\|\| strcmp(pRootElem->getName(), "Envelope")
51	)
52	throw OVFLogicError(N_("Root element in OVF file must be \"Envelope\"."));
53
54	// OVF has the following rough layout:
55	/*
56	-- <References> .... files referenced from other parts of the file, such as VMDK images
57	-- Metadata, comprised of several section commands
58	-- virtual machines, either a single <VirtualSystem>, or a <VirtualSystemCollection>
59	-- optionally <Strings> for localization
60	*/
61
62	// get all "File" child elements of "References" section so we can look up files easily;
63	// first find the "References" sections so we can look up files
64	xml::ElementNodesList listFileElements; // receives all /Envelope/References/File nodes
65	const xml::ElementNode *pReferencesElem;
66	if ((pReferencesElem = pRootElem->findChildElement("References")))
67	pReferencesElem->getChildElements(listFileElements, "File");
68
69	// now go though the sections
70	LoopThruSections(pReferencesElem, pRootElem);
71	}
72
73	/**
74	* Private helper method that goes thru the elements of the given "current" element in the OVF XML
75	* and handles the contained child elements (which can be "Section" or "Content" elements).
76	*
77	* @param pcszPath Path spec of the XML file, for error messages.
78	* @param pReferencesElement "References" element from OVF, for looking up file specifications; can be NULL if no such element is present.
79	* @param pCurElem Element whose children are to be analyzed here.
80	* @return
81	*/
82	void OVFReader::LoopThruSections(const xml::ElementNode *pReferencesElem,
83	const xml::ElementNode *pCurElem)
84	{
85	xml::NodesLoop loopChildren(*pCurElem);
86	const xml::ElementNode *pElem;
87	while ((pElem = loopChildren.forAllNodes()))
88	{
89	const char *pcszElemName = pElem->getName();
90	const char *pcszTypeAttr = "";
91	const xml::AttributeNode *pTypeAttr;
92	if ((pTypeAttr = pElem->findAttribute("type")))
93	pcszTypeAttr = pTypeAttr->getValue();
94
95	if ( (!strcmp(pcszElemName, "DiskSection"))
96	\|\| ( (!strcmp(pcszElemName, "Section"))
97	&& (!strcmp(pcszTypeAttr, "ovf:DiskSection_Type"))
98	)
99	)
100	{
101	HandleDiskSection(pReferencesElem, pElem);
102	}
103	else if ( (!strcmp(pcszElemName, "NetworkSection"))
104	\|\| ( (!strcmp(pcszElemName, "Section"))
105	&& (!strcmp(pcszTypeAttr, "ovf:NetworkSection_Type"))
106	)
107	)
108	{
109	HandleNetworkSection(pElem);
110	}
111	else if ( (!strcmp(pcszElemName, "DeploymentOptionSection")))
112	{
113	// TODO
114	}
115	else if ( (!strcmp(pcszElemName, "Info")))
116	{
117	// child of VirtualSystemCollection -- TODO
118	}
119	else if ( (!strcmp(pcszElemName, "ResourceAllocationSection")))
120	{
121	// child of VirtualSystemCollection -- TODO
122	}
123	else if ( (!strcmp(pcszElemName, "StartupSection")))
124	{
125	// child of VirtualSystemCollection -- TODO
126	}
127	else if ( (!strcmp(pcszElemName, "VirtualSystem"))
128	\|\| ( (!strcmp(pcszElemName, "Content"))
129	&& (!strcmp(pcszTypeAttr, "ovf:VirtualSystem_Type"))
130	)
131	)
132	{
133	HandleVirtualSystemContent(pElem);
134	}
135	else if ( (!strcmp(pcszElemName, "VirtualSystemCollection"))
136	\|\| ( (!strcmp(pcszElemName, "Content"))
137	&& (!strcmp(pcszTypeAttr, "ovf:VirtualSystemCollection_Type"))
138	)
139	)
140	{
141	// TODO ResourceAllocationSection
142
143	// recurse for this, since it has VirtualSystem elements as children
144	LoopThruSections(pReferencesElem, pElem);
145	}
146	}
147	}
148
149	/**
150	* Private helper method that handles disk sections in the OVF XML.
151	* Gets called indirectly from IAppliance::read().
152	*
153	* @param pcszPath Path spec of the XML file, for error messages.
154	* @param pReferencesElement "References" element from OVF, for looking up file specifications; can be NULL if no such element is present.
155	* @param pSectionElem Section element for which this helper is getting called.
156	* @return
157	*/
158	void OVFReader::HandleDiskSection(const xml::ElementNode *pReferencesElem,
159	const xml::ElementNode *pSectionElem)
160	{
161	// contains "Disk" child elements
162	xml::NodesLoop loopDisks(*pSectionElem, "Disk");
163	const xml::ElementNode *pelmDisk;
164	while ((pelmDisk = loopDisks.forAllNodes()))
165	{
166	DiskImage d;
167	const char *pcszBad = NULL;
168	const char *pcszDiskId;
169	const char *pcszFormat;
170	if (!(pelmDisk->getAttributeValue("diskId", pcszDiskId)))
171	pcszBad = "diskId";
172	else if (!(pelmDisk->getAttributeValue("format", pcszFormat)))
173	pcszBad = "format";
174	else if (!(pelmDisk->getAttributeValue("capacity", d.iCapacity)))
175	pcszBad = "capacity";
176	else
177	{
178	d.strDiskId = pcszDiskId;
179	d.strFormat = pcszFormat;
180
181	if (!(pelmDisk->getAttributeValue("populatedSize", d.iPopulatedSize)))
182	// optional
183	d.iPopulatedSize = -1;
184
185	const char *pcszFileRef;
186	if (pelmDisk->getAttributeValue("fileRef", pcszFileRef)) // optional
187	{
188	// look up corresponding /References/File nodes (list built above)
189	const xml::ElementNode *pFileElem;
190	if ( pReferencesElem
191	&& ((pFileElem = pReferencesElem->findChildElementFromId(pcszFileRef)))
192	)
193	{
194	// copy remaining values from file node then
195	const char *pcszBadInFile = NULL;
196	const char *pcszHref;
197	if (!(pFileElem->getAttributeValue("href", pcszHref)))
198	pcszBadInFile = "href";
199	else if (!(pFileElem->getAttributeValue("size", d.iSize)))
200	d.iSize = -1; // optional
201
202	d.strHref = pcszHref;
203
204	// if (!(pFileElem->getAttributeValue("size", d.iChunkSize))) TODO
205	d.iChunkSize = -1; // optional
206	const char *pcszCompression;
207	if (pFileElem->getAttributeValue("compression", pcszCompression))
208	d.strCompression = pcszCompression;
209
210	if (pcszBadInFile)
211	throw OVFLogicError(N_("Error reading \"%s\": missing or invalid attribute '%s' in 'File' element, line %d"),
212	m_strPath.c_str(),
213	pcszBadInFile,
214	pFileElem->getLineNumber());
215	}
216	else
217	throw OVFLogicError(N_("Error reading \"%s\": cannot find References/File element for ID '%s' referenced by 'Disk' element, line %d"),
218	m_strPath.c_str(),
219	pcszFileRef,
220	pelmDisk->getLineNumber());
221	}
222	}
223
224	if (pcszBad)
225	throw OVFLogicError(N_("Error reading \"%s\": missing or invalid attribute '%s' in 'DiskSection' element, line %d"),
226	m_strPath.c_str(),
227	pcszBad,
228	pelmDisk->getLineNumber());
229
230	m_mapDisks[d.strDiskId] = d;
231	}
232	}
233
234	/**
235	* Private helper method that handles network sections in the OVF XML.
236	* Gets called indirectly from IAppliance::read().
237	*
238	* @param pcszPath Path spec of the XML file, for error messages.
239	* @param pSectionElem Section element for which this helper is getting called.
240	* @return
241	*/
242	void OVFReader::HandleNetworkSection(const xml::ElementNode * /* pSectionElem */)
243	{
244	// we ignore network sections for now
245
246	// xml::NodesLoop loopNetworks(*pSectionElem, "Network");
247	// const xml::Node *pelmNetwork;
248	// while ((pelmNetwork = loopNetworks.forAllNodes()))
249	// {
250	// Network n;
251	// if (!(pelmNetwork->getAttributeValue("name", n.strNetworkName)))
252	// return setError(VBOX_E_FILE_ERROR,
253	// tr("Error reading \"%s\": missing 'name' attribute in 'Network', line %d"),
254	// pcszPath,
255	// pelmNetwork->getLineNumber());
256	//
257	// m->mapNetworks[n.strNetworkName] = n;
258	// }
259	}
260
261	/**
262	* Private helper method that handles a "VirtualSystem" element in the OVF XML.
263	* Gets called indirectly from IAppliance::read().
264	*
265	* @param pcszPath
266	* @param pContentElem
267	* @return
268	*/
269	void OVFReader::HandleVirtualSystemContent(const xml::ElementNode *pelmVirtualSystem)
270	{
271	VirtualSystem vsys;
272
273	// peek under the <VirtualSystem> node whether we have a <vbox:Machine> node;
274	// that case case, the caller can completely ignore the OVF but only load the VBox machine XML
275	vsys.pelmVboxMachine = pelmVirtualSystem->findChildElement("vbox", "Machine");
276
277	// now look for real OVF
278	const xml::AttributeNode *pIdAttr = pelmVirtualSystem->findAttribute("id");
279	if (pIdAttr)
280	vsys.strName = pIdAttr->getValue();
281
282	xml::NodesLoop loop(*pelmVirtualSystem); // all child elements
283	const xml::ElementNode *pelmThis;
284	while ((pelmThis = loop.forAllNodes()))
285	{
286	const char *pcszElemName = pelmThis->getName();
287	const xml::AttributeNode *pTypeAttr = pelmThis->findAttribute("type");
288	const char *pcszTypeAttr = (pTypeAttr) ? pTypeAttr->getValue() : "";
289
290	if ( (!strcmp(pcszElemName, "EulaSection"))
291	\|\| (!strcmp(pcszTypeAttr, "ovf:EulaSection_Type"))
292	)
293	{
294	/* <EulaSection>
295	<Info ovf:msgid="6">License agreement for the Virtual System.</Info>
296	<License ovf:msgid="1">License terms can go in here.</License>
297	</EulaSection> */
298
299	const xml::ElementNode *pelmLicense;
300	if ((pelmLicense = pelmThis->findChildElement("License")))
301	vsys.strLicenseText = pelmLicense->getValue();
302	}
303	if ( (!strcmp(pcszElemName, "ProductSection"))
304	\|\| (!strcmp(pcszTypeAttr, "ovf:ProductSection_Type"))
305	)
306	{
307	/* <Section ovf:required="false" xsi:type="ovf:ProductSection_Type">
308	<Info>Meta-information about the installed software</Info>
309	<Product>VAtest</Product>
310	<Vendor>SUN Microsystems</Vendor>
311	<Version>10.0</Version>
312	<ProductUrl>http://blogs.sun.com/VirtualGuru</ProductUrl>
313	<VendorUrl>http://www.sun.com</VendorUrl>
314	</Section> */
315	const xml::ElementNode *pelmProduct;
316	if ((pelmProduct = pelmThis->findChildElement("Product")))
317	vsys.strProduct = pelmProduct->getValue();
318	const xml::ElementNode *pelmVendor;
319	if ((pelmVendor = pelmThis->findChildElement("Vendor")))
320	vsys.strVendor = pelmVendor->getValue();
321	const xml::ElementNode *pelmVersion;
322	if ((pelmVersion = pelmThis->findChildElement("Version")))
323	vsys.strVersion = pelmVersion->getValue();
324	const xml::ElementNode *pelmProductUrl;
325	if ((pelmProductUrl = pelmThis->findChildElement("ProductUrl")))
326	vsys.strProductUrl = pelmProductUrl->getValue();
327	const xml::ElementNode *pelmVendorUrl;
328	if ((pelmVendorUrl = pelmThis->findChildElement("VendorUrl")))
329	vsys.strVendorUrl = pelmVendorUrl->getValue();
330	}
331	else if ( (!strcmp(pcszElemName, "VirtualHardwareSection"))
332	\|\| (!strcmp(pcszTypeAttr, "ovf:VirtualHardwareSection_Type"))
333	)
334	{
335	const xml::ElementNode pelmSystem, pelmVirtualSystemType;
336	if ((pelmSystem = pelmThis->findChildElement("System")))
337	{
338	/* <System>
339	<vssd:Description>Description of the virtual hardware section.</vssd:Description>
340	<vssd:ElementName>vmware</vssd:ElementName>
341	<vssd:InstanceID>1</vssd:InstanceID>
342	<vssd:VirtualSystemIdentifier>MyLampService</vssd:VirtualSystemIdentifier>
343	<vssd:VirtualSystemType>vmx-4</vssd:VirtualSystemType>
344	</System>*/
345	if ((pelmVirtualSystemType = pelmSystem->findChildElement("VirtualSystemType")))
346	vsys.strVirtualSystemType = pelmVirtualSystemType->getValue();
347	}
348
349	xml::NodesLoop loopVirtualHardwareItems(*pelmThis, "Item"); // all "Item" child elements
350	const xml::ElementNode *pelmItem;
351	while ((pelmItem = loopVirtualHardwareItems.forAllNodes()))
352	{
353	VirtualHardwareItem i;
354
355	i.ulLineNumber = pelmItem->getLineNumber();
356
357	xml::NodesLoop loopItemChildren(*pelmItem); // all child elements
358	const xml::ElementNode *pelmItemChild;
359	while ((pelmItemChild = loopItemChildren.forAllNodes()))
360	{
361	const char *pcszItemChildName = pelmItemChild->getName();
362	if (!strcmp(pcszItemChildName, "Description"))
363	i.strDescription = pelmItemChild->getValue();
364	else if (!strcmp(pcszItemChildName, "Caption"))
365	i.strCaption = pelmItemChild->getValue();
366	else if (!strcmp(pcszItemChildName, "ElementName"))
367	i.strElementName = pelmItemChild->getValue();
368	else if ( (!strcmp(pcszItemChildName, "InstanceID"))
369	\|\| (!strcmp(pcszItemChildName, "InstanceId"))
370	)
371	pelmItemChild->copyValue(i.ulInstanceID);
372	else if (!strcmp(pcszItemChildName, "HostResource"))
373	i.strHostResource = pelmItemChild->getValue();
374	else if (!strcmp(pcszItemChildName, "ResourceType"))
375	{
376	uint32_t ulType;
377	pelmItemChild->copyValue(ulType);
378	i.resourceType = (ResourceType_T)ulType;
379	}
380	else if (!strcmp(pcszItemChildName, "OtherResourceType"))
381	i.strOtherResourceType = pelmItemChild->getValue();
382	else if (!strcmp(pcszItemChildName, "ResourceSubType"))
383	i.strResourceSubType = pelmItemChild->getValue();
384	else if (!strcmp(pcszItemChildName, "AutomaticAllocation"))
385	i.fAutomaticAllocation = (!strcmp(pelmItemChild->getValue(), "true")) ? true : false;
386	else if (!strcmp(pcszItemChildName, "AutomaticDeallocation"))
387	i.fAutomaticDeallocation = (!strcmp(pelmItemChild->getValue(), "true")) ? true : false;
388	else if (!strcmp(pcszItemChildName, "Parent"))
389	pelmItemChild->copyValue(i.ulParent);
390	else if (!strcmp(pcszItemChildName, "Connection"))
391	i.strConnection = pelmItemChild->getValue();
392	else if (!strcmp(pcszItemChildName, "Address"))
393	i.strAddress = pelmItemChild->getValue();
394	else if (!strcmp(pcszItemChildName, "AddressOnParent"))
395	i.strAddressOnParent = pelmItemChild->getValue();
396	else if (!strcmp(pcszItemChildName, "AllocationUnits"))
397	i.strAllocationUnits = pelmItemChild->getValue();
398	else if (!strcmp(pcszItemChildName, "VirtualQuantity"))
399	pelmItemChild->copyValue(i.ullVirtualQuantity);
400	else if (!strcmp(pcszItemChildName, "Reservation"))
401	pelmItemChild->copyValue(i.ullReservation);
402	else if (!strcmp(pcszItemChildName, "Limit"))
403	pelmItemChild->copyValue(i.ullLimit);
404	else if (!strcmp(pcszItemChildName, "Weight"))
405	pelmItemChild->copyValue(i.ullWeight);
406	else if (!strcmp(pcszItemChildName, "ConsumerVisibility"))
407	i.strConsumerVisibility = pelmItemChild->getValue();
408	else if (!strcmp(pcszItemChildName, "MappingBehavior"))
409	i.strMappingBehavior = pelmItemChild->getValue();
410	else if (!strcmp(pcszItemChildName, "PoolID"))
411	i.strPoolID = pelmItemChild->getValue();
412	else if (!strcmp(pcszItemChildName, "BusNumber"))
413	pelmItemChild->copyValue(i.ulBusNumber);
414	else
415	throw OVFLogicError(N_("Error reading \"%s\": unknown element \"%s\" under Item element, line %d"),
416	m_strPath.c_str(),
417	pcszItemChildName,
418	i.ulLineNumber);
419	}
420
421	// store!
422	vsys.mapHardwareItems[i.ulInstanceID] = i;
423	}
424
425	// now go thru all hardware items and handle them according to their type;
426	// in this first loop we handle all items _except_ hard disk images,
427	// which we'll handle in a second loop below
428	HardwareItemsMap::const_iterator itH;
429	for (itH = vsys.mapHardwareItems.begin();
430	itH != vsys.mapHardwareItems.end();
431	++itH)
432	{
433	const VirtualHardwareItem &i = itH->second;
434
435	// do some analysis
436	switch (i.resourceType)
437	{
438	case ResourceType_Processor: // 3
439	/* <rasd:Caption>1 virtual CPU</rasd:Caption>
440	<rasd:Description>Number of virtual CPUs</rasd:Description>
441	<rasd:ElementName>virtual CPU</rasd:ElementName>
442	<rasd:InstanceID>1</rasd:InstanceID>
443	<rasd:ResourceType>3</rasd:ResourceType>
444	<rasd:VirtualQuantity>1</rasd:VirtualQuantity>*/
445	if (i.ullVirtualQuantity < UINT16_MAX)
446	vsys.cCPUs = (uint16_t)i.ullVirtualQuantity;
447	else
448	throw OVFLogicError(N_("Error reading \"%s\": CPU count %RI64 is larger than %d, line %d"),
449	m_strPath.c_str(),
450	i.ullVirtualQuantity,
451	UINT16_MAX,
452	i.ulLineNumber);
453	break;
454
455	case ResourceType_Memory: // 4
456	if ( (i.strAllocationUnits == "MegaBytes") // found in OVF created by OVF toolkit
457	\|\| (i.strAllocationUnits == "MB") // found in MS docs
458	\|\| (i.strAllocationUnits == "byte * 2^20") // suggested by OVF spec DSP0243 page 21
459	)
460	vsys.ullMemorySize = i.ullVirtualQuantity * 1024 * 1024;
461	else
462	throw OVFLogicError(N_("Error reading \"%s\": Invalid allocation unit \"%s\" specified with memory size item, line %d"),
463	m_strPath.c_str(),
464	i.strAllocationUnits.c_str(),
465	i.ulLineNumber);
466	break;
467
468	case ResourceType_IDEController: // 5
469	{
470	/* <Item>
471	<rasd:Caption>ideController0</rasd:Caption>
472	<rasd:Description>IDE Controller</rasd:Description>
473	<rasd:InstanceId>5</rasd:InstanceId>
474	<rasd:ResourceType>5</rasd:ResourceType>
475	<rasd:Address>0</rasd:Address>
476	<rasd:BusNumber>0</rasd:BusNumber>
477	</Item> */
478	HardDiskController hdc;
479	hdc.system = HardDiskController::IDE;
480	hdc.idController = i.ulInstanceID;
481	hdc.strControllerType = i.strResourceSubType;
482	hdc.strAddress = i.strAddress;
483	hdc.ulBusNumber = i.ulBusNumber;
484
485	vsys.mapControllers[i.ulInstanceID] = hdc;
486	}
487	break;
488
489	case ResourceType_ParallelSCSIHBA: // 6 SCSI controller
490	{
491	/* <Item>
492	<rasd:Caption>SCSI Controller 0 - LSI Logic</rasd:Caption>
493	<rasd:Description>SCI Controller</rasd:Description>
494	<rasd:ElementName>SCSI controller</rasd:ElementName>
495	<rasd:InstanceID>4</rasd:InstanceID>
496	<rasd:ResourceSubType>LsiLogic</rasd:ResourceSubType>
497	<rasd:ResourceType>6</rasd:ResourceType>
498	</Item> */
499	HardDiskController hdc;
500	hdc.system = HardDiskController::SCSI;
501	hdc.idController = i.ulInstanceID;
502	hdc.strControllerType = i.strResourceSubType;
503
504	vsys.mapControllers[i.ulInstanceID] = hdc;
505	}
506	break;
507
508	case ResourceType_EthernetAdapter: // 10
509	{
510	/* <Item>
511	<rasd:Caption>Ethernet adapter on 'Bridged'</rasd:Caption>
512	<rasd:AutomaticAllocation>true</rasd:AutomaticAllocation>
513	<rasd:Connection>Bridged</rasd:Connection>
514	<rasd:InstanceID>6</rasd:InstanceID>
515	<rasd:ResourceType>10</rasd:ResourceType>
516	<rasd:ResourceSubType>E1000</rasd:ResourceSubType>
517	</Item>
518
519	OVF spec DSP 0243 page 21:
520	"For an Ethernet adapter, this specifies the abstract network connection name
521	for the virtual machine. All Ethernet adapters that specify the same abstract
522	network connection name within an OVF package shall be deployed on the same
523	network. The abstract network connection name shall be listed in the NetworkSection
524	at the outermost envelope level." */
525
526	// only store the name
527	EthernetAdapter ea;
528	ea.strAdapterType = i.strResourceSubType;
529	ea.strNetworkName = i.strConnection;
530	vsys.llEthernetAdapters.push_back(ea);
531	}
532	break;
533
534	case ResourceType_FloppyDrive: // 14
535	vsys.fHasFloppyDrive = true; // we have no additional information
536	break;
537
538	case ResourceType_CDDrive: // 15
539	/* <Item ovf:required="false">
540	<rasd:Caption>cdrom1</rasd:Caption>
541	<rasd:InstanceId>7</rasd:InstanceId>
542	<rasd:ResourceType>15</rasd:ResourceType>
543	<rasd:AutomaticAllocation>true</rasd:AutomaticAllocation>
544	<rasd:Parent>5</rasd:Parent>
545	<rasd:AddressOnParent>0</rasd:AddressOnParent>
546	</Item> */
547	// I tried to see what happens if I set an ISO for the CD-ROM in VMware Workstation,
548	// but then the ovftool dies with "Device backing not supported". So I guess if
549	// VMware can't export ISOs, then we don't need to be able to import them right now.
550	vsys.fHasCdromDrive = true; // we have no additional information
551	break;
552
553	case ResourceType_HardDisk: // 17
554	// handled separately in second loop below
555	break;
556
557	case ResourceType_OtherStorageDevice: // 20 SATA controller
558	{
559	/* <Item>
560	<rasd:Description>SATA Controller</rasd:Description>
561	<rasd:Caption>sataController0</rasd:Caption>
562	<rasd:InstanceID>4</rasd:InstanceID>
563	<rasd:ResourceType>20</rasd:ResourceType>
564	<rasd:ResourceSubType>AHCI</rasd:ResourceSubType>
565	<rasd:Address>0</rasd:Address>
566	<rasd:BusNumber>0</rasd:BusNumber>
567	</Item> */
568	if ( i.strCaption.startsWith("sataController", MiniString::CaseInsensitive)
569	&& !i.strResourceSubType.compare("AHCI", MiniString::CaseInsensitive)
570	)
571	{
572	HardDiskController hdc;
573	hdc.system = HardDiskController::SATA;
574	hdc.idController = i.ulInstanceID;
575	hdc.strControllerType = i.strResourceSubType;
576
577	vsys.mapControllers[i.ulInstanceID] = hdc;
578	}
579	else
580	throw OVFLogicError(N_("Error reading \"%s\": Host resource of type \"Other Storage Device (%d)\" is supported with SATA AHCI controllers only, line %d"),
581	m_strPath.c_str(),
582	ResourceType_OtherStorageDevice,
583	i.ulLineNumber);
584	}
585	break;
586
587	case ResourceType_USBController: // 23
588	/* <Item ovf:required="false">
589	<rasd:Caption>usb</rasd:Caption>
590	<rasd:Description>USB Controller</rasd:Description>
591	<rasd:InstanceId>3</rasd:InstanceId>
592	<rasd:ResourceType>23</rasd:ResourceType>
593	<rasd:Address>0</rasd:Address>
594	<rasd:BusNumber>0</rasd:BusNumber>
595	</Item> */
596	vsys.fHasUsbController = true; // we have no additional information
597	break;
598
599	case ResourceType_SoundCard: // 35
600	/* <Item ovf:required="false">
601	<rasd:Caption>sound</rasd:Caption>
602	<rasd:Description>Sound Card</rasd:Description>
603	<rasd:InstanceId>10</rasd:InstanceId>
604	<rasd:ResourceType>35</rasd:ResourceType>
605	<rasd:ResourceSubType>ensoniq1371</rasd:ResourceSubType>
606	<rasd:AutomaticAllocation>false</rasd:AutomaticAllocation>
607	<rasd:AddressOnParent>3</rasd:AddressOnParent>
608	</Item> */
609	vsys.strSoundCardType = i.strResourceSubType;
610	break;
611
612	default:
613	throw OVFLogicError(N_("Error reading \"%s\": Unknown resource type %d in hardware item, line %d"),
614	m_strPath.c_str(),
615	i.resourceType,
616	i.ulLineNumber);
617	} // end switch
618	}
619
620	// now run through the items for a second time, but handle only
621	// hard disk images; otherwise the code would fail if a hard
622	// disk image appears in the OVF before its hard disk controller
623	for (itH = vsys.mapHardwareItems.begin();
624	itH != vsys.mapHardwareItems.end();
625	++itH)
626	{
627	const VirtualHardwareItem &i = itH->second;
628
629	// do some analysis
630	switch (i.resourceType)
631	{
632	case ResourceType_HardDisk: // 17
633	{
634	/* <Item>
635	<rasd:Caption>Harddisk 1</rasd:Caption>
636	<rasd:Description>HD</rasd:Description>
637	<rasd:ElementName>Hard Disk</rasd:ElementName>
638	<rasd:HostResource>ovf://disk/lamp</rasd:HostResource>
639	<rasd:InstanceID>5</rasd:InstanceID>
640	<rasd:Parent>4</rasd:Parent>
641	<rasd:ResourceType>17</rasd:ResourceType>
642	</Item> */
643
644	// look up the hard disk controller element whose InstanceID equals our Parent;
645	// this is how the connection is specified in OVF
646	ControllersMap::const_iterator it = vsys.mapControllers.find(i.ulParent);
647	if (it == vsys.mapControllers.end())
648	throw OVFLogicError(N_("Error reading \"%s\": Hard disk item with instance ID %d specifies invalid parent %d, line %d"),
649	m_strPath.c_str(),
650	i.ulInstanceID,
651	i.ulParent,
652	i.ulLineNumber);
653	//const HardDiskController &hdc = it->second;
654
655	VirtualDisk vd;
656	vd.idController = i.ulParent;
657	i.strAddressOnParent.toInt(vd.ulAddressOnParent);
658	// ovf://disk/lamp
659	// 123456789012345
660	if (i.strHostResource.substr(0, 11) == "ovf://disk/")
661	vd.strDiskId = i.strHostResource.substr(11);
662	else if (i.strHostResource.substr(0, 10) == "ovf:/disk/")
663	vd.strDiskId = i.strHostResource.substr(10);
664	else if (i.strHostResource.substr(0, 6) == "/disk/")
665	vd.strDiskId = i.strHostResource.substr(6);
666
667	if ( !(vd.strDiskId.length())
668	\|\| (m_mapDisks.find(vd.strDiskId) == m_mapDisks.end())
669	)
670	throw OVFLogicError(N_("Error reading \"%s\": Hard disk item with instance ID %d specifies invalid host resource \"%s\", line %d"),
671	m_strPath.c_str(),
672	i.ulInstanceID,
673	i.strHostResource.c_str(),
674	i.ulLineNumber);
675
676	vsys.mapVirtualDisks[vd.strDiskId] = vd;
677	}
678	break;
679	default: break;
680	}
681	}
682	}
683	else if ( (!strcmp(pcszElemName, "OperatingSystemSection"))
684	\|\| (!strcmp(pcszTypeAttr, "ovf:OperatingSystemSection_Type"))
685	)
686	{
687	uint64_t cimos64;
688	if (!(pelmThis->getAttributeValue("id", cimos64)))
689	throw OVFLogicError(N_("Error reading \"%s\": missing or invalid 'ovf:id' attribute in operating system section element, line %d"),
690	m_strPath.c_str(),
691	pelmThis->getLineNumber());
692
693	vsys.cimos = (CIMOSType_T)cimos64;
694	const xml::ElementNode *pelmCIMOSDescription;
695	if ((pelmCIMOSDescription = pelmThis->findChildElement("Description")))
696	vsys.strCimosDesc = pelmCIMOSDescription->getValue();
697	}
698	else if ( (!strcmp(pcszElemName, "AnnotationSection"))
699	\|\| (!strcmp(pcszTypeAttr, "ovf:AnnotationSection_Type"))
700	)
701	{
702	const xml::ElementNode *pelmAnnotation;
703	if ((pelmAnnotation = pelmThis->findChildElement("Annotation")))
704	vsys.strDescription = pelmAnnotation->getValue();
705	}
706	}
707
708	// now create the virtual system
709	m_llVirtualSystems.push_back(vsys);
710	}
711
712	////////////////////////////////////////////////////////////////////////////////
713	//
714	// Errors
715	//
716	////////////////////////////////////////////////////////////////////////////////
717
718	OVFLogicError::OVFLogicError(const char *aFormat, ...)
719	{
720	char *pszNewMsg;
721	va_list args;
722	va_start(args, aFormat);
723	RTStrAPrintfV(&pszNewMsg, aFormat, args);
724	setWhat(pszNewMsg);
725	RTStrFree(pszNewMsg);
726	va_end(args);
727	}

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

source: vbox/trunk/src/VBox/Main/xml/ovfreader.cpp@ 28032

Download in other formats: