ApplianceImplImport.cpp@ 53517

Last change on this file since 53517 was 53354, checked in by vboxsync, 10 years ago
R7524 - needs testing in VBoxManage.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 168.9 KB

Line
1	/* $Id: ApplianceImplImport.cpp 53354 2014-11-19 18:32:03Z vboxsync $ */
2	/** @file
3	* IAppliance and IVirtualSystem COM class implementations.
4	*/
5
6	/*
7	* Copyright (C) 2008-2014 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18	#include <iprt/path.h>
19	#include <iprt/dir.h>
20	#include <iprt/file.h>
21	#include <iprt/s3.h>
22	#include <iprt/sha.h>
23	#include <iprt/manifest.h>
24	#include <iprt/tar.h>
25	#include <iprt/stream.h>
26
27	#include <VBox/vd.h>
28	#include <VBox/com/array.h>
29
30	#include "ApplianceImpl.h"
31	#include "VirtualBoxImpl.h"
32	#include "GuestOSTypeImpl.h"
33	#include "ProgressImpl.h"
34	#include "MachineImpl.h"
35	#include "MediumImpl.h"
36	#include "MediumFormatImpl.h"
37	#include "SystemPropertiesImpl.h"
38	#include "HostImpl.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	#include <iprt/x509-branch-collision.h>
50	#include <set>
51
52	using namespace std;
53
54	////////////////////////////////////////////////////////////////////////////////
55	//
56	// IAppliance public methods
57	//
58	////////////////////////////////////////////////////////////////////////////////
59
60	/**
61	* Public method implementation. This opens the OVF with ovfreader.cpp.
62	* Thread implementation is in Appliance::readImpl().
63	*
64	* @param aFile
65	* @return
66	*/
67	HRESULT Appliance::read(const com::Utf8Str &aFile,
68	ComPtr<IProgress> &aProgress)
69	{
70	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
71
72	if (!i_isApplianceIdle())
73	return E_ACCESSDENIED;
74
75	if (m->pReader)
76	{
77	delete m->pReader;
78	m->pReader = NULL;
79	}
80
81	// see if we can handle this file; for now we insist it has an ovf/ova extension
82	if (!( aFile.endsWith(".ovf", Utf8Str::CaseInsensitive)
83	\|\| aFile.endsWith(".ova", Utf8Str::CaseInsensitive)))
84	return setError(VBOX_E_FILE_ERROR,
85	tr("Appliance file must have .ovf extension"));
86
87	ComObjPtr<Progress> progress;
88	HRESULT rc = S_OK;
89	try
90	{
91	/* Parse all necessary info out of the URI */
92	i_parseURI(aFile, m->locInfo);
93	rc = i_readImpl(m->locInfo, progress);
94	}
95	catch (HRESULT aRC)
96	{
97	rc = aRC;
98	}
99
100	if (SUCCEEDED(rc))
101	/* Return progress to the caller */
102	progress.queryInterfaceTo(aProgress.asOutParam());
103
104	return S_OK;
105	}
106
107	/**
108	* Public method implementation. This looks at the output of ovfreader.cpp and creates
109	* VirtualSystemDescription instances.
110	* @return
111	*/
112	HRESULT Appliance::interpret()
113	{
114	// @todo:
115	// - don't use COM methods but the methods directly (faster, but needs appropriate
116	// locking of that objects itself (s. HardDisk))
117	// - Appropriate handle errors like not supported file formats
118	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
119
120	if (!i_isApplianceIdle())
121	return E_ACCESSDENIED;
122
123	HRESULT rc = S_OK;
124
125	/* Clear any previous virtual system descriptions */
126	m->virtualSystemDescriptions.clear();
127
128	if (!m->pReader)
129	return setError(E_FAIL,
130	tr("Cannot interpret appliance without reading it first (call read() before interpret())"));
131
132	// Change the appliance state so we can safely leave the lock while doing time-consuming
133	// disk imports; also the below method calls do all kinds of locking which conflicts with
134	// the appliance object lock
135	m->state = Data::ApplianceImporting;
136	alock.release();
137
138	/* Try/catch so we can clean up on error */
139	try
140	{
141	list<ovf::VirtualSystem>::const_iterator it;
142	/* Iterate through all virtual systems */
143	for (it = m->pReader->m_llVirtualSystems.begin();
144	it != m->pReader->m_llVirtualSystems.end();
145	++it)
146	{
147	const ovf::VirtualSystem &vsysThis = *it;
148
149	ComObjPtr<VirtualSystemDescription> pNewDesc;
150	rc = pNewDesc.createObject();
151	if (FAILED(rc)) throw rc;
152	rc = pNewDesc->init();
153	if (FAILED(rc)) throw rc;
154
155	// if the virtual system in OVF had a <vbox:Machine> element, have the
156	// VirtualBox settings code parse that XML now
157	if (vsysThis.pelmVBoxMachine)
158	pNewDesc->i_importVBoxMachineXML(*vsysThis.pelmVBoxMachine);
159
160	// Guest OS type
161	// This is taken from one of three places, in this order:
162	Utf8Str strOsTypeVBox;
163	Utf8StrFmt strCIMOSType("%RU32", (uint32_t)vsysThis.cimos);
164	// 1) If there is a <vbox:Machine>, then use the type from there.
165	if ( vsysThis.pelmVBoxMachine
166	&& pNewDesc->m->pConfig->machineUserData.strOsType.isNotEmpty()
167	)
168	strOsTypeVBox = pNewDesc->m->pConfig->machineUserData.strOsType;
169	// 2) Otherwise, if there is OperatingSystemSection/vbox:OSType, use that one.
170	else if (vsysThis.strTypeVBox.isNotEmpty()) // OVFReader has found vbox:OSType
171	strOsTypeVBox = vsysThis.strTypeVBox;
172	// 3) Otherwise, make a best guess what the vbox type is from the OVF (CIM) OS type.
173	else
174	convertCIMOSType2VBoxOSType(strOsTypeVBox, vsysThis.cimos, vsysThis.strCimosDesc);
175	pNewDesc->i_addEntry(VirtualSystemDescriptionType_OS,
176	"",
177	strCIMOSType,
178	strOsTypeVBox);
179
180	/* VM name */
181	Utf8Str nameVBox;
182	/* If there is a <vbox:Machine>, we always prefer the setting from there. */
183	if ( vsysThis.pelmVBoxMachine
184	&& pNewDesc->m->pConfig->machineUserData.strName.isNotEmpty())
185	nameVBox = pNewDesc->m->pConfig->machineUserData.strName;
186	else
187	nameVBox = vsysThis.strName;
188	/* If there isn't any name specified create a default one out
189	* of the OS type */
190	if (nameVBox.isEmpty())
191	nameVBox = strOsTypeVBox;
192	i_searchUniqueVMName(nameVBox);
193	pNewDesc->i_addEntry(VirtualSystemDescriptionType_Name,
194	"",
195	vsysThis.strName,
196	nameVBox);
197
198	/* Based on the VM name, create a target machine path. */
199	Bstr bstrMachineFilename;
200	rc = mVirtualBox->ComposeMachineFilename(Bstr(nameVBox).raw(),
201	NULL /* aGroup */,
202	NULL /* aCreateFlags */,
203	NULL /* aBaseFolder */,
204	bstrMachineFilename.asOutParam());
205	if (FAILED(rc)) throw rc;
206	/* Determine the machine folder from that */
207	Utf8Str strMachineFolder = Utf8Str(bstrMachineFilename).stripFilename();
208
209	/* VM Product */
210	if (!vsysThis.strProduct.isEmpty())
211	pNewDesc->i_addEntry(VirtualSystemDescriptionType_Product,
212	"",
213	vsysThis.strProduct,
214	vsysThis.strProduct);
215
216	/* VM Vendor */
217	if (!vsysThis.strVendor.isEmpty())
218	pNewDesc->i_addEntry(VirtualSystemDescriptionType_Vendor,
219	"",
220	vsysThis.strVendor,
221	vsysThis.strVendor);
222
223	/* VM Version */
224	if (!vsysThis.strVersion.isEmpty())
225	pNewDesc->i_addEntry(VirtualSystemDescriptionType_Version,
226	"",
227	vsysThis.strVersion,
228	vsysThis.strVersion);
229
230	/* VM ProductUrl */
231	if (!vsysThis.strProductUrl.isEmpty())
232	pNewDesc->i_addEntry(VirtualSystemDescriptionType_ProductUrl,
233	"",
234	vsysThis.strProductUrl,
235	vsysThis.strProductUrl);
236
237	/* VM VendorUrl */
238	if (!vsysThis.strVendorUrl.isEmpty())
239	pNewDesc->i_addEntry(VirtualSystemDescriptionType_VendorUrl,
240	"",
241	vsysThis.strVendorUrl,
242	vsysThis.strVendorUrl);
243
244	/* VM description */
245	if (!vsysThis.strDescription.isEmpty())
246	pNewDesc->i_addEntry(VirtualSystemDescriptionType_Description,
247	"",
248	vsysThis.strDescription,
249	vsysThis.strDescription);
250
251	/* VM license */
252	if (!vsysThis.strLicenseText.isEmpty())
253	pNewDesc->i_addEntry(VirtualSystemDescriptionType_License,
254	"",
255	vsysThis.strLicenseText,
256	vsysThis.strLicenseText);
257
258	/* Now that we know the OS type, get our internal defaults based on that. */
259	ComPtr<IGuestOSType> pGuestOSType;
260	rc = mVirtualBox->GetGuestOSType(Bstr(strOsTypeVBox).raw(), pGuestOSType.asOutParam());
261	if (FAILED(rc)) throw rc;
262
263	/* CPU count */
264	ULONG cpuCountVBox;
265	/* If there is a <vbox:Machine>, we always prefer the setting from there. */
266	if ( vsysThis.pelmVBoxMachine
267	&& pNewDesc->m->pConfig->hardwareMachine.cCPUs)
268	cpuCountVBox = pNewDesc->m->pConfig->hardwareMachine.cCPUs;
269	else
270	cpuCountVBox = vsysThis.cCPUs;
271	/* Check for the constraints */
272	if (cpuCountVBox > SchemaDefs::MaxCPUCount)
273	{
274	i_addWarning(tr("The virtual system \"%s\" claims support for %u CPU's, but VirtualBox has support for "
275	"max %u CPU's only."),
276	vsysThis.strName.c_str(), cpuCountVBox, SchemaDefs::MaxCPUCount);
277	cpuCountVBox = SchemaDefs::MaxCPUCount;
278	}
279	if (vsysThis.cCPUs == 0)
280	cpuCountVBox = 1;
281	pNewDesc->i_addEntry(VirtualSystemDescriptionType_CPU,
282	"",
283	Utf8StrFmt("%RU32", (uint32_t)vsysThis.cCPUs),
284	Utf8StrFmt("%RU32", (uint32_t)cpuCountVBox));
285
286	/* RAM */
287	uint64_t ullMemSizeVBox;
288	/* If there is a <vbox:Machine>, we always prefer the setting from there. */
289	if ( vsysThis.pelmVBoxMachine
290	&& pNewDesc->m->pConfig->hardwareMachine.ulMemorySizeMB)
291	ullMemSizeVBox = pNewDesc->m->pConfig->hardwareMachine.ulMemorySizeMB;
292	else
293	ullMemSizeVBox = vsysThis.ullMemorySize / _1M;
294	/* Check for the constraints */
295	if ( ullMemSizeVBox != 0
296	&& ( ullMemSizeVBox < MM_RAM_MIN_IN_MB
297	\|\| ullMemSizeVBox > MM_RAM_MAX_IN_MB
298	)
299	)
300	{
301	i_addWarning(tr("The virtual system \"%s\" claims support for %llu MB RAM size, but VirtualBox has "
302	"support for min %u & max %u MB RAM size only."),
303	vsysThis.strName.c_str(), ullMemSizeVBox, MM_RAM_MIN_IN_MB, MM_RAM_MAX_IN_MB);
304	ullMemSizeVBox = RT_MIN(RT_MAX(ullMemSizeVBox, MM_RAM_MIN_IN_MB), MM_RAM_MAX_IN_MB);
305	}
306	if (vsysThis.ullMemorySize == 0)
307	{
308	/* If the RAM of the OVF is zero, use our predefined values */
309	ULONG memSizeVBox2;
310	rc = pGuestOSType->COMGETTER(RecommendedRAM)(&memSizeVBox2);
311	if (FAILED(rc)) throw rc;
312	/* VBox stores that in MByte */
313	ullMemSizeVBox = (uint64_t)memSizeVBox2;
314	}
315	pNewDesc->i_addEntry(VirtualSystemDescriptionType_Memory,
316	"",
317	Utf8StrFmt("%RU64", (uint64_t)vsysThis.ullMemorySize),
318	Utf8StrFmt("%RU64", (uint64_t)ullMemSizeVBox));
319
320	/* Audio */
321	Utf8Str strSoundCard;
322	Utf8Str strSoundCardOrig;
323	/* If there is a <vbox:Machine>, we always prefer the setting from there. */
324	if ( vsysThis.pelmVBoxMachine
325	&& pNewDesc->m->pConfig->hardwareMachine.audioAdapter.fEnabled)
326	{
327	strSoundCard = Utf8StrFmt("%RU32",
328	(uint32_t)pNewDesc->m->pConfig->hardwareMachine.audioAdapter.controllerType);
329	}
330	else if (vsysThis.strSoundCardType.isNotEmpty())
331	{
332	/* Set the AC97 always for the simple OVF case.
333	* @todo: figure out the hardware which could be possible */
334	strSoundCard = Utf8StrFmt("%RU32", (uint32_t)AudioControllerType_AC97);
335	strSoundCardOrig = vsysThis.strSoundCardType;
336	}
337	if (strSoundCard.isNotEmpty())
338	pNewDesc->i_addEntry(VirtualSystemDescriptionType_SoundCard,
339	"",
340	strSoundCardOrig,
341	strSoundCard);
342
343	#ifdef VBOX_WITH_USB
344	/* USB Controller */
345	/* If there is a <vbox:Machine>, we always prefer the setting from there. */
346	if ( ( vsysThis.pelmVBoxMachine
347	&& pNewDesc->m->pConfig->hardwareMachine.usbSettings.llUSBControllers.size() > 0)
348	\|\| vsysThis.fHasUsbController)
349	pNewDesc->i_addEntry(VirtualSystemDescriptionType_USBController, "", "", "");
350	#endif /* VBOX_WITH_USB */
351
352	/* Network Controller */
353	/* If there is a <vbox:Machine>, we always prefer the setting from there. */
354	if (vsysThis.pelmVBoxMachine)
355	{
356	uint32_t maxNetworkAdapters = Global::getMaxNetworkAdapters(pNewDesc->m->pConfig->hardwareMachine.chipsetType);
357
358	const settings::NetworkAdaptersList &llNetworkAdapters = pNewDesc->m->pConfig->hardwareMachine.llNetworkAdapters;
359	/* Check for the constrains */
360	if (llNetworkAdapters.size() > maxNetworkAdapters)
361	i_addWarning(tr("The virtual system \"%s\" claims support for %zu network adapters, but VirtualBox "
362	"has support for max %u network adapter only."),
363	vsysThis.strName.c_str(), llNetworkAdapters.size(), maxNetworkAdapters);
364	/* Iterate through all network adapters. */
365	settings::NetworkAdaptersList::const_iterator it1;
366	size_t a = 0;
367	for (it1 = llNetworkAdapters.begin();
368	it1 != llNetworkAdapters.end() && a < maxNetworkAdapters;
369	++it1, ++a)
370	{
371	if (it1->fEnabled)
372	{
373	Utf8Str strMode = convertNetworkAttachmentTypeToString(it1->mode);
374	pNewDesc->i_addEntry(VirtualSystemDescriptionType_NetworkAdapter,
375	"", // ref
376	strMode, // orig
377	Utf8StrFmt("%RU32", (uint32_t)it1->type), // conf
378	0,
379	Utf8StrFmt("slot=%RU32;type=%s", it1->ulSlot, strMode.c_str())); // extra conf
380	}
381	}
382	}
383	/* else we use the ovf configuration. */
384	else if (vsysThis.llEthernetAdapters.size() > 0)
385	{
386	size_t cEthernetAdapters = vsysThis.llEthernetAdapters.size();
387	uint32_t maxNetworkAdapters = Global::getMaxNetworkAdapters(ChipsetType_PIIX3);
388
389	/* Check for the constrains */
390	if (cEthernetAdapters > maxNetworkAdapters)
391	i_addWarning(tr("The virtual system \"%s\" claims support for %zu network adapters, but VirtualBox "
392	"has support for max %u network adapter only."),
393	vsysThis.strName.c_str(), cEthernetAdapters, maxNetworkAdapters);
394
395	/* Get the default network adapter type for the selected guest OS */
396	NetworkAdapterType_T defaultAdapterVBox = NetworkAdapterType_Am79C970A;
397	rc = pGuestOSType->COMGETTER(AdapterType)(&defaultAdapterVBox);
398	if (FAILED(rc)) throw rc;
399
400	ovf::EthernetAdaptersList::const_iterator itEA;
401	/* Iterate through all abstract networks. Ignore network cards
402	* which exceed the limit of VirtualBox. */
403	size_t a = 0;
404	for (itEA = vsysThis.llEthernetAdapters.begin();
405	itEA != vsysThis.llEthernetAdapters.end() && a < maxNetworkAdapters;
406	++itEA, ++a)
407	{
408	const ovf::EthernetAdapter &ea = *itEA; // logical network to connect to
409	Utf8Str strNetwork = ea.strNetworkName;
410	// make sure it's one of these two
411	if ( (strNetwork.compare("Null", Utf8Str::CaseInsensitive))
412	&& (strNetwork.compare("NAT", Utf8Str::CaseInsensitive))
413	&& (strNetwork.compare("Bridged", Utf8Str::CaseInsensitive))
414	&& (strNetwork.compare("Internal", Utf8Str::CaseInsensitive))
415	&& (strNetwork.compare("HostOnly", Utf8Str::CaseInsensitive))
416	&& (strNetwork.compare("Generic", Utf8Str::CaseInsensitive))
417	)
418	strNetwork = "Bridged"; // VMware assumes this is the default apparently
419
420	/* Figure out the hardware type */
421	NetworkAdapterType_T nwAdapterVBox = defaultAdapterVBox;
422	if (!ea.strAdapterType.compare("PCNet32", Utf8Str::CaseInsensitive))
423	{
424	/* If the default adapter is already one of the two
425	* PCNet adapters use the default one. If not use the
426	* Am79C970A as fallback. */
427	if (!(defaultAdapterVBox == NetworkAdapterType_Am79C970A \|\|
428	defaultAdapterVBox == NetworkAdapterType_Am79C973))
429	nwAdapterVBox = NetworkAdapterType_Am79C970A;
430	}
431	#ifdef VBOX_WITH_E1000
432	/* VMWare accidentally write this with VirtualCenter 3.5,
433	so make sure in this case always to use the VMWare one */
434	else if (!ea.strAdapterType.compare("E10000", Utf8Str::CaseInsensitive))
435	nwAdapterVBox = NetworkAdapterType_I82545EM;
436	else if (!ea.strAdapterType.compare("E1000", Utf8Str::CaseInsensitive))
437	{
438	/* Check if this OVF was written by VirtualBox */
439	if (Utf8Str(vsysThis.strVirtualSystemType).contains("virtualbox", Utf8Str::CaseInsensitive))
440	{
441	/* If the default adapter is already one of the three
442	* E1000 adapters use the default one. If not use the
443	* I82545EM as fallback. */
444	if (!(defaultAdapterVBox == NetworkAdapterType_I82540EM \|\|
445	defaultAdapterVBox == NetworkAdapterType_I82543GC \|\|
446	defaultAdapterVBox == NetworkAdapterType_I82545EM))
447	nwAdapterVBox = NetworkAdapterType_I82540EM;
448	}
449	else
450	/* Always use this one since it's what VMware uses */
451	nwAdapterVBox = NetworkAdapterType_I82545EM;
452	}
453	#endif /* VBOX_WITH_E1000 */
454
455	pNewDesc->i_addEntry(VirtualSystemDescriptionType_NetworkAdapter,
456	"", // ref
457	ea.strNetworkName, // orig
458	Utf8StrFmt("%RU32", (uint32_t)nwAdapterVBox), // conf
459	0,
460	Utf8StrFmt("type=%s", strNetwork.c_str())); // extra conf
461	}
462	}
463
464	/* If there is a <vbox:Machine>, we always prefer the setting from there. */
465	bool fFloppy = false;
466	bool fDVD = false;
467	if (vsysThis.pelmVBoxMachine)
468	{
469	settings::StorageControllersList &llControllers = pNewDesc->m->pConfig->storageMachine.llStorageControllers;
470	settings::StorageControllersList::iterator it3;
471	for (it3 = llControllers.begin();
472	it3 != llControllers.end();
473	++it3)
474	{
475	settings::AttachedDevicesList &llAttachments = it3->llAttachedDevices;
476	settings::AttachedDevicesList::iterator it4;
477	for (it4 = llAttachments.begin();
478	it4 != llAttachments.end();
479	++it4)
480	{
481	fDVD \|= it4->deviceType == DeviceType_DVD;
482	fFloppy \|= it4->deviceType == DeviceType_Floppy;
483	if (fFloppy && fDVD)
484	break;
485	}
486	if (fFloppy && fDVD)
487	break;
488	}
489	}
490	else
491	{
492	fFloppy = vsysThis.fHasFloppyDrive;
493	fDVD = vsysThis.fHasCdromDrive;
494	}
495	/* Floppy Drive */
496	if (fFloppy)
497	pNewDesc->i_addEntry(VirtualSystemDescriptionType_Floppy, "", "", "");
498	/* CD Drive */
499	if (fDVD)
500	pNewDesc->i_addEntry(VirtualSystemDescriptionType_CDROM, "", "", "");
501
502	/* Hard disk Controller */
503	uint16_t cIDEused = 0;
504	uint16_t cSATAused = 0; NOREF(cSATAused);
505	uint16_t cSCSIused = 0; NOREF(cSCSIused);
506	ovf::ControllersMap::const_iterator hdcIt;
507	/* Iterate through all hard disk controllers */
508	for (hdcIt = vsysThis.mapControllers.begin();
509	hdcIt != vsysThis.mapControllers.end();
510	++hdcIt)
511	{
512	const ovf::HardDiskController &hdc = hdcIt->second;
513	Utf8Str strControllerID = Utf8StrFmt("%RI32", (uint32_t)hdc.idController);
514
515	switch (hdc.system)
516	{
517	case ovf::HardDiskController::IDE:
518	/* Check for the constrains */
519	if (cIDEused < 4)
520	{
521	// @todo: figure out the IDE types
522	/* Use PIIX4 as default */
523	Utf8Str strType = "PIIX4";
524	if (!hdc.strControllerType.compare("PIIX3", Utf8Str::CaseInsensitive))
525	strType = "PIIX3";
526	else if (!hdc.strControllerType.compare("ICH6", Utf8Str::CaseInsensitive))
527	strType = "ICH6";
528	pNewDesc->i_addEntry(VirtualSystemDescriptionType_HardDiskControllerIDE,
529	strControllerID, // strRef
530	hdc.strControllerType, // aOvfValue
531	strType); // aVBoxValue
532	}
533	else
534	/* Warn only once */
535	if (cIDEused == 2)
536	i_addWarning(tr("The virtual \"%s\" system requests support for more than two "
537	"IDE controller channels, but VirtualBox supports only two."),
538	vsysThis.strName.c_str());
539
540	++cIDEused;
541	break;
542
543	case ovf::HardDiskController::SATA:
544	/* Check for the constrains */
545	if (cSATAused < 1)
546	{
547	// @todo: figure out the SATA types
548	/* We only support a plain AHCI controller, so use them always */
549	pNewDesc->i_addEntry(VirtualSystemDescriptionType_HardDiskControllerSATA,
550	strControllerID,
551	hdc.strControllerType,
552	"AHCI");
553	}
554	else
555	{
556	/* Warn only once */
557	if (cSATAused == 1)
558	i_addWarning(tr("The virtual system \"%s\" requests support for more than one "
559	"SATA controller, but VirtualBox has support for only one"),
560	vsysThis.strName.c_str());
561
562	}
563	++cSATAused;
564	break;
565
566	case ovf::HardDiskController::SCSI:
567	/* Check for the constrains */
568	if (cSCSIused < 1)
569	{
570	VirtualSystemDescriptionType_T vsdet = VirtualSystemDescriptionType_HardDiskControllerSCSI;
571	Utf8Str hdcController = "LsiLogic";
572	if (!hdc.strControllerType.compare("lsilogicsas", Utf8Str::CaseInsensitive))
573	{
574	// OVF considers SAS a variant of SCSI but VirtualBox considers it a class of its own
575	vsdet = VirtualSystemDescriptionType_HardDiskControllerSAS;
576	hdcController = "LsiLogicSas";
577	}
578	else if (!hdc.strControllerType.compare("BusLogic", Utf8Str::CaseInsensitive))
579	hdcController = "BusLogic";
580	pNewDesc->i_addEntry(vsdet,
581	strControllerID,
582	hdc.strControllerType,
583	hdcController);
584	}
585	else
586	i_addWarning(tr("The virtual system \"%s\" requests support for an additional "
587	"SCSI controller of type \"%s\" with ID %s, but VirtualBox presently "
588	"supports only one SCSI controller."),
589	vsysThis.strName.c_str(),
590	hdc.strControllerType.c_str(),
591	strControllerID.c_str());
592	++cSCSIused;
593	break;
594	}
595	}
596
597	/* Hard disks */
598	if (vsysThis.mapVirtualDisks.size() > 0)
599	{
600	ovf::VirtualDisksMap::const_iterator itVD;
601	/* Iterate through all hard disks ()*/
602	for (itVD = vsysThis.mapVirtualDisks.begin();
603	itVD != vsysThis.mapVirtualDisks.end();
604	++itVD)
605	{
606	const ovf::VirtualDisk &hd = itVD->second;
607	/* Get the associated disk image */
608	ovf::DiskImage di;
609	std::map<RTCString, ovf::DiskImage>::iterator foundDisk;
610
611	foundDisk = m->pReader->m_mapDisks.find(hd.strDiskId);
612	if (foundDisk == m->pReader->m_mapDisks.end())
613	continue;
614	else
615	{
616	di = foundDisk->second;
617	}
618
619	/*
620	* Figure out from URI which format the image of disk has.
621	* URI must have inside section <Disk> .
622	* But there aren't strong requirements about correspondence one URI for one disk virtual format.
623	* So possibly, we aren't able to recognize some URIs.
624	*/
625
626	ComObjPtr<MediumFormat> mediumFormat;
627	rc = i_findMediumFormatFromDiskImage(di, mediumFormat);
628	if (FAILED(rc))
629	throw rc;
630
631	Bstr bstrFormatName;
632	rc = mediumFormat->COMGETTER(Name)(bstrFormatName.asOutParam());
633	if (FAILED(rc))
634	throw rc;
635	Utf8Str vdf = Utf8Str(bstrFormatName);
636
637	// @todo:
638	// - figure out all possible vmdk formats we also support
639	// - figure out if there is a url specifier for vhd already
640	// - we need a url specifier for the vdi format
641
642	if (vdf.compare("VMDK", Utf8Str::CaseInsensitive) == 0)
643	{
644	/* If the href is empty use the VM name as filename */
645	Utf8Str strFilename = di.strHref;
646	if (!strFilename.length())
647	strFilename = Utf8StrFmt("%s.vmdk", hd.strDiskId.c_str());
648
649	Utf8Str strTargetPath = Utf8Str(strMachineFolder);
650	strTargetPath.append(RTPATH_DELIMITER).append(di.strHref);
651	i_searchUniqueDiskImageFilePath(strTargetPath);
652
653	/* find the description for the hard disk controller
654	* that has the same ID as hd.idController */
655	const VirtualSystemDescriptionEntry *pController;
656	if (!(pController = pNewDesc->i_findControllerFromID(hd.idController)))
657	throw setError(E_FAIL,
658	tr("Cannot find hard disk controller with OVF instance ID %RI32 "
659	"to which disk \"%s\" should be attached"),
660	hd.idController,
661	di.strHref.c_str());
662
663	/* controller to attach to, and the bus within that controller */
664	Utf8StrFmt strExtraConfig("controller=%RI16;channel=%RI16",
665	pController->ulIndex,
666	hd.ulAddressOnParent);
667	pNewDesc->i_addEntry(VirtualSystemDescriptionType_HardDiskImage,
668	hd.strDiskId,
669	di.strHref,
670	strTargetPath,
671	di.ulSuggestedSizeMB,
672	strExtraConfig);
673	}
674	else if (vdf.compare("RAW", Utf8Str::CaseInsensitive) == 0)
675	{
676	/* If the href is empty use the VM name as filename */
677	Utf8Str strFilename = di.strHref;
678	if (!strFilename.length())
679	strFilename = Utf8StrFmt("%s.iso", hd.strDiskId.c_str());
680
681	Utf8Str strTargetPath = Utf8Str(strMachineFolder)
682	.append(RTPATH_DELIMITER)
683	.append(di.strHref);
684	i_searchUniqueDiskImageFilePath(strTargetPath);
685
686	/* find the description for the hard disk controller
687	* that has the same ID as hd.idController */
688	const VirtualSystemDescriptionEntry *pController;
689	if (!(pController = pNewDesc->i_findControllerFromID(hd.idController)))
690	throw setError(E_FAIL,
691	tr("Cannot find disk controller with OVF instance ID %RI32 "
692	"to which disk \"%s\" should be attached"),
693	hd.idController,
694	di.strHref.c_str());
695
696	/* controller to attach to, and the bus within that controller */
697	Utf8StrFmt strExtraConfig("controller=%RI16;channel=%RI16",
698	pController->ulIndex,
699	hd.ulAddressOnParent);
700	pNewDesc->i_addEntry(VirtualSystemDescriptionType_HardDiskImage,
701	hd.strDiskId,
702	di.strHref,
703	strTargetPath,
704	di.ulSuggestedSizeMB,
705	strExtraConfig);
706	}
707	else
708	throw setError(VBOX_E_FILE_ERROR,
709	tr("Unsupported format for virtual disk image %s in OVF: \"%s\""),
710	di.strHref.c_str(),
711	di.strFormat.c_str());
712	}
713	}
714
715	m->virtualSystemDescriptions.push_back(pNewDesc);
716	}
717	}
718	catch (HRESULT aRC)
719	{
720	/* On error we clear the list & return */
721	m->virtualSystemDescriptions.clear();
722	rc = aRC;
723	}
724
725	// reset the appliance state
726	alock.acquire();
727	m->state = Data::ApplianceIdle;
728
729	return rc;
730	}
731
732	/**
733	* Public method implementation. This creates one or more new machines according to the
734	* VirtualSystemScription instances created by Appliance::Interpret().
735	* Thread implementation is in Appliance::i_importImpl().
736	* @param aProgress
737	* @return
738	*/
739	HRESULT Appliance::importMachines(const std::vector<ImportOptions_T> &aOptions,
740	ComPtr<IProgress> &aProgress)
741	{
742	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
743
744	if (aOptions.size())
745	{
746	m->optListImport.setCapacity(aOptions.size());
747	for (size_t i = 0; i < aOptions.size(); ++i)
748	{
749	m->optListImport.insert(i, aOptions[i]);
750	}
751	}
752
753	AssertReturn(!(m->optListImport.contains
754	(ImportOptions_KeepAllMACs)
755	&& m->optListImport.contains(ImportOptions_KeepNATMACs)
756	), E_INVALIDARG);
757
758	// do not allow entering this method if the appliance is busy reading or writing
759	if (!i_isApplianceIdle())
760	return E_ACCESSDENIED;
761
762	if (!m->pReader)
763	return setError(E_FAIL,
764	tr("Cannot import machines without reading it first (call read() before i_importMachines())"));
765
766	ComObjPtr<Progress> progress;
767	HRESULT rc = S_OK;
768	try
769	{
770	rc = i_importImpl(m->locInfo, progress);
771	}
772	catch (HRESULT aRC)
773	{
774	rc = aRC;
775	}
776
777	if (SUCCEEDED(rc))
778	/* Return progress to the caller */
779	progress.queryInterfaceTo(aProgress.asOutParam());
780
781	return rc;
782	}
783
784	////////////////////////////////////////////////////////////////////////////////
785	//
786	// Appliance private methods
787	//
788	////////////////////////////////////////////////////////////////////////////////
789
790	HRESULT Appliance::i_preCheckImageAvailability(PSHASTORAGE pSHAStorage,
791	RTCString &availableImage)
792	{
793	PFSSRDONLYINTERFACEIO pTarIo = (PFSSRDONLYINTERFACEIO)pSHAStorage->pVDImageIfaces->pvUser;
794	const char *pszFilename;
795	int vrc = fssRdOnlyGetCurrentName(pTarIo, &pszFilename);
796	if (RT_SUCCESS(vrc))
797	{
798	if (!fssRdOnlyIsCurrentDirectory(pTarIo))
799	{
800	availableImage = pszFilename;
801	return S_OK;
802	}
803
804	throw setError(VBOX_E_FILE_ERROR, tr("Empty directory folder (%s) isn't allowed in the OVA package (%Rrc)"),
805	pszFilename, VERR_IS_A_DIRECTORY);
806	}
807
808	throw setError(VBOX_E_FILE_ERROR, tr("Could not open the current file in the OVA package (%Rrc)"), vrc);
809	}
810
811	/*******************************************************************************
812	* Read stuff
813	******************************************************************************/
814
815	/**
816	* Implementation for reading an OVF (via task).
817	*
818	* This starts a new thread which will call
819	* Appliance::taskThreadImportOrExport() which will then call readFS() or
820	* readS3(). This will then open the OVF with ovfreader.cpp.
821	*
822	* This is in a separate private method because it is used from three locations:
823	*
824	* 1) from the public Appliance::Read().
825	*
826	* 2) in a second worker thread; in that case, Appliance::ImportMachines() called Appliance::i_importImpl(), which
827	* called Appliance::readFSOVA(), which called Appliance::i_importImpl(), which then called this again.
828	*
829	* 3) from Appliance::readS3(), which got called from a previous instance of Appliance::taskThreadImportOrExport().
830	*
831	* @param aLocInfo The OVF location.
832	* @param aProgress Where to return the progress object.
833	* @return COM success status code. COM error codes will be thrown.
834	*/
835	HRESULT Appliance::i_readImpl(const LocationInfo &aLocInfo, ComObjPtr<Progress> &aProgress)
836	{
837	BstrFmt bstrDesc = BstrFmt(tr("Reading appliance '%s'"),
838	aLocInfo.strPath.c_str());
839	HRESULT rc;
840	/* Create the progress object */
841	aProgress.createObject();
842	if (aLocInfo.storageType == VFSType_File)
843	/* 1 operation only */
844	rc = aProgress->init(mVirtualBox, static_cast<IAppliance*>(this),
845	bstrDesc.raw(),
846	TRUE /* aCancelable */);
847	else
848	/* 4/5 is downloading, 1/5 is reading */
849	rc = aProgress->init(mVirtualBox, static_cast<IAppliance*>(this),
850	bstrDesc.raw(),
851	TRUE /* aCancelable */,
852	2, // ULONG cOperations,
853	5, // ULONG ulTotalOperationsWeight,
854	BstrFmt(tr("Download appliance '%s'"),
855	aLocInfo.strPath.c_str()).raw(), // CBSTR bstrFirstOperationDescription,
856	4); // ULONG ulFirstOperationWeight,
857	if (FAILED(rc)) throw rc;
858
859	/* Initialize our worker task */
860	std::auto_ptr<TaskOVF> task(new TaskOVF(this, TaskOVF::Read, aLocInfo, aProgress));
861
862	rc = task->startThread();
863	if (FAILED(rc)) throw rc;
864
865	/* Don't destruct on success */
866	task.release();
867
868	return rc;
869	}
870
871	/**
872	* Actual worker code for reading an OVF from disk. This is called from Appliance::taskThreadImportOrExport()
873	* and therefore runs on the OVF read worker thread. This opens the OVF with ovfreader.cpp.
874	*
875	* This runs in two contexts:
876	*
877	* 1) in a first worker thread; in that case, Appliance::Read() called Appliance::readImpl();
878	*
879	* 2) in a second worker thread; in that case, Appliance::Read() called Appliance::readImpl(), which
880	* called Appliance::readS3(), which called Appliance::readImpl(), which then called this.
881	*
882	* @param pTask
883	* @return
884	*/
885	HRESULT Appliance::i_readFS(TaskOVF *pTask)
886	{
887	LogFlowFuncEnter();
888	LogFlowFunc(("Appliance %p\n", this));
889
890	AutoCaller autoCaller(this);
891	if (FAILED(autoCaller.rc())) return autoCaller.rc();
892
893	AutoWriteLock appLock(this COMMA_LOCKVAL_SRC_POS);
894
895	HRESULT rc = S_OK;
896
897	if (pTask->locInfo.strPath.endsWith(".ovf", Utf8Str::CaseInsensitive))
898	rc = i_readFSOVF(pTask);
899	else
900	rc = i_readFSOVA(pTask);
901
902	LogFlowFunc(("rc=%Rhrc\n", rc));
903	LogFlowFuncLeave();
904
905	return rc;
906	}
907
908	HRESULT Appliance::i_readFSOVF(TaskOVF *pTask)
909	{
910	LogFlowFuncEnter();
911
912	HRESULT rc = S_OK;
913	int vrc = VINF_SUCCESS;
914
915	PVDINTERFACEIO pShaIo = 0;
916	PVDINTERFACEIO pFileIo = 0;
917	do
918	{
919	try
920	{
921	/* Create the necessary file access interfaces. */
922	pFileIo = FileCreateInterface();
923	if (!pFileIo)
924	{
925	rc = E_OUTOFMEMORY;
926	break;
927	}
928
929	Utf8Str strMfFile = Utf8Str(pTask->locInfo.strPath).stripSuffix().append(".mf");
930
931	SHASTORAGE storage;
932	RT_ZERO(storage);
933
934	if (RTFileExists(strMfFile.c_str()))
935	{
936	pShaIo = ShaCreateInterface();
937	if (!pShaIo)
938	{
939	rc = E_OUTOFMEMORY;
940	break;
941	}
942
943	//read the manifest file and find a type of used digest
944	RTFILE pFile = NULL;
945	vrc = RTFileOpen(&pFile, strMfFile.c_str(), RTFILE_O_OPEN \| RTFILE_O_READ \| RTFILE_O_DENY_NONE);
946	if (RT_SUCCESS(vrc) && pFile != NULL)
947	{
948	uint64_t cbFile = 0;
949	uint64_t maxFileSize = _1M;
950	size_t cbRead = 0;
951	void pBuf; /* @todo r=bird: You leak this buffer! throwing stuff is evil. */
952
953	vrc = RTFileGetSize(pFile, &cbFile);
954	if (cbFile > maxFileSize)
955	throw setError(VBOX_E_FILE_ERROR,
956	tr("Size of the manifest file '%s' is bigger than 1Mb. Check it, please."),
957	RTPathFilename(strMfFile.c_str()));
958
959	if (RT_SUCCESS(vrc))
960	pBuf = RTMemAllocZ(cbFile);
961	else
962	throw setError(VBOX_E_FILE_ERROR,
963	tr("Could not get size of the manifest file '%s' "),
964	RTPathFilename(strMfFile.c_str()));
965
966	vrc = RTFileRead(pFile, pBuf, cbFile, &cbRead);
967
968	if (RT_FAILURE(vrc))
969	{
970	if (pBuf)
971	RTMemFree(pBuf);
972	throw setError(VBOX_E_FILE_ERROR,
973	tr("Could not read the manifest file '%s' (%Rrc)"),
974	RTPathFilename(strMfFile.c_str()), vrc);
975	}
976
977	RTFileClose(pFile);
978
979	RTDIGESTTYPE digestType;
980	vrc = RTManifestVerifyDigestType(pBuf, cbRead, &digestType);
981
982	if (pBuf)
983	RTMemFree(pBuf);
984
985	if (RT_FAILURE(vrc))
986	{
987	throw setError(VBOX_E_FILE_ERROR,
988	tr("Could not verify supported digest types in the manifest file '%s' (%Rrc)"),
989	RTPathFilename(strMfFile.c_str()), vrc);
990	}
991
992	storage.fCreateDigest = true;
993
994	if (digestType == RTDIGESTTYPE_SHA256)
995	{
996	storage.fSha256 = true;
997	}
998
999	Utf8Str name = i_applianceIOName(applianceIOFile);
1000
1001	vrc = VDInterfaceAdd(&pFileIo->Core, name.c_str(),
1002	VDINTERFACETYPE_IO, 0, sizeof(VDINTERFACEIO),
1003	&storage.pVDImageIfaces);
1004	if (RT_FAILURE(vrc))
1005	throw setError(VBOX_E_IPRT_ERROR, "Creation of the VD interface failed (%Rrc)", vrc);
1006
1007	rc = i_readFSImpl(pTask, pTask->locInfo.strPath, pShaIo, &storage);
1008	if (FAILED(rc))
1009	break;
1010	}
1011	else
1012	{
1013	throw setError(VBOX_E_FILE_ERROR,
1014	tr("Could not open the manifest file '%s' (%Rrc)"),
1015	RTPathFilename(strMfFile.c_str()), vrc);
1016	}
1017	}
1018	else
1019	{
1020	storage.fCreateDigest = false;
1021	rc = i_readFSImpl(pTask, pTask->locInfo.strPath, pFileIo, &storage);
1022	if (FAILED(rc))
1023	break;
1024	}
1025	}
1026	catch (HRESULT rc2)
1027	{
1028	rc = rc2;
1029	}
1030
1031	}while (0);
1032
1033	/* Cleanup */
1034	if (pShaIo)
1035	RTMemFree(pShaIo);
1036	if (pFileIo)
1037	RTMemFree(pFileIo);
1038
1039	LogFlowFunc(("rc=%Rhrc\n", rc));
1040	LogFlowFuncLeave();
1041
1042	return rc;
1043	}
1044
1045	HRESULT Appliance::i_readFSOVA(TaskOVF *pTask)
1046	{
1047	LogFlowFuncEnter();
1048
1049	/*
1050	* Open the tar file and get a VD I/O interface for it.
1051	*/
1052	HRESULT hrc;
1053	PFSSRDONLYINTERFACEIO pTarIo;
1054	int vrc = fssRdOnlyCreateInterfaceForTarFile(pTask->locInfo.strPath.c_str(), &pTarIo);
1055	if (RT_SUCCESS(vrc))
1056	{
1057	/*
1058	* Check that the first file is has an .ovf suffix.
1059	*/
1060	const char *pszName;
1061	vrc = fssRdOnlyGetCurrentName(pTarIo, &pszName);
1062	if (RT_SUCCESS(vrc))
1063	{
1064	size_t cchName = strlen(pszName);
1065	if ( cchName >= sizeof(".ovf")
1066	&& RTStrICmp(&pszName[cchName - sizeof(".ovf") + 1], ".ovf") == 0)
1067	{
1068	/*
1069	* Stack the rest of the expected VD I/O stuff.
1070	*/
1071	PVDINTERFACEIO pShaIo = ShaCreateInterface();
1072	if (pShaIo)
1073	{
1074	Utf8Str IoName = i_applianceIOName(applianceIOTar);
1075	SHASTORAGE ShaStorage;
1076	RT_ZERO(ShaStorage);
1077	vrc = VDInterfaceAdd((PVDINTERFACE)pTarIo, IoName.c_str(),
1078	VDINTERFACETYPE_IO, pTarIo, sizeof(VDINTERFACEIO),
1079	&ShaStorage.pVDImageIfaces);
1080	if (RT_SUCCESS(vrc))
1081	/*
1082	* Read and parse the OVF.
1083	*/
1084	hrc = i_readFSImpl(pTask, pszName, pShaIo, &ShaStorage);
1085	else
1086	hrc = setError(VBOX_E_IPRT_ERROR, "Creation of the VD interface failed (%Rrc)", vrc);
1087	RTMemFree(pShaIo);
1088	}
1089	else
1090	hrc = E_OUTOFMEMORY;
1091	}
1092	else
1093	hrc = setError(VBOX_E_FILE_ERROR,
1094	tr("First file in the OVA package must have the extension 'ovf'. But the file '%s' has a different extension."),
1095	pszName);
1096	}
1097	else
1098	hrc = setError(VBOX_E_FILE_ERROR, tr("Error reading OVA file '%s' (%Rrc)"), pTask->locInfo.strPath.c_str(), vrc);
1099	fssRdOnlyDestroyInterface(pTarIo);
1100	}
1101	else
1102	hrc = setError(VBOX_E_FILE_ERROR, tr("Could not open the OVA file '%s' (%Rrc)"), pTask->locInfo.strPath.c_str(), vrc);
1103
1104	LogFlowFunc(("rc=%Rhrc\n", hrc));
1105	LogFlowFuncLeave();
1106	return hrc;
1107	}
1108
1109	HRESULT Appliance::i_readFSImpl(TaskOVF *pTask, const RTCString &strFilename, PVDINTERFACEIO pIfIo, PSHASTORAGE pStorage)
1110	{
1111	LogFlowFuncEnter();
1112
1113	HRESULT rc = S_OK;
1114
1115	pStorage->fCreateDigest = true;
1116
1117	void *pvTmpBuf = 0;
1118	try
1119	{
1120	/* Read the OVF into a memory buffer */
1121	size_t cbSize = 0;
1122	int vrc = readFileIntoBuffer(strFilename.c_str(), &pvTmpBuf, &cbSize, pIfIo, pStorage);
1123	if (RT_FAILURE(vrc)
1124	\|\| !pvTmpBuf)
1125	throw setError(VBOX_E_FILE_ERROR,
1126	tr("Could not read OVF file '%s' (%Rrc)"),
1127	RTPathFilename(strFilename.c_str()), vrc);
1128
1129	/* Read & parse the XML structure of the OVF file */
1130	m->pReader = new ovf::OVFReader(pvTmpBuf, cbSize, pTask->locInfo.strPath);
1131
1132	if (m->pReader->m_envelopeData.getOVFVersion() == ovf::OVFVersion_2_0)
1133	{
1134	m->fSha256 = true;
1135
1136	uint8_t digest[RTSHA256_HASH_SIZE];
1137	size_t cchDigest = RTSHA256_DIGEST_LEN;
1138	char *pszDigest;
1139
1140	RTSha256(pvTmpBuf, cbSize, &digest[0]);
1141
1142	vrc = RTStrAllocEx(&pszDigest, cchDigest + 1);
1143	if (RT_FAILURE(vrc))
1144	throw setError(E_OUTOFMEMORY, tr("Could not allocate string for SHA256 digest (%Rrc)"), vrc);
1145
1146	vrc = RTSha256ToString(digest, pszDigest, cchDigest + 1);
1147	if (RT_SUCCESS(vrc))
1148	/* Copy the SHA256 sum of the OVF file for later validation */
1149	m->strOVFSHADigest = pszDigest;
1150	else
1151	throw setError(VBOX_E_FILE_ERROR, tr("Converting SHA256 digest to a string was failed (%Rrc)"), vrc);
1152
1153	RTStrFree(pszDigest);
1154
1155	}
1156	else
1157	{
1158	m->fSha256 = false;
1159	/* Copy the SHA1 sum of the OVF file for later validation */
1160	m->strOVFSHADigest = pStorage->strDigest;
1161	}
1162
1163	}
1164	catch (RTCError &x) // includes all XML exceptions
1165	{
1166	rc = setError(VBOX_E_FILE_ERROR,
1167	x.what());
1168	}
1169	catch (HRESULT aRC)
1170	{
1171	rc = aRC;
1172	}
1173
1174	/* Cleanup */
1175	if (pvTmpBuf)
1176	RTMemFree(pvTmpBuf);
1177
1178	LogFlowFunc(("rc=%Rhrc\n", rc));
1179	LogFlowFuncLeave();
1180
1181	return rc;
1182	}
1183
1184	#ifdef VBOX_WITH_S3
1185	/**
1186	* Worker code for reading OVF from the cloud. This is called from Appliance::taskThreadImportOrExport()
1187	* in S3 mode and therefore runs on the OVF read worker thread. This then starts a second worker
1188	* thread to create temporary files (see Appliance::readFS()).
1189	*
1190	* @param pTask
1191	* @return
1192	*/
1193	HRESULT Appliance::i_readS3(TaskOVF *pTask)
1194	{
1195	LogFlowFuncEnter();
1196	LogFlowFunc(("Appliance %p\n", this));
1197
1198	AutoCaller autoCaller(this);
1199	if (FAILED(autoCaller.rc())) return autoCaller.rc();
1200
1201	AutoWriteLock appLock(this COMMA_LOCKVAL_SRC_POS);
1202
1203	HRESULT rc = S_OK;
1204	int vrc = VINF_SUCCESS;
1205	RTS3 hS3 = NIL_RTS3;
1206	char szOSTmpDir[RTPATH_MAX];
1207	RTPathTemp(szOSTmpDir, sizeof(szOSTmpDir));
1208	/* The template for the temporary directory created below */
1209	char *pszTmpDir = RTPathJoinA(szOSTmpDir, "vbox-ovf-XXXXXX");
1210	list< pair<Utf8Str, ULONG> > filesList;
1211	Utf8Str strTmpOvf;
1212
1213	try
1214	{
1215	/* Extract the bucket */
1216	Utf8Str tmpPath = pTask->locInfo.strPath;
1217	Utf8Str bucket;
1218	i_parseBucket(tmpPath, bucket);
1219
1220	/* We need a temporary directory which we can put the OVF file & all
1221	* disk images in */
1222	vrc = RTDirCreateTemp(pszTmpDir, 0700);
1223	if (RT_FAILURE(vrc))
1224	throw setError(VBOX_E_FILE_ERROR,
1225	tr("Cannot create temporary directory '%s'"), pszTmpDir);
1226
1227	/* The temporary name of the target OVF file */
1228	strTmpOvf = Utf8StrFmt("%s/%s", pszTmpDir, RTPathFilename(tmpPath.c_str()));
1229
1230	/* Next we have to download the OVF */
1231	vrc = RTS3Create(&hS3,
1232	pTask->locInfo.strUsername.c_str(),
1233	pTask->locInfo.strPassword.c_str(),
1234	pTask->locInfo.strHostname.c_str(),
1235	"virtualbox-agent/" VBOX_VERSION_STRING);
1236	if (RT_FAILURE(vrc))
1237	throw setError(VBOX_E_IPRT_ERROR,
1238	tr("Cannot create S3 service handler"));
1239	RTS3SetProgressCallback(hS3, pTask->updateProgress, &pTask);
1240
1241	/* Get it */
1242	char *pszFilename = RTPathFilename(strTmpOvf.c_str());
1243	vrc = RTS3GetKey(hS3, bucket.c_str(), pszFilename, strTmpOvf.c_str());
1244	if (RT_FAILURE(vrc))
1245	{
1246	if (vrc == VERR_S3_CANCELED)
1247	throw S_OK; /* todo: !!!!!!!!!!!!! */
1248	else if (vrc == VERR_S3_ACCESS_DENIED)
1249	throw setError(E_ACCESSDENIED,
1250	tr("Cannot download file '%s' from S3 storage server (Access denied). Make sure that "
1251	"your credentials are right. "
1252	"Also check that your host clock is properly synced"),
1253	pszFilename);
1254	else if (vrc == VERR_S3_NOT_FOUND)
1255	throw setError(VBOX_E_FILE_ERROR,
1256	tr("Cannot download file '%s' from S3 storage server (File not found)"), pszFilename);
1257	else
1258	throw setError(VBOX_E_IPRT_ERROR,
1259	tr("Cannot download file '%s' from S3 storage server (%Rrc)"), pszFilename, vrc);
1260	}
1261
1262	/* Close the connection early */
1263	RTS3Destroy(hS3);
1264	hS3 = NIL_RTS3;
1265
1266	pTask->pProgress->SetNextOperation(Bstr(tr("Reading")).raw(), 1);
1267
1268	/* Prepare the temporary reading of the OVF */
1269	ComObjPtr<Progress> progress;
1270	LocationInfo li;
1271	li.strPath = strTmpOvf;
1272	/* Start the reading from the fs */
1273	rc = i_readImpl(li, progress);
1274	if (FAILED(rc)) throw rc;
1275
1276	/* Unlock the appliance for the reading thread */
1277	appLock.release();
1278	/* Wait until the reading is done, but report the progress back to the
1279	caller */
1280	ComPtr<IProgress> progressInt(progress);
1281	i_waitForAsyncProgress(pTask->pProgress, progressInt); /* Any errors will be thrown */
1282
1283	/* Again lock the appliance for the next steps */
1284	appLock.acquire();
1285	}
1286	catch(HRESULT aRC)
1287	{
1288	rc = aRC;
1289	}
1290	/* Cleanup */
1291	RTS3Destroy(hS3);
1292	/* Delete all files which where temporary created */
1293	if (RTPathExists(strTmpOvf.c_str()))
1294	{
1295	vrc = RTFileDelete(strTmpOvf.c_str());
1296	if (RT_FAILURE(vrc))
1297	rc = setError(VBOX_E_FILE_ERROR,
1298	tr("Cannot delete file '%s' (%Rrc)"), strTmpOvf.c_str(), vrc);
1299	}
1300	/* Delete the temporary directory */
1301	if (RTPathExists(pszTmpDir))
1302	{
1303	vrc = RTDirRemove(pszTmpDir);
1304	if (RT_FAILURE(vrc))
1305	rc = setError(VBOX_E_FILE_ERROR,
1306	tr("Cannot delete temporary directory '%s' (%Rrc)"), pszTmpDir, vrc);
1307	}
1308	if (pszTmpDir)
1309	RTStrFree(pszTmpDir);
1310
1311	LogFlowFunc(("rc=%Rhrc\n", rc));
1312	LogFlowFuncLeave();
1313
1314	return rc;
1315	}
1316	#endif /* VBOX_WITH_S3 */
1317
1318	/*******************************************************************************
1319	* Import stuff
1320	******************************************************************************/
1321
1322	/**
1323	* Implementation for importing OVF data into VirtualBox. This starts a new thread which will call
1324	* Appliance::taskThreadImportOrExport().
1325	*
1326	* This creates one or more new machines according to the VirtualSystemScription instances created by
1327	* Appliance::Interpret().
1328	*
1329	* This is in a separate private method because it is used from two locations:
1330	*
1331	* 1) from the public Appliance::ImportMachines().
1332	* 2) from Appliance::i_importS3(), which got called from a previous instance of Appliance::taskThreadImportOrExport().
1333	*
1334	* @param aLocInfo
1335	* @param aProgress
1336	* @return
1337	*/
1338	HRESULT Appliance::i_importImpl(const LocationInfo &locInfo,
1339	ComObjPtr<Progress> &progress)
1340	{
1341	HRESULT rc = S_OK;
1342
1343	SetUpProgressMode mode;
1344	if (locInfo.storageType == VFSType_File)
1345	mode = ImportFile;
1346	else
1347	mode = ImportS3;
1348
1349	rc = i_setUpProgress(progress,
1350	BstrFmt(tr("Importing appliance '%s'"), locInfo.strPath.c_str()),
1351	mode);
1352	if (FAILED(rc)) throw rc;
1353
1354	/* Initialize our worker task */
1355	std::auto_ptr<TaskOVF> task(new TaskOVF(this, TaskOVF::Import, locInfo, progress));
1356
1357	rc = task->startThread();
1358	if (FAILED(rc)) throw rc;
1359
1360	/* Don't destruct on success */
1361	task.release();
1362
1363	return rc;
1364	}
1365
1366	/**
1367	* Actual worker code for importing OVF data into VirtualBox.
1368	*
1369	* This is called from Appliance::taskThreadImportOrExport() and therefore runs
1370	* on the OVF import worker thread. This creates one or more new machines
1371	* according to the VirtualSystemScription instances created by
1372	* Appliance::Interpret().
1373	*
1374	* This runs in three contexts:
1375	*
1376	* 1) in a first worker thread; in that case, Appliance::ImportMachines() called Appliance::i_importImpl();
1377	*
1378	* 2) in a second worker thread; in that case, Appliance::ImportMachines() called Appliance::i_importImpl(), which
1379	* called Appliance::i_i_importFSOVA(), which called Appliance::i_importImpl(), which then called this again.
1380	*
1381	* 3) in a second worker thread; in that case, Appliance::ImportMachines() called Appliance::i_importImpl(), which
1382	* called Appliance::i_importS3(), which called Appliance::i_importImpl(), which then called this again.
1383	*
1384	* @param pTask The OVF task data.
1385	* @return COM status code.
1386	*/
1387	HRESULT Appliance::i_importFS(TaskOVF *pTask)
1388	{
1389
1390	LogFlowFuncEnter();
1391	LogFlowFunc(("Appliance %p\n", this));
1392
1393	/* Change the appliance state so we can safely leave the lock while doing
1394	* time-consuming disk imports; also the below method calls do all kinds of
1395	* locking which conflicts with the appliance object lock. */
1396	AutoWriteLock writeLock(this COMMA_LOCKVAL_SRC_POS);
1397	/* Check if the appliance is currently busy. */
1398	if (!i_isApplianceIdle())
1399	return E_ACCESSDENIED;
1400	/* Set the internal state to importing. */
1401	m->state = Data::ApplianceImporting;
1402
1403	HRESULT rc = S_OK;
1404
1405	/* Clear the list of imported machines, if any */
1406	m->llGuidsMachinesCreated.clear();
1407
1408	if (pTask->locInfo.strPath.endsWith(".ovf", Utf8Str::CaseInsensitive))
1409	rc = i_importFSOVF(pTask, writeLock);
1410	else
1411	rc = i_importFSOVA(pTask, writeLock);
1412
1413	if (FAILED(rc))
1414	{
1415	/* With _whatever_ error we've had, do a complete roll-back of
1416	* machines and disks we've created */
1417	writeLock.release();
1418	ErrorInfoKeeper eik;
1419	for (list<Guid>::iterator itID = m->llGuidsMachinesCreated.begin();
1420	itID != m->llGuidsMachinesCreated.end();
1421	++itID)
1422	{
1423	Guid guid = *itID;
1424	Bstr bstrGuid = guid.toUtf16();
1425	ComPtr<IMachine> failedMachine;
1426	HRESULT rc2 = mVirtualBox->FindMachine(bstrGuid.raw(), failedMachine.asOutParam());
1427	if (SUCCEEDED(rc2))
1428	{
1429	SafeIfaceArray<IMedium> aMedia;
1430	rc2 = failedMachine->Unregister(CleanupMode_DetachAllReturnHardDisksOnly, ComSafeArrayAsOutParam(aMedia));
1431	ComPtr<IProgress> pProgress2;
1432	rc2 = failedMachine->DeleteConfig(ComSafeArrayAsInParam(aMedia), pProgress2.asOutParam());
1433	pProgress2->WaitForCompletion(-1);
1434	}
1435	}
1436	writeLock.acquire();
1437	}
1438
1439	/* Reset the state so others can call methods again */
1440	m->state = Data::ApplianceIdle;
1441
1442	LogFlowFunc(("rc=%Rhrc\n", rc));
1443	LogFlowFuncLeave();
1444
1445	return rc;
1446	}
1447
1448	HRESULT Appliance::i_importFSOVF(TaskOVF *pTask, AutoWriteLockBase& writeLock)
1449	{
1450	LogFlowFuncEnter();
1451
1452	HRESULT rc = S_OK;
1453
1454	PVDINTERFACEIO pShaIo = NULL;
1455	PVDINTERFACEIO pFileIo = NULL;
1456	void *pvMfBuf = NULL;
1457	void *pvCertBuf = NULL;
1458	writeLock.release();
1459
1460	/* Create the import stack for the rollback on errors. */
1461	ImportStack stack(pTask->locInfo, m->pReader->m_mapDisks, pTask->pProgress);
1462
1463	try
1464	{
1465	/* Create the necessary file access interfaces. */
1466	pFileIo = FileCreateInterface();
1467	if (!pFileIo)
1468	throw setError(E_OUTOFMEMORY);
1469
1470	Utf8Str strMfFile = Utf8Str(pTask->locInfo.strPath).stripSuffix().append(".mf");
1471
1472	SHASTORAGE storage;
1473	RT_ZERO(storage);
1474
1475	Utf8Str name = i_applianceIOName(applianceIOFile);
1476
1477	int vrc = VDInterfaceAdd(&pFileIo->Core, name.c_str(),
1478	VDINTERFACETYPE_IO, 0, sizeof(VDINTERFACEIO),
1479	&storage.pVDImageIfaces);
1480	if (RT_FAILURE(vrc))
1481	throw setError(VBOX_E_IPRT_ERROR, "Creation of the VD interface failed (%Rrc)", vrc);
1482
1483	if (RTFileExists(strMfFile.c_str()))
1484	{
1485	pShaIo = ShaCreateInterface();
1486	if (!pShaIo)
1487	throw setError(E_OUTOFMEMORY);
1488
1489	Utf8Str nameSha = i_applianceIOName(applianceIOSha);
1490	/* Fill out interface descriptor. */
1491	pShaIo->Core.u32Magic = VDINTERFACE_MAGIC;
1492	pShaIo->Core.cbSize = sizeof(VDINTERFACEIO);
1493	pShaIo->Core.pszInterfaceName = nameSha.c_str();
1494	pShaIo->Core.enmInterface = VDINTERFACETYPE_IO;
1495	pShaIo->Core.pvUser = &storage;
1496	pShaIo->Core.pNext = NULL;
1497
1498	storage.fCreateDigest = true;
1499
1500	size_t cbMfFile = 0;
1501
1502	/* Now import the appliance. */
1503	i_importMachines(stack, pShaIo, &storage);
1504	/* Read & verify the manifest file. */
1505	/* Add the ovf file to the digest list. */
1506	stack.llSrcDisksDigest.push_front(STRPAIR(pTask->locInfo.strPath, m->strOVFSHADigest));
1507	rc = i_readFileToBuf(strMfFile, &pvMfBuf, &cbMfFile, true, pShaIo, &storage);
1508	if (FAILED(rc)) throw rc;
1509	rc = i_verifyManifestFile(strMfFile, stack, pvMfBuf, cbMfFile);
1510	if (FAILED(rc)) throw rc;
1511
1512	size_t cbCertFile = 0;
1513
1514	/* Save the SHA digest of the manifest file for the next validation */
1515	Utf8Str manifestShaDigest = storage.strDigest;
1516
1517	Utf8Str strCertFile = Utf8Str(pTask->locInfo.strPath).stripSuffix().append(".cert");
1518	if (RTFileExists(strCertFile.c_str()))
1519	{
1520	rc = i_readFileToBuf(strCertFile, &pvCertBuf, &cbCertFile, false, pShaIo, &storage);
1521	if (FAILED(rc)) throw rc;
1522
1523	/* verify Certificate */
1524	rc = i_verifyCertificateFile(pvCertBuf, cbCertFile, &storage);
1525	if (FAILED(rc)) throw rc;
1526	}
1527	}
1528	else
1529	{
1530	storage.fCreateDigest = false;
1531	i_importMachines(stack, pFileIo, &storage);
1532	}
1533	}
1534	catch (HRESULT rc2)
1535	{
1536	rc = rc2;
1537	/*
1538	* Restoring original UUID from OVF description file.
1539	* During import VBox creates new UUIDs for imported images and
1540	* assigns them to the images. In case of failure we have to restore
1541	* the original UUIDs because those new UUIDs are obsolete now and
1542	* won't be used anymore.
1543	*/
1544	{
1545	ErrorInfoKeeper eik; /* paranoia */
1546	list< ComObjPtr<VirtualSystemDescription> >::const_iterator itvsd;
1547	/* Iterate through all virtual systems of that appliance */
1548	for (itvsd = m->virtualSystemDescriptions.begin();
1549	itvsd != m->virtualSystemDescriptions.end();
1550	++itvsd)
1551	{
1552	ComObjPtr<VirtualSystemDescription> vsdescThis = (*itvsd);
1553	settings::MachineConfigFile *pConfig = vsdescThis->m->pConfig;
1554	if(vsdescThis->m->pConfig!=NULL)
1555	stack.restoreOriginalUUIDOfAttachedDevice(pConfig);
1556	}
1557	}
1558	}
1559	writeLock.acquire();
1560
1561	/* Cleanup */
1562	if (pvMfBuf)
1563	RTMemFree(pvMfBuf);
1564	if (pvCertBuf)
1565	RTMemFree(pvCertBuf);
1566	if (pShaIo)
1567	RTMemFree(pShaIo);
1568	if (pFileIo)
1569	RTMemFree(pFileIo);
1570
1571	LogFlowFunc(("rc=%Rhrc\n", rc));
1572	LogFlowFuncLeave();
1573
1574	return rc;
1575	}
1576
1577	HRESULT Appliance::i_importFSOVA(TaskOVF *pTask, AutoWriteLockBase& writeLock)
1578	{
1579	LogFlowFuncEnter();
1580	HRESULT rc = S_OK;
1581
1582	/*
1583	* Open the OVA (TAR) file.
1584	*/
1585	PFSSRDONLYINTERFACEIO pTarIo;
1586	int vrc = fssRdOnlyCreateInterfaceForTarFile(pTask->locInfo.strPath.c_str(), &pTarIo);
1587	if (RT_FAILURE(vrc))
1588	return setError(VBOX_E_FILE_ERROR,
1589	tr("Could not open OVA file '%s' (%Rrc)"),
1590	pTask->locInfo.strPath.c_str(), vrc);
1591
1592
1593	PVDINTERFACEIO pShaIo = 0;
1594	void *pvMfBuf = NULL;
1595	void *pvCertBuf = NULL;
1596	Utf8Str OVFfilename;
1597
1598	writeLock.release();
1599
1600	/* Create the import stack for the rollback on errors. */
1601	ImportStack stack(pTask->locInfo, m->pReader->m_mapDisks, pTask->pProgress);
1602
1603	try
1604	{
1605	/* Create the necessary file access interfaces. */
1606	pShaIo = ShaCreateInterface();
1607	if (!pShaIo)
1608	throw setError(E_OUTOFMEMORY);
1609
1610	Utf8Str nameTar = i_applianceIOName(applianceIOTar);
1611	SHASTORAGE storage;
1612	RT_ZERO(storage);
1613	vrc = VDInterfaceAdd((PVDINTERFACE)pTarIo, nameTar.c_str(),
1614	VDINTERFACETYPE_IO, pTarIo, sizeof(VDINTERFACEIO),
1615	&storage.pVDImageIfaces);
1616	if (RT_FAILURE(vrc))
1617	throw setError(VBOX_E_IPRT_ERROR,
1618	tr("Creation of the VD interface failed (%Rrc)"), vrc);
1619
1620	/* Fill out interface descriptor. */
1621	Utf8Str nameSha = i_applianceIOName(applianceIOSha);
1622	pShaIo->Core.u32Magic = VDINTERFACE_MAGIC;
1623	pShaIo->Core.cbSize = sizeof(VDINTERFACEIO);
1624	pShaIo->Core.pszInterfaceName = nameSha.c_str();
1625	pShaIo->Core.enmInterface = VDINTERFACETYPE_IO;
1626	pShaIo->Core.pvUser = &storage;
1627	pShaIo->Core.pNext = NULL;
1628
1629	/*
1630	* File #1 - the .ova file.
1631	*
1632	* Read the name of the first file. This is how all internal files
1633	* are named.
1634	*/
1635	const char *pszFilename;
1636	vrc = fssRdOnlyGetCurrentName(pTarIo, &pszFilename);
1637	if (RT_FAILURE(vrc))
1638	throw setError(VBOX_E_IPRT_ERROR,
1639	tr("Getting the OVF file within the archive failed (%Rrc)"), vrc);
1640	if (vrc == VINF_TAR_DIR_PATH)
1641	throw setError(VBOX_E_FILE_ERROR,
1642	tr("Empty directory folder (%s) isn't allowed in the OVA package (%Rrc)"),
1643	pszFilename, vrc);
1644
1645	/* save original OVF filename */
1646	OVFfilename = pszFilename;
1647	Utf8Str strMfFile = (Utf8Str(pszFilename)).stripSuffix().append(".mf");
1648	Utf8Str strCertFile = (Utf8Str(pszFilename)).stripSuffix().append(".cert");
1649
1650	/* Skip the OVF file, cause this was read in IAppliance::Read already. */
1651	vrc = fssRdOnlySkipCurrent(pTarIo);
1652	if (RT_SUCCESS(vrc))
1653	vrc = fssRdOnlyGetCurrentName(pTarIo, &pszFilename);
1654	if ( RT_FAILURE(vrc)
1655	&& vrc != VERR_EOF)
1656	throw setError(VBOX_E_IPRT_ERROR, tr("Seeking within the archive failed (%Rrc)"), vrc);
1657
1658	PVDINTERFACEIO pCallbacks = pShaIo;
1659	PSHASTORAGE pStorage = &storage;
1660
1661	/* We always need to create the digest, cause we don't know if there
1662	* is a manifest file in the stream. */
1663	pStorage->fCreateDigest = true;
1664
1665	/*
1666	* File #2 - the manifest file (.mf), optional.
1667	*
1668	* Note: This isn't fatal if the file is not found. The standard
1669	* defines 3 cases:
1670	* 1. no manifest file
1671	* 2. manifest file after the OVF file
1672	* 3. manifest file after all disk files
1673	*
1674	* If we want streaming capabilities, we can't check if it is there by
1675	* searching for it. We have to try to open it on all possible places.
1676	* If it fails here, we will try it again after all disks where read.
1677	*/
1678	size_t cbMfFile = 0;
1679	rc = i_readTarFileToBuf(pTarIo, strMfFile, &pvMfBuf, &cbMfFile, true, pCallbacks, pStorage);
1680	if (FAILED(rc))
1681	throw rc;
1682
1683	/*
1684	* File #3 - certificate file (.cer), optional.
1685	*
1686	* Logic is the same as with manifest file. This only makes sense if
1687	* there is a manifest file.
1688	*/
1689	size_t cbCertFile = 0;
1690	vrc = fssRdOnlyGetCurrentName(pTarIo, &pszFilename);
1691	if (RT_SUCCESS(vrc))
1692	{
1693	if (pvMfBuf)
1694	{
1695	if (strCertFile.compare(pszFilename) == 0)
1696	{
1697	rc = i_readTarFileToBuf(pTarIo, strCertFile, &pvCertBuf, &cbCertFile, false, pCallbacks, pStorage);
1698	if (FAILED(rc)) throw rc;
1699
1700	if (pvCertBuf)
1701	{
1702	/* verify the certificate */
1703	rc = i_verifyCertificateFile(pvCertBuf, cbCertFile, pStorage);
1704	if (FAILED(rc)) throw rc;
1705	}
1706	}
1707	}
1708	}
1709
1710	/*
1711	* Now import the appliance.
1712	*/
1713	i_importMachines(stack, pCallbacks, pStorage);
1714
1715	/*
1716	* The certificate and mainifest files may alternatively be stored
1717	* after the disk files, so look again if we didn't find them already.
1718	*/
1719	if (!pvMfBuf)
1720	{
1721	/*
1722	* File #N-1 - The manifest file, optional.
1723	*/
1724	rc = i_readTarFileToBuf(pTarIo, strMfFile, &pvMfBuf, &cbMfFile, true, pCallbacks, pStorage);
1725	if (FAILED(rc)) throw rc;
1726
1727	/* If we were able to read a manifest file we can check it now. */
1728	if (pvMfBuf)
1729	{
1730	/* Add the ovf file to the digest list. */
1731	stack.llSrcDisksDigest.push_front(STRPAIR(OVFfilename, m->strOVFSHADigest));
1732	rc = i_verifyManifestFile(strMfFile, stack, pvMfBuf, cbMfFile);
1733	if (FAILED(rc)) throw rc;
1734
1735	/*
1736	* File #N - The certificate file, optional.
1737	* (Requires mainfest, as mention before.)
1738	*/
1739	vrc = fssRdOnlyGetCurrentName(pTarIo, &pszFilename);
1740	if (RT_SUCCESS(vrc))
1741	{
1742	if (strCertFile.compare(pszFilename) == 0)
1743	{
1744	rc = i_readTarFileToBuf(pTarIo, strCertFile, &pvCertBuf, &cbCertFile, false, pCallbacks, pStorage);
1745	if (FAILED(rc)) throw rc;
1746
1747	if (pvCertBuf)
1748	{
1749	/* verify the certificate */
1750	rc = i_verifyCertificateFile(pvCertBuf, cbCertFile, pStorage);
1751	if (FAILED(rc)) throw rc;
1752	}
1753	}
1754	}
1755	}
1756	}
1757	/** @todo else: Verify the manifest! */
1758	}
1759	catch (HRESULT rc2)
1760	{
1761	rc = rc2;
1762
1763	/*
1764	* Restoring original UUID from OVF description file.
1765	* During import VBox creates new UUIDs for imported images and
1766	* assigns them to the images. In case of failure we have to restore
1767	* the original UUIDs because those new UUIDs are obsolete now and
1768	* won't be used anymore.
1769	*/
1770	ErrorInfoKeeper eik; /* paranoia */
1771	list< ComObjPtr<VirtualSystemDescription> >::const_iterator itvsd;
1772	/* Iterate through all virtual systems of that appliance */
1773	for (itvsd = m->virtualSystemDescriptions.begin();
1774	itvsd != m->virtualSystemDescriptions.end();
1775	++itvsd)
1776	{
1777	ComObjPtr<VirtualSystemDescription> vsdescThis = (*itvsd);
1778	settings::MachineConfigFile *pConfig = vsdescThis->m->pConfig;
1779	if(vsdescThis->m->pConfig!=NULL)
1780	stack.restoreOriginalUUIDOfAttachedDevice(pConfig);
1781	}
1782	}
1783	writeLock.acquire();
1784
1785	/* Cleanup */
1786	fssRdOnlyDestroyInterface(pTarIo);
1787	if (pvMfBuf)
1788	RTMemFree(pvMfBuf);
1789	if (pShaIo)
1790	RTMemFree(pShaIo);
1791	if (pvCertBuf)
1792	RTMemFree(pvCertBuf);
1793
1794	LogFlowFunc(("rc=%Rhrc\n", rc));
1795	LogFlowFuncLeave();
1796
1797	return rc;
1798	}
1799
1800	#ifdef VBOX_WITH_S3
1801	/**
1802	* Worker code for importing OVF from the cloud. This is called from Appliance::taskThreadImportOrExport()
1803	* in S3 mode and therefore runs on the OVF import worker thread. This then starts a second worker
1804	* thread to import from temporary files (see Appliance::i_importFS()).
1805	* @param pTask
1806	* @return
1807	*/
1808	HRESULT Appliance::i_importS3(TaskOVF *pTask)
1809	{
1810	LogFlowFuncEnter();
1811	LogFlowFunc(("Appliance %p\n", this));
1812
1813	AutoWriteLock appLock(this COMMA_LOCKVAL_SRC_POS);
1814
1815	int vrc = VINF_SUCCESS;
1816	RTS3 hS3 = NIL_RTS3;
1817	char szOSTmpDir[RTPATH_MAX];
1818	RTPathTemp(szOSTmpDir, sizeof(szOSTmpDir));
1819	/* The template for the temporary directory created below */
1820	char *pszTmpDir = RTPathJoinA(szOSTmpDir, "vbox-ovf-XXXXXX");
1821	list< pair<Utf8Str, ULONG> > filesList;
1822
1823	HRESULT rc = S_OK;
1824	try
1825	{
1826	/* Extract the bucket */
1827	Utf8Str tmpPath = pTask->locInfo.strPath;
1828	Utf8Str bucket;
1829	i_parseBucket(tmpPath, bucket);
1830
1831	/* We need a temporary directory which we can put the all disk images
1832	* in */
1833	vrc = RTDirCreateTemp(pszTmpDir, 0700);
1834	if (RT_FAILURE(vrc))
1835	throw setError(VBOX_E_FILE_ERROR,
1836	tr("Cannot create temporary directory '%s' (%Rrc)"), pszTmpDir, vrc);
1837
1838	/* Add every disks of every virtual system to an internal list */
1839	list< ComObjPtr<VirtualSystemDescription> >::const_iterator it;
1840	for (it = m->virtualSystemDescriptions.begin();
1841	it != m->virtualSystemDescriptions.end();
1842	++it)
1843	{
1844	ComObjPtr<VirtualSystemDescription> vsdescThis = (*it);
1845	std::list<VirtualSystemDescriptionEntry*> avsdeHDs =
1846	vsdescThis->i_findByType(VirtualSystemDescriptionType_HardDiskImage);
1847	std::list<VirtualSystemDescriptionEntry*>::const_iterator itH;
1848	for (itH = avsdeHDs.begin();
1849	itH != avsdeHDs.end();
1850	++itH)
1851	{
1852	const Utf8Str &strTargetFile = (*itH)->strOvf;
1853	if (!strTargetFile.isEmpty())
1854	{
1855	/* The temporary name of the target disk file */
1856	Utf8StrFmt strTmpDisk("%s/%s", pszTmpDir, RTPathFilename(strTargetFile.c_str()));
1857	filesList.push_back(pair<Utf8Str, ULONG>(strTmpDisk, (*itH)->ulSizeMB));
1858	}
1859	}
1860	}
1861
1862	/* Next we have to download the disk images */
1863	vrc = RTS3Create(&hS3,
1864	pTask->locInfo.strUsername.c_str(),
1865	pTask->locInfo.strPassword.c_str(),
1866	pTask->locInfo.strHostname.c_str(),
1867	"virtualbox-agent/" VBOX_VERSION_STRING);
1868	if (RT_FAILURE(vrc))
1869	throw setError(VBOX_E_IPRT_ERROR,
1870	tr("Cannot create S3 service handler"));
1871	RTS3SetProgressCallback(hS3, pTask->updateProgress, &pTask);
1872
1873	/* Download all files */
1874	for (list< pair<Utf8Str, ULONG> >::const_iterator it1 = filesList.begin(); it1 != filesList.end(); ++it1)
1875	{
1876	const pair<Utf8Str, ULONG> &s = (*it1);
1877	const Utf8Str &strSrcFile = s.first;
1878	/* Construct the source file name */
1879	char *pszFilename = RTPathFilename(strSrcFile.c_str());
1880	/* Advance to the next operation */
1881	if (!pTask->pProgress.isNull())
1882	pTask->pProgress->SetNextOperation(BstrFmt(tr("Downloading file '%s'"), pszFilename).raw(), s.second);
1883
1884	vrc = RTS3GetKey(hS3, bucket.c_str(), pszFilename, strSrcFile.c_str());
1885	if (RT_FAILURE(vrc))
1886	{
1887	if (vrc == VERR_S3_CANCELED)
1888	throw S_OK; /* todo: !!!!!!!!!!!!! */
1889	else if (vrc == VERR_S3_ACCESS_DENIED)
1890	throw setError(E_ACCESSDENIED,
1891	tr("Cannot download file '%s' from S3 storage server (Access denied). "
1892	"Make sure that your credentials are right. Also check that your host clock is "
1893	"properly synced"),
1894	pszFilename);
1895	else if (vrc == VERR_S3_NOT_FOUND)
1896	throw setError(VBOX_E_FILE_ERROR,
1897	tr("Cannot download file '%s' from S3 storage server (File not found)"),
1898	pszFilename);
1899	else
1900	throw setError(VBOX_E_IPRT_ERROR,
1901	tr("Cannot download file '%s' from S3 storage server (%Rrc)"),
1902	pszFilename, vrc);
1903	}
1904	}
1905
1906	/* Provide a OVF file (haven't to exist) so the import routine can
1907	* figure out where the disk images/manifest file are located. */
1908	Utf8StrFmt strTmpOvf("%s/%s", pszTmpDir, RTPathFilename(tmpPath.c_str()));
1909	/* Now check if there is an manifest file. This is optional. */
1910	Utf8Str strManifestFile; //= queryManifestFileName(strTmpOvf);
1911	// Utf8Str strManifestFile = queryManifestFileName(strTmpOvf);
1912	char *pszFilename = RTPathFilename(strManifestFile.c_str());
1913	if (!pTask->pProgress.isNull())
1914	pTask->pProgress->SetNextOperation(BstrFmt(tr("Downloading file '%s'"), pszFilename).raw(), 1);
1915
1916	/* Try to download it. If the error is VERR_S3_NOT_FOUND, it isn't fatal. */
1917	vrc = RTS3GetKey(hS3, bucket.c_str(), pszFilename, strManifestFile.c_str());
1918	if (RT_SUCCESS(vrc))
1919	filesList.push_back(pair<Utf8Str, ULONG>(strManifestFile, 0));
1920	else if (RT_FAILURE(vrc))
1921	{
1922	if (vrc == VERR_S3_CANCELED)
1923	throw S_OK; /* todo: !!!!!!!!!!!!! */
1924	else if (vrc == VERR_S3_NOT_FOUND)
1925	vrc = VINF_SUCCESS; /* Not found is ok */
1926	else if (vrc == VERR_S3_ACCESS_DENIED)
1927	throw setError(E_ACCESSDENIED,
1928	tr("Cannot download file '%s' from S3 storage server (Access denied)."
1929	"Make sure that your credentials are right. "
1930	"Also check that your host clock is properly synced"),
1931	pszFilename);
1932	else
1933	throw setError(VBOX_E_IPRT_ERROR,
1934	tr("Cannot download file '%s' from S3 storage server (%Rrc)"),
1935	pszFilename, vrc);
1936	}
1937
1938	/* Close the connection early */
1939	RTS3Destroy(hS3);
1940	hS3 = NIL_RTS3;
1941
1942	pTask->pProgress->SetNextOperation(BstrFmt(tr("Importing appliance")).raw(), m->ulWeightForXmlOperation);
1943
1944	ComObjPtr<Progress> progress;
1945	/* Import the whole temporary OVF & the disk images */
1946	LocationInfo li;
1947	li.strPath = strTmpOvf;
1948	rc = i_importImpl(li, progress);
1949	if (FAILED(rc)) throw rc;
1950
1951	/* Unlock the appliance for the fs import thread */
1952	appLock.release();
1953	/* Wait until the import is done, but report the progress back to the
1954	caller */
1955	ComPtr<IProgress> progressInt(progress);
1956	i_waitForAsyncProgress(pTask->pProgress, progressInt); /* Any errors will be thrown */
1957
1958	/* Again lock the appliance for the next steps */
1959	appLock.acquire();
1960	}
1961	catch(HRESULT aRC)
1962	{
1963	rc = aRC;
1964	}
1965	/* Cleanup */
1966	RTS3Destroy(hS3);
1967	/* Delete all files which where temporary created */
1968	for (list< pair<Utf8Str, ULONG> >::const_iterator it1 = filesList.begin(); it1 != filesList.end(); ++it1)
1969	{
1970	const char pszFilePath = (it1).first.c_str();
1971	if (RTPathExists(pszFilePath))
1972	{
1973	vrc = RTFileDelete(pszFilePath);
1974	if (RT_FAILURE(vrc))
1975	rc = setError(VBOX_E_FILE_ERROR,
1976	tr("Cannot delete file '%s' (%Rrc)"), pszFilePath, vrc);
1977	}
1978	}
1979	/* Delete the temporary directory */
1980	if (RTPathExists(pszTmpDir))
1981	{
1982	vrc = RTDirRemove(pszTmpDir);
1983	if (RT_FAILURE(vrc))
1984	rc = setError(VBOX_E_FILE_ERROR,
1985	tr("Cannot delete temporary directory '%s' (%Rrc)"), pszTmpDir, vrc);
1986	}
1987	if (pszTmpDir)
1988	RTStrFree(pszTmpDir);
1989
1990	LogFlowFunc(("rc=%Rhrc\n", rc));
1991	LogFlowFuncLeave();
1992
1993	return rc;
1994	}
1995	#endif /* VBOX_WITH_S3 */
1996
1997	HRESULT Appliance::i_readFileToBuf(const Utf8Str &strFile,
1998	void **ppvBuf,
1999	size_t *pcbSize,
2000	bool fCreateDigest,
2001	PVDINTERFACEIO pCallbacks,
2002	PSHASTORAGE pStorage)
2003	{
2004	HRESULT rc = S_OK;
2005
2006	bool fOldDigest = pStorage->fCreateDigest;/* Save the old digest property */
2007	pStorage->fCreateDigest = fCreateDigest;
2008	int vrc = readFileIntoBuffer(strFile.c_str(), ppvBuf, pcbSize, pCallbacks, pStorage);
2009	if ( RT_FAILURE(vrc)
2010	&& vrc != VERR_FILE_NOT_FOUND)
2011	rc = setError(VBOX_E_FILE_ERROR,
2012	tr("Could not read file '%s' (%Rrc)"),
2013	RTPathFilename(strFile.c_str()), vrc);
2014	pStorage->fCreateDigest = fOldDigest; /* Restore the old digest creation behavior again. */
2015
2016	return rc;
2017	}
2018
2019	HRESULT Appliance::i_readTarFileToBuf(PFSSRDONLYINTERFACEIO pTarIo,
2020	const Utf8Str &strFile,
2021	void **ppvBuf,
2022	size_t *pcbSize,
2023	bool fCreateDigest,
2024	PVDINTERFACEIO pCallbacks,
2025	PSHASTORAGE pStorage)
2026	{
2027	HRESULT rc = S_OK;
2028
2029	const char *pszCurFile;
2030	int vrc = fssRdOnlyGetCurrentName(pTarIo, &pszCurFile);
2031	if (RT_SUCCESS(vrc))
2032	{
2033	if (vrc != VINF_TAR_DIR_PATH)
2034	{
2035	if (!strcmp(pszCurFile, RTPathFilename(strFile.c_str())))
2036	rc = i_readFileToBuf(strFile, ppvBuf, pcbSize, fCreateDigest, pCallbacks, pStorage);
2037	}
2038	else
2039	rc = setError(VBOX_E_FILE_ERROR,
2040	tr("Empty directory folder (%s) isn't allowed in the OVA package (%Rrc)"),
2041	pszCurFile, vrc);
2042	}
2043	else if (vrc != VERR_EOF)
2044	rc = setError(VBOX_E_IPRT_ERROR, "Seeking within the archive failed (%Rrc)", vrc);
2045
2046	return rc;
2047	}
2048
2049	HRESULT Appliance::i_verifyManifestFile(const Utf8Str &strFile, ImportStack &stack, void *pvBuf, size_t cbSize)
2050	{
2051	LogFlowFuncEnter();
2052	LogFlowFunc(("Appliance %p\n", this));
2053	HRESULT rc = S_OK;
2054
2055	PRTMANIFESTTEST paTests = (PRTMANIFESTTEST)RTMemAlloc(sizeof(RTMANIFESTTEST) * stack.llSrcDisksDigest.size());
2056	if (!paTests)
2057	return E_OUTOFMEMORY;
2058
2059	size_t i = 0;
2060	list<STRPAIR>::const_iterator it1;
2061	for (it1 = stack.llSrcDisksDigest.begin();
2062	it1 != stack.llSrcDisksDigest.end();
2063	++it1, ++i)
2064	{
2065	paTests[i].pszTestFile = (*it1).first.c_str();
2066	paTests[i].pszTestDigest = (*it1).second.c_str();
2067	}
2068	size_t iFailed;
2069	int vrc = RTManifestVerifyFilesBuf(pvBuf, cbSize, paTests, stack.llSrcDisksDigest.size(), &iFailed);
2070	if (RT_UNLIKELY(vrc == VERR_MANIFEST_DIGEST_MISMATCH))
2071	rc = setError(VBOX_E_FILE_ERROR,
2072	tr("The SHA digest of '%s' does not match the one in '%s' (%Rrc)"),
2073	RTPathFilename(paTests[iFailed].pszTestFile), RTPathFilename(strFile.c_str()), vrc);
2074	else if (RT_FAILURE(vrc))
2075	rc = setError(VBOX_E_FILE_ERROR,
2076	tr("Could not verify the content of '%s' against the available files (%Rrc)"),
2077	RTPathFilename(strFile.c_str()), vrc);
2078
2079	RTMemFree(paTests);
2080	LogFlowFuncLeave();
2081
2082	return rc;
2083	}
2084
2085	HRESULT Appliance::i_verifyCertificateFile(void *pvBuf, size_t cbSize, PSHASTORAGE pStorage)
2086	{
2087	LogFlowFuncEnter();
2088	LogFlowFunc(("Appliance %p\n", this));
2089	HRESULT rc = S_OK;
2090
2091	int vrc = 0;
2092	RTDIGESTTYPE digestType;
2093	void * pvCertBuf = pvBuf;
2094	size_t cbCertSize = cbSize;
2095	Utf8Str manifestDigest = pStorage->strDigest;
2096
2097	vrc = RTManifestVerifyDigestType(pvCertBuf, cbCertSize, &digestType);
2098	if (RT_FAILURE(vrc))
2099	{
2100	rc = setError(VBOX_E_FILE_ERROR, tr("Digest type of certificate is unknown"));
2101	}
2102	else
2103	{
2104	RTX509PrepareOpenSSL();
2105
2106	vrc = RTRSAVerify(pvCertBuf, (unsigned int)cbCertSize, manifestDigest.c_str(), digestType);
2107	if (RT_SUCCESS(vrc))
2108	{
2109	/*
2110	* possible step in the future. Not obligatory due to OVF2.0 standard
2111	* OVF2.0:"A consumer of the OVF package shall verify the signature and should validate the certificate"
2112	*/
2113	vrc = RTX509CertificateVerify(pvCertBuf, (unsigned int)cbCertSize);
2114	}
2115
2116	/* After first unsuccessful operation */
2117	if (RT_FAILURE(vrc))
2118	{
2119	{
2120	/* first stage for getting possible error code and it's description using native openssl method */
2121	char* errStrDesc = NULL;
2122	unsigned long errValue = RTX509GetErrorDescription(&errStrDesc);
2123
2124	if(errValue != 0)
2125	{
2126	rc = setError(VBOX_E_FILE_ERROR, tr(errStrDesc));
2127	LogFlowFunc(("Error during verifying X509 certificate(internal openssl description): %s\n", errStrDesc));
2128	}
2129
2130	RTMemFree(errStrDesc);
2131	}
2132
2133	{
2134	/* second stage for getting possible error code using our defined errors codes. The original error description
2135	will be replaced by our description */
2136
2137	Utf8Str errStrDesc;
2138	switch(vrc)
2139	{
2140	case VERR_X509_READING_CERT_FROM_BIO:
2141	errStrDesc = "Error during reading a certificate in PEM format from BIO ";
2142	break;
2143	case VERR_X509_EXTRACT_PUBKEY_FROM_CERT:
2144	errStrDesc = "Error during extraction a public key from the certificate ";
2145	break;
2146	case VERR_X509_EXTRACT_RSA_FROM_PUBLIC_KEY:
2147	errStrDesc = "Error during extraction RSA from the public key ";
2148	break;
2149	case VERR_X509_RSA_VERIFICATION_FUILURE:
2150	errStrDesc = "RSA verification failure ";
2151	break;
2152	case VERR_X509_NO_BASIC_CONSTARAINTS:
2153	errStrDesc = "Basic constraints were not found ";
2154	break;
2155	case VERR_X509_GETTING_EXTENSION_FROM_CERT:
2156	errStrDesc = "Error during getting extensions from the certificate ";
2157	break;
2158	case VERR_X509_GETTING_DATA_FROM_EXTENSION:
2159	errStrDesc = "Error during extraction data from the extension ";
2160	break;
2161	case VERR_X509_PRINT_EXTENSION_TO_BIO:
2162	errStrDesc = "Error during print out an extension to BIO ";
2163	break;
2164	case VERR_X509_CERTIFICATE_VERIFICATION_FAILURE:
2165	errStrDesc = "X509 certificate verification failure ";
2166	break;
2167	default:
2168	errStrDesc = "Unknown error during X509 certificate verification";
2169	}
2170	rc = setError(VBOX_E_FILE_ERROR, tr(errStrDesc.c_str()));
2171	}
2172	}
2173	else
2174	{
2175	if(vrc == VINF_X509_NOT_SELFSIGNED_CERTIFICATE)
2176	{
2177	setWarning(VBOX_E_FILE_ERROR,
2178	tr("Signature from the X509 certificate has been verified. "
2179	"But VirtualBox can't validate the given X509 certificate. "
2180	"Only self signed X509 certificates are supported at moment. \n"));
2181	}
2182	}
2183	}
2184
2185	LogFlowFuncLeave();
2186	return rc;
2187	}
2188
2189	/**
2190	* Helper that converts VirtualSystem attachment values into VirtualBox attachment values.
2191	* Throws HRESULT values on errors!
2192	*
2193	* @param hdc in: the HardDiskController structure to attach to.
2194	* @param ulAddressOnParent in: the AddressOnParent parameter from OVF.
2195	* @param controllerType out: the name of the hard disk controller to attach to (e.g. "IDE Controller").
2196	* @param lControllerPort out: the channel (controller port) of the controller to attach to.
2197	* @param lDevice out: the device number to attach to.
2198	*/
2199	void Appliance::i_convertDiskAttachmentValues(const ovf::HardDiskController &hdc,
2200	uint32_t ulAddressOnParent,
2201	Bstr &controllerType,
2202	int32_t &lControllerPort,
2203	int32_t &lDevice)
2204	{
2205	Log(("Appliance::i_convertDiskAttachmentValues: hdc.system=%d, hdc.fPrimary=%d, ulAddressOnParent=%d\n",
2206	hdc.system,
2207	hdc.fPrimary,
2208	ulAddressOnParent));
2209
2210	switch (hdc.system)
2211	{
2212	case ovf::HardDiskController::IDE:
2213	// For the IDE bus, the port parameter can be either 0 or 1, to specify the primary
2214	// or secondary IDE controller, respectively. For the primary controller of the IDE bus,
2215	// the device number can be either 0 or 1, to specify the master or the slave device,
2216	// respectively. For the secondary IDE controller, the device number is always 1 because
2217	// the master device is reserved for the CD-ROM drive.
2218	controllerType = Bstr("IDE Controller");
2219	switch (ulAddressOnParent)
2220	{
2221	case 0: // master
2222	if (!hdc.fPrimary)
2223	{
2224	// secondary master
2225	lControllerPort = (long)1;
2226	lDevice = (long)0;
2227	}
2228	else // primary master
2229	{
2230	lControllerPort = (long)0;
2231	lDevice = (long)0;
2232	}
2233	break;
2234
2235	case 1: // slave
2236	if (!hdc.fPrimary)
2237	{
2238	// secondary slave
2239	lControllerPort = (long)1;
2240	lDevice = (long)1;
2241	}
2242	else // primary slave
2243	{
2244	lControllerPort = (long)0;
2245	lDevice = (long)1;
2246	}
2247	break;
2248
2249	// used by older VBox exports
2250	case 2: // interpret this as secondary master
2251	lControllerPort = (long)1;
2252	lDevice = (long)0;
2253	break;
2254
2255	// used by older VBox exports
2256	case 3: // interpret this as secondary slave
2257	lControllerPort = (long)1;
2258	lDevice = (long)1;
2259	break;
2260
2261	default:
2262	throw setError(VBOX_E_NOT_SUPPORTED,
2263	tr("Invalid channel %RI16 specified; IDE controllers support only 0, 1 or 2"),
2264	ulAddressOnParent);
2265	break;
2266	}
2267	break;
2268
2269	case ovf::HardDiskController::SATA:
2270	controllerType = Bstr("SATA Controller");
2271	lControllerPort = (long)ulAddressOnParent;
2272	lDevice = (long)0;
2273	break;
2274
2275	case ovf::HardDiskController::SCSI:
2276	{
2277	if(hdc.strControllerType.compare("lsilogicsas")==0)
2278	controllerType = Bstr("SAS Controller");
2279	else
2280	controllerType = Bstr("SCSI Controller");
2281	lControllerPort = (long)ulAddressOnParent;
2282	lDevice = (long)0;
2283	}
2284	break;
2285
2286	default: break;
2287	}
2288
2289	Log(("=> lControllerPort=%d, lDevice=%d\n", lControllerPort, lDevice));
2290	}
2291
2292	/**
2293	* Imports one disk image. This is common code shared between
2294	* -- i_importMachineGeneric() for the OVF case; in that case the information comes from
2295	* the OVF virtual systems;
2296	* -- i_importVBoxMachine(); in that case, the information comes from the <vbox:Machine>
2297	* tag.
2298	*
2299	* Both ways of describing machines use the OVF disk references section, so in both cases
2300	* the caller needs to pass in the ovf::DiskImage structure from ovfreader.cpp.
2301	*
2302	* As a result, in both cases, if di.strHref is empty, we create a new disk as per the OVF
2303	* spec, even though this cannot really happen in the vbox:Machine case since such data
2304	* would never have been exported.
2305	*
2306	* This advances stack.pProgress by one operation with the disk's weight.
2307	*
2308	* @param di ovfreader.cpp structure describing the disk image from the OVF that is to be imported
2309	* @param strTargetPath Where to create the target image.
2310	* @param pTargetHD out: The newly created target disk. This also gets pushed on stack.llHardDisksCreated for cleanup.
2311	* @param stack
2312	*/
2313	void Appliance::i_importOneDiskImage(const ovf::DiskImage &di,
2314	Utf8Str *strTargetPath,
2315	ComObjPtr<Medium> &pTargetHD,
2316	ImportStack &stack,
2317	PVDINTERFACEIO pCallbacks,
2318	PSHASTORAGE pStorage)
2319	{
2320	SHASTORAGE finalStorage;
2321	PSHASTORAGE pRealUsedStorage = pStorage;/* may be changed later to finalStorage */
2322	PVDINTERFACEIO pFileIo = NULL;/* used in GZIP case*/
2323	ComObjPtr<Progress> pProgress;
2324	pProgress.createObject();
2325	HRESULT rc = pProgress->init(mVirtualBox,
2326	static_cast<IAppliance*>(this),
2327	BstrFmt(tr("Creating medium '%s'"),
2328	strTargetPath->c_str()).raw(),
2329	TRUE);
2330	if (FAILED(rc)) throw rc;
2331
2332	/* Get the system properties. */
2333	SystemProperties *pSysProps = mVirtualBox->i_getSystemProperties();
2334
2335	/*
2336	* we put strSourceOVF into the stack.llSrcDisksDigest in the end of this
2337	* function like a key for a later validation of the SHA digests
2338	*/
2339	const Utf8Str &strSourceOVF = di.strHref;
2340
2341	Utf8Str strSrcFilePath(stack.strSourceDir);
2342	Utf8Str strTargetDir(*strTargetPath);
2343
2344	/* Construct source file path */
2345	Utf8Str name = i_applianceIOName(applianceIOTar);
2346
2347	if (RTStrNICmp(pStorage->pVDImageIfaces->pszInterfaceName, name.c_str(), name.length()) == 0)
2348	strSrcFilePath = strSourceOVF;
2349	else
2350	{
2351	strSrcFilePath.append(RTPATH_SLASH_STR);
2352	strSrcFilePath.append(strSourceOVF);
2353	}
2354
2355	/* First of all check if the path is an UUID. If so, the user like to
2356	* import the disk into an existing path. This is useful for iSCSI for
2357	* example. */
2358	RTUUID uuid;
2359	int vrc = RTUuidFromStr(&uuid, strTargetPath->c_str());
2360	if (vrc == VINF_SUCCESS)
2361	{
2362	rc = mVirtualBox->i_findHardDiskById(Guid(uuid), true, &pTargetHD);
2363	if (FAILED(rc)) throw rc;
2364	}
2365	else
2366	{
2367	bool fGzipUsed = !(di.strCompression.compare("gzip",Utf8Str::CaseInsensitive));
2368	/* check read file to GZIP compression */
2369	try
2370	{
2371	if (fGzipUsed == true)
2372	{
2373	/*
2374	* Create the necessary file access interfaces.
2375	* For the next step:
2376	* We need to replace the previously created chain of SHA-TAR or SHA-FILE interfaces
2377	* with simple FILE interface because we don't need SHA or TAR interfaces here anymore.
2378	* But we mustn't delete the chain of SHA-TAR or SHA-FILE interfaces.
2379	*/
2380
2381	/* Decompress the GZIP file and save a new file in the target path */
2382	strTargetDir = strTargetDir.stripFilename();
2383	strTargetDir.append("/temp_");
2384
2385	Utf8Str strTempTargetFilename(*strTargetPath);
2386	strTempTargetFilename = strTempTargetFilename.stripPath();
2387	strTempTargetFilename = strTempTargetFilename.stripSuffix();
2388
2389	strTargetDir.append(strTempTargetFilename);
2390
2391	vrc = decompressImageAndSave(strSrcFilePath.c_str(), strTargetDir.c_str(), pCallbacks, pStorage);
2392
2393	if (RT_FAILURE(vrc))
2394	throw setError(VBOX_E_FILE_ERROR,
2395	tr("Could not read the file '%s' (%Rrc)"),
2396	RTPathFilename(strSrcFilePath.c_str()), vrc);
2397
2398	/* Create the necessary file access interfaces. */
2399	pFileIo = FileCreateInterface();
2400	if (!pFileIo)
2401	throw setError(E_OUTOFMEMORY);
2402
2403	name = i_applianceIOName(applianceIOFile);
2404
2405	vrc = VDInterfaceAdd(&pFileIo->Core, name.c_str(),
2406	VDINTERFACETYPE_IO, NULL, sizeof(VDINTERFACEIO),
2407	&finalStorage.pVDImageIfaces);
2408	if (RT_FAILURE(vrc))
2409	throw setError(VBOX_E_IPRT_ERROR,
2410	tr("Creation of the VD interface failed (%Rrc)"), vrc);
2411
2412	/* Correct the source and the target with the actual values */
2413	strSrcFilePath = strTargetDir;
2414	strTargetDir = strTargetDir.stripFilename();
2415	strTargetDir.append(RTPATH_SLASH_STR);
2416	strTargetDir.append(strTempTargetFilename.c_str());
2417	*strTargetPath = strTargetDir.c_str();
2418
2419	pRealUsedStorage = &finalStorage;
2420	}
2421
2422	Utf8Str strTrgFormat = "VMDK";
2423	ULONG lCabs = 0;
2424
2425	if (RTPathHasSuffix(strTargetPath->c_str()))
2426	{
2427	const char *pszSuff = RTPathSuffix(strTargetPath->c_str());
2428	/* Figure out which format the user like to have. Default is VMDK. */
2429	ComObjPtr<MediumFormat> trgFormat = pSysProps->i_mediumFormatFromExtension(&pszSuff[1]);
2430	if (trgFormat.isNull())
2431	throw setError(VBOX_E_NOT_SUPPORTED,
2432	tr("Could not find a valid medium format for the target disk '%s'"),
2433	strTargetPath->c_str());
2434	/* Check the capabilities. We need create capabilities. */
2435	lCabs = 0;
2436	com::SafeArray <MediumFormatCapabilities_T> mediumFormatCap;
2437	rc = trgFormat->COMGETTER(Capabilities)(ComSafeArrayAsOutParam(mediumFormatCap));
2438
2439	if (FAILED(rc))
2440	throw rc;
2441	else
2442	{
2443	for (ULONG j = 0; j < mediumFormatCap.size(); j++)
2444	lCabs \|= mediumFormatCap[j];
2445	}
2446
2447	if (!( ((lCabs & MediumFormatCapabilities_CreateFixed) == MediumFormatCapabilities_CreateFixed)
2448	\|\| ((lCabs & MediumFormatCapabilities_CreateDynamic) == MediumFormatCapabilities_CreateDynamic)))
2449	throw setError(VBOX_E_NOT_SUPPORTED,
2450	tr("Could not find a valid medium format for the target disk '%s'"),
2451	strTargetPath->c_str());
2452	Bstr bstrFormatName;
2453	rc = trgFormat->COMGETTER(Name)(bstrFormatName.asOutParam());
2454	if (FAILED(rc)) throw rc;
2455	strTrgFormat = Utf8Str(bstrFormatName);
2456	}
2457	else
2458	{
2459	throw setError(VBOX_E_FILE_ERROR,
2460	tr("The target disk '%s' has no extension "),
2461	strTargetPath->c_str(), VERR_INVALID_NAME);
2462	}
2463
2464	/* Create an IMedium object. */
2465	pTargetHD.createObject();
2466
2467	/CD/DVD case/
2468	if (strTrgFormat.compare("RAW", Utf8Str::CaseInsensitive) == 0)
2469	{
2470	try
2471	{
2472	if (fGzipUsed == true)
2473	{
2474	/*
2475	* The source and target pathes are the same.
2476	* It means that we have the needed file already.
2477	* For example, in GZIP case, we decompress the file and save it in the target path,
2478	* but with some prefix like "temp_". See part "check read file to GZIP compression" earlier
2479	* in this function.
2480	* Just rename the file by deleting "temp_" from it's name
2481	*/
2482	vrc = RTFileRename(strSrcFilePath.c_str(), strTargetPath->c_str(), RTPATHRENAME_FLAGS_NO_REPLACE);
2483	if (RT_FAILURE(vrc))
2484	throw setError(VBOX_E_FILE_ERROR,
2485	tr("Could not rename the file '%s' (%Rrc)"),
2486	RTPathFilename(strSourceOVF.c_str()), vrc);
2487	}
2488	else
2489	{
2490	/* Calculating SHA digest for ISO file while copying one */
2491	vrc = copyFileAndCalcShaDigest(strSrcFilePath.c_str(),
2492	strTargetPath->c_str(),
2493	pCallbacks,
2494	pRealUsedStorage);
2495
2496	if (RT_FAILURE(vrc))
2497	throw setError(VBOX_E_FILE_ERROR,
2498	tr("Could not copy ISO file '%s' listed in the OVF file (%Rrc)"),
2499	RTPathFilename(strSourceOVF.c_str()), vrc);
2500	}
2501	}
2502	catch (HRESULT /arc/)
2503	{
2504	throw;
2505	}
2506
2507	/* Advance to the next operation. */
2508	/* operation's weight, as set up with the IProgress originally */
2509	stack.pProgress->SetNextOperation(BstrFmt(tr("Importing virtual disk image '%s'"),
2510	RTPathFilename(strSourceOVF.c_str())).raw(),
2511	di.ulSuggestedSizeMB);
2512	}
2513	else/* HDD case*/
2514	{
2515	rc = pTargetHD->init(mVirtualBox,
2516	strTrgFormat,
2517	*strTargetPath,
2518	Guid::Empty /* media registry: none yet */,
2519	DeviceType_HardDisk);
2520	if (FAILED(rc)) throw rc;
2521
2522	/* Now create an empty hard disk. */
2523	rc = mVirtualBox->CreateHardDisk(Bstr(strTrgFormat).raw(),
2524	Bstr(*strTargetPath).raw(),
2525	ComPtr<IMedium>(pTargetHD).asOutParam());
2526	if (FAILED(rc)) throw rc;
2527
2528	/* If strHref is empty we have to create a new file. */
2529	if (strSourceOVF.isEmpty())
2530	{
2531	com::SafeArray<MediumVariant_T> mediumVariant;
2532	mediumVariant.push_back(MediumVariant_Standard);
2533	/* Create a dynamic growing disk image with the given capacity. */
2534	rc = pTargetHD->CreateBaseStorage(di.iCapacity / _1M,
2535	ComSafeArrayAsInParam(mediumVariant),
2536	ComPtr<IProgress>(pProgress).asOutParam());
2537	if (FAILED(rc)) throw rc;
2538
2539	/* Advance to the next operation. */
2540	/* operation's weight, as set up with the IProgress originally */
2541	stack.pProgress->SetNextOperation(BstrFmt(tr("Creating disk image '%s'"),
2542	strTargetPath->c_str()).raw(),
2543	di.ulSuggestedSizeMB);
2544	}
2545	else
2546	{
2547	/* We need a proper source format description */
2548	/* Which format to use? */
2549	ComObjPtr<MediumFormat> srcFormat;
2550	rc = i_findMediumFormatFromDiskImage(di, srcFormat);
2551	if (FAILED(rc))
2552	throw setError(VBOX_E_NOT_SUPPORTED,
2553	tr("Could not find a valid medium format for the source disk '%s' "
2554	"Check correctness of the image format URL in the OVF description file "
2555	"or extension of the image"),
2556	RTPathFilename(strSourceOVF.c_str()));
2557
2558	/* Clone the source disk image */
2559	ComObjPtr<Medium> nullParent;
2560	rc = pTargetHD->i_importFile(strSrcFilePath.c_str(),
2561	srcFormat,
2562	MediumVariant_Standard,
2563	pCallbacks, pRealUsedStorage,
2564	nullParent,
2565	pProgress);
2566	if (FAILED(rc)) throw rc;
2567
2568
2569
2570	/* Advance to the next operation. */
2571	/* operation's weight, as set up with the IProgress originally */
2572	stack.pProgress->SetNextOperation(BstrFmt(tr("Importing virtual disk image '%s'"),
2573	RTPathFilename(strSourceOVF.c_str())).raw(),
2574	di.ulSuggestedSizeMB);
2575	}
2576
2577	/* Now wait for the background disk operation to complete; this throws
2578	* HRESULTs on error. */
2579	ComPtr<IProgress> pp(pProgress);
2580	i_waitForAsyncProgress(stack.pProgress, pp);
2581
2582	if (fGzipUsed == true)
2583	{
2584	/*
2585	* Just delete the temporary file
2586	*/
2587	vrc = RTFileDelete(strSrcFilePath.c_str());
2588	if (RT_FAILURE(vrc))
2589	setWarning(VBOX_E_FILE_ERROR,
2590	tr("Could not delete the file '%s' (%Rrc)"),
2591	RTPathFilename(strSrcFilePath.c_str()), vrc);
2592	}
2593	}
2594	}
2595	catch (...)
2596	{
2597	if (pFileIo)
2598	RTMemFree(pFileIo);
2599
2600	throw;
2601	}
2602	}
2603
2604	if (pFileIo)
2605	RTMemFree(pFileIo);
2606
2607	/* Add the newly create disk path + a corresponding digest the our list for
2608	* later manifest verification. */
2609	stack.llSrcDisksDigest.push_back(STRPAIR(strSourceOVF, pStorage ? pStorage->strDigest : ""));
2610	}
2611
2612	/**
2613	* Imports one OVF virtual system (described by the given ovf::VirtualSystem and VirtualSystemDescription)
2614	* into VirtualBox by creating an IMachine instance, which is returned.
2615	*
2616	* This throws HRESULT error codes for anything that goes wrong, in which case the caller must clean
2617	* up any leftovers from this function. For this, the given ImportStack instance has received information
2618	* about what needs cleaning up (to support rollback).
2619	*
2620	* @param vsysThis OVF virtual system (machine) to import.
2621	* @param vsdescThis Matching virtual system description (machine) to import.
2622	* @param pNewMachine out: Newly created machine.
2623	* @param stack Cleanup stack for when this throws.
2624	*/
2625	void Appliance::i_importMachineGeneric(const ovf::VirtualSystem &vsysThis,
2626	ComObjPtr<VirtualSystemDescription> &vsdescThis,
2627	ComPtr<IMachine> &pNewMachine,
2628	ImportStack &stack,
2629	PVDINTERFACEIO pCallbacks,
2630	PSHASTORAGE pStorage)
2631	{
2632	LogFlowFuncEnter();
2633	HRESULT rc;
2634
2635	// Get the instance of IGuestOSType which matches our string guest OS type so we
2636	// can use recommended defaults for the new machine where OVF doesn't provide any
2637	ComPtr<IGuestOSType> osType;
2638	rc = mVirtualBox->GetGuestOSType(Bstr(stack.strOsTypeVBox).raw(), osType.asOutParam());
2639	if (FAILED(rc)) throw rc;
2640
2641	/* Create the machine */
2642	SafeArray<BSTR> groups; /* no groups */
2643	rc = mVirtualBox->CreateMachine(NULL, /* machine name: use default */
2644	Bstr(stack.strNameVBox).raw(),
2645	ComSafeArrayAsInParam(groups),
2646	Bstr(stack.strOsTypeVBox).raw(),
2647	NULL, /* aCreateFlags */
2648	pNewMachine.asOutParam());
2649	if (FAILED(rc)) throw rc;
2650
2651	// set the description
2652	if (!stack.strDescription.isEmpty())
2653	{
2654	rc = pNewMachine->COMSETTER(Description)(Bstr(stack.strDescription).raw());
2655	if (FAILED(rc)) throw rc;
2656	}
2657
2658	// CPU count
2659	rc = pNewMachine->COMSETTER(CPUCount)(stack.cCPUs);
2660	if (FAILED(rc)) throw rc;
2661
2662	if (stack.fForceHWVirt)
2663	{
2664	rc = pNewMachine->SetHWVirtExProperty(HWVirtExPropertyType_Enabled, TRUE);
2665	if (FAILED(rc)) throw rc;
2666	}
2667
2668	// RAM
2669	rc = pNewMachine->COMSETTER(MemorySize)(stack.ulMemorySizeMB);
2670	if (FAILED(rc)) throw rc;
2671
2672	/* VRAM */
2673	/* Get the recommended VRAM for this guest OS type */
2674	ULONG vramVBox;
2675	rc = osType->COMGETTER(RecommendedVRAM)(&vramVBox);
2676	if (FAILED(rc)) throw rc;
2677
2678	/* Set the VRAM */
2679	rc = pNewMachine->COMSETTER(VRAMSize)(vramVBox);
2680	if (FAILED(rc)) throw rc;
2681
2682	// I/O APIC: Generic OVF has no setting for this. Enable it if we
2683	// import a Windows VM because if if Windows was installed without IOAPIC,
2684	// it will not mind finding an one later on, but if Windows was installed
2685	// _with_ an IOAPIC, it will bluescreen if it's not found
2686	if (!stack.fForceIOAPIC)
2687	{
2688	Bstr bstrFamilyId;
2689	rc = osType->COMGETTER(FamilyId)(bstrFamilyId.asOutParam());
2690	if (FAILED(rc)) throw rc;
2691	if (bstrFamilyId == "Windows")
2692	stack.fForceIOAPIC = true;
2693	}
2694
2695	if (stack.fForceIOAPIC)
2696	{
2697	ComPtr<IBIOSSettings> pBIOSSettings;
2698	rc = pNewMachine->COMGETTER(BIOSSettings)(pBIOSSettings.asOutParam());
2699	if (FAILED(rc)) throw rc;
2700
2701	rc = pBIOSSettings->COMSETTER(IOAPICEnabled)(TRUE);
2702	if (FAILED(rc)) throw rc;
2703	}
2704
2705	if (!stack.strAudioAdapter.isEmpty())
2706	if (stack.strAudioAdapter.compare("null", Utf8Str::CaseInsensitive) != 0)
2707	{
2708	uint32_t audio = RTStrToUInt32(stack.strAudioAdapter.c_str()); // should be 0 for AC97
2709	ComPtr<IAudioAdapter> audioAdapter;
2710	rc = pNewMachine->COMGETTER(AudioAdapter)(audioAdapter.asOutParam());
2711	if (FAILED(rc)) throw rc;
2712	rc = audioAdapter->COMSETTER(Enabled)(true);
2713	if (FAILED(rc)) throw rc;
2714	rc = audioAdapter->COMSETTER(AudioController)(static_cast<AudioControllerType_T>(audio));
2715	if (FAILED(rc)) throw rc;
2716	}
2717
2718	#ifdef VBOX_WITH_USB
2719	/* USB Controller */
2720	if (stack.fUSBEnabled)
2721	{
2722	ComPtr<IUSBController> usbController;
2723	rc = pNewMachine->AddUSBController(Bstr("OHCI").raw(), USBControllerType_OHCI, usbController.asOutParam());
2724	if (FAILED(rc)) throw rc;
2725	}
2726	#endif /* VBOX_WITH_USB */
2727
2728	/* Change the network adapters */
2729	uint32_t maxNetworkAdapters = Global::getMaxNetworkAdapters(ChipsetType_PIIX3);
2730
2731	std::list<VirtualSystemDescriptionEntry*> vsdeNW = vsdescThis->i_findByType(VirtualSystemDescriptionType_NetworkAdapter);
2732	if (vsdeNW.size() == 0)
2733	{
2734	/* No network adapters, so we have to disable our default one */
2735	ComPtr<INetworkAdapter> nwVBox;
2736	rc = pNewMachine->GetNetworkAdapter(0, nwVBox.asOutParam());
2737	if (FAILED(rc)) throw rc;
2738	rc = nwVBox->COMSETTER(Enabled)(false);
2739	if (FAILED(rc)) throw rc;
2740	}
2741	else if (vsdeNW.size() > maxNetworkAdapters)
2742	throw setError(VBOX_E_FILE_ERROR,
2743	tr("Too many network adapters: OVF requests %d network adapters, "
2744	"but VirtualBox only supports %d"),
2745	vsdeNW.size(), maxNetworkAdapters);
2746	else
2747	{
2748	list<VirtualSystemDescriptionEntry*>::const_iterator nwIt;
2749	size_t a = 0;
2750	for (nwIt = vsdeNW.begin();
2751	nwIt != vsdeNW.end();
2752	++nwIt, ++a)
2753	{
2754	const VirtualSystemDescriptionEntry* pvsys = *nwIt;
2755
2756	const Utf8Str &nwTypeVBox = pvsys->strVBoxCurrent;
2757	uint32_t tt1 = RTStrToUInt32(nwTypeVBox.c_str());
2758	ComPtr<INetworkAdapter> pNetworkAdapter;
2759	rc = pNewMachine->GetNetworkAdapter((ULONG)a, pNetworkAdapter.asOutParam());
2760	if (FAILED(rc)) throw rc;
2761	/* Enable the network card & set the adapter type */
2762	rc = pNetworkAdapter->COMSETTER(Enabled)(true);
2763	if (FAILED(rc)) throw rc;
2764	rc = pNetworkAdapter->COMSETTER(AdapterType)(static_cast<NetworkAdapterType_T>(tt1));
2765	if (FAILED(rc)) throw rc;
2766
2767	// default is NAT; change to "bridged" if extra conf says so
2768	if (pvsys->strExtraConfigCurrent.endsWith("type=Bridged", Utf8Str::CaseInsensitive))
2769	{
2770	/* Attach to the right interface */
2771	rc = pNetworkAdapter->COMSETTER(AttachmentType)(NetworkAttachmentType_Bridged);
2772	if (FAILED(rc)) throw rc;
2773	ComPtr<IHost> host;
2774	rc = mVirtualBox->COMGETTER(Host)(host.asOutParam());
2775	if (FAILED(rc)) throw rc;
2776	com::SafeIfaceArray<IHostNetworkInterface> nwInterfaces;
2777	rc = host->COMGETTER(NetworkInterfaces)(ComSafeArrayAsOutParam(nwInterfaces));
2778	if (FAILED(rc)) throw rc;
2779	// We search for the first host network interface which
2780	// is usable for bridged networking
2781	for (size_t j = 0;
2782	j < nwInterfaces.size();
2783	++j)
2784	{
2785	HostNetworkInterfaceType_T itype;
2786	rc = nwInterfaces[j]->COMGETTER(InterfaceType)(&itype);
2787	if (FAILED(rc)) throw rc;
2788	if (itype == HostNetworkInterfaceType_Bridged)
2789	{
2790	Bstr name;
2791	rc = nwInterfaces[j]->COMGETTER(Name)(name.asOutParam());
2792	if (FAILED(rc)) throw rc;
2793	/* Set the interface name to attach to */
2794	rc = pNetworkAdapter->COMSETTER(BridgedInterface)(name.raw());
2795	if (FAILED(rc)) throw rc;
2796	break;
2797	}
2798	}
2799	}
2800	/* Next test for host only interfaces */
2801	else if (pvsys->strExtraConfigCurrent.endsWith("type=HostOnly", Utf8Str::CaseInsensitive))
2802	{
2803	/* Attach to the right interface */
2804	rc = pNetworkAdapter->COMSETTER(AttachmentType)(NetworkAttachmentType_HostOnly);
2805	if (FAILED(rc)) throw rc;
2806	ComPtr<IHost> host;
2807	rc = mVirtualBox->COMGETTER(Host)(host.asOutParam());
2808	if (FAILED(rc)) throw rc;
2809	com::SafeIfaceArray<IHostNetworkInterface> nwInterfaces;
2810	rc = host->COMGETTER(NetworkInterfaces)(ComSafeArrayAsOutParam(nwInterfaces));
2811	if (FAILED(rc)) throw rc;
2812	// We search for the first host network interface which
2813	// is usable for host only networking
2814	for (size_t j = 0;
2815	j < nwInterfaces.size();
2816	++j)
2817	{
2818	HostNetworkInterfaceType_T itype;
2819	rc = nwInterfaces[j]->COMGETTER(InterfaceType)(&itype);
2820	if (FAILED(rc)) throw rc;
2821	if (itype == HostNetworkInterfaceType_HostOnly)
2822	{
2823	Bstr name;
2824	rc = nwInterfaces[j]->COMGETTER(Name)(name.asOutParam());
2825	if (FAILED(rc)) throw rc;
2826	/* Set the interface name to attach to */
2827	rc = pNetworkAdapter->COMSETTER(HostOnlyInterface)(name.raw());
2828	if (FAILED(rc)) throw rc;
2829	break;
2830	}
2831	}
2832	}
2833	/* Next test for internal interfaces */
2834	else if (pvsys->strExtraConfigCurrent.endsWith("type=Internal", Utf8Str::CaseInsensitive))
2835	{
2836	/* Attach to the right interface */
2837	rc = pNetworkAdapter->COMSETTER(AttachmentType)(NetworkAttachmentType_Internal);
2838	if (FAILED(rc)) throw rc;
2839	}
2840	/* Next test for Generic interfaces */
2841	else if (pvsys->strExtraConfigCurrent.endsWith("type=Generic", Utf8Str::CaseInsensitive))
2842	{
2843	/* Attach to the right interface */
2844	rc = pNetworkAdapter->COMSETTER(AttachmentType)(NetworkAttachmentType_Generic);
2845	if (FAILED(rc)) throw rc;
2846	}
2847
2848	/* Next test for NAT network interfaces */
2849	else if (pvsys->strExtraConfigCurrent.endsWith("type=NATNetwork", Utf8Str::CaseInsensitive))
2850	{
2851	/* Attach to the right interface */
2852	rc = pNetworkAdapter->COMSETTER(AttachmentType)(NetworkAttachmentType_NATNetwork);
2853	if (FAILED(rc)) throw rc;
2854	com::SafeIfaceArray<INATNetwork> nwNATNetworks;
2855	rc = mVirtualBox->COMGETTER(NATNetworks)(ComSafeArrayAsOutParam(nwNATNetworks));
2856	if (FAILED(rc)) throw rc;
2857	// Pick the first NAT network (if there is any)
2858	if (nwNATNetworks.size())
2859	{
2860	Bstr name;
2861	rc = nwNATNetworks[0]->COMGETTER(NetworkName)(name.asOutParam());
2862	if (FAILED(rc)) throw rc;
2863	/* Set the NAT network name to attach to */
2864	rc = pNetworkAdapter->COMSETTER(NATNetwork)(name.raw());
2865	if (FAILED(rc)) throw rc;
2866	break;
2867	}
2868	}
2869	}
2870	}
2871
2872	// IDE Hard disk controller
2873	std::list<VirtualSystemDescriptionEntry*> vsdeHDCIDE =
2874	vsdescThis->i_findByType(VirtualSystemDescriptionType_HardDiskControllerIDE);
2875	/*
2876	* In OVF (at least VMware's version of it), an IDE controller has two ports,
2877	* so VirtualBox's single IDE controller with two channels and two ports each counts as
2878	* two OVF IDE controllers -- so we accept one or two such IDE controllers
2879	*/
2880	size_t cIDEControllers = vsdeHDCIDE.size();
2881	if (cIDEControllers > 2)
2882	throw setError(VBOX_E_FILE_ERROR,
2883	tr("Too many IDE controllers in OVF; import facility only supports two"));
2884	if (vsdeHDCIDE.size() > 0)
2885	{
2886	// one or two IDE controllers present in OVF: add one VirtualBox controller
2887	ComPtr<IStorageController> pController;
2888	rc = pNewMachine->AddStorageController(Bstr("IDE Controller").raw(), StorageBus_IDE, pController.asOutParam());
2889	if (FAILED(rc)) throw rc;
2890
2891	const char *pcszIDEType = vsdeHDCIDE.front()->strVBoxCurrent.c_str();
2892	if (!strcmp(pcszIDEType, "PIIX3"))
2893	rc = pController->COMSETTER(ControllerType)(StorageControllerType_PIIX3);
2894	else if (!strcmp(pcszIDEType, "PIIX4"))
2895	rc = pController->COMSETTER(ControllerType)(StorageControllerType_PIIX4);
2896	else if (!strcmp(pcszIDEType, "ICH6"))
2897	rc = pController->COMSETTER(ControllerType)(StorageControllerType_ICH6);
2898	else
2899	throw setError(VBOX_E_FILE_ERROR,
2900	tr("Invalid IDE controller type \"%s\""),
2901	pcszIDEType);
2902	if (FAILED(rc)) throw rc;
2903	}
2904
2905	/* Hard disk controller SATA */
2906	std::list<VirtualSystemDescriptionEntry*> vsdeHDCSATA =
2907	vsdescThis->i_findByType(VirtualSystemDescriptionType_HardDiskControllerSATA);
2908	if (vsdeHDCSATA.size() > 1)
2909	throw setError(VBOX_E_FILE_ERROR,
2910	tr("Too many SATA controllers in OVF; import facility only supports one"));
2911	if (vsdeHDCSATA.size() > 0)
2912	{
2913	ComPtr<IStorageController> pController;
2914	const Utf8Str &hdcVBox = vsdeHDCSATA.front()->strVBoxCurrent;
2915	if (hdcVBox == "AHCI")
2916	{
2917	rc = pNewMachine->AddStorageController(Bstr("SATA Controller").raw(),
2918	StorageBus_SATA,
2919	pController.asOutParam());
2920	if (FAILED(rc)) throw rc;
2921	}
2922	else
2923	throw setError(VBOX_E_FILE_ERROR,
2924	tr("Invalid SATA controller type \"%s\""),
2925	hdcVBox.c_str());
2926	}
2927
2928	/* Hard disk controller SCSI */
2929	std::list<VirtualSystemDescriptionEntry*> vsdeHDCSCSI =
2930	vsdescThis->i_findByType(VirtualSystemDescriptionType_HardDiskControllerSCSI);
2931	if (vsdeHDCSCSI.size() > 1)
2932	throw setError(VBOX_E_FILE_ERROR,
2933	tr("Too many SCSI controllers in OVF; import facility only supports one"));
2934	if (vsdeHDCSCSI.size() > 0)
2935	{
2936	ComPtr<IStorageController> pController;
2937	Bstr bstrName(L"SCSI Controller");
2938	StorageBus_T busType = StorageBus_SCSI;
2939	StorageControllerType_T controllerType;
2940	const Utf8Str &hdcVBox = vsdeHDCSCSI.front()->strVBoxCurrent;
2941	if (hdcVBox == "LsiLogic")
2942	controllerType = StorageControllerType_LsiLogic;
2943	else if (hdcVBox == "LsiLogicSas")
2944	{
2945	// OVF treats LsiLogicSas as a SCSI controller but VBox considers it a class of its own
2946	bstrName = L"SAS Controller";
2947	busType = StorageBus_SAS;
2948	controllerType = StorageControllerType_LsiLogicSas;
2949	}
2950	else if (hdcVBox == "BusLogic")
2951	controllerType = StorageControllerType_BusLogic;
2952	else
2953	throw setError(VBOX_E_FILE_ERROR,
2954	tr("Invalid SCSI controller type \"%s\""),
2955	hdcVBox.c_str());
2956
2957	rc = pNewMachine->AddStorageController(bstrName.raw(), busType, pController.asOutParam());
2958	if (FAILED(rc)) throw rc;
2959	rc = pController->COMSETTER(ControllerType)(controllerType);
2960	if (FAILED(rc)) throw rc;
2961	}
2962
2963	/* Hard disk controller SAS */
2964	std::list<VirtualSystemDescriptionEntry*> vsdeHDCSAS =
2965	vsdescThis->i_findByType(VirtualSystemDescriptionType_HardDiskControllerSAS);
2966	if (vsdeHDCSAS.size() > 1)
2967	throw setError(VBOX_E_FILE_ERROR,
2968	tr("Too many SAS controllers in OVF; import facility only supports one"));
2969	if (vsdeHDCSAS.size() > 0)
2970	{
2971	ComPtr<IStorageController> pController;
2972	rc = pNewMachine->AddStorageController(Bstr(L"SAS Controller").raw(),
2973	StorageBus_SAS,
2974	pController.asOutParam());
2975	if (FAILED(rc)) throw rc;
2976	rc = pController->COMSETTER(ControllerType)(StorageControllerType_LsiLogicSas);
2977	if (FAILED(rc)) throw rc;
2978	}
2979
2980	/* Now its time to register the machine before we add any hard disks */
2981	rc = mVirtualBox->RegisterMachine(pNewMachine);
2982	if (FAILED(rc)) throw rc;
2983
2984	// store new machine for roll-back in case of errors
2985	Bstr bstrNewMachineId;
2986	rc = pNewMachine->COMGETTER(Id)(bstrNewMachineId.asOutParam());
2987	if (FAILED(rc)) throw rc;
2988	Guid uuidNewMachine(bstrNewMachineId);
2989	m->llGuidsMachinesCreated.push_back(uuidNewMachine);
2990
2991	// Add floppies and CD-ROMs to the appropriate controllers.
2992	std::list<VirtualSystemDescriptionEntry*> vsdeFloppy = vsdescThis->i_findByType(VirtualSystemDescriptionType_Floppy);
2993	if (vsdeFloppy.size() > 1)
2994	throw setError(VBOX_E_FILE_ERROR,
2995	tr("Too many floppy controllers in OVF; import facility only supports one"));
2996	std::list<VirtualSystemDescriptionEntry*> vsdeCDROM = vsdescThis->i_findByType(VirtualSystemDescriptionType_CDROM);
2997	if ( (vsdeFloppy.size() > 0)
2998	\|\| (vsdeCDROM.size() > 0)
2999	)
3000	{
3001	// If there's an error here we need to close the session, so
3002	// we need another try/catch block.
3003
3004	try
3005	{
3006	// to attach things we need to open a session for the new machine
3007	rc = pNewMachine->LockMachine(stack.pSession, LockType_Write);
3008	if (FAILED(rc)) throw rc;
3009	stack.fSessionOpen = true;
3010
3011	ComPtr<IMachine> sMachine;
3012	rc = stack.pSession->COMGETTER(Machine)(sMachine.asOutParam());
3013	if (FAILED(rc)) throw rc;
3014
3015	// floppy first
3016	if (vsdeFloppy.size() == 1)
3017	{
3018	ComPtr<IStorageController> pController;
3019	rc = sMachine->AddStorageController(Bstr("Floppy Controller").raw(),
3020	StorageBus_Floppy,
3021	pController.asOutParam());
3022	if (FAILED(rc)) throw rc;
3023
3024	Bstr bstrName;
3025	rc = pController->COMGETTER(Name)(bstrName.asOutParam());
3026	if (FAILED(rc)) throw rc;
3027
3028	// this is for rollback later
3029	MyHardDiskAttachment mhda;
3030	mhda.pMachine = pNewMachine;
3031	mhda.controllerType = bstrName;
3032	mhda.lControllerPort = 0;
3033	mhda.lDevice = 0;
3034
3035	Log(("Attaching floppy\n"));
3036
3037	rc = sMachine->AttachDevice(mhda.controllerType.raw(),
3038	mhda.lControllerPort,
3039	mhda.lDevice,
3040	DeviceType_Floppy,
3041	NULL);
3042	if (FAILED(rc)) throw rc;
3043
3044	stack.llHardDiskAttachments.push_back(mhda);
3045	}
3046
3047	rc = sMachine->SaveSettings();
3048	if (FAILED(rc)) throw rc;
3049
3050	// only now that we're done with all disks, close the session
3051	rc = stack.pSession->UnlockMachine();
3052	if (FAILED(rc)) throw rc;
3053	stack.fSessionOpen = false;
3054	}
3055	catch(HRESULT aRC)
3056	{
3057	com::ErrorInfo info;
3058
3059	if (stack.fSessionOpen)
3060	stack.pSession->UnlockMachine();
3061
3062	if (info.isFullAvailable())
3063	throw setError(aRC, Utf8Str(info.getText()).c_str());
3064	else
3065	throw setError(aRC, "Unknown error during OVF import");
3066	}
3067	}
3068
3069	// create the hard disks & connect them to the appropriate controllers
3070	std::list<VirtualSystemDescriptionEntry*> avsdeHDs = vsdescThis->i_findByType(VirtualSystemDescriptionType_HardDiskImage);
3071	if (avsdeHDs.size() > 0)
3072	{
3073	// If there's an error here we need to close the session, so
3074	// we need another try/catch block.
3075	try
3076	{
3077	#ifdef LOG_ENABLED
3078	if (LogIsEnabled())
3079	{
3080	size_t i = 0;
3081	for (list<VirtualSystemDescriptionEntry*>::const_iterator itHD = avsdeHDs.begin();
3082	itHD != avsdeHDs.end(); ++itHD, i++)
3083	Log(("avsdeHDs[%zu]: strRef=%s strOvf=%s\n", i, (itHD)->strRef.c_str(), (itHD)->strOvf.c_str()));
3084	i = 0;
3085	for (ovf::DiskImagesMap::const_iterator itDisk = stack.mapDisks.begin(); itDisk != stack.mapDisks.end(); ++itDisk)
3086	Log(("mapDisks[%zu]: strDiskId=%s strHref=%s\n",
3087	i, itDisk->second.strDiskId.c_str(), itDisk->second.strHref.c_str()));
3088
3089	}
3090	#endif
3091
3092	// to attach things we need to open a session for the new machine
3093	rc = pNewMachine->LockMachine(stack.pSession, LockType_Write);
3094	if (FAILED(rc)) throw rc;
3095	stack.fSessionOpen = true;
3096
3097	/* get VM name from virtual system description. Only one record is possible (size of list is equal 1). */
3098	std::list<VirtualSystemDescriptionEntry*> vmName = vsdescThis->i_findByType(VirtualSystemDescriptionType_Name);
3099	std::list<VirtualSystemDescriptionEntry*>::iterator vmNameIt = vmName.begin();
3100	VirtualSystemDescriptionEntry* vmNameEntry = *vmNameIt;
3101
3102
3103	ovf::DiskImagesMap::const_iterator oit = stack.mapDisks.begin();
3104	std::set<RTCString> disksResolvedNames;
3105
3106	uint32_t cImportedDisks = 0;
3107
3108	while(oit != stack.mapDisks.end() && cImportedDisks != avsdeHDs.size())
3109	{
3110	ovf::DiskImage diCurrent = oit->second;
3111	ovf::VirtualDisksMap::const_iterator itVDisk = vsysThis.mapVirtualDisks.begin();
3112
3113	VirtualSystemDescriptionEntry *vsdeTargetHD = 0;
3114	Log(("diCurrent.strDiskId=%s diCurrent.strHref=%s\n", diCurrent.strDiskId.c_str(), diCurrent.strHref.c_str()));
3115
3116	/*
3117	*
3118	* Iterate over all given disk images of the virtual system
3119	* disks description. We need to find the target disk path,
3120	* which could be changed by the user.
3121	*
3122	*/
3123	{
3124	list<VirtualSystemDescriptionEntry*>::const_iterator itHD;
3125	for (itHD = avsdeHDs.begin();
3126	itHD != avsdeHDs.end();
3127	++itHD)
3128	{
3129	VirtualSystemDescriptionEntry vsdeHD = itHD;
3130	if (vsdeHD->strRef == diCurrent.strDiskId)
3131	{
3132	vsdeTargetHD = vsdeHD;
3133	break;
3134	}
3135	}
3136	if (!vsdeTargetHD)
3137	{
3138	/* possible case if a disk image belongs to other virtual system (OVF package with multiple VMs inside) */
3139	LogWarning(("OVA/OVF import: Disk image %s was missed during import of VM %s\n",
3140	oit->first.c_str(), vmNameEntry->strOvf.c_str()));
3141	NOREF(vmNameEntry);
3142	++oit;
3143	continue;
3144	}
3145
3146	//diCurrent.strDiskId contains the disk identifier (e.g. "vmdisk1"), which should exist
3147	//in the virtual system's disks map under that ID and also in the global images map
3148	itVDisk = vsysThis.mapVirtualDisks.find(diCurrent.strDiskId);
3149	if (itVDisk == vsysThis.mapVirtualDisks.end())
3150	throw setError(E_FAIL,
3151	tr("Internal inconsistency looking up disk image '%s'"),
3152	diCurrent.strHref.c_str());
3153	}
3154
3155	/*
3156	* preliminary check availability of the image
3157	* This step is useful if image is placed in the OVA (TAR) package
3158	*/
3159
3160	Utf8Str name = i_applianceIOName(applianceIOTar);
3161
3162	if (strncmp(pStorage->pVDImageIfaces->pszInterfaceName, name.c_str(), name.length()) == 0)
3163	{
3164	/* It means that we possibly have imported the storage earlier on the previous loop steps*/
3165	std::set<RTCString>::const_iterator h = disksResolvedNames.find(diCurrent.strHref);
3166	if (h != disksResolvedNames.end())
3167	{
3168	/* Yes, disk name was found, we can skip it*/
3169	++oit;
3170	continue;
3171	}
3172
3173	RTCString availableImage(diCurrent.strHref);
3174
3175	rc = i_preCheckImageAvailability(pStorage, availableImage);
3176
3177	if (SUCCEEDED(rc))
3178	{
3179	/* current opened file isn't the same as passed one */
3180	if(availableImage.compare(diCurrent.strHref, Utf8Str::CaseInsensitive) != 0)
3181	{
3182	/*
3183	* availableImage contains the disk file reference (e.g. "disk1.vmdk"), which should exist
3184	* in the global images map.
3185	* And find the disk from the OVF's disk list
3186	*
3187	*/
3188	{
3189	ovf::DiskImagesMap::const_iterator itDiskImage = stack.mapDisks.begin();
3190	while (++itDiskImage != stack.mapDisks.end())
3191	{
3192	if (itDiskImage->second.strHref.compare(availableImage, Utf8Str::CaseInsensitive) == 0)
3193	break;
3194	}
3195	if (itDiskImage == stack.mapDisks.end())
3196	{
3197	throw setError(E_FAIL,
3198	tr("Internal inconsistency looking up disk image '%s'. "
3199	"Check compliance OVA package structure and file names "
3200	"references in the section <References> in the OVF file."),
3201	availableImage.c_str());
3202	}
3203
3204	/* replace with a new found disk image */
3205	diCurrent = *(&itDiskImage->second);
3206	}
3207
3208	/*
3209	* Again iterate over all given disk images of the virtual system
3210	* disks description using the found disk image
3211	*/
3212	{
3213	list<VirtualSystemDescriptionEntry*>::const_iterator itHD;
3214	for (itHD = avsdeHDs.begin();
3215	itHD != avsdeHDs.end();
3216	++itHD)
3217	{
3218	VirtualSystemDescriptionEntry vsdeHD = itHD;
3219	if (vsdeHD->strRef == diCurrent.strDiskId)
3220	{
3221	vsdeTargetHD = vsdeHD;
3222	break;
3223	}
3224	}
3225	if (!vsdeTargetHD)
3226	{
3227	/*
3228	* in this case it's an error because something wrong with OVF description file.
3229	* May be VBox imports OVA package with wrong file sequence inside the archive.
3230	*/
3231	throw setError(E_FAIL,
3232	tr("Internal inconsistency looking up disk image '%s'"),
3233	diCurrent.strHref.c_str());
3234	}
3235
3236	itVDisk = vsysThis.mapVirtualDisks.find(diCurrent.strDiskId);
3237	if (itVDisk == vsysThis.mapVirtualDisks.end())
3238	throw setError(E_FAIL,
3239	tr("Internal inconsistency looking up disk image '%s'"),
3240	diCurrent.strHref.c_str());
3241	}
3242	}
3243	else
3244	{
3245	++oit;
3246	}
3247	}
3248	else
3249	{
3250	++oit;
3251	continue;
3252	}
3253	}
3254	else
3255	{
3256	/* just continue with normal files*/
3257	++oit;
3258	}
3259
3260	const ovf::VirtualDisk &ovfVdisk = itVDisk->second;
3261
3262	/* very important to store disk name for the next checks */
3263	disksResolvedNames.insert(diCurrent.strHref);
3264
3265	ComObjPtr<Medium> pTargetHD;
3266
3267	Utf8Str savedVBoxCurrent = vsdeTargetHD->strVBoxCurrent;
3268
3269	i_importOneDiskImage(diCurrent,
3270	&vsdeTargetHD->strVBoxCurrent,
3271	pTargetHD,
3272	stack,
3273	pCallbacks,
3274	pStorage);
3275
3276	// now use the new uuid to attach the disk image to our new machine
3277	ComPtr<IMachine> sMachine;
3278	rc = stack.pSession->COMGETTER(Machine)(sMachine.asOutParam());
3279	if (FAILED(rc))
3280	throw rc;
3281
3282	// find the hard disk controller to which we should attach
3283	ovf::HardDiskController hdc = (*vsysThis.mapControllers.find(ovfVdisk.idController)).second;
3284
3285	// this is for rollback later
3286	MyHardDiskAttachment mhda;
3287	mhda.pMachine = pNewMachine;
3288
3289	i_convertDiskAttachmentValues(hdc,
3290	ovfVdisk.ulAddressOnParent,
3291	mhda.controllerType, // Bstr
3292	mhda.lControllerPort,
3293	mhda.lDevice);
3294
3295	Log(("Attaching disk %s to port %d on device %d\n",
3296	vsdeTargetHD->strVBoxCurrent.c_str(), mhda.lControllerPort, mhda.lDevice));
3297
3298	ComObjPtr<MediumFormat> mediumFormat;
3299	rc = i_findMediumFormatFromDiskImage(diCurrent, mediumFormat);
3300	if (FAILED(rc))
3301	throw rc;
3302
3303	Bstr bstrFormatName;
3304	rc = mediumFormat->COMGETTER(Name)(bstrFormatName.asOutParam());
3305	if (FAILED(rc))
3306	throw rc;
3307
3308	Utf8Str vdf = Utf8Str(bstrFormatName);
3309
3310	if (vdf.compare("RAW", Utf8Str::CaseInsensitive) == 0)
3311	{
3312	ComPtr<IMedium> dvdImage(pTargetHD);
3313
3314	rc = mVirtualBox->OpenMedium(Bstr(vsdeTargetHD->strVBoxCurrent).raw(),
3315	DeviceType_DVD,
3316	AccessMode_ReadWrite,
3317	false,
3318	dvdImage.asOutParam());
3319
3320	if (FAILED(rc))
3321	throw rc;
3322
3323	rc = sMachine->AttachDevice(mhda.controllerType.raw(),// wstring name
3324	mhda.lControllerPort, // long controllerPort
3325	mhda.lDevice, // long device
3326	DeviceType_DVD, // DeviceType_T type
3327	dvdImage);
3328	if (FAILED(rc))
3329	throw rc;
3330	}
3331	else
3332	{
3333	rc = sMachine->AttachDevice(mhda.controllerType.raw(),// wstring name
3334	mhda.lControllerPort, // long controllerPort
3335	mhda.lDevice, // long device
3336	DeviceType_HardDisk, // DeviceType_T type
3337	pTargetHD);
3338
3339	if (FAILED(rc))
3340	throw rc;
3341	}
3342
3343	stack.llHardDiskAttachments.push_back(mhda);
3344
3345	rc = sMachine->SaveSettings();
3346	if (FAILED(rc))
3347	throw rc;
3348
3349	/* restore */
3350	vsdeTargetHD->strVBoxCurrent = savedVBoxCurrent;
3351
3352	++cImportedDisks;
3353
3354	} // end while(oit != stack.mapDisks.end())
3355
3356	/*
3357	* quantity of the imported disks isn't equal to the size of the avsdeHDs list.
3358	*/
3359	if(cImportedDisks < avsdeHDs.size())
3360	{
3361	LogWarning(("Not all disk images were imported for VM %s. Check OVF description file.",
3362	vmNameEntry->strOvf.c_str()));
3363	}
3364
3365	// only now that we're done with all disks, close the session
3366	rc = stack.pSession->UnlockMachine();
3367	if (FAILED(rc))
3368	throw rc;
3369	stack.fSessionOpen = false;
3370	}
3371	catch(HRESULT aRC)
3372	{
3373	com::ErrorInfo info;
3374	if (stack.fSessionOpen)
3375	stack.pSession->UnlockMachine();
3376
3377	if (info.isFullAvailable())
3378	throw setError(aRC, Utf8Str(info.getText()).c_str());
3379	else
3380	throw setError(aRC, "Unknown error during OVF import");
3381	}
3382	}
3383	LogFlowFuncLeave();
3384	}
3385
3386	/**
3387	* Imports one OVF virtual system (described by a vbox:Machine tag represented by the given config
3388	* structure) into VirtualBox by creating an IMachine instance, which is returned.
3389	*
3390	* This throws HRESULT error codes for anything that goes wrong, in which case the caller must clean
3391	* up any leftovers from this function. For this, the given ImportStack instance has received information
3392	* about what needs cleaning up (to support rollback).
3393	*
3394	* The machine config stored in the settings::MachineConfigFile structure contains the UUIDs of
3395	* the disk attachments used by the machine when it was exported. We also add vbox:uuid attributes
3396	* to the OVF disks sections so we can look them up. While importing these UUIDs into a second host
3397	* will most probably work, reimporting them into the same host will cause conflicts, so we always
3398	* generate new ones on import. This involves the following:
3399	*
3400	* 1) Scan the machine config for disk attachments.
3401	*
3402	* 2) For each disk attachment found, look up the OVF disk image from the disk references section
3403	* and import the disk into VirtualBox, which creates a new UUID for it. In the machine config,
3404	* replace the old UUID with the new one.
3405	*
3406	* 3) Change the machine config according to the OVF virtual system descriptions, in case the
3407	* caller has modified them using setFinalValues().
3408	*
3409	* 4) Create the VirtualBox machine with the modfified machine config.
3410	*
3411	* @param config
3412	* @param pNewMachine
3413	* @param stack
3414	*/
3415	void Appliance::i_importVBoxMachine(ComObjPtr<VirtualSystemDescription> &vsdescThis,
3416	ComPtr<IMachine> &pReturnNewMachine,
3417	ImportStack &stack,
3418	PVDINTERFACEIO pCallbacks,
3419	PSHASTORAGE pStorage)
3420	{
3421	LogFlowFuncEnter();
3422	Assert(vsdescThis->m->pConfig);
3423
3424	HRESULT rc = S_OK;
3425
3426	settings::MachineConfigFile &config = *vsdescThis->m->pConfig;
3427
3428	/*
3429	* step 1): modify machine config according to OVF config, in case the user
3430	* has modified them using setFinalValues()
3431	*/
3432
3433	/* OS Type */
3434	config.machineUserData.strOsType = stack.strOsTypeVBox;
3435	/* Description */
3436	config.machineUserData.strDescription = stack.strDescription;
3437	/* CPU count & extented attributes */
3438	config.hardwareMachine.cCPUs = stack.cCPUs;
3439	if (stack.fForceIOAPIC)
3440	config.hardwareMachine.fHardwareVirt = true;
3441	if (stack.fForceIOAPIC)
3442	config.hardwareMachine.biosSettings.fIOAPICEnabled = true;
3443	/* RAM size */
3444	config.hardwareMachine.ulMemorySizeMB = stack.ulMemorySizeMB;
3445
3446	/*
3447	<const name="HardDiskControllerIDE" value="14" />
3448	<const name="HardDiskControllerSATA" value="15" />
3449	<const name="HardDiskControllerSCSI" value="16" />
3450	<const name="HardDiskControllerSAS" value="17" />
3451	*/
3452
3453	#ifdef VBOX_WITH_USB
3454	/* USB controller */
3455	if (stack.fUSBEnabled)
3456	{
3457	/** @todo r=klaus add support for arbitrary USB controller types, this can't handle
3458	* multiple controllers due to its design anyway */
3459	/* usually the OHCI controller is enabled already, need to check */
3460	bool fOHCIEnabled = false;
3461	settings::USBControllerList &llUSBControllers = config.hardwareMachine.usbSettings.llUSBControllers;
3462	settings::USBControllerList::iterator it;
3463	for (it = llUSBControllers.begin(); it != llUSBControllers.end(); ++it)
3464	{
3465	if (it->enmType == USBControllerType_OHCI)
3466	{
3467	fOHCIEnabled = true;
3468	break;
3469	}
3470	}
3471
3472	if (!fOHCIEnabled)
3473	{
3474	settings::USBController ctrl;
3475	ctrl.strName = "OHCI";
3476	ctrl.enmType = USBControllerType_OHCI;
3477
3478	llUSBControllers.push_back(ctrl);
3479	}
3480	}
3481	else
3482	config.hardwareMachine.usbSettings.llUSBControllers.clear();
3483	#endif
3484	/* Audio adapter */
3485	if (stack.strAudioAdapter.isNotEmpty())
3486	{
3487	config.hardwareMachine.audioAdapter.fEnabled = true;
3488	config.hardwareMachine.audioAdapter.controllerType = (AudioControllerType_T)stack.strAudioAdapter.toUInt32();
3489	}
3490	else
3491	config.hardwareMachine.audioAdapter.fEnabled = false;
3492	/* Network adapter */
3493	settings::NetworkAdaptersList &llNetworkAdapters = config.hardwareMachine.llNetworkAdapters;
3494	/* First disable all network cards, they will be enabled below again. */
3495	settings::NetworkAdaptersList::iterator it1;
3496	bool fKeepAllMACs = m->optListImport.contains(ImportOptions_KeepAllMACs);
3497	bool fKeepNATMACs = m->optListImport.contains(ImportOptions_KeepNATMACs);
3498	for (it1 = llNetworkAdapters.begin(); it1 != llNetworkAdapters.end(); ++it1)
3499	{
3500	it1->fEnabled = false;
3501	if (!( fKeepAllMACs
3502	\|\| (fKeepNATMACs && it1->mode == NetworkAttachmentType_NAT)
3503	\|\| (fKeepNATMACs && it1->mode == NetworkAttachmentType_NATNetwork)))
3504	Host::i_generateMACAddress(it1->strMACAddress);
3505	}
3506	/* Now iterate over all network entries. */
3507	std::list<VirtualSystemDescriptionEntry*> avsdeNWs = vsdescThis->i_findByType(VirtualSystemDescriptionType_NetworkAdapter);
3508	if (avsdeNWs.size() > 0)
3509	{
3510	/* Iterate through all network adapter entries and search for the
3511	* corresponding one in the machine config. If one is found, configure
3512	* it based on the user settings. */
3513	list<VirtualSystemDescriptionEntry*>::const_iterator itNW;
3514	for (itNW = avsdeNWs.begin();
3515	itNW != avsdeNWs.end();
3516	++itNW)
3517	{
3518	VirtualSystemDescriptionEntry vsdeNW = itNW;
3519	if ( vsdeNW->strExtraConfigCurrent.startsWith("slot=", Utf8Str::CaseInsensitive)
3520	&& vsdeNW->strExtraConfigCurrent.length() > 6)
3521	{
3522	uint32_t iSlot = vsdeNW->strExtraConfigCurrent.substr(5, 1).toUInt32();
3523	/* Iterate through all network adapters in the machine config. */
3524	for (it1 = llNetworkAdapters.begin();
3525	it1 != llNetworkAdapters.end();
3526	++it1)
3527	{
3528	/* Compare the slots. */
3529	if (it1->ulSlot == iSlot)
3530	{
3531	it1->fEnabled = true;
3532	it1->type = (NetworkAdapterType_T)vsdeNW->strVBoxCurrent.toUInt32();
3533	break;
3534	}
3535	}
3536	}
3537	}
3538	}
3539
3540	/* Floppy controller */
3541	bool fFloppy = vsdescThis->i_findByType(VirtualSystemDescriptionType_Floppy).size() > 0;
3542	/* DVD controller */
3543	bool fDVD = vsdescThis->i_findByType(VirtualSystemDescriptionType_CDROM).size() > 0;
3544	/* Iterate over all storage controller check the attachments and remove
3545	* them when necessary. Also detect broken configs with more than one
3546	* attachment. Old VirtualBox versions (prior to 3.2.10) had all disk
3547	* attachments pointing to the last hard disk image, which causes import
3548	* failures. A long fixed bug, however the OVF files are long lived. */
3549	settings::StorageControllersList &llControllers = config.storageMachine.llStorageControllers;
3550	Guid hdUuid;
3551	uint32_t cDisks = 0;
3552	bool fInconsistent = false;
3553	bool fRepairDuplicate = false;
3554	settings::StorageControllersList::iterator it3;
3555	for (it3 = llControllers.begin();
3556	it3 != llControllers.end();
3557	++it3)
3558	{
3559	settings::AttachedDevicesList &llAttachments = it3->llAttachedDevices;
3560	settings::AttachedDevicesList::iterator it4 = llAttachments.begin();
3561	while (it4 != llAttachments.end())
3562	{
3563	if ( ( !fDVD
3564	&& it4->deviceType == DeviceType_DVD)
3565	\|\|
3566	( !fFloppy
3567	&& it4->deviceType == DeviceType_Floppy))
3568	{
3569	it4 = llAttachments.erase(it4);
3570	continue;
3571	}
3572	else if (it4->deviceType == DeviceType_HardDisk)
3573	{
3574	const Guid &thisUuid = it4->uuid;
3575	cDisks++;
3576	if (cDisks == 1)
3577	{
3578	if (hdUuid.isZero())
3579	hdUuid = thisUuid;
3580	else
3581	fInconsistent = true;
3582	}
3583	else
3584	{
3585	if (thisUuid.isZero())
3586	fInconsistent = true;
3587	else if (thisUuid == hdUuid)
3588	fRepairDuplicate = true;
3589	}
3590	}
3591	++it4;
3592	}
3593	}
3594	/* paranoia... */
3595	if (fInconsistent \|\| cDisks == 1)
3596	fRepairDuplicate = false;
3597
3598	/*
3599	* step 2: scan the machine config for media attachments
3600	*/
3601	/* get VM name from virtual system description. Only one record is possible (size of list is equal 1). */
3602	std::list<VirtualSystemDescriptionEntry*> vmName = vsdescThis->i_findByType(VirtualSystemDescriptionType_Name);
3603	std::list<VirtualSystemDescriptionEntry*>::iterator vmNameIt = vmName.begin();
3604	VirtualSystemDescriptionEntry* vmNameEntry = *vmNameIt;
3605
3606	/* Get all hard disk descriptions. */
3607	std::list<VirtualSystemDescriptionEntry*> avsdeHDs = vsdescThis->i_findByType(VirtualSystemDescriptionType_HardDiskImage);
3608	std::list<VirtualSystemDescriptionEntry*>::iterator avsdeHDsIt = avsdeHDs.begin();
3609	/* paranoia - if there is no 1:1 match do not try to repair. */
3610	if (cDisks != avsdeHDs.size())
3611	fRepairDuplicate = false;
3612
3613	// there must be an image in the OVF disk structs with the same UUID
3614
3615	ovf::DiskImagesMap::const_iterator oit = stack.mapDisks.begin();
3616	std::set<RTCString> disksResolvedNames;
3617
3618	uint32_t cImportedDisks = 0;
3619
3620	while(oit != stack.mapDisks.end() && cImportedDisks != avsdeHDs.size())
3621	{
3622	ovf::DiskImage diCurrent = oit->second;
3623
3624	VirtualSystemDescriptionEntry *vsdeTargetHD = 0;
3625
3626	{
3627	/* Iterate over all given disk images of the virtual system
3628	* disks description. We need to find the target disk path,
3629	* which could be changed by the user. */
3630	list<VirtualSystemDescriptionEntry*>::const_iterator itHD;
3631	for (itHD = avsdeHDs.begin();
3632	itHD != avsdeHDs.end();
3633	++itHD)
3634	{
3635	VirtualSystemDescriptionEntry vsdeHD = itHD;
3636	if (vsdeHD->strRef == oit->first)
3637	{
3638	vsdeTargetHD = vsdeHD;
3639	break;
3640	}
3641	}
3642	if (!vsdeTargetHD)
3643	{
3644	/* possible case if a disk image belongs to other virtual system (OVF package with multiple VMs inside) */
3645	LogWarning(("OVA/OVF import: Disk image %s was missed during import of VM %s\n",
3646	oit->first.c_str(), vmNameEntry->strOvf.c_str()));
3647	NOREF(vmNameEntry);
3648	++oit;
3649	continue;
3650	}
3651	}
3652
3653	/*
3654	* preliminary check availability of the image
3655	* This step is useful if image is placed in the OVA (TAR) package
3656	*/
3657
3658	Utf8Str name = i_applianceIOName(applianceIOTar);
3659
3660	if (strncmp(pStorage->pVDImageIfaces->pszInterfaceName, name.c_str(), name.length()) == 0)
3661	{
3662	/* It means that we possibly have imported the storage earlier on the previous loop steps*/
3663	std::set<RTCString>::const_iterator h = disksResolvedNames.find(diCurrent.strHref);
3664	if (h != disksResolvedNames.end())
3665	{
3666	/* Yes, disk name was found, we can skip it*/
3667	++oit;
3668	continue;
3669	}
3670
3671	RTCString availableImage(diCurrent.strHref);
3672
3673	rc = i_preCheckImageAvailability(pStorage, availableImage);
3674
3675	if (SUCCEEDED(rc))
3676	{
3677	/* current opened file isn't the same as passed one */
3678	if(availableImage.compare(diCurrent.strHref, Utf8Str::CaseInsensitive) != 0)
3679	{
3680	// availableImage contains the disk identifier (e.g. "vmdisk1"), which should exist
3681	// in the virtual system's disks map under that ID and also in the global images map
3682	// and find the disk from the OVF's disk list
3683	ovf::DiskImagesMap::const_iterator itDiskImage = stack.mapDisks.begin();
3684	while (++itDiskImage != stack.mapDisks.end())
3685	{
3686	if(itDiskImage->second.strHref.compare(availableImage, Utf8Str::CaseInsensitive) == 0 )
3687	break;
3688	}
3689	if (itDiskImage == stack.mapDisks.end())
3690	{
3691	throw setError(E_FAIL,
3692	tr("Internal inconsistency looking up disk image '%s'. "
3693	"Check compliance OVA package structure and file names "
3694	"references in the section <References> in the OVF file."),
3695	availableImage.c_str());
3696	}
3697
3698	/* replace with a new found disk image */
3699	diCurrent = *(&itDiskImage->second);
3700
3701	/*
3702	* Again iterate over all given disk images of the virtual system
3703	* disks description using the found disk image
3704	*/
3705	list<VirtualSystemDescriptionEntry*>::const_iterator itHD;
3706	for (itHD = avsdeHDs.begin();
3707	itHD != avsdeHDs.end();
3708	++itHD)
3709	{
3710	VirtualSystemDescriptionEntry vsdeHD = itHD;
3711	if (vsdeHD->strRef == diCurrent.strDiskId)
3712	{
3713	vsdeTargetHD = vsdeHD;
3714	break;
3715	}
3716	}
3717	if (!vsdeTargetHD)
3718	/*
3719	* in this case it's an error because something wrong with OVF description file.
3720	* May be VBox imports OVA package with wrong file sequence inside the archive.
3721	*/
3722	throw setError(E_FAIL,
3723	tr("Internal inconsistency looking up disk image '%s'"),
3724	diCurrent.strHref.c_str());
3725	}
3726	else
3727	{
3728	++oit;
3729	}
3730	}
3731	else
3732	{
3733	++oit;
3734	continue;
3735	}
3736	}
3737	else
3738	{
3739	/* just continue with normal files*/
3740	++oit;
3741	}
3742
3743	/* Important! to store disk name for the next checks */
3744	disksResolvedNames.insert(diCurrent.strHref);
3745
3746	// there must be an image in the OVF disk structs with the same UUID
3747	bool fFound = false;
3748	Utf8Str strUuid;
3749
3750	// for each storage controller...
3751	for (settings::StorageControllersList::iterator sit = config.storageMachine.llStorageControllers.begin();
3752	sit != config.storageMachine.llStorageControllers.end();
3753	++sit)
3754	{
3755	settings::StorageController &sc = *sit;
3756
3757	// find the OVF virtual system description entry for this storage controller
3758	switch (sc.storageBus)
3759	{
3760	case StorageBus_SATA:
3761	break;
3762	case StorageBus_SCSI:
3763	break;
3764	case StorageBus_IDE:
3765	break;
3766	case StorageBus_SAS:
3767	break;
3768	}
3769
3770	// for each medium attachment to this controller...
3771	for (settings::AttachedDevicesList::iterator dit = sc.llAttachedDevices.begin();
3772	dit != sc.llAttachedDevices.end();
3773	++dit)
3774	{
3775	settings::AttachedDevice &d = *dit;
3776
3777	if (d.uuid.isZero())
3778	// empty DVD and floppy media
3779	continue;
3780
3781	// When repairing a broken VirtualBox xml config section (written
3782	// by VirtualBox versions earlier than 3.2.10) assume the disks
3783	// show up in the same order as in the OVF description.
3784	if (fRepairDuplicate)
3785	{
3786	VirtualSystemDescriptionEntry vsdeHD = avsdeHDsIt;
3787	ovf::DiskImagesMap::const_iterator itDiskImage = stack.mapDisks.find(vsdeHD->strRef);
3788	if (itDiskImage != stack.mapDisks.end())
3789	{
3790	const ovf::DiskImage &di = itDiskImage->second;
3791	d.uuid = Guid(di.uuidVBox);
3792	}
3793	++avsdeHDsIt;
3794	}
3795
3796	// convert the Guid to string
3797	strUuid = d.uuid.toString();
3798
3799	if (diCurrent.uuidVBox != strUuid)
3800	{
3801	continue;
3802	}
3803
3804	/*
3805	* step 3: import disk
3806	*/
3807	Utf8Str savedVBoxCurrent = vsdeTargetHD->strVBoxCurrent;
3808	ComObjPtr<Medium> pTargetHD;
3809	i_importOneDiskImage(diCurrent,
3810	&vsdeTargetHD->strVBoxCurrent,
3811	pTargetHD,
3812	stack,
3813	pCallbacks,
3814	pStorage);
3815
3816	Bstr hdId;
3817
3818	ComObjPtr<MediumFormat> mediumFormat;
3819	rc = i_findMediumFormatFromDiskImage(diCurrent, mediumFormat);
3820	if (FAILED(rc))
3821	throw rc;
3822
3823	Bstr bstrFormatName;
3824	rc = mediumFormat->COMGETTER(Name)(bstrFormatName.asOutParam());
3825	if (FAILED(rc))
3826	throw rc;
3827
3828	Utf8Str vdf = Utf8Str(bstrFormatName);
3829
3830	if (vdf.compare("RAW", Utf8Str::CaseInsensitive) == 0)
3831	{
3832	ComPtr<IMedium> dvdImage(pTargetHD);
3833
3834	rc = mVirtualBox->OpenMedium(Bstr(vsdeTargetHD->strVBoxCurrent).raw(),
3835	DeviceType_DVD,
3836	AccessMode_ReadWrite,
3837	false,
3838	dvdImage.asOutParam());
3839
3840	if (FAILED(rc)) throw rc;
3841
3842	// ... and replace the old UUID in the machine config with the one of
3843	// the imported disk that was just created
3844	rc = dvdImage->COMGETTER(Id)(hdId.asOutParam());
3845	if (FAILED(rc)) throw rc;
3846	}
3847	else
3848	{
3849	// ... and replace the old UUID in the machine config with the one of
3850	// the imported disk that was just created
3851	rc = pTargetHD->COMGETTER(Id)(hdId.asOutParam());
3852	if (FAILED(rc)) throw rc;
3853	}
3854
3855	/* restore */
3856	vsdeTargetHD->strVBoxCurrent = savedVBoxCurrent;
3857
3858	/*
3859	* 1. saving original UUID for restoring in case of failure.
3860	* 2. replacement of original UUID by new UUID in the current VM config (settings::MachineConfigFile).
3861	*/
3862	{
3863	rc = stack.saveOriginalUUIDOfAttachedDevice(d, Utf8Str(hdId));
3864	d.uuid = hdId;
3865	}
3866
3867	fFound = true;
3868	break;
3869	} // for (settings::AttachedDevicesList::const_iterator dit = sc.llAttachedDevices.begin();
3870	} // for (settings::StorageControllersList::const_iterator sit = config.storageMachine.llStorageControllers.begin();
3871
3872	// no disk with such a UUID found:
3873	if (!fFound)
3874	throw setError(E_FAIL,
3875	tr("<vbox:Machine> element in OVF contains a medium attachment for the disk image %s "
3876	"but the OVF describes no such image"),
3877	strUuid.c_str());
3878
3879	++cImportedDisks;
3880
3881	}// while(oit != stack.mapDisks.end())
3882
3883
3884	/*
3885	* quantity of the imported disks isn't equal to the size of the avsdeHDs list.
3886	*/
3887	if(cImportedDisks < avsdeHDs.size())
3888	{
3889	LogWarning(("Not all disk images were imported for VM %s. Check OVF description file.",
3890	vmNameEntry->strOvf.c_str()));
3891	}
3892
3893	/*
3894	* step 4): create the machine and have it import the config
3895	*/
3896
3897	ComObjPtr<Machine> pNewMachine;
3898	rc = pNewMachine.createObject();
3899	if (FAILED(rc)) throw rc;
3900
3901	// this magic constructor fills the new machine object with the MachineConfig
3902	// instance that we created from the vbox:Machine
3903	rc = pNewMachine->init(mVirtualBox,
3904	stack.strNameVBox,// name from OVF preparations; can be suffixed to avoid duplicates
3905	config); // the whole machine config
3906	if (FAILED(rc)) throw rc;
3907
3908	pReturnNewMachine = ComPtr<IMachine>(pNewMachine);
3909
3910	// and register it
3911	rc = mVirtualBox->RegisterMachine(pNewMachine);
3912	if (FAILED(rc)) throw rc;
3913
3914	// store new machine for roll-back in case of errors
3915	Bstr bstrNewMachineId;
3916	rc = pNewMachine->COMGETTER(Id)(bstrNewMachineId.asOutParam());
3917	if (FAILED(rc)) throw rc;
3918	m->llGuidsMachinesCreated.push_back(Guid(bstrNewMachineId));
3919
3920	LogFlowFuncLeave();
3921	}
3922
3923	void Appliance::i_importMachines(ImportStack &stack,
3924	PVDINTERFACEIO pCallbacks,
3925	PSHASTORAGE pStorage)
3926	{
3927	HRESULT rc = S_OK;
3928
3929	// this is safe to access because this thread only gets started
3930	const ovf::OVFReader &reader = *m->pReader;
3931
3932	/*
3933	* get the SHA digest version that was set in accordance with the value of attribute "xmlns:ovf"
3934	* of the element <Envelope> in the OVF file during reading operation. See readFSImpl().
3935	*/
3936	pStorage->fSha256 = m->fSha256;
3937
3938	// create a session for the machine + disks we manipulate below
3939	rc = stack.pSession.createInprocObject(CLSID_Session);
3940	if (FAILED(rc)) throw rc;
3941
3942	list<ovf::VirtualSystem>::const_iterator it;
3943	list< ComObjPtr<VirtualSystemDescription> >::const_iterator it1;
3944	/* Iterate through all virtual systems of that appliance */
3945	size_t i = 0;
3946	for (it = reader.m_llVirtualSystems.begin(), it1 = m->virtualSystemDescriptions.begin();
3947	it != reader.m_llVirtualSystems.end() && it1 != m->virtualSystemDescriptions.end();
3948	++it, ++it1, ++i)
3949	{
3950	const ovf::VirtualSystem &vsysThis = *it;
3951	ComObjPtr<VirtualSystemDescription> vsdescThis = (*it1);
3952
3953	ComPtr<IMachine> pNewMachine;
3954
3955	// there are two ways in which we can create a vbox machine from OVF:
3956	// -- either this OVF was written by vbox 3.2 or later, in which case there is a <vbox:Machine> element
3957	// in the <VirtualSystem>; then the VirtualSystemDescription::Data has a settings::MachineConfigFile
3958	// with all the machine config pretty-parsed;
3959	// -- or this is an OVF from an older vbox or an external source, and then we need to translate the
3960	// VirtualSystemDescriptionEntry and do import work
3961
3962	// Even for the vbox:Machine case, there are a number of configuration items that will be taken from
3963	// the OVF because otherwise the "override import parameters" mechanism in the GUI won't work.
3964
3965	// VM name
3966	std::list<VirtualSystemDescriptionEntry*> vsdeName = vsdescThis->i_findByType(VirtualSystemDescriptionType_Name);
3967	if (vsdeName.size() < 1)
3968	throw setError(VBOX_E_FILE_ERROR,
3969	tr("Missing VM name"));
3970	stack.strNameVBox = vsdeName.front()->strVBoxCurrent;
3971
3972	// have VirtualBox suggest where the filename would be placed so we can
3973	// put the disk images in the same directory
3974	Bstr bstrMachineFilename;
3975	rc = mVirtualBox->ComposeMachineFilename(Bstr(stack.strNameVBox).raw(),
3976	NULL /* aGroup */,
3977	NULL /* aCreateFlags */,
3978	NULL /* aBaseFolder */,
3979	bstrMachineFilename.asOutParam());
3980	if (FAILED(rc)) throw rc;
3981	// and determine the machine folder from that
3982	stack.strMachineFolder = bstrMachineFilename;
3983	stack.strMachineFolder.stripFilename();
3984	LogFunc(("i=%zu strName=%s bstrMachineFilename=%ls\n", i, stack.strNameVBox.c_str(), bstrMachineFilename.raw()));
3985
3986	// guest OS type
3987	std::list<VirtualSystemDescriptionEntry*> vsdeOS;
3988	vsdeOS = vsdescThis->i_findByType(VirtualSystemDescriptionType_OS);
3989	if (vsdeOS.size() < 1)
3990	throw setError(VBOX_E_FILE_ERROR,
3991	tr("Missing guest OS type"));
3992	stack.strOsTypeVBox = vsdeOS.front()->strVBoxCurrent;
3993
3994	// CPU count
3995	std::list<VirtualSystemDescriptionEntry*> vsdeCPU = vsdescThis->i_findByType(VirtualSystemDescriptionType_CPU);
3996	if (vsdeCPU.size() != 1)
3997	throw setError(VBOX_E_FILE_ERROR, tr("CPU count missing"));
3998
3999	stack.cCPUs = vsdeCPU.front()->strVBoxCurrent.toUInt32();
4000	// We need HWVirt & IO-APIC if more than one CPU is requested
4001	if (stack.cCPUs > 1)
4002	{
4003	stack.fForceHWVirt = true;
4004	stack.fForceIOAPIC = true;
4005	}
4006
4007	// RAM
4008	std::list<VirtualSystemDescriptionEntry*> vsdeRAM = vsdescThis->i_findByType(VirtualSystemDescriptionType_Memory);
4009	if (vsdeRAM.size() != 1)
4010	throw setError(VBOX_E_FILE_ERROR, tr("RAM size missing"));
4011	stack.ulMemorySizeMB = (ULONG)vsdeRAM.front()->strVBoxCurrent.toUInt64();
4012
4013	#ifdef VBOX_WITH_USB
4014	// USB controller
4015	std::list<VirtualSystemDescriptionEntry*> vsdeUSBController =
4016	vsdescThis->i_findByType(VirtualSystemDescriptionType_USBController);
4017	// USB support is enabled if there's at least one such entry; to disable USB support,
4018	// the type of the USB item would have been changed to "ignore"
4019	stack.fUSBEnabled = vsdeUSBController.size() > 0;
4020	#endif
4021	// audio adapter
4022	std::list<VirtualSystemDescriptionEntry*> vsdeAudioAdapter =
4023	vsdescThis->i_findByType(VirtualSystemDescriptionType_SoundCard);
4024	/* @todo: we support one audio adapter only */
4025	if (vsdeAudioAdapter.size() > 0)
4026	stack.strAudioAdapter = vsdeAudioAdapter.front()->strVBoxCurrent;
4027
4028	// for the description of the new machine, always use the OVF entry, the user may have changed it in the import config
4029	std::list<VirtualSystemDescriptionEntry*> vsdeDescription =
4030	vsdescThis->i_findByType(VirtualSystemDescriptionType_Description);
4031	if (vsdeDescription.size())
4032	stack.strDescription = vsdeDescription.front()->strVBoxCurrent;
4033
4034	// import vbox:machine or OVF now
4035	if (vsdescThis->m->pConfig)
4036	// vbox:Machine config
4037	i_importVBoxMachine(vsdescThis, pNewMachine, stack, pCallbacks, pStorage);
4038	else
4039	// generic OVF config
4040	i_importMachineGeneric(vsysThis, vsdescThis, pNewMachine, stack, pCallbacks, pStorage);
4041
4042	} // for (it = pAppliance->m->llVirtualSystems.begin() ...
4043	}
4044
4045	HRESULT Appliance::ImportStack::saveOriginalUUIDOfAttachedDevice(settings::AttachedDevice &device,
4046	const Utf8Str &newlyUuid)
4047	{
4048	HRESULT rc = S_OK;
4049
4050	/* save for restoring */
4051	mapNewUUIDsToOriginalUUIDs.insert(std::make_pair(newlyUuid, device.uuid.toString()));
4052
4053	return rc;
4054	}
4055
4056	HRESULT Appliance::ImportStack::restoreOriginalUUIDOfAttachedDevice(settings::MachineConfigFile *config)
4057	{
4058	HRESULT rc = S_OK;
4059
4060	settings::StorageControllersList &llControllers = config->storageMachine.llStorageControllers;
4061	settings::StorageControllersList::iterator itscl;
4062	for (itscl = llControllers.begin();
4063	itscl != llControllers.end();
4064	++itscl)
4065	{
4066	settings::AttachedDevicesList &llAttachments = itscl->llAttachedDevices;
4067	settings::AttachedDevicesList::iterator itadl = llAttachments.begin();
4068	while (itadl != llAttachments.end())
4069	{
4070	std::map<Utf8Str , Utf8Str>::iterator it =
4071	mapNewUUIDsToOriginalUUIDs.find(itadl->uuid.toString());
4072	if(it!=mapNewUUIDsToOriginalUUIDs.end())
4073	{
4074	Utf8Str uuidOriginal = it->second;
4075	itadl->uuid = Guid(uuidOriginal);
4076	mapNewUUIDsToOriginalUUIDs.erase(it->first);
4077	}
4078	++itadl;
4079	}
4080	}
4081
4082	return rc;
4083	}
4084

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

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

Download in other formats: