ApplianceImplImport.cpp@ 36964

Last change on this file since 36964 was 36575, checked in by vboxsync, 14 years ago
Main/src-server/ApplianceImplImport: automatically repair broken OVF images with multiple disks, created by 3.2.8 and earlier
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 118.9 KB

Line
1	/* $Id: ApplianceImplImport.cpp 36575 2011-04-06 13:07:54Z vboxsync $ */
2	/** @file
3	*
4	* IAppliance and IVirtualSystem COM class implementations.
5	*/
6
7	/*
8	* Copyright (C) 2008-2011 Oracle Corporation
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
19	#include <iprt/path.h>
20	#include <iprt/dir.h>
21	#include <iprt/file.h>
22	#include <iprt/s3.h>
23	#include <iprt/sha.h>
24	#include <iprt/manifest.h>
25	#include <iprt/tar.h>
26	#include <iprt/stream.h>
27
28	#include <VBox/vd.h>
29	#include <VBox/com/array.h>
30
31	#include "ApplianceImpl.h"
32	#include "VirtualBoxImpl.h"
33	#include "GuestOSTypeImpl.h"
34	#include "ProgressImpl.h"
35	#include "MachineImpl.h"
36	#include "MediumImpl.h"
37	#include "MediumFormatImpl.h"
38	#include "SystemPropertiesImpl.h"
39
40	#include "AutoCaller.h"
41	#include "Logging.h"
42
43	#include "ApplianceImplPrivate.h"
44
45	#include <VBox/param.h>
46	#include <VBox/version.h>
47	#include <VBox/settings.h>
48
49	using namespace std;
50
51	////////////////////////////////////////////////////////////////////////////////
52	//
53	// IAppliance public methods
54	//
55	////////////////////////////////////////////////////////////////////////////////
56
57	/**
58	* Public method implementation. This opens the OVF with ovfreader.cpp.
59	* Thread implementation is in Appliance::readImpl().
60	*
61	* @param path
62	* @return
63	*/
64	STDMETHODIMP Appliance::Read(IN_BSTR path, IProgress **aProgress)
65	{
66	if (!path) return E_POINTER;
67	CheckComArgOutPointerValid(aProgress);
68
69	AutoCaller autoCaller(this);
70	if (FAILED(autoCaller.rc())) return autoCaller.rc();
71
72	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
73
74	if (!isApplianceIdle())
75	return E_ACCESSDENIED;
76
77	if (m->pReader)
78	{
79	delete m->pReader;
80	m->pReader = NULL;
81	}
82
83	// see if we can handle this file; for now we insist it has an ovf/ova extension
84	Utf8Str strPath (path);
85	if (!( strPath.endsWith(".ovf", Utf8Str::CaseInsensitive)
86	\|\| strPath.endsWith(".ova", Utf8Str::CaseInsensitive)))
87	return setError(VBOX_E_FILE_ERROR,
88	tr("Appliance file must have .ovf extension"));
89
90	ComObjPtr<Progress> progress;
91	HRESULT rc = S_OK;
92	try
93	{
94	/* Parse all necessary info out of the URI */
95	parseURI(strPath, m->locInfo);
96	rc = readImpl(m->locInfo, progress);
97	}
98	catch (HRESULT aRC)
99	{
100	rc = aRC;
101	}
102
103	if (SUCCEEDED(rc))
104	/* Return progress to the caller */
105	progress.queryInterfaceTo(aProgress);
106
107	return S_OK;
108	}
109
110	/**
111	* Public method implementation. This looks at the output of ovfreader.cpp and creates
112	* VirtualSystemDescription instances.
113	* @return
114	*/
115	STDMETHODIMP Appliance::Interpret()
116	{
117	// @todo:
118	// - don't use COM methods but the methods directly (faster, but needs appropriate locking of that objects itself (s. HardDisk))
119	// - Appropriate handle errors like not supported file formats
120	AutoCaller autoCaller(this);
121	if (FAILED(autoCaller.rc())) return autoCaller.rc();
122
123	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
124
125	if (!isApplianceIdle())
126	return E_ACCESSDENIED;
127
128	HRESULT rc = S_OK;
129
130	/* Clear any previous virtual system descriptions */
131	m->virtualSystemDescriptions.clear();
132
133	if (!m->pReader)
134	return setError(E_FAIL,
135	tr("Cannot interpret appliance without reading it first (call read() before interpret())"));
136
137	// Change the appliance state so we can safely leave the lock while doing time-consuming
138	// disk imports; also the below method calls do all kinds of locking which conflicts with
139	// the appliance object lock
140	m->state = Data::ApplianceImporting;
141	alock.release();
142
143	/* Try/catch so we can clean up on error */
144	try
145	{
146	list<ovf::VirtualSystem>::const_iterator it;
147	/* Iterate through all virtual systems */
148	for (it = m->pReader->m_llVirtualSystems.begin();
149	it != m->pReader->m_llVirtualSystems.end();
150	++it)
151	{
152	const ovf::VirtualSystem &vsysThis = *it;
153
154	ComObjPtr<VirtualSystemDescription> pNewDesc;
155	rc = pNewDesc.createObject();
156	if (FAILED(rc)) throw rc;
157	rc = pNewDesc->init();
158	if (FAILED(rc)) throw rc;
159
160	// if the virtual system in OVF had a <vbox:Machine> element, have the
161	// VirtualBox settings code parse that XML now
162	if (vsysThis.pelmVboxMachine)
163	pNewDesc->importVboxMachineXML(*vsysThis.pelmVboxMachine);
164
165	// Guest OS type
166	// This is taken from one of three places, in this order:
167	Utf8Str strOsTypeVBox;
168	Utf8StrFmt strCIMOSType("%RU32", (uint32_t)vsysThis.cimos);
169	// 1) If there is a <vbox:Machine>, then use the type from there.
170	if ( vsysThis.pelmVboxMachine
171	&& pNewDesc->m->pConfig->machineUserData.strOsType.isNotEmpty()
172	)
173	strOsTypeVBox = pNewDesc->m->pConfig->machineUserData.strOsType;
174	// 2) Otherwise, if there is OperatingSystemSection/vbox:OSType, use that one.
175	else if (vsysThis.strTypeVbox.isNotEmpty()) // OVFReader has found vbox:OSType
176	strOsTypeVBox = vsysThis.strTypeVbox;
177	// 3) Otherwise, make a best guess what the vbox type is from the OVF (CIM) OS type.
178	else
179	convertCIMOSType2VBoxOSType(strOsTypeVBox, vsysThis.cimos, vsysThis.strCimosDesc);
180	pNewDesc->addEntry(VirtualSystemDescriptionType_OS,
181	"",
182	strCIMOSType,
183	strOsTypeVBox);
184
185	/* VM name */
186	Utf8Str nameVBox;
187	/* If there is a <vbox:Machine>, we always prefer the setting from there. */
188	if ( vsysThis.pelmVboxMachine
189	&& pNewDesc->m->pConfig->machineUserData.strName.isNotEmpty())
190	nameVBox = pNewDesc->m->pConfig->machineUserData.strName;
191	else
192	nameVBox = vsysThis.strName;
193	/* If the there isn't any name specified create a default one out
194	* of the OS type */
195	if (nameVBox.isEmpty())
196	nameVBox = strOsTypeVBox;
197	searchUniqueVMName(nameVBox);
198	pNewDesc->addEntry(VirtualSystemDescriptionType_Name,
199	"",
200	vsysThis.strName,
201	nameVBox);
202
203	/* Based on the VM name, create a target machine path. */
204	Bstr bstrMachineFilename;
205	rc = mVirtualBox->ComposeMachineFilename(Bstr(nameVBox).raw(),
206	NULL,
207	bstrMachineFilename.asOutParam());
208	if (FAILED(rc)) throw rc;
209	/* Determine the machine folder from that */
210	Utf8Str strMachineFolder = Utf8Str(bstrMachineFilename).stripFilename();
211
212	/* VM Product */
213	if (!vsysThis.strProduct.isEmpty())
214	pNewDesc->addEntry(VirtualSystemDescriptionType_Product,
215	"",
216	vsysThis.strProduct,
217	vsysThis.strProduct);
218
219	/* VM Vendor */
220	if (!vsysThis.strVendor.isEmpty())
221	pNewDesc->addEntry(VirtualSystemDescriptionType_Vendor,
222	"",
223	vsysThis.strVendor,
224	vsysThis.strVendor);
225
226	/* VM Version */
227	if (!vsysThis.strVersion.isEmpty())
228	pNewDesc->addEntry(VirtualSystemDescriptionType_Version,
229	"",
230	vsysThis.strVersion,
231	vsysThis.strVersion);
232
233	/* VM ProductUrl */
234	if (!vsysThis.strProductUrl.isEmpty())
235	pNewDesc->addEntry(VirtualSystemDescriptionType_ProductUrl,
236	"",
237	vsysThis.strProductUrl,
238	vsysThis.strProductUrl);
239
240	/* VM VendorUrl */
241	if (!vsysThis.strVendorUrl.isEmpty())
242	pNewDesc->addEntry(VirtualSystemDescriptionType_VendorUrl,
243	"",
244	vsysThis.strVendorUrl,
245	vsysThis.strVendorUrl);
246
247	/* VM description */
248	if (!vsysThis.strDescription.isEmpty())
249	pNewDesc->addEntry(VirtualSystemDescriptionType_Description,
250	"",
251	vsysThis.strDescription,
252	vsysThis.strDescription);
253
254	/* VM license */
255	if (!vsysThis.strLicenseText.isEmpty())
256	pNewDesc->addEntry(VirtualSystemDescriptionType_License,
257	"",
258	vsysThis.strLicenseText,
259	vsysThis.strLicenseText);
260
261	/* Now that we know the OS type, get our internal defaults based on that. */
262	ComPtr<IGuestOSType> pGuestOSType;
263	rc = mVirtualBox->GetGuestOSType(Bstr(strOsTypeVBox).raw(), pGuestOSType.asOutParam());
264	if (FAILED(rc)) throw rc;
265
266	/* CPU count */
267	ULONG cpuCountVBox;
268	/* If there is a <vbox:Machine>, we always prefer the setting from there. */
269	if ( vsysThis.pelmVboxMachine
270	&& pNewDesc->m->pConfig->hardwareMachine.cCPUs)
271	cpuCountVBox = pNewDesc->m->pConfig->hardwareMachine.cCPUs;
272	else
273	cpuCountVBox = vsysThis.cCPUs;
274	/* Check for the constraints */
275	if (cpuCountVBox > SchemaDefs::MaxCPUCount)
276	{
277	addWarning(tr("The virtual system \"%s\" claims support for %u CPU's, but VirtualBox has support for max %u CPU's only."),
278	vsysThis.strName.c_str(), cpuCountVBox, SchemaDefs::MaxCPUCount);
279	cpuCountVBox = SchemaDefs::MaxCPUCount;
280	}
281	if (vsysThis.cCPUs == 0)
282	cpuCountVBox = 1;
283	pNewDesc->addEntry(VirtualSystemDescriptionType_CPU,
284	"",
285	Utf8StrFmt("%RU32", (uint32_t)vsysThis.cCPUs),
286	Utf8StrFmt("%RU32", (uint32_t)cpuCountVBox));
287
288	/* RAM */
289	uint64_t ullMemSizeVBox;
290	/* If there is a <vbox:Machine>, we always prefer the setting from there. */
291	if ( vsysThis.pelmVboxMachine
292	&& pNewDesc->m->pConfig->hardwareMachine.ulMemorySizeMB)
293	ullMemSizeVBox = pNewDesc->m->pConfig->hardwareMachine.ulMemorySizeMB;
294	else
295	ullMemSizeVBox = vsysThis.ullMemorySize / _1M;
296	/* Check for the constraints */
297	if ( ullMemSizeVBox != 0
298	&& ( ullMemSizeVBox < MM_RAM_MIN_IN_MB
299	\|\| ullMemSizeVBox > MM_RAM_MAX_IN_MB
300	)
301	)
302	{
303	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."),
304	vsysThis.strName.c_str(), ullMemSizeVBox, MM_RAM_MIN_IN_MB, MM_RAM_MAX_IN_MB);
305	ullMemSizeVBox = RT_MIN(RT_MAX(ullMemSizeVBox, MM_RAM_MIN_IN_MB), MM_RAM_MAX_IN_MB);
306	}
307	if (vsysThis.ullMemorySize == 0)
308	{
309	/* If the RAM of the OVF is zero, use our predefined values */
310	ULONG memSizeVBox2;
311	rc = pGuestOSType->COMGETTER(RecommendedRAM)(&memSizeVBox2);
312	if (FAILED(rc)) throw rc;
313	/* VBox stores that in MByte */
314	ullMemSizeVBox = (uint64_t)memSizeVBox2;
315	}
316	pNewDesc->addEntry(VirtualSystemDescriptionType_Memory,
317	"",
318	Utf8StrFmt("%RU64", (uint64_t)vsysThis.ullMemorySize),
319	Utf8StrFmt("%RU64", (uint64_t)ullMemSizeVBox));
320
321	/* Audio */
322	Utf8Str strSoundCard;
323	Utf8Str strSoundCardOrig;
324	/* If there is a <vbox:Machine>, we always prefer the setting from there. */
325	if ( vsysThis.pelmVboxMachine
326	&& pNewDesc->m->pConfig->hardwareMachine.audioAdapter.fEnabled)
327	strSoundCard = Utf8StrFmt("%RU32", (uint32_t)pNewDesc->m->pConfig->hardwareMachine.audioAdapter.controllerType);
328	else if (vsysThis.strSoundCardType.isNotEmpty())
329	{
330	/* Set the AC97 always for the simple OVF case.
331	* @todo: figure out the hardware which could be possible */
332	strSoundCard = Utf8StrFmt("%RU32", (uint32_t)AudioControllerType_AC97);
333	strSoundCardOrig = vsysThis.strSoundCardType;
334	}
335	if (strSoundCard.isNotEmpty())
336	pNewDesc->addEntry(VirtualSystemDescriptionType_SoundCard,
337	"",
338	strSoundCardOrig,
339	strSoundCard);
340
341	#ifdef VBOX_WITH_USB
342	/* USB Controller */
343	/* If there is a <vbox:Machine>, we always prefer the setting from there. */
344	if ( ( vsysThis.pelmVboxMachine
345	&& pNewDesc->m->pConfig->hardwareMachine.usbController.fEnabled)
346	\|\| vsysThis.fHasUsbController)
347	pNewDesc->addEntry(VirtualSystemDescriptionType_USBController, "", "", "");
348	#endif /* VBOX_WITH_USB */
349
350	/* Network Controller */
351	/* If there is a <vbox:Machine>, we always prefer the setting from there. */
352	if (vsysThis.pelmVboxMachine)
353	{
354	const settings::NetworkAdaptersList &llNetworkAdapters = pNewDesc->m->pConfig->hardwareMachine.llNetworkAdapters;
355	/* Check for the constrains */
356	if (llNetworkAdapters.size() > SchemaDefs::NetworkAdapterCount)
357	addWarning(tr("The virtual system \"%s\" claims support for %zu network adapters, but VirtualBox has support for max %u network adapter only."),
358	vsysThis.strName.c_str(), llNetworkAdapters.size(), SchemaDefs::NetworkAdapterCount);
359	/* Iterate through all network adapters. */
360	settings::NetworkAdaptersList::const_iterator it1;
361	size_t a = 0;
362	for (it1 = llNetworkAdapters.begin();
363	it1 != llNetworkAdapters.end() && a < SchemaDefs::NetworkAdapterCount;
364	++it1, ++a)
365	{
366	if (it1->fEnabled)
367	{
368	Utf8Str strMode = convertNetworkAttachmentTypeToString(it1->mode);
369	pNewDesc->addEntry(VirtualSystemDescriptionType_NetworkAdapter,
370	"", // ref
371	strMode, // orig
372	Utf8StrFmt("%RU32", (uint32_t)it1->type), // conf
373	0,
374	Utf8StrFmt("slot=%RU32;type=%s", it1->ulSlot, strMode.c_str())); // extra conf
375	}
376	}
377	}
378	/* else we use the ovf configuration. */
379	else if (size_t cEthernetAdapters = vsysThis.llEthernetAdapters.size() > 0)
380	{
381	/* Check for the constrains */
382	if (cEthernetAdapters > SchemaDefs::NetworkAdapterCount)
383	addWarning(tr("The virtual system \"%s\" claims support for %zu network adapters, but VirtualBox has support for max %u network adapter only."),
384	vsysThis.strName.c_str(), cEthernetAdapters, SchemaDefs::NetworkAdapterCount);
385
386	/* Get the default network adapter type for the selected guest OS */
387	NetworkAdapterType_T defaultAdapterVBox = NetworkAdapterType_Am79C970A;
388	rc = pGuestOSType->COMGETTER(AdapterType)(&defaultAdapterVBox);
389	if (FAILED(rc)) throw rc;
390
391	ovf::EthernetAdaptersList::const_iterator itEA;
392	/* Iterate through all abstract networks. We support 8 network
393	* adapters at the maximum, so the first 8 will be added only. */
394	size_t a = 0;
395	for (itEA = vsysThis.llEthernetAdapters.begin();
396	itEA != vsysThis.llEthernetAdapters.end() && a < SchemaDefs::NetworkAdapterCount;
397	++itEA, ++a)
398	{
399	const ovf::EthernetAdapter &ea = *itEA; // logical network to connect to
400	Utf8Str strNetwork = ea.strNetworkName;
401	// make sure it's one of these two
402	if ( (strNetwork.compare("Null", Utf8Str::CaseInsensitive))
403	&& (strNetwork.compare("NAT", Utf8Str::CaseInsensitive))
404	&& (strNetwork.compare("Bridged", Utf8Str::CaseInsensitive))
405	&& (strNetwork.compare("Internal", Utf8Str::CaseInsensitive))
406	&& (strNetwork.compare("HostOnly", Utf8Str::CaseInsensitive))
407	&& (strNetwork.compare("VDE", Utf8Str::CaseInsensitive))
408	)
409	strNetwork = "Bridged"; // VMware assumes this is the default apparently
410
411	/* Figure out the hardware type */
412	NetworkAdapterType_T nwAdapterVBox = defaultAdapterVBox;
413	if (!ea.strAdapterType.compare("PCNet32", Utf8Str::CaseInsensitive))
414	{
415	/* If the default adapter is already one of the two
416	* PCNet adapters use the default one. If not use the
417	* Am79C970A as fallback. */
418	if (!(defaultAdapterVBox == NetworkAdapterType_Am79C970A \|\|
419	defaultAdapterVBox == NetworkAdapterType_Am79C973))
420	nwAdapterVBox = NetworkAdapterType_Am79C970A;
421	}
422	#ifdef VBOX_WITH_E1000
423	/* VMWare accidentally write this with VirtualCenter 3.5,
424	so make sure in this case always to use the VMWare one */
425	else if (!ea.strAdapterType.compare("E10000", Utf8Str::CaseInsensitive))
426	nwAdapterVBox = NetworkAdapterType_I82545EM;
427	else if (!ea.strAdapterType.compare("E1000", Utf8Str::CaseInsensitive))
428	{
429	/* Check if this OVF was written by VirtualBox */
430	if (Utf8Str(vsysThis.strVirtualSystemType).contains("virtualbox", Utf8Str::CaseInsensitive))
431	{
432	/* If the default adapter is already one of the three
433	* E1000 adapters use the default one. If not use the
434	* I82545EM as fallback. */
435	if (!(defaultAdapterVBox == NetworkAdapterType_I82540EM \|\|
436	defaultAdapterVBox == NetworkAdapterType_I82543GC \|\|
437	defaultAdapterVBox == NetworkAdapterType_I82545EM))
438	nwAdapterVBox = NetworkAdapterType_I82540EM;
439	}
440	else
441	/* Always use this one since it's what VMware uses */
442	nwAdapterVBox = NetworkAdapterType_I82545EM;
443	}
444	#endif /* VBOX_WITH_E1000 */
445
446	pNewDesc->addEntry(VirtualSystemDescriptionType_NetworkAdapter,
447	"", // ref
448	ea.strNetworkName, // orig
449	Utf8StrFmt("%RU32", (uint32_t)nwAdapterVBox), // conf
450	0,
451	Utf8StrFmt("type=%s", strNetwork.c_str())); // extra conf
452	}
453	}
454
455	/* If there is a <vbox:Machine>, we always prefer the setting from there. */
456	bool fFloppy = false;
457	bool fDVD = false;
458	if (vsysThis.pelmVboxMachine)
459	{
460	settings::StorageControllersList &llControllers = pNewDesc->m->pConfig->storageMachine.llStorageControllers;
461	settings::StorageControllersList::iterator it3;
462	for (it3 = llControllers.begin();
463	it3 != llControllers.end();
464	++it3)
465	{
466	settings::AttachedDevicesList &llAttachments = it3->llAttachedDevices;
467	settings::AttachedDevicesList::iterator it4;
468	for (it4 = llAttachments.begin();
469	it4 != llAttachments.end();
470	++it4)
471	{
472	fDVD \|= it4->deviceType == DeviceType_DVD;
473	fFloppy \|= it4->deviceType == DeviceType_Floppy;
474	if (fFloppy && fDVD)
475	break;
476	}
477	if (fFloppy && fDVD)
478	break;
479	}
480	}
481	else
482	{
483	fFloppy = vsysThis.fHasFloppyDrive;
484	fDVD = vsysThis.fHasCdromDrive;
485	}
486	/* Floppy Drive */
487	if (fFloppy)
488	pNewDesc->addEntry(VirtualSystemDescriptionType_Floppy, "", "", "");
489	/* CD Drive */
490	if (fDVD)
491	pNewDesc->addEntry(VirtualSystemDescriptionType_CDROM, "", "", "");
492
493	/* Hard disk Controller */
494	uint16_t cIDEused = 0;
495	uint16_t cSATAused = 0; NOREF(cSATAused);
496	uint16_t cSCSIused = 0; NOREF(cSCSIused);
497	ovf::ControllersMap::const_iterator hdcIt;
498	/* Iterate through all hard disk controllers */
499	for (hdcIt = vsysThis.mapControllers.begin();
500	hdcIt != vsysThis.mapControllers.end();
501	++hdcIt)
502	{
503	const ovf::HardDiskController &hdc = hdcIt->second;
504	Utf8Str strControllerID = Utf8StrFmt("%RI32", (uint32_t)hdc.idController);
505
506	switch (hdc.system)
507	{
508	case ovf::HardDiskController::IDE:
509	/* Check for the constrains */
510	if (cIDEused < 4)
511	{
512	// @todo: figure out the IDE types
513	/* Use PIIX4 as default */
514	Utf8Str strType = "PIIX4";
515	if (!hdc.strControllerType.compare("PIIX3", Utf8Str::CaseInsensitive))
516	strType = "PIIX3";
517	else if (!hdc.strControllerType.compare("ICH6", Utf8Str::CaseInsensitive))
518	strType = "ICH6";
519	pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskControllerIDE,
520	strControllerID, // strRef
521	hdc.strControllerType, // aOvfValue
522	strType); // aVboxValue
523	}
524	else
525	/* Warn only once */
526	if (cIDEused == 2)
527	addWarning(tr("The virtual \"%s\" system requests support for more than two IDE controller channels, but VirtualBox supports only two."),
528	vsysThis.strName.c_str());
529
530	++cIDEused;
531	break;
532
533	case ovf::HardDiskController::SATA:
534	/* Check for the constrains */
535	if (cSATAused < 1)
536	{
537	// @todo: figure out the SATA types
538	/* We only support a plain AHCI controller, so use them always */
539	pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskControllerSATA,
540	strControllerID,
541	hdc.strControllerType,
542	"AHCI");
543	}
544	else
545	{
546	/* Warn only once */
547	if (cSATAused == 1)
548	addWarning(tr("The virtual system \"%s\" requests support for more than one SATA controller, but VirtualBox has support for only one"),
549	vsysThis.strName.c_str());
550
551	}
552	++cSATAused;
553	break;
554
555	case ovf::HardDiskController::SCSI:
556	/* Check for the constrains */
557	if (cSCSIused < 1)
558	{
559	VirtualSystemDescriptionType_T vsdet = VirtualSystemDescriptionType_HardDiskControllerSCSI;
560	Utf8Str hdcController = "LsiLogic";
561	if (!hdc.strControllerType.compare("lsilogicsas", Utf8Str::CaseInsensitive))
562	{
563	// OVF considers SAS a variant of SCSI but VirtualBox considers it a class of its own
564	vsdet = VirtualSystemDescriptionType_HardDiskControllerSAS;
565	hdcController = "LsiLogicSas";
566	}
567	else if (!hdc.strControllerType.compare("BusLogic", Utf8Str::CaseInsensitive))
568	hdcController = "BusLogic";
569	pNewDesc->addEntry(vsdet,
570	strControllerID,
571	hdc.strControllerType,
572	hdcController);
573	}
574	else
575	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."),
576	vsysThis.strName.c_str(),
577	hdc.strControllerType.c_str(),
578	strControllerID.c_str());
579	++cSCSIused;
580	break;
581	}
582	}
583
584	/* Hard disks */
585	if (vsysThis.mapVirtualDisks.size() > 0)
586	{
587	ovf::VirtualDisksMap::const_iterator itVD;
588	/* Iterate through all hard disks ()*/
589	for (itVD = vsysThis.mapVirtualDisks.begin();
590	itVD != vsysThis.mapVirtualDisks.end();
591	++itVD)
592	{
593	const ovf::VirtualDisk &hd = itVD->second;
594	/* Get the associated disk image */
595	const ovf::DiskImage &di = m->pReader->m_mapDisks[hd.strDiskId];
596
597	// @todo:
598	// - figure out all possible vmdk formats we also support
599	// - figure out if there is a url specifier for vhd already
600	// - we need a url specifier for the vdi format
601	if ( di.strFormat.compare("http://www.vmware.com/specifications/vmdk.html#sparse", Utf8Str::CaseInsensitive)
602	\|\| di.strFormat.compare("http://www.vmware.com/interfaces/specifications/vmdk.html#streamOptimized", Utf8Str::CaseInsensitive)
603	\|\| di.strFormat.compare("http://www.vmware.com/specifications/vmdk.html#compressed", Utf8Str::CaseInsensitive)
604	\|\| di.strFormat.compare("http://www.vmware.com/interfaces/specifications/vmdk.html#compressed", Utf8Str::CaseInsensitive)
605	)
606	{
607	/* If the href is empty use the VM name as filename */
608	Utf8Str strFilename = di.strHref;
609	if (!strFilename.length())
610	strFilename = Utf8StrFmt("%s.vmdk", nameVBox.c_str());
611
612	Utf8Str strTargetPath = Utf8Str(strMachineFolder)
613	.append(RTPATH_DELIMITER)
614	.append(di.strHref);
615	searchUniqueDiskImageFilePath(strTargetPath);
616
617	/* find the description for the hard disk controller
618	* that has the same ID as hd.idController */
619	const VirtualSystemDescriptionEntry *pController;
620	if (!(pController = pNewDesc->findControllerFromID(hd.idController)))
621	throw setError(E_FAIL,
622	tr("Cannot find hard disk controller with OVF instance ID %RI32 to which disk \"%s\" should be attached"),
623	hd.idController,
624	di.strHref.c_str());
625
626	/* controller to attach to, and the bus within that controller */
627	Utf8StrFmt strExtraConfig("controller=%RI16;channel=%RI16",
628	pController->ulIndex,
629	hd.ulAddressOnParent);
630	pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskImage,
631	hd.strDiskId,
632	di.strHref,
633	strTargetPath,
634	di.ulSuggestedSizeMB,
635	strExtraConfig);
636	}
637	else
638	throw setError(VBOX_E_FILE_ERROR,
639	tr("Unsupported format for virtual disk image in OVF: \"%s\"", di.strFormat.c_str()));
640	}
641	}
642
643	m->virtualSystemDescriptions.push_back(pNewDesc);
644	}
645	}
646	catch (HRESULT aRC)
647	{
648	/* On error we clear the list & return */
649	m->virtualSystemDescriptions.clear();
650	rc = aRC;
651	}
652
653	// reset the appliance state
654	alock.acquire();
655	m->state = Data::ApplianceIdle;
656
657	return rc;
658	}
659
660	/**
661	* Public method implementation. This creates one or more new machines according to the
662	* VirtualSystemScription instances created by Appliance::Interpret().
663	* Thread implementation is in Appliance::importImpl().
664	* @param aProgress
665	* @return
666	*/
667	STDMETHODIMP Appliance::ImportMachines(IProgress **aProgress)
668	{
669	CheckComArgOutPointerValid(aProgress);
670
671	AutoCaller autoCaller(this);
672	if (FAILED(autoCaller.rc())) return autoCaller.rc();
673
674	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
675
676	// do not allow entering this method if the appliance is busy reading or writing
677	if (!isApplianceIdle())
678	return E_ACCESSDENIED;
679
680	if (!m->pReader)
681	return setError(E_FAIL,
682	tr("Cannot import machines without reading it first (call read() before importMachines())"));
683
684	ComObjPtr<Progress> progress;
685	HRESULT rc = S_OK;
686	try
687	{
688	rc = importImpl(m->locInfo, progress);
689	}
690	catch (HRESULT aRC)
691	{
692	rc = aRC;
693	}
694
695	if (SUCCEEDED(rc))
696	/* Return progress to the caller */
697	progress.queryInterfaceTo(aProgress);
698
699	return rc;
700	}
701
702	////////////////////////////////////////////////////////////////////////////////
703	//
704	// Appliance private methods
705	//
706	////////////////////////////////////////////////////////////////////////////////
707
708
709	/*******************************************************************************
710	* Read stuff
711	******************************************************************************/
712
713	/**
714	* Implementation for reading an OVF. This starts a new thread which will call
715	* Appliance::taskThreadImportOrExport() which will then call readFS() or readS3().
716	* This will then open the OVF with ovfreader.cpp.
717	*
718	* This is in a separate private method because it is used from three locations:
719	*
720	* 1) from the public Appliance::Read().
721	*
722	* 2) in a second worker thread; in that case, Appliance::ImportMachines() called Appliance::importImpl(), which
723	* called Appliance::readFSOVA(), which called Appliance::importImpl(), which then called this again.
724	*
725	* 3) from Appliance::readS3(), which got called from a previous instance of Appliance::taskThreadImportOrExport().
726	*
727	* @param aLocInfo
728	* @param aProgress
729	* @return
730	*/
731	HRESULT Appliance::readImpl(const LocationInfo &aLocInfo, ComObjPtr<Progress> &aProgress)
732	{
733	BstrFmt bstrDesc = BstrFmt(tr("Reading appliance '%s'"),
734	aLocInfo.strPath.c_str());
735	HRESULT rc;
736	/* Create the progress object */
737	aProgress.createObject();
738	if (aLocInfo.storageType == VFSType_File)
739	/* 1 operation only */
740	rc = aProgress->init(mVirtualBox, static_cast<IAppliance*>(this),
741	bstrDesc.raw(),
742	TRUE /* aCancelable */);
743	else
744	/* 4/5 is downloading, 1/5 is reading */
745	rc = aProgress->init(mVirtualBox, static_cast<IAppliance*>(this),
746	bstrDesc.raw(),
747	TRUE /* aCancelable */,
748	2, // ULONG cOperations,
749	5, // ULONG ulTotalOperationsWeight,
750	BstrFmt(tr("Download appliance '%s'"),
751	aLocInfo.strPath.c_str()).raw(), // CBSTR bstrFirstOperationDescription,
752	4); // ULONG ulFirstOperationWeight,
753	if (FAILED(rc)) throw rc;
754
755	/* Initialize our worker task */
756	std::auto_ptr<TaskOVF> task(new TaskOVF(this, TaskOVF::Read, aLocInfo, aProgress));
757
758	rc = task->startThread();
759	if (FAILED(rc)) throw rc;
760
761	/* Don't destruct on success */
762	task.release();
763
764	return rc;
765	}
766
767	/**
768	* Actual worker code for reading an OVF from disk. This is called from Appliance::taskThreadImportOrExport()
769	* and therefore runs on the OVF read worker thread. This opens the OVF with ovfreader.cpp.
770	*
771	* This runs in two contexts:
772	*
773	* 1) in a first worker thread; in that case, Appliance::Read() called Appliance::readImpl();
774	*
775	* 2) in a second worker thread; in that case, Appliance::Read() called Appliance::readImpl(), which
776	* called Appliance::readS3(), which called Appliance::readImpl(), which then called this.
777	*
778	* @param pTask
779	* @return
780	*/
781	HRESULT Appliance::readFS(TaskOVF *pTask)
782	{
783	LogFlowFuncEnter();
784	LogFlowFunc(("Appliance %p\n", this));
785
786	AutoCaller autoCaller(this);
787	if (FAILED(autoCaller.rc())) return autoCaller.rc();
788
789	AutoWriteLock appLock(this COMMA_LOCKVAL_SRC_POS);
790
791	HRESULT rc = S_OK;
792
793	if (pTask->locInfo.strPath.endsWith(".ovf", Utf8Str::CaseInsensitive))
794	rc = readFSOVF(pTask);
795	else
796	rc = readFSOVA(pTask);
797
798	LogFlowFunc(("rc=%Rhrc\n", rc));
799	LogFlowFuncLeave();
800
801	return rc;
802	}
803
804	HRESULT Appliance::readFSOVF(TaskOVF *pTask)
805	{
806	LogFlowFuncEnter();
807
808	HRESULT rc = S_OK;
809
810	PVDINTERFACEIO pSha1Callbacks = 0;
811	PVDINTERFACEIO pFileCallbacks = 0;
812	do
813	{
814	pSha1Callbacks = Sha1CreateInterface();
815	if (!pSha1Callbacks)
816	{
817	rc = E_OUTOFMEMORY;
818	break;
819	}
820	pFileCallbacks = FileCreateInterface();
821	if (!pFileCallbacks)
822	{
823	rc = E_OUTOFMEMORY;
824	break;
825	}
826	VDINTERFACE VDInterfaceIO;
827	SHA1STORAGE storage;
828	RT_ZERO(storage);
829	int vrc = VDInterfaceAdd(&VDInterfaceIO, "Appliance::IOFile",
830	VDINTERFACETYPE_IO, pFileCallbacks,
831	0, &storage.pVDImageIfaces);
832	if (RT_FAILURE(vrc))
833	{
834	rc = E_FAIL;
835	break;
836	}
837	rc = readFSImpl(pTask, pSha1Callbacks, &storage);
838	}while(0);
839
840	/* Cleanup */
841	if (pSha1Callbacks)
842	RTMemFree(pSha1Callbacks);
843	if (pFileCallbacks)
844	RTMemFree(pFileCallbacks);
845
846	LogFlowFunc(("rc=%Rhrc\n", rc));
847	LogFlowFuncLeave();
848
849	return rc;
850	}
851
852	HRESULT Appliance::readFSOVA(TaskOVF *pTask)
853	{
854	LogFlowFuncEnter();
855
856	RTTAR tar;
857	int vrc = RTTarOpen(&tar, pTask->locInfo.strPath.c_str(), RTFILE_O_OPEN \| RTFILE_O_READ \| RTFILE_O_DENY_NONE, true);
858	if (RT_FAILURE(vrc))
859	return setError(VBOX_E_FILE_ERROR,
860	tr("Could not open OVA file '%s' (%Rrc)"),
861	pTask->locInfo.strPath.c_str(), vrc);
862
863	HRESULT rc = S_OK;
864
865	PVDINTERFACEIO pSha1Callbacks = 0;
866	PVDINTERFACEIO pTarCallbacks = 0;
867	do
868	{
869	pSha1Callbacks = Sha1CreateInterface();
870	if (!pSha1Callbacks)
871	{
872	rc = E_OUTOFMEMORY;
873	break;
874	}
875	pTarCallbacks = TarCreateInterface();
876	if (!pTarCallbacks)
877	{
878	rc = E_OUTOFMEMORY;
879	break;
880	}
881	VDINTERFACE VDInterfaceIO;
882	SHA1STORAGE storage;
883	RT_ZERO(storage);
884	vrc = VDInterfaceAdd(&VDInterfaceIO, "Appliance::IOTar",
885	VDINTERFACETYPE_IO, pTarCallbacks,
886	tar, &storage.pVDImageIfaces);
887	if (RT_FAILURE(vrc))
888	{
889	rc = E_FAIL;
890	break;
891	}
892	rc = readFSImpl(pTask, pSha1Callbacks, &storage);
893	}while(0);
894
895	RTTarClose(tar);
896
897	/* Cleanup */
898	if (pSha1Callbacks)
899	RTMemFree(pSha1Callbacks);
900	if (pTarCallbacks)
901	RTMemFree(pTarCallbacks);
902
903	LogFlowFunc(("rc=%Rhrc\n", rc));
904	LogFlowFuncLeave();
905
906	return rc;
907	}
908
909	HRESULT Appliance::readFSImpl(TaskOVF *pTask, PVDINTERFACEIO pCallbacks, PSHA1STORAGE pStorage)
910	{
911	LogFlowFuncEnter();
912
913	HRESULT rc = S_OK;
914
915	pStorage->fCreateDigest = true;
916
917	void *pvTmpBuf = 0;
918	try
919	{
920	Utf8Str strOvfFile = Utf8Str(pTask->locInfo.strPath).stripExt().append(".ovf");
921	/* Read the OVF into a memory buffer */
922	size_t cbSize = 0;
923	int vrc = Sha1ReadBuf(strOvfFile.c_str(), &pvTmpBuf, &cbSize, pCallbacks, pStorage);
924	if ( RT_FAILURE(vrc)
925	\|\| !pvTmpBuf)
926	throw setError(VBOX_E_FILE_ERROR,
927	tr("Could not read OVF file '%s' (%Rrc)"),
928	RTPathFilename(strOvfFile.c_str()), vrc);
929	/* Copy the SHA1 sum of the OVF file for later validation */
930	m->strOVFSHA1Digest = pStorage->strDigest;
931	/* Read & parse the XML structure of the OVF file */
932	m->pReader = new ovf::OVFReader(pvTmpBuf, cbSize, pTask->locInfo.strPath);
933	}
934	catch (RTCError &x) // includes all XML exceptions
935	{
936	rc = setError(VBOX_E_FILE_ERROR,
937	x.what());
938	}
939	catch (HRESULT aRC)
940	{
941	rc = aRC;
942	}
943
944	/* Cleanup */
945	if (pvTmpBuf)
946	RTMemFree(pvTmpBuf);
947
948	LogFlowFunc(("rc=%Rhrc\n", rc));
949	LogFlowFuncLeave();
950
951	return rc;
952	}
953
954	#ifdef VBOX_WITH_S3
955	/**
956	* Worker code for reading OVF from the cloud. This is called from Appliance::taskThreadImportOrExport()
957	* in S3 mode and therefore runs on the OVF read worker thread. This then starts a second worker
958	* thread to create temporary files (see Appliance::readFS()).
959	*
960	* @param pTask
961	* @return
962	*/
963	HRESULT Appliance::readS3(TaskOVF *pTask)
964	{
965	LogFlowFuncEnter();
966	LogFlowFunc(("Appliance %p\n", this));
967
968	AutoCaller autoCaller(this);
969	if (FAILED(autoCaller.rc())) return autoCaller.rc();
970
971	AutoWriteLock appLock(this COMMA_LOCKVAL_SRC_POS);
972
973	HRESULT rc = S_OK;
974	int vrc = VINF_SUCCESS;
975	RTS3 hS3 = NIL_RTS3;
976	char szOSTmpDir[RTPATH_MAX];
977	RTPathTemp(szOSTmpDir, sizeof(szOSTmpDir));
978	/* The template for the temporary directory created below */
979	char *pszTmpDir = RTPathJoinA(szOSTmpDir, "vbox-ovf-XXXXXX");
980	list< pair<Utf8Str, ULONG> > filesList;
981	Utf8Str strTmpOvf;
982
983	try
984	{
985	/* Extract the bucket */
986	Utf8Str tmpPath = pTask->locInfo.strPath;
987	Utf8Str bucket;
988	parseBucket(tmpPath, bucket);
989
990	/* We need a temporary directory which we can put the OVF file & all
991	* disk images in */
992	vrc = RTDirCreateTemp(pszTmpDir);
993	if (RT_FAILURE(vrc))
994	throw setError(VBOX_E_FILE_ERROR,
995	tr("Cannot create temporary directory '%s'"), pszTmpDir);
996
997	/* The temporary name of the target OVF file */
998	strTmpOvf = Utf8StrFmt("%s/%s", pszTmpDir, RTPathFilename(tmpPath.c_str()));
999
1000	/* Next we have to download the OVF */
1001	vrc = RTS3Create(&hS3, pTask->locInfo.strUsername.c_str(), pTask->locInfo.strPassword.c_str(), pTask->locInfo.strHostname.c_str(), "virtualbox-agent/"VBOX_VERSION_STRING);
1002	if (RT_FAILURE(vrc))
1003	throw setError(VBOX_E_IPRT_ERROR,
1004	tr("Cannot create S3 service handler"));
1005	RTS3SetProgressCallback(hS3, pTask->updateProgress, &pTask);
1006
1007	/* Get it */
1008	char *pszFilename = RTPathFilename(strTmpOvf.c_str());
1009	vrc = RTS3GetKey(hS3, bucket.c_str(), pszFilename, strTmpOvf.c_str());
1010	if (RT_FAILURE(vrc))
1011	{
1012	if (vrc == VERR_S3_CANCELED)
1013	throw S_OK; /* todo: !!!!!!!!!!!!! */
1014	else if (vrc == VERR_S3_ACCESS_DENIED)
1015	throw setError(E_ACCESSDENIED,
1016	tr("Cannot download file '%s' from S3 storage server (Access denied). Make sure that your credentials are right."
1017	"Also check that your host clock is properly synced"),
1018	pszFilename);
1019	else if (vrc == VERR_S3_NOT_FOUND)
1020	throw setError(VBOX_E_FILE_ERROR,
1021	tr("Cannot download file '%s' from S3 storage server (File not found)"), pszFilename);
1022	else
1023	throw setError(VBOX_E_IPRT_ERROR,
1024	tr("Cannot download file '%s' from S3 storage server (%Rrc)"), pszFilename, vrc);
1025	}
1026
1027	/* Close the connection early */
1028	RTS3Destroy(hS3);
1029	hS3 = NIL_RTS3;
1030
1031	pTask->pProgress->SetNextOperation(Bstr(tr("Reading")).raw(), 1);
1032
1033	/* Prepare the temporary reading of the OVF */
1034	ComObjPtr<Progress> progress;
1035	LocationInfo li;
1036	li.strPath = strTmpOvf;
1037	/* Start the reading from the fs */
1038	rc = readImpl(li, progress);
1039	if (FAILED(rc)) throw rc;
1040
1041	/* Unlock the appliance for the reading thread */
1042	appLock.release();
1043	/* Wait until the reading is done, but report the progress back to the
1044	caller */
1045	ComPtr<IProgress> progressInt(progress);
1046	waitForAsyncProgress(pTask->pProgress, progressInt); /* Any errors will be thrown */
1047
1048	/* Again lock the appliance for the next steps */
1049	appLock.acquire();
1050	}
1051	catch(HRESULT aRC)
1052	{
1053	rc = aRC;
1054	}
1055	/* Cleanup */
1056	RTS3Destroy(hS3);
1057	/* Delete all files which where temporary created */
1058	if (RTPathExists(strTmpOvf.c_str()))
1059	{
1060	vrc = RTFileDelete(strTmpOvf.c_str());
1061	if (RT_FAILURE(vrc))
1062	rc = setError(VBOX_E_FILE_ERROR,
1063	tr("Cannot delete file '%s' (%Rrc)"), strTmpOvf.c_str(), vrc);
1064	}
1065	/* Delete the temporary directory */
1066	if (RTPathExists(pszTmpDir))
1067	{
1068	vrc = RTDirRemove(pszTmpDir);
1069	if (RT_FAILURE(vrc))
1070	rc = setError(VBOX_E_FILE_ERROR,
1071	tr("Cannot delete temporary directory '%s' (%Rrc)"), pszTmpDir, vrc);
1072	}
1073	if (pszTmpDir)
1074	RTStrFree(pszTmpDir);
1075
1076	LogFlowFunc(("rc=%Rhrc\n", rc));
1077	LogFlowFuncLeave();
1078
1079	return rc;
1080	}
1081	#endif /* VBOX_WITH_S3 */
1082
1083	/*******************************************************************************
1084	* Import stuff
1085	******************************************************************************/
1086
1087	/**
1088	* Implementation for importing OVF data into VirtualBox. This starts a new thread which will call
1089	* Appliance::taskThreadImportOrExport().
1090	*
1091	* This creates one or more new machines according to the VirtualSystemScription instances created by
1092	* Appliance::Interpret().
1093	*
1094	* This is in a separate private method because it is used from two locations:
1095	*
1096	* 1) from the public Appliance::ImportMachines().
1097	* 2) from Appliance::importS3(), which got called from a previous instance of Appliance::taskThreadImportOrExport().
1098	*
1099	* @param aLocInfo
1100	* @param aProgress
1101	* @return
1102	*/
1103	HRESULT Appliance::importImpl(const LocationInfo &locInfo,
1104	ComObjPtr<Progress> &progress)
1105	{
1106	HRESULT rc = S_OK;
1107
1108	SetUpProgressMode mode;
1109	if (locInfo.storageType == VFSType_File)
1110	mode = ImportFile;
1111	else
1112	mode = ImportS3;
1113
1114	rc = setUpProgress(progress,
1115	BstrFmt(tr("Importing appliance '%s'"), locInfo.strPath.c_str()),
1116	mode);
1117	if (FAILED(rc)) throw rc;
1118
1119	/* Initialize our worker task */
1120	std::auto_ptr<TaskOVF> task(new TaskOVF(this, TaskOVF::Import, locInfo, progress));
1121
1122	rc = task->startThread();
1123	if (FAILED(rc)) throw rc;
1124
1125	/* Don't destruct on success */
1126	task.release();
1127
1128	return rc;
1129	}
1130
1131	/**
1132	* Actual worker code for importing OVF data into VirtualBox. This is called from Appliance::taskThreadImportOrExport()
1133	* and therefore runs on the OVF import worker thread. This creates one or more new machines according to the
1134	* VirtualSystemScription instances created by Appliance::Interpret().
1135	*
1136	* This runs in three contexts:
1137	*
1138	* 1) in a first worker thread; in that case, Appliance::ImportMachines() called Appliance::importImpl();
1139	*
1140	* 2) in a second worker thread; in that case, Appliance::ImportMachines() called Appliance::importImpl(), which
1141	* called Appliance::importFSOVA(), which called Appliance::importImpl(), which then called this again.
1142	*
1143	* 3) in a second worker thread; in that case, Appliance::ImportMachines() called Appliance::importImpl(), which
1144	* called Appliance::importS3(), which called Appliance::importImpl(), which then called this again.
1145	*
1146	* @param pTask
1147	* @return
1148	*/
1149	HRESULT Appliance::importFS(TaskOVF *pTask)
1150	{
1151
1152	LogFlowFuncEnter();
1153	LogFlowFunc(("Appliance %p\n", this));
1154
1155	AutoCaller autoCaller(this);
1156	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1157
1158	/* Change the appliance state so we can safely leave the lock while doing
1159	* time-consuming disk imports; also the below method calls do all kinds of
1160	* locking which conflicts with the appliance object lock. */
1161	AutoWriteLock writeLock(this COMMA_LOCKVAL_SRC_POS);
1162	/* Check if the appliance is currently busy. */
1163	if (!isApplianceIdle())
1164	return E_ACCESSDENIED;
1165	/* Set the internal state to importing. */
1166	m->state = Data::ApplianceImporting;
1167
1168	HRESULT rc = S_OK;
1169
1170	/* Clear the list of imported machines, if any */
1171	m->llGuidsMachinesCreated.clear();
1172
1173	if (pTask->locInfo.strPath.endsWith(".ovf", Utf8Str::CaseInsensitive))
1174	rc = importFSOVF(pTask, writeLock);
1175	else
1176	rc = importFSOVA(pTask, writeLock);
1177
1178	if (FAILED(rc))
1179	{
1180	/* With _whatever_ error we've had, do a complete roll-back of
1181	* machines and disks we've created */
1182	writeLock.release();
1183	for (list<Guid>::iterator itID = m->llGuidsMachinesCreated.begin();
1184	itID != m->llGuidsMachinesCreated.end();
1185	++itID)
1186	{
1187	Guid guid = *itID;
1188	Bstr bstrGuid = guid.toUtf16();
1189	ComPtr<IMachine> failedMachine;
1190	HRESULT rc2 = mVirtualBox->FindMachine(bstrGuid.raw(), failedMachine.asOutParam());
1191	if (SUCCEEDED(rc2))
1192	{
1193	SafeIfaceArray<IMedium> aMedia;
1194	rc2 = failedMachine->Unregister(CleanupMode_DetachAllReturnHardDisksOnly, ComSafeArrayAsOutParam(aMedia));
1195	ComPtr<IProgress> pProgress2;
1196	rc2 = failedMachine->Delete(ComSafeArrayAsInParam(aMedia), pProgress2.asOutParam());
1197	pProgress2->WaitForCompletion(-1);
1198	}
1199	}
1200	writeLock.acquire();
1201	}
1202
1203	/* Reset the state so others can call methods again */
1204	m->state = Data::ApplianceIdle;
1205
1206	LogFlowFunc(("rc=%Rhrc\n", rc));
1207	LogFlowFuncLeave();
1208
1209	return rc;
1210	}
1211
1212	HRESULT Appliance::importFSOVF(TaskOVF *pTask, AutoWriteLockBase& writeLock)
1213	{
1214	LogFlowFuncEnter();
1215
1216	HRESULT rc = S_OK;
1217
1218	PVDINTERFACEIO pSha1Callbacks = 0;
1219	PVDINTERFACEIO pFileCallbacks = 0;
1220	void *pvMfBuf = 0;
1221	writeLock.release();
1222	try
1223	{
1224	/* Create the necessary file access interfaces. */
1225	pSha1Callbacks = Sha1CreateInterface();
1226	if (!pSha1Callbacks)
1227	throw E_OUTOFMEMORY;
1228	pFileCallbacks = FileCreateInterface();
1229	if (!pFileCallbacks)
1230	throw E_OUTOFMEMORY;
1231
1232	VDINTERFACE VDInterfaceIO;
1233	SHA1STORAGE storage;
1234	RT_ZERO(storage);
1235	storage.fCreateDigest = true;
1236	int vrc = VDInterfaceAdd(&VDInterfaceIO, "Appliance::IOFile",
1237	VDINTERFACETYPE_IO, pFileCallbacks,
1238	0, &storage.pVDImageIfaces);
1239	if (RT_FAILURE(vrc))
1240	throw E_FAIL;
1241
1242	size_t cbMfSize = 0;
1243	Utf8Str strMfFile = Utf8Str(pTask->locInfo.strPath).stripExt().append(".mf");
1244	/* Create the import stack for the rollback on errors. */
1245	ImportStack stack(pTask->locInfo, m->pReader->m_mapDisks, pTask->pProgress);
1246	/* Do we need the digest information? */
1247	storage.fCreateDigest = RTFileExists(strMfFile.c_str());
1248	/* Now import the appliance. */
1249	importMachines(stack, pSha1Callbacks, &storage);
1250	/* Read & verify the manifest file, if there is one. */
1251	if (storage.fCreateDigest)
1252	{
1253	/* Add the ovf file to the digest list. */
1254	stack.llSrcDisksDigest.push_front(STRPAIR(pTask->locInfo.strPath, m->strOVFSHA1Digest));
1255	rc = readManifestFile(strMfFile, &pvMfBuf, &cbMfSize, pSha1Callbacks, &storage);
1256	if (FAILED(rc)) throw rc;
1257	rc = verifyManifestFile(strMfFile, stack, pvMfBuf, cbMfSize);
1258	if (FAILED(rc)) throw rc;
1259	}
1260	}
1261	catch (HRESULT rc2)
1262	{
1263	rc = rc2;
1264	}
1265	writeLock.acquire();
1266
1267	/* Cleanup */
1268	if (pvMfBuf)
1269	RTMemFree(pvMfBuf);
1270	if (pSha1Callbacks)
1271	RTMemFree(pSha1Callbacks);
1272	if (pFileCallbacks)
1273	RTMemFree(pFileCallbacks);
1274
1275	LogFlowFunc(("rc=%Rhrc\n", rc));
1276	LogFlowFuncLeave();
1277
1278	return rc;
1279	}
1280
1281	HRESULT Appliance::importFSOVA(TaskOVF *pTask, AutoWriteLockBase& writeLock)
1282	{
1283	LogFlowFuncEnter();
1284
1285	RTTAR tar;
1286	int vrc = RTTarOpen(&tar, pTask->locInfo.strPath.c_str(), RTFILE_O_OPEN \| RTFILE_O_READ \| RTFILE_O_DENY_NONE, true);
1287	if (RT_FAILURE(vrc))
1288	return setError(VBOX_E_FILE_ERROR,
1289	tr("Could not open OVA file '%s' (%Rrc)"),
1290	pTask->locInfo.strPath.c_str(), vrc);
1291
1292	HRESULT rc = S_OK;
1293
1294	PVDINTERFACEIO pSha1Callbacks = 0;
1295	PVDINTERFACEIO pTarCallbacks = 0;
1296	void *pvMfBuf = 0;
1297	writeLock.release();
1298	try
1299	{
1300	/* Create the necessary file access interfaces. */
1301	pSha1Callbacks = Sha1CreateInterface();
1302	if (!pSha1Callbacks)
1303	throw E_OUTOFMEMORY;
1304	pTarCallbacks = TarCreateInterface();
1305	if (!pTarCallbacks)
1306	throw E_OUTOFMEMORY;
1307
1308	VDINTERFACE VDInterfaceIO;
1309	SHA1STORAGE storage;
1310	RT_ZERO(storage);
1311	vrc = VDInterfaceAdd(&VDInterfaceIO, "Appliance::IOTar",
1312	VDINTERFACETYPE_IO, pTarCallbacks,
1313	tar, &storage.pVDImageIfaces);
1314	if (RT_FAILURE(vrc))
1315	throw setError(E_FAIL,
1316	tr("Internal error (%Rrc)"), vrc);
1317
1318	/* Skip the OVF file, cause this was read in IAppliance::Read already. */
1319	vrc = RTTarSeekNextFile(tar);
1320	if ( RT_FAILURE(vrc)
1321	&& vrc != VERR_TAR_END_OF_FILE)
1322	throw setError(E_FAIL,
1323	tr("Internal error (%Rrc)"), vrc);
1324
1325	PVDINTERFACEIO pCallbacks = pSha1Callbacks;
1326	PSHA1STORAGE pStorage = &storage;
1327
1328	/* We always need to create the digest, cause we didn't know if there
1329	* is a manifest file in the stream. */
1330	pStorage->fCreateDigest = true;
1331
1332	size_t cbMfSize = 0;
1333	Utf8Str strMfFile = Utf8Str(pTask->locInfo.strPath).stripExt().append(".mf");
1334	/* Create the import stack for the rollback on errors. */
1335	ImportStack stack(pTask->locInfo, m->pReader->m_mapDisks, pTask->pProgress);
1336	/*
1337	* Try to read the manifest file. First try.
1338	*
1339	* Note: This isn't fatal if the file is not found. The standard
1340	* defines 3 cases.
1341	* 1. no manifest file
1342	* 2. manifest file after the OVF file
1343	* 3. manifest file after all disk files
1344	* If we want streaming capabilities, we can't check if it is there by
1345	* searching for it. We have to try to open it on all possible places.
1346	* If it fails here, we will try it again after all disks where read.
1347	*/
1348	rc = readTarManifestFile(tar, strMfFile, &pvMfBuf, &cbMfSize, pCallbacks, pStorage);
1349	if (FAILED(rc)) throw rc;
1350	/* Now import the appliance. */
1351	importMachines(stack, pCallbacks, pStorage);
1352	/* Try to read the manifest file. Second try. */
1353	if (!pvMfBuf)
1354	{
1355	rc = readTarManifestFile(tar, strMfFile, &pvMfBuf, &cbMfSize, pCallbacks, pStorage);
1356	if (FAILED(rc)) throw rc;
1357	}
1358	/* If we were able to read a manifest file we can check it now. */
1359	if (pvMfBuf)
1360	{
1361	/* Add the ovf file to the digest list. */
1362	stack.llSrcDisksDigest.push_front(STRPAIR(Utf8Str(pTask->locInfo.strPath).stripExt().append(".ovf"), m->strOVFSHA1Digest));
1363	rc = verifyManifestFile(strMfFile, stack, pvMfBuf, cbMfSize);
1364	if (FAILED(rc)) throw rc;
1365	}
1366	}
1367	catch (HRESULT rc2)
1368	{
1369	rc = rc2;
1370	}
1371	writeLock.acquire();
1372
1373	RTTarClose(tar);
1374
1375	/* Cleanup */
1376	if (pvMfBuf)
1377	RTMemFree(pvMfBuf);
1378	if (pSha1Callbacks)
1379	RTMemFree(pSha1Callbacks);
1380	if (pTarCallbacks)
1381	RTMemFree(pTarCallbacks);
1382
1383	LogFlowFunc(("rc=%Rhrc\n", rc));
1384	LogFlowFuncLeave();
1385
1386	return rc;
1387	}
1388
1389	#ifdef VBOX_WITH_S3
1390	/**
1391	* Worker code for importing OVF from the cloud. This is called from Appliance::taskThreadImportOrExport()
1392	* in S3 mode and therefore runs on the OVF import worker thread. This then starts a second worker
1393	* thread to import from temporary files (see Appliance::importFS()).
1394	* @param pTask
1395	* @return
1396	*/
1397	HRESULT Appliance::importS3(TaskOVF *pTask)
1398	{
1399	LogFlowFuncEnter();
1400	LogFlowFunc(("Appliance %p\n", this));
1401
1402	AutoCaller autoCaller(this);
1403	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1404
1405	AutoWriteLock appLock(this COMMA_LOCKVAL_SRC_POS);
1406
1407	int vrc = VINF_SUCCESS;
1408	RTS3 hS3 = NIL_RTS3;
1409	char szOSTmpDir[RTPATH_MAX];
1410	RTPathTemp(szOSTmpDir, sizeof(szOSTmpDir));
1411	/* The template for the temporary directory created below */
1412	char *pszTmpDir = RTPathJoinA(szOSTmpDir, "vbox-ovf-XXXXXX");
1413	list< pair<Utf8Str, ULONG> > filesList;
1414
1415	HRESULT rc = S_OK;
1416	try
1417	{
1418	/* Extract the bucket */
1419	Utf8Str tmpPath = pTask->locInfo.strPath;
1420	Utf8Str bucket;
1421	parseBucket(tmpPath, bucket);
1422
1423	/* We need a temporary directory which we can put the all disk images
1424	* in */
1425	vrc = RTDirCreateTemp(pszTmpDir);
1426	if (RT_FAILURE(vrc))
1427	throw setError(VBOX_E_FILE_ERROR,
1428	tr("Cannot create temporary directory '%s' (%Rrc)"), pszTmpDir, vrc);
1429
1430	/* Add every disks of every virtual system to an internal list */
1431	list< ComObjPtr<VirtualSystemDescription> >::const_iterator it;
1432	for (it = m->virtualSystemDescriptions.begin();
1433	it != m->virtualSystemDescriptions.end();
1434	++it)
1435	{
1436	ComObjPtr<VirtualSystemDescription> vsdescThis = (*it);
1437	std::list<VirtualSystemDescriptionEntry*> avsdeHDs = vsdescThis->findByType(VirtualSystemDescriptionType_HardDiskImage);
1438	std::list<VirtualSystemDescriptionEntry*>::const_iterator itH;
1439	for (itH = avsdeHDs.begin();
1440	itH != avsdeHDs.end();
1441	++itH)
1442	{
1443	const Utf8Str &strTargetFile = (*itH)->strOvf;
1444	if (!strTargetFile.isEmpty())
1445	{
1446	/* The temporary name of the target disk file */
1447	Utf8StrFmt strTmpDisk("%s/%s", pszTmpDir, RTPathFilename(strTargetFile.c_str()));
1448	filesList.push_back(pair<Utf8Str, ULONG>(strTmpDisk, (*itH)->ulSizeMB));
1449	}
1450	}
1451	}
1452
1453	/* Next we have to download the disk images */
1454	vrc = RTS3Create(&hS3, pTask->locInfo.strUsername.c_str(), pTask->locInfo.strPassword.c_str(), pTask->locInfo.strHostname.c_str(), "virtualbox-agent/"VBOX_VERSION_STRING);
1455	if (RT_FAILURE(vrc))
1456	throw setError(VBOX_E_IPRT_ERROR,
1457	tr("Cannot create S3 service handler"));
1458	RTS3SetProgressCallback(hS3, pTask->updateProgress, &pTask);
1459
1460	/* Download all files */
1461	for (list< pair<Utf8Str, ULONG> >::const_iterator it1 = filesList.begin(); it1 != filesList.end(); ++it1)
1462	{
1463	const pair<Utf8Str, ULONG> &s = (*it1);
1464	const Utf8Str &strSrcFile = s.first;
1465	/* Construct the source file name */
1466	char *pszFilename = RTPathFilename(strSrcFile.c_str());
1467	/* Advance to the next operation */
1468	if (!pTask->pProgress.isNull())
1469	pTask->pProgress->SetNextOperation(BstrFmt(tr("Downloading file '%s'"), pszFilename).raw(), s.second);
1470
1471	vrc = RTS3GetKey(hS3, bucket.c_str(), pszFilename, strSrcFile.c_str());
1472	if (RT_FAILURE(vrc))
1473	{
1474	if (vrc == VERR_S3_CANCELED)
1475	throw S_OK; /* todo: !!!!!!!!!!!!! */
1476	else if (vrc == VERR_S3_ACCESS_DENIED)
1477	throw setError(E_ACCESSDENIED,
1478	tr("Cannot download file '%s' from S3 storage server (Access denied). "
1479	"Make sure that your credentials are right. Also check that your host clock is properly synced"),
1480	pszFilename);
1481	else if (vrc == VERR_S3_NOT_FOUND)
1482	throw setError(VBOX_E_FILE_ERROR,
1483	tr("Cannot download file '%s' from S3 storage server (File not found)"),
1484	pszFilename);
1485	else
1486	throw setError(VBOX_E_IPRT_ERROR,
1487	tr("Cannot download file '%s' from S3 storage server (%Rrc)"),
1488	pszFilename, vrc);
1489	}
1490	}
1491
1492	/* Provide a OVF file (haven't to exist) so the import routine can
1493	* figure out where the disk images/manifest file are located. */
1494	Utf8StrFmt strTmpOvf("%s/%s", pszTmpDir, RTPathFilename(tmpPath.c_str()));
1495	/* Now check if there is an manifest file. This is optional. */
1496	Utf8Str strManifestFile; //= queryManifestFileName(strTmpOvf);
1497	// Utf8Str strManifestFile = queryManifestFileName(strTmpOvf);
1498	char *pszFilename = RTPathFilename(strManifestFile.c_str());
1499	if (!pTask->pProgress.isNull())
1500	pTask->pProgress->SetNextOperation(BstrFmt(tr("Downloading file '%s'"), pszFilename).raw(), 1);
1501
1502	/* Try to download it. If the error is VERR_S3_NOT_FOUND, it isn't fatal. */
1503	vrc = RTS3GetKey(hS3, bucket.c_str(), pszFilename, strManifestFile.c_str());
1504	if (RT_SUCCESS(vrc))
1505	filesList.push_back(pair<Utf8Str, ULONG>(strManifestFile, 0));
1506	else if (RT_FAILURE(vrc))
1507	{
1508	if (vrc == VERR_S3_CANCELED)
1509	throw S_OK; /* todo: !!!!!!!!!!!!! */
1510	else if (vrc == VERR_S3_NOT_FOUND)
1511	vrc = VINF_SUCCESS; /* Not found is ok */
1512	else if (vrc == VERR_S3_ACCESS_DENIED)
1513	throw setError(E_ACCESSDENIED,
1514	tr("Cannot download file '%s' from S3 storage server (Access denied)."
1515	"Make sure that your credentials are right. Also check that your host clock is properly synced"),
1516	pszFilename);
1517	else
1518	throw setError(VBOX_E_IPRT_ERROR,
1519	tr("Cannot download file '%s' from S3 storage server (%Rrc)"),
1520	pszFilename, vrc);
1521	}
1522
1523	/* Close the connection early */
1524	RTS3Destroy(hS3);
1525	hS3 = NIL_RTS3;
1526
1527	pTask->pProgress->SetNextOperation(BstrFmt(tr("Importing appliance")).raw(), m->ulWeightForXmlOperation);
1528
1529	ComObjPtr<Progress> progress;
1530	/* Import the whole temporary OVF & the disk images */
1531	LocationInfo li;
1532	li.strPath = strTmpOvf;
1533	rc = importImpl(li, progress);
1534	if (FAILED(rc)) throw rc;
1535
1536	/* Unlock the appliance for the fs import thread */
1537	appLock.release();
1538	/* Wait until the import is done, but report the progress back to the
1539	caller */
1540	ComPtr<IProgress> progressInt(progress);
1541	waitForAsyncProgress(pTask->pProgress, progressInt); /* Any errors will be thrown */
1542
1543	/* Again lock the appliance for the next steps */
1544	appLock.acquire();
1545	}
1546	catch(HRESULT aRC)
1547	{
1548	rc = aRC;
1549	}
1550	/* Cleanup */
1551	RTS3Destroy(hS3);
1552	/* Delete all files which where temporary created */
1553	for (list< pair<Utf8Str, ULONG> >::const_iterator it1 = filesList.begin(); it1 != filesList.end(); ++it1)
1554	{
1555	const char pszFilePath = (it1).first.c_str();
1556	if (RTPathExists(pszFilePath))
1557	{
1558	vrc = RTFileDelete(pszFilePath);
1559	if (RT_FAILURE(vrc))
1560	rc = setError(VBOX_E_FILE_ERROR,
1561	tr("Cannot delete file '%s' (%Rrc)"), pszFilePath, vrc);
1562	}
1563	}
1564	/* Delete the temporary directory */
1565	if (RTPathExists(pszTmpDir))
1566	{
1567	vrc = RTDirRemove(pszTmpDir);
1568	if (RT_FAILURE(vrc))
1569	rc = setError(VBOX_E_FILE_ERROR,
1570	tr("Cannot delete temporary directory '%s' (%Rrc)"), pszTmpDir, vrc);
1571	}
1572	if (pszTmpDir)
1573	RTStrFree(pszTmpDir);
1574
1575	LogFlowFunc(("rc=%Rhrc\n", rc));
1576	LogFlowFuncLeave();
1577
1578	return rc;
1579	}
1580	#endif /* VBOX_WITH_S3 */
1581
1582	HRESULT Appliance::readManifestFile(const Utf8Str &strFile, void *ppvBuf, size_t pcbSize, PVDINTERFACEIO pCallbacks, PSHA1STORAGE pStorage)
1583	{
1584	HRESULT rc = S_OK;
1585
1586	bool fOldDigest = pStorage->fCreateDigest;
1587	pStorage->fCreateDigest = false; /* No digest for the manifest file */
1588	int vrc = Sha1ReadBuf(strFile.c_str(), ppvBuf, pcbSize, pCallbacks, pStorage);
1589	if ( RT_FAILURE(vrc)
1590	&& vrc != VERR_FILE_NOT_FOUND)
1591	rc = setError(VBOX_E_FILE_ERROR,
1592	tr("Could not read manifest file '%s' (%Rrc)"),
1593	RTPathFilename(strFile.c_str()), vrc);
1594	pStorage->fCreateDigest = fOldDigest; /* Restore the old digest creation behavior again. */
1595
1596	return rc;
1597	}
1598
1599	HRESULT Appliance::readTarManifestFile(RTTAR tar, const Utf8Str &strFile, void *ppvBuf, size_t pcbSize, PVDINTERFACEIO pCallbacks, PSHA1STORAGE pStorage)
1600	{
1601	HRESULT rc = S_OK;
1602
1603	char *pszCurFile;
1604	int vrc = RTTarCurrentFile(tar, &pszCurFile);
1605	if (RT_SUCCESS(vrc))
1606	{
1607	if (!strcmp(pszCurFile, RTPathFilename(strFile.c_str())))
1608	rc = readManifestFile(strFile, ppvBuf, pcbSize, pCallbacks, pStorage);
1609	RTStrFree(pszCurFile);
1610	}
1611	else if (vrc != VERR_TAR_END_OF_FILE)
1612	rc = E_FAIL;
1613
1614	return rc;
1615	}
1616
1617	HRESULT Appliance::verifyManifestFile(const Utf8Str &strFile, ImportStack &stack, void *pvBuf, size_t cbSize)
1618	{
1619	HRESULT rc = S_OK;
1620
1621	PRTMANIFESTTEST paTests = (PRTMANIFESTTEST)RTMemAlloc(sizeof(RTMANIFESTTEST) * stack.llSrcDisksDigest.size());
1622	if (!paTests)
1623	return E_OUTOFMEMORY;
1624
1625	size_t i = 0;
1626	list<STRPAIR>::const_iterator it1;
1627	for (it1 = stack.llSrcDisksDigest.begin();
1628	it1 != stack.llSrcDisksDigest.end();
1629	++it1, ++i)
1630	{
1631	paTests[i].pszTestFile = (*it1).first.c_str();
1632	paTests[i].pszTestDigest = (*it1).second.c_str();
1633	}
1634	size_t iFailed;
1635	int vrc = RTManifestVerifyFilesBuf(pvBuf, cbSize, paTests, stack.llSrcDisksDigest.size(), &iFailed);
1636	if (RT_UNLIKELY(vrc == VERR_MANIFEST_DIGEST_MISMATCH))
1637	rc = setError(VBOX_E_FILE_ERROR,
1638	tr("The SHA1 digest of '%s' does not match the one in '%s' (%Rrc)"),
1639	RTPathFilename(paTests[iFailed].pszTestFile), RTPathFilename(strFile.c_str()), vrc);
1640	else if (RT_FAILURE(vrc))
1641	rc = setError(VBOX_E_FILE_ERROR,
1642	tr("Could not verify the content of '%s' against the available files (%Rrc)"),
1643	RTPathFilename(strFile.c_str()), vrc);
1644
1645	RTMemFree(paTests);
1646
1647	return rc;
1648	}
1649
1650
1651	/**
1652	* Helper that converts VirtualSystem attachment values into VirtualBox attachment values.
1653	* Throws HRESULT values on errors!
1654	*
1655	* @param hdc in: the HardDiskController structure to attach to.
1656	* @param ulAddressOnParent in: the AddressOnParent parameter from OVF.
1657	* @param controllerType out: the name of the hard disk controller to attach to (e.g. "IDE Controller").
1658	* @param lControllerPort out: the channel (controller port) of the controller to attach to.
1659	* @param lDevice out: the device number to attach to.
1660	*/
1661	void Appliance::convertDiskAttachmentValues(const ovf::HardDiskController &hdc,
1662	uint32_t ulAddressOnParent,
1663	Bstr &controllerType,
1664	int32_t &lControllerPort,
1665	int32_t &lDevice)
1666	{
1667	Log(("Appliance::convertDiskAttachmentValues: hdc.system=%d, hdc.fPrimary=%d, ulAddressOnParent=%d\n", hdc.system, hdc.fPrimary, ulAddressOnParent));
1668
1669	switch (hdc.system)
1670	{
1671	case ovf::HardDiskController::IDE:
1672	// For the IDE bus, the port parameter can be either 0 or 1, to specify the primary
1673	// or secondary IDE controller, respectively. For the primary controller of the IDE bus,
1674	// the device number can be either 0 or 1, to specify the master or the slave device,
1675	// respectively. For the secondary IDE controller, the device number is always 1 because
1676	// the master device is reserved for the CD-ROM drive.
1677	controllerType = Bstr("IDE Controller");
1678	switch (ulAddressOnParent)
1679	{
1680	case 0: // master
1681	if (!hdc.fPrimary)
1682	{
1683	// secondary master
1684	lControllerPort = (long)1;
1685	lDevice = (long)0;
1686	}
1687	else // primary master
1688	{
1689	lControllerPort = (long)0;
1690	lDevice = (long)0;
1691	}
1692	break;
1693
1694	case 1: // slave
1695	if (!hdc.fPrimary)
1696	{
1697	// secondary slave
1698	lControllerPort = (long)1;
1699	lDevice = (long)1;
1700	}
1701	else // primary slave
1702	{
1703	lControllerPort = (long)0;
1704	lDevice = (long)1;
1705	}
1706	break;
1707
1708	// used by older VBox exports
1709	case 2: // interpret this as secondary master
1710	lControllerPort = (long)1;
1711	lDevice = (long)0;
1712	break;
1713
1714	// used by older VBox exports
1715	case 3: // interpret this as secondary slave
1716	lControllerPort = (long)1;
1717	lDevice = (long)1;
1718	break;
1719
1720	default:
1721	throw setError(VBOX_E_NOT_SUPPORTED,
1722	tr("Invalid channel %RI16 specified; IDE controllers support only 0, 1 or 2"),
1723	ulAddressOnParent);
1724	break;
1725	}
1726	break;
1727
1728	case ovf::HardDiskController::SATA:
1729	controllerType = Bstr("SATA Controller");
1730	lControllerPort = (long)ulAddressOnParent;
1731	lDevice = (long)0;
1732	break;
1733
1734	case ovf::HardDiskController::SCSI:
1735	controllerType = Bstr("SCSI Controller");
1736	lControllerPort = (long)ulAddressOnParent;
1737	lDevice = (long)0;
1738	break;
1739
1740	default: break;
1741	}
1742
1743	Log(("=> lControllerPort=%d, lDevice=%d\n", lControllerPort, lDevice));
1744	}
1745
1746	/**
1747	* Imports one disk image. This is common code shared between
1748	* -- importMachineGeneric() for the OVF case; in that case the information comes from
1749	* the OVF virtual systems;
1750	* -- importVBoxMachine(); in that case, the information comes from the <vbox:Machine>
1751	* tag.
1752	*
1753	* Both ways of describing machines use the OVF disk references section, so in both cases
1754	* the caller needs to pass in the ovf::DiskImage structure from ovfreader.cpp.
1755	*
1756	* As a result, in both cases, if di.strHref is empty, we create a new disk as per the OVF
1757	* spec, even though this cannot really happen in the vbox:Machine case since such data
1758	* would never have been exported.
1759	*
1760	* This advances stack.pProgress by one operation with the disk's weight.
1761	*
1762	* @param di ovfreader.cpp structure describing the disk image from the OVF that is to be imported
1763	* @param ulSizeMB Size of the disk image (for progress reporting)
1764	* @param strTargetPath Where to create the target image.
1765	* @param pTargetHD out: The newly created target disk. This also gets pushed on stack.llHardDisksCreated for cleanup.
1766	* @param stack
1767	*/
1768	void Appliance::importOneDiskImage(const ovf::DiskImage &di,
1769	const Utf8Str &strTargetPath,
1770	ComObjPtr<Medium> &pTargetHD,
1771	ImportStack &stack,
1772	PVDINTERFACEIO pCallbacks,
1773	PSHA1STORAGE pStorage)
1774	{
1775	ComObjPtr<Progress> pProgress;
1776	pProgress.createObject();
1777	HRESULT rc = pProgress->init(mVirtualBox, static_cast<IAppliance*>(this), BstrFmt(tr("Creating medium '%s'"), strTargetPath.c_str()).raw(), TRUE);
1778	if (FAILED(rc)) throw rc;
1779
1780	/* Get the system properties. */
1781	SystemProperties *pSysProps = mVirtualBox->getSystemProperties();
1782
1783	/* First of all check if the path is an UUID. If so, the user like to
1784	* import the disk into an existing path. This is useful for iSCSI for
1785	* example. */
1786	RTUUID uuid;
1787	int vrc = RTUuidFromStr(&uuid, strTargetPath.c_str());
1788	if (vrc == VINF_SUCCESS)
1789	{
1790	rc = mVirtualBox->findHardDiskById(Guid(uuid), true, &pTargetHD);
1791	if (FAILED(rc)) throw rc;
1792	}
1793	else
1794	{
1795	Utf8Str strTrgFormat = "VMDK";
1796	if (RTPathHaveExt(strTargetPath.c_str()))
1797	{
1798	char *pszExt = RTPathExt(strTargetPath.c_str());
1799	/* Figure out which format the user like to have. Default is VMDK. */
1800	ComObjPtr<MediumFormat> trgFormat = pSysProps->mediumFormatFromExtension(&pszExt[1]);
1801	if (trgFormat.isNull())
1802	throw setError(VBOX_E_NOT_SUPPORTED,
1803	tr("Could not find a valid medium format for the target disk '%s'"),
1804	strTargetPath.c_str());
1805	/* Check the capabilities. We need create capabilities. */
1806	ULONG lCabs = 0;
1807	rc = trgFormat->COMGETTER(Capabilities)(&lCabs);
1808	if (FAILED(rc)) throw rc;
1809	if (!( ((lCabs & MediumFormatCapabilities_CreateFixed) == MediumFormatCapabilities_CreateFixed)
1810	\|\| ((lCabs & MediumFormatCapabilities_CreateDynamic) == MediumFormatCapabilities_CreateDynamic)))
1811	throw setError(VBOX_E_NOT_SUPPORTED,
1812	tr("Could not find a valid medium format for the target disk '%s'"),
1813	strTargetPath.c_str());
1814	Bstr bstrFormatName;
1815	rc = trgFormat->COMGETTER(Name)(bstrFormatName.asOutParam());
1816	if (FAILED(rc)) throw rc;
1817	strTrgFormat = Utf8Str(bstrFormatName);
1818	}
1819
1820	/* Create an IMedium object. */
1821	pTargetHD.createObject();
1822	rc = pTargetHD->init(mVirtualBox,
1823	strTrgFormat,
1824	strTargetPath,
1825	Guid::Empty, // media registry: none yet
1826	NULL /* llRegistriesThatNeedSaving */);
1827	if (FAILED(rc)) throw rc;
1828
1829	/* Now create an empty hard disk. */
1830	rc = mVirtualBox->CreateHardDisk(NULL,
1831	Bstr(strTargetPath).raw(),
1832	ComPtr<IMedium>(pTargetHD).asOutParam());
1833	if (FAILED(rc)) throw rc;
1834	}
1835
1836	const Utf8Str &strSourceOVF = di.strHref;
1837	/* Construct source file path */
1838	Utf8StrFmt strSrcFilePath("%s%c%s", stack.strSourceDir.c_str(), RTPATH_DELIMITER, strSourceOVF.c_str());
1839
1840	/* If strHref is empty we have to create a new file. */
1841	if (strSourceOVF.isEmpty())
1842	{
1843	/* Create a dynamic growing disk image with the given capacity. */
1844	rc = pTargetHD->CreateBaseStorage(di.iCapacity / _1M, MediumVariant_Standard, ComPtr<IProgress>(pProgress).asOutParam());
1845	if (FAILED(rc)) throw rc;
1846
1847	/* Advance to the next operation. */
1848	stack.pProgress->SetNextOperation(BstrFmt(tr("Creating disk image '%s'"), strTargetPath.c_str()).raw(),
1849	di.ulSuggestedSizeMB); // operation's weight, as set up with the IProgress originally
1850	}
1851	else
1852	{
1853	/* We need a proper source format description */
1854	ComObjPtr<MediumFormat> srcFormat;
1855	/* Which format to use? */
1856	Utf8Str strSrcFormat = "VDI";
1857	if ( di.strFormat.compare("http://www.vmware.com/specifications/vmdk.html#sparse", Utf8Str::CaseInsensitive)
1858	\|\| di.strFormat.compare("http://www.vmware.com/interfaces/specifications/vmdk.html#streamOptimized", Utf8Str::CaseInsensitive)
1859	\|\| di.strFormat.compare("http://www.vmware.com/specifications/vmdk.html#compressed", Utf8Str::CaseInsensitive)
1860	\|\| di.strFormat.compare("http://www.vmware.com/interfaces/specifications/vmdk.html#compressed", Utf8Str::CaseInsensitive)
1861	)
1862	strSrcFormat = "VMDK";
1863	srcFormat = pSysProps->mediumFormat(strSrcFormat);
1864	if (srcFormat.isNull())
1865	throw setError(VBOX_E_NOT_SUPPORTED,
1866	tr("Could not find a valid medium format for the source disk '%s'"),
1867	RTPathFilename(strSrcFilePath.c_str()));
1868
1869	/* Clone the source disk image */
1870	ComObjPtr<Medium> nullParent;
1871	rc = pTargetHD->importFile(strSrcFilePath.c_str(),
1872	srcFormat,
1873	MediumVariant_Standard,
1874	pCallbacks, pStorage,
1875	nullParent,
1876	pProgress);
1877	if (FAILED(rc)) throw rc;
1878
1879	/* Advance to the next operation. */
1880	stack.pProgress->SetNextOperation(BstrFmt(tr("Importing virtual disk image '%s'"), RTPathFilename(strSrcFilePath.c_str())).raw(),
1881	di.ulSuggestedSizeMB); // operation's weight, as set up with the IProgress originally);
1882	}
1883
1884	/* Now wait for the background disk operation to complete; this throws
1885	* HRESULTs on error. */
1886	ComPtr<IProgress> pp(pProgress);
1887	waitForAsyncProgress(stack.pProgress, pp);
1888
1889	/* Add the newly create disk path + a corresponding digest the our list for
1890	* later manifest verification. */
1891	stack.llSrcDisksDigest.push_back(STRPAIR(strSrcFilePath, pStorage->strDigest));
1892	}
1893
1894	/**
1895	* Imports one OVF virtual system (described by the given ovf::VirtualSystem and VirtualSystemDescription)
1896	* into VirtualBox by creating an IMachine instance, which is returned.
1897	*
1898	* This throws HRESULT error codes for anything that goes wrong, in which case the caller must clean
1899	* up any leftovers from this function. For this, the given ImportStack instance has received information
1900	* about what needs cleaning up (to support rollback).
1901	*
1902	* @param vsysThis OVF virtual system (machine) to import.
1903	* @param vsdescThis Matching virtual system description (machine) to import.
1904	* @param pNewMachine out: Newly created machine.
1905	* @param stack Cleanup stack for when this throws.
1906	*/
1907	void Appliance::importMachineGeneric(const ovf::VirtualSystem &vsysThis,
1908	ComObjPtr<VirtualSystemDescription> &vsdescThis,
1909	ComPtr<IMachine> &pNewMachine,
1910	ImportStack &stack,
1911	PVDINTERFACEIO pCallbacks,
1912	PSHA1STORAGE pStorage)
1913	{
1914	HRESULT rc;
1915
1916	// Get the instance of IGuestOSType which matches our string guest OS type so we
1917	// can use recommended defaults for the new machine where OVF doesn't provide any
1918	ComPtr<IGuestOSType> osType;
1919	rc = mVirtualBox->GetGuestOSType(Bstr(stack.strOsTypeVBox).raw(), osType.asOutParam());
1920	if (FAILED(rc)) throw rc;
1921
1922	/* Create the machine */
1923	rc = mVirtualBox->CreateMachine(NULL, /* machine name: use default */
1924	Bstr(stack.strNameVBox).raw(),
1925	Bstr(stack.strOsTypeVBox).raw(),
1926	NULL, /* uuid */
1927	FALSE, /* fForceOverwrite */
1928	pNewMachine.asOutParam());
1929	if (FAILED(rc)) throw rc;
1930
1931	// set the description
1932	if (!stack.strDescription.isEmpty())
1933	{
1934	rc = pNewMachine->COMSETTER(Description)(Bstr(stack.strDescription).raw());
1935	if (FAILED(rc)) throw rc;
1936	}
1937
1938	// CPU count
1939	rc = pNewMachine->COMSETTER(CPUCount)(stack.cCPUs);
1940	if (FAILED(rc)) throw rc;
1941
1942	if (stack.fForceHWVirt)
1943	{
1944	rc = pNewMachine->SetHWVirtExProperty(HWVirtExPropertyType_Enabled, TRUE);
1945	if (FAILED(rc)) throw rc;
1946	}
1947
1948	// RAM
1949	rc = pNewMachine->COMSETTER(MemorySize)(stack.ulMemorySizeMB);
1950	if (FAILED(rc)) throw rc;
1951
1952	/* VRAM */
1953	/* Get the recommended VRAM for this guest OS type */
1954	ULONG vramVBox;
1955	rc = osType->COMGETTER(RecommendedVRAM)(&vramVBox);
1956	if (FAILED(rc)) throw rc;
1957
1958	/* Set the VRAM */
1959	rc = pNewMachine->COMSETTER(VRAMSize)(vramVBox);
1960	if (FAILED(rc)) throw rc;
1961
1962	// I/O APIC: Generic OVF has no setting for this. Enable it if we
1963	// import a Windows VM because if if Windows was installed without IOAPIC,
1964	// it will not mind finding an one later on, but if Windows was installed
1965	// _with_ an IOAPIC, it will bluescreen if it's not found
1966	if (!stack.fForceIOAPIC)
1967	{
1968	Bstr bstrFamilyId;
1969	rc = osType->COMGETTER(FamilyId)(bstrFamilyId.asOutParam());
1970	if (FAILED(rc)) throw rc;
1971	if (bstrFamilyId == "Windows")
1972	stack.fForceIOAPIC = true;
1973	}
1974
1975	if (stack.fForceIOAPIC)
1976	{
1977	ComPtr<IBIOSSettings> pBIOSSettings;
1978	rc = pNewMachine->COMGETTER(BIOSSettings)(pBIOSSettings.asOutParam());
1979	if (FAILED(rc)) throw rc;
1980
1981	rc = pBIOSSettings->COMSETTER(IOAPICEnabled)(TRUE);
1982	if (FAILED(rc)) throw rc;
1983	}
1984
1985	if (!stack.strAudioAdapter.isEmpty())
1986	if (stack.strAudioAdapter.compare("null", Utf8Str::CaseInsensitive) != 0)
1987	{
1988	uint32_t audio = RTStrToUInt32(stack.strAudioAdapter.c_str()); // should be 0 for AC97
1989	ComPtr<IAudioAdapter> audioAdapter;
1990	rc = pNewMachine->COMGETTER(AudioAdapter)(audioAdapter.asOutParam());
1991	if (FAILED(rc)) throw rc;
1992	rc = audioAdapter->COMSETTER(Enabled)(true);
1993	if (FAILED(rc)) throw rc;
1994	rc = audioAdapter->COMSETTER(AudioController)(static_cast<AudioControllerType_T>(audio));
1995	if (FAILED(rc)) throw rc;
1996	}
1997
1998	#ifdef VBOX_WITH_USB
1999	/* USB Controller */
2000	ComPtr<IUSBController> usbController;
2001	rc = pNewMachine->COMGETTER(USBController)(usbController.asOutParam());
2002	if (FAILED(rc)) throw rc;
2003	rc = usbController->COMSETTER(Enabled)(stack.fUSBEnabled);
2004	if (FAILED(rc)) throw rc;
2005	#endif /* VBOX_WITH_USB */
2006
2007	/* Change the network adapters */
2008	std::list<VirtualSystemDescriptionEntry*> vsdeNW = vsdescThis->findByType(VirtualSystemDescriptionType_NetworkAdapter);
2009	if (vsdeNW.size() == 0)
2010	{
2011	/* No network adapters, so we have to disable our default one */
2012	ComPtr<INetworkAdapter> nwVBox;
2013	rc = pNewMachine->GetNetworkAdapter(0, nwVBox.asOutParam());
2014	if (FAILED(rc)) throw rc;
2015	rc = nwVBox->COMSETTER(Enabled)(false);
2016	if (FAILED(rc)) throw rc;
2017	}
2018	else if (vsdeNW.size() > SchemaDefs::NetworkAdapterCount)
2019	throw setError(VBOX_E_FILE_ERROR,
2020	tr("Too many network adapters: OVF requests %d network adapters, but VirtualBox only supports %d"),
2021	vsdeNW.size(), SchemaDefs::NetworkAdapterCount);
2022	else
2023	{
2024	list<VirtualSystemDescriptionEntry*>::const_iterator nwIt;
2025	size_t a = 0;
2026	for (nwIt = vsdeNW.begin();
2027	nwIt != vsdeNW.end();
2028	++nwIt, ++a)
2029	{
2030	const VirtualSystemDescriptionEntry* pvsys = *nwIt;
2031
2032	const Utf8Str &nwTypeVBox = pvsys->strVboxCurrent;
2033	uint32_t tt1 = RTStrToUInt32(nwTypeVBox.c_str());
2034	ComPtr<INetworkAdapter> pNetworkAdapter;
2035	rc = pNewMachine->GetNetworkAdapter((ULONG)a, pNetworkAdapter.asOutParam());
2036	if (FAILED(rc)) throw rc;
2037	/* Enable the network card & set the adapter type */
2038	rc = pNetworkAdapter->COMSETTER(Enabled)(true);
2039	if (FAILED(rc)) throw rc;
2040	rc = pNetworkAdapter->COMSETTER(AdapterType)(static_cast<NetworkAdapterType_T>(tt1));
2041	if (FAILED(rc)) throw rc;
2042
2043	// default is NAT; change to "bridged" if extra conf says so
2044	if (pvsys->strExtraConfigCurrent.endsWith("type=Bridged", Utf8Str::CaseInsensitive))
2045	{
2046	/* Attach to the right interface */
2047	rc = pNetworkAdapter->AttachToBridgedInterface();
2048	if (FAILED(rc)) throw rc;
2049	ComPtr<IHost> host;
2050	rc = mVirtualBox->COMGETTER(Host)(host.asOutParam());
2051	if (FAILED(rc)) throw rc;
2052	com::SafeIfaceArray<IHostNetworkInterface> nwInterfaces;
2053	rc = host->COMGETTER(NetworkInterfaces)(ComSafeArrayAsOutParam(nwInterfaces));
2054	if (FAILED(rc)) throw rc;
2055	// We search for the first host network interface which
2056	// is usable for bridged networking
2057	for (size_t j = 0;
2058	j < nwInterfaces.size();
2059	++j)
2060	{
2061	HostNetworkInterfaceType_T itype;
2062	rc = nwInterfaces[j]->COMGETTER(InterfaceType)(&itype);
2063	if (FAILED(rc)) throw rc;
2064	if (itype == HostNetworkInterfaceType_Bridged)
2065	{
2066	Bstr name;
2067	rc = nwInterfaces[j]->COMGETTER(Name)(name.asOutParam());
2068	if (FAILED(rc)) throw rc;
2069	/* Set the interface name to attach to */
2070	pNetworkAdapter->COMSETTER(HostInterface)(name.raw());
2071	if (FAILED(rc)) throw rc;
2072	break;
2073	}
2074	}
2075	}
2076	/* Next test for host only interfaces */
2077	else if (pvsys->strExtraConfigCurrent.endsWith("type=HostOnly", Utf8Str::CaseInsensitive))
2078	{
2079	/* Attach to the right interface */
2080	rc = pNetworkAdapter->AttachToHostOnlyInterface();
2081	if (FAILED(rc)) throw rc;
2082	ComPtr<IHost> host;
2083	rc = mVirtualBox->COMGETTER(Host)(host.asOutParam());
2084	if (FAILED(rc)) throw rc;
2085	com::SafeIfaceArray<IHostNetworkInterface> nwInterfaces;
2086	rc = host->COMGETTER(NetworkInterfaces)(ComSafeArrayAsOutParam(nwInterfaces));
2087	if (FAILED(rc)) throw rc;
2088	// We search for the first host network interface which
2089	// is usable for host only networking
2090	for (size_t j = 0;
2091	j < nwInterfaces.size();
2092	++j)
2093	{
2094	HostNetworkInterfaceType_T itype;
2095	rc = nwInterfaces[j]->COMGETTER(InterfaceType)(&itype);
2096	if (FAILED(rc)) throw rc;
2097	if (itype == HostNetworkInterfaceType_HostOnly)
2098	{
2099	Bstr name;
2100	rc = nwInterfaces[j]->COMGETTER(Name)(name.asOutParam());
2101	if (FAILED(rc)) throw rc;
2102	/* Set the interface name to attach to */
2103	pNetworkAdapter->COMSETTER(HostInterface)(name.raw());
2104	if (FAILED(rc)) throw rc;
2105	break;
2106	}
2107	}
2108	}
2109	/* Next test for internal interfaces */
2110	else if (pvsys->strExtraConfigCurrent.endsWith("type=Internal", Utf8Str::CaseInsensitive))
2111	{
2112	/* Attach to the right interface */
2113	rc = pNetworkAdapter->AttachToInternalNetwork();
2114	if (FAILED(rc)) throw rc;
2115	}
2116	/* Next test for VDE interfaces */
2117	else if (pvsys->strExtraConfigCurrent.endsWith("type=VDE", Utf8Str::CaseInsensitive))
2118	{
2119	/* Attach to the right interface */
2120	rc = pNetworkAdapter->AttachToVDE();
2121	if (FAILED(rc)) throw rc;
2122	}
2123	}
2124	}
2125
2126	// IDE Hard disk controller
2127	std::list<VirtualSystemDescriptionEntry*> vsdeHDCIDE = vsdescThis->findByType(VirtualSystemDescriptionType_HardDiskControllerIDE);
2128	// In OVF (at least VMware's version of it), an IDE controller has two ports, so VirtualBox's single IDE controller
2129	// with two channels and two ports each counts as two OVF IDE controllers -- so we accept one or two such IDE controllers
2130	size_t cIDEControllers = vsdeHDCIDE.size();
2131	if (cIDEControllers > 2)
2132	throw setError(VBOX_E_FILE_ERROR,
2133	tr("Too many IDE controllers in OVF; import facility only supports two"));
2134	if (vsdeHDCIDE.size() > 0)
2135	{
2136	// one or two IDE controllers present in OVF: add one VirtualBox controller
2137	ComPtr<IStorageController> pController;
2138	rc = pNewMachine->AddStorageController(Bstr("IDE Controller").raw(), StorageBus_IDE, pController.asOutParam());
2139	if (FAILED(rc)) throw rc;
2140
2141	const char *pcszIDEType = vsdeHDCIDE.front()->strVboxCurrent.c_str();
2142	if (!strcmp(pcszIDEType, "PIIX3"))
2143	rc = pController->COMSETTER(ControllerType)(StorageControllerType_PIIX3);
2144	else if (!strcmp(pcszIDEType, "PIIX4"))
2145	rc = pController->COMSETTER(ControllerType)(StorageControllerType_PIIX4);
2146	else if (!strcmp(pcszIDEType, "ICH6"))
2147	rc = pController->COMSETTER(ControllerType)(StorageControllerType_ICH6);
2148	else
2149	throw setError(VBOX_E_FILE_ERROR,
2150	tr("Invalid IDE controller type \"%s\""),
2151	pcszIDEType);
2152	if (FAILED(rc)) throw rc;
2153	}
2154
2155	/* Hard disk controller SATA */
2156	std::list<VirtualSystemDescriptionEntry*> vsdeHDCSATA = vsdescThis->findByType(VirtualSystemDescriptionType_HardDiskControllerSATA);
2157	if (vsdeHDCSATA.size() > 1)
2158	throw setError(VBOX_E_FILE_ERROR,
2159	tr("Too many SATA controllers in OVF; import facility only supports one"));
2160	if (vsdeHDCSATA.size() > 0)
2161	{
2162	ComPtr<IStorageController> pController;
2163	const Utf8Str &hdcVBox = vsdeHDCSATA.front()->strVboxCurrent;
2164	if (hdcVBox == "AHCI")
2165	{
2166	rc = pNewMachine->AddStorageController(Bstr("SATA Controller").raw(), StorageBus_SATA, pController.asOutParam());
2167	if (FAILED(rc)) throw rc;
2168	}
2169	else
2170	throw setError(VBOX_E_FILE_ERROR,
2171	tr("Invalid SATA controller type \"%s\""),
2172	hdcVBox.c_str());
2173	}
2174
2175	/* Hard disk controller SCSI */
2176	std::list<VirtualSystemDescriptionEntry*> vsdeHDCSCSI = vsdescThis->findByType(VirtualSystemDescriptionType_HardDiskControllerSCSI);
2177	if (vsdeHDCSCSI.size() > 1)
2178	throw setError(VBOX_E_FILE_ERROR,
2179	tr("Too many SCSI controllers in OVF; import facility only supports one"));
2180	if (vsdeHDCSCSI.size() > 0)
2181	{
2182	ComPtr<IStorageController> pController;
2183	Bstr bstrName(L"SCSI Controller");
2184	StorageBus_T busType = StorageBus_SCSI;
2185	StorageControllerType_T controllerType;
2186	const Utf8Str &hdcVBox = vsdeHDCSCSI.front()->strVboxCurrent;
2187	if (hdcVBox == "LsiLogic")
2188	controllerType = StorageControllerType_LsiLogic;
2189	else if (hdcVBox == "LsiLogicSas")
2190	{
2191	// OVF treats LsiLogicSas as a SCSI controller but VBox considers it a class of its own
2192	bstrName = L"SAS Controller";
2193	busType = StorageBus_SAS;
2194	controllerType = StorageControllerType_LsiLogicSas;
2195	}
2196	else if (hdcVBox == "BusLogic")
2197	controllerType = StorageControllerType_BusLogic;
2198	else
2199	throw setError(VBOX_E_FILE_ERROR,
2200	tr("Invalid SCSI controller type \"%s\""),
2201	hdcVBox.c_str());
2202
2203	rc = pNewMachine->AddStorageController(bstrName.raw(), busType, pController.asOutParam());
2204	if (FAILED(rc)) throw rc;
2205	rc = pController->COMSETTER(ControllerType)(controllerType);
2206	if (FAILED(rc)) throw rc;
2207	}
2208
2209	/* Hard disk controller SAS */
2210	std::list<VirtualSystemDescriptionEntry*> vsdeHDCSAS = vsdescThis->findByType(VirtualSystemDescriptionType_HardDiskControllerSAS);
2211	if (vsdeHDCSAS.size() > 1)
2212	throw setError(VBOX_E_FILE_ERROR,
2213	tr("Too many SAS controllers in OVF; import facility only supports one"));
2214	if (vsdeHDCSAS.size() > 0)
2215	{
2216	ComPtr<IStorageController> pController;
2217	rc = pNewMachine->AddStorageController(Bstr(L"SAS Controller").raw(), StorageBus_SAS, pController.asOutParam());
2218	if (FAILED(rc)) throw rc;
2219	rc = pController->COMSETTER(ControllerType)(StorageControllerType_LsiLogicSas);
2220	if (FAILED(rc)) throw rc;
2221	}
2222
2223	/* Now its time to register the machine before we add any hard disks */
2224	rc = mVirtualBox->RegisterMachine(pNewMachine);
2225	if (FAILED(rc)) throw rc;
2226
2227	// store new machine for roll-back in case of errors
2228	Bstr bstrNewMachineId;
2229	rc = pNewMachine->COMGETTER(Id)(bstrNewMachineId.asOutParam());
2230	if (FAILED(rc)) throw rc;
2231	Guid uuidNewMachine(bstrNewMachineId);
2232	m->llGuidsMachinesCreated.push_back(uuidNewMachine);
2233
2234	// Add floppies and CD-ROMs to the appropriate controllers.
2235	std::list<VirtualSystemDescriptionEntry*> vsdeFloppy = vsdescThis->findByType(VirtualSystemDescriptionType_Floppy);
2236	if (vsdeFloppy.size() > 1)
2237	throw setError(VBOX_E_FILE_ERROR,
2238	tr("Too many floppy controllers in OVF; import facility only supports one"));
2239	std::list<VirtualSystemDescriptionEntry*> vsdeCDROM = vsdescThis->findByType(VirtualSystemDescriptionType_CDROM);
2240	if ( (vsdeFloppy.size() > 0)
2241	\|\| (vsdeCDROM.size() > 0)
2242	)
2243	{
2244	// If there's an error here we need to close the session, so
2245	// we need another try/catch block.
2246
2247	try
2248	{
2249	// to attach things we need to open a session for the new machine
2250	rc = pNewMachine->LockMachine(stack.pSession, LockType_Write);
2251	if (FAILED(rc)) throw rc;
2252	stack.fSessionOpen = true;
2253
2254	ComPtr<IMachine> sMachine;
2255	rc = stack.pSession->COMGETTER(Machine)(sMachine.asOutParam());
2256	if (FAILED(rc)) throw rc;
2257
2258	// floppy first
2259	if (vsdeFloppy.size() == 1)
2260	{
2261	ComPtr<IStorageController> pController;
2262	rc = sMachine->AddStorageController(Bstr("Floppy Controller").raw(), StorageBus_Floppy, pController.asOutParam());
2263	if (FAILED(rc)) throw rc;
2264
2265	Bstr bstrName;
2266	rc = pController->COMGETTER(Name)(bstrName.asOutParam());
2267	if (FAILED(rc)) throw rc;
2268
2269	// this is for rollback later
2270	MyHardDiskAttachment mhda;
2271	mhda.pMachine = pNewMachine;
2272	mhda.controllerType = bstrName;
2273	mhda.lControllerPort = 0;
2274	mhda.lDevice = 0;
2275
2276	Log(("Attaching floppy\n"));
2277
2278	rc = sMachine->AttachDevice(mhda.controllerType.raw(),
2279	mhda.lControllerPort,
2280	mhda.lDevice,
2281	DeviceType_Floppy,
2282	NULL);
2283	if (FAILED(rc)) throw rc;
2284
2285	stack.llHardDiskAttachments.push_back(mhda);
2286	}
2287
2288	// CD-ROMs next
2289	for (std::list<VirtualSystemDescriptionEntry*>::const_iterator jt = vsdeCDROM.begin();
2290	jt != vsdeCDROM.end();
2291	++jt)
2292	{
2293	// for now always attach to secondary master on IDE controller;
2294	// there seems to be no useful information in OVF where else to
2295	// attach it (@todo test with latest versions of OVF software)
2296
2297	// find the IDE controller
2298	const ovf::HardDiskController *pController = NULL;
2299	for (ovf::ControllersMap::const_iterator kt = vsysThis.mapControllers.begin();
2300	kt != vsysThis.mapControllers.end();
2301	++kt)
2302	{
2303	if (kt->second.system == ovf::HardDiskController::IDE)
2304	{
2305	pController = &kt->second;
2306	break;
2307	}
2308	}
2309
2310	if (!pController)
2311	throw setError(VBOX_E_FILE_ERROR,
2312	tr("OVF wants a CD-ROM drive but cannot find IDE controller, which is required in this version of VirtualBox"));
2313
2314	// this is for rollback later
2315	MyHardDiskAttachment mhda;
2316	mhda.pMachine = pNewMachine;
2317
2318	convertDiskAttachmentValues(*pController,
2319	2, // interpreted as secondary master
2320	mhda.controllerType, // Bstr
2321	mhda.lControllerPort,
2322	mhda.lDevice);
2323
2324	Log(("Attaching CD-ROM to port %d on device %d\n", mhda.lControllerPort, mhda.lDevice));
2325
2326	rc = sMachine->AttachDevice(mhda.controllerType.raw(),
2327	mhda.lControllerPort,
2328	mhda.lDevice,
2329	DeviceType_DVD,
2330	NULL);
2331	if (FAILED(rc)) throw rc;
2332
2333	stack.llHardDiskAttachments.push_back(mhda);
2334	} // end for (itHD = avsdeHDs.begin();
2335
2336	rc = sMachine->SaveSettings();
2337	if (FAILED(rc)) throw rc;
2338
2339	// only now that we're done with all disks, close the session
2340	rc = stack.pSession->UnlockMachine();
2341	if (FAILED(rc)) throw rc;
2342	stack.fSessionOpen = false;
2343	}
2344	catch(HRESULT /* aRC */)
2345	{
2346	if (stack.fSessionOpen)
2347	stack.pSession->UnlockMachine();
2348
2349	throw;
2350	}
2351	}
2352
2353	// create the hard disks & connect them to the appropriate controllers
2354	std::list<VirtualSystemDescriptionEntry*> avsdeHDs = vsdescThis->findByType(VirtualSystemDescriptionType_HardDiskImage);
2355	if (avsdeHDs.size() > 0)
2356	{
2357	// If there's an error here we need to close the session, so
2358	// we need another try/catch block.
2359	try
2360	{
2361	// to attach things we need to open a session for the new machine
2362	rc = pNewMachine->LockMachine(stack.pSession, LockType_Write);
2363	if (FAILED(rc)) throw rc;
2364	stack.fSessionOpen = true;
2365
2366	/* Iterate over all given disk images */
2367	list<VirtualSystemDescriptionEntry*>::const_iterator itHD;
2368	for (itHD = avsdeHDs.begin();
2369	itHD != avsdeHDs.end();
2370	++itHD)
2371	{
2372	VirtualSystemDescriptionEntry vsdeHD = itHD;
2373
2374	// vsdeHD->strRef contains the disk identifier (e.g. "vmdisk1"), which should exist
2375	// in the virtual system's disks map under that ID and also in the global images map
2376	ovf::VirtualDisksMap::const_iterator itVirtualDisk = vsysThis.mapVirtualDisks.find(vsdeHD->strRef);
2377	// and find the disk from the OVF's disk list
2378	ovf::DiskImagesMap::const_iterator itDiskImage = stack.mapDisks.find(vsdeHD->strRef);
2379	if ( (itVirtualDisk == vsysThis.mapVirtualDisks.end())
2380	\|\| (itDiskImage == stack.mapDisks.end())
2381	)
2382	throw setError(E_FAIL,
2383	tr("Internal inconsistency looking up disk image '%s'"),
2384	vsdeHD->strRef.c_str());
2385
2386	const ovf::DiskImage &ovfDiskImage = itDiskImage->second;
2387	const ovf::VirtualDisk &ovfVdisk = itVirtualDisk->second;
2388
2389	ComObjPtr<Medium> pTargetHD;
2390	importOneDiskImage(ovfDiskImage,
2391	vsdeHD->strVboxCurrent,
2392	pTargetHD,
2393	stack,
2394	pCallbacks,
2395	pStorage);
2396
2397	// now use the new uuid to attach the disk image to our new machine
2398	ComPtr<IMachine> sMachine;
2399	rc = stack.pSession->COMGETTER(Machine)(sMachine.asOutParam());
2400	if (FAILED(rc)) throw rc;
2401
2402	// find the hard disk controller to which we should attach
2403	ovf::HardDiskController hdc = (*vsysThis.mapControllers.find(ovfVdisk.idController)).second;
2404
2405	// this is for rollback later
2406	MyHardDiskAttachment mhda;
2407	mhda.pMachine = pNewMachine;
2408
2409	convertDiskAttachmentValues(hdc,
2410	ovfVdisk.ulAddressOnParent,
2411	mhda.controllerType, // Bstr
2412	mhda.lControllerPort,
2413	mhda.lDevice);
2414
2415	Log(("Attaching disk %s to port %d on device %d\n", vsdeHD->strVboxCurrent.c_str(), mhda.lControllerPort, mhda.lDevice));
2416
2417	rc = sMachine->AttachDevice(mhda.controllerType.raw(), // wstring name
2418	mhda.lControllerPort, // long controllerPort
2419	mhda.lDevice, // long device
2420	DeviceType_HardDisk, // DeviceType_T type
2421	pTargetHD);
2422	if (FAILED(rc)) throw rc;
2423
2424	stack.llHardDiskAttachments.push_back(mhda);
2425
2426	rc = sMachine->SaveSettings();
2427	if (FAILED(rc)) throw rc;
2428	} // end for (itHD = avsdeHDs.begin();
2429
2430	// only now that we're done with all disks, close the session
2431	rc = stack.pSession->UnlockMachine();
2432	if (FAILED(rc)) throw rc;
2433	stack.fSessionOpen = false;
2434	}
2435	catch(HRESULT /* aRC */)
2436	{
2437	if (stack.fSessionOpen)
2438	stack.pSession->UnlockMachine();
2439
2440	throw;
2441	}
2442	}
2443	}
2444
2445	/**
2446	* Imports one OVF virtual system (described by a vbox:Machine tag represented by the given config
2447	* structure) into VirtualBox by creating an IMachine instance, which is returned.
2448	*
2449	* This throws HRESULT error codes for anything that goes wrong, in which case the caller must clean
2450	* up any leftovers from this function. For this, the given ImportStack instance has received information
2451	* about what needs cleaning up (to support rollback).
2452	*
2453	* The machine config stored in the settings::MachineConfigFile structure contains the UUIDs of
2454	* the disk attachments used by the machine when it was exported. We also add vbox:uuid attributes
2455	* to the OVF disks sections so we can look them up. While importing these UUIDs into a second host
2456	* will most probably work, reimporting them into the same host will cause conflicts, so we always
2457	* generate new ones on import. This involves the following:
2458	*
2459	* 1) Scan the machine config for disk attachments.
2460	*
2461	* 2) For each disk attachment found, look up the OVF disk image from the disk references section
2462	* and import the disk into VirtualBox, which creates a new UUID for it. In the machine config,
2463	* replace the old UUID with the new one.
2464	*
2465	* 3) Change the machine config according to the OVF virtual system descriptions, in case the
2466	* caller has modified them using setFinalValues().
2467	*
2468	* 4) Create the VirtualBox machine with the modfified machine config.
2469	*
2470	* @param config
2471	* @param pNewMachine
2472	* @param stack
2473	*/
2474	void Appliance::importVBoxMachine(ComObjPtr<VirtualSystemDescription> &vsdescThis,
2475	ComPtr<IMachine> &pReturnNewMachine,
2476	ImportStack &stack,
2477	PVDINTERFACEIO pCallbacks,
2478	PSHA1STORAGE pStorage)
2479	{
2480	Assert(vsdescThis->m->pConfig);
2481
2482	HRESULT rc = S_OK;
2483
2484	settings::MachineConfigFile &config = *vsdescThis->m->pConfig;
2485
2486	/*
2487	*
2488	* step 1): modify machine config according to OVF config, in case the user
2489	* has modified them using setFinalValues()
2490	*
2491	*/
2492
2493	/* OS Type */
2494	config.machineUserData.strOsType = stack.strOsTypeVBox;
2495	/* Description */
2496	config.machineUserData.strDescription = stack.strDescription;
2497	/* CPU count & extented attributes */
2498	config.hardwareMachine.cCPUs = stack.cCPUs;
2499	if (stack.fForceIOAPIC)
2500	config.hardwareMachine.fHardwareVirt = true;
2501	if (stack.fForceIOAPIC)
2502	config.hardwareMachine.biosSettings.fIOAPICEnabled = true;
2503	/* RAM size */
2504	config.hardwareMachine.ulMemorySizeMB = stack.ulMemorySizeMB;
2505
2506	/*
2507	<const name="HardDiskControllerIDE" value="14" />
2508	<const name="HardDiskControllerSATA" value="15" />
2509	<const name="HardDiskControllerSCSI" value="16" />
2510	<const name="HardDiskControllerSAS" value="17" />
2511	*/
2512
2513	#ifdef VBOX_WITH_USB
2514	/* USB controller */
2515	config.hardwareMachine.usbController.fEnabled = stack.fUSBEnabled;
2516	#endif
2517	/* Audio adapter */
2518	if (stack.strAudioAdapter.isNotEmpty())
2519	{
2520	config.hardwareMachine.audioAdapter.fEnabled = true;
2521	config.hardwareMachine.audioAdapter.controllerType = (AudioControllerType_T)stack.strAudioAdapter.toUInt32();
2522	}
2523	else
2524	config.hardwareMachine.audioAdapter.fEnabled = false;
2525	/* Network adapter */
2526	settings::NetworkAdaptersList &llNetworkAdapters = config.hardwareMachine.llNetworkAdapters;
2527	/* First disable all network cards, they will be enabled below again. */
2528	settings::NetworkAdaptersList::iterator it1;
2529	for (it1 = llNetworkAdapters.begin(); it1 != llNetworkAdapters.end(); ++it1)
2530	it1->fEnabled = false;
2531	/* Now iterate over all network entries. */
2532	std::list<VirtualSystemDescriptionEntry*> avsdeNWs = vsdescThis->findByType(VirtualSystemDescriptionType_NetworkAdapter);
2533	if (avsdeNWs.size() > 0)
2534	{
2535	/* Iterate through all network adapter entries and search for the
2536	* corrosponding one in the machine config. If one is found, configure
2537	* it based on the user settings. */
2538	list<VirtualSystemDescriptionEntry*>::const_iterator itNW;
2539	for (itNW = avsdeNWs.begin();
2540	itNW != avsdeNWs.end();
2541	++itNW)
2542	{
2543	VirtualSystemDescriptionEntry vsdeNW = itNW;
2544	if ( vsdeNW->strExtraConfigCurrent.startsWith("slot=", Utf8Str::CaseInsensitive)
2545	&& vsdeNW->strExtraConfigCurrent.length() > 6)
2546	{
2547	uint32_t iSlot = vsdeNW->strExtraConfigCurrent.substr(5, 1).toUInt32();
2548	/* Iterate through all network adapters in the machine config. */
2549	for (it1 = llNetworkAdapters.begin();
2550	it1 != llNetworkAdapters.end();
2551	++it1)
2552	{
2553	/* Compare the slots. */
2554	if (it1->ulSlot == iSlot)
2555	{
2556	it1->fEnabled = true;
2557	it1->type = (NetworkAdapterType_T)vsdeNW->strVboxCurrent.toUInt32();
2558	break;
2559	}
2560	}
2561	}
2562	}
2563	}
2564
2565	/* Floppy controller */
2566	bool fFloppy = vsdescThis->findByType(VirtualSystemDescriptionType_Floppy).size() > 0;
2567	/* DVD controller */
2568	bool fDVD = vsdescThis->findByType(VirtualSystemDescriptionType_CDROM).size() > 0;
2569	/* Iterate over all storage controller check the attachments and remove
2570	* them when necessary. Also detect broken configs with more than one
2571	* attachment. Old VirtualBox versions (prior to 3.2.10) had all disk
2572	* attachments pointing to the last hard disk image, which causes import
2573	* failures. A long fixed bug, however the OVF files are long lived. */
2574	settings::StorageControllersList &llControllers = config.storageMachine.llStorageControllers;
2575	Guid hdUuid;
2576	uint32_t cHardDisks = 0;
2577	bool fInconsistent = false;
2578	bool fRepairDuplicate = false;
2579	settings::StorageControllersList::iterator it3;
2580	for (it3 = llControllers.begin();
2581	it3 != llControllers.end();
2582	++it3)
2583	{
2584	settings::AttachedDevicesList &llAttachments = it3->llAttachedDevices;
2585	settings::AttachedDevicesList::iterator it4;
2586	for (it4 = llAttachments.begin();
2587	it4 != llAttachments.end();
2588	++it4)
2589	{
2590	if ( ( !fDVD
2591	&& it4->deviceType == DeviceType_DVD)
2592	\|\|
2593	( !fFloppy
2594	&& it4->deviceType == DeviceType_Floppy))
2595	llAttachments.erase(it4++);
2596	else if (it4->deviceType == DeviceType_HardDisk)
2597	{
2598	const Guid &thisUuid = it4->uuid;
2599	cHardDisks++;
2600	if (cHardDisks == 1)
2601	{
2602	if (hdUuid.isEmpty())
2603	hdUuid = thisUuid;
2604	else
2605	fInconsistent = true;
2606	}
2607	else
2608	{
2609	if (thisUuid.isEmpty())
2610	fInconsistent = true;
2611	else if (thisUuid == hdUuid)
2612	fRepairDuplicate = true;
2613	}
2614	}
2615	}
2616	}
2617	/* paranoia... */
2618	if (fInconsistent \|\| cHardDisks == 1)
2619	fRepairDuplicate = false;
2620
2621	/*
2622	*
2623	* step 2: scan the machine config for media attachments
2624	*
2625	*/
2626
2627	/* Get all hard disk descriptions. */
2628	std::list<VirtualSystemDescriptionEntry*> avsdeHDs = vsdescThis->findByType(VirtualSystemDescriptionType_HardDiskImage);
2629	std::list<VirtualSystemDescriptionEntry*>::iterator avsdeHDsIt = avsdeHDs.begin();
2630	/* paranoia - if there is no 1:1 match do not try to repair. */
2631	if (cHardDisks != avsdeHDs.size())
2632	fRepairDuplicate = false;
2633
2634	// for each storage controller...
2635	for (settings::StorageControllersList::iterator sit = config.storageMachine.llStorageControllers.begin();
2636	sit != config.storageMachine.llStorageControllers.end();
2637	++sit)
2638	{
2639	settings::StorageController &sc = *sit;
2640
2641	// find the OVF virtual system description entry for this storage controller
2642	switch (sc.storageBus)
2643	{
2644	case StorageBus_SATA:
2645	break;
2646	case StorageBus_SCSI:
2647	break;
2648	case StorageBus_IDE:
2649	break;
2650	case StorageBus_SAS:
2651	break;
2652	}
2653
2654	// for each medium attachment to this controller...
2655	for (settings::AttachedDevicesList::iterator dit = sc.llAttachedDevices.begin();
2656	dit != sc.llAttachedDevices.end();
2657	++dit)
2658	{
2659	settings::AttachedDevice &d = *dit;
2660
2661	if (d.uuid.isEmpty())
2662	// empty DVD and floppy media
2663	continue;
2664
2665	// When repairing a broken VirtualBox xml config section (written
2666	// by VirtualBox versions earlier than 3.2.10) assume the disks
2667	// show up in the same order as in the OVF description.
2668	if (fRepairDuplicate)
2669	{
2670	VirtualSystemDescriptionEntry vsdeHD = avsdeHDsIt;
2671	ovf::DiskImagesMap::const_iterator itDiskImage = stack.mapDisks.find(vsdeHD->strRef);
2672	if (itDiskImage != stack.mapDisks.end())
2673	{
2674	const ovf::DiskImage &di = itDiskImage->second;
2675	d.uuid = Guid(di.uuidVbox);
2676	}
2677	++avsdeHDsIt;
2678	}
2679
2680	// convert the Guid to string
2681	Utf8Str strUuid = d.uuid.toString();
2682
2683	// there must be an image in the OVF disk structs with the same UUID
2684	bool fFound = false;
2685	for (ovf::DiskImagesMap::const_iterator oit = stack.mapDisks.begin();
2686	oit != stack.mapDisks.end();
2687	++oit)
2688	{
2689	const ovf::DiskImage &di = oit->second;
2690
2691	if (di.uuidVbox == strUuid)
2692	{
2693	VirtualSystemDescriptionEntry *vsdeTargetHD = 0;
2694
2695	/* Iterate over all given disk images of the virtual system
2696	* disks description. We need to find the target disk path,
2697	* which could be changed by the user. */
2698	list<VirtualSystemDescriptionEntry*>::const_iterator itHD;
2699	for (itHD = avsdeHDs.begin();
2700	itHD != avsdeHDs.end();
2701	++itHD)
2702	{
2703	VirtualSystemDescriptionEntry vsdeHD = itHD;
2704	if (vsdeHD->strRef == oit->first)
2705	{
2706	vsdeTargetHD = vsdeHD;
2707	break;
2708	}
2709	}
2710	if (!vsdeTargetHD)
2711	throw setError(E_FAIL,
2712	tr("Internal inconsistency looking up disk image '%s'"),
2713	oit->first.c_str());
2714
2715	/*
2716	*
2717	* step 3: import disk
2718	*
2719	*/
2720	ComObjPtr<Medium> pTargetHD;
2721	importOneDiskImage(di,
2722	vsdeTargetHD->strVboxCurrent,
2723	pTargetHD,
2724	stack,
2725	pCallbacks,
2726	pStorage);
2727
2728	// ... and replace the old UUID in the machine config with the one of
2729	// the imported disk that was just created
2730	Bstr hdId;
2731	rc = pTargetHD->COMGETTER(Id)(hdId.asOutParam());
2732	if (FAILED(rc)) throw rc;
2733
2734	d.uuid = hdId;
2735
2736	fFound = true;
2737	break;
2738	}
2739	}
2740
2741	// no disk with such a UUID found:
2742	if (!fFound)
2743	throw setError(E_FAIL,
2744	tr("<vbox:Machine> element in OVF contains a medium attachment for the disk image %s but the OVF describes no such image"),
2745	strUuid.c_str());
2746	} // for (settings::AttachedDevicesList::const_iterator dit = sc.llAttachedDevices.begin();
2747	} // for (settings::StorageControllersList::const_iterator sit = config.storageMachine.llStorageControllers.begin();
2748
2749	/*
2750	*
2751	* step 4): create the machine and have it import the config
2752	*
2753	*/
2754
2755	ComObjPtr<Machine> pNewMachine;
2756	rc = pNewMachine.createObject();
2757	if (FAILED(rc)) throw rc;
2758
2759	// this magic constructor fills the new machine object with the MachineConfig
2760	// instance that we created from the vbox:Machine
2761	rc = pNewMachine->init(mVirtualBox,
2762	stack.strNameVBox, // name from OVF preparations; can be suffixed to avoid duplicates, or changed by user
2763	config); // the whole machine config
2764	if (FAILED(rc)) throw rc;
2765
2766	pReturnNewMachine = ComPtr<IMachine>(pNewMachine);
2767
2768	// and register it
2769	rc = mVirtualBox->RegisterMachine(pNewMachine);
2770	if (FAILED(rc)) throw rc;
2771
2772	// store new machine for roll-back in case of errors
2773	Bstr bstrNewMachineId;
2774	rc = pNewMachine->COMGETTER(Id)(bstrNewMachineId.asOutParam());
2775	if (FAILED(rc)) throw rc;
2776	m->llGuidsMachinesCreated.push_back(Guid(bstrNewMachineId));
2777	}
2778
2779	void Appliance::importMachines(ImportStack &stack,
2780	PVDINTERFACEIO pCallbacks,
2781	PSHA1STORAGE pStorage)
2782	{
2783	HRESULT rc = S_OK;
2784
2785	// this is safe to access because this thread only gets started
2786	// if pReader != NULL
2787	const ovf::OVFReader &reader = *m->pReader;
2788
2789	// create a session for the machine + disks we manipulate below
2790	rc = stack.pSession.createInprocObject(CLSID_Session);
2791	if (FAILED(rc)) throw rc;
2792
2793	list<ovf::VirtualSystem>::const_iterator it;
2794	list< ComObjPtr<VirtualSystemDescription> >::const_iterator it1;
2795	/* Iterate through all virtual systems of that appliance */
2796	size_t i = 0;
2797	for (it = reader.m_llVirtualSystems.begin(),
2798	it1 = m->virtualSystemDescriptions.begin();
2799	it != reader.m_llVirtualSystems.end();
2800	++it, ++it1, ++i)
2801	{
2802	const ovf::VirtualSystem &vsysThis = *it;
2803	ComObjPtr<VirtualSystemDescription> vsdescThis = (*it1);
2804
2805	ComPtr<IMachine> pNewMachine;
2806
2807	// there are two ways in which we can create a vbox machine from OVF:
2808	// -- either this OVF was written by vbox 3.2 or later, in which case there is a <vbox:Machine> element
2809	// in the <VirtualSystem>; then the VirtualSystemDescription::Data has a settings::MachineConfigFile
2810	// with all the machine config pretty-parsed;
2811	// -- or this is an OVF from an older vbox or an external source, and then we need to translate the
2812	// VirtualSystemDescriptionEntry and do import work
2813
2814	// Even for the vbox:Machine case, there are a number of configuration items that will be taken from
2815	// the OVF because otherwise the "override import parameters" mechanism in the GUI won't work.
2816
2817	// VM name
2818	std::list<VirtualSystemDescriptionEntry*> vsdeName = vsdescThis->findByType(VirtualSystemDescriptionType_Name);
2819	if (vsdeName.size() < 1)
2820	throw setError(VBOX_E_FILE_ERROR,
2821	tr("Missing VM name"));
2822	stack.strNameVBox = vsdeName.front()->strVboxCurrent;
2823
2824	// have VirtualBox suggest where the filename would be placed so we can
2825	// put the disk images in the same directory
2826	Bstr bstrMachineFilename;
2827	rc = mVirtualBox->ComposeMachineFilename(Bstr(stack.strNameVBox).raw(),
2828	NULL,
2829	bstrMachineFilename.asOutParam());
2830	if (FAILED(rc)) throw rc;
2831	// and determine the machine folder from that
2832	stack.strMachineFolder = bstrMachineFilename;
2833	stack.strMachineFolder.stripFilename();
2834
2835	// guest OS type
2836	std::list<VirtualSystemDescriptionEntry*> vsdeOS;
2837	vsdeOS = vsdescThis->findByType(VirtualSystemDescriptionType_OS);
2838	if (vsdeOS.size() < 1)
2839	throw setError(VBOX_E_FILE_ERROR,
2840	tr("Missing guest OS type"));
2841	stack.strOsTypeVBox = vsdeOS.front()->strVboxCurrent;
2842
2843	// CPU count
2844	std::list<VirtualSystemDescriptionEntry*> vsdeCPU = vsdescThis->findByType(VirtualSystemDescriptionType_CPU);
2845	if (vsdeCPU.size() != 1)
2846	throw setError(VBOX_E_FILE_ERROR, tr("CPU count missing"));
2847
2848	stack.cCPUs = vsdeCPU.front()->strVboxCurrent.toUInt32();
2849	// We need HWVirt & IO-APIC if more than one CPU is requested
2850	if (stack.cCPUs > 1)
2851	{
2852	stack.fForceHWVirt = true;
2853	stack.fForceIOAPIC = true;
2854	}
2855
2856	// RAM
2857	std::list<VirtualSystemDescriptionEntry*> vsdeRAM = vsdescThis->findByType(VirtualSystemDescriptionType_Memory);
2858	if (vsdeRAM.size() != 1)
2859	throw setError(VBOX_E_FILE_ERROR, tr("RAM size missing"));
2860	stack.ulMemorySizeMB = (ULONG)vsdeRAM.front()->strVboxCurrent.toUInt64();
2861
2862	#ifdef VBOX_WITH_USB
2863	// USB controller
2864	std::list<VirtualSystemDescriptionEntry*> vsdeUSBController = vsdescThis->findByType(VirtualSystemDescriptionType_USBController);
2865	// USB support is enabled if there's at least one such entry; to disable USB support,
2866	// the type of the USB item would have been changed to "ignore"
2867	stack.fUSBEnabled = vsdeUSBController.size() > 0;
2868	#endif
2869	// audio adapter
2870	std::list<VirtualSystemDescriptionEntry*> vsdeAudioAdapter = vsdescThis->findByType(VirtualSystemDescriptionType_SoundCard);
2871	/* @todo: we support one audio adapter only */
2872	if (vsdeAudioAdapter.size() > 0)
2873	stack.strAudioAdapter = vsdeAudioAdapter.front()->strVboxCurrent;
2874
2875	// for the description of the new machine, always use the OVF entry, the user may have changed it in the import config
2876	std::list<VirtualSystemDescriptionEntry*> vsdeDescription = vsdescThis->findByType(VirtualSystemDescriptionType_Description);
2877	if (vsdeDescription.size())
2878	stack.strDescription = vsdeDescription.front()->strVboxCurrent;
2879
2880	// import vbox:machine or OVF now
2881	if (vsdescThis->m->pConfig)
2882	// vbox:Machine config
2883	importVBoxMachine(vsdescThis, pNewMachine, stack, pCallbacks, pStorage);
2884	else
2885	// generic OVF config
2886	importMachineGeneric(vsysThis, vsdescThis, pNewMachine, stack, pCallbacks, pStorage);
2887
2888	} // for (it = pAppliance->m->llVirtualSystems.begin() ...
2889	}
2890

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

source: vbox/trunk/src/VBox/Main/src-server/ApplianceImplImport.cpp@ 36964

Download in other formats: