ApplianceImplImport.cpp@ 78923

Last change on this file since 78923 was 78923, checked in by vboxsync, 6 years ago
bugref:9416. Changed the choosing OS type logic for OCI import. Added small private helper function i_setApplianceState(). Moved ApplianceState from Appliance::Data to Appliance.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 218.7 KB

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

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

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

Download in other formats: