ApplianceImpl.cpp@ 19182

Last change on this file since 19182 was 19165, checked in by vboxsync, 16 years ago
Main-OVF: always use the VBox default network adapter if the OVF is written by VBox
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 191.5 KB

Line
1	/* $Id: ApplianceImpl.cpp 19165 2009-04-24 11:36:51Z 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 <VBox/param.h>
24	#include <iprt/stream.h>
25	#include <iprt/path.h>
26	#include <iprt/dir.h>
27	#include <iprt/file.h>
28
29	#include "ApplianceImpl.h"
30	#include "VirtualBoxImpl.h"
31	#include "GuestOSTypeImpl.h"
32	#include "ProgressImpl.h"
33	#include "MachineImpl.h"
34	#include "HostNetworkInterfaceImpl.h"
35
36	#include "Logging.h"
37
38	#include "VBox/xml.h"
39
40	using namespace std;
41
42	////////////////////////////////////////////////////////////////////////////////
43	//
44	// hardware definitions
45	//
46	////////////////////////////////////////////////////////////////////////////////
47
48	struct DiskImage
49	{
50	Utf8Str strDiskId; // value from DiskSection/Disk/@diskId
51	int64_t iCapacity; // value from DiskSection/Disk/@capacity;
52	// (maximum size for dynamic images, I guess; we always translate this to bytes)
53	int64_t iPopulatedSize; // optional value from DiskSection/Disk/@populatedSize
54	// (actual used size of disk, always in bytes; can be an estimate of used disk
55	// space, but cannot be larger than iCapacity; -1 if not set)
56	Utf8Str strFormat; // value from DiskSection/Disk/@format
57	// typically http://www.vmware.com/specifications/vmdk.html#sparse
58
59	// fields from /References/File; the spec says the file reference from disk can be empty,
60	// so in that case, strFilename will be empty, then a new disk should be created
61	Utf8Str strHref; // value from /References/File/@href (filename); if empty, then the remaining fields are ignored
62	int64_t iSize; // value from /References/File/@size (optional according to spec; then we set -1 here)
63	int64_t iChunkSize; // value from /References/File/@chunkSize (optional, unsupported)
64	Utf8Str strCompression; // value from /References/File/@compression (optional, can be "gzip" according to spec)
65	};
66
67	struct VirtualHardwareItem
68	{
69	Utf8Str strDescription;
70	Utf8Str strCaption;
71	Utf8Str strElementName;
72
73	uint32_t ulInstanceID;
74	uint32_t ulParent;
75
76	OVFResourceType_T resourceType;
77	Utf8Str strOtherResourceType;
78	Utf8Str strResourceSubType;
79
80	Utf8Str strHostResource; // "Abstractly specifies how a device shall connect to a resource on the deployment platform.
81	// Not all devices need a backing." Used with disk items, for which this references a virtual
82	// disk from the Disks section.
83	bool fAutomaticAllocation;
84	bool fAutomaticDeallocation;
85	Utf8Str strConnection; // "All Ethernet adapters that specify the same abstract network connection name within an OVF
86	// package shall be deployed on the same network. The abstract network connection name shall be
87	// listed in the NetworkSection at the outermost envelope level." We ignore this and only set up
88	// a network adapter depending on the network name.
89	Utf8Str strAddress; // "Device-specific. For an Ethernet adapter, this specifies the MAC address."
90	Utf8Str strAddressOnParent; // "For a device, this specifies its location on the controller."
91	Utf8Str strAllocationUnits; // "Specifies the units of allocation used. For example, “byte * 2^20”."
92	uint64_t ullVirtualQuantity; // "Specifies the quantity of resources presented. For example, “256”."
93	uint64_t ullReservation; // "Specifies the minimum quantity of resources guaranteed to be available."
94	uint64_t ullLimit; // "Specifies the maximum quantity of resources that will be granted."
95	uint64_t ullWeight; // "Specifies a relative priority for this allocation in relation to other allocations."
96
97	Utf8Str strConsumerVisibility;
98	Utf8Str strMappingBehavior;
99	Utf8Str strPoolID;
100	uint32_t ulBusNumber; // seen with IDE controllers, but not listed in OVF spec
101
102	uint32_t ulLineNumber; // line number of <Item> element in XML source; cached for error messages
103
104	VirtualHardwareItem()
105	: ulInstanceID(0), fAutomaticAllocation(false), fAutomaticDeallocation(false), ullVirtualQuantity(0), ullReservation(0), ullLimit(0), ullWeight(0), ulBusNumber(0), ulLineNumber(0)
106	{};
107	};
108
109	typedef map<Utf8Str, DiskImage> DiskImagesMap;
110
111	struct VirtualSystem;
112
113	typedef map<uint32_t, VirtualHardwareItem> HardwareItemsMap;
114
115	struct HardDiskController
116	{
117	uint32_t idController; // instance ID (Item/InstanceId); this gets referenced from HardDisk
118	enum ControllerSystemType { IDE, SATA, SCSI };
119	ControllerSystemType system; // one of IDE, SATA, SCSI
120	Utf8Str strControllerType; // controller subtype (Item/ResourceSubType); e.g. "LsiLogic"; can be empty (esp. for IDE)
121	Utf8Str strAddress; // for IDE
122	uint32_t ulBusNumber; // for IDE
123
124	HardDiskController()
125	: idController(0),
126	ulBusNumber(0)
127	{
128	}
129	};
130
131	typedef map<uint32_t, HardDiskController> ControllersMap;
132
133	struct VirtualDisk
134	{
135	uint32_t idController; // SCSI (or IDE) controller this disk is connected to;
136	// points into VirtualSystem.mapControllers
137	uint32_t ulAddressOnParent; // parsed strAddressOnParent of hardware item; will be 0 or 1 for IDE
138	// and possibly higher for disks attached to SCSI controllers (untested)
139	Utf8Str strDiskId; // if the hard disk has an ovf:/disk/<id> reference,
140	// this receives the <id> component; points to one of the
141	// references in Appliance::Data.mapDisks
142	};
143
144	typedef map<Utf8Str, VirtualDisk> VirtualDisksMap;
145
146	struct EthernetAdapter
147	{
148	Utf8Str strAdapterType; // "PCNet32" or "E1000" or whatever; from <rasd:ResourceSubType>
149	Utf8Str strNetworkName; // from <rasd:Connection>
150	};
151
152	typedef list<EthernetAdapter> EthernetAdaptersList;
153
154	struct VirtualSystem
155	{
156	Utf8Str strName; // copy of VirtualSystem/@id
157
158	Utf8Str strDescription; // copy of VirtualSystem/Info content
159
160	CIMOSType_T cimos;
161	Utf8Str strCimosDesc; // readable description of the cimos type in the case of cimos = 0/1/102
162	Utf8Str strVirtualSystemType; // generic hardware description; OVF says this can be something like "vmx-4" or "xen";
163	// VMware Workstation 6.5 is "vmx-07"
164
165	HardwareItemsMap mapHardwareItems; // map of virtual hardware items, sorted by unique instance ID
166
167	uint64_t ullMemorySize; // always in bytes, copied from llHardwareItems; default = 0 (unspecified)
168	uint16_t cCPUs; // no. of CPUs, copied from llHardwareItems; default = 1
169
170	EthernetAdaptersList llEthernetAdapters; // (one for each VirtualSystem/Item[@ResourceType=10]element)
171
172	ControllersMap mapControllers;
173	// list of hard disk controllers
174	// (one for each VirtualSystem/Item[@ResourceType=6] element with accumulated data from children)
175
176	VirtualDisksMap mapVirtualDisks;
177	// (one for each VirtualSystem/Item[@ResourceType=17] element with accumulated data from children)
178
179	bool fHasFloppyDrive; // true if there's a floppy item in mapHardwareItems
180	bool fHasCdromDrive; // true if there's a CD-ROM item in mapHardwareItems; ISO images are not yet supported by OVFtool
181	bool fHasUsbController; // true if there's a USB controller item in mapHardwareItems
182
183	Utf8Str strSoundCardType; // if not empty, then the system wants a soundcard; this then specifies the hardware;
184	// VMware Workstation 6.5 uses "ensoniq1371" for example
185
186	Utf8Str strLicenseText; // license info if any; receives contents of VirtualSystem/EulaSection/License
187
188	Utf8Str strProduct; // product info if any; receives contents of VirtualSystem/ProductSection/Product
189	Utf8Str strVendor; // product info if any; receives contents of VirtualSystem/ProductSection/Vendor
190	Utf8Str strVersion; // product info if any; receives contents of VirtualSystem/ProductSection/Version
191	Utf8Str strProductUrl; // product info if any; receives contents of VirtualSystem/ProductSection/ProductUrl
192	Utf8Str strVendorUrl; // product info if any; receives contents of VirtualSystem/ProductSection/VendorUrl
193
194	VirtualSystem()
195	: ullMemorySize(0), cCPUs(1), fHasFloppyDrive(false), fHasCdromDrive(false), fHasUsbController(false)
196	{
197	}
198	};
199
200	////////////////////////////////////////////////////////////////////////////////
201	//
202	// Appliance data definition
203	//
204	////////////////////////////////////////////////////////////////////////////////
205
206	// opaque private instance data of Appliance class
207	struct Appliance::Data
208	{
209	Utf8Str strPath; // file name last given to either read() or write()
210
211	DiskImagesMap mapDisks; // map of DiskImage structs, sorted by DiskImage.strDiskId
212
213	list<VirtualSystem> llVirtualSystems; // list of virtual systems, created by and valid after read()
214
215	list< ComObjPtr<VirtualSystemDescription> > virtualSystemDescriptions; //
216
217	list<Utf8Str> llWarnings;
218
219	ULONG ulWeightPerOperation; // for progress calculations
220	};
221
222	struct VirtualSystemDescription::Data
223	{
224	list<VirtualSystemDescriptionEntry> llDescriptions;
225	};
226
227	////////////////////////////////////////////////////////////////////////////////
228	//
229	// internal helpers
230	//
231	////////////////////////////////////////////////////////////////////////////////
232
233	static Utf8Str stripFilename(const Utf8Str &strFile)
234	{
235	Utf8Str str2(strFile);
236	RTPathStripFilename(str2.mutableRaw());
237	return str2;
238	}
239
240	static const struct
241	{
242	CIMOSType_T cim;
243	const char *pcszVbox;
244	}
245	g_osTypes[] =
246	{
247	{ CIMOSType_CIMOS_Unknown, SchemaDefs_OSTypeId_Other },
248	{ CIMOSType_CIMOS_OS2, SchemaDefs_OSTypeId_OS2 },
249	{ CIMOSType_CIMOS_MSDOS, SchemaDefs_OSTypeId_DOS },
250	{ CIMOSType_CIMOS_WIN3x, SchemaDefs_OSTypeId_Windows31 },
251	{ CIMOSType_CIMOS_WIN95, SchemaDefs_OSTypeId_Windows95 },
252	{ CIMOSType_CIMOS_WIN98, SchemaDefs_OSTypeId_Windows98 },
253	{ CIMOSType_CIMOS_WINNT, SchemaDefs_OSTypeId_WindowsNT4 },
254	{ CIMOSType_CIMOS_NetWare, SchemaDefs_OSTypeId_Netware },
255	{ CIMOSType_CIMOS_NovellOES, SchemaDefs_OSTypeId_Netware },
256	{ CIMOSType_CIMOS_Solaris, SchemaDefs_OSTypeId_OpenSolaris },
257	{ CIMOSType_CIMOS_SunOS, SchemaDefs_OSTypeId_OpenSolaris },
258	{ CIMOSType_CIMOS_FreeBSD, SchemaDefs_OSTypeId_FreeBSD },
259	{ CIMOSType_CIMOS_NetBSD, SchemaDefs_OSTypeId_NetBSD },
260	{ CIMOSType_CIMOS_QNX, SchemaDefs_OSTypeId_QNX },
261	{ CIMOSType_CIMOS_Windows2000, SchemaDefs_OSTypeId_Windows2000 },
262	{ CIMOSType_CIMOS_WindowsMe, SchemaDefs_OSTypeId_WindowsMe },
263	{ CIMOSType_CIMOS_OpenBSD, SchemaDefs_OSTypeId_OpenBSD },
264	{ CIMOSType_CIMOS_WindowsXP, SchemaDefs_OSTypeId_WindowsXP },
265	{ CIMOSType_CIMOS_WindowsXPEmbedded, SchemaDefs_OSTypeId_WindowsXP },
266	{ CIMOSType_CIMOS_WindowsEmbeddedforPointofService, SchemaDefs_OSTypeId_WindowsXP },
267	{ CIMOSType_CIMOS_MicrosoftWindowsServer2003, SchemaDefs_OSTypeId_Windows2003 },
268	{ CIMOSType_CIMOS_MicrosoftWindowsServer2003_64, SchemaDefs_OSTypeId_Windows2003_64 },
269	{ CIMOSType_CIMOS_WindowsXP_64, SchemaDefs_OSTypeId_WindowsXP_64 },
270	{ CIMOSType_CIMOS_WindowsVista, SchemaDefs_OSTypeId_WindowsVista },
271	{ CIMOSType_CIMOS_WindowsVista_64, SchemaDefs_OSTypeId_WindowsVista_64 },
272	{ CIMOSType_CIMOS_MicrosoftWindowsServer2008, SchemaDefs_OSTypeId_Windows2008 },
273	{ CIMOSType_CIMOS_MicrosoftWindowsServer2008_64, SchemaDefs_OSTypeId_Windows2008_64 },
274	{ CIMOSType_CIMOS_FreeBSD_64, SchemaDefs_OSTypeId_FreeBSD_64 },
275	{ CIMOSType_CIMOS_RedHatEnterpriseLinux, SchemaDefs_OSTypeId_RedHat },
276	{ CIMOSType_CIMOS_RedHatEnterpriseLinux_64, SchemaDefs_OSTypeId_RedHat_64 },
277	{ CIMOSType_CIMOS_Solaris_64, SchemaDefs_OSTypeId_OpenSolaris_64 },
278	{ CIMOSType_CIMOS_SUSE, SchemaDefs_OSTypeId_OpenSUSE },
279	{ CIMOSType_CIMOS_SLES, SchemaDefs_OSTypeId_OpenSUSE },
280	{ CIMOSType_CIMOS_NovellLinuxDesktop, SchemaDefs_OSTypeId_OpenSUSE },
281	{ CIMOSType_CIMOS_SUSE_64, SchemaDefs_OSTypeId_OpenSUSE_64 },
282	{ CIMOSType_CIMOS_SLES_64, SchemaDefs_OSTypeId_OpenSUSE_64 },
283	{ CIMOSType_CIMOS_LINUX, SchemaDefs_OSTypeId_Linux },
284	{ CIMOSType_CIMOS_SunJavaDesktopSystem, SchemaDefs_OSTypeId_Linux },
285	{ CIMOSType_CIMOS_TurboLinux, SchemaDefs_OSTypeId_Linux},
286
287	// { CIMOSType_CIMOS_TurboLinux_64, },
288
289	{ CIMOSType_CIMOS_Mandriva, SchemaDefs_OSTypeId_Mandriva },
290	{ CIMOSType_CIMOS_Mandriva_64, SchemaDefs_OSTypeId_Mandriva_64 },
291	{ CIMOSType_CIMOS_Ubuntu, SchemaDefs_OSTypeId_Ubuntu },
292	{ CIMOSType_CIMOS_Ubuntu_64, SchemaDefs_OSTypeId_Ubuntu_64 },
293	{ CIMOSType_CIMOS_Debian, SchemaDefs_OSTypeId_Debian },
294	{ CIMOSType_CIMOS_Debian_64, SchemaDefs_OSTypeId_Debian_64 },
295	{ CIMOSType_CIMOS_Linux_2_4_x, SchemaDefs_OSTypeId_Linux24 },
296	{ CIMOSType_CIMOS_Linux_2_4_x_64, SchemaDefs_OSTypeId_Linux24_64 },
297	{ CIMOSType_CIMOS_Linux_2_6_x, SchemaDefs_OSTypeId_Linux26 },
298	{ CIMOSType_CIMOS_Linux_2_6_x_64, SchemaDefs_OSTypeId_Linux26_64 },
299	{ CIMOSType_CIMOS_Linux_64, SchemaDefs_OSTypeId_Linux26_64 }
300	};
301
302	/* Pattern structure for matching the os type description field */
303	struct osTypePattern
304	{
305	const char *pcszPattern;
306	const char *pcszVbox;
307	};
308
309	/* These are the 32-Bit ones. They are sorted by priority. */
310	static const osTypePattern g_osTypesPattern[] =
311	{
312	{"Windows NT", SchemaDefs_OSTypeId_WindowsNT4},
313	{"Windows XP", SchemaDefs_OSTypeId_WindowsXP},
314	{"Windows 2000", SchemaDefs_OSTypeId_Windows2000},
315	{"Windows 2003", SchemaDefs_OSTypeId_Windows2003},
316	{"Windows Vista", SchemaDefs_OSTypeId_WindowsVista},
317	{"Windows 2008", SchemaDefs_OSTypeId_Windows2008},
318	{"SUSE", SchemaDefs_OSTypeId_OpenSUSE},
319	{"Novell", SchemaDefs_OSTypeId_OpenSUSE},
320	{"Red Hat", SchemaDefs_OSTypeId_RedHat},
321	{"Mandriva", SchemaDefs_OSTypeId_Mandriva},
322	{"Ubuntu", SchemaDefs_OSTypeId_Ubuntu},
323	{"Debian", SchemaDefs_OSTypeId_Debian},
324	{"QNX", SchemaDefs_OSTypeId_QNX},
325	{"Linux 2.4", SchemaDefs_OSTypeId_Linux24},
326	{"Linux 2.6", SchemaDefs_OSTypeId_Linux26},
327	{"Linux", SchemaDefs_OSTypeId_Linux},
328	{"OpenSolaris", SchemaDefs_OSTypeId_OpenSolaris},
329	{"Solaris", SchemaDefs_OSTypeId_OpenSolaris},
330	{"FreeBSD", SchemaDefs_OSTypeId_FreeBSD},
331	{"NetBSD", SchemaDefs_OSTypeId_NetBSD},
332	{"Windows 95", SchemaDefs_OSTypeId_Windows95},
333	{"Windows 98", SchemaDefs_OSTypeId_Windows98},
334	{"Windows Me", SchemaDefs_OSTypeId_WindowsMe},
335	{"Windows 3.", SchemaDefs_OSTypeId_Windows31},
336	{"DOS", SchemaDefs_OSTypeId_DOS},
337	{"OS2", SchemaDefs_OSTypeId_OS2}
338	};
339
340	/* These are the 64-Bit ones. They are sorted by priority. */
341	static const osTypePattern g_osTypesPattern64[] =
342	{
343	{"Windows XP", SchemaDefs_OSTypeId_WindowsXP_64},
344	{"Windows 2003", SchemaDefs_OSTypeId_Windows2003_64},
345	{"Windows Vista", SchemaDefs_OSTypeId_WindowsVista_64},
346	{"Windows 2008", SchemaDefs_OSTypeId_Windows2008_64},
347	{"SUSE", SchemaDefs_OSTypeId_OpenSUSE_64},
348	{"Novell", SchemaDefs_OSTypeId_OpenSUSE_64},
349	{"Red Hat", SchemaDefs_OSTypeId_RedHat_64},
350	{"Mandriva", SchemaDefs_OSTypeId_Mandriva_64},
351	{"Ubuntu", SchemaDefs_OSTypeId_Ubuntu_64},
352	{"Debian", SchemaDefs_OSTypeId_Debian_64},
353	{"Linux 2.4", SchemaDefs_OSTypeId_Linux24_64},
354	{"Linux 2.6", SchemaDefs_OSTypeId_Linux26_64},
355	{"Linux", SchemaDefs_OSTypeId_Linux26_64},
356	{"OpenSolaris", SchemaDefs_OSTypeId_OpenSolaris_64},
357	{"Solaris", SchemaDefs_OSTypeId_OpenSolaris_64},
358	{"FreeBSD", SchemaDefs_OSTypeId_FreeBSD_64},
359	};
360
361	/**
362	* Private helper func that suggests a VirtualBox guest OS type
363	* for the given OVF operating system type.
364	* @param osTypeVBox
365	* @param c
366	* @param cStr
367	*/
368	static void convertCIMOSType2VBoxOSType(Utf8Str &strType, CIMOSType_T c, const Utf8Str &cStr)
369	{
370	/* First check if the type is other/other_64 */
371	if (c == CIMOSType_CIMOS_Other)
372	{
373	for (size_t i=0; i < RT_ELEMENTS(g_osTypesPattern); ++i)
374	if (cStr.contains (g_osTypesPattern[i].pcszPattern, Utf8Str::CaseInsensitive))
375	{
376	strType = g_osTypesPattern[i].pcszVbox;
377	return;
378	}
379	}
380	else if (c == CIMOSType_CIMOS_Other_64)
381	{
382	for (size_t i=0; i < RT_ELEMENTS(g_osTypesPattern64); ++i)
383	if (cStr.contains (g_osTypesPattern64[i].pcszPattern, Utf8Str::CaseInsensitive))
384	{
385	strType = g_osTypesPattern64[i].pcszVbox;
386	return;
387	}
388	}
389
390	for (size_t i = 0; i < RT_ELEMENTS(g_osTypes); ++i)
391	{
392	if (c == g_osTypes[i].cim)
393	{
394	strType = g_osTypes[i].pcszVbox;
395	return;
396	}
397	}
398
399	strType = SchemaDefs_OSTypeId_Other;
400	}
401
402	/**
403	* Private helper func that suggests a VirtualBox guest OS type
404	* for the given OVF operating system type.
405	* @param osTypeVBox
406	* @param c
407	*/
408	static CIMOSType_T convertVBoxOSType2CIMOSType(const char *pcszVbox)
409	{
410	for (size_t i = 0; i < RT_ELEMENTS(g_osTypes); ++i)
411	{
412	if (!RTStrICmp(pcszVbox, g_osTypes[i].pcszVbox))
413	return g_osTypes[i].cim;
414	}
415
416	return CIMOSType_CIMOS_Other;
417	}
418
419	////////////////////////////////////////////////////////////////////////////////
420	//
421	// IVirtualBox public methods
422	//
423	////////////////////////////////////////////////////////////////////////////////
424
425	// This code is here so we won't have to include the appliance headers in the
426	// IVirtualBox implementation.
427
428	/**
429	* Implementation for IVirtualBox::createAppliance.
430	*
431	* @param anAppliance IAppliance object created if S_OK is returned.
432	* @return S_OK or error.
433	*/
434	STDMETHODIMP VirtualBox::CreateAppliance(IAppliance** anAppliance)
435	{
436	HRESULT rc;
437
438	ComObjPtr<Appliance> appliance;
439	appliance.createObject();
440	rc = appliance->init(this);
441
442	if (SUCCEEDED(rc))
443	appliance.queryInterfaceTo(anAppliance);
444
445	return rc;
446	}
447
448	////////////////////////////////////////////////////////////////////////////////
449	//
450	// Appliance constructor / destructor
451	//
452	////////////////////////////////////////////////////////////////////////////////
453
454	DEFINE_EMPTY_CTOR_DTOR(Appliance)
455	struct shutup {};
456
457	/**
458	* Appliance COM initializer.
459	* @param
460	* @return
461	*/
462
463	HRESULT Appliance::init(VirtualBox *aVirtualBox)
464	{
465	/* Enclose the state transition NotReady->InInit->Ready */
466	AutoInitSpan autoInitSpan(this);
467	AssertReturn(autoInitSpan.isOk(), E_FAIL);
468
469	/* Weak reference to a VirtualBox object */
470	unconst(mVirtualBox) = aVirtualBox;
471
472	// initialize data
473	m = new Data;
474
475	/* Confirm a successful initialization */
476	autoInitSpan.setSucceeded();
477
478	return S_OK;
479	}
480
481	/**
482	* Appliance COM uninitializer.
483	* @return
484	*/
485	void Appliance::uninit()
486	{
487	delete m;
488	m = NULL;
489	}
490
491	////////////////////////////////////////////////////////////////////////////////
492	//
493	// Appliance private methods
494	//
495	////////////////////////////////////////////////////////////////////////////////
496
497	/**
498	* Private helper method that goes thru the elements of the given "current" element in the OVF XML
499	* and handles the contained child elements (which can be "Section" or "Content" elements).
500	*
501	* @param pcszPath Path spec of the XML file, for error messages.
502	* @param pReferencesElement "References" element from OVF, for looking up file specifications; can be NULL if no such element is present.
503	* @param pCurElem Element whose children are to be analyzed here.
504	* @return
505	*/
506	HRESULT Appliance::LoopThruSections(const char *pcszPath,
507	const xml::ElementNode *pReferencesElem,
508	const xml::ElementNode *pCurElem)
509	{
510	HRESULT rc;
511
512	xml::NodesLoop loopChildren(*pCurElem);
513	const xml::ElementNode *pElem;
514	while ((pElem = loopChildren.forAllNodes()))
515	{
516	const char *pcszElemName = pElem->getName();
517	const char *pcszTypeAttr = "";
518	const xml::AttributeNode *pTypeAttr;
519	if ((pTypeAttr = pElem->findAttribute("type")))
520	pcszTypeAttr = pTypeAttr->getValue();
521
522	if ( (!strcmp(pcszElemName, "DiskSection"))
523	\|\| ( (!strcmp(pcszElemName, "Section"))
524	&& (!strcmp(pcszTypeAttr, "ovf:DiskSection_Type"))
525	)
526	)
527	{
528	if (!(SUCCEEDED((rc = HandleDiskSection(pcszPath, pReferencesElem, pElem)))))
529	return rc;
530	}
531	else if ( (!strcmp(pcszElemName, "NetworkSection"))
532	\|\| ( (!strcmp(pcszElemName, "Section"))
533	&& (!strcmp(pcszTypeAttr, "ovf:NetworkSection_Type"))
534	)
535	)
536	{
537	if (!(SUCCEEDED((rc = HandleNetworkSection(pcszPath, pElem)))))
538	return rc;
539	}
540	else if ( (!strcmp(pcszElemName, "DeploymentOptionSection")))
541	{
542	// TODO
543	}
544	else if ( (!strcmp(pcszElemName, "Info")))
545	{
546	// child of VirtualSystemCollection -- TODO
547	}
548	else if ( (!strcmp(pcszElemName, "ResourceAllocationSection")))
549	{
550	// child of VirtualSystemCollection -- TODO
551	}
552	else if ( (!strcmp(pcszElemName, "StartupSection")))
553	{
554	// child of VirtualSystemCollection -- TODO
555	}
556	else if ( (!strcmp(pcszElemName, "VirtualSystem"))
557	\|\| ( (!strcmp(pcszElemName, "Content"))
558	&& (!strcmp(pcszTypeAttr, "ovf:VirtualSystem_Type"))
559	)
560	)
561	{
562	if (!(SUCCEEDED((rc = HandleVirtualSystemContent(pcszPath, pElem)))))
563	return rc;
564	}
565	else if ( (!strcmp(pcszElemName, "VirtualSystemCollection"))
566	\|\| ( (!strcmp(pcszElemName, "Content"))
567	&& (!strcmp(pcszTypeAttr, "ovf:VirtualSystemCollection_Type"))
568	)
569	)
570	{
571	// TODO ResourceAllocationSection
572
573	// recurse for this, since it has VirtualSystem elements as children
574	if (!(SUCCEEDED((rc = LoopThruSections(pcszPath, pReferencesElem, pElem)))))
575	return rc;
576	}
577	}
578
579	return S_OK;
580	}
581
582	/**
583	* Private helper method that handles disk sections in the OVF XML.
584	* Gets called indirectly from IAppliance::read().
585	*
586	* @param pcszPath Path spec of the XML file, for error messages.
587	* @param pReferencesElement "References" element from OVF, for looking up file specifications; can be NULL if no such element is present.
588	* @param pSectionElem Section element for which this helper is getting called.
589	* @return
590	*/
591	HRESULT Appliance::HandleDiskSection(const char *pcszPath,
592	const xml::ElementNode *pReferencesElem,
593	const xml::ElementNode *pSectionElem)
594	{
595	// contains "Disk" child elements
596	xml::NodesLoop loopDisks(*pSectionElem, "Disk");
597	const xml::ElementNode *pelmDisk;
598	while ((pelmDisk = loopDisks.forAllNodes()))
599	{
600	DiskImage d;
601	const char *pcszBad = NULL;
602	if (!(pelmDisk->getAttributeValue("diskId", d.strDiskId)))
603	pcszBad = "diskId";
604	else if (!(pelmDisk->getAttributeValue("format", d.strFormat)))
605	pcszBad = "format";
606	else if (!(pelmDisk->getAttributeValue("capacity", d.iCapacity)))
607	pcszBad = "capacity";
608	else
609	{
610	if (!(pelmDisk->getAttributeValue("populatedSize", d.iPopulatedSize)))
611	// optional
612	d.iPopulatedSize = -1;
613
614	Utf8Str strFileRef;
615	if (pelmDisk->getAttributeValue("fileRef", strFileRef)) // optional
616	{
617	// look up corresponding /References/File nodes (list built above)
618	const xml::ElementNode *pFileElem;
619	if ( pReferencesElem
620	&& ((pFileElem = pReferencesElem->findChildElementFromId(strFileRef.c_str())))
621	)
622	{
623	// copy remaining values from file node then
624	const char *pcszBadInFile = NULL;
625	if (!(pFileElem->getAttributeValue("href", d.strHref)))
626	pcszBadInFile = "href";
627	else if (!(pFileElem->getAttributeValue("size", d.iSize)))
628	d.iSize = -1; // optional
629	// if (!(pFileElem->getAttributeValue("size", d.iChunkSize))) TODO
630	d.iChunkSize = -1; // optional
631	pFileElem->getAttributeValue("compression", d.strCompression);
632
633	if (pcszBadInFile)
634	return setError(VBOX_E_FILE_ERROR,
635	tr("Error reading \"%s\": missing or invalid attribute '%s' in 'File' element, line %d"),
636	pcszPath,
637	pcszBadInFile,
638	pFileElem->getLineNumber());
639	}
640	else
641	return setError(VBOX_E_FILE_ERROR,
642	tr("Error reading \"%s\": cannot find References/File element for ID '%s' referenced by 'Disk' element, line %d"),
643	pcszPath,
644	strFileRef.c_str(),
645	pelmDisk->getLineNumber());
646	}
647	}
648
649	if (pcszBad)
650	return setError(VBOX_E_FILE_ERROR,
651	tr("Error reading \"%s\": missing or invalid attribute '%s' in 'DiskSection' element, line %d"),
652	pcszPath,
653	pcszBad,
654	pelmDisk->getLineNumber());
655
656	m->mapDisks[d.strDiskId] = d;
657	}
658
659	return S_OK;
660	}
661
662	/**
663	* Private helper method that handles network sections in the OVF XML.
664	* Gets called indirectly from IAppliance::read().
665	*
666	* @param pcszPath Path spec of the XML file, for error messages.
667	* @param pSectionElem Section element for which this helper is getting called.
668	* @return
669	*/
670	HRESULT Appliance::HandleNetworkSection(const char * /* pcszPath */,
671	const xml::ElementNode * /* pSectionElem */)
672	{
673	// we ignore network sections for now
674
675	// xml::NodesLoop loopNetworks(*pSectionElem, "Network");
676	// const xml::Node *pelmNetwork;
677	// while ((pelmNetwork = loopNetworks.forAllNodes()))
678	// {
679	// Network n;
680	// if (!(pelmNetwork->getAttributeValue("name", n.strNetworkName)))
681	// return setError(VBOX_E_FILE_ERROR,
682	// tr("Error reading \"%s\": missing 'name' attribute in 'Network', line %d"),
683	// pcszPath,
684	// pelmNetwork->getLineNumber());
685	//
686	// m->mapNetworks[n.strNetworkName] = n;
687	// }
688
689	return S_OK;
690	}
691
692	/**
693	* Private helper method that handles a "VirtualSystem" element in the OVF XML.
694	* Gets called indirectly from IAppliance::read().
695	*
696	* @param pcszPath
697	* @param pContentElem
698	* @return
699	*/
700	HRESULT Appliance::HandleVirtualSystemContent(const char *pcszPath,
701	const xml::ElementNode *pelmVirtualSystem)
702	{
703	VirtualSystem vsys;
704
705	const xml::AttributeNode *pIdAttr = pelmVirtualSystem->findAttribute("id");
706	if (pIdAttr)
707	vsys.strName = pIdAttr->getValue();
708
709	xml::NodesLoop loop(*pelmVirtualSystem); // all child elements
710	const xml::ElementNode *pelmThis;
711	while ((pelmThis = loop.forAllNodes()))
712	{
713	const char *pcszElemName = pelmThis->getName();
714	const xml::AttributeNode *pTypeAttr = pelmThis->findAttribute("type");
715	const char *pcszTypeAttr = (pTypeAttr) ? pTypeAttr->getValue() : "";
716
717	if ( (!strcmp(pcszElemName, "EulaSection"))
718	\|\| (!strcmp(pcszTypeAttr, "ovf:EulaSection_Type"))
719	)
720	{
721	/* <EulaSection>
722	<Info ovf:msgid="6">License agreement for the Virtual System.</Info>
723	<License ovf:msgid="1">License terms can go in here.</License>
724	</EulaSection> */
725
726	const xml::ElementNode *pelmLicense;
727	if ((pelmLicense = pelmThis->findChildElement("License")))
728	vsys.strLicenseText = pelmLicense->getValue();
729	}
730	if ( (!strcmp(pcszElemName, "ProductSection"))
731	\|\| (!strcmp(pcszTypeAttr, "ovf:ProductSection_Type"))
732	)
733	{
734	/* <Section ovf:required="false" xsi:type="ovf:ProductSection_Type">
735	<Info>Meta-information about the installed software</Info>
736	<Product>VAtest</Product>
737	<Vendor>SUN Microsystems</Vendor>
738	<Version>10.0</Version>
739	<ProductUrl>http://blogs.sun.com/VirtualGuru</ProductUrl>
740	<VendorUrl>http://www.sun.com</VendorUrl>
741	</Section> */
742	const xml::ElementNode *pelmProduct;
743	if ((pelmProduct = pelmThis->findChildElement("Product")))
744	vsys.strProduct = pelmProduct->getValue();
745	const xml::ElementNode *pelmVendor;
746	if ((pelmVendor = pelmThis->findChildElement("Vendor")))
747	vsys.strVendor = pelmVendor->getValue();
748	const xml::ElementNode *pelmVersion;
749	if ((pelmVersion = pelmThis->findChildElement("Version")))
750	vsys.strVersion = pelmVersion->getValue();
751	const xml::ElementNode *pelmProductUrl;
752	if ((pelmProductUrl = pelmThis->findChildElement("ProductUrl")))
753	vsys.strProductUrl = pelmProductUrl->getValue();
754	const xml::ElementNode *pelmVendorUrl;
755	if ((pelmVendorUrl = pelmThis->findChildElement("VendorUrl")))
756	vsys.strVendorUrl = pelmVendorUrl->getValue();
757	}
758	else if ( (!strcmp(pcszElemName, "VirtualHardwareSection"))
759	\|\| (!strcmp(pcszTypeAttr, "ovf:VirtualHardwareSection_Type"))
760	)
761	{
762	const xml::ElementNode pelmSystem, pelmVirtualSystemType;
763	if ((pelmSystem = pelmThis->findChildElement("System")))
764	{
765	/* <System>
766	<vssd:Description>Description of the virtual hardware section.</vssd:Description>
767	<vssd:ElementName>vmware</vssd:ElementName>
768	<vssd:InstanceID>1</vssd:InstanceID>
769	<vssd:VirtualSystemIdentifier>MyLampService</vssd:VirtualSystemIdentifier>
770	<vssd:VirtualSystemType>vmx-4</vssd:VirtualSystemType>
771	</System>*/
772	if ((pelmVirtualSystemType = pelmSystem->findChildElement("VirtualSystemType")))
773	vsys.strVirtualSystemType = pelmVirtualSystemType->getValue();
774	}
775
776	xml::NodesLoop loopVirtualHardwareItems(*pelmThis, "Item"); // all "Item" child elements
777	const xml::ElementNode *pelmItem;
778	while ((pelmItem = loopVirtualHardwareItems.forAllNodes()))
779	{
780	VirtualHardwareItem i;
781
782	i.ulLineNumber = pelmItem->getLineNumber();
783
784	xml::NodesLoop loopItemChildren(*pelmItem); // all child elements
785	const xml::ElementNode *pelmItemChild;
786	while ((pelmItemChild = loopItemChildren.forAllNodes()))
787	{
788	const char *pcszItemChildName = pelmItemChild->getName();
789	if (!strcmp(pcszItemChildName, "Description"))
790	i.strDescription = pelmItemChild->getValue();
791	else if (!strcmp(pcszItemChildName, "Caption"))
792	i.strCaption = pelmItemChild->getValue();
793	else if (!strcmp(pcszItemChildName, "ElementName"))
794	i.strElementName = pelmItemChild->getValue();
795	else if ( (!strcmp(pcszItemChildName, "InstanceID"))
796	\|\| (!strcmp(pcszItemChildName, "InstanceId"))
797	)
798	pelmItemChild->copyValue(i.ulInstanceID);
799	else if (!strcmp(pcszItemChildName, "HostResource"))
800	i.strHostResource = pelmItemChild->getValue();
801	else if (!strcmp(pcszItemChildName, "ResourceType"))
802	{
803	uint32_t ulType;
804	pelmItemChild->copyValue(ulType);
805	i.resourceType = (OVFResourceType_T)ulType;
806	}
807	else if (!strcmp(pcszItemChildName, "OtherResourceType"))
808	i.strOtherResourceType = pelmItemChild->getValue();
809	else if (!strcmp(pcszItemChildName, "ResourceSubType"))
810	i.strResourceSubType = pelmItemChild->getValue();
811	else if (!strcmp(pcszItemChildName, "AutomaticAllocation"))
812	i.fAutomaticAllocation = (!strcmp(pelmItemChild->getValue(), "true")) ? true : false;
813	else if (!strcmp(pcszItemChildName, "AutomaticDeallocation"))
814	i.fAutomaticDeallocation = (!strcmp(pelmItemChild->getValue(), "true")) ? true : false;
815	else if (!strcmp(pcszItemChildName, "Parent"))
816	pelmItemChild->copyValue(i.ulParent);
817	else if (!strcmp(pcszItemChildName, "Connection"))
818	i.strConnection = pelmItemChild->getValue();
819	else if (!strcmp(pcszItemChildName, "Address"))
820	i.strAddress = pelmItemChild->getValue();
821	else if (!strcmp(pcszItemChildName, "AddressOnParent"))
822	i.strAddressOnParent = pelmItemChild->getValue();
823	else if (!strcmp(pcszItemChildName, "AllocationUnits"))
824	i.strAllocationUnits = pelmItemChild->getValue();
825	else if (!strcmp(pcszItemChildName, "VirtualQuantity"))
826	pelmItemChild->copyValue(i.ullVirtualQuantity);
827	else if (!strcmp(pcszItemChildName, "Reservation"))
828	pelmItemChild->copyValue(i.ullReservation);
829	else if (!strcmp(pcszItemChildName, "Limit"))
830	pelmItemChild->copyValue(i.ullLimit);
831	else if (!strcmp(pcszItemChildName, "Weight"))
832	pelmItemChild->copyValue(i.ullWeight);
833	else if (!strcmp(pcszItemChildName, "ConsumerVisibility"))
834	i.strConsumerVisibility = pelmItemChild->getValue();
835	else if (!strcmp(pcszItemChildName, "MappingBehavior"))
836	i.strMappingBehavior = pelmItemChild->getValue();
837	else if (!strcmp(pcszItemChildName, "PoolID"))
838	i.strPoolID = pelmItemChild->getValue();
839	else if (!strcmp(pcszItemChildName, "BusNumber"))
840	pelmItemChild->copyValue(i.ulBusNumber);
841	else
842	return setError(VBOX_E_FILE_ERROR,
843	tr("Error reading \"%s\": unknown element \"%s\" under Item element, line %d"),
844	pcszPath,
845	pcszItemChildName,
846	i.ulLineNumber);
847	}
848
849	// store!
850	vsys.mapHardwareItems[i.ulInstanceID] = i;
851	}
852
853	// now go thru all hardware items and handle them according to their type;
854	// in this first loop we handle all items _except_ hard disk images,
855	// which we'll handle in a second loop below
856	HardwareItemsMap::const_iterator itH;
857	for (itH = vsys.mapHardwareItems.begin();
858	itH != vsys.mapHardwareItems.end();
859	++itH)
860	{
861	const VirtualHardwareItem &i = itH->second;
862
863	// do some analysis
864	switch (i.resourceType)
865	{
866	case OVFResourceType_Processor: // 3
867	/* <rasd:Caption>1 virtual CPU</rasd:Caption>
868	<rasd:Description>Number of virtual CPUs</rasd:Description>
869	<rasd:ElementName>virtual CPU</rasd:ElementName>
870	<rasd:InstanceID>1</rasd:InstanceID>
871	<rasd:ResourceType>3</rasd:ResourceType>
872	<rasd:VirtualQuantity>1</rasd:VirtualQuantity>*/
873	if (i.ullVirtualQuantity < UINT16_MAX)
874	vsys.cCPUs = (uint16_t)i.ullVirtualQuantity;
875	else
876	return setError(VBOX_E_FILE_ERROR,
877	tr("Error reading \"%s\": CPU count %RI64 is larger than %d, line %d"),
878	pcszPath,
879	i.ullVirtualQuantity,
880	UINT16_MAX,
881	i.ulLineNumber);
882	break;
883
884	case OVFResourceType_Memory: // 4
885	if ( (i.strAllocationUnits == "MegaBytes") // found in OVF created by OVF toolkit
886	\|\| (i.strAllocationUnits == "MB") // found in MS docs
887	\|\| (i.strAllocationUnits == "byte * 2^20") // suggested by OVF spec DSP0243 page 21
888	)
889	vsys.ullMemorySize = i.ullVirtualQuantity * 1024 * 1024;
890	else
891	return setError(VBOX_E_FILE_ERROR,
892	tr("Error reading \"%s\": Invalid allocation unit \"%s\" specified with memory size item, line %d"),
893	pcszPath,
894	i.strAllocationUnits.c_str(),
895	i.ulLineNumber);
896	break;
897
898	case OVFResourceType_IDEController: // 5
899	{
900	/* <Item>
901	<rasd:Caption>ideController0</rasd:Caption>
902	<rasd:Description>IDE Controller</rasd:Description>
903	<rasd:InstanceId>5</rasd:InstanceId>
904	<rasd:ResourceType>5</rasd:ResourceType>
905	<rasd:Address>0</rasd:Address>
906	<rasd:BusNumber>0</rasd:BusNumber>
907	</Item> */
908	HardDiskController hdc;
909	hdc.system = HardDiskController::IDE;
910	hdc.idController = i.ulInstanceID;
911	hdc.strControllerType = i.strResourceSubType;
912	hdc.strAddress = i.strAddress;
913	hdc.ulBusNumber = i.ulBusNumber;
914
915	vsys.mapControllers[i.ulInstanceID] = hdc;
916	}
917	break;
918
919	case OVFResourceType_ParallelSCSIHBA: // 6 SCSI controller
920	{
921	/* <Item>
922	<rasd:Caption>SCSI Controller 0 - LSI Logic</rasd:Caption>
923	<rasd:Description>SCI Controller</rasd:Description>
924	<rasd:ElementName>SCSI controller</rasd:ElementName>
925	<rasd:InstanceID>4</rasd:InstanceID>
926	<rasd:ResourceSubType>LsiLogic</rasd:ResourceSubType>
927	<rasd:ResourceType>6</rasd:ResourceType>
928	</Item> */
929	HardDiskController hdc;
930	hdc.system = HardDiskController::SCSI;
931	hdc.idController = i.ulInstanceID;
932	hdc.strControllerType = i.strResourceSubType;
933
934	vsys.mapControllers[i.ulInstanceID] = hdc;
935	}
936	break;
937
938	case OVFResourceType_EthernetAdapter: // 10
939	{
940	/* <Item>
941	<rasd:Caption>Ethernet adapter on 'Bridged'</rasd:Caption>
942	<rasd:AutomaticAllocation>true</rasd:AutomaticAllocation>
943	<rasd:Connection>Bridged</rasd:Connection>
944	<rasd:InstanceID>6</rasd:InstanceID>
945	<rasd:ResourceType>10</rasd:ResourceType>
946	<rasd:ResourceSubType>E1000</rasd:ResourceSubType>
947	</Item>
948
949	OVF spec DSP 0243 page 21:
950	"For an Ethernet adapter, this specifies the abstract network connection name
951	for the virtual machine. All Ethernet adapters that specify the same abstract
952	network connection name within an OVF package shall be deployed on the same
953	network. The abstract network connection name shall be listed in the NetworkSection
954	at the outermost envelope level." */
955
956	// only store the name
957	EthernetAdapter ea;
958	ea.strAdapterType = i.strResourceSubType;
959	ea.strNetworkName = i.strConnection;
960	vsys.llEthernetAdapters.push_back(ea);
961	}
962	break;
963
964	case OVFResourceType_FloppyDrive: // 14
965	vsys.fHasFloppyDrive = true; // we have no additional information
966	break;
967
968	case OVFResourceType_CDDrive: // 15
969	/* <Item ovf:required="false">
970	<rasd:Caption>cdrom1</rasd:Caption>
971	<rasd:InstanceId>7</rasd:InstanceId>
972	<rasd:ResourceType>15</rasd:ResourceType>
973	<rasd:AutomaticAllocation>true</rasd:AutomaticAllocation>
974	<rasd:Parent>5</rasd:Parent>
975	<rasd:AddressOnParent>0</rasd:AddressOnParent>
976	</Item> */
977	// I tried to see what happens if I set an ISO for the CD-ROM in VMware Workstation,
978	// but then the ovftool dies with "Device backing not supported". So I guess if
979	// VMware can't export ISOs, then we don't need to be able to import them right now.
980	vsys.fHasCdromDrive = true; // we have no additional information
981	break;
982
983	case OVFResourceType_HardDisk: // 17
984	// handled separately in second loop below
985	break;
986
987	case OVFResourceType_OtherStorageDevice: // 20 SATA controller
988	{
989	/* <Item>
990	<rasd:Description>SATA Controller</rasd:Description>
991	<rasd:Caption>sataController0</rasd:Caption>
992	<rasd:InstanceID>4</rasd:InstanceID>
993	<rasd:ResourceType>20</rasd:ResourceType>
994	<rasd:ResourceSubType>AHCI</rasd:ResourceSubType>
995	<rasd:Address>0</rasd:Address>
996	<rasd:BusNumber>0</rasd:BusNumber>
997	</Item> */
998	if (i.strCaption.startsWith ("sataController", Utf8Str::CaseInsensitive) &&
999	!i.strResourceSubType.compare ("AHCI", Utf8Str::CaseInsensitive))
1000	{
1001	HardDiskController hdc;
1002	hdc.system = HardDiskController::SATA;
1003	hdc.idController = i.ulInstanceID;
1004	hdc.strControllerType = i.strResourceSubType;
1005
1006	vsys.mapControllers[i.ulInstanceID] = hdc;
1007	}
1008	else
1009	return setError(VBOX_E_FILE_ERROR,
1010	tr("Error reading \"%s\": Host resource of type \"Other Storage Device (%d)\" is supported with SATA AHCI controllers only, line %d"),
1011	pcszPath,
1012	OVFResourceType_OtherStorageDevice,
1013	i.ulLineNumber);
1014	}
1015	break;
1016
1017	case OVFResourceType_USBController: // 23
1018	/* <Item ovf:required="false">
1019	<rasd:Caption>usb</rasd:Caption>
1020	<rasd:Description>USB Controller</rasd:Description>
1021	<rasd:InstanceId>3</rasd:InstanceId>
1022	<rasd:ResourceType>23</rasd:ResourceType>
1023	<rasd:Address>0</rasd:Address>
1024	<rasd:BusNumber>0</rasd:BusNumber>
1025	</Item> */
1026	vsys.fHasUsbController = true; // we have no additional information
1027	break;
1028
1029	case OVFResourceType_SoundCard: // 35
1030	/* <Item ovf:required="false">
1031	<rasd:Caption>sound</rasd:Caption>
1032	<rasd:Description>Sound Card</rasd:Description>
1033	<rasd:InstanceId>10</rasd:InstanceId>
1034	<rasd:ResourceType>35</rasd:ResourceType>
1035	<rasd:ResourceSubType>ensoniq1371</rasd:ResourceSubType>
1036	<rasd:AutomaticAllocation>false</rasd:AutomaticAllocation>
1037	<rasd:AddressOnParent>3</rasd:AddressOnParent>
1038	</Item> */
1039	vsys.strSoundCardType = i.strResourceSubType;
1040	break;
1041
1042	default:
1043	return setError(VBOX_E_FILE_ERROR,
1044	tr("Error reading \"%s\": Unknown resource type %d in hardware item, line %d"),
1045	pcszPath,
1046	i.resourceType,
1047	i.ulLineNumber);
1048	} // end switch
1049	}
1050
1051	// now run through the items for a second time, but handle only
1052	// hard disk images; otherwise the code would fail if a hard
1053	// disk image appears in the OVF before its hard disk controller
1054	for (itH = vsys.mapHardwareItems.begin();
1055	itH != vsys.mapHardwareItems.end();
1056	++itH)
1057	{
1058	const VirtualHardwareItem &i = itH->second;
1059
1060	// do some analysis
1061	switch (i.resourceType)
1062	{
1063	case OVFResourceType_HardDisk: // 17
1064	{
1065	/* <Item>
1066	<rasd:Caption>Harddisk 1</rasd:Caption>
1067	<rasd:Description>HD</rasd:Description>
1068	<rasd:ElementName>Hard Disk</rasd:ElementName>
1069	<rasd:HostResource>ovf://disk/lamp</rasd:HostResource>
1070	<rasd:InstanceID>5</rasd:InstanceID>
1071	<rasd:Parent>4</rasd:Parent>
1072	<rasd:ResourceType>17</rasd:ResourceType>
1073	</Item> */
1074
1075	// look up the hard disk controller element whose InstanceID equals our Parent;
1076	// this is how the connection is specified in OVF
1077	ControllersMap::const_iterator it = vsys.mapControllers.find(i.ulParent);
1078	if (it == vsys.mapControllers.end())
1079	return setError(VBOX_E_FILE_ERROR,
1080	tr("Error reading \"%s\": Hard disk item with instance ID %d specifies invalid parent %d, line %d"),
1081	pcszPath,
1082	i.ulInstanceID,
1083	i.ulParent,
1084	i.ulLineNumber);
1085	//const HardDiskController &hdc = it->second;
1086
1087	VirtualDisk vd;
1088	vd.idController = i.ulParent;
1089	i.strAddressOnParent.toInt(vd.ulAddressOnParent);
1090	// ovf://disk/lamp
1091	// 123456789012345
1092	if (i.strHostResource.substr(0, 11) == "ovf://disk/")
1093	vd.strDiskId = i.strHostResource.substr(11);
1094	else if (i.strHostResource.substr(0, 6) == "/disk/")
1095	vd.strDiskId = i.strHostResource.substr(6);
1096
1097	if ( !(vd.strDiskId.length())
1098	\|\| (m->mapDisks.find(vd.strDiskId) == m->mapDisks.end())
1099	)
1100	return setError(VBOX_E_FILE_ERROR,
1101	tr("Error reading \"%s\": Hard disk item with instance ID %d specifies invalid host resource \"%s\", line %d"),
1102	pcszPath,
1103	i.ulInstanceID,
1104	i.strHostResource.c_str(),
1105	i.ulLineNumber);
1106
1107	vsys.mapVirtualDisks[vd.strDiskId] = vd;
1108	}
1109	break;
1110	}
1111	}
1112	}
1113	else if ( (!strcmp(pcszElemName, "OperatingSystemSection"))
1114	\|\| (!strcmp(pcszTypeAttr, "ovf:OperatingSystemSection_Type"))
1115	)
1116	{
1117	uint64_t cimos64;
1118	if (!(pelmThis->getAttributeValue("id", cimos64)))
1119	return setError(VBOX_E_FILE_ERROR,
1120	tr("Error reading \"%s\": missing or invalid 'ovf:id' attribute in operating system section element, line %d"),
1121	pcszPath,
1122	pelmThis->getLineNumber());
1123
1124	vsys.cimos = (CIMOSType_T)cimos64;
1125	const xml::ElementNode *pelmCIMOSDescription;
1126	if ((pelmCIMOSDescription = pelmThis->findChildElement("Description")))
1127	vsys.strCimosDesc = pelmCIMOSDescription->getValue();
1128	}
1129	else if ( (!strcmp(pcszElemName, "AnnotationSection"))
1130	\|\| (!strcmp(pcszTypeAttr, "ovf:AnnotationSection_Type"))
1131	)
1132	{
1133	const xml::ElementNode *pelmAnnotation;
1134	if ((pelmAnnotation = pelmThis->findChildElement("Annotation")))
1135	vsys.strDescription = pelmAnnotation->getValue();
1136	}
1137	}
1138
1139	// now create the virtual system
1140	m->llVirtualSystems.push_back(vsys);
1141
1142	return S_OK;
1143	}
1144
1145	////////////////////////////////////////////////////////////////////////////////
1146	//
1147	// IAppliance public methods
1148	//
1149	////////////////////////////////////////////////////////////////////////////////
1150
1151	/**
1152	* Public method implementation.
1153	* @param
1154	* @return
1155	*/
1156	STDMETHODIMP Appliance::COMGETTER(Path)(BSTR *aPath)
1157	{
1158	if (!aPath)
1159	return E_POINTER;
1160
1161	AutoCaller autoCaller(this);
1162	CheckComRCReturnRC(autoCaller.rc());
1163
1164	AutoReadLock alock(this);
1165
1166	Bstr bstrPath(m->strPath);
1167	bstrPath.cloneTo(aPath);
1168
1169	return S_OK;
1170	}
1171
1172	/**
1173	* Public method implementation.
1174	* @param
1175	* @return
1176	*/
1177	STDMETHODIMP Appliance::COMGETTER(Disks)(ComSafeArrayOut(BSTR, aDisks))
1178	{
1179	CheckComArgOutSafeArrayPointerValid(aDisks);
1180
1181	AutoCaller autoCaller(this);
1182	CheckComRCReturnRC(autoCaller.rc());
1183
1184	AutoReadLock alock(this);
1185
1186	size_t c = m->mapDisks.size();
1187	com::SafeArray<BSTR> sfaDisks(c);
1188
1189	DiskImagesMap::const_iterator it;
1190	size_t i = 0;
1191	for (it = m->mapDisks.begin();
1192	it != m->mapDisks.end();
1193	++it, ++i)
1194	{
1195	// create a string representing this disk
1196	const DiskImage &d = it->second;
1197	char *psz = NULL;
1198	RTStrAPrintf(&psz,
1199	"%s\t"
1200	"%RI64\t"
1201	"%RI64\t"
1202	"%s\t"
1203	"%s\t"
1204	"%RI64\t"
1205	"%RI64\t"
1206	"%s",
1207	d.strDiskId.c_str(),
1208	d.iCapacity,
1209	d.iPopulatedSize,
1210	d.strFormat.c_str(),
1211	d.strHref.c_str(),
1212	d.iSize,
1213	d.iChunkSize,
1214	d.strCompression.c_str());
1215	Utf8Str utf(psz);
1216	Bstr bstr(utf);
1217	// push to safearray
1218	bstr.cloneTo(&sfaDisks[i]);
1219	RTStrFree(psz);
1220	}
1221
1222	sfaDisks.detachTo(ComSafeArrayOutArg(aDisks));
1223
1224	return S_OK;
1225	}
1226
1227	/**
1228	* Public method implementation.
1229	* @param
1230	* @return
1231	*/
1232	STDMETHODIMP Appliance::COMGETTER(VirtualSystemDescriptions)(ComSafeArrayOut(IVirtualSystemDescription*, aVirtualSystemDescriptions))
1233	{
1234	CheckComArgOutSafeArrayPointerValid(aVirtualSystemDescriptions);
1235
1236	AutoCaller autoCaller(this);
1237	CheckComRCReturnRC(autoCaller.rc());
1238
1239	AutoReadLock alock(this);
1240
1241	SafeIfaceArray<IVirtualSystemDescription> sfaVSD(m->virtualSystemDescriptions);
1242	sfaVSD.detachTo(ComSafeArrayOutArg(aVirtualSystemDescriptions));
1243
1244	return S_OK;
1245	}
1246
1247	/**
1248	* Public method implementation.
1249	* @param path
1250	* @return
1251	*/
1252	STDMETHODIMP Appliance::Read(IN_BSTR path)
1253	{
1254	HRESULT rc = S_OK;
1255
1256	if (!path)
1257	return E_POINTER;
1258
1259	AutoCaller autoCaller(this);
1260	CheckComRCReturnRC(autoCaller.rc());
1261
1262	AutoWriteLock alock(this);
1263
1264	// see if we can handle this file; for now we insist it has an ".ovf" extension
1265	m->strPath = path;
1266	if (!m->strPath.endsWith(".ovf", Utf8Str::CaseInsensitive))
1267	return setError(VBOX_E_FILE_ERROR,
1268	tr("Appliance file must have .ovf extension"));
1269
1270	try
1271	{
1272	xml::XmlFileParser parser;
1273	xml::Document doc;
1274	parser.read(m->strPath.raw(),
1275	doc);
1276
1277	const xml::ElementNode *pRootElem = doc.getRootElement();
1278	if (strcmp(pRootElem->getName(), "Envelope"))
1279	return setError(VBOX_E_FILE_ERROR,
1280	tr("Root element in OVF file must be \"Envelope\"."));
1281
1282	// OVF has the following rough layout:
1283	/*
1284	-- <References> .... files referenced from other parts of the file, such as VMDK images
1285	-- Metadata, comprised of several section commands
1286	-- virtual machines, either a single <VirtualSystem>, or a <VirtualSystemCollection>
1287	-- optionally <Strings> for localization
1288	*/
1289
1290	// get all "File" child elements of "References" section so we can look up files easily;
1291	// first find the "References" sections so we can look up files
1292	xml::ElementNodesList listFileElements; // receives all /Envelope/References/File nodes
1293	const xml::ElementNode *pReferencesElem;
1294	if ((pReferencesElem = pRootElem->findChildElement("References")))
1295	pReferencesElem->getChildElements(listFileElements, "File");
1296
1297	// now go though the sections
1298	if (!(SUCCEEDED(rc = LoopThruSections(m->strPath.raw(), pReferencesElem, pRootElem))))
1299	return rc;
1300	}
1301	catch(xml::Error &x)
1302	{
1303	return setError(VBOX_E_FILE_ERROR,
1304	x.what());
1305	}
1306
1307	return S_OK;
1308	}
1309
1310	/**
1311	* Public method implementation.
1312	* @return
1313	*/
1314	STDMETHODIMP Appliance::Interpret()
1315	{
1316	// @todo:
1317	// - don't use COM methods but the methods directly (faster, but needs appropriate locking of that objects itself (s. HardDisk))
1318	// - Appropriate handle errors like not supported file formats
1319	AutoCaller autoCaller(this);
1320	CheckComRCReturnRC(autoCaller.rc());
1321
1322	AutoWriteLock(this);
1323
1324	HRESULT rc = S_OK;
1325
1326	/* Clear any previous virtual system descriptions */
1327	m->virtualSystemDescriptions.clear();
1328
1329	/* We need the default path for storing disk images */
1330	ComPtr<ISystemProperties> systemProps;
1331	rc = mVirtualBox->COMGETTER(SystemProperties)(systemProps.asOutParam());
1332	CheckComRCReturnRC(rc);
1333	Bstr bstrDefaultHardDiskLocation;
1334	rc = systemProps->COMGETTER(DefaultHardDiskFolder)(bstrDefaultHardDiskLocation.asOutParam());
1335	CheckComRCReturnRC(rc);
1336
1337	/* Try/catch so we can clean up on error */
1338	try
1339	{
1340	list<VirtualSystem>::const_iterator it;
1341	/* Iterate through all virtual systems */
1342	for (it = m->llVirtualSystems.begin();
1343	it != m->llVirtualSystems.end();
1344	++it)
1345	{
1346	const VirtualSystem &vsysThis = *it;
1347
1348	ComObjPtr<VirtualSystemDescription> pNewDesc;
1349	rc = pNewDesc.createObject();
1350	CheckComRCThrowRC(rc);
1351	rc = pNewDesc->init();
1352	CheckComRCThrowRC(rc);
1353
1354	/* Guest OS type */
1355	Utf8Str strOsTypeVBox,
1356	strCIMOSType = Utf8StrFmt("%RI32", (uint32_t)vsysThis.cimos);
1357	convertCIMOSType2VBoxOSType(strOsTypeVBox, vsysThis.cimos, vsysThis.strCimosDesc);
1358	pNewDesc->addEntry(VirtualSystemDescriptionType_OS,
1359	"",
1360	strCIMOSType,
1361	strOsTypeVBox);
1362
1363	/* VM name */
1364	/* If the there isn't any name specified create a default one out of
1365	* the OS type */
1366	Utf8Str nameVBox = vsysThis.strName;
1367	if (nameVBox.isEmpty())
1368	nameVBox = strOsTypeVBox;
1369	searchUniqueVMName(nameVBox);
1370	pNewDesc->addEntry(VirtualSystemDescriptionType_Name,
1371	"",
1372	vsysThis.strName,
1373	nameVBox);
1374
1375	/* VM Product */
1376	if (!vsysThis.strProduct.isEmpty())
1377	pNewDesc->addEntry(VirtualSystemDescriptionType_Product,
1378	"",
1379	vsysThis.strProduct,
1380	vsysThis.strProduct);
1381
1382	/* VM Vendor */
1383	if (!vsysThis.strVendor.isEmpty())
1384	pNewDesc->addEntry(VirtualSystemDescriptionType_Vendor,
1385	"",
1386	vsysThis.strVendor,
1387	vsysThis.strVendor);
1388
1389	/* VM Version */
1390	if (!vsysThis.strVersion.isEmpty())
1391	pNewDesc->addEntry(VirtualSystemDescriptionType_Version,
1392	"",
1393	vsysThis.strVersion,
1394	vsysThis.strVersion);
1395
1396	/* VM ProductUrl */
1397	if (!vsysThis.strProductUrl.isEmpty())
1398	pNewDesc->addEntry(VirtualSystemDescriptionType_ProductUrl,
1399	"",
1400	vsysThis.strProductUrl,
1401	vsysThis.strProductUrl);
1402
1403	/* VM VendorUrl */
1404	if (!vsysThis.strVendorUrl.isEmpty())
1405	pNewDesc->addEntry(VirtualSystemDescriptionType_VendorUrl,
1406	"",
1407	vsysThis.strVendorUrl,
1408	vsysThis.strVendorUrl);
1409
1410	/* VM description */
1411	if (!vsysThis.strDescription.isEmpty())
1412	pNewDesc->addEntry(VirtualSystemDescriptionType_Description,
1413	"",
1414	vsysThis.strDescription,
1415	vsysThis.strDescription);
1416
1417	/* VM license */
1418	if (!vsysThis.strLicenseText.isEmpty())
1419	pNewDesc->addEntry(VirtualSystemDescriptionType_License,
1420	"",
1421	vsysThis.strLicenseText,
1422	vsysThis.strLicenseText);
1423
1424	/* Now that we know the OS type, get our internal defaults based on that. */
1425	ComPtr<IGuestOSType> pGuestOSType;
1426	rc = mVirtualBox->GetGuestOSType(Bstr(strOsTypeVBox), pGuestOSType.asOutParam());
1427	CheckComRCThrowRC(rc);
1428
1429	/* CPU count */
1430	ULONG cpuCountVBox = vsysThis.cCPUs;
1431	/* Check for the constrains */
1432	if (cpuCountVBox > 1) //SchemaDefs::MaxCPUCount)
1433	{
1434	addWarning(tr("The virtual system \"%s\" claims support for %u CPU's, but VirtualBox has support for max %u CPU's only."),
1435	vsysThis.strName.c_str(), cpuCountVBox, 1); //SchemaDefs::MaxCPUCount);
1436	cpuCountVBox = 1; //SchemaDefs::MaxCPUCount;
1437	}
1438	if (vsysThis.cCPUs == 0)
1439	cpuCountVBox = 1;
1440	pNewDesc->addEntry(VirtualSystemDescriptionType_CPU,
1441	"",
1442	Utf8StrFmt("%RI32", (uint32_t)vsysThis.cCPUs),
1443	Utf8StrFmt("%RI32", (uint32_t)cpuCountVBox));
1444
1445	/* RAM */
1446	uint64_t ullMemSizeVBox = vsysThis.ullMemorySize / _1M;
1447	/* Check for the constrains */
1448	if (ullMemSizeVBox != 0 &&
1449	(ullMemSizeVBox < MM_RAM_MIN_IN_MB \|\|
1450	ullMemSizeVBox > MM_RAM_MAX_IN_MB))
1451	{
1452	addWarning(tr("The virtual system \"%s\" claims support for %llu MB RAM size, but VirtualBox has support for min %u & max %u MB RAM size only."),
1453	vsysThis.strName.c_str(), ullMemSizeVBox, MM_RAM_MIN_IN_MB, MM_RAM_MAX_IN_MB);
1454	ullMemSizeVBox = RT_MIN(RT_MAX(ullMemSizeVBox, MM_RAM_MIN_IN_MB), MM_RAM_MAX_IN_MB);
1455	}
1456	if (vsysThis.ullMemorySize == 0)
1457	{
1458	/* If the RAM of the OVF is zero, use our predefined values */
1459	ULONG memSizeVBox2;
1460	rc = pGuestOSType->COMGETTER(RecommendedRAM)(&memSizeVBox2);
1461	CheckComRCThrowRC(rc);
1462	/* VBox stores that in MByte */
1463	ullMemSizeVBox = (uint64_t)memSizeVBox2;
1464	}
1465	pNewDesc->addEntry(VirtualSystemDescriptionType_Memory,
1466	"",
1467	Utf8StrFmt("%RI64", (uint64_t)vsysThis.ullMemorySize),
1468	Utf8StrFmt("%RI64", (uint64_t)ullMemSizeVBox));
1469
1470	/* Audio */
1471	if (!vsysThis.strSoundCardType.isNull())
1472	/* Currently we set the AC97 always.
1473	@todo: figure out the hardware which could be possible */
1474	pNewDesc->addEntry(VirtualSystemDescriptionType_SoundCard,
1475	"",
1476	vsysThis.strSoundCardType,
1477	Utf8StrFmt("%RI32", (uint32_t)AudioControllerType_AC97));
1478
1479	#ifdef VBOX_WITH_USB
1480	/* USB Controller */
1481	if (vsysThis.fHasUsbController)
1482	pNewDesc->addEntry(VirtualSystemDescriptionType_USBController, "", "", "");
1483	#endif /* VBOX_WITH_USB */
1484
1485	/* Network Controller */
1486	size_t cEthernetAdapters = vsysThis.llEthernetAdapters.size();
1487	if (cEthernetAdapters > 0)
1488	{
1489	/* Check for the constrains */
1490	if (cEthernetAdapters > SchemaDefs::NetworkAdapterCount)
1491	addWarning(tr("The virtual system \"%s\" claims support for %zu network adapters, but VirtualBox has support for max %u network adapter only."),
1492	vsysThis.strName.c_str(), cEthernetAdapters, SchemaDefs::NetworkAdapterCount);
1493
1494	/* Get the default network adapter type for the selected guest OS */
1495	NetworkAdapterType_T defaultAdapterVBox = NetworkAdapterType_Am79C970A;
1496	rc = pGuestOSType->COMGETTER(AdapterType)(&defaultAdapterVBox);
1497	CheckComRCThrowRC(rc);
1498
1499	EthernetAdaptersList::const_iterator itEA;
1500	/* Iterate through all abstract networks. We support 8 network
1501	* adapters at the maximum, so the first 8 will be added only. */
1502	size_t a = 0;
1503	for (itEA = vsysThis.llEthernetAdapters.begin();
1504	itEA != vsysThis.llEthernetAdapters.end() && a < SchemaDefs::NetworkAdapterCount;
1505	++itEA, ++a)
1506	{
1507	const EthernetAdapter &ea = *itEA; // logical network to connect to
1508	Utf8Str strNetwork = ea.strNetworkName;
1509	// make sure it's one of these two
1510	if ( (strNetwork.compare("Null", Utf8Str::CaseInsensitive))
1511	&& (strNetwork.compare("NAT", Utf8Str::CaseInsensitive))
1512	&& (strNetwork.compare("Bridged", Utf8Str::CaseInsensitive))
1513	&& (strNetwork.compare("Internal", Utf8Str::CaseInsensitive))
1514	&& (strNetwork.compare("HostOnly", Utf8Str::CaseInsensitive))
1515	)
1516	strNetwork = "Bridged"; // VMware assumes this is the default apparently
1517
1518	/* Figure out the hardware type */
1519	NetworkAdapterType_T nwAdapterVBox = defaultAdapterVBox;
1520	if (!ea.strAdapterType.compare("PCNet32", Utf8Str::CaseInsensitive))
1521	{
1522	/* If the default adapter is already one of the two
1523	* PCNet adapters use the default one. If not use the
1524	* Am79C970A as fallback. */
1525	if (!(defaultAdapterVBox == NetworkAdapterType_Am79C970A \|\|
1526	defaultAdapterVBox == NetworkAdapterType_Am79C973))
1527	nwAdapterVBox = NetworkAdapterType_Am79C970A;
1528	}
1529	#ifdef VBOX_WITH_E1000
1530	else if (!ea.strAdapterType.compare("E1000", Utf8Str::CaseInsensitive) \|\|
1531	!ea.strAdapterType.compare("E10000", Utf8Str::CaseInsensitive)) // VMWare accidentally write this with VirtualCenter 3.5
1532	{
1533	/* Check if this OVF was written by VirtualBox */
1534	if (vsysThis.strVirtualSystemType.contains("virtualbox", Utf8Str::CaseInsensitive))
1535	{
1536	/* If the default adapter is already one of the three
1537	* E1000 adapters use the default one. If not use the
1538	* I82545EM as fallback. */
1539	if (!(defaultAdapterVBox == NetworkAdapterType_I82540EM \|\|
1540	defaultAdapterVBox == NetworkAdapterType_I82543GC \|\|
1541	defaultAdapterVBox == NetworkAdapterType_I82545EM))
1542	nwAdapterVBox = NetworkAdapterType_I82540EM;
1543	}
1544	else
1545	/* Always use this one since it's what VMware uses */
1546	nwAdapterVBox = NetworkAdapterType_I82545EM;
1547	}
1548	#endif /* VBOX_WITH_E1000 */
1549
1550	pNewDesc->addEntry(VirtualSystemDescriptionType_NetworkAdapter,
1551	"", // ref
1552	ea.strNetworkName, // orig
1553	Utf8StrFmt("%RI32", (uint32_t)nwAdapterVBox), // conf
1554	0,
1555	Utf8StrFmt("type=%s", strNetwork.c_str())); // extra conf
1556	}
1557	}
1558
1559	/* Floppy Drive */
1560	if (vsysThis.fHasFloppyDrive)
1561	pNewDesc->addEntry(VirtualSystemDescriptionType_Floppy, "", "", "");
1562
1563	/* CD Drive */
1564	/* @todo: I can't disable the CDROM. So nothing to do for now */
1565	/*
1566	if (vsysThis.fHasCdromDrive)
1567	pNewDesc->addEntry(VirtualSystemDescriptionType_CDROM, "", "", "");*/
1568
1569	/* Hard disk Controller */
1570	uint16_t cIDEused = 0;
1571	uint16_t cSATAused = 0;
1572	uint16_t cSCSIused = 0;
1573	ControllersMap::const_iterator hdcIt;
1574	/* Iterate through all hard disk controllers */
1575	for (hdcIt = vsysThis.mapControllers.begin();
1576	hdcIt != vsysThis.mapControllers.end();
1577	++hdcIt)
1578	{
1579	const HardDiskController &hdc = hdcIt->second;
1580	Utf8Str strControllerID = Utf8StrFmt("%RI32", (uint32_t)hdc.idController);
1581
1582	switch (hdc.system)
1583	{
1584	case HardDiskController::IDE:
1585	{
1586	/* Check for the constrains */
1587	/* @todo: I'm very confused! Are these bits one controller or
1588	is every port/bus declared as an extra controller. */
1589	if (cIDEused < 4)
1590	{
1591	// @todo: figure out the IDE types
1592	/* Use PIIX4 as default */
1593	Utf8Str strType = "PIIX4";
1594	if (!hdc.strControllerType.compare("PIIX3", Utf8Str::CaseInsensitive))
1595	strType = "PIIX3";
1596	else if (!hdc.strControllerType.compare("ICH6", Utf8Str::CaseInsensitive))
1597	strType = "ICH6";
1598	pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskControllerIDE,
1599	strControllerID,
1600	hdc.strControllerType,
1601	strType);
1602	}
1603	else
1604	{
1605	/* Warn only once */
1606	if (cIDEused == 1)
1607	addWarning(tr("The virtual \"%s\" system requests support for more than one IDE controller, but VirtualBox has support for only one."),
1608	vsysThis.strName.c_str());
1609
1610	}
1611	++cIDEused;
1612	break;
1613	}
1614
1615	#ifdef VBOX_WITH_AHCI
1616	case HardDiskController::SATA:
1617	{
1618	/* Check for the constrains */
1619	if (cSATAused < 1)
1620	{
1621	// @todo: figure out the SATA types
1622	/* We only support a plain AHCI controller, so use them always */
1623	pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskControllerSATA,
1624	strControllerID,
1625	hdc.strControllerType,
1626	"AHCI");
1627	}
1628	else
1629	{
1630	/* Warn only once */
1631	if (cSATAused == 1)
1632	addWarning(tr("The virtual system \"%s\" requests support for more than one SATA controller, but VirtualBox has support for only one"),
1633	vsysThis.strName.c_str());
1634
1635	}
1636	++cSATAused;
1637	break;
1638	}
1639	#endif /* VBOX_WITH_AHCI */
1640
1641	case HardDiskController::SCSI:
1642	{
1643	/* Check for the constrains */
1644	if (cSCSIused < 1)
1645	{
1646	Utf8Str hdcController = "LsiLogic";
1647	if (!hdc.strControllerType.compare("BusLogic", Utf8Str::CaseInsensitive))
1648	hdcController = "BusLogic";
1649	pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskControllerSCSI,
1650	strControllerID,
1651	hdc.strControllerType,
1652	hdcController);
1653	}
1654	else
1655	addWarning(tr("The virtual system \"%s\" requests support for an additional SCSI controller of type \"%s\" with ID %s, but VirtualBox presently supports only one SCSI controller."),
1656	vsysThis.strName.c_str(),
1657	hdc.strControllerType.c_str(),
1658	strControllerID.c_str());
1659	++cSCSIused;
1660	break;
1661	}
1662	}
1663	}
1664
1665	/* Hard disks */
1666	if (vsysThis.mapVirtualDisks.size() > 0)
1667	{
1668	VirtualDisksMap::const_iterator itVD;
1669	/* Iterate through all hard disks ()*/
1670	for (itVD = vsysThis.mapVirtualDisks.begin();
1671	itVD != vsysThis.mapVirtualDisks.end();
1672	++itVD)
1673	{
1674	const VirtualDisk &hd = itVD->second;
1675	/* Get the associated disk image */
1676	const DiskImage &di = m->mapDisks[hd.strDiskId];
1677
1678	// @todo:
1679	// - figure out all possible vmdk formats we also support
1680	// - figure out if there is a url specifier for vhd already
1681	// - we need a url specifier for the vdi format
1682	if ( di.strFormat.compare("http://www.vmware.com/specifications/vmdk.html#sparse", Utf8Str::CaseInsensitive)
1683	\|\| di.strFormat.compare("http://www.vmware.com/specifications/vmdk.html#compressed", Utf8Str::CaseInsensitive))
1684	{
1685	/* If the href is empty use the VM name as filename */
1686	Utf8Str strFilename = di.strHref;
1687	if (!strFilename.length())
1688	strFilename = Utf8StrFmt("%s.vmdk", nameVBox.c_str());
1689	/* Construct a unique target path */
1690	Utf8StrFmt strPath("%ls%c%s",
1691	bstrDefaultHardDiskLocation.raw(),
1692	RTPATH_DELIMITER,
1693	strFilename.c_str());
1694	searchUniqueDiskImageFilePath(strPath);
1695
1696	/* find the description for the hard disk controller
1697	* that has the same ID as hd.idController */
1698	const VirtualSystemDescriptionEntry *pController;
1699	if (!(pController = pNewDesc->findControllerFromID(hd.idController)))
1700	throw setError(E_FAIL,
1701	tr("Cannot find hard disk controller with OVF instance ID %RI32 to which disk \"%s\" should be attached"),
1702	hd.idController,
1703	di.strHref.c_str());
1704
1705	/* controller to attach to, and the bus within that controller */
1706	Utf8StrFmt strExtraConfig("controller=%RI16;channel=%RI16",
1707	pController->ulIndex,
1708	hd.ulAddressOnParent);
1709	ULONG ulSize = 0;
1710	if (di.iCapacity != -1)
1711	ulSize = (ULONG)(di.iCapacity / _1M);
1712	else if (di.iPopulatedSize != -1)
1713	ulSize = (ULONG)(di.iPopulatedSize / _1M);
1714	else if (di.iSize != -1)
1715	ulSize = (ULONG)(di.iSize / _1M);
1716	if (ulSize == 0)
1717	ulSize = 10000; // assume 10 GB, this is for the progress bar only anyway
1718	pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskImage,
1719	hd.strDiskId,
1720	di.strHref,
1721	strPath,
1722	ulSize,
1723	strExtraConfig);
1724	}
1725	else
1726	throw setError(VBOX_E_FILE_ERROR,
1727	tr("Unsupported format for virtual disk image in OVF: \"%s\"", di.strFormat.c_str()));
1728	}
1729	}
1730
1731	m->virtualSystemDescriptions.push_back(pNewDesc);
1732	}
1733	}
1734	catch (HRESULT aRC)
1735	{
1736	/* On error we clear the list & return */
1737	m->virtualSystemDescriptions.clear();
1738	rc = aRC;
1739	}
1740
1741	return rc;
1742	}
1743
1744	struct Appliance::TaskImportMachines
1745	{
1746	TaskImportMachines(Appliance aThat, Progress aProgress)
1747	: pAppliance(aThat)
1748	, progress(aProgress)
1749	, rc(S_OK)
1750	{}
1751	~TaskImportMachines() {}
1752
1753	HRESULT startThread();
1754
1755	Appliance *pAppliance;
1756	ComObjPtr<Progress> progress;
1757	HRESULT rc;
1758	};
1759
1760	HRESULT Appliance::TaskImportMachines::startThread()
1761	{
1762	int vrc = RTThreadCreate(NULL, Appliance::taskThreadImportMachines, this,
1763	0, RTTHREADTYPE_MAIN_HEAVY_WORKER, 0,
1764	"Appliance::Task");
1765	ComAssertMsgRCRet(vrc,
1766	("Could not create taskThreadImportMachines (%Rrc)\n", vrc), E_FAIL);
1767
1768	return S_OK;
1769	}
1770
1771	/**
1772	* Public method implementation.
1773	* @param aProgress
1774	* @return
1775	*/
1776	STDMETHODIMP Appliance::ImportMachines(IProgress **aProgress)
1777	{
1778	CheckComArgOutPointerValid(aProgress);
1779
1780	AutoCaller autoCaller(this);
1781	CheckComRCReturnRC(autoCaller.rc());
1782
1783	AutoReadLock(this);
1784
1785	HRESULT rc = S_OK;
1786
1787	ComObjPtr<Progress> progress;
1788	try
1789	{
1790	Bstr progressDesc = BstrFmt(tr("Import appliance '%s'"),
1791	m->strPath.raw());
1792	rc = setUpProgress(progress, progressDesc);
1793	if (FAILED(rc)) throw rc;
1794
1795	/* Initialize our worker task */
1796	std::auto_ptr<TaskImportMachines> task(new TaskImportMachines(this, progress));
1797	//AssertComRCThrowRC (task->autoCaller.rc());
1798
1799	rc = task->startThread();
1800	if (FAILED(rc)) throw rc;
1801
1802	task.release();
1803	}
1804	catch (HRESULT aRC)
1805	{
1806	rc = aRC;
1807	}
1808
1809	if (SUCCEEDED(rc))
1810	/* Return progress to the caller */
1811	progress.queryInterfaceTo(aProgress);
1812
1813	return rc;
1814	}
1815
1816	struct MyHardDiskAttachment
1817	{
1818	Guid uuid;
1819	ComPtr<IMachine> pMachine;
1820	Bstr controllerType;
1821	int32_t lChannel;
1822	int32_t lDevice;
1823	};
1824
1825	/**
1826	* Worker thread implementation for ImportMachines().
1827	* @param aThread
1828	* @param pvUser
1829	*/
1830	/* static */
1831	DECLCALLBACK(int) Appliance::taskThreadImportMachines(RTTHREAD /* aThread /, void pvUser)
1832	{
1833	std::auto_ptr<TaskImportMachines> task(static_cast<TaskImportMachines*>(pvUser));
1834	AssertReturn(task.get(), VERR_GENERAL_FAILURE);
1835
1836	Appliance *pAppliance = task->pAppliance;
1837
1838	LogFlowFuncEnter();
1839	LogFlowFunc(("Appliance %p\n", pAppliance));
1840
1841	AutoCaller autoCaller(pAppliance);
1842	CheckComRCReturnRC(autoCaller.rc());
1843
1844	AutoWriteLock appLock(pAppliance);
1845
1846	HRESULT rc = S_OK;
1847
1848	ComPtr<IVirtualBox> pVirtualBox(pAppliance->mVirtualBox);
1849
1850	// rollback for errors:
1851	// a list of images that we created/imported
1852	list<MyHardDiskAttachment> llHardDiskAttachments;
1853	list< ComPtr<IHardDisk> > llHardDisksCreated;
1854	list<Guid> llMachinesRegistered;
1855
1856	ComPtr<ISession> session;
1857	bool fSessionOpen = false;
1858	rc = session.createInprocObject(CLSID_Session);
1859	CheckComRCReturnRC(rc);
1860
1861	list<VirtualSystem>::const_iterator it;
1862	list< ComObjPtr<VirtualSystemDescription> >::const_iterator it1;
1863	/* Iterate through all virtual systems of that appliance */
1864	size_t i = 0;
1865	for (it = pAppliance->m->llVirtualSystems.begin(),
1866	it1 = pAppliance->m->virtualSystemDescriptions.begin();
1867	it != pAppliance->m->llVirtualSystems.end();
1868	++it, ++it1, ++i)
1869	{
1870	const VirtualSystem &vsysThis = *it;
1871	ComObjPtr<VirtualSystemDescription> vsdescThis = (*it1);
1872
1873	ComPtr<IMachine> pNewMachine;
1874
1875	/* Catch possible errors */
1876	try
1877	{
1878	/* Guest OS type */
1879	std::list<VirtualSystemDescriptionEntry*> vsdeOS;
1880	vsdeOS = vsdescThis->findByType(VirtualSystemDescriptionType_OS);
1881	if (vsdeOS.size() < 1)
1882	throw setError(VBOX_E_FILE_ERROR,
1883	tr("Missing guest OS type"));
1884	const Utf8Str &strOsTypeVBox = vsdeOS.front()->strVbox;
1885
1886	/* Now that we know the base system get our internal defaults based on that. */
1887	ComPtr<IGuestOSType> osType;
1888	rc = pVirtualBox->GetGuestOSType(Bstr(strOsTypeVBox), osType.asOutParam());
1889	if (FAILED(rc)) throw rc;
1890
1891	/* Create the machine */
1892	/* First get the name */
1893	std::list<VirtualSystemDescriptionEntry*> vsdeName = vsdescThis->findByType(VirtualSystemDescriptionType_Name);
1894	if (vsdeName.size() < 1)
1895	throw setError(VBOX_E_FILE_ERROR,
1896	tr("Missing VM name"));
1897	const Utf8Str &strNameVBox = vsdeName.front()->strVbox;
1898	rc = pVirtualBox->CreateMachine(Bstr(strNameVBox), Bstr(strOsTypeVBox),
1899	Bstr(), Guid(),
1900	pNewMachine.asOutParam());
1901	if (FAILED(rc)) throw rc;
1902
1903	// and the description
1904	std::list<VirtualSystemDescriptionEntry*> vsdeDescription = vsdescThis->findByType(VirtualSystemDescriptionType_Description);
1905	if (vsdeDescription.size())
1906	{
1907	const Utf8Str &strDescription = vsdeDescription.front()->strVbox;
1908	rc = pNewMachine->COMSETTER(Description)(Bstr(strDescription));
1909	if (FAILED(rc)) throw rc;
1910	}
1911
1912	/* CPU count (ignored for now) */
1913	// EntriesList vsdeCPU = vsd->findByType (VirtualSystemDescriptionType_CPU);
1914
1915	/* RAM */
1916	std::list<VirtualSystemDescriptionEntry*> vsdeRAM = vsdescThis->findByType(VirtualSystemDescriptionType_Memory);
1917	ComAssertMsgThrow(vsdeRAM.size() == 1, ("RAM size missing"), E_FAIL);
1918	const Utf8Str &memoryVBox = vsdeRAM.front()->strVbox;
1919	ULONG tt = (ULONG)RTStrToUInt64(memoryVBox.c_str());
1920	rc = pNewMachine->COMSETTER(MemorySize)(tt);
1921	if (FAILED(rc)) throw rc;
1922
1923	/* VRAM */
1924	/* Get the recommended VRAM for this guest OS type */
1925	ULONG vramVBox;
1926	rc = osType->COMGETTER(RecommendedVRAM)(&vramVBox);
1927	if (FAILED(rc)) throw rc;
1928
1929	/* Set the VRAM */
1930	rc = pNewMachine->COMSETTER(VRAMSize)(vramVBox);
1931	if (FAILED(rc)) throw rc;
1932
1933	/* I/O APIC: so far we have no setting for this. Enable it if we
1934	import a Windows VM because if if Windows was installed without IOAPIC,
1935	it will not mind finding an one later on, but if Windows was installed
1936	_with_ an IOAPIC, it will bluescreen if it's not found */
1937	Bstr bstrFamilyId;
1938	rc = osType->COMGETTER(FamilyId)(bstrFamilyId.asOutParam());
1939	if (FAILED(rc)) throw rc;
1940
1941	Utf8Str strFamilyId(bstrFamilyId);
1942	if (strFamilyId == "Windows")
1943	{
1944	ComPtr<IBIOSSettings> pBIOSSettings;
1945	rc = pNewMachine->COMGETTER(BIOSSettings)(pBIOSSettings.asOutParam());
1946	if (FAILED(rc)) throw rc;
1947
1948	rc = pBIOSSettings->COMSETTER(IOAPICEnabled)(TRUE);
1949	if (FAILED(rc)) throw rc;
1950	}
1951
1952	/* Audio Adapter */
1953	std::list<VirtualSystemDescriptionEntry*> vsdeAudioAdapter = vsdescThis->findByType(VirtualSystemDescriptionType_SoundCard);
1954	/* @todo: we support one audio adapter only */
1955	if (vsdeAudioAdapter.size() > 0)
1956	{
1957	const Utf8Str& audioAdapterVBox = vsdeAudioAdapter.front()->strVbox;
1958	if (audioAdapterVBox.compare("null", Utf8Str::CaseInsensitive) != 0)
1959	{
1960	uint32_t audio = RTStrToUInt32(audioAdapterVBox.c_str());
1961	ComPtr<IAudioAdapter> audioAdapter;
1962	rc = pNewMachine->COMGETTER(AudioAdapter)(audioAdapter.asOutParam());
1963	if (FAILED(rc)) throw rc;
1964	rc = audioAdapter->COMSETTER(Enabled)(true);
1965	if (FAILED(rc)) throw rc;
1966	rc = audioAdapter->COMSETTER(AudioController)(static_cast<AudioControllerType_T>(audio));
1967	if (FAILED(rc)) throw rc;
1968	}
1969	}
1970
1971	#ifdef VBOX_WITH_USB
1972	/* USB Controller */
1973	std::list<VirtualSystemDescriptionEntry*> vsdeUSBController = vsdescThis->findByType(VirtualSystemDescriptionType_USBController);
1974	// USB support is enabled if there's at least one such entry; to disable USB support,
1975	// the type of the USB item would have been changed to "ignore"
1976	bool fUSBEnabled = vsdeUSBController.size() > 0;
1977
1978	ComPtr<IUSBController> usbController;
1979	rc = pNewMachine->COMGETTER(USBController)(usbController.asOutParam());
1980	if (FAILED(rc)) throw rc;
1981	rc = usbController->COMSETTER(Enabled)(fUSBEnabled);
1982	if (FAILED(rc)) throw rc;
1983	#endif /* VBOX_WITH_USB */
1984
1985	/* Change the network adapters */
1986	std::list<VirtualSystemDescriptionEntry*> vsdeNW = vsdescThis->findByType(VirtualSystemDescriptionType_NetworkAdapter);
1987	if (vsdeNW.size() == 0)
1988	{
1989	/* No network adapters, so we have to disable our default one */
1990	ComPtr<INetworkAdapter> nwVBox;
1991	rc = pNewMachine->GetNetworkAdapter(0, nwVBox.asOutParam());
1992	if (FAILED(rc)) throw rc;
1993	rc = nwVBox->COMSETTER(Enabled)(false);
1994	if (FAILED(rc)) throw rc;
1995	}
1996	else
1997	{
1998	list<VirtualSystemDescriptionEntry*>::const_iterator nwIt;
1999	/* Iterate through all network cards. We support 8 network adapters
2000	* at the maximum. (@todo: warn if there are more!) */
2001	size_t a = 0;
2002	for (nwIt = vsdeNW.begin();
2003	(nwIt != vsdeNW.end() && a < SchemaDefs::NetworkAdapterCount);
2004	++nwIt, ++a)
2005	{
2006	const VirtualSystemDescriptionEntry* pvsys = *nwIt;
2007
2008	const Utf8Str &nwTypeVBox = pvsys->strVbox;
2009	uint32_t tt1 = RTStrToUInt32(nwTypeVBox.c_str());
2010	ComPtr<INetworkAdapter> pNetworkAdapter;
2011	rc = pNewMachine->GetNetworkAdapter((ULONG)a, pNetworkAdapter.asOutParam());
2012	if (FAILED(rc)) throw rc;
2013	/* Enable the network card & set the adapter type */
2014	rc = pNetworkAdapter->COMSETTER(Enabled)(true);
2015	if (FAILED(rc)) throw rc;
2016	rc = pNetworkAdapter->COMSETTER(AdapterType)(static_cast<NetworkAdapterType_T>(tt1));
2017	if (FAILED(rc)) throw rc;
2018
2019	// default is NAT; change to "bridged" if extra conf says so
2020	if (!pvsys->strExtraConfig.compare("type=Bridged", Utf8Str::CaseInsensitive))
2021	{
2022	/* Attach to the right interface */
2023	rc = pNetworkAdapter->AttachToBridgedInterface();
2024	if (FAILED(rc)) throw rc;
2025	ComPtr<IHost> host;
2026	rc = pVirtualBox->COMGETTER(Host)(host.asOutParam());
2027	if (FAILED(rc)) throw rc;
2028	com::SafeIfaceArray<IHostNetworkInterface> nwInterfaces;
2029	rc = host->COMGETTER(NetworkInterfaces)(ComSafeArrayAsOutParam(nwInterfaces));
2030	if (FAILED(rc)) throw rc;
2031	/* We search for the first host network interface which
2032	* is usable for bridged networking */
2033	for (size_t i=0; i < nwInterfaces.size(); ++i)
2034	{
2035	HostNetworkInterfaceType_T itype;
2036	rc = nwInterfaces[i]->COMGETTER(InterfaceType)(&itype);
2037	if (FAILED(rc)) throw rc;
2038	if (itype == HostNetworkInterfaceType_Bridged)
2039	{
2040	Bstr name;
2041	rc = nwInterfaces[i]->COMGETTER(Name)(name.asOutParam());
2042	if (FAILED(rc)) throw rc;
2043	/* Set the interface name to attach to */
2044	pNetworkAdapter->COMSETTER(HostInterface)(name);
2045	if (FAILED(rc)) throw rc;
2046	break;
2047	}
2048	}
2049	}
2050	/* Next test for host only interfaces */
2051	else if (!pvsys->strExtraConfig.compare("type=HostOnly", Utf8Str::CaseInsensitive))
2052	{
2053	/* Attach to the right interface */
2054	rc = pNetworkAdapter->AttachToHostOnlyInterface();
2055	if (FAILED(rc)) throw rc;
2056	ComPtr<IHost> host;
2057	rc = pVirtualBox->COMGETTER(Host)(host.asOutParam());
2058	if (FAILED(rc)) throw rc;
2059	com::SafeIfaceArray<IHostNetworkInterface> nwInterfaces;
2060	rc = host->COMGETTER(NetworkInterfaces)(ComSafeArrayAsOutParam(nwInterfaces));
2061	if (FAILED(rc)) throw rc;
2062	/* We search for the first host network interface which
2063	* is usable for host only networking */
2064	for (size_t i=0; i < nwInterfaces.size(); ++i)
2065	{
2066	HostNetworkInterfaceType_T itype;
2067	rc = nwInterfaces[i]->COMGETTER(InterfaceType)(&itype);
2068	if (FAILED(rc)) throw rc;
2069	if (itype == HostNetworkInterfaceType_HostOnly)
2070	{
2071	Bstr name;
2072	rc = nwInterfaces[i]->COMGETTER(Name)(name.asOutParam());
2073	if (FAILED(rc)) throw rc;
2074	/* Set the interface name to attach to */
2075	pNetworkAdapter->COMSETTER(HostInterface)(name);
2076	if (FAILED(rc)) throw rc;
2077	break;
2078	}
2079	}
2080	}
2081	}
2082	}
2083
2084	/* Floppy drive */
2085	std::list<VirtualSystemDescriptionEntry*> vsdeFloppy = vsdescThis->findByType(VirtualSystemDescriptionType_Floppy);
2086	// Floppy support is enabled if there's at least one such entry; to disable floppy support,
2087	// the type of the floppy item would have been changed to "ignore"
2088	bool fFloppyEnabled = vsdeFloppy.size() > 0;
2089	ComPtr<IFloppyDrive> floppyDrive;
2090	rc = pNewMachine->COMGETTER(FloppyDrive)(floppyDrive.asOutParam());
2091	if (FAILED(rc)) throw rc;
2092	rc = floppyDrive->COMSETTER(Enabled)(fFloppyEnabled);
2093	if (FAILED(rc)) throw rc;
2094
2095	/* CDROM drive */
2096	/* @todo: I can't disable the CDROM. So nothing to do for now */
2097	// std::list<VirtualSystemDescriptionEntry*> vsdeFloppy = vsd->findByType(VirtualSystemDescriptionType_CDROM);
2098
2099	/* Hard disk controller IDE */
2100	std::list<VirtualSystemDescriptionEntry*> vsdeHDCIDE = vsdescThis->findByType(VirtualSystemDescriptionType_HardDiskControllerIDE);
2101	if (vsdeHDCIDE.size() > 1)
2102	throw setError(VBOX_E_FILE_ERROR,
2103	tr("Too many IDE controllers in OVF; VirtualBox only supports one"));
2104	if (vsdeHDCIDE.size() == 1)
2105	{
2106	ComPtr<IStorageController> pController;
2107	rc = pNewMachine->GetStorageControllerByName(Bstr("IDE"), pController.asOutParam());
2108	if (FAILED(rc)) throw rc;
2109
2110	const char *pcszIDEType = vsdeHDCIDE.front()->strVbox.c_str();
2111	if (!strcmp(pcszIDEType, "PIIX3"))
2112	rc = pController->COMSETTER(ControllerType)(StorageControllerType_PIIX3);
2113	else if (!strcmp(pcszIDEType, "PIIX4"))
2114	rc = pController->COMSETTER(ControllerType)(StorageControllerType_PIIX4);
2115	else if (!strcmp(pcszIDEType, "ICH6"))
2116	rc = pController->COMSETTER(ControllerType)(StorageControllerType_ICH6);
2117	else
2118	throw setError(VBOX_E_FILE_ERROR,
2119	tr("Invalid IDE controller type \"%s\""),
2120	pcszIDEType);
2121	if (FAILED(rc)) throw rc;
2122	}
2123	#ifdef VBOX_WITH_AHCI
2124	/* Hard disk controller SATA */
2125	std::list<VirtualSystemDescriptionEntry*> vsdeHDCSATA = vsdescThis->findByType(VirtualSystemDescriptionType_HardDiskControllerSATA);
2126	if (vsdeHDCSATA.size() > 1)
2127	throw setError(VBOX_E_FILE_ERROR,
2128	tr("Too many SATA controllers in OVF; VirtualBox only supports one"));
2129	if (vsdeHDCSATA.size() > 0)
2130	{
2131	ComPtr<IStorageController> pController;
2132	const Utf8Str &hdcVBox = vsdeHDCSATA.front()->strVbox;
2133	if (hdcVBox == "AHCI")
2134	{
2135	rc = pNewMachine->AddStorageController(Bstr("SATA"), StorageBus_SATA, pController.asOutParam());
2136	if (FAILED(rc)) throw rc;
2137	}
2138	else
2139	throw setError(VBOX_E_FILE_ERROR,
2140	tr("Invalid SATA controller type \"%s\""),
2141	hdcVBox.c_str());
2142	}
2143	#endif /* VBOX_WITH_AHCI */
2144
2145	/* Hard disk controller SCSI */
2146	std::list<VirtualSystemDescriptionEntry*> vsdeHDCSCSI = vsdescThis->findByType(VirtualSystemDescriptionType_HardDiskControllerSCSI);
2147	if (vsdeHDCSCSI.size() > 1)
2148	throw setError(VBOX_E_FILE_ERROR,
2149	tr("Too many SCSI controllers in OVF; VirtualBox only supports one"));
2150	if (vsdeHDCSCSI.size() > 0)
2151	{
2152	ComPtr<IStorageController> pController;
2153	StorageControllerType_T controllerType;
2154	const Utf8Str &hdcVBox = vsdeHDCSCSI.front()->strVbox;
2155	if (hdcVBox == "LsiLogic")
2156	controllerType = StorageControllerType_LsiLogic;
2157	else if (hdcVBox == "BusLogic")
2158	controllerType = StorageControllerType_BusLogic;
2159	else
2160	throw setError(VBOX_E_FILE_ERROR,
2161	tr("Invalid SCSI controller type \"%s\""),
2162	hdcVBox.c_str());
2163
2164	rc = pNewMachine->AddStorageController(Bstr("SCSI"), StorageBus_SCSI, pController.asOutParam());
2165	if (FAILED(rc)) throw rc;
2166	rc = pController->COMSETTER(ControllerType)(controllerType);
2167	if (FAILED(rc)) throw rc;
2168	}
2169
2170	/* Now its time to register the machine before we add any hard disks */
2171	rc = pVirtualBox->RegisterMachine(pNewMachine);
2172	if (FAILED(rc)) throw rc;
2173
2174	Guid newMachineId;
2175	rc = pNewMachine->COMGETTER(Id)(newMachineId.asOutParam());
2176	if (FAILED(rc)) throw rc;
2177
2178	// store new machine for roll-back in case of errors
2179	llMachinesRegistered.push_back(newMachineId);
2180
2181	/* Create the hard disks & connect them to the appropriate controllers. */
2182	std::list<VirtualSystemDescriptionEntry*> avsdeHDs = vsdescThis->findByType(VirtualSystemDescriptionType_HardDiskImage);
2183	if (avsdeHDs.size() > 0)
2184	{
2185	/* If in the next block an error occur we have to deregister
2186	the machine, so make an extra try/catch block. */
2187	ComPtr<IHardDisk> srcHdVBox;
2188	bool fSourceHdNeedsClosing = false;
2189
2190	try
2191	{
2192	/* In order to attach hard disks we need to open a session
2193	* for the new machine */
2194	rc = pVirtualBox->OpenSession(session, newMachineId);
2195	if (FAILED(rc)) throw rc;
2196	fSessionOpen = true;
2197
2198	/* The disk image has to be on the same place as the OVF file. So
2199	* strip the filename out of the full file path. */
2200	Utf8Str strSrcDir = stripFilename(pAppliance->m->strPath);
2201
2202	/* Iterate over all given disk images */
2203	list<VirtualSystemDescriptionEntry*>::const_iterator itHD;
2204	for (itHD = avsdeHDs.begin();
2205	itHD != avsdeHDs.end();
2206	++itHD)
2207	{
2208	VirtualSystemDescriptionEntry vsdeHD = itHD;
2209
2210	const char *pcszDstFilePath = vsdeHD->strVbox.c_str();
2211	/* Check if the destination file exists already or the
2212	* destination path is empty. */
2213	if ( !(*pcszDstFilePath)
2214	\|\| RTPathExists(pcszDstFilePath)
2215	)
2216	/* This isn't allowed */
2217	throw setError(VBOX_E_FILE_ERROR,
2218	tr("Destination file '%s' exists",
2219	pcszDstFilePath));
2220
2221	/* Find the disk from the OVF's disk list */
2222	DiskImagesMap::const_iterator itDiskImage = pAppliance->m->mapDisks.find(vsdeHD->strRef);
2223	/* vsdeHD->strRef contains the disk identifier (e.g. "vmdisk1"), which should exist
2224	in the virtual system's disks map under that ID and also in the global images map. */
2225	VirtualDisksMap::const_iterator itVirtualDisk = vsysThis.mapVirtualDisks.find(vsdeHD->strRef);
2226
2227	if ( itDiskImage == pAppliance->m->mapDisks.end()
2228	\|\| itVirtualDisk == vsysThis.mapVirtualDisks.end()
2229	)
2230	throw setError(E_FAIL,
2231	tr("Internal inconsistency looking up disk images."));
2232
2233	const DiskImage &di = itDiskImage->second;
2234	const VirtualDisk &vd = itVirtualDisk->second;
2235
2236	/* Make sure all target directories exists */
2237	rc = VirtualBox::ensureFilePathExists(pcszDstFilePath);
2238	if (FAILED(rc))
2239	throw rc;
2240
2241	// subprogress object for hard disk
2242	ComPtr<IProgress> pProgress2;
2243
2244	ComPtr<IHardDisk> dstHdVBox;
2245	/* If strHref is empty we have to create a new file */
2246	if (di.strHref.isEmpty())
2247	{
2248	/* Which format to use? */
2249	Bstr srcFormat = L"VDI";
2250	if ( di.strFormat.compare("http://www.vmware.com/specifications/vmdk.html#sparse", Utf8Str::CaseInsensitive)
2251	\|\| di.strFormat.compare("http://www.vmware.com/specifications/vmdk.html#compressed", Utf8Str::CaseInsensitive))
2252	srcFormat = L"VMDK";
2253	/* Create an empty hard disk */
2254	rc = pVirtualBox->CreateHardDisk(srcFormat, Bstr(pcszDstFilePath), dstHdVBox.asOutParam());
2255	if (FAILED(rc)) throw rc;
2256
2257	/* Create a dynamic growing disk image with the given capacity */
2258	rc = dstHdVBox->CreateBaseStorage(di.iCapacity / _1M, HardDiskVariant_Standard, pProgress2.asOutParam());
2259	if (FAILED(rc)) throw rc;
2260
2261	/* Advance to the next operation */
2262	if (!task->progress.isNull())
2263	task->progress->setNextOperation(BstrFmt(tr("Creating virtual disk image '%s'"), pcszDstFilePath),
2264	vsdeHD->ulSizeMB); // operation's weight, as set up with the IProgress originally
2265	}
2266	else
2267	{
2268	/* Construct the source file path */
2269	Utf8StrFmt strSrcFilePath("%s%c%s", strSrcDir.c_str(), RTPATH_DELIMITER, di.strHref.c_str());
2270	/* Check if the source file exists */
2271	if (!RTPathExists(strSrcFilePath.c_str()))
2272	/* This isn't allowed */
2273	throw setError(VBOX_E_FILE_ERROR,
2274	tr("Source virtual disk image file '%s' doesn't exist"),
2275	strSrcFilePath.c_str());
2276
2277	/* Clone the disk image (this is necessary cause the id has
2278	* to be recreated for the case the same hard disk is
2279	* attached already from a previous import) */
2280
2281	/* First open the existing disk image */
2282	rc = pVirtualBox->OpenHardDisk(Bstr(strSrcFilePath),
2283	AccessMode_ReadOnly,
2284	srcHdVBox.asOutParam());
2285	if (FAILED(rc)) throw rc;
2286	fSourceHdNeedsClosing = true;
2287
2288	/* We need the format description of the source disk image */
2289	Bstr srcFormat;
2290	rc = srcHdVBox->COMGETTER(Format)(srcFormat.asOutParam());
2291	if (FAILED(rc)) throw rc;
2292	/* Create a new hard disk interface for the destination disk image */
2293	rc = pVirtualBox->CreateHardDisk(srcFormat, Bstr(pcszDstFilePath), dstHdVBox.asOutParam());
2294	if (FAILED(rc)) throw rc;
2295	/* Clone the source disk image */
2296	rc = srcHdVBox->CloneTo(dstHdVBox, HardDiskVariant_Standard, NULL, pProgress2.asOutParam());
2297	if (FAILED(rc)) throw rc;
2298
2299	/* Advance to the next operation */
2300	if (!task->progress.isNull())
2301	task->progress->setNextOperation(BstrFmt(tr("Importing virtual disk image '%s'"), strSrcFilePath.c_str()),
2302	vsdeHD->ulSizeMB); // operation's weight, as set up with the IProgress originally);
2303	}
2304
2305	// now wait for the background disk operation to complete; this throws HRESULTs on error
2306	pAppliance->waitForAsyncProgress(task->progress, pProgress2);
2307
2308	if (fSourceHdNeedsClosing)
2309	{
2310	rc = srcHdVBox->Close();
2311	if (FAILED(rc)) throw rc;
2312	fSourceHdNeedsClosing = false;
2313	}
2314
2315	llHardDisksCreated.push_back(dstHdVBox);
2316	/* Now use the new uuid to attach the disk image to our new machine */
2317	ComPtr<IMachine> sMachine;
2318	rc = session->COMGETTER(Machine)(sMachine.asOutParam());
2319	if (FAILED(rc)) throw rc;
2320	Guid hdId;
2321	rc = dstHdVBox->COMGETTER(Id)(hdId.asOutParam());
2322	if (FAILED(rc)) throw rc;
2323
2324	/* For now we assume we have one controller of every type only */
2325	HardDiskController hdc = (*vsysThis.mapControllers.find(vd.idController)).second;
2326
2327	// this is for rollback later
2328	MyHardDiskAttachment mhda;
2329	mhda.uuid = newMachineId;
2330	mhda.pMachine = pNewMachine;
2331
2332	switch (hdc.system)
2333	{
2334	case HardDiskController::IDE:
2335	// For the IDE bus, the channel parameter can be either 0 or 1, to specify the primary
2336	// or secondary IDE controller, respectively. For the primary controller of the IDE bus,
2337	// the device number can be either 0 or 1, to specify the master or the slave device,
2338	// respectively. For the secondary IDE controller, the device number is always 1 because
2339	// the master device is reserved for the CD-ROM drive.
2340	mhda.controllerType = Bstr("IDE");
2341	switch (vd.ulAddressOnParent)
2342	{
2343	case 0: // interpret this as primary master
2344	mhda.lChannel = (long)0;
2345	mhda.lDevice = (long)0;
2346	break;
2347
2348	case 1: // interpret this as primary slave
2349	mhda.lChannel = (long)0;
2350	mhda.lDevice = (long)1;
2351	break;
2352
2353	case 2: // interpret this as secondary slave
2354	mhda.lChannel = (long)1;
2355	mhda.lDevice = (long)1;
2356	break;
2357
2358	default:
2359	throw setError(VBOX_E_NOT_SUPPORTED,
2360	tr("Invalid channel %RI16 specified; IDE controllers support only 0, 1 or 2"), vd.ulAddressOnParent);
2361	break;
2362	}
2363	break;
2364
2365	case HardDiskController::SATA:
2366	mhda.controllerType = Bstr("SATA");
2367	mhda.lChannel = (long)vd.ulAddressOnParent;
2368	mhda.lDevice = (long)0;
2369	break;
2370
2371	case HardDiskController::SCSI:
2372	mhda.controllerType = Bstr("SCSI");
2373	mhda.lChannel = (long)vd.ulAddressOnParent;
2374	mhda.lDevice = (long)0;
2375	break;
2376
2377	default: break;
2378	}
2379
2380	Log(("Attaching disk %s to channel %d on device %d\n", pcszDstFilePath, mhda.lChannel, mhda.lDevice));
2381
2382	rc = sMachine->AttachHardDisk(hdId,
2383	mhda.controllerType,
2384	mhda.lChannel,
2385	mhda.lDevice);
2386	if (FAILED(rc)) throw rc;
2387
2388	llHardDiskAttachments.push_back(mhda);
2389
2390	rc = sMachine->SaveSettings();
2391	if (FAILED(rc)) throw rc;
2392	} // end for (itHD = avsdeHDs.begin();
2393
2394	// only now that we're done with all disks, close the session
2395	rc = session->Close();
2396	if (FAILED(rc)) throw rc;
2397	fSessionOpen = false;
2398	}
2399	catch(HRESULT /* aRC */)
2400	{
2401	if (fSourceHdNeedsClosing)
2402	srcHdVBox->Close();
2403
2404	if (fSessionOpen)
2405	session->Close();
2406
2407	throw;
2408	}
2409	}
2410	}
2411	catch(HRESULT aRC)
2412	{
2413	rc = aRC;
2414	}
2415
2416	if (FAILED(rc))
2417	break;
2418
2419	} // for (it = pAppliance->m->llVirtualSystems.begin(),
2420
2421	if (FAILED(rc))
2422	{
2423	// with _whatever_ error we've had, do a complete roll-back of
2424	// machines and disks we've created; unfortunately this is
2425	// not so trivially done...
2426
2427	HRESULT rc2;
2428	// detach all hard disks from all machines we created
2429	list<MyHardDiskAttachment>::iterator itM;
2430	for (itM = llHardDiskAttachments.begin();
2431	itM != llHardDiskAttachments.end();
2432	++itM)
2433	{
2434	const MyHardDiskAttachment &mhda = *itM;
2435	rc2 = pVirtualBox->OpenSession(session, mhda.uuid);
2436	if (SUCCEEDED(rc2))
2437	{
2438	ComPtr<IMachine> sMachine;
2439	rc2 = session->COMGETTER(Machine)(sMachine.asOutParam());
2440	if (SUCCEEDED(rc2))
2441	{
2442	rc2 = sMachine->DetachHardDisk(Bstr(mhda.controllerType), mhda.lChannel, mhda.lDevice);
2443	rc2 = sMachine->SaveSettings();
2444	}
2445	session->Close();
2446	}
2447	}
2448
2449	// now clean up all hard disks we created
2450	list< ComPtr<IHardDisk> >::iterator itHD;
2451	for (itHD = llHardDisksCreated.begin();
2452	itHD != llHardDisksCreated.end();
2453	++itHD)
2454	{
2455	ComPtr<IHardDisk> pDisk = *itHD;
2456	ComPtr<IProgress> pProgress;
2457	rc2 = pDisk->DeleteStorage(pProgress.asOutParam());
2458	rc2 = pProgress->WaitForCompletion(-1);
2459	}
2460
2461	// finally, deregister and remove all machines
2462	list<Guid>::iterator itID;
2463	for (itID = llMachinesRegistered.begin();
2464	itID != llMachinesRegistered.end();
2465	++itID)
2466	{
2467	const Guid &guid = *itID;
2468	ComPtr<IMachine> failedMachine;
2469	rc2 = pVirtualBox->UnregisterMachine(guid, failedMachine.asOutParam());
2470	if (SUCCEEDED(rc2))
2471	rc2 = failedMachine->DeleteSettings();
2472	}
2473	}
2474
2475	task->rc = rc;
2476
2477	if (!task->progress.isNull())
2478	task->progress->notifyComplete(rc);
2479
2480	LogFlowFunc(("rc=%Rhrc\n", rc));
2481	LogFlowFuncLeave();
2482
2483	return VINF_SUCCESS;
2484	}
2485
2486	struct Appliance::TaskWriteOVF
2487	{
2488	TaskWriteOVF(Appliance aThat, Progress aProgress)
2489	: pAppliance(aThat),
2490	enFormat(unspecified),
2491	progress(aProgress),
2492	rc(S_OK)
2493	{}
2494	~TaskWriteOVF() {}
2495
2496	HRESULT startThread();
2497
2498	Appliance *pAppliance;
2499	enum { unspecified, OVF_0_9, OVF_1_0 }
2500	enFormat;
2501
2502	ComObjPtr<Progress> progress;
2503	HRESULT rc;
2504	};
2505
2506	HRESULT Appliance::TaskWriteOVF::startThread()
2507	{
2508	int vrc = RTThreadCreate(NULL, Appliance::taskThreadWriteOVF, this,
2509	0, RTTHREADTYPE_MAIN_HEAVY_WORKER, 0,
2510	"Appliance::Task");
2511	ComAssertMsgRCRet(vrc,
2512	("Could not create taskThreadExportOVF (%Rrc)\n", vrc), E_FAIL);
2513
2514	return S_OK;
2515	}
2516
2517	STDMETHODIMP Appliance::Write(IN_BSTR format, IN_BSTR path, IProgress **aProgress)
2518	{
2519	HRESULT rc = S_OK;
2520
2521	CheckComArgOutPointerValid(aProgress);
2522
2523	AutoCaller autoCaller(this);
2524	if (FAILED(rc = autoCaller.rc())) return rc;
2525
2526	AutoWriteLock(this);
2527
2528	// see if we can handle this file; for now we insist it has an ".ovf" extension
2529	m->strPath = path;
2530	if (!m->strPath.endsWith(".ovf", Utf8Str::CaseInsensitive))
2531	return setError(VBOX_E_FILE_ERROR,
2532	tr("Appliance file must have .ovf extension"));
2533
2534	ComObjPtr<Progress> progress;
2535	try
2536	{
2537	Bstr progressDesc = BstrFmt(tr("Export appliance '%s'"),
2538	m->strPath.raw());
2539	rc = setUpProgress(progress, progressDesc);
2540	if (FAILED(rc)) throw rc;
2541
2542	/* Initialize our worker task */
2543	std::auto_ptr<TaskWriteOVF> task(new TaskWriteOVF(this, progress));
2544	//AssertComRCThrowRC (task->autoCaller.rc());
2545
2546	Utf8Str strFormat(format);
2547	if (strFormat == "ovf-0.9")
2548	task->enFormat = TaskWriteOVF::OVF_0_9;
2549	else if (strFormat == "ovf-1.0")
2550	task->enFormat = TaskWriteOVF::OVF_1_0;
2551	else
2552	return setError(VBOX_E_FILE_ERROR,
2553	tr("Invalid format \"%s\" specified"), strFormat.c_str());
2554
2555	rc = task->startThread();
2556	CheckComRCThrowRC(rc);
2557
2558	task.release();
2559	}
2560	catch (HRESULT aRC)
2561	{
2562	rc = aRC;
2563	}
2564
2565	if (SUCCEEDED(rc))
2566	/* Return progress to the caller */
2567	progress.queryInterfaceTo(aProgress);
2568
2569	return rc;
2570	}
2571
2572	/**
2573	* Worker thread implementation for Write() (ovf writer).
2574	* @param aThread
2575	* @param pvUser
2576	*/
2577	/* static */
2578	DECLCALLBACK(int) Appliance::taskThreadWriteOVF(RTTHREAD /* aThread /, void pvUser)
2579	{
2580	std::auto_ptr<TaskWriteOVF> task(static_cast<TaskWriteOVF*>(pvUser));
2581	AssertReturn(task.get(), VERR_GENERAL_FAILURE);
2582
2583	Appliance *pAppliance = task->pAppliance;
2584
2585	LogFlowFuncEnter();
2586	LogFlowFunc(("Appliance %p\n", pAppliance));
2587
2588	AutoCaller autoCaller(pAppliance);
2589	CheckComRCReturnRC(autoCaller.rc());
2590
2591	AutoWriteLock appLock(pAppliance);
2592
2593	HRESULT rc = S_OK;
2594
2595	ComPtr<IVirtualBox> pVirtualBox(pAppliance->mVirtualBox);
2596
2597	try
2598	{
2599	xml::Document doc;
2600	xml::ElementNode *pelmRoot = doc.createRootElement("Envelope");
2601
2602	pelmRoot->setAttribute("ovf:version", (task->enFormat == TaskWriteOVF::OVF_1_0) ? "1.0" : "0.9");
2603	pelmRoot->setAttribute("xml:lang", "en-US");
2604
2605	Utf8Str strNamespace = (TaskWriteOVF::OVF_0_9)
2606	? "http://www.vmware.com/schema/ovf/1/envelope" // 0.9
2607	: "http://schemas.dmtf.org/ovf/envelope/1"; // 1.0
2608	pelmRoot->setAttribute("xmlns", strNamespace);
2609	pelmRoot->setAttribute("xmlns:ovf", strNamespace);
2610
2611	// pelmRoot->setAttribute("xmlns:ovfstr", "http://schema.dmtf.org/ovf/strings/1");
2612	pelmRoot->setAttribute("xmlns:rasd", "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData");
2613	pelmRoot->setAttribute("xmlns:vssd", "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_VirtualSystemSettingData");
2614	pelmRoot->setAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
2615	// pelmRoot->setAttribute("xsi:schemaLocation", "http://schemas.dmtf.org/ovf/envelope/1 ../ovf-envelope.xsd");
2616
2617	// <Envelope>/<References>
2618	xml::ElementNode *pelmReferences = pelmRoot->createChild("References"); // 0.9 and 1.0
2619
2620	/* <Envelope>/<DiskSection>:
2621	<DiskSection>
2622	<Info>List of the virtual disks used in the package</Info>
2623	<Disk ovf:capacity="4294967296" ovf:diskId="lamp" ovf:format="http://www.vmware.com/specifications/vmdk.html#compressed" ovf:populatedSize="1924967692"/>
2624	</DiskSection> */
2625	xml::ElementNode *pelmDiskSection;
2626	if (task->enFormat == TaskWriteOVF::OVF_0_9)
2627	{
2628	// <Section xsi:type="ovf:DiskSection_Type">
2629	pelmDiskSection = pelmRoot->createChild("Section");
2630	pelmDiskSection->setAttribute("xsi:type", "ovf:DiskSection_Type");
2631	}
2632	else
2633	pelmDiskSection = pelmRoot->createChild("DiskSection");
2634
2635	xml::ElementNode *pelmDiskSectionInfo = pelmDiskSection->createChild("Info");
2636	pelmDiskSectionInfo->addContent("List of the virtual disks used in the package");
2637	// for now, set up a map so we have a list of unique disk names (to make
2638	// sure the same disk name is only added once)
2639	map<Utf8Str, const VirtualSystemDescriptionEntry*> mapDisks;
2640
2641	/* <Envelope>/<NetworkSection>:
2642	<NetworkSection>
2643	<Info>Logical networks used in the package</Info>
2644	<Network ovf:name="VM Network">
2645	<Description>The network that the LAMP Service will be available on</Description>
2646	</Network>
2647	</NetworkSection> */
2648	xml::ElementNode *pelmNetworkSection;
2649	if (task->enFormat == TaskWriteOVF::OVF_0_9)
2650	{
2651	// <Section xsi:type="ovf:NetworkSection_Type">
2652	pelmNetworkSection = pelmRoot->createChild("Section");
2653	pelmNetworkSection->setAttribute("xsi:type", "ovf:NetworkSection_Type");
2654	}
2655	else
2656	pelmNetworkSection = pelmRoot->createChild("NetworkSection");
2657
2658	xml::ElementNode *pelmNetworkSectionInfo = pelmNetworkSection->createChild("Info");
2659	pelmNetworkSectionInfo->addContent("Logical networks used in the package");
2660	// for now, set up a map so we have a list of unique network names (to make
2661	// sure the same network name is only added once)
2662	map<Utf8Str, bool> mapNetworks;
2663	// we fill this later below when we iterate over the networks
2664
2665	// and here come the virtual systems:
2666
2667	// write a collection if we have more than one virtual system _and_ we're
2668	// writing OVF 1.0; otherwise fail since ovftool can't import more than
2669	// one machine, it seems
2670	xml::ElementNode *pelmToAddVirtualSystemsTo;
2671	if (pAppliance->m->virtualSystemDescriptions.size() > 1)
2672	{
2673	if (task->enFormat == TaskWriteOVF::OVF_0_9)
2674	throw setError(VBOX_E_FILE_ERROR,
2675	tr("Cannot export more than one virtual system with OVF 0.9, use OVF 1.0"));
2676
2677	pelmToAddVirtualSystemsTo = pelmRoot->createChild("VirtualSystemCollection");
2678	/* xml::AttributeNode pattrVirtualSystemCollectionId = / pelmToAddVirtualSystemsTo->setAttribute("ovf:name", "ExportedVirtualBoxMachines"); // whatever
2679	}
2680	else
2681	pelmToAddVirtualSystemsTo = pelmRoot; // add virtual system directly under root element
2682
2683	list< ComObjPtr<VirtualSystemDescription> >::const_iterator it;
2684	/* Iterate through all virtual systems of that appliance */
2685	for (it = pAppliance->m->virtualSystemDescriptions.begin();
2686	it != pAppliance->m->virtualSystemDescriptions.end();
2687	++it)
2688	{
2689	ComObjPtr<VirtualSystemDescription> vsdescThis = (*it);
2690
2691	xml::ElementNode *pelmVirtualSystem;
2692	if (task->enFormat == TaskWriteOVF::OVF_0_9)
2693	{
2694	// <Section xsi:type="ovf:NetworkSection_Type">
2695	pelmVirtualSystem = pelmToAddVirtualSystemsTo->createChild("Content");
2696	pelmVirtualSystem->setAttribute("xsi:type", "ovf:VirtualSystem_Type");
2697	}
2698	else
2699	pelmVirtualSystem = pelmToAddVirtualSystemsTo->createChild("VirtualSystem");
2700
2701	/xml::ElementNode pelmVirtualSystemInfo =*/ pelmVirtualSystem->createChild("Info")->addContent("A virtual machine");
2702
2703	std::list<VirtualSystemDescriptionEntry*> llName = vsdescThis->findByType(VirtualSystemDescriptionType_Name);
2704	if (llName.size() != 1)
2705	throw setError(VBOX_E_NOT_SUPPORTED,
2706	tr("Missing VM name"));
2707	Utf8Str &strVMName = llName.front()->strVbox;
2708	pelmVirtualSystem->setAttribute("ovf:id", strVMName);
2709
2710	// product info
2711	std::list<VirtualSystemDescriptionEntry*> llProduct = vsdescThis->findByType(VirtualSystemDescriptionType_Product);
2712	std::list<VirtualSystemDescriptionEntry*> llProductUrl = vsdescThis->findByType(VirtualSystemDescriptionType_ProductUrl);
2713	std::list<VirtualSystemDescriptionEntry*> llVendor = vsdescThis->findByType(VirtualSystemDescriptionType_Vendor);
2714	std::list<VirtualSystemDescriptionEntry*> llVendorUrl = vsdescThis->findByType(VirtualSystemDescriptionType_VendorUrl);
2715	std::list<VirtualSystemDescriptionEntry*> llVersion = vsdescThis->findByType(VirtualSystemDescriptionType_Version);
2716	bool fProduct = llProduct.size() && !llProduct.front()->strVbox.isEmpty();
2717	bool fProductUrl = llProductUrl.size() && !llProductUrl.front()->strVbox.isEmpty();
2718	bool fVendor = llVendor.size() && !llVendor.front()->strVbox.isEmpty();
2719	bool fVendorUrl = llVendorUrl.size() && !llVendorUrl.front()->strVbox.isEmpty();
2720	bool fVersion = llVersion.size() && !llVersion.front()->strVbox.isEmpty();
2721	if (fProduct \|\|
2722	fProductUrl \|\|
2723	fVersion \|\|
2724	fVendorUrl \|\|
2725	fVersion)
2726	{
2727	/* <Section ovf:required="false" xsi:type="ovf:ProductSection_Type">
2728	<Info>Meta-information about the installed software</Info>
2729	<Product>VAtest</Product>
2730	<Vendor>SUN Microsystems</Vendor>
2731	<Version>10.0</Version>
2732	<ProductUrl>http://blogs.sun.com/VirtualGuru</ProductUrl>
2733	<VendorUrl>http://www.sun.com</VendorUrl>
2734	</Section> */
2735	xml::ElementNode *pelmAnnotationSection;
2736	if (task->enFormat == TaskWriteOVF::OVF_0_9)
2737	{
2738	// <Section ovf:required="false" xsi:type="ovf:ProductSection_Type">
2739	pelmAnnotationSection = pelmVirtualSystem->createChild("Section");
2740	pelmAnnotationSection->setAttribute("xsi:type", "ovf:ProductSection_Type");
2741	}
2742	else
2743	pelmAnnotationSection = pelmVirtualSystem->createChild("ProductSection");
2744
2745	pelmAnnotationSection->createChild("Info")->addContent("Meta-information about the installed software");
2746	if (fProduct)
2747	pelmAnnotationSection->createChild("Product")->addContent(llProduct.front()->strVbox);
2748	if (fVendor)
2749	pelmAnnotationSection->createChild("Vendor")->addContent(llVendor.front()->strVbox);
2750	if (fVersion)
2751	pelmAnnotationSection->createChild("Version")->addContent(llVersion.front()->strVbox);
2752	if (fProductUrl)
2753	pelmAnnotationSection->createChild("ProductUrl")->addContent(llProductUrl.front()->strVbox);
2754	if (fVendorUrl)
2755	pelmAnnotationSection->createChild("VendorUrl")->addContent(llVendorUrl.front()->strVbox);
2756	}
2757
2758	// description
2759	std::list<VirtualSystemDescriptionEntry*> llDescription = vsdescThis->findByType(VirtualSystemDescriptionType_Description);
2760	if (llDescription.size() &&
2761	!llDescription.front()->strVbox.isEmpty())
2762	{
2763	/* <Section ovf:required="false" xsi:type="ovf:AnnotationSection_Type">
2764	<Info>A human-readable annotation</Info>
2765	<Annotation>Plan 9</Annotation>
2766	</Section> */
2767	xml::ElementNode *pelmAnnotationSection;
2768	if (task->enFormat == TaskWriteOVF::OVF_0_9)
2769	{
2770	// <Section ovf:required="false" xsi:type="ovf:AnnotationSection_Type">
2771	pelmAnnotationSection = pelmVirtualSystem->createChild("Section");
2772	pelmAnnotationSection->setAttribute("xsi:type", "ovf:AnnotationSection_Type");
2773	}
2774	else
2775	pelmAnnotationSection = pelmVirtualSystem->createChild("AnnotationSection");
2776
2777	pelmAnnotationSection->createChild("Info")->addContent("A human-readable annotation");
2778	pelmAnnotationSection->createChild("Annotation")->addContent(llDescription.front()->strVbox);
2779	}
2780
2781	// license
2782	std::list<VirtualSystemDescriptionEntry*> llLicense = vsdescThis->findByType(VirtualSystemDescriptionType_License);
2783	if (llLicense.size() &&
2784	!llLicense.front()->strVbox.isEmpty())
2785	{
2786	/* <EulaSection>
2787	<Info ovf:msgid="6">License agreement for the Virtual System.</Info>
2788	<License ovf:msgid="1">License terms can go in here.</License>
2789	</EulaSection> */
2790	xml::ElementNode *pelmEulaSection;
2791	if (task->enFormat == TaskWriteOVF::OVF_0_9)
2792	{
2793	pelmEulaSection = pelmVirtualSystem->createChild("Section");
2794	pelmEulaSection->setAttribute("xsi:type", "ovf:EulaSection_Type");
2795	}
2796	else
2797	pelmEulaSection = pelmVirtualSystem->createChild("EulaSection");
2798
2799	pelmEulaSection->createChild("Info")->addContent("License agreement for the virtual system");
2800	pelmEulaSection->createChild("License")->addContent(llLicense.front()->strVbox);
2801	}
2802
2803	// operating system
2804	std::list<VirtualSystemDescriptionEntry*> llOS = vsdescThis->findByType(VirtualSystemDescriptionType_OS);
2805	if (llOS.size() != 1)
2806	throw setError(VBOX_E_NOT_SUPPORTED,
2807	tr("Missing OS type"));
2808	/* <OperatingSystemSection ovf:id="82">
2809	<Info>Guest Operating System</Info>
2810	<Description>Linux 2.6.x</Description>
2811	</OperatingSystemSection> */
2812	xml::ElementNode *pelmOperatingSystemSection;
2813	if (task->enFormat == TaskWriteOVF::OVF_0_9)
2814	{
2815	pelmOperatingSystemSection = pelmVirtualSystem->createChild("Section");
2816	pelmOperatingSystemSection->setAttribute("xsi:type", "ovf:OperatingSystemSection_Type");
2817	}
2818	else
2819	pelmOperatingSystemSection = pelmVirtualSystem->createChild("OperatingSystemSection");
2820
2821	pelmOperatingSystemSection->setAttribute("ovf:id", llOS.front()->strOvf);
2822	pelmOperatingSystemSection->createChild("Info")->addContent("The kind of installed guest operating system");
2823	Utf8Str strOSDesc;
2824	convertCIMOSType2VBoxOSType(strOSDesc, (CIMOSType_T)llOS.front()->strOvf.toInt32(), "");
2825	pelmOperatingSystemSection->createChild("Description")->addContent(strOSDesc);
2826
2827	// <VirtualHardwareSection ovf:id="hw1" ovf:transport="iso">
2828	xml::ElementNode *pelmVirtualHardwareSection;
2829	if (task->enFormat == TaskWriteOVF::OVF_0_9)
2830	{
2831	// <Section xsi:type="ovf:VirtualHardwareSection_Type">
2832	pelmVirtualHardwareSection = pelmVirtualSystem->createChild("Section");
2833	pelmVirtualHardwareSection->setAttribute("xsi:type", "ovf:VirtualHardwareSection_Type");
2834	}
2835	else
2836	pelmVirtualHardwareSection = pelmVirtualSystem->createChild("VirtualHardwareSection");
2837
2838	pelmVirtualHardwareSection->createChild("Info")->addContent("Virtual hardware requirements for a virtual machine");
2839
2840	/* <System>
2841	<vssd:Description>Description of the virtual hardware section.</vssd:Description>
2842	<vssd:ElementName>vmware</vssd:ElementName>
2843	<vssd:InstanceID>1</vssd:InstanceID>
2844	<vssd:VirtualSystemIdentifier>MyLampService</vssd:VirtualSystemIdentifier>
2845	<vssd:VirtualSystemType>vmx-4</vssd:VirtualSystemType>
2846	</System> */
2847	xml::ElementNode *pelmSystem = pelmVirtualHardwareSection->createChild("System");
2848
2849	// <vssd:InstanceId>0</vssd:InstanceId>
2850	pelmSystem->createChild("vssd:InstanceId")->addContent("0");
2851	// <vssd:VirtualSystemIdentifier>VAtest</vssd:VirtualSystemIdentifier>
2852	pelmSystem->createChild("vssd:VirtualSystemIdentifier")->addContent(strVMName);
2853	// <vssd:VirtualSystemType>vmx-4</vssd:VirtualSystemType>
2854	const char *pcszHardware = "virtualbox-2.2";
2855	if (task->enFormat == TaskWriteOVF::OVF_0_9)
2856	// pretend to be vmware compatible then
2857	pcszHardware = "vmx-6";
2858	pelmSystem->createChild("vssd:VirtualSystemType")->addContent(pcszHardware);
2859
2860	// loop thru all description entries twice; once to write out all
2861	// devices _except_ disk images, and a second time to assign the
2862	// disk images; this is because disk images need to reference
2863	// IDE controllers, and we can't know their instance IDs without
2864	// assigning them first
2865
2866	uint32_t idIDEController = 0;
2867	int32_t lIDEControllerIndex = 0;
2868	uint32_t idSATAController = 0;
2869	int32_t lSATAControllerIndex = 0;
2870	uint32_t idSCSIController = 0;
2871	int32_t lSCSIControllerIndex = 0;
2872
2873	uint32_t ulInstanceID = 1;
2874	uint32_t cDisks = 0;
2875
2876	for (size_t uLoop = 1;
2877	uLoop <= 2;
2878	++uLoop)
2879	{
2880	int32_t lIndexThis = 0;
2881	list<VirtualSystemDescriptionEntry>::const_iterator itD;
2882	for (itD = vsdescThis->m->llDescriptions.begin();
2883	itD != vsdescThis->m->llDescriptions.end();
2884	++itD, ++lIndexThis)
2885	{
2886	const VirtualSystemDescriptionEntry &desc = *itD;
2887
2888	OVFResourceType_T type = (OVFResourceType_T)0; // if this becomes != 0 then we do stuff
2889	Utf8Str strResourceSubType;
2890
2891	Utf8Str strDescription; // results in <rasd:Description>...</rasd:Description> block
2892	Utf8Str strCaption; // results in <rasd:Caption>...</rasd:Caption> block
2893
2894	uint32_t ulParent = 0;
2895
2896	int32_t lVirtualQuantity = -1;
2897	Utf8Str strAllocationUnits;
2898
2899	int32_t lAddress = -1;
2900	int32_t lBusNumber = -1;
2901	int32_t lAddressOnParent = -1;
2902
2903	int32_t lAutomaticAllocation = -1; // 0 means "false", 1 means "true"
2904	Utf8Str strConnection; // results in <rasd:Connection>...</rasd:Connection> block
2905	Utf8Str strHostResource;
2906
2907	uint64_t uTemp;
2908
2909	switch (desc.type)
2910	{
2911	case VirtualSystemDescriptionType_CPU:
2912	/* <Item>
2913	<rasd:Caption>1 virtual CPU</rasd:Caption>
2914	<rasd:Description>Number of virtual CPUs</rasd:Description>
2915	<rasd:ElementName>virtual CPU</rasd:ElementName>
2916	<rasd:InstanceID>1</rasd:InstanceID>
2917	<rasd:ResourceType>3</rasd:ResourceType>
2918	<rasd:VirtualQuantity>1</rasd:VirtualQuantity>
2919	</Item> */
2920	if (uLoop == 1)
2921	{
2922	strDescription = "Number of virtual CPUs";
2923	type = OVFResourceType_Processor; // 3
2924	lVirtualQuantity = 1;
2925	}
2926	break;
2927
2928	case VirtualSystemDescriptionType_Memory:
2929	/* <Item>
2930	<rasd:AllocationUnits>MegaBytes</rasd:AllocationUnits>
2931	<rasd:Caption>256 MB of memory</rasd:Caption>
2932	<rasd:Description>Memory Size</rasd:Description>
2933	<rasd:ElementName>Memory</rasd:ElementName>
2934	<rasd:InstanceID>2</rasd:InstanceID>
2935	<rasd:ResourceType>4</rasd:ResourceType>
2936	<rasd:VirtualQuantity>256</rasd:VirtualQuantity>
2937	</Item> */
2938	if (uLoop == 1)
2939	{
2940	strDescription = "Memory Size";
2941	type = OVFResourceType_Memory; // 4
2942	desc.strVbox.toInt(uTemp);
2943	lVirtualQuantity = (int32_t)(uTemp / _1M);
2944	strAllocationUnits = "MegaBytes";
2945	strCaption = Utf8StrFmt("%d MB of memory", lVirtualQuantity); // without this ovftool won't eat the item
2946	}
2947	break;
2948
2949	case VirtualSystemDescriptionType_HardDiskControllerIDE:
2950	/* <Item>
2951	<rasd:Caption>ideController1</rasd:Caption>
2952	<rasd:Description>IDE Controller</rasd:Description>
2953	<rasd:InstanceId>5</rasd:InstanceId>
2954	<rasd:ResourceType>5</rasd:ResourceType>
2955	<rasd:Address>1</rasd:Address>
2956	<rasd:BusNumber>1</rasd:BusNumber>
2957	</Item> */
2958	if (uLoop == 1)
2959	{
2960	strDescription = "IDE Controller";
2961	type = OVFResourceType_IDEController; // 5
2962	strResourceSubType = desc.strVbox;
2963	// it seems that OVFTool always writes these two, and since we can only
2964	// have one IDE controller, we'll use this as well
2965	lAddress = 1;
2966	lBusNumber = 1;
2967
2968	// remember this ID
2969	idIDEController = ulInstanceID;
2970	lIDEControllerIndex = lIndexThis;
2971	}
2972	break;
2973
2974	case VirtualSystemDescriptionType_HardDiskControllerSATA:
2975	/* <Item>
2976	<rasd:Caption>sataController0</rasd:Caption>
2977	<rasd:Description>SATA Controller</rasd:Description>
2978	<rasd:InstanceId>4</rasd:InstanceId>
2979	<rasd:ResourceType>20</rasd:ResourceType>
2980	<rasd:ResourceSubType>ahci</rasd:ResourceSubType>
2981	<rasd:Address>0</rasd:Address>
2982	<rasd:BusNumber>0</rasd:BusNumber>
2983	</Item>
2984	*/
2985	if (uLoop == 1)
2986	{
2987	strDescription = "SATA Controller";
2988	strCaption = "sataController0";
2989	type = OVFResourceType_OtherStorageDevice; // 20
2990	// it seems that OVFTool always writes these two, and since we can only
2991	// have one SATA controller, we'll use this as well
2992	lAddress = 0;
2993	lBusNumber = 0;
2994
2995	if ( desc.strVbox.isEmpty() // AHCI is the default in VirtualBox
2996	\|\| (!desc.strVbox.compare("ahci", Utf8Str::CaseInsensitive))
2997	)
2998	strResourceSubType = "AHCI";
2999	else
3000	throw setError(VBOX_E_NOT_SUPPORTED,
3001	tr("Invalid config string \"%s\" in SATA controller"), desc.strVbox.c_str());
3002
3003	// remember this ID
3004	idSATAController = ulInstanceID;
3005	lSATAControllerIndex = lIndexThis;
3006	}
3007	break;
3008
3009	case VirtualSystemDescriptionType_HardDiskControllerSCSI:
3010	/* <Item>
3011	<rasd:Caption>scsiController0</rasd:Caption>
3012	<rasd:Description>SCSI Controller</rasd:Description>
3013	<rasd:InstanceId>4</rasd:InstanceId>
3014	<rasd:ResourceType>6</rasd:ResourceType>
3015	<rasd:ResourceSubType>buslogic</rasd:ResourceSubType>
3016	<rasd:Address>0</rasd:Address>
3017	<rasd:BusNumber>0</rasd:BusNumber>
3018	</Item>
3019	*/
3020	if (uLoop == 1)
3021	{
3022	strDescription = "SCSI Controller";
3023	strCaption = "scsiController0";
3024	type = OVFResourceType_ParallelSCSIHBA; // 6
3025	// it seems that OVFTool always writes these two, and since we can only
3026	// have one SATA controller, we'll use this as well
3027	lAddress = 0;
3028	lBusNumber = 0;
3029
3030	if ( desc.strVbox.isEmpty() // LsiLogic is the default in VirtualBox
3031	\|\| (!desc.strVbox.compare("lsilogic", Utf8Str::CaseInsensitive))
3032	)
3033	strResourceSubType = "lsilogic";
3034	else if (!desc.strVbox.compare("buslogic", Utf8Str::CaseInsensitive))
3035	strResourceSubType = "buslogic";
3036	else
3037	throw setError(VBOX_E_NOT_SUPPORTED,
3038	tr("Invalid config string \"%s\" in SCSI controller"), desc.strVbox.c_str());
3039
3040	// remember this ID
3041	idSCSIController = ulInstanceID;
3042	lSCSIControllerIndex = lIndexThis;
3043	}
3044	break;
3045
3046	case VirtualSystemDescriptionType_HardDiskImage:
3047	/* <Item>
3048	<rasd:Caption>disk1</rasd:Caption>
3049	<rasd:InstanceId>8</rasd:InstanceId>
3050	<rasd:ResourceType>17</rasd:ResourceType>
3051	<rasd:HostResource>/disk/vmdisk1</rasd:HostResource>
3052	<rasd:Parent>4</rasd:Parent>
3053	<rasd:AddressOnParent>0</rasd:AddressOnParent>
3054	</Item> */
3055	if (uLoop == 2)
3056	{
3057	Utf8Str strDiskID = Utf8StrFmt("vmdisk%RI32", ++cDisks);
3058
3059	strDescription = "Disk Image";
3060	strCaption = Utf8StrFmt("disk%RI32", cDisks); // this is not used for anything else
3061	type = OVFResourceType_HardDisk; // 17
3062
3063	// the following references the "<Disks>" XML block
3064	strHostResource = Utf8StrFmt("/disk/%s", strDiskID.c_str());
3065
3066	// controller=<index>;channel=<c>
3067	size_t pos1 = desc.strExtraConfig.find("controller=");
3068	size_t pos2 = desc.strExtraConfig.find("channel=");
3069	if (pos1 != Utf8Str::npos)
3070	{
3071	int32_t lControllerIndex = -1;
3072	RTStrToInt32Ex(desc.strExtraConfig.c_str() + pos1 + 11, NULL, 0, &lControllerIndex);
3073	if (lControllerIndex == lIDEControllerIndex)
3074	ulParent = idIDEController;
3075	else if (lControllerIndex == lSCSIControllerIndex)
3076	ulParent = idSCSIController;
3077	else if (lControllerIndex == lSATAControllerIndex)
3078	ulParent = idSATAController;
3079	}
3080	if (pos2 != Utf8Str::npos)
3081	RTStrToInt32Ex(desc.strExtraConfig.c_str() + pos2 + 8, NULL, 0, &lAddressOnParent);
3082
3083	if ( !ulParent
3084	\|\| lAddressOnParent == -1
3085	)
3086	throw setError(VBOX_E_NOT_SUPPORTED,
3087	tr("Missing or bad extra config string in hard disk image: \"%s\""), desc.strExtraConfig.c_str());
3088
3089	mapDisks[strDiskID] = &desc;
3090	}
3091	break;
3092
3093	case VirtualSystemDescriptionType_Floppy:
3094	if (uLoop == 1)
3095	{
3096	strDescription = "Floppy Drive";
3097	strCaption = "floppy0"; // this is what OVFTool writes
3098	type = OVFResourceType_FloppyDrive; // 14
3099	lAutomaticAllocation = 0;
3100	lAddressOnParent = 0; // this is what OVFTool writes
3101	}
3102	break;
3103
3104	case VirtualSystemDescriptionType_CDROM:
3105	if (uLoop == 2)
3106	{
3107	// we can't have a CD without an IDE controller
3108	if (!idIDEController)
3109	throw setError(VBOX_E_NOT_SUPPORTED,
3110	tr("Can't have CD-ROM without IDE controller"));
3111
3112	strDescription = "CD-ROM Drive";
3113	strCaption = "cdrom1"; // this is what OVFTool writes
3114	type = OVFResourceType_CDDrive; // 15
3115	lAutomaticAllocation = 1;
3116	ulParent = idIDEController;
3117	lAddressOnParent = 0; // this is what OVFTool writes
3118	}
3119	break;
3120
3121	case VirtualSystemDescriptionType_NetworkAdapter:
3122	/* <Item>
3123	<rasd:AutomaticAllocation>true</rasd:AutomaticAllocation>
3124	<rasd:Caption>Ethernet adapter on 'VM Network'</rasd:Caption>
3125	<rasd:Connection>VM Network</rasd:Connection>
3126	<rasd:ElementName>VM network</rasd:ElementName>
3127	<rasd:InstanceID>3</rasd:InstanceID>
3128	<rasd:ResourceType>10</rasd:ResourceType>
3129	</Item> */
3130	if (uLoop == 1)
3131	{
3132	lAutomaticAllocation = 1;
3133	strCaption = Utf8StrFmt("Ethernet adapter on '%s'", desc.strOvf.c_str());
3134	type = OVFResourceType_EthernetAdapter; // 10
3135	/* Set the hardware type to something useful.
3136	* To be compatible with vmware & others we set
3137	* PCNet32 for our PCNet types & E1000 for the
3138	* E1000 cards. */
3139	switch (desc.strVbox.toInt32())
3140	{
3141	case NetworkAdapterType_Am79C970A:
3142	case NetworkAdapterType_Am79C973: strResourceSubType = "PCNet32"; break;
3143	#ifdef VBOX_WITH_E1000
3144	case NetworkAdapterType_I82540EM:
3145	case NetworkAdapterType_I82545EM:
3146	case NetworkAdapterType_I82543GC: strResourceSubType = "E1000"; break;
3147	#endif /* VBOX_WITH_E1000 */
3148	}
3149	strConnection = desc.strOvf;
3150
3151	mapNetworks[desc.strOvf] = true;
3152	}
3153	break;
3154
3155	case VirtualSystemDescriptionType_USBController:
3156	/* <Item ovf:required="false">
3157	<rasd:Caption>usb</rasd:Caption>
3158	<rasd:Description>USB Controller</rasd:Description>
3159	<rasd:InstanceId>3</rasd:InstanceId>
3160	<rasd:ResourceType>23</rasd:ResourceType>
3161	<rasd:Address>0</rasd:Address>
3162	<rasd:BusNumber>0</rasd:BusNumber>
3163	</Item> */
3164	if (uLoop == 1)
3165	{
3166	strDescription = "USB Controller";
3167	strCaption = "usb";
3168	type = OVFResourceType_USBController; // 23
3169	lAddress = 0; // this is what OVFTool writes
3170	lBusNumber = 0; // this is what OVFTool writes
3171	}
3172	break;
3173
3174	case VirtualSystemDescriptionType_SoundCard:
3175	/* <Item ovf:required="false">
3176	<rasd:Caption>sound</rasd:Caption>
3177	<rasd:Description>Sound Card</rasd:Description>
3178	<rasd:InstanceId>10</rasd:InstanceId>
3179	<rasd:ResourceType>35</rasd:ResourceType>
3180	<rasd:ResourceSubType>ensoniq1371</rasd:ResourceSubType>
3181	<rasd:AutomaticAllocation>false</rasd:AutomaticAllocation>
3182	<rasd:AddressOnParent>3</rasd:AddressOnParent>
3183	</Item> */
3184	if (uLoop == 1)
3185	{
3186	strDescription = "Sound Card";
3187	strCaption = "sound";
3188	type = OVFResourceType_SoundCard; // 35
3189	strResourceSubType = desc.strOvf; // e.g. ensoniq1371
3190	lAutomaticAllocation = 0;
3191	lAddressOnParent = 3; // what gives? this is what OVFTool writes
3192	}
3193	break;
3194	}
3195
3196	if (type)
3197	{
3198	xml::ElementNode *pItem;
3199
3200	pItem = pelmVirtualHardwareSection->createChild("Item");
3201
3202	// NOTE: do not change the order of these items without good reason! While we don't care
3203	// about ordering, VMware's ovftool does and fails if the items are not written in
3204	// exactly this order, as stupid as it seems.
3205
3206	if (!strCaption.isEmpty())
3207	pItem->createChild("rasd:Caption")->addContent(strCaption);
3208	if (!strDescription.isEmpty())
3209	pItem->createChild("rasd:Description")->addContent(strDescription);
3210
3211	// <rasd:InstanceID>1</rasd:InstanceID>
3212	xml::ElementNode *pelmInstanceID;
3213	if (task->enFormat == TaskWriteOVF::OVF_0_9)
3214	pelmInstanceID = pItem->createChild("rasd:InstanceId");
3215	else
3216	pelmInstanceID = pItem->createChild("rasd:InstanceID"); // capitalization changed...
3217	pelmInstanceID->addContent(Utf8StrFmt("%d", ulInstanceID++));
3218
3219	// <rasd:ResourceType>3</rasd:ResourceType>
3220	pItem->createChild("rasd:ResourceType")->addContent(Utf8StrFmt("%d", type));
3221	if (!strResourceSubType.isEmpty())
3222	pItem->createChild("rasd:ResourceSubType")->addContent(strResourceSubType);
3223
3224	if (!strHostResource.isEmpty())
3225	pItem->createChild("rasd:HostResource")->addContent(strHostResource);
3226
3227	if (!strAllocationUnits.isEmpty())
3228	pItem->createChild("rasd:AllocationUnits")->addContent(strAllocationUnits);
3229
3230	// <rasd:VirtualQuantity>1</rasd:VirtualQuantity>
3231	if (lVirtualQuantity != -1)
3232	pItem->createChild("rasd:VirtualQuantity")->addContent(Utf8StrFmt("%d", lVirtualQuantity));
3233
3234	if (lAutomaticAllocation != -1)
3235	pItem->createChild("rasd:AutomaticAllocation")->addContent( (lAutomaticAllocation) ? "true" : "false" );
3236
3237	if (!strConnection.isEmpty())
3238	pItem->createChild("rasd:Connection")->addContent(strConnection);
3239
3240	if (lAddress != -1)
3241	pItem->createChild("rasd:Address")->addContent(Utf8StrFmt("%d", lAddress));
3242
3243	if (lBusNumber != -1)
3244	pItem->createChild("rasd:BusNumber")->addContent(Utf8StrFmt("%d", lBusNumber));
3245
3246	if (ulParent)
3247	pItem->createChild("rasd:Parent")->addContent(Utf8StrFmt("%d", ulParent));
3248	if (lAddressOnParent != -1)
3249	pItem->createChild("rasd:AddressOnParent")->addContent(Utf8StrFmt("%d", lAddressOnParent));
3250	}
3251	}
3252	} // for (size_t uLoop = 0; ...
3253	}
3254
3255	// finally, fill in the network section we set up empty above according
3256	// to the networks we found with the hardware items
3257	map<Utf8Str, bool>::const_iterator itN;
3258	for (itN = mapNetworks.begin();
3259	itN != mapNetworks.end();
3260	++itN)
3261	{
3262	const Utf8Str &strNetwork = itN->first;
3263	xml::ElementNode *pelmNetwork = pelmNetworkSection->createChild("Network");
3264	pelmNetwork->setAttribute("ovf:name", strNetwork.c_str());
3265	pelmNetwork->createChild("Description")->addContent("Logical network used by this appliance.");
3266	}
3267
3268	map<Utf8Str, const VirtualSystemDescriptionEntry*>::const_iterator itS;
3269	uint32_t ulFile = 1;
3270	for (itS = mapDisks.begin();
3271	itS != mapDisks.end();
3272	++itS)
3273	{
3274	const Utf8Str &strDiskID = itS->first;
3275	const VirtualSystemDescriptionEntry *pDiskEntry = itS->second;
3276
3277	// source path: where the VBox image is
3278	const Utf8Str &strSrcFilePath = pDiskEntry->strVbox;
3279	Bstr bstrSrcFilePath(strSrcFilePath);
3280	if (!RTPathExists(strSrcFilePath.c_str()))
3281	/* This isn't allowed */
3282	throw setError(VBOX_E_FILE_ERROR,
3283	tr("Source virtual disk image file '%s' doesn't exist"),
3284	strSrcFilePath.c_str());
3285
3286	// output filename
3287	const Utf8Str &strTargetFileNameOnly = pDiskEntry->strOvf;
3288	// target path needs to be composed from where the output OVF is
3289	Utf8Str strTargetFilePath = stripFilename(pAppliance->m->strPath);
3290	strTargetFilePath.append("/");
3291	strTargetFilePath.append(strTargetFileNameOnly);
3292
3293	// clone the disk:
3294	ComPtr<IHardDisk> pSourceDisk;
3295	ComPtr<IHardDisk> pTargetDisk;
3296	ComPtr<IProgress> pProgress2;
3297
3298	Log(("Finding source disk \"%ls\"\n", bstrSrcFilePath.raw()));
3299	rc = pVirtualBox->FindHardDisk(bstrSrcFilePath, pSourceDisk.asOutParam());
3300	if (FAILED(rc)) throw rc;
3301
3302	/* We are always exporting to vmdfk stream optimized for now */
3303	Bstr bstrSrcFormat = L"VMDK";
3304
3305	// create a new hard disk interface for the destination disk image
3306	Log(("Creating target disk \"%s\"\n", strTargetFilePath.raw()));
3307	rc = pVirtualBox->CreateHardDisk(bstrSrcFormat, Bstr(strTargetFilePath), pTargetDisk.asOutParam());
3308	if (FAILED(rc)) throw rc;
3309
3310	// the target disk is now registered and needs to be removed again,
3311	// both after successful cloning or if anything goes bad!
3312	try
3313	{
3314	// create a flat copy of the source disk image
3315	rc = pSourceDisk->CloneTo(pTargetDisk, HardDiskVariant_VmdkStreamOptimized, NULL, pProgress2.asOutParam());
3316	if (FAILED(rc)) throw rc;
3317
3318	// advance to the next operation
3319	if (!task->progress.isNull())
3320	task->progress->setNextOperation(BstrFmt(tr("Exporting virtual disk image '%s'"), strSrcFilePath.c_str()),
3321	pDiskEntry->ulSizeMB); // operation's weight, as set up with the IProgress originally);
3322
3323	// now wait for the background disk operation to complete; this throws HRESULTs on error
3324	pAppliance->waitForAsyncProgress(task->progress, pProgress2);
3325	}
3326	catch (HRESULT rc3)
3327	{
3328	// upon error after registering, close the disk or
3329	// it'll stick in the registry forever
3330	pTargetDisk->Close();
3331	throw rc3;
3332	}
3333
3334	// we need the following for the XML
3335	uint64_t cbFile = 0; // actual file size
3336	rc = pTargetDisk->COMGETTER(Size)(&cbFile);
3337	if (FAILED(rc)) throw rc;
3338
3339	ULONG64 cbCapacity = 0; // size reported to guest
3340	rc = pTargetDisk->COMGETTER(LogicalSize)(&cbCapacity);
3341	if (FAILED(rc)) throw rc;
3342	// capacity is reported in megabytes, so...
3343	cbCapacity *= _1M;
3344
3345	// upon success, close the disk as well
3346	rc = pTargetDisk->Close();
3347	if (FAILED(rc)) throw rc;
3348
3349	// now handle the XML for the disk:
3350	Utf8StrFmt strFileRef("file%RI32", ulFile++);
3351	// <File ovf:href="WindowsXpProfessional-disk1.vmdk" ovf:id="file1" ovf:size="1710381056"/>
3352	xml::ElementNode *pelmFile = pelmReferences->createChild("File");
3353	pelmFile->setAttribute("ovf:href", strTargetFileNameOnly);
3354	pelmFile->setAttribute("ovf:id", strFileRef);
3355	pelmFile->setAttribute("ovf:size", Utf8StrFmt("%RI64", cbFile).c_str());
3356
3357	// add disk to XML Disks section
3358	// <Disk ovf:capacity="8589934592" ovf:diskId="vmdisk1" ovf:fileRef="file1" ovf:format="http://www.vmware.com/specifications/vmdk.html#sparse"/>
3359	xml::ElementNode *pelmDisk = pelmDiskSection->createChild("Disk");
3360	pelmDisk->setAttribute("ovf:capacity", Utf8StrFmt("%RI64", cbCapacity).c_str());
3361	pelmDisk->setAttribute("ovf:diskId", strDiskID);
3362	pelmDisk->setAttribute("ovf:fileRef", strFileRef);
3363	pelmDisk->setAttribute("ovf:format", "http://www.vmware.com/specifications/vmdk.html#sparse"); // must be sparse or ovftool chokes
3364	}
3365
3366	// now go write the XML
3367	xml::XmlFileWriter writer(doc);
3368	writer.write(pAppliance->m->strPath.c_str());
3369	}
3370	catch(xml::Error &x)
3371	{
3372	rc = setError(VBOX_E_FILE_ERROR,
3373	x.what());
3374	}
3375	catch(HRESULT aRC)
3376	{
3377	rc = aRC;
3378	}
3379
3380	task->rc = rc;
3381
3382	if (!task->progress.isNull())
3383	task->progress->notifyComplete(rc);
3384
3385	LogFlowFunc(("rc=%Rhrc\n", rc));
3386	LogFlowFuncLeave();
3387
3388	return VINF_SUCCESS;
3389	}
3390
3391	/**
3392	* Public method implementation.
3393	* @return
3394	*/
3395	STDMETHODIMP Appliance::GetWarnings(ComSafeArrayOut(BSTR, aWarnings))
3396	{
3397	if (ComSafeArrayOutIsNull(aWarnings))
3398	return E_POINTER;
3399
3400	AutoCaller autoCaller(this);
3401	CheckComRCReturnRC(autoCaller.rc());
3402
3403	AutoReadLock alock(this);
3404
3405	com::SafeArray<BSTR> sfaWarnings(m->llWarnings.size());
3406
3407	list<Utf8Str>::const_iterator it;
3408	size_t i = 0;
3409	for (it = m->llWarnings.begin();
3410	it != m->llWarnings.end();
3411	++it, ++i)
3412	{
3413	Bstr bstr = *it;
3414	bstr.cloneTo(&sfaWarnings[i]);
3415	}
3416
3417	sfaWarnings.detachTo(ComSafeArrayOutArg(aWarnings));
3418
3419	return S_OK;
3420	}
3421
3422	HRESULT Appliance::searchUniqueVMName(Utf8Str& aName) const
3423	{
3424	IMachine *machine = NULL;
3425	char *tmpName = RTStrDup(aName.c_str());
3426	int i = 1;
3427	/* @todo: Maybe too cost-intensive; try to find a lighter way */
3428	while (mVirtualBox->FindMachine(Bstr(tmpName), &machine) != VBOX_E_OBJECT_NOT_FOUND)
3429	{
3430	RTStrFree(tmpName);
3431	RTStrAPrintf(&tmpName, "%s_%d", aName.c_str(), i);
3432	++i;
3433	}
3434	aName = tmpName;
3435	RTStrFree(tmpName);
3436
3437	return S_OK;
3438	}
3439
3440	HRESULT Appliance::searchUniqueDiskImageFilePath(Utf8Str& aName) const
3441	{
3442	IHardDisk *harddisk = NULL;
3443	char *tmpName = RTStrDup(aName.c_str());
3444	int i = 1;
3445	/* Check if the file exists or if a file with this path is registered
3446	* already */
3447	/* @todo: Maybe too cost-intensive; try to find a lighter way */
3448	while (RTPathExists(tmpName) \|\|
3449	mVirtualBox->FindHardDisk(Bstr(tmpName), &harddisk) != VBOX_E_OBJECT_NOT_FOUND)
3450	{
3451	RTStrFree(tmpName);
3452	char *tmpDir = RTStrDup(aName.c_str());
3453	RTPathStripFilename(tmpDir);;
3454	char *tmpFile = RTStrDup(RTPathFilename(aName.c_str()));
3455	RTPathStripExt(tmpFile);
3456	const char *tmpExt = RTPathExt(aName.c_str());
3457	RTStrAPrintf(&tmpName, "%s%c%s_%d%s", tmpDir, RTPATH_DELIMITER, tmpFile, i, tmpExt);
3458	RTStrFree(tmpFile);
3459	RTStrFree(tmpDir);
3460	++i;
3461	}
3462	aName = tmpName;
3463	RTStrFree(tmpName);
3464
3465	return S_OK;
3466	}
3467
3468	/**
3469	* Sets up the given progress object so that it represents disk images accurately
3470	* during importMachines() and write().
3471	* @param pProgress
3472	* @param bstrDescription
3473	* @return
3474	*/
3475	HRESULT Appliance::setUpProgress(ComObjPtr<Progress> &pProgress, const Bstr &bstrDescription)
3476	{
3477	HRESULT rc;
3478
3479	/* Create the progress object */
3480	pProgress.createObject();
3481
3482	// weigh the disk images according to their sizes
3483	uint32_t ulTotalMB = 0;
3484	uint32_t cDisks = 0;
3485	list< ComObjPtr<VirtualSystemDescription> >::const_iterator it;
3486	for (it = m->virtualSystemDescriptions.begin();
3487	it != m->virtualSystemDescriptions.end();
3488	++it)
3489	{
3490	ComObjPtr<VirtualSystemDescription> vsdescThis = (*it);
3491	/* One for every hard disk of the Virtual System */
3492	std::list<VirtualSystemDescriptionEntry*> avsdeHDs = vsdescThis->findByType(VirtualSystemDescriptionType_HardDiskImage);
3493	std::list<VirtualSystemDescriptionEntry*>::const_iterator itH;
3494	for (itH = avsdeHDs.begin();
3495	itH != avsdeHDs.end();
3496	++itH)
3497	{
3498	const VirtualSystemDescriptionEntry pHD = itH;
3499	ulTotalMB += pHD->ulSizeMB;
3500	++cDisks;
3501	}
3502	}
3503
3504	ULONG cOperations = 1 + cDisks; // one op per disk plus 1 for the XML
3505
3506	ULONG ulTotalOperationsWeight;
3507	if (ulTotalMB)
3508	{
3509	m->ulWeightPerOperation = (ULONG)((double)ulTotalMB * 1 / 100); // use 1% of the progress for the XML
3510	ulTotalOperationsWeight = ulTotalMB + m->ulWeightPerOperation;
3511	}
3512	else
3513	{
3514	// no disks to export:
3515	ulTotalOperationsWeight = 1;
3516	m->ulWeightPerOperation = 1;
3517	}
3518
3519	Log(("Setting up progress object: ulTotalMB = %d, cDisks = %d, => cOperations = %d, ulTotalOperationsWeight = %d, m->ulWeightPerOperation = %d\n",
3520	ulTotalMB, cDisks, cOperations, ulTotalOperationsWeight, m->ulWeightPerOperation));
3521
3522	rc = pProgress->init(mVirtualBox, static_cast<IAppliance*>(this),
3523	bstrDescription,
3524	TRUE /* aCancelable */,
3525	cOperations, // ULONG cOperations,
3526	ulTotalOperationsWeight, // ULONG ulTotalOperationsWeight,
3527	bstrDescription, // CBSTR bstrFirstOperationDescription,
3528	m->ulWeightPerOperation); // ULONG ulFirstOperationWeight,
3529	return rc;
3530	}
3531
3532	/**
3533	* Called from the import and export background threads to synchronize the second
3534	* background disk thread's progress object with the current progress object so
3535	* that the user interface sees progress correctly and that cancel signals are
3536	* passed on to the second thread.
3537	* @param pProgressThis Progress object of the current thread.
3538	* @param pProgressAsync Progress object of asynchronous task running in background.
3539	*/
3540	void Appliance::waitForAsyncProgress(ComObjPtr<Progress> &pProgressThis,
3541	ComPtr<IProgress> &pProgressAsync)
3542	{
3543	HRESULT rc;
3544
3545	// now loop until the asynchronous operation completes and then report its result
3546	BOOL fCompleted;
3547	BOOL fCanceled;
3548	ULONG currentPercent;
3549	while (SUCCEEDED(pProgressAsync->COMGETTER(Completed(&fCompleted))))
3550	{
3551	rc = pProgressThis->COMGETTER(Canceled)(&fCanceled);
3552	if (FAILED(rc)) throw rc;
3553	if (fCanceled)
3554	{
3555	pProgressAsync->Cancel();
3556	break;
3557	}
3558
3559	rc = pProgressAsync->COMGETTER(Percent(&currentPercent));
3560	if (FAILED(rc)) throw rc;
3561	if (!pProgressThis.isNull())
3562	pProgressThis->setCurrentOperationProgress(currentPercent);
3563	if (fCompleted)
3564	break;
3565
3566	/* Make sure the loop is not too tight */
3567	rc = pProgressAsync->WaitForCompletion(100);
3568	if (FAILED(rc)) throw rc;
3569	}
3570	// report result of asynchronous operation
3571	HRESULT vrc;
3572	rc = pProgressAsync->COMGETTER(ResultCode)(&vrc);
3573	if (FAILED(rc)) throw rc;
3574
3575
3576	// if the thread of the progress object has an error, then
3577	// retrieve the error info from there, or it'll be lost
3578	if (FAILED(vrc))
3579	{
3580	ProgressErrorInfo info(pProgressAsync);
3581	Utf8Str str(info.getText());
3582	const char *pcsz = str.c_str();
3583	HRESULT rc2 = setError(vrc, pcsz);
3584	throw rc2;
3585	}
3586	}
3587
3588	void Appliance::addWarning(const char* aWarning, ...)
3589	{
3590	va_list args;
3591	va_start(args, aWarning);
3592	Utf8StrFmtVA str(aWarning, args);
3593	va_end(args);
3594	m->llWarnings.push_back(str);
3595	}
3596
3597	////////////////////////////////////////////////////////////////////////////////
3598	//
3599	// IVirtualSystemDescription constructor / destructor
3600	//
3601	////////////////////////////////////////////////////////////////////////////////
3602
3603	DEFINE_EMPTY_CTOR_DTOR(VirtualSystemDescription)
3604	struct shutup3 {};
3605
3606	/**
3607	* COM initializer.
3608	* @return
3609	*/
3610	HRESULT VirtualSystemDescription::init()
3611	{
3612	/* Enclose the state transition NotReady->InInit->Ready */
3613	AutoInitSpan autoInitSpan(this);
3614	AssertReturn(autoInitSpan.isOk(), E_FAIL);
3615
3616	/* Initialize data */
3617	m = new Data();
3618
3619	/* Confirm a successful initialization */
3620	autoInitSpan.setSucceeded();
3621	return S_OK;
3622	}
3623
3624	/**
3625	* COM uninitializer.
3626	*/
3627
3628	void VirtualSystemDescription::uninit()
3629	{
3630	delete m;
3631	m = NULL;
3632	}
3633
3634	////////////////////////////////////////////////////////////////////////////////
3635	//
3636	// IVirtualSystemDescription public methods
3637	//
3638	////////////////////////////////////////////////////////////////////////////////
3639
3640	/**
3641	* Public method implementation.
3642	* @param
3643	* @return
3644	*/
3645	STDMETHODIMP VirtualSystemDescription::COMGETTER(Count)(ULONG *aCount)
3646	{
3647	if (!aCount)
3648	return E_POINTER;
3649
3650	AutoCaller autoCaller(this);
3651	CheckComRCReturnRC(autoCaller.rc());
3652
3653	AutoReadLock alock(this);
3654
3655	*aCount = (ULONG)m->llDescriptions.size();
3656
3657	return S_OK;
3658	}
3659
3660	/**
3661	* Public method implementation.
3662	* @return
3663	*/
3664	STDMETHODIMP VirtualSystemDescription::GetDescription(ComSafeArrayOut(VirtualSystemDescriptionType_T, aTypes),
3665	ComSafeArrayOut(BSTR, aRefs),
3666	ComSafeArrayOut(BSTR, aOrigValues),
3667	ComSafeArrayOut(BSTR, aVboxValues),
3668	ComSafeArrayOut(BSTR, aExtraConfigValues))
3669	{
3670	if (ComSafeArrayOutIsNull(aTypes) \|\|
3671	ComSafeArrayOutIsNull(aRefs) \|\|
3672	ComSafeArrayOutIsNull(aOrigValues) \|\|
3673	ComSafeArrayOutIsNull(aVboxValues) \|\|
3674	ComSafeArrayOutIsNull(aExtraConfigValues))
3675	return E_POINTER;
3676
3677	AutoCaller autoCaller(this);
3678	CheckComRCReturnRC(autoCaller.rc());
3679
3680	AutoReadLock alock(this);
3681
3682	ULONG c = (ULONG)m->llDescriptions.size();
3683	com::SafeArray<VirtualSystemDescriptionType_T> sfaTypes(c);
3684	com::SafeArray<BSTR> sfaRefs(c);
3685	com::SafeArray<BSTR> sfaOrigValues(c);
3686	com::SafeArray<BSTR> sfaVboxValues(c);
3687	com::SafeArray<BSTR> sfaExtraConfigValues(c);
3688
3689	list<VirtualSystemDescriptionEntry>::const_iterator it;
3690	size_t i = 0;
3691	for (it = m->llDescriptions.begin();
3692	it != m->llDescriptions.end();
3693	++it, ++i)
3694	{
3695	const VirtualSystemDescriptionEntry &vsde = (*it);
3696
3697	sfaTypes[i] = vsde.type;
3698
3699	Bstr bstr = vsde.strRef;
3700	bstr.cloneTo(&sfaRefs[i]);
3701
3702	bstr = vsde.strOvf;
3703	bstr.cloneTo(&sfaOrigValues[i]);
3704
3705	bstr = vsde.strVbox;
3706	bstr.cloneTo(&sfaVboxValues[i]);
3707
3708	bstr = vsde.strExtraConfig;
3709	bstr.cloneTo(&sfaExtraConfigValues[i]);
3710	}
3711
3712	sfaTypes.detachTo(ComSafeArrayOutArg(aTypes));
3713	sfaRefs.detachTo(ComSafeArrayOutArg(aRefs));
3714	sfaOrigValues.detachTo(ComSafeArrayOutArg(aOrigValues));
3715	sfaVboxValues.detachTo(ComSafeArrayOutArg(aVboxValues));
3716	sfaExtraConfigValues.detachTo(ComSafeArrayOutArg(aExtraConfigValues));
3717
3718	return S_OK;
3719	}
3720
3721	/**
3722	* Public method implementation.
3723	* @return
3724	*/
3725	STDMETHODIMP VirtualSystemDescription::GetDescriptionByType(VirtualSystemDescriptionType_T aType,
3726	ComSafeArrayOut(VirtualSystemDescriptionType_T, aTypes),
3727	ComSafeArrayOut(BSTR, aRefs),
3728	ComSafeArrayOut(BSTR, aOrigValues),
3729	ComSafeArrayOut(BSTR, aVboxValues),
3730	ComSafeArrayOut(BSTR, aExtraConfigValues))
3731	{
3732	if (ComSafeArrayOutIsNull(aTypes) \|\|
3733	ComSafeArrayOutIsNull(aRefs) \|\|
3734	ComSafeArrayOutIsNull(aOrigValues) \|\|
3735	ComSafeArrayOutIsNull(aVboxValues) \|\|
3736	ComSafeArrayOutIsNull(aExtraConfigValues))
3737	return E_POINTER;
3738
3739	AutoCaller autoCaller(this);
3740	CheckComRCReturnRC(autoCaller.rc());
3741
3742	AutoReadLock alock(this);
3743
3744	std::list<VirtualSystemDescriptionEntry*> vsd = findByType (aType);
3745	ULONG c = (ULONG)vsd.size();
3746	com::SafeArray<VirtualSystemDescriptionType_T> sfaTypes(c);
3747	com::SafeArray<BSTR> sfaRefs(c);
3748	com::SafeArray<BSTR> sfaOrigValues(c);
3749	com::SafeArray<BSTR> sfaVboxValues(c);
3750	com::SafeArray<BSTR> sfaExtraConfigValues(c);
3751
3752	list<VirtualSystemDescriptionEntry*>::const_iterator it;
3753	size_t i = 0;
3754	for (it = vsd.begin();
3755	it != vsd.end();
3756	++it, ++i)
3757	{
3758	const VirtualSystemDescriptionEntry vsde = (it);
3759
3760	sfaTypes[i] = vsde->type;
3761
3762	Bstr bstr = vsde->strRef;
3763	bstr.cloneTo(&sfaRefs[i]);
3764
3765	bstr = vsde->strOvf;
3766	bstr.cloneTo(&sfaOrigValues[i]);
3767
3768	bstr = vsde->strVbox;
3769	bstr.cloneTo(&sfaVboxValues[i]);
3770
3771	bstr = vsde->strExtraConfig;
3772	bstr.cloneTo(&sfaExtraConfigValues[i]);
3773	}
3774
3775	sfaTypes.detachTo(ComSafeArrayOutArg(aTypes));
3776	sfaRefs.detachTo(ComSafeArrayOutArg(aRefs));
3777	sfaOrigValues.detachTo(ComSafeArrayOutArg(aOrigValues));
3778	sfaVboxValues.detachTo(ComSafeArrayOutArg(aVboxValues));
3779	sfaExtraConfigValues.detachTo(ComSafeArrayOutArg(aExtraConfigValues));
3780
3781	return S_OK;
3782	}
3783
3784	/**
3785	* Public method implementation.
3786	* @return
3787	*/
3788	STDMETHODIMP VirtualSystemDescription::GetValuesByType(VirtualSystemDescriptionType_T aType,
3789	VirtualSystemDescriptionValueType_T aWhich,
3790	ComSafeArrayOut(BSTR, aValues))
3791	{
3792	if (ComSafeArrayOutIsNull(aValues))
3793	return E_POINTER;
3794
3795	AutoCaller autoCaller(this);
3796	CheckComRCReturnRC(autoCaller.rc());
3797
3798	AutoReadLock alock(this);
3799
3800	std::list<VirtualSystemDescriptionEntry*> vsd = findByType (aType);
3801	com::SafeArray<BSTR> sfaValues((ULONG)vsd.size());
3802
3803	list<VirtualSystemDescriptionEntry*>::const_iterator it;
3804	size_t i = 0;
3805	for (it = vsd.begin();
3806	it != vsd.end();
3807	++it, ++i)
3808	{
3809	const VirtualSystemDescriptionEntry vsde = (it);
3810
3811	Bstr bstr;
3812	switch (aWhich)
3813	{
3814	case VirtualSystemDescriptionValueType_Reference: bstr = vsde->strRef; break;
3815	case VirtualSystemDescriptionValueType_Original: bstr = vsde->strOvf; break;
3816	case VirtualSystemDescriptionValueType_Auto: bstr = vsde->strVbox; break;
3817	case VirtualSystemDescriptionValueType_ExtraConfig: bstr = vsde->strExtraConfig; break;
3818	}
3819
3820	bstr.cloneTo(&sfaValues[i]);
3821	}
3822
3823	sfaValues.detachTo(ComSafeArrayOutArg(aValues));
3824
3825	return S_OK;
3826	}
3827
3828	/**
3829	* Public method implementation.
3830	* @return
3831	*/
3832	STDMETHODIMP VirtualSystemDescription::SetFinalValues(ComSafeArrayIn(BOOL, aEnabled),
3833	ComSafeArrayIn(IN_BSTR, argVboxValues),
3834	ComSafeArrayIn(IN_BSTR, argExtraConfigValues))
3835	{
3836	#ifndef RT_OS_WINDOWS
3837	NOREF(aEnabledSize);
3838	#endif /* RT_OS_WINDOWS */
3839
3840	CheckComArgSafeArrayNotNull(aEnabled);
3841	CheckComArgSafeArrayNotNull(argVboxValues);
3842	CheckComArgSafeArrayNotNull(argExtraConfigValues);
3843
3844	AutoCaller autoCaller(this);
3845	CheckComRCReturnRC(autoCaller.rc());
3846
3847	AutoWriteLock alock(this);
3848
3849	com::SafeArray<BOOL> sfaEnabled(ComSafeArrayInArg(aEnabled));
3850	com::SafeArray<IN_BSTR> sfaVboxValues(ComSafeArrayInArg(argVboxValues));
3851	com::SafeArray<IN_BSTR> sfaExtraConfigValues(ComSafeArrayInArg(argExtraConfigValues));
3852
3853	if ( (sfaEnabled.size() != m->llDescriptions.size())
3854	\|\| (sfaVboxValues.size() != m->llDescriptions.size())
3855	\|\| (sfaExtraConfigValues.size() != m->llDescriptions.size())
3856	)
3857	return E_INVALIDARG;
3858
3859	list<VirtualSystemDescriptionEntry>::iterator it;
3860	size_t i = 0;
3861	for (it = m->llDescriptions.begin();
3862	it != m->llDescriptions.end();
3863	++it, ++i)
3864	{
3865	VirtualSystemDescriptionEntry& vsde = *it;
3866
3867	if (sfaEnabled[i])
3868	{
3869	vsde.strVbox = sfaVboxValues[i];
3870	vsde.strExtraConfig = sfaExtraConfigValues[i];
3871	}
3872	else
3873	vsde.type = VirtualSystemDescriptionType_Ignore;
3874	}
3875
3876	return S_OK;
3877	}
3878
3879	/**
3880	* Public method implementation.
3881	* @return
3882	*/
3883	STDMETHODIMP VirtualSystemDescription::AddDescription(VirtualSystemDescriptionType_T aType,
3884	IN_BSTR aVboxValue,
3885	IN_BSTR aExtraConfigValue)
3886	{
3887	CheckComArgNotNull(aVboxValue);
3888	CheckComArgNotNull(aExtraConfigValue);
3889
3890	AutoCaller autoCaller(this);
3891	CheckComRCReturnRC(autoCaller.rc());
3892
3893	AutoWriteLock alock(this);
3894
3895	addEntry(aType, "", aVboxValue, aVboxValue, 0, aExtraConfigValue);
3896
3897	return S_OK;
3898	}
3899
3900	/**
3901	* Internal method; adds a new description item to the member list.
3902	* @param aType Type of description for the new item.
3903	* @param strRef Reference item; only used with hard disk controllers.
3904	* @param aOrigValue Corresponding original value from OVF.
3905	* @param aAutoValue Initial configuration value (can be overridden by caller with setFinalValues).
3906	* @param strExtraConfig Extra configuration; meaning dependent on type.
3907	*/
3908	void VirtualSystemDescription::addEntry(VirtualSystemDescriptionType_T aType,
3909	const Utf8Str &strRef,
3910	const Utf8Str &aOrigValue,
3911	const Utf8Str &aAutoValue,
3912	uint32_t ulSizeMB,
3913	const Utf8Str &strExtraConfig /= ""/)
3914	{
3915	VirtualSystemDescriptionEntry vsde;
3916	vsde.ulIndex = (uint32_t)m->llDescriptions.size(); // each entry gets an index so the client side can reference them
3917	vsde.type = aType;
3918	vsde.strRef = strRef;
3919	vsde.strOvf = aOrigValue;
3920	vsde.strVbox = aAutoValue;
3921	vsde.strExtraConfig = strExtraConfig;
3922	vsde.ulSizeMB = ulSizeMB;
3923
3924	m->llDescriptions.push_back(vsde);
3925	}
3926
3927	/**
3928	* Private method; returns a list of description items containing all the items from the member
3929	* description items of this virtual system that match the given type.
3930	* @param aType
3931	* @return
3932	*/
3933	std::list<VirtualSystemDescriptionEntry*> VirtualSystemDescription::findByType(VirtualSystemDescriptionType_T aType)
3934	{
3935	std::list<VirtualSystemDescriptionEntry*> vsd;
3936
3937	list<VirtualSystemDescriptionEntry>::iterator it;
3938	for (it = m->llDescriptions.begin();
3939	it != m->llDescriptions.end();
3940	++it)
3941	{
3942	if (it->type == aType)
3943	vsd.push_back(&(*it));
3944	}
3945
3946	return vsd;
3947	}
3948
3949	/**
3950	* Private method; looks thru the member hardware items for the IDE, SATA, or SCSI controller with
3951	* the given reference ID. Useful when needing the controller for a particular
3952	* virtual disk.
3953	* @param id
3954	* @return
3955	*/
3956	const VirtualSystemDescriptionEntry* VirtualSystemDescription::findControllerFromID(uint32_t id)
3957	{
3958	Utf8Str strRef = Utf8StrFmt("%RI32", id);
3959	list<VirtualSystemDescriptionEntry>::const_iterator it;
3960	for (it = m->llDescriptions.begin();
3961	it != m->llDescriptions.end();
3962	++it)
3963	{
3964	const VirtualSystemDescriptionEntry &d = *it;
3965	switch (d.type)
3966	{
3967	case VirtualSystemDescriptionType_HardDiskControllerIDE:
3968	case VirtualSystemDescriptionType_HardDiskControllerSATA:
3969	case VirtualSystemDescriptionType_HardDiskControllerSCSI:
3970	if (d.strRef == strRef)
3971	return &d;
3972	break;
3973	}
3974	}
3975
3976	return NULL;
3977	}
3978
3979	////////////////////////////////////////////////////////////////////////////////
3980	//
3981	// IMachine public methods
3982	//
3983	////////////////////////////////////////////////////////////////////////////////
3984
3985	// This code is here so we won't have to include the appliance headers in the
3986	// IMachine implementation, and we also need to access private appliance data.
3987
3988	/**
3989	* Public method implementation.
3990	* @param appliance
3991	* @return
3992	*/
3993
3994	STDMETHODIMP Machine::Export(IAppliance aAppliance, IVirtualSystemDescription *aDescription)
3995	{
3996	HRESULT rc = S_OK;
3997
3998	if (!aAppliance)
3999	return E_POINTER;
4000
4001	AutoCaller autoCaller(this);
4002	CheckComRCReturnRC(autoCaller.rc());
4003
4004	AutoReadLock alock(this);
4005
4006	ComObjPtr<VirtualSystemDescription> pNewDesc;
4007
4008	try
4009	{
4010	Bstr bstrName;
4011	Bstr bstrDescription;
4012	Bstr bstrGuestOSType;
4013	uint32_t cCPUs;
4014	uint32_t ulMemSizeMB;
4015	BOOL fDVDEnabled;
4016	BOOL fFloppyEnabled;
4017	BOOL fUSBEnabled;
4018	BOOL fAudioEnabled;
4019	AudioControllerType_T audioController;
4020
4021	ComPtr<IUSBController> pUsbController;
4022	ComPtr<IAudioAdapter> pAudioAdapter;
4023
4024	// get name
4025	bstrName = mUserData->mName;
4026	// get description
4027	bstrDescription = mUserData->mDescription;
4028	// get guest OS
4029	bstrGuestOSType = mUserData->mOSTypeId;
4030	// CPU count
4031	cCPUs = mHWData->mCPUCount;
4032	// memory size in MB
4033	ulMemSizeMB = mHWData->mMemorySize;
4034	// VRAM size?
4035	// BIOS settings?
4036	// 3D acceleration enabled?
4037	// hardware virtualization enabled?
4038	// nested paging enabled?
4039	// HWVirtExVPIDEnabled?
4040	// PAEEnabled?
4041	// snapshotFolder?
4042	// VRDPServer?
4043
4044	// floppy
4045	rc = mFloppyDrive->COMGETTER(Enabled)(&fFloppyEnabled);
4046	if (FAILED(rc)) throw rc;
4047
4048	// CD-ROM ?!?
4049	// ComPtr<IDVDDrive> pDVDDrive;
4050	fDVDEnabled = 1;
4051
4052	// this is more tricky so use the COM method
4053	rc = COMGETTER(USBController)(pUsbController.asOutParam());
4054	if (FAILED(rc)) throw rc;
4055	rc = pUsbController->COMGETTER(Enabled)(&fUSBEnabled);
4056
4057	pAudioAdapter = mAudioAdapter;
4058	rc = pAudioAdapter->COMGETTER(Enabled)(&fAudioEnabled);
4059	if (FAILED(rc)) throw rc;
4060	rc = pAudioAdapter->COMGETTER(AudioController)(&audioController);
4061	if (FAILED(rc)) throw rc;
4062
4063	// create a new virtual system
4064	rc = pNewDesc.createObject();
4065	CheckComRCThrowRC(rc);
4066	rc = pNewDesc->init();
4067	CheckComRCThrowRC(rc);
4068
4069	/* Guest OS type */
4070	Utf8Str strOsTypeVBox(bstrGuestOSType);
4071	CIMOSType_T cim = convertVBoxOSType2CIMOSType(strOsTypeVBox.c_str());
4072	pNewDesc->addEntry(VirtualSystemDescriptionType_OS,
4073	"",
4074	Utf8StrFmt("%RI32", cim),
4075	strOsTypeVBox);
4076
4077	/* VM name */
4078	Utf8Str strVMName(bstrName);
4079	pNewDesc->addEntry(VirtualSystemDescriptionType_Name,
4080	"",
4081	strVMName,
4082	strVMName);
4083
4084	// description
4085	Utf8Str strDescription(bstrDescription);
4086	pNewDesc->addEntry(VirtualSystemDescriptionType_Description,
4087	"",
4088	strDescription,
4089	strDescription);
4090
4091	/* CPU count*/
4092	Utf8Str strCpuCount = Utf8StrFmt("%RI32", cCPUs);
4093	pNewDesc->addEntry(VirtualSystemDescriptionType_CPU,
4094	"",
4095	strCpuCount,
4096	strCpuCount);
4097
4098	/* Memory */
4099	Utf8Str strMemory = Utf8StrFmt("%RI32", (uint64_t)ulMemSizeMB * _1M);
4100	pNewDesc->addEntry(VirtualSystemDescriptionType_Memory,
4101	"",
4102	strMemory,
4103	strMemory);
4104
4105	int32_t lIDEControllerIndex = 0;
4106	int32_t lSATAControllerIndex = 0;
4107	int32_t lSCSIControllerIndex = 0;
4108
4109	// <const name="HardDiskControllerIDE" value="6" />
4110	ComPtr<IStorageController> pController;
4111	rc = GetStorageControllerByName(Bstr("IDE"), pController.asOutParam());
4112	if (FAILED(rc)) throw rc;
4113	Utf8Str strVbox;
4114	StorageControllerType_T ctlr;
4115	rc = pController->COMGETTER(ControllerType)(&ctlr);
4116	if (FAILED(rc)) throw rc;
4117	switch(ctlr)
4118	{
4119	case StorageControllerType_PIIX3: strVbox = "PIIX3"; break;
4120	case StorageControllerType_PIIX4: strVbox = "PIIX4"; break;
4121	case StorageControllerType_ICH6: strVbox = "ICH6"; break;
4122	}
4123
4124	if (strVbox.length())
4125	{
4126	lIDEControllerIndex = (int32_t)pNewDesc->m->llDescriptions.size();
4127	pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskControllerIDE,
4128	Utf8StrFmt("%d", lIDEControllerIndex),
4129	strVbox,
4130	strVbox);
4131	}
4132
4133	#ifdef VBOX_WITH_AHCI
4134	// <const name="HardDiskControllerSATA" value="7" />
4135	rc = GetStorageControllerByName(Bstr("SATA"), pController.asOutParam());
4136	if (SUCCEEDED(rc))
4137	{
4138	strVbox = "AHCI";
4139	lSATAControllerIndex = (int32_t)pNewDesc->m->llDescriptions.size();
4140	pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskControllerSATA,
4141	Utf8StrFmt("%d", lSATAControllerIndex),
4142	strVbox,
4143	strVbox);
4144	}
4145	#endif // VBOX_WITH_AHCI
4146
4147	// <const name="HardDiskControllerSCSI" value="8" />
4148	rc = GetStorageControllerByName(Bstr("SCSI"), pController.asOutParam());
4149	if (SUCCEEDED(rc))
4150	{
4151	rc = pController->COMGETTER(ControllerType)(&ctlr);
4152	if (SUCCEEDED(rc))
4153	{
4154	strVbox = "LsiLogic"; // the default in VBox
4155	switch(ctlr)
4156	{
4157	case StorageControllerType_LsiLogic: strVbox = "LsiLogic"; break;
4158	case StorageControllerType_BusLogic: strVbox = "BusLogic"; break;
4159	}
4160	lSCSIControllerIndex = (int32_t)pNewDesc->m->llDescriptions.size();
4161	pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskControllerSCSI,
4162	Utf8StrFmt("%d", lSCSIControllerIndex),
4163	strVbox,
4164	strVbox);
4165	}
4166	else
4167	throw rc;
4168	}
4169
4170	// <const name="HardDiskImage" value="9" />
4171	HDData::AttachmentList::iterator itA;
4172	for (itA = mHDData->mAttachments.begin();
4173	itA != mHDData->mAttachments.end();
4174	++itA)
4175	{
4176	ComObjPtr<HardDiskAttachment> pHDA = *itA;
4177
4178	// the attachment's data
4179	ComPtr<IHardDisk> pHardDisk;
4180	ComPtr<IStorageController> ctl;
4181	Bstr controllerName;
4182
4183	rc = pHDA->COMGETTER(Controller)(controllerName.asOutParam());
4184	if (FAILED(rc)) throw rc;
4185
4186	rc = GetStorageControllerByName(controllerName, ctl.asOutParam());
4187	if (FAILED(rc)) throw rc;
4188
4189	StorageBus_T storageBus;
4190	LONG lChannel;
4191	LONG lDevice;
4192
4193	rc = ctl->COMGETTER(Bus)(&storageBus);
4194	if (FAILED(rc)) throw rc;
4195
4196	rc = pHDA->COMGETTER(HardDisk)(pHardDisk.asOutParam());
4197	if (FAILED(rc)) throw rc;
4198
4199	rc = pHDA->COMGETTER(Port)(&lChannel);
4200	if (FAILED(rc)) throw rc;
4201
4202	rc = pHDA->COMGETTER(Device)(&lDevice);
4203	if (FAILED(rc)) throw rc;
4204
4205	Bstr bstrLocation;
4206	rc = pHardDisk->COMGETTER(Location)(bstrLocation.asOutParam());
4207	if (FAILED(rc)) throw rc;
4208	Bstr bstrName;
4209	rc = pHardDisk->COMGETTER(Name)(bstrName.asOutParam());
4210	if (FAILED(rc)) throw rc;
4211
4212	// force reading state, or else size will be returned as 0
4213	MediaState_T ms;
4214	rc = pHardDisk->COMGETTER(State)(&ms);
4215	if (FAILED(rc)) throw rc;
4216
4217	ULONG64 ullSize;
4218	rc = pHardDisk->COMGETTER(Size)(&ullSize);
4219	if (FAILED(rc)) throw rc;
4220
4221	// and how this translates to the virtual system
4222	int32_t lControllerVsys = 0;
4223	LONG lChannelVsys;
4224
4225	switch (storageBus)
4226	{
4227	case StorageBus_IDE:
4228	// this is the exact reverse to what we're doing in Appliance::taskThreadImportMachines,
4229	// and it must be updated when that is changed!
4230
4231	if (lChannel == 0 && lDevice == 0) // primary master
4232	lChannelVsys = 0;
4233	else if (lChannel == 0 && lDevice == 1) // primary slave
4234	lChannelVsys = 1;
4235	else if (lChannel == 1 && lDevice == 1) // secondary slave; secondary master is always CDROM
4236	lChannelVsys = 2;
4237	else
4238	throw setError(VBOX_E_NOT_SUPPORTED,
4239	tr("Cannot handle hard disk attachment: channel is %d, device is %d"), lChannel, lDevice);
4240
4241	lControllerVsys = lIDEControllerIndex;
4242	break;
4243
4244	case StorageBus_SATA:
4245	lChannelVsys = lChannel; // should be between 0 and 29
4246	lControllerVsys = lSATAControllerIndex;
4247	break;
4248
4249	case StorageBus_SCSI:
4250	lChannelVsys = lChannel; // should be between 0 and 15
4251	lControllerVsys = lSCSIControllerIndex;
4252	break;
4253
4254	default:
4255	throw setError(VBOX_E_NOT_SUPPORTED,
4256	tr("Cannot handle hard disk attachment: storageBus is %d, channel is %d, device is %d"), storageBus, lChannel, lDevice);
4257	break;
4258	}
4259
4260	Utf8Str strTargetVmdkName(bstrName);
4261	RTPathStripExt(strTargetVmdkName.mutableRaw());
4262	strTargetVmdkName.append(".vmdk");
4263
4264	pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskImage,
4265	strTargetVmdkName, // disk ID: let's use the name
4266	strTargetVmdkName, // OVF value:
4267	Utf8Str(bstrLocation), // vbox value: media path
4268	(uint32_t)(ullSize / _1M),
4269	Utf8StrFmt("controller=%RI32;channel=%RI32", lControllerVsys, lChannelVsys));
4270	}
4271
4272	/* Floppy Drive */
4273	if (fFloppyEnabled)
4274	pNewDesc->addEntry(VirtualSystemDescriptionType_Floppy, "", "", "");
4275
4276	/* CD Drive */
4277	if (fDVDEnabled)
4278	pNewDesc->addEntry(VirtualSystemDescriptionType_CDROM, "", "", "");
4279
4280	// <const name="NetworkAdapter" />
4281	size_t a;
4282	for (a = 0;
4283	a < SchemaDefs::NetworkAdapterCount;
4284	++a)
4285	{
4286	ComPtr<INetworkAdapter> pNetworkAdapter;
4287	BOOL fEnabled;
4288	NetworkAdapterType_T adapterType;
4289	NetworkAttachmentType_T attachmentType;
4290
4291	rc = GetNetworkAdapter((ULONG)a, pNetworkAdapter.asOutParam());
4292	if (FAILED(rc)) throw rc;
4293	/* Enable the network card & set the adapter type */
4294	rc = pNetworkAdapter->COMGETTER(Enabled)(&fEnabled);
4295	if (FAILED(rc)) throw rc;
4296
4297	if (fEnabled)
4298	{
4299	Utf8Str strAttachmentType;
4300
4301	rc = pNetworkAdapter->COMGETTER(AdapterType)(&adapterType);
4302	if (FAILED(rc)) throw rc;
4303
4304	rc = pNetworkAdapter->COMGETTER(AttachmentType)(&attachmentType);
4305	if (FAILED(rc)) throw rc;
4306
4307	switch (attachmentType)
4308	{
4309	case NetworkAttachmentType_Null:
4310	strAttachmentType = "Null";
4311	break;
4312
4313	case NetworkAttachmentType_NAT:
4314	strAttachmentType = "NAT";
4315	break;
4316
4317	case NetworkAttachmentType_Bridged:
4318	strAttachmentType = "Bridged";
4319	break;
4320
4321	case NetworkAttachmentType_Internal:
4322	strAttachmentType = "Internal";
4323	break;
4324
4325	case NetworkAttachmentType_HostOnly:
4326	strAttachmentType = "HostOnly";
4327	break;
4328	}
4329
4330	pNewDesc->addEntry(VirtualSystemDescriptionType_NetworkAdapter,
4331	"", // ref
4332	strAttachmentType, // orig
4333	Utf8StrFmt("%RI32", (uint32_t)adapterType), // conf
4334	Utf8StrFmt("type=%s", strAttachmentType.c_str())); // extra conf
4335	}
4336	}
4337
4338	// <const name="USBController" />
4339	#ifdef VBOX_WITH_USB
4340	if (fUSBEnabled)
4341	pNewDesc->addEntry(VirtualSystemDescriptionType_USBController, "", "", "");
4342	#endif /* VBOX_WITH_USB */
4343
4344	// <const name="SoundCard" />
4345	if (fAudioEnabled)
4346	{
4347	pNewDesc->addEntry(VirtualSystemDescriptionType_SoundCard,
4348	"",
4349	"ensoniq1371", // this is what OVFTool writes and VMware supports
4350	Utf8StrFmt("%RI32", audioController));
4351	}
4352
4353	// finally, add the virtual system to the appliance
4354	Appliance pAppliance = static_cast<Appliance>(aAppliance);
4355	AutoCaller autoCaller1(pAppliance);
4356	CheckComRCReturnRC(autoCaller1.rc());
4357
4358	/* We return the new description to the caller */
4359	ComPtr<IVirtualSystemDescription> copy(pNewDesc);
4360	copy.queryInterfaceTo(aDescription);
4361
4362	AutoWriteLock alock(pAppliance);
4363
4364	pAppliance->m->virtualSystemDescriptions.push_back(pNewDesc);
4365	}
4366	catch(HRESULT arc)
4367	{
4368	rc = arc;
4369	}
4370
4371	return rc;
4372	}
4373
4374	/* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

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

Download in other formats: