ApplianceImpl.cpp@ 16228

Last change on this file since 16228 was 16228, checked in by vboxsync, 16 years ago
OVF: handle IDE controllers
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 60.8 KB

Line
1	/* $Id: ApplianceImpl.cpp 16228 2009-01-26 13:11:42Z vboxsync $ */
2	/** @file
3	*
4	* IAppliance and IVirtualSystem COM class implementations
5	*/
6
7	/*
8	* Copyright (C) 2008-2009 Sun Microsystems, Inc.
9	*
10	* This file is part of VirtualBox Open Source Edition (OSE), as
11	* available from http://www.virtualbox.org. This file is free software;
12	* you can redistribute it and/or modify it under the terms of the GNU
13	* General Public License (GPL) as published by the Free Software
14	* Foundation, in version 2 as it comes in the "COPYING" file of the
15	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
16	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
17	*
18	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
19	* Clara, CA 95054 USA or visit http://www.sun.com if you need
20	* additional information or have any questions.
21	*/
22
23	#include <iprt/stream.h>
24	#include <iprt/path.h>
25
26	#include "ApplianceImpl.h"
27	#include "VirtualBoxImpl.h"
28	#include "GuestOSTypeImpl.h"
29
30	#include "Logging.h"
31
32	#include "VBox/xml.h"
33
34	#include <iostream>
35	#include <sstream>
36
37	using namespace std;
38
39	// defines
40	////////////////////////////////////////////////////////////////////////////////
41
42	struct DiskImage
43	{
44	string strDiskId; // value from DiskSection/Disk/@diskId
45	int64_t iCapacity; // value from DiskSection/Disk/@capacity;
46	// (maximum size for dynamic images, I guess; we always translate this to bytes)
47	int64_t iPopulatedSize; // value from DiskSection/Disk/@populatedSize
48	// (actual used size of disk, always in bytes; can be an estimate of used disk
49	// space, but cannot be larger than iCapacity)
50	string strFormat; // value from DiskSection/Disk/@format
51	// typically http://www.vmware.com/specifications/vmdk.html#sparse
52
53	// fields from /References/File; the spec says the file reference from disk can be empty,
54	// so in that case, strFilename will be empty, then a new disk should be created
55	string strHref; // value from /References/File/@href (filename); if empty, then the remaining fields are ignored
56	int64_t iSize; // value from /References/File/@size (optional according to spec; then we set -1 here)
57	int64_t iChunkSize; // value from /References/File/@chunkSize (optional, unsupported)
58	string strCompression; // value from /References/File/@compression (optional, can be "gzip" according to spec)
59	};
60
61	struct Network
62	{
63	string strNetworkName; // value from NetworkSection/Network/@name
64	// unfortunately the OVF spec is unspecific about how networks should be specified further
65	};
66
67	struct VirtualHardwareItem
68	{
69	string strDescription;
70	string strCaption;
71	string strElementName;
72
73	uint32_t ulInstanceID;
74	uint32_t ulParent;
75
76	string strHostResource;
77	OVFResourceType_T resourceType;
78	string strOtherResourceType;
79	string strResourceSubType;
80	bool fAutomaticAllocation;
81	bool fAutomaticDeallocation;
82	string strConnection; // for ethernet
83	string strAddress;
84	string strAddressOnParent;
85	string strAllocationUnits;
86	uint64_t ullVirtualQuantity;
87	uint64_t ullReservation;
88	uint64_t ullLimit;
89	uint64_t ullWeight;
90	string strConsumerVisibility;
91	string strMappingBehavior;
92	string strPoolID;
93	uint32_t ulBusNumber;
94
95	uint32_t ulLineNumber; // line number of <Item> element in XML source
96
97	VirtualHardwareItem()
98	: ulInstanceID(0), fAutomaticAllocation(false), fAutomaticDeallocation(false), ullVirtualQuantity(0), ullReservation(0), ullLimit(0), ullWeight(0)
99	{};
100	};
101
102	typedef map<string, DiskImage> DiskImagesMap;
103	typedef map<string, Network> NetworksMap;
104
105	struct VirtualSystem;
106
107	// opaque private instance data of Appliance class
108	struct Appliance::Data
109	{
110	Bstr bstrPath;
111
112	DiskImagesMap mapDisks; // map of DiskImage structs, sorted by DiskImage.strDiskId
113
114	NetworksMap mapNetworks; // map of Network structs, sorted by Network.strNetworkName
115
116	list<VirtualSystem> llVirtualSystems;
117
118	list< ComObjPtr<VirtualSystemDescription> > virtualSystemDescriptions;
119	};
120
121	typedef map<uint32_t, VirtualHardwareItem> HardwareItemsMap;
122
123	enum ControllerSystemType { IDE, SATA, SCSI };
124	struct HardDiskController
125	{
126	uint32_t idController; // instance ID (Item/InstanceId); this gets referenced from HardDisk
127	ControllerSystemType controllerSystem; // one of IDE, SATA, SCSI
128	string strControllerType; // controller type (Item/ResourceSubType); e.g. "LsiLogic"; can be empty (esp. for IDE)
129	string strAddress; // for IDE
130	uint32_t ulBusNumber; // for IDE
131
132	HardDiskController()
133	: idController(0),
134	ulBusNumber(0)
135	{
136	}
137	};
138
139	typedef map<uint32_t, HardDiskController> ControllersMap;
140
141	struct VirtualDisk
142	{
143	uint32_t idController; // SCSI (or IDE) controller this disk is connected to;
144	// points into VirtualSystem.mapControllers
145	string strDiskId; // if the hard disk has an ovf:/disk/<id> reference,
146	// this receives the <id> component; points to one of the
147	// references in Appliance::Data.mapDisks
148	};
149
150	struct VirtualSystem
151	{
152	string strName; // copy of VirtualSystem/@id
153
154	CIMOSType_T cimos;
155	string strVirtualSystemType;
156
157	HardwareItemsMap mapHardwareItems; // map of virtual hardware items, sorted by unique instance ID
158
159	uint64_t ullMemorySize; // always in bytes, copied from llHardwareItems; default = 0 (unspecified)
160	uint16_t cCPUs; // no. of CPUs, copied from llHardwareItems; default = 1
161
162	list<string> llNetworkNames;
163	// list of strings referring to network names
164	// (one for each VirtualSystem/Item[@ResourceType=10]/Connection element)
165
166	ControllersMap mapControllers;
167	// list of hard disk controllers
168	// (one for each VirtualSystem/Item[@ResourceType=6] element with accumulated data from children)
169
170	list<VirtualDisk> llVirtualDisks;
171	// (one for each VirtualSystem/Item[@ResourceType=17] element with accumulated data from children)
172
173	string strLicenceInfo; // license info if any; receives contents of VirtualSystem/EulaSection/Info
174	string strLicenceText; // license info if any; receives contents of VirtualSystem/EulaSection/License
175
176	VirtualSystem()
177	: ullMemorySize(0), cCPUs(1)
178	{
179	}
180	};
181
182	// globals
183	////////////////////////////////////////////////////////////////////////////////
184
185	template <class T> inline std::string toString(const T& val)
186	{
187	std::ostringstream ss;
188	ss << val;
189	return ss.str();
190	}
191
192	// IVirtualBox public methods
193	////////////////////////////////////////////////////////////////////////////////
194
195	/**
196	* Implementation for IVirtualBox::openAppliance. Loads the given appliance (see API reference).
197	*
198	* @param bstrPath Appliance to open (either .ovf or .ova file, see API reference)
199	* @param anAppliance IAppliance object created if S_OK is returned.
200	* @return S_OK or error.
201	*/
202	STDMETHODIMP VirtualBox::OpenAppliance (IN_BSTR bstrPath, IAppliance** anAppliance)
203	{
204	HRESULT rc;
205
206	ComObjPtr<Appliance> appliance;
207	appliance.createObject();
208	rc = appliance->init (this, bstrPath);
209	// ComAssertComRCThrowRC(rc);
210
211	if (SUCCEEDED(rc))
212	appliance.queryInterfaceTo(anAppliance);
213
214	return rc;
215	}
216
217	// IAppliance constructor / destructor
218	////////////////////////////////////////////////////////////////////////////////
219
220	DEFINE_EMPTY_CTOR_DTOR(Appliance)
221	struct shutup {};
222
223	// IAppliance private methods
224	////////////////////////////////////////////////////////////////////////////////
225
226	/**
227	* Private helper method that goes thru the elements of the given "current" element in the OVF XML
228	* and handles the contained child elements (which can be "Section" or "Content" elements).
229	*
230	* @param pcszPath Path spec of the XML file, for error messages.
231	* @param pReferencesElement "References" element from OVF, for looking up file specifications; can be NULL if no such element is present.
232	* @param pCurElem Element whose children are to be analyzed here.
233	* @return
234	*/
235	HRESULT Appliance::LoopThruSections(const char *pcszPath,
236	const xml::Node *pReferencesElem,
237	const xml::Node *pCurElem)
238	{
239	HRESULT rc;
240
241	xml::NodesLoop loopChildren(*pCurElem);
242	const xml::Node *pElem;
243	while ((pElem = loopChildren.forAllNodes()))
244	{
245	const char *pcszElemName = pElem->getName();
246	const char *pcszTypeAttr = "";
247	const xml::Node *pTypeAttr;
248	if ((pTypeAttr = pElem->findAttribute("type")))
249	pcszTypeAttr = pTypeAttr->getValue();
250
251	if ( (!strcmp(pcszElemName, "DiskSection"))
252	\|\| ( (!strcmp(pcszElemName, "Section"))
253	&& (!strcmp(pcszTypeAttr, "ovf:DiskSection_Type"))
254	)
255	)
256	{
257	if (!(SUCCEEDED((rc = HandleDiskSection(pcszPath, pReferencesElem, pElem)))))
258	return rc;
259	}
260	else if ( (!strcmp(pcszElemName, "NetworkSection"))
261	\|\| ( (!strcmp(pcszElemName, "Section"))
262	&& (!strcmp(pcszTypeAttr, "ovf:NetworkSection_Type"))
263	)
264	)
265	{
266	if (!(SUCCEEDED((rc = HandleNetworkSection(pcszPath, pElem)))))
267	return rc;
268	}
269	else if ( (!strcmp(pcszElemName, "DeploymentOptionSection>")))
270	{
271	// TODO
272	}
273	else if ( (!strcmp(pcszElemName, "Info")))
274	{
275	// child of VirtualSystemCollection -- TODO
276	}
277	else if ( (!strcmp(pcszElemName, "ResourceAllocationSection")))
278	{
279	// child of VirtualSystemCollection -- TODO
280	}
281	else if ( (!strcmp(pcszElemName, "StartupSection")))
282	{
283	// child of VirtualSystemCollection -- TODO
284	}
285	else if ( (!strcmp(pcszElemName, "VirtualSystem"))
286	\|\| ( (!strcmp(pcszElemName, "Content"))
287	&& (!strcmp(pcszTypeAttr, "ovf:VirtualSystem_Type"))
288	)
289	)
290	{
291	if (!(SUCCEEDED((rc = HandleVirtualSystemContent(pcszPath, pElem)))))
292	return rc;
293	}
294	else if ( (!strcmp(pcszElemName, "VirtualSystemCollection"))
295	\|\| ( (!strcmp(pcszElemName, "Content"))
296	&& (!strcmp(pcszTypeAttr, "ovf:VirtualSystemCollection_Type"))
297	)
298	)
299	{
300	// TODO ResourceAllocationSection
301
302	// recurse for this, since it has VirtualSystem elements as children
303	if (!(SUCCEEDED((rc = LoopThruSections(pcszPath, pReferencesElem, pElem)))))
304	return rc;
305	}
306	}
307
308	return S_OK;
309	}
310
311	/**
312	* Private helper method that handles disk sections in the OVF XML.
313	* @param pcszPath Path spec of the XML file, for error messages.
314	* @param pReferencesElement "References" element from OVF, for looking up file specifications; can be NULL if no such element is present.
315	* @param pSectionElem Section element for which this helper is getting called.
316	* @return
317	*/
318	HRESULT Appliance::HandleDiskSection(const char *pcszPath,
319	const xml::Node *pReferencesElem,
320	const xml::Node *pSectionElem)
321	{
322	// contains "Disk" child elements
323	xml::NodesLoop loopDisks(*pSectionElem, "Disk");
324	const xml::Node *pelmDisk;
325	while ((pelmDisk = loopDisks.forAllNodes()))
326	{
327	DiskImage d;
328	const char *pcszBad = NULL;
329	if (!(pelmDisk->getAttributeValue("diskId", d.strDiskId)))
330	pcszBad = "diskId";
331	else if (!(pelmDisk->getAttributeValue("format", d.strFormat)))
332	pcszBad = "format";
333	else if (!(pelmDisk->getAttributeValue("capacity", d.iCapacity)))
334	pcszBad = "capacity";
335	else
336	{
337	if (!(pelmDisk->getAttributeValue("populatedSize", d.iPopulatedSize)))
338	// optional
339	d.iPopulatedSize = -1;
340
341	string strFileRef;
342	if (pelmDisk->getAttributeValue("fileRef", strFileRef)) // optional
343	{
344	// look up corresponding /References/File nodes (list built above)
345	const xml::Node *pFileElem;
346	if ( pReferencesElem
347	&& ((pFileElem = pReferencesElem->findChildElementFromId(strFileRef.c_str())))
348	)
349	{
350	// copy remaining values from file node then
351	const char *pcszBadInFile = NULL;
352	if (!(pFileElem->getAttributeValue("href", d.strHref)))
353	pcszBadInFile = "href";
354	else if (!(pFileElem->getAttributeValue("size", d.iSize)))
355	d.iSize = -1; // optional
356	// if (!(pFileElem->getAttributeValue("size", d.iChunkSize))) TODO
357	d.iChunkSize = -1; // optional
358	pFileElem->getAttributeValue("compression", d.strCompression);
359
360	if (pcszBadInFile)
361	return setError(VBOX_E_FILE_ERROR,
362	tr("Error reading \"%s\": missing or invalid attribute '%s' in 'File' element, line %d"),
363	pcszPath,
364	pcszBadInFile,
365	pFileElem->getLineNumber());
366	}
367	else
368	return setError(VBOX_E_FILE_ERROR,
369	tr("Error reading \"%s\": cannot find References/File element for ID '%s' referenced by 'Disk' element, line %d"),
370	pcszPath,
371	strFileRef.c_str(),
372	pelmDisk->getLineNumber());
373	}
374	}
375
376	if (pcszBad)
377	return setError(VBOX_E_FILE_ERROR,
378	tr("Error reading \"%s\": missing or invalid attribute '%s' in 'DiskSection' element, line %d"),
379	pcszPath,
380	pcszBad,
381	pelmDisk->getLineNumber());
382
383	// RTPrintf(" found disk: %s\n", d.strDiskId.c_str());
384	m->mapDisks[d.strDiskId] = d;
385	}
386
387	return S_OK;
388	}
389
390	/**
391	* Private helper method that handles network sections in the OVF XML.
392	* @param pcszPath Path spec of the XML file, for error messages.
393	* @param pSectionElem Section element for which this helper is getting called.
394	* @return
395	*/
396	HRESULT Appliance::HandleNetworkSection(const char *pcszPath,
397	const xml::Node *pSectionElem)
398	{
399	// contains "Disk" child elements
400	xml::NodesLoop loopNetworks(*pSectionElem, "Network");
401	const xml::Node *pelmNetwork;
402	while ((pelmNetwork = loopNetworks.forAllNodes()))
403	{
404	Network n;
405	if (!(pelmNetwork->getAttributeValue("name", n.strNetworkName)))
406	return setError(VBOX_E_FILE_ERROR,
407	tr("Error reading \"%s\": missing 'name' attribute in 'Network', line %d"),
408	pcszPath,
409	pelmNetwork->getLineNumber());
410
411	m->mapNetworks[n.strNetworkName] = n;
412	}
413
414	return S_OK;
415	}
416
417	/**
418	* Private helper method that handles a "VirtualSystem" element in the OVF XML.
419	*
420	* @param pcszPath
421	* @param pContentElem
422	* @return
423	*/
424	HRESULT Appliance::HandleVirtualSystemContent(const char *pcszPath,
425	const xml::Node *pelmVirtualSystem)
426	{
427	VirtualSystem d;
428
429	const xml::Node *pIdAttr = pelmVirtualSystem->findAttribute("type");
430	if (pIdAttr)
431	d.strName = pIdAttr->getValue();
432
433	xml::NodesLoop loop(*pelmVirtualSystem); // all child elements
434	const xml::Node *pelmThis;
435	while ((pelmThis = loop.forAllNodes()))
436	{
437	const char *pcszElemName = pelmThis->getName();
438	const xml::Node *pTypeAttr = pelmThis->findAttribute("type");
439	const char *pcszTypeAttr = (pTypeAttr) ? pTypeAttr->getValue() : "";
440
441	if (!strcmp(pcszElemName, "EulaSection"))
442	{
443	/* <EulaSection>
444	<Info ovf:msgid="6">License agreement for the Virtual System.</Info>
445	<License ovf:msgid="1">License terms can go in here.</License>
446	</EulaSection> */
447
448	const xml::Node pelmInfo, pelmLicense;
449	if ( ((pelmInfo = pelmThis->findChildElement("Info")))
450	&& ((pelmLicense = pelmThis->findChildElement("License")))
451	)
452	{
453	d.strLicenceInfo = pelmInfo->getValue();
454	d.strLicenceText = pelmLicense->getValue();
455	}
456	}
457	else if ( (!strcmp(pcszElemName, "VirtualHardwareSection"))
458	\|\| (!strcmp(pcszTypeAttr, "ovf:VirtualHardwareSection_Type"))
459	)
460	{
461	const xml::Node pelmSystem, pelmVirtualSystemType;
462	if ((pelmSystem = pelmThis->findChildElement("System")))
463	{
464	/* <System>
465	<vssd:Description>Description of the virtual hardware section.</vssd:Description>
466	<vssd:ElementName>vmware</vssd:ElementName>
467	<vssd:InstanceID>1</vssd:InstanceID>
468	<vssd:VirtualSystemIdentifier>MyLampService</vssd:VirtualSystemIdentifier>
469	<vssd:VirtualSystemType>vmx-4</vssd:VirtualSystemType>
470	</System>*/
471	if ((pelmVirtualSystemType = pelmSystem->findChildElement("VirtualSystemType")))
472	d.strVirtualSystemType = pelmVirtualSystemType->getValue();
473	}
474
475	xml::NodesLoop loopVirtualHardwareItems(*pelmThis, "Item"); // all "Item" child elements
476	const xml::Node *pelmItem;
477	while ((pelmItem = loopVirtualHardwareItems.forAllNodes()))
478	{
479	VirtualHardwareItem i;
480
481	i.ulLineNumber = pelmItem->getLineNumber();
482
483	xml::NodesLoop loopItemChildren(*pelmItem); // all child elements
484	const xml::Node *pelmItemChild;
485	while ((pelmItemChild = loopItemChildren.forAllNodes()))
486	{
487	const char *pcszItemChildName = pelmItemChild->getName();
488	if (!strcmp(pcszItemChildName, "Description"))
489	i.strDescription = pelmItemChild->getValue();
490	else if (!strcmp(pcszItemChildName, "Caption"))
491	i.strCaption = pelmItemChild->getValue();
492	else if (!strcmp(pcszItemChildName, "ElementName"))
493	i.strElementName = pelmItemChild->getValue();
494	else if ( (!strcmp(pcszItemChildName, "InstanceID"))
495	\|\| (!strcmp(pcszItemChildName, "InstanceId"))
496	)
497	pelmItemChild->copyValue(i.ulInstanceID);
498	else if (!strcmp(pcszItemChildName, "HostResource"))
499	i.strHostResource = pelmItemChild->getValue();
500	else if (!strcmp(pcszItemChildName, "ResourceType"))
501	{
502	int32_t iType; /** @todo how to fix correctly? (enum fun.) */
503	pelmItemChild->copyValue(iType);
504	i.resourceType = (OVFResourceType_T)iType;
505	}
506	else if (!strcmp(pcszItemChildName, "OtherResourceType"))
507	i.strOtherResourceType = pelmItemChild->getValue();
508	else if (!strcmp(pcszItemChildName, "ResourceSubType"))
509	i.strResourceSubType = pelmItemChild->getValue();
510	else if (!strcmp(pcszItemChildName, "AutomaticAllocation"))
511	i.fAutomaticAllocation = (!strcmp(pelmItemChild->getValue(), "true")) ? true : false;
512	else if (!strcmp(pcszItemChildName, "AutomaticDeallocation"))
513	i.fAutomaticDeallocation = (!strcmp(pelmItemChild->getValue(), "true")) ? true : false;
514	else if (!strcmp(pcszItemChildName, "Parent"))
515	pelmItemChild->copyValue(i.ulParent);
516	else if (!strcmp(pcszItemChildName, "Connection"))
517	i.strConnection = pelmItemChild->getValue();
518	else if (!strcmp(pcszItemChildName, "Address"))
519	i.strAddress = pelmItemChild->getValue();
520	else if (!strcmp(pcszItemChildName, "AddressOnParent"))
521	i.strAddressOnParent = pelmItemChild->getValue();
522	else if (!strcmp(pcszItemChildName, "AllocationUnits"))
523	i.strAllocationUnits = pelmItemChild->getValue();
524	else if (!strcmp(pcszItemChildName, "VirtualQuantity"))
525	pelmItemChild->copyValue(i.ullVirtualQuantity);
526	else if (!strcmp(pcszItemChildName, "Reservation"))
527	pelmItemChild->copyValue(i.ullReservation);
528	else if (!strcmp(pcszItemChildName, "Limit"))
529	pelmItemChild->copyValue(i.ullLimit);
530	else if (!strcmp(pcszItemChildName, "Weight"))
531	pelmItemChild->copyValue(i.ullWeight);
532	else if (!strcmp(pcszItemChildName, "ConsumerVisibility"))
533	i.strConsumerVisibility = pelmItemChild->getValue();
534	else if (!strcmp(pcszItemChildName, "MappingBehavior"))
535	i.strMappingBehavior = pelmItemChild->getValue();
536	else if (!strcmp(pcszItemChildName, "PoolID"))
537	i.strPoolID = pelmItemChild->getValue();
538	else if (!strcmp(pcszItemChildName, "BusNumber"))
539	pelmItemChild->copyValue(i.ulBusNumber);
540	else
541	return setError(VBOX_E_FILE_ERROR,
542	tr("Error reading \"%s\": unknown element \"%s\" under Item element, line %d"),
543	pcszPath,
544	pcszItemChildName,
545	i.ulLineNumber);
546	}
547
548	// store!
549	d.mapHardwareItems[i.ulInstanceID] = i;
550	}
551
552	HardwareItemsMap::const_iterator itH;
553
554	for (itH = d.mapHardwareItems.begin();
555	itH != d.mapHardwareItems.end();
556	++itH)
557	{
558	const VirtualHardwareItem &i = itH->second;
559
560	// do some analysis
561	switch (i.resourceType)
562	{
563	case OVFResourceType_Processor: // 3
564	/* <rasd:Caption>1 virtual CPU</rasd:Caption>
565	<rasd:Description>Number of virtual CPUs</rasd:Description>
566	<rasd:ElementName>virtual CPU</rasd:ElementName>
567	<rasd:InstanceID>1</rasd:InstanceID>
568	<rasd:ResourceType>3</rasd:ResourceType>
569	<rasd:VirtualQuantity>1</rasd:VirtualQuantity>*/
570	if (i.ullVirtualQuantity < UINT16_MAX)
571	d.cCPUs = (uint16_t)i.ullVirtualQuantity;
572	else
573	return setError(VBOX_E_FILE_ERROR,
574	tr("Error reading \"%s\": CPU count %RI64 is larger than %d, line %d"),
575	pcszPath,
576	i.ullVirtualQuantity,
577	UINT16_MAX,
578	i.ulLineNumber);
579	break;
580
581	case OVFResourceType_Memory: // 4
582	if ( (i.strAllocationUnits == "MegaBytes") // found in OVF created by OVF toolkit
583	\|\| (i.strAllocationUnits == "MB") // found in MS docs
584	\|\| (i.strAllocationUnits == "byte * 2^20") // suggested by OVF spec DSP0243 page 21
585	)
586	d.ullMemorySize = i.ullVirtualQuantity * 1024 * 1024;
587	else
588	return setError(VBOX_E_FILE_ERROR,
589	tr("Error reading \"%s\": Invalid allocation unit \"%s\" specified with memory size item, line %d"),
590	pcszPath,
591	i.strAllocationUnits.c_str(),
592	i.ulLineNumber);
593	break;
594
595	case OVFResourceType_IdeController: // 5 IdeController
596	{
597	/* <Item>
598	<rasd:Caption>ideController0</rasd:Caption>
599	<rasd:Description>IDE Controller</rasd:Description>
600	<rasd:InstanceId>5</rasd:InstanceId>
601	<rasd:ResourceType>5</rasd:ResourceType>
602	<rasd:Address>0</rasd:Address>
603	<rasd:BusNumber>0</rasd:BusNumber>
604	</Item> */
605	HardDiskController hdc;
606	hdc.idController = i.ulInstanceID;
607	hdc.controllerSystem = IDE;
608	hdc.strAddress = i.strAddress;
609	hdc.ulBusNumber = i.ulBusNumber;
610
611	d.mapControllers[i.ulInstanceID] = hdc;
612	}
613
614	case OVFResourceType_ParallelScsiHba: // 6 SCSI controller
615	{
616	/* <Item>
617	<rasd:Caption>SCSI Controller 0 - LSI Logic</rasd:Caption>
618	<rasd:Description>SCI Controller</rasd:Description>
619	<rasd:ElementName>SCSI controller</rasd:ElementName>
620	<rasd:InstanceID>4</rasd:InstanceID>
621	<rasd:ResourceSubType>LsiLogic</rasd:ResourceSubType>
622	<rasd:ResourceType>6</rasd:ResourceType>
623	</Item> */
624	HardDiskController hdc;
625	hdc.idController = i.ulInstanceID;
626	hdc.controllerSystem = SCSI;
627	hdc.strControllerType = i.strResourceSubType;
628
629	d.mapControllers[i.ulInstanceID] = hdc;
630	}
631	break;
632
633	case OVFResourceType_EthernetAdapter: // 10
634	{
635	/* <Item>
636	<rasd:AutomaticAllocation>true</rasd:AutomaticAllocation>
637	<rasd:Caption>Ethernet adapter on 'VM Network'</rasd:Caption>
638	<rasd:Connection>VM Network</rasd:Connection>
639	<rasd:Description>VM Network?</rasd:Description>
640	<rasd:ElementName>Ethernet adapter</rasd:ElementName>
641	<rasd:InstanceID>3</rasd:InstanceID>
642	<rasd:ResourceType>10</rasd:ResourceType>
643	</Item>
644
645	OVF spec DSP 0243 page 21:
646	"For an Ethernet adapter, this specifies the abstract network connection name
647	for the virtual machine. All Ethernet adapters that specify the same abstract
648	network connection name within an OVF package shall be deployed on the same
649	network. The abstract network connection name shall be listed in the NetworkSection
650	at the outermost envelope level." */
651
652	// make sure we have a matching NetworkSection/Network
653	NetworksMap::iterator it = m->mapNetworks.find(i.strConnection);
654	if (it == m->mapNetworks.end())
655	return setError(VBOX_E_FILE_ERROR,
656	tr("Error reading \"%s\": Invalid connection \"%s\"; cannot find matching NetworkSection/Network element, line %d"),
657	pcszPath,
658	i.strConnection.c_str(),
659	i.ulLineNumber);
660
661	d.llNetworkNames.push_back(i.strConnection);
662	}
663	break;
664
665	case OVFResourceType_HardDisk: // 17
666	{
667	/* <Item>
668	<rasd:Caption>Harddisk 1</rasd:Caption>
669	<rasd:Description>HD</rasd:Description>
670	<rasd:ElementName>Hard Disk</rasd:ElementName>
671	<rasd:HostResource>ovf://disk/lamp</rasd:HostResource>
672	<rasd:InstanceID>5</rasd:InstanceID>
673	<rasd:Parent>4</rasd:Parent>
674	<rasd:ResourceType>17</rasd:ResourceType>
675	</Item> */
676
677	// look up the hard disk controller element whose InstanceID equals our Parent;
678	// this is how the connection is specified in OVF
679	ControllersMap::const_iterator it = d.mapControllers.find(i.ulParent);
680	if (it == d.mapControllers.end())
681	return setError(VBOX_E_FILE_ERROR,
682	tr("Error reading \"%s\": Hard disk item with instance ID %d specifies invalid parent %d, line %d"),
683	pcszPath,
684	i.ulInstanceID,
685	i.ulParent,
686	i.ulLineNumber);
687	const HardDiskController &hdc = it->second;
688
689	VirtualDisk vd;
690	vd.idController = i.ulParent;
691	bool fFound = false;
692	// ovf://disk/lamp
693	// 12345678901234
694	if (i.strHostResource.substr(0, 11) == "ovf://disk/")
695	{
696	vd.strDiskId = i.strHostResource.substr(11);
697	if (m->mapDisks.find(vd.strDiskId) != m->mapDisks.end())
698	fFound = true;
699	}
700
701	if (!fFound)
702	return setError(VBOX_E_FILE_ERROR,
703	tr("Error reading \"%s\": Hard disk item with instance ID %d specifies invalid host resource \"%s\", line %d"),
704	pcszPath,
705	i.ulInstanceID,
706	i.strHostResource.c_str(),
707	i.ulLineNumber);
708
709	d.llVirtualDisks.push_back(vd);
710	}
711	break;
712	}
713	}
714	}
715	else if ( (!strcmp(pcszElemName, "OperatingSystemSection"))
716	\|\| (!strcmp(pcszTypeAttr, "ovf:OperatingSystemSection_Type"))
717	)
718	{
719	uint64_t cimos64;
720	if (!(pelmThis->getAttributeValue("id", cimos64)))
721	return setError(VBOX_E_FILE_ERROR,
722	tr("Error reading \"%s\": missing or invalid 'ovf:id' attribute in operating system section element, line %d"),
723	pcszPath,
724	pelmThis->getLineNumber());
725
726	d.cimos = (CIMOSType_T)cimos64;
727	}
728	}
729
730	// now create the virtual system
731	m->llVirtualSystems.push_back(d);
732
733	return S_OK;
734	}
735
736	// IAppliance public methods
737	////////////////////////////////////////////////////////////////////////////////
738
739	/**
740	* Appliance initializer.
741	*
742	* This loads the given appliance.
743	* @param
744	* @return
745	*/
746
747	HRESULT Appliance::init (VirtualBox *aVirtualBox, IN_BSTR &path)
748	{
749	HRESULT rc;
750
751	/* Enclose the state transition NotReady->InInit->Ready */
752	AutoInitSpan autoInitSpan(this);
753	AssertReturn (autoInitSpan.isOk(), E_FAIL);
754
755	/* Weakly reference to a VirtualBox object */
756	unconst (mVirtualBox) = aVirtualBox;
757
758	// initialize data
759	m = new Data;
760	m->bstrPath = path;
761
762	// see if we can handle this file; for now we insist it has an ".ovf" extension
763	Utf8Str utf8Path(path);
764	const char *pcszLastDot = strrchr(utf8Path, '.');
765	if ( (!pcszLastDot)
766	\|\| ( strcmp(pcszLastDot, ".ovf")
767	&& strcmp(pcszLastDot, ".OVF")
768	)
769	)
770	return setError(VBOX_E_FILE_ERROR,
771	tr("Appliance file must have .ovf extension"));
772
773	try
774	{
775	xml::XmlFileParser parser;
776	xml::Document doc;
777	parser.read(utf8Path.raw(),
778	doc);
779
780	const xml::Node *pRootElem = doc.getRootElement();
781	if (strcmp(pRootElem->getName(), "Envelope"))
782	return setError(VBOX_E_FILE_ERROR,
783	tr("Root element in OVF file must be \"Envelope\"."));
784
785	// OVF has the following rough layout:
786	/*
787	-- <References> .... files referenced from other parts of the file, such as VMDK images
788	-- Metadata, comprised of several section commands
789	-- virtual machines, either a single <VirtualSystem>, or a <VirtualSystemCollection>
790	-- optionally <Strings> for localization
791	*/
792
793	// get all "File" child elements of "References" section so we can look up files easily;
794	// first find the "References" sections so we can look up files
795	xml::NodesList listFileElements; // receives all /Envelope/References/File nodes
796	const xml::Node *pReferencesElem;
797	if ((pReferencesElem = pRootElem->findChildElement("References")))
798	pReferencesElem->getChildElements(listFileElements, "File");
799
800	// now go though the sections
801	if (!(SUCCEEDED(rc = LoopThruSections(utf8Path.raw(), pReferencesElem, pRootElem))))
802	return rc;
803	}
804	catch(xml::Error &x)
805	{
806	return setError(VBOX_E_FILE_ERROR,
807	x.what());
808	}
809
810	rc = construeAppliance();
811	if (FAILED (rc))
812	return rc;
813
814	/* Confirm a successful initialization */
815	autoInitSpan.setSucceeded();
816
817	return S_OK;
818	}
819
820	void Appliance::uninit()
821	{
822	delete m;
823	m = NULL;
824	}
825
826	STDMETHODIMP Appliance::COMGETTER(Path)(BSTR *aPath)
827	{
828	if (!aPath)
829	return E_POINTER;
830
831	AutoCaller autoCaller(this);
832	CheckComRCReturnRC(autoCaller.rc());
833
834	AutoReadLock alock(this);
835
836	m->bstrPath.cloneTo(aPath);
837
838	return S_OK;
839	}
840
841	STDMETHODIMP Appliance::GetDisks(ComSafeArrayOut(BSTR, aDisks), ULONG *cDisks)
842	{
843	CheckComArgOutSafeArrayPointerValid(aDisks);
844
845	AutoCaller autoCaller(this);
846	CheckComRCReturnRC(autoCaller.rc());
847
848	AutoReadLock alock(this);
849
850	size_t c = m->mapDisks.size();
851	com::SafeArray<BSTR> sfaDisks(c);
852
853	DiskImagesMap::const_iterator it;
854	size_t i = 0;
855	for (it = m->mapDisks.begin();
856	it != m->mapDisks.end();
857	++it, ++i)
858	{
859	// create a string representing this disk
860	const DiskImage &d = it->second;
861	char *psz = NULL;
862	RTStrAPrintf(&psz,
863	"%s\t"
864	"%RI64\t"
865	"%RI64\t"
866	"%s\t"
867	"%s\t"
868	"%RI64\t"
869	"%RI64\t"
870	"%s",
871	d.strDiskId.c_str(),
872	d.iCapacity,
873	d.iPopulatedSize,
874	d.strFormat.c_str(),
875	d.strHref.c_str(),
876	d.iSize,
877	d.iChunkSize,
878	d.strCompression.c_str());
879	Utf8Str utf(psz);
880	Bstr bstr(utf);
881	// push to safearray
882	bstr.cloneTo(&sfaDisks[i]);
883	RTStrFree(psz);
884	}
885
886	*cDisks = (ULONG)i;
887
888	sfaDisks.detachTo(ComSafeArrayOutArg(aDisks));
889
890	return S_OK;
891	}
892
893	STDMETHODIMP Appliance::COMGETTER(VirtualSystemDescriptions)(ComSafeArrayOut(IVirtualSystemDescription*, aVirtualSystemDescriptions))
894	{
895	CheckComArgOutSafeArrayPointerValid (aVirtualSystemDescriptions);
896
897	AutoCaller autoCaller (this);
898	CheckComRCReturnRC (autoCaller.rc());
899
900	AutoReadLock alock (this);
901
902	SafeIfaceArray<IVirtualSystemDescription> sfaVSD (m->virtualSystemDescriptions);
903	sfaVSD.detachTo (ComSafeArrayOutArg (aVirtualSystemDescriptions));
904
905	return S_OK;
906	}
907
908	STDMETHODIMP Appliance::ImportAppliance()
909	{
910	HRESULT rc = S_OK;
911
912	list<VirtualSystem>::const_iterator it;
913	list< ComObjPtr<VirtualSystemDescription> >::const_iterator it1;
914	/* Iterate through all appliances */
915	size_t i = 0;
916	for (it = m->llVirtualSystems.begin(),
917	it1 = m->virtualSystemDescriptions.begin();
918	it != m->llVirtualSystems.end();
919	++it, ++it1, ++i)
920	{
921	const VirtualSystem &vs = *it;
922	ComObjPtr<VirtualSystemDescription> vsd = (*it1);
923
924	/* Guest OS type */
925	list<VirtualSystemDescriptionEntry> vsdeOS = vsd->findByType (VirtualSystemDescriptionType_OS);
926	Assert (vsdeOS.size() == 1);
927	string osTypeVBox = vsdeOS.front().strFinalValue;
928
929	/* Now that we know the base system get our internal defaults based on that. */
930	IGuestOSType *osType = NULL;
931	rc = mVirtualBox->GetGuestOSType (Bstr (Utf8Str (osTypeVBox.c_str())), &osType);
932	ComAssertComRCThrowRC (rc);
933
934	/* Create the machine */
935	/* First get the name */
936	list<VirtualSystemDescriptionEntry> vsdeName = vsd->findByType (VirtualSystemDescriptionType_Name);
937	Assert (vsdeName.size() == 1);
938	string nameVBox = vsdeName.front().strFinalValue;
939	IMachine *newMachine = NULL;
940	rc = mVirtualBox->CreateMachine (Bstr (nameVBox.c_str()), Bstr (osTypeVBox.c_str()),
941	Bstr (), Guid(),
942	&newMachine);
943	ComAssertComRCThrowRC (rc);
944
945	/* CPU count (ignored for now) */
946	// list<VirtualSystemDescriptionEntry> vsdeCPU = vsd->findByType (VirtualSystemDescriptionType_CPU);
947
948	/* RAM */
949	list<VirtualSystemDescriptionEntry> vsdeRAM = vsd->findByType (VirtualSystemDescriptionType_Memory);
950	Assert (vsdeRAM.size() == 1);
951	string memoryVBox = vsdeRAM.front().strFinalValue;
952	uint32_t tt = RTStrToUInt32 (memoryVBox.c_str()) / _1M;
953
954	rc = newMachine->COMSETTER(MemorySize)(tt);
955	ComAssertComRCThrowRC (rc);
956
957	/* VRAM */
958	/* Get the recommended VRAM for this guest os type */
959	ULONG vramVBox;
960	rc = osType->COMGETTER(RecommendedVRAM) (&vramVBox);
961	ComAssertComRCThrowRC (rc);
962	/* Set the VRAM */
963	rc = newMachine->COMSETTER(VRAMSize) (vramVBox);
964	ComAssertComRCThrowRC (rc);
965
966	/* Change the network adapters */
967	list<VirtualSystemDescriptionEntry> vsdeNW = vsd->findByType (VirtualSystemDescriptionType_NetworkAdapter);
968	if (vsdeNW.size() == 0)
969	{
970	/* No network adapters, so we have to disable our default one */
971	INetworkAdapter *nwVBox = NULL;
972	rc = newMachine->GetNetworkAdapter (0, &nwVBox);
973	ComAssertComRCThrowRC (rc);
974	rc = nwVBox->COMSETTER(Enabled) (false);
975	ComAssertComRCThrowRC (rc);
976	}
977	else
978	{
979	list<VirtualSystemDescriptionEntry>::const_iterator nwIt;
980	size_t a = 0;
981	for (nwIt = vsdeNW.begin();
982	(nwIt != vsdeNW.end() && a < 9);
983	++nwIt, ++a)
984	{
985	string nwTypeVBox = nwIt->strFinalValue;
986	uint32_t tt1 = RTStrToUInt32 (nwTypeVBox.c_str());
987	INetworkAdapter *nwVBox = NULL;
988	rc = newMachine->GetNetworkAdapter ((ULONG)a, &nwVBox);
989	ComAssertComRCThrowRC (rc);
990	/* Enable the network card & set the adapter type */
991	/* NAT is set as default */
992	rc = nwVBox->COMSETTER(Enabled) (true);
993	ComAssertComRCThrowRC (rc);
994	rc = nwVBox->COMSETTER(AdapterType) (static_cast<NetworkAdapterType_T> (tt1));
995	ComAssertComRCThrowRC (rc);
996	}
997	}
998	/* Now its time to register the machine before we add any hard disks */
999	rc = mVirtualBox->RegisterMachine (newMachine);
1000	ComAssertComRCThrowRC (rc);
1001
1002	/* @todo: Unregister on failure */
1003	#if 0
1004	vbox.UnregisterMachine (machineId);
1005	if (vbox.isOk())
1006	mMachine.DeleteSettings();
1007	return false;
1008	#endif
1009	}
1010
1011	return S_OK;
1012	}
1013
1014	HRESULT Appliance::construeAppliance()
1015	{
1016	// @todo:
1017	// - Locking
1018	// - COM error handling
1019	// - don't use COM methods but the methods directly (faster, but needs appropriate locking of that objects itself (s. HardDisk2))
1020	// - Appropriate handle errors like not supported file formats
1021
1022	HRESULT rc = S_OK;
1023
1024	/* Clear any previous virtual system descriptions */
1025	// @todo: have the entries deleted also?
1026	m->virtualSystemDescriptions.clear();
1027
1028	/* We need the default path for storing disk images */
1029	ISystemProperties *systemProps = NULL;
1030	rc = mVirtualBox->COMGETTER(SystemProperties) (&systemProps);
1031	ComAssertComRCThrowRC (rc);
1032	BSTR defaultHardDiskLocation;
1033	rc = systemProps->COMGETTER(DefaultHardDiskFolder) (&defaultHardDiskLocation);
1034	ComAssertComRCThrowRC (rc);
1035
1036	list<VirtualSystem>::const_iterator it;
1037	/* Iterate through all appliances */
1038	for (it = m->llVirtualSystems.begin();
1039	it != m->llVirtualSystems.end();
1040	++it)
1041	{
1042	const VirtualSystem &vs = *it;
1043	ComObjPtr <VirtualSystemDescription> vsd;
1044	vsd.createObject();
1045	rc = vsd->init();
1046	ComAssertComRCThrowRC(rc);
1047
1048	string osTypeVBox = SchemaDefs_OSTypeId_Other;
1049	/* Guest OS type */
1050	switch (vs.cimos)
1051	{
1052	case CIMOSType_CIMOS_Unknown: // 0 - Unknown
1053	osTypeVBox = SchemaDefs_OSTypeId_Other;
1054	break;
1055
1056	case CIMOSType_CIMOS_OS2: // 12 - OS/2
1057	osTypeVBox = SchemaDefs_OSTypeId_OS2;
1058	break;
1059
1060	case CIMOSType_CIMOS_MSDOS: // 14 - MSDOS
1061	osTypeVBox = SchemaDefs_OSTypeId_DOS;
1062	break;
1063
1064	case CIMOSType_CIMOS_WIN3x: // 15 - WIN3x
1065	osTypeVBox = SchemaDefs_OSTypeId_Windows31;
1066	break;
1067
1068	case CIMOSType_CIMOS_WIN95: // 16 - WIN95
1069	osTypeVBox = SchemaDefs_OSTypeId_Windows95;
1070	break;
1071
1072	case CIMOSType_CIMOS_WIN98: // 17 - WIN98
1073	osTypeVBox = SchemaDefs_OSTypeId_Windows98;
1074	break;
1075
1076	case CIMOSType_CIMOS_WINNT: // 18 - WINNT
1077	osTypeVBox = SchemaDefs_OSTypeId_WindowsNT4;
1078	break;
1079
1080	case CIMOSType_CIMOS_NetWare: // 21 - NetWare
1081	case CIMOSType_CIMOS_NovellOES: // 86 - Novell OES
1082	osTypeVBox = SchemaDefs_OSTypeId_Netware;
1083	break;
1084
1085	case CIMOSType_CIMOS_Solaris: // 29 - Solaris
1086	case CIMOSType_CIMOS_SunOS: // 30 - SunOS
1087	osTypeVBox = SchemaDefs_OSTypeId_Solaris;
1088	break;
1089
1090	case CIMOSType_CIMOS_FreeBSD: // 42 - FreeBSD
1091	osTypeVBox = SchemaDefs_OSTypeId_FreeBSD;
1092	break;
1093
1094	case CIMOSType_CIMOS_NetBSD: // 43 - NetBSD
1095	osTypeVBox = SchemaDefs_OSTypeId_NetBSD;
1096	break;
1097
1098	case CIMOSType_CIMOS_QNX: // 48 - QNX
1099	osTypeVBox = SchemaDefs_OSTypeId_QNX;
1100	break;
1101
1102	case CIMOSType_CIMOS_Windows2000: // 58 - Windows 2000
1103	osTypeVBox = SchemaDefs_OSTypeId_Windows2000;
1104	break;
1105
1106	case CIMOSType_CIMOS_WindowsMe: // 63 - Windows (R) Me
1107	osTypeVBox = SchemaDefs_OSTypeId_WindowsMe;
1108	break;
1109
1110	case CIMOSType_CIMOS_OpenBSD: // 65 - OpenBSD
1111	osTypeVBox = SchemaDefs_OSTypeId_OpenBSD;
1112	break;
1113
1114	case CIMOSType_CIMOS_WindowsXP: // 67 - Windows XP
1115	case CIMOSType_CIMOS_WindowsXPEmbedded: // 72 - Windows XP Embedded
1116	case CIMOSType_CIMOS_WindowsEmbeddedforPointofService: // 75 - Windows Embedded for Point of Service
1117	osTypeVBox = SchemaDefs_OSTypeId_WindowsXP;
1118	break;
1119
1120	case CIMOSType_CIMOS_MicrosoftWindowsServer2003: // 69 - Microsoft Windows Server 2003
1121	osTypeVBox = SchemaDefs_OSTypeId_Windows2003;
1122	break;
1123
1124	case CIMOSType_CIMOS_MicrosoftWindowsServer2003_64: // 70 - Microsoft Windows Server 2003 64-Bit
1125	osTypeVBox = SchemaDefs_OSTypeId_Windows2003_64;
1126	break;
1127
1128	case CIMOSType_CIMOS_WindowsXP_64: // 71 - Windows XP 64-Bit
1129	osTypeVBox = SchemaDefs_OSTypeId_WindowsXP_64;
1130	break;
1131
1132	case CIMOSType_CIMOS_WindowsVista: // 73 - Windows Vista
1133	osTypeVBox = SchemaDefs_OSTypeId_WindowsVista;
1134	break;
1135
1136	case CIMOSType_CIMOS_WindowsVista_64: // 74 - Windows Vista 64-Bit
1137	osTypeVBox = SchemaDefs_OSTypeId_WindowsVista_64;
1138	break;
1139
1140	case CIMOSType_CIMOS_MicrosoftWindowsServer2008: // 76 - Microsoft Windows Server 2008
1141	osTypeVBox = SchemaDefs_OSTypeId_Windows2008;
1142	break;
1143
1144	case CIMOSType_CIMOS_MicrosoftWindowsServer2008_64: // 77 - Microsoft Windows Server 2008 64-Bit
1145	osTypeVBox = SchemaDefs_OSTypeId_Windows2008_64;
1146	break;
1147
1148	case CIMOSType_CIMOS_FreeBSD_64: // 78 - FreeBSD 64-Bit
1149	osTypeVBox = SchemaDefs_OSTypeId_FreeBSD_64;
1150	break;
1151
1152	case CIMOSType_CIMOS_RedHatEnterpriseLinux: // 79 - RedHat Enterprise Linux
1153	osTypeVBox = SchemaDefs_OSTypeId_RedHat;
1154	break;
1155
1156	case CIMOSType_CIMOS_RedHatEnterpriseLinux_64: // 80 - RedHat Enterprise Linux 64-Bit
1157	osTypeVBox = SchemaDefs_OSTypeId_RedHat_64;
1158	break;
1159
1160	case CIMOSType_CIMOS_Solaris_64: // 81 - Solaris 64-Bit
1161	osTypeVBox = SchemaDefs_OSTypeId_Solaris_64;
1162	break;
1163
1164	case CIMOSType_CIMOS_SUSE: // 82 - SUSE
1165	case CIMOSType_CIMOS_SLES: // 84 - SLES
1166	case CIMOSType_CIMOS_NovellLinuxDesktop: // 87 - Novell Linux Desktop
1167	osTypeVBox = SchemaDefs_OSTypeId_OpenSUSE;
1168	break;
1169
1170	case CIMOSType_CIMOS_SUSE_64: // 83 - SUSE 64-Bit
1171	case CIMOSType_CIMOS_SLES_64: // 85 - SLES 64-Bit
1172	osTypeVBox = SchemaDefs_OSTypeId_OpenSUSE_64;
1173	break;
1174
1175	case CIMOSType_CIMOS_LINUX: // 36 - LINUX
1176	case CIMOSType_CIMOS_SunJavaDesktopSystem: // 88 - Sun Java Desktop System
1177	case CIMOSType_CIMOS_TurboLinux: // 91 - TurboLinux
1178	osTypeVBox = SchemaDefs_OSTypeId_Linux;
1179	break;
1180
1181	// case CIMOSType_CIMOS_TurboLinux_64: // 92 - TurboLinux 64-Bit
1182	// case CIMOSType_CIMOS_Linux_64: // 101 - Linux 64-Bit
1183	// osTypeVBox = VBOXOSTYPE_Linux_x64;
1184	// break;
1185
1186	case CIMOSType_CIMOS_Mandriva: // 89 - Mandriva
1187	osTypeVBox = SchemaDefs_OSTypeId_Mandriva;
1188	break;
1189
1190	case CIMOSType_CIMOS_Mandriva_64: // 90 - Mandriva 64-Bit
1191	osTypeVBox = SchemaDefs_OSTypeId_Mandriva_64;
1192	break;
1193
1194	case CIMOSType_CIMOS_Ubuntu: // 93 - Ubuntu
1195	osTypeVBox = SchemaDefs_OSTypeId_Ubuntu;
1196	break;
1197
1198	case CIMOSType_CIMOS_Ubuntu_64: // 94 - Ubuntu 64-Bit
1199	osTypeVBox = SchemaDefs_OSTypeId_Ubuntu_64;
1200	break;
1201
1202	case CIMOSType_CIMOS_Debian: // 95 - Debian
1203	osTypeVBox = SchemaDefs_OSTypeId_Debian;
1204	break;
1205
1206	case CIMOSType_CIMOS_Debian_64: // 96 - Debian 64-Bit
1207	osTypeVBox = SchemaDefs_OSTypeId_Debian_64;
1208	break;
1209
1210	case CIMOSType_CIMOS_Linux_2_4_x: // 97 - Linux 2.4.x
1211	osTypeVBox = SchemaDefs_OSTypeId_Linux24;
1212	break;
1213
1214	case CIMOSType_CIMOS_Linux_2_4_x_64: // 98 - Linux 2.4.x 64-Bit
1215	osTypeVBox = SchemaDefs_OSTypeId_Linux24_64;
1216	break;
1217
1218	case CIMOSType_CIMOS_Linux_2_6_x: // 99 - Linux 2.6.x
1219	osTypeVBox = SchemaDefs_OSTypeId_Linux26;
1220	break;
1221
1222	case CIMOSType_CIMOS_Linux_2_6_x_64: // 100 - Linux 2.6.x 64-Bit
1223	osTypeVBox = SchemaDefs_OSTypeId_Linux26_64;
1224	break;
1225	default:
1226	{
1227	/* If we are here we have no clue what OS this should be. Set to
1228	* other type as default. */
1229	osTypeVBox = SchemaDefs_OSTypeId_Other;
1230	}
1231	}
1232	vsd->addEntry (VirtualSystemDescriptionType_OS, 0, toString<ULONG> (vs.cimos), osTypeVBox);
1233
1234	/* VM name */
1235	/* If the there isn't any name specified create a default one out of
1236	* the OS type */
1237	string nameVBox = vs.strName;
1238	if (nameVBox == "")
1239	nameVBox = osTypeVBox;
1240	/* @todo: make sure the name is unique (add some numbers if not) */
1241	searchUniqueVMName (nameVBox);
1242	vsd->addEntry(VirtualSystemDescriptionType_Name, 0, nameVBox, nameVBox);
1243
1244	/* Now that we know the base system get our internal defaults based on that. */
1245	IGuestOSType *osType = NULL;
1246	rc = mVirtualBox->GetGuestOSType (Bstr (Utf8Str (osTypeVBox.c_str())), &osType);
1247	ComAssertComRCThrowRC (rc);
1248
1249	/* CPU count */
1250	ULONG cpuCountVBox = vs.cCPUs;
1251	if (vs.cCPUs == 0)
1252	cpuCountVBox = 1;
1253	vsd->addEntry (VirtualSystemDescriptionType_CPU, 0, toString<ULONG> (vs.cCPUs), toString<ULONG> (cpuCountVBox));
1254
1255	/* RAM */
1256	uint64_t ullMemSizeVBox = vs.ullMemorySize; /** @todo r=bird/MSC: this will overflow at 4GB, use 64-bit type. */
1257	if (vs.ullMemorySize == 0)
1258	{
1259	/* If the RAM of the OVF is zero, use our predefined values */
1260	ULONG memSizeVBox2;
1261	rc = osType->COMGETTER(RecommendedRAM)(&memSizeVBox2);
1262	ComAssertComRCThrowRC (rc);
1263	/* VBox stores that in MByte */
1264	ullMemSizeVBox = memSizeVBox2 * _1M;
1265	}
1266	vsd->addEntry (VirtualSystemDescriptionType_Memory, 0, toString<uint64_t> (vs.ullMemorySize), toString<uint64_t> (ullMemSizeVBox));
1267
1268	/* Hard disk Controller */
1269	ControllersMap::const_iterator hdcIt;
1270	/* Iterate through all hard disk controllers */
1271	for (hdcIt = vs.mapControllers.begin();
1272	hdcIt != vs.mapControllers.end();
1273	++hdcIt)
1274	{
1275	HardDiskController hdc = hdcIt->second;
1276	switch (hdc.controllerSystem)
1277	{
1278	case IDE:
1279	{
1280	// @todo: figure out the IDE types
1281	/* Use PIIX4 as default */
1282	IDEControllerType_T hdcController = IDEControllerType_PIIX4;
1283	if (!RTStrICmp(hdc.strControllerType.c_str(), "PIIX3"))
1284	hdcController = IDEControllerType_PIIX3;
1285	else if (!RTStrICmp(hdc.strControllerType.c_str(), "PIIX4"))
1286	hdcController = IDEControllerType_PIIX4;
1287	vsd->addEntry (VirtualSystemDescriptionType_HarddiskControllerIDE, hdc.idController, hdc.strControllerType, toString<ULONG> (hdcController));
1288	break;
1289	}
1290	case SATA:
1291	{
1292	// @todo: figure out the SATA types
1293	/* We only support a plain AHCI controller, so use them always */
1294	vsd->addEntry (VirtualSystemDescriptionType_HarddiskControllerSATA, hdc.idController, hdc.strControllerType, "AHCI");
1295	break;
1296	}
1297	case SCSI:
1298	{
1299	string hdcController = "LsiLogic";
1300	// @todo: figure out the SCSI types
1301	if (!RTStrICmp(hdc.strControllerType.c_str(), "LsiLogic"))
1302	hdcController = "LsiLogic";
1303	else if (!RTStrICmp(hdc.strControllerType.c_str(), "BusLogic"))
1304	hdcController = "BusLogic";
1305	vsd->addEntry (VirtualSystemDescriptionType_HarddiskControllerSCSI, hdc.idController, hdc.strControllerType, hdcController);
1306	break;
1307	}
1308	}
1309	}
1310
1311	/* Hard disks */
1312	if (vs.llVirtualDisks.size() > 0)
1313	{
1314	// @todo:
1315	// - strHref could be empty (construct a new default file name)
1316	// - check that the filename is unique to vbox in any case
1317	list<VirtualDisk>::const_iterator hdIt;
1318	/* Iterate through all hard disks */
1319	for (hdIt = vs.llVirtualDisks.begin();
1320	hdIt != vs.llVirtualDisks.end();
1321	++hdIt)
1322	{
1323	VirtualDisk hd = *hdIt;
1324	/* Get the associated disk image */
1325	DiskImage di = m->mapDisks [hd.strDiskId];
1326	/* We have to check if we support this format */
1327	bool fSupported = false;
1328	// @todo:
1329	// - figure out all possible vmdk formats we also support
1330	// - figure out if there is a url specifier for vhd already
1331	// - we need a url specifier for the vdi format
1332	if (!RTStrICmp(di.strFormat.c_str(), "http://www.vmware.com/specifications/vmdk.html#sparse"))
1333	fSupported = true;
1334	/* enable compressed formats for the first tests also */
1335	else if (!RTStrICmp(di.strFormat.c_str(), "http://www.vmware.com/specifications/vmdk.html#compressed"))
1336	fSupported = true;
1337	if (fSupported)
1338	{
1339	/* Construct the path */
1340	string path = Utf8StrFmt ("%ls%c%s", defaultHardDiskLocation, RTPATH_DELIMITER, di.strHref.c_str()).raw();
1341	vsd->addEntry (VirtualSystemDescriptionType_Harddisk, hd.idController, di.strHref, path);
1342	}
1343	}
1344	}
1345
1346	/* Network Controller */
1347	// @todo: is there no hardware specified in the OVF-Format?
1348	if (vs.llNetworkNames.size() > 0)
1349	{
1350	/* Get the default network adapter type for the selected guest os */
1351	NetworkAdapterType_T nwAdapterVBox = NetworkAdapterType_Am79C970A;
1352	rc = osType->COMGETTER(AdapterType) (&nwAdapterVBox);
1353	ComAssertComRCThrowRC (rc);
1354	list<string>::const_iterator nwIt;
1355	/* Iterate through all abstract networks */
1356	for (nwIt = vs.llNetworkNames.begin();
1357	nwIt != vs.llNetworkNames.end();
1358	++nwIt)
1359	{
1360	// string nwController = *nwIt; // @todo: not used yet
1361	vsd->addEntry (VirtualSystemDescriptionType_NetworkAdapter, 0, "", toString<ULONG> (nwAdapterVBox));
1362	}
1363	}
1364	m->virtualSystemDescriptions.push_back (vsd);
1365	}
1366
1367	return S_OK;
1368	}
1369
1370	HRESULT Appliance::searchUniqueVMName (std::string& aName)
1371	{
1372	IMachine *machine = NULL;
1373	char *tmpName = RTStrDup (aName.c_str());
1374	int i = 1;
1375	/* @todo: Maybe to cost intensive; try to find a lighter way */
1376	while (mVirtualBox->FindMachine (Bstr (tmpName), &machine) != VBOX_E_OBJECT_NOT_FOUND)
1377	{
1378	RTStrFree (tmpName);
1379	RTStrAPrintf (&tmpName, "%s_%d", aName.c_str(), i);
1380	++i;
1381	}
1382	aName = tmpName;
1383	RTStrFree (tmpName);
1384
1385	return S_OK;
1386	}
1387
1388	// IVirtualSystemDescription constructor / destructor
1389	////////////////////////////////////////////////////////////////////////////////
1390
1391	DEFINE_EMPTY_CTOR_DTOR(VirtualSystemDescription)
1392	struct shutup3 {};
1393
1394	struct VirtualSystemDescription::Data
1395	{
1396	list<VirtualSystemDescriptionEntry> descriptions;
1397	};
1398
1399	HRESULT VirtualSystemDescription::init()
1400	{
1401	/* Enclose the state transition NotReady->InInit->Ready */
1402	AutoInitSpan autoInitSpan (this);
1403	AssertReturn (autoInitSpan.isOk(), E_FAIL);
1404
1405	/* Initialize data */
1406	m = new Data();
1407
1408	/* Confirm a successful initialization */
1409	autoInitSpan.setSucceeded();
1410
1411	return S_OK;
1412	}
1413
1414	void VirtualSystemDescription::uninit()
1415	{
1416	delete m;
1417	m = NULL;
1418	}
1419
1420	STDMETHODIMP VirtualSystemDescription::GetDescription (ComSafeArrayOut(VirtualSystemDescriptionType_T, aTypes),
1421	ComSafeArrayOut(ULONG, aRefs),
1422	ComSafeArrayOut(BSTR, aOrigValues),
1423	ComSafeArrayOut(BSTR, aAutoValues),
1424	ComSafeArrayOut(BSTR, aConfigurations))
1425	{
1426	if (ComSafeArrayOutIsNull (aTypes) \|\|
1427	ComSafeArrayOutIsNull (aRefs) \|\|
1428	ComSafeArrayOutIsNull (aOrigValues) \|\|
1429	ComSafeArrayOutIsNull (aAutoValues) \|\|
1430	ComSafeArrayOutIsNull (aConfigurations))
1431	return E_POINTER;
1432
1433	AutoCaller autoCaller (this);
1434	CheckComRCReturnRC (autoCaller.rc());
1435
1436	AutoReadLock alock (this);
1437
1438	ULONG c = (ULONG)m->descriptions.size();
1439	com::SafeArray<VirtualSystemDescriptionType_T> sfaTypes (c);
1440	com::SafeArray<ULONG> sfaRefs (c);
1441	com::SafeArray<BSTR> sfaOrigValues (c);
1442	com::SafeArray<BSTR> sfaAutoValues (c);
1443	com::SafeArray<BSTR> sfaConfigurations (c);
1444
1445	list<VirtualSystemDescriptionEntry>::const_iterator it;
1446	size_t i = 0;
1447	for (it = m->descriptions.begin();
1448	it != m->descriptions.end();
1449	++it, ++i)
1450	{
1451	VirtualSystemDescriptionEntry vsde = (*it);
1452	/* Types */
1453	sfaTypes [i] = vsde.type;
1454	/* Refs */
1455	sfaRefs [i] = vsde.ref;
1456	/* Original value */
1457	Bstr bstr = Utf8Str (vsde.strOriginalValue.c_str());
1458	bstr.cloneTo (&sfaOrigValues [i]);
1459	/* Auto value */
1460	bstr = Utf8Str (vsde.strAutoValue.c_str());
1461	bstr.cloneTo (&sfaAutoValues [i]);
1462	/* Configuration */
1463	bstr = Utf8Str (vsde.strConfiguration.c_str());
1464	bstr.cloneTo (&sfaConfigurations [i]);
1465	}
1466
1467	sfaTypes.detachTo (ComSafeArrayOutArg (aTypes));
1468	sfaRefs.detachTo (ComSafeArrayOutArg (aRefs));
1469	sfaOrigValues.detachTo (ComSafeArrayOutArg (aOrigValues));
1470	sfaAutoValues.detachTo (ComSafeArrayOutArg (aAutoValues));
1471	sfaConfigurations.detachTo (ComSafeArrayOutArg (aConfigurations));
1472
1473	return S_OK;
1474	}
1475
1476	STDMETHODIMP VirtualSystemDescription::SetFinalValues (ComSafeArrayIn (IN_BSTR, aFinalValues))
1477	{
1478	CheckComArgSafeArrayNotNull (aFinalValues);
1479
1480	AutoCaller autoCaller (this);
1481	CheckComRCReturnRC (autoCaller.rc());
1482
1483	AutoWriteLock alock (this);
1484
1485	com::SafeArray <IN_BSTR> values (ComSafeArrayInArg (aFinalValues));
1486	if (values.size() != m->descriptions.size())
1487	return E_INVALIDARG;
1488
1489	list<VirtualSystemDescriptionEntry>::const_iterator it;
1490	size_t i = 0;
1491	for (it = m->descriptions.begin();
1492	it != m->descriptions.end();
1493	++it, ++i)
1494	{
1495	VirtualSystemDescriptionEntry vsde = (*it);
1496	vsde.strFinalValue = Utf8Str (values [i]).raw();
1497	}
1498
1499	return S_OK;
1500	}
1501
1502	void VirtualSystemDescription::addEntry (VirtualSystemDescriptionType_T aType, ULONG aRef, std::string aOrigValue, std::string aAutoValue)
1503	{
1504	VirtualSystemDescriptionEntry vsde;
1505	vsde.type = aType;
1506	vsde.ref = aRef;
1507	vsde.strOriginalValue = aOrigValue;
1508	vsde.strAutoValue = aAutoValue;
1509	/* For now we add the auto value as final value also */
1510	vsde.strFinalValue = aAutoValue;
1511
1512	m->descriptions.push_back (vsde);
1513	}
1514
1515	list<VirtualSystemDescriptionEntry> VirtualSystemDescription::findByType (VirtualSystemDescriptionType_T aType)
1516	{
1517	list<VirtualSystemDescriptionEntry> vsd;
1518
1519	list<VirtualSystemDescriptionEntry>::const_iterator it;
1520	for (it = m->descriptions.begin();
1521	it != m->descriptions.end();
1522	++it)
1523	if (it->type == aType)
1524	vsd.push_back (*it);
1525
1526	return vsd;
1527	}
1528

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

source: vbox/trunk/src/VBox/Main/ApplianceImpl.cpp@ 16228

Download in other formats: