ApplianceImplImport.cpp@ 47470

Last change on this file since 47470 was 47401, checked in by vboxsync, 11 years ago
Main,Frontends: Second step of USB controller rework. There is one controller instance for every USB controller now. Adapt frontends and testsuite to work with the changed API
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 153.8 KB

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

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

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

Download in other formats: