ApplianceImplImport.cpp@ 60952

Last change on this file since 60952 was 60341, checked in by vboxsync, 9 years ago
ICertificate, Import wizard: Some adjustments to make it do and show what comment 22 indicated. Note that the 3rd case (mismatching signature) is handled via errors set by Appliance::i_readTailProcessing.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 174.9 KB

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

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

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

Download in other formats: