VirtualBox

source: vbox/trunk/src/VBox/Main/ApplianceImpl.cpp@ 18599

Last change on this file since 18599 was 18591, checked in by vboxsync, 16 years ago

E1000: Added support for 82545EM (MT Server)
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 184.3 KB
Line 
1/* $Id: ApplianceImpl.cpp 18591 2009-04-01 10:11:51Z vboxsync $ */
2/** @file
3 *
4 * IAppliance and IVirtualSystem COM class implementations.
5 */
6
7/*
8 * Copyright (C) 2008-2009 Sun Microsystems, Inc.
9 *
10 * This file is part of VirtualBox Open Source Edition (OSE), as
11 * available from http://www.virtualbox.org. This file is free software;
12 * you can redistribute it and/or modify it under the terms of the GNU
13 * General Public License (GPL) as published by the Free Software
14 * Foundation, in version 2 as it comes in the "COPYING" file of the
15 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
16 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
17 *
18 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
19 * Clara, CA 95054 USA or visit http://www.sun.com if you need
20 * additional information or have any questions.
21 */
22
23#include <VBox/param.h>
24#include <iprt/stream.h>
25#include <iprt/path.h>
26#include <iprt/dir.h>
27#include <iprt/file.h>
28
29#include "ApplianceImpl.h"
30#include "VirtualBoxImpl.h"
31#include "GuestOSTypeImpl.h"
32#include "ProgressImpl.h"
33#include "MachineImpl.h"
34#include "HostNetworkInterfaceImpl.h"
35
36#include "Logging.h"
37
38#include "VBox/xml.h"
39
40using namespace std;
41
42////////////////////////////////////////////////////////////////////////////////
43//
44// hardware definitions
45//
46////////////////////////////////////////////////////////////////////////////////
47
48struct DiskImage
49{
50 Utf8Str strDiskId; // value from DiskSection/Disk/@diskId
51 int64_t iCapacity; // value from DiskSection/Disk/@capacity;
52 // (maximum size for dynamic images, I guess; we always translate this to bytes)
53 int64_t iPopulatedSize; // optional value from DiskSection/Disk/@populatedSize
54 // (actual used size of disk, always in bytes; can be an estimate of used disk
55 // space, but cannot be larger than iCapacity; -1 if not set)
56 Utf8Str strFormat; // value from DiskSection/Disk/@format
57 // typically http://www.vmware.com/specifications/vmdk.html#sparse
58
59 // fields from /References/File; the spec says the file reference from disk can be empty,
60 // so in that case, strFilename will be empty, then a new disk should be created
61 Utf8Str strHref; // value from /References/File/@href (filename); if empty, then the remaining fields are ignored
62 int64_t iSize; // value from /References/File/@size (optional according to spec; then we set -1 here)
63 int64_t iChunkSize; // value from /References/File/@chunkSize (optional, unsupported)
64 Utf8Str strCompression; // value from /References/File/@compression (optional, can be "gzip" according to spec)
65};
66
67struct VirtualHardwareItem
68{
69 Utf8Str strDescription;
70 Utf8Str strCaption;
71 Utf8Str strElementName;
72
73 uint32_t ulInstanceID;
74 uint32_t ulParent;
75
76 OVFResourceType_T resourceType;
77 Utf8Str strOtherResourceType;
78 Utf8Str strResourceSubType;
79
80 Utf8Str strHostResource; // "Abstractly specifies how a device shall connect to a resource on the deployment platform.
81 // Not all devices need a backing." Used with disk items, for which this references a virtual
82 // disk from the Disks section.
83 bool fAutomaticAllocation;
84 bool fAutomaticDeallocation;
85 Utf8Str strConnection; // "All Ethernet adapters that specify the same abstract network connection name within an OVF
86 // package shall be deployed on the same network. The abstract network connection name shall be
87 // listed in the NetworkSection at the outermost envelope level." We ignore this and only set up
88 // a network adapter depending on the network name.
89 Utf8Str strAddress; // "Device-specific. For an Ethernet adapter, this specifies the MAC address."
90 Utf8Str strAddressOnParent; // "For a device, this specifies its location on the controller."
91 Utf8Str strAllocationUnits; // "Specifies the units of allocation used. For example, “byte * 2^20”."
92 uint64_t ullVirtualQuantity; // "Specifies the quantity of resources presented. For example, “256”."
93 uint64_t ullReservation; // "Specifies the minimum quantity of resources guaranteed to be available."
94 uint64_t ullLimit; // "Specifies the maximum quantity of resources that will be granted."
95 uint64_t ullWeight; // "Specifies a relative priority for this allocation in relation to other allocations."
96
97 Utf8Str strConsumerVisibility;
98 Utf8Str strMappingBehavior;
99 Utf8Str strPoolID;
100 uint32_t ulBusNumber; // seen with IDE controllers, but not listed in OVF spec
101
102 uint32_t ulLineNumber; // line number of <Item> element in XML source; cached for error messages
103
104 VirtualHardwareItem()
105 : ulInstanceID(0), fAutomaticAllocation(false), fAutomaticDeallocation(false), ullVirtualQuantity(0), ullReservation(0), ullLimit(0), ullWeight(0), ulBusNumber(0), ulLineNumber(0)
106 {};
107};
108
109typedef map<Utf8Str, DiskImage> DiskImagesMap;
110
111struct VirtualSystem;
112
113typedef map<uint32_t, VirtualHardwareItem> HardwareItemsMap;
114
115struct HardDiskController
116{
117 uint32_t idController; // instance ID (Item/InstanceId); this gets referenced from HardDisk
118 enum ControllerSystemType { IDE, SATA, SCSI };
119 ControllerSystemType system; // one of IDE, SATA, SCSI
120 Utf8Str strControllerType; // controller subtype (Item/ResourceSubType); e.g. "LsiLogic"; can be empty (esp. for IDE)
121 Utf8Str strAddress; // for IDE
122 uint32_t ulBusNumber; // for IDE
123
124 HardDiskController()
125 : idController(0),
126 ulBusNumber(0)
127 {
128 }
129};
130
131typedef map<uint32_t, HardDiskController> ControllersMap;
132
133struct VirtualDisk
134{
135 uint32_t idController; // SCSI (or IDE) controller this disk is connected to;
136 // points into VirtualSystem.mapControllers
137 uint32_t ulAddressOnParent; // parsed strAddressOnParent of hardware item; will be 0 or 1 for IDE
138 // and possibly higher for disks attached to SCSI controllers (untested)
139 Utf8Str strDiskId; // if the hard disk has an ovf:/disk/<id> reference,
140 // this receives the <id> component; points to one of the
141 // references in Appliance::Data.mapDisks
142};
143
144typedef map<Utf8Str, VirtualDisk> VirtualDisksMap;
145
146struct EthernetAdapter
147{
148 Utf8Str strAdapterType; // "PCNet32" or "E1000" or whatever; from <rasd:ResourceSubType>
149 Utf8Str strNetworkName; // from <rasd:Connection>
150};
151
152typedef list<EthernetAdapter> EthernetAdaptersList;
153
154struct VirtualSystem
155{
156 Utf8Str strName; // copy of VirtualSystem/@id
157
158 Utf8Str strDescription; // copy of VirtualSystem/Info content
159
160 CIMOSType_T cimos;
161 Utf8Str strCimosDesc; // readable description of the cimos type in the case of cimos = 0/1/102
162 Utf8Str strVirtualSystemType; // generic hardware description; OVF says this can be something like "vmx-4" or "xen";
163 // VMware Workstation 6.5 is "vmx-07"
164
165 HardwareItemsMap mapHardwareItems; // map of virtual hardware items, sorted by unique instance ID
166
167 uint64_t ullMemorySize; // always in bytes, copied from llHardwareItems; default = 0 (unspecified)
168 uint16_t cCPUs; // no. of CPUs, copied from llHardwareItems; default = 1
169
170 EthernetAdaptersList llEthernetAdapters; // (one for each VirtualSystem/Item[@ResourceType=10]element)
171
172 ControllersMap mapControllers;
173 // list of hard disk controllers
174 // (one for each VirtualSystem/Item[@ResourceType=6] element with accumulated data from children)
175
176 VirtualDisksMap mapVirtualDisks;
177 // (one for each VirtualSystem/Item[@ResourceType=17] element with accumulated data from children)
178
179 bool fHasFloppyDrive; // true if there's a floppy item in mapHardwareItems
180 bool fHasCdromDrive; // true if there's a CD-ROM item in mapHardwareItems; ISO images are not yet supported by OVFtool
181 bool fHasUsbController; // true if there's a USB controller item in mapHardwareItems
182
183 Utf8Str strSoundCardType; // if not empty, then the system wants a soundcard; this then specifies the hardware;
184 // VMware Workstation 6.5 uses "ensoniq1371" for example
185
186 Utf8Str strLicenseText; // license info if any; receives contents of VirtualSystem/EulaSection/License
187
188 Utf8Str strProduct; // product info if any; receives contents of VirtualSystem/ProductSection/Product
189 Utf8Str strVendor; // product info if any; receives contents of VirtualSystem/ProductSection/Vendor
190 Utf8Str strVersion; // product info if any; receives contents of VirtualSystem/ProductSection/Version
191 Utf8Str strProductUrl; // product info if any; receives contents of VirtualSystem/ProductSection/ProductUrl
192 Utf8Str strVendorUrl; // product info if any; receives contents of VirtualSystem/ProductSection/VendorUrl
193
194 VirtualSystem()
195 : ullMemorySize(0), cCPUs(1), fHasFloppyDrive(false), fHasCdromDrive(false), fHasUsbController(false)
196 {
197 }
198};
199
200////////////////////////////////////////////////////////////////////////////////
201//
202// Appliance data definition
203//
204////////////////////////////////////////////////////////////////////////////////
205
206// opaque private instance data of Appliance class
207struct Appliance::Data
208{
209 Utf8Str strPath; // file name last given to either read() or write()
210
211 DiskImagesMap mapDisks; // map of DiskImage structs, sorted by DiskImage.strDiskId
212
213 list<VirtualSystem> llVirtualSystems; // list of virtual systems, created by and valid after read()
214
215 list< ComObjPtr<VirtualSystemDescription> > virtualSystemDescriptions; //
216
217 list<Utf8Str> llWarnings;
218
219 ULONG ulWeightPerOperation; // for progress calculations
220};
221
222struct VirtualSystemDescription::Data
223{
224 list<VirtualSystemDescriptionEntry> llDescriptions;
225};
226
227////////////////////////////////////////////////////////////////////////////////
228//
229// internal helpers
230//
231////////////////////////////////////////////////////////////////////////////////
232
233static Utf8Str stripFilename(const Utf8Str &strFile)
234{
235 Utf8Str str2(strFile);
236 RTPathStripFilename(str2.mutableRaw());
237 return str2;
238}
239
240static const struct
241{
242 CIMOSType_T cim;
243 const char *pcszVbox;
244}
245 g_osTypes[] =
246 {
247 { CIMOSType_CIMOS_Unknown, SchemaDefs_OSTypeId_Other },
248 { CIMOSType_CIMOS_OS2, SchemaDefs_OSTypeId_OS2 },
249 { CIMOSType_CIMOS_MSDOS, SchemaDefs_OSTypeId_DOS },
250 { CIMOSType_CIMOS_WIN3x, SchemaDefs_OSTypeId_Windows31 },
251 { CIMOSType_CIMOS_WIN95, SchemaDefs_OSTypeId_Windows95 },
252 { CIMOSType_CIMOS_WIN98, SchemaDefs_OSTypeId_Windows98 },
253 { CIMOSType_CIMOS_WINNT, SchemaDefs_OSTypeId_WindowsNT4 },
254 { CIMOSType_CIMOS_NetWare, SchemaDefs_OSTypeId_Netware },
255 { CIMOSType_CIMOS_NovellOES, SchemaDefs_OSTypeId_Netware },
256 { CIMOSType_CIMOS_Solaris, SchemaDefs_OSTypeId_OpenSolaris },
257 { CIMOSType_CIMOS_SunOS, SchemaDefs_OSTypeId_OpenSolaris },
258 { CIMOSType_CIMOS_FreeBSD, SchemaDefs_OSTypeId_FreeBSD },
259 { CIMOSType_CIMOS_NetBSD, SchemaDefs_OSTypeId_NetBSD },
260 { CIMOSType_CIMOS_QNX, SchemaDefs_OSTypeId_QNX },
261 { CIMOSType_CIMOS_Windows2000, SchemaDefs_OSTypeId_Windows2000 },
262 { CIMOSType_CIMOS_WindowsMe, SchemaDefs_OSTypeId_WindowsMe },
263 { CIMOSType_CIMOS_OpenBSD, SchemaDefs_OSTypeId_OpenBSD },
264 { CIMOSType_CIMOS_WindowsXP, SchemaDefs_OSTypeId_WindowsXP },
265 { CIMOSType_CIMOS_WindowsXPEmbedded, SchemaDefs_OSTypeId_WindowsXP },
266 { CIMOSType_CIMOS_WindowsEmbeddedforPointofService, SchemaDefs_OSTypeId_WindowsXP },
267 { CIMOSType_CIMOS_MicrosoftWindowsServer2003, SchemaDefs_OSTypeId_Windows2003 },
268 { CIMOSType_CIMOS_MicrosoftWindowsServer2003_64, SchemaDefs_OSTypeId_Windows2003_64 },
269 { CIMOSType_CIMOS_WindowsXP_64, SchemaDefs_OSTypeId_WindowsXP_64 },
270 { CIMOSType_CIMOS_WindowsVista, SchemaDefs_OSTypeId_WindowsVista },
271 { CIMOSType_CIMOS_WindowsVista_64, SchemaDefs_OSTypeId_WindowsVista_64 },
272 { CIMOSType_CIMOS_MicrosoftWindowsServer2008, SchemaDefs_OSTypeId_Windows2008 },
273 { CIMOSType_CIMOS_MicrosoftWindowsServer2008_64, SchemaDefs_OSTypeId_Windows2008_64 },
274 { CIMOSType_CIMOS_FreeBSD_64, SchemaDefs_OSTypeId_FreeBSD_64 },
275 { CIMOSType_CIMOS_RedHatEnterpriseLinux, SchemaDefs_OSTypeId_RedHat },
276 { CIMOSType_CIMOS_RedHatEnterpriseLinux_64, SchemaDefs_OSTypeId_RedHat_64 },
277 { CIMOSType_CIMOS_Solaris_64, SchemaDefs_OSTypeId_OpenSolaris_64 },
278 { CIMOSType_CIMOS_SUSE, SchemaDefs_OSTypeId_OpenSUSE },
279 { CIMOSType_CIMOS_SLES, SchemaDefs_OSTypeId_OpenSUSE },
280 { CIMOSType_CIMOS_NovellLinuxDesktop, SchemaDefs_OSTypeId_OpenSUSE },
281 { CIMOSType_CIMOS_SUSE_64, SchemaDefs_OSTypeId_OpenSUSE_64 },
282 { CIMOSType_CIMOS_SLES_64, SchemaDefs_OSTypeId_OpenSUSE_64 },
283 { CIMOSType_CIMOS_LINUX, SchemaDefs_OSTypeId_Linux },
284 { CIMOSType_CIMOS_SunJavaDesktopSystem, SchemaDefs_OSTypeId_Linux },
285 { CIMOSType_CIMOS_TurboLinux, SchemaDefs_OSTypeId_Linux},
286
287 // { CIMOSType_CIMOS_TurboLinux_64, },
288
289 { CIMOSType_CIMOS_Mandriva, SchemaDefs_OSTypeId_Mandriva },
290 { CIMOSType_CIMOS_Mandriva_64, SchemaDefs_OSTypeId_Mandriva_64 },
291 { CIMOSType_CIMOS_Ubuntu, SchemaDefs_OSTypeId_Ubuntu },
292 { CIMOSType_CIMOS_Ubuntu_64, SchemaDefs_OSTypeId_Ubuntu_64 },
293 { CIMOSType_CIMOS_Debian, SchemaDefs_OSTypeId_Debian },
294 { CIMOSType_CIMOS_Debian_64, SchemaDefs_OSTypeId_Debian_64 },
295 { CIMOSType_CIMOS_Linux_2_4_x, SchemaDefs_OSTypeId_Linux24 },
296 { CIMOSType_CIMOS_Linux_2_4_x_64, SchemaDefs_OSTypeId_Linux24_64 },
297 { CIMOSType_CIMOS_Linux_2_6_x, SchemaDefs_OSTypeId_Linux26 },
298 { CIMOSType_CIMOS_Linux_2_6_x_64, SchemaDefs_OSTypeId_Linux26_64 },
299 { CIMOSType_CIMOS_Linux_64, SchemaDefs_OSTypeId_Linux26_64 }
300};
301
302/* Pattern structure for matching the os type description field */
303struct osTypePattern
304{
305 const char *pcszPattern;
306 const char *pcszVbox;
307};
308
309/* These are the 32-Bit ones. They are sorted by priority. */
310static const osTypePattern g_osTypesPattern[] =
311{
312 {"Windows NT", SchemaDefs_OSTypeId_WindowsNT4},
313 {"Windows XP", SchemaDefs_OSTypeId_WindowsXP},
314 {"Windows 2000", SchemaDefs_OSTypeId_Windows2000},
315 {"Windows 2003", SchemaDefs_OSTypeId_Windows2003},
316 {"Windows Vista", SchemaDefs_OSTypeId_WindowsVista},
317 {"Windows 2008", SchemaDefs_OSTypeId_Windows2008},
318 {"SUSE", SchemaDefs_OSTypeId_OpenSUSE},
319 {"Novell", SchemaDefs_OSTypeId_OpenSUSE},
320 {"Red Hat", SchemaDefs_OSTypeId_RedHat},
321 {"Mandriva", SchemaDefs_OSTypeId_Mandriva},
322 {"Ubuntu", SchemaDefs_OSTypeId_Ubuntu},
323 {"Debian", SchemaDefs_OSTypeId_Debian},
324 {"QNX", SchemaDefs_OSTypeId_QNX},
325 {"Linux 2.4", SchemaDefs_OSTypeId_Linux24},
326 {"Linux 2.6", SchemaDefs_OSTypeId_Linux26},
327 {"Linux", SchemaDefs_OSTypeId_Linux},
328 {"OpenSolaris", SchemaDefs_OSTypeId_OpenSolaris},
329 {"Solaris", SchemaDefs_OSTypeId_OpenSolaris},
330 {"FreeBSD", SchemaDefs_OSTypeId_FreeBSD},
331 {"NetBSD", SchemaDefs_OSTypeId_NetBSD},
332 {"Windows 95", SchemaDefs_OSTypeId_Windows95},
333 {"Windows 98", SchemaDefs_OSTypeId_Windows98},
334 {"Windows Me", SchemaDefs_OSTypeId_WindowsMe},
335 {"Windows 3.", SchemaDefs_OSTypeId_Windows31},
336 {"DOS", SchemaDefs_OSTypeId_DOS},
337 {"OS2", SchemaDefs_OSTypeId_OS2}
338};
339
340/* These are the 64-Bit ones. They are sorted by priority. */
341static const osTypePattern g_osTypesPattern64[] =
342{
343 {"Windows XP", SchemaDefs_OSTypeId_WindowsXP_64},
344 {"Windows 2003", SchemaDefs_OSTypeId_Windows2003_64},
345 {"Windows Vista", SchemaDefs_OSTypeId_WindowsVista_64},
346 {"Windows 2008", SchemaDefs_OSTypeId_Windows2008_64},
347 {"SUSE", SchemaDefs_OSTypeId_OpenSUSE_64},
348 {"Novell", SchemaDefs_OSTypeId_OpenSUSE_64},
349 {"Red Hat", SchemaDefs_OSTypeId_RedHat_64},
350 {"Mandriva", SchemaDefs_OSTypeId_Mandriva_64},
351 {"Ubuntu", SchemaDefs_OSTypeId_Ubuntu_64},
352 {"Debian", SchemaDefs_OSTypeId_Debian_64},
353 {"Linux 2.4", SchemaDefs_OSTypeId_Linux24_64},
354 {"Linux 2.6", SchemaDefs_OSTypeId_Linux26_64},
355 {"Linux", SchemaDefs_OSTypeId_Linux26_64},
356 {"OpenSolaris", SchemaDefs_OSTypeId_OpenSolaris_64},
357 {"Solaris", SchemaDefs_OSTypeId_OpenSolaris_64},
358 {"FreeBSD", SchemaDefs_OSTypeId_FreeBSD_64},
359};
360
361/**
362 * Private helper func that suggests a VirtualBox guest OS type
363 * for the given OVF operating system type.
364 * @param osTypeVBox
365 * @param c
366 * @param cStr
367 */
368static void convertCIMOSType2VBoxOSType(Utf8Str &strType, CIMOSType_T c, const Utf8Str &cStr)
369{
370 /* First check if the type is other/other_64 */
371 if (c == CIMOSType_CIMOS_Other)
372 {
373 for (size_t i=0; i < RT_ELEMENTS(g_osTypesPattern); ++i)
374 if (cStr.contains (g_osTypesPattern[i].pcszPattern, Utf8Str::CaseInsensitive))
375 {
376 strType = g_osTypesPattern[i].pcszVbox;
377 return;
378 }
379 }
380 else if (c == CIMOSType_CIMOS_Other_64)
381 {
382 for (size_t i=0; i < RT_ELEMENTS(g_osTypesPattern64); ++i)
383 if (cStr.contains (g_osTypesPattern64[i].pcszPattern, Utf8Str::CaseInsensitive))
384 {
385 strType = g_osTypesPattern64[i].pcszVbox;
386 return;
387 }
388 }
389
390 for (size_t i = 0; i < RT_ELEMENTS(g_osTypes); ++i)
391 {
392 if (c == g_osTypes[i].cim)
393 {
394 strType = g_osTypes[i].pcszVbox;
395 return;
396 }
397 }
398
399 strType = SchemaDefs_OSTypeId_Other;
400}
401
402/**
403 * Private helper func that suggests a VirtualBox guest OS type
404 * for the given OVF operating system type.
405 * @param osTypeVBox
406 * @param c
407 */
408static CIMOSType_T convertVBoxOSType2CIMOSType(const char *pcszVbox)
409{
410 for (size_t i = 0; i < RT_ELEMENTS(g_osTypes); ++i)
411 {
412 if (!RTStrICmp(pcszVbox, g_osTypes[i].pcszVbox))
413 return g_osTypes[i].cim;
414 }
415
416 return CIMOSType_CIMOS_Other;
417}
418
419////////////////////////////////////////////////////////////////////////////////
420//
421// IVirtualBox public methods
422//
423////////////////////////////////////////////////////////////////////////////////
424
425// This code is here so we won't have to include the appliance headers in the
426// IVirtualBox implementation.
427
428/**
429 * Implementation for IVirtualBox::createAppliance.
430 *
431 * @param anAppliance IAppliance object created if S_OK is returned.
432 * @return S_OK or error.
433 */
434STDMETHODIMP VirtualBox::CreateAppliance(IAppliance** anAppliance)
435{
436 HRESULT rc;
437
438 ComObjPtr<Appliance> appliance;
439 appliance.createObject();
440 rc = appliance->init(this);
441
442 if (SUCCEEDED(rc))
443 appliance.queryInterfaceTo(anAppliance);
444
445 return rc;
446}
447
448////////////////////////////////////////////////////////////////////////////////
449//
450// Appliance constructor / destructor
451//
452////////////////////////////////////////////////////////////////////////////////
453
454DEFINE_EMPTY_CTOR_DTOR(Appliance)
455struct shutup {};
456
457/**
458 * Appliance COM initializer.
459 * @param
460 * @return
461 */
462
463HRESULT Appliance::init(VirtualBox *aVirtualBox)
464{
465 /* Enclose the state transition NotReady->InInit->Ready */
466 AutoInitSpan autoInitSpan(this);
467 AssertReturn(autoInitSpan.isOk(), E_FAIL);
468
469 /* Weak reference to a VirtualBox object */
470 unconst(mVirtualBox) = aVirtualBox;
471
472 // initialize data
473 m = new Data;
474
475 /* Confirm a successful initialization */
476 autoInitSpan.setSucceeded();
477
478 return S_OK;
479}
480
481/**
482 * Appliance COM uninitializer.
483 * @return
484 */
485void Appliance::uninit()
486{
487 delete m;
488 m = NULL;
489}
490
491////////////////////////////////////////////////////////////////////////////////
492//
493// Appliance private methods
494//
495////////////////////////////////////////////////////////////////////////////////
496
497/**
498 * Private helper method that goes thru the elements of the given "current" element in the OVF XML
499 * and handles the contained child elements (which can be "Section" or "Content" elements).
500 *
501 * @param pcszPath Path spec of the XML file, for error messages.
502 * @param pReferencesElement "References" element from OVF, for looking up file specifications; can be NULL if no such element is present.
503 * @param pCurElem Element whose children are to be analyzed here.
504 * @return
505 */
506HRESULT Appliance::LoopThruSections(const char *pcszPath,
507 const xml::ElementNode *pReferencesElem,
508 const xml::ElementNode *pCurElem)
509{
510 HRESULT rc;
511
512 xml::NodesLoop loopChildren(*pCurElem);
513 const xml::ElementNode *pElem;
514 while ((pElem = loopChildren.forAllNodes()))
515 {
516 const char *pcszElemName = pElem->getName();
517 const char *pcszTypeAttr = "";
518 const xml::AttributeNode *pTypeAttr;
519 if ((pTypeAttr = pElem->findAttribute("type")))
520 pcszTypeAttr = pTypeAttr->getValue();
521
522 if ( (!strcmp(pcszElemName, "DiskSection"))
523 || ( (!strcmp(pcszElemName, "Section"))
524 && (!strcmp(pcszTypeAttr, "ovf:DiskSection_Type"))
525 )
526 )
527 {
528 if (!(SUCCEEDED((rc = HandleDiskSection(pcszPath, pReferencesElem, pElem)))))
529 return rc;
530 }
531 else if ( (!strcmp(pcszElemName, "NetworkSection"))
532 || ( (!strcmp(pcszElemName, "Section"))
533 && (!strcmp(pcszTypeAttr, "ovf:NetworkSection_Type"))
534 )
535 )
536 {
537 if (!(SUCCEEDED((rc = HandleNetworkSection(pcszPath, pElem)))))
538 return rc;
539 }
540 else if ( (!strcmp(pcszElemName, "DeploymentOptionSection")))
541 {
542 // TODO
543 }
544 else if ( (!strcmp(pcszElemName, "Info")))
545 {
546 // child of VirtualSystemCollection -- TODO
547 }
548 else if ( (!strcmp(pcszElemName, "ResourceAllocationSection")))
549 {
550 // child of VirtualSystemCollection -- TODO
551 }
552 else if ( (!strcmp(pcszElemName, "StartupSection")))
553 {
554 // child of VirtualSystemCollection -- TODO
555 }
556 else if ( (!strcmp(pcszElemName, "VirtualSystem"))
557 || ( (!strcmp(pcszElemName, "Content"))
558 && (!strcmp(pcszTypeAttr, "ovf:VirtualSystem_Type"))
559 )
560 )
561 {
562 if (!(SUCCEEDED((rc = HandleVirtualSystemContent(pcszPath, pElem)))))
563 return rc;
564 }
565 else if ( (!strcmp(pcszElemName, "VirtualSystemCollection"))
566 || ( (!strcmp(pcszElemName, "Content"))
567 && (!strcmp(pcszTypeAttr, "ovf:VirtualSystemCollection_Type"))
568 )
569 )
570 {
571 // TODO ResourceAllocationSection
572
573 // recurse for this, since it has VirtualSystem elements as children
574 if (!(SUCCEEDED((rc = LoopThruSections(pcszPath, pReferencesElem, pElem)))))
575 return rc;
576 }
577 }
578
579 return S_OK;
580}
581
582/**
583 * Private helper method that handles disk sections in the OVF XML.
584 * Gets called indirectly from IAppliance::read().
585 *
586 * @param pcszPath Path spec of the XML file, for error messages.
587 * @param pReferencesElement "References" element from OVF, for looking up file specifications; can be NULL if no such element is present.
588 * @param pSectionElem Section element for which this helper is getting called.
589 * @return
590 */
591HRESULT Appliance::HandleDiskSection(const char *pcszPath,
592 const xml::ElementNode *pReferencesElem,
593 const xml::ElementNode *pSectionElem)
594{
595 // contains "Disk" child elements
596 xml::NodesLoop loopDisks(*pSectionElem, "Disk");
597 const xml::ElementNode *pelmDisk;
598 while ((pelmDisk = loopDisks.forAllNodes()))
599 {
600 DiskImage d;
601 const char *pcszBad = NULL;
602 if (!(pelmDisk->getAttributeValue("diskId", d.strDiskId)))
603 pcszBad = "diskId";
604 else if (!(pelmDisk->getAttributeValue("format", d.strFormat)))
605 pcszBad = "format";
606 else if (!(pelmDisk->getAttributeValue("capacity", d.iCapacity)))
607 pcszBad = "capacity";
608 else
609 {
610 if (!(pelmDisk->getAttributeValue("populatedSize", d.iPopulatedSize)))
611 // optional
612 d.iPopulatedSize = -1;
613
614 Utf8Str strFileRef;
615 if (pelmDisk->getAttributeValue("fileRef", strFileRef)) // optional
616 {
617 // look up corresponding /References/File nodes (list built above)
618 const xml::ElementNode *pFileElem;
619 if ( pReferencesElem
620 && ((pFileElem = pReferencesElem->findChildElementFromId(strFileRef.c_str())))
621 )
622 {
623 // copy remaining values from file node then
624 const char *pcszBadInFile = NULL;
625 if (!(pFileElem->getAttributeValue("href", d.strHref)))
626 pcszBadInFile = "href";
627 else if (!(pFileElem->getAttributeValue("size", d.iSize)))
628 d.iSize = -1; // optional
629 // if (!(pFileElem->getAttributeValue("size", d.iChunkSize))) TODO
630 d.iChunkSize = -1; // optional
631 pFileElem->getAttributeValue("compression", d.strCompression);
632
633 if (pcszBadInFile)
634 return setError(VBOX_E_FILE_ERROR,
635 tr("Error reading \"%s\": missing or invalid attribute '%s' in 'File' element, line %d"),
636 pcszPath,
637 pcszBadInFile,
638 pFileElem->getLineNumber());
639 }
640 else
641 return setError(VBOX_E_FILE_ERROR,
642 tr("Error reading \"%s\": cannot find References/File element for ID '%s' referenced by 'Disk' element, line %d"),
643 pcszPath,
644 strFileRef.c_str(),
645 pelmDisk->getLineNumber());
646 }
647 }
648
649 if (pcszBad)
650 return setError(VBOX_E_FILE_ERROR,
651 tr("Error reading \"%s\": missing or invalid attribute '%s' in 'DiskSection' element, line %d"),
652 pcszPath,
653 pcszBad,
654 pelmDisk->getLineNumber());
655
656 m->mapDisks[d.strDiskId] = d;
657 }
658
659 return S_OK;
660}
661
662/**
663 * Private helper method that handles network sections in the OVF XML.
664 * Gets called indirectly from IAppliance::read().
665 *
666 * @param pcszPath Path spec of the XML file, for error messages.
667 * @param pSectionElem Section element for which this helper is getting called.
668 * @return
669 */
670HRESULT Appliance::HandleNetworkSection(const char * /* pcszPath */,
671 const xml::ElementNode * /* pSectionElem */)
672{
673 // we ignore network sections for now
674
675// xml::NodesLoop loopNetworks(*pSectionElem, "Network");
676// const xml::Node *pelmNetwork;
677// while ((pelmNetwork = loopNetworks.forAllNodes()))
678// {
679// Network n;
680// if (!(pelmNetwork->getAttributeValue("name", n.strNetworkName)))
681// return setError(VBOX_E_FILE_ERROR,
682// tr("Error reading \"%s\": missing 'name' attribute in 'Network', line %d"),
683// pcszPath,
684// pelmNetwork->getLineNumber());
685//
686// m->mapNetworks[n.strNetworkName] = n;
687// }
688
689 return S_OK;
690}
691
692/**
693 * Private helper method that handles a "VirtualSystem" element in the OVF XML.
694 * Gets called indirectly from IAppliance::read().
695 *
696 * @param pcszPath
697 * @param pContentElem
698 * @return
699 */
700HRESULT Appliance::HandleVirtualSystemContent(const char *pcszPath,
701 const xml::ElementNode *pelmVirtualSystem)
702{
703 VirtualSystem vsys;
704
705 const xml::AttributeNode *pIdAttr = pelmVirtualSystem->findAttribute("id");
706 if (pIdAttr)
707 vsys.strName = pIdAttr->getValue();
708
709 xml::NodesLoop loop(*pelmVirtualSystem); // all child elements
710 const xml::ElementNode *pelmThis;
711 while ((pelmThis = loop.forAllNodes()))
712 {
713 const char *pcszElemName = pelmThis->getName();
714 const xml::AttributeNode *pTypeAttr = pelmThis->findAttribute("type");
715 const char *pcszTypeAttr = (pTypeAttr) ? pTypeAttr->getValue() : "";
716
717 if ( (!strcmp(pcszElemName, "EulaSection"))
718 || (!strcmp(pcszTypeAttr, "ovf:EulaSection_Type"))
719 )
720 {
721 /* <EulaSection>
722 <Info ovf:msgid="6">License agreement for the Virtual System.</Info>
723 <License ovf:msgid="1">License terms can go in here.</License>
724 </EulaSection> */
725
726 const xml::ElementNode *pelmLicense;
727 if ((pelmLicense = pelmThis->findChildElement("License")))
728 vsys.strLicenseText = pelmLicense->getValue();
729 }
730 if ( (!strcmp(pcszElemName, "ProductSection"))
731 || (!strcmp(pcszTypeAttr, "ovf:ProductSection_Type"))
732 )
733 {
734 /* <Section ovf:required="false" xsi:type="ovf:ProductSection_Type">
735 <Info>Meta-information about the installed software</Info>
736 <Product>VAtest</Product>
737 <Vendor>SUN Microsystems</Vendor>
738 <Version>10.0</Version>
739 <ProductUrl>http://blogs.sun.com/VirtualGuru</ProductUrl>
740 <VendorUrl>http://www.sun.com</VendorUrl>
741 </Section> */
742 const xml::ElementNode *pelmProduct;
743 if ((pelmProduct = pelmThis->findChildElement("Product")))
744 vsys.strProduct = pelmProduct->getValue();
745 const xml::ElementNode *pelmVendor;
746 if ((pelmVendor = pelmThis->findChildElement("Vendor")))
747 vsys.strVendor = pelmVendor->getValue();
748 const xml::ElementNode *pelmVersion;
749 if ((pelmVersion = pelmThis->findChildElement("Version")))
750 vsys.strVersion = pelmVersion->getValue();
751 const xml::ElementNode *pelmProductUrl;
752 if ((pelmProductUrl = pelmThis->findChildElement("ProductUrl")))
753 vsys.strProductUrl = pelmProductUrl->getValue();
754 const xml::ElementNode *pelmVendorUrl;
755 if ((pelmVendorUrl = pelmThis->findChildElement("VendorUrl")))
756 vsys.strVendorUrl = pelmVendorUrl->getValue();
757 }
758 else if ( (!strcmp(pcszElemName, "VirtualHardwareSection"))
759 || (!strcmp(pcszTypeAttr, "ovf:VirtualHardwareSection_Type"))
760 )
761 {
762 const xml::ElementNode *pelmSystem, *pelmVirtualSystemType;
763 if ((pelmSystem = pelmThis->findChildElement("System")))
764 {
765 /* <System>
766 <vssd:Description>Description of the virtual hardware section.</vssd:Description>
767 <vssd:ElementName>vmware</vssd:ElementName>
768 <vssd:InstanceID>1</vssd:InstanceID>
769 <vssd:VirtualSystemIdentifier>MyLampService</vssd:VirtualSystemIdentifier>
770 <vssd:VirtualSystemType>vmx-4</vssd:VirtualSystemType>
771 </System>*/
772 if ((pelmVirtualSystemType = pelmSystem->findChildElement("VirtualSystemType")))
773 vsys.strVirtualSystemType = pelmVirtualSystemType->getValue();
774 }
775
776 xml::NodesLoop loopVirtualHardwareItems(*pelmThis, "Item"); // all "Item" child elements
777 const xml::ElementNode *pelmItem;
778 while ((pelmItem = loopVirtualHardwareItems.forAllNodes()))
779 {
780 VirtualHardwareItem i;
781
782 i.ulLineNumber = pelmItem->getLineNumber();
783
784 xml::NodesLoop loopItemChildren(*pelmItem); // all child elements
785 const xml::ElementNode *pelmItemChild;
786 while ((pelmItemChild = loopItemChildren.forAllNodes()))
787 {
788 const char *pcszItemChildName = pelmItemChild->getName();
789 if (!strcmp(pcszItemChildName, "Description"))
790 i.strDescription = pelmItemChild->getValue();
791 else if (!strcmp(pcszItemChildName, "Caption"))
792 i.strCaption = pelmItemChild->getValue();
793 else if (!strcmp(pcszItemChildName, "ElementName"))
794 i.strElementName = pelmItemChild->getValue();
795 else if ( (!strcmp(pcszItemChildName, "InstanceID"))
796 || (!strcmp(pcszItemChildName, "InstanceId"))
797 )
798 pelmItemChild->copyValue(i.ulInstanceID);
799 else if (!strcmp(pcszItemChildName, "HostResource"))
800 i.strHostResource = pelmItemChild->getValue();
801 else if (!strcmp(pcszItemChildName, "ResourceType"))
802 {
803 uint32_t ulType;
804 pelmItemChild->copyValue(ulType);
805 i.resourceType = (OVFResourceType_T)ulType;
806 }
807 else if (!strcmp(pcszItemChildName, "OtherResourceType"))
808 i.strOtherResourceType = pelmItemChild->getValue();
809 else if (!strcmp(pcszItemChildName, "ResourceSubType"))
810 i.strResourceSubType = pelmItemChild->getValue();
811 else if (!strcmp(pcszItemChildName, "AutomaticAllocation"))
812 i.fAutomaticAllocation = (!strcmp(pelmItemChild->getValue(), "true")) ? true : false;
813 else if (!strcmp(pcszItemChildName, "AutomaticDeallocation"))
814 i.fAutomaticDeallocation = (!strcmp(pelmItemChild->getValue(), "true")) ? true : false;
815 else if (!strcmp(pcszItemChildName, "Parent"))
816 pelmItemChild->copyValue(i.ulParent);
817 else if (!strcmp(pcszItemChildName, "Connection"))
818 i.strConnection = pelmItemChild->getValue();
819 else if (!strcmp(pcszItemChildName, "Address"))
820 i.strAddress = pelmItemChild->getValue();
821 else if (!strcmp(pcszItemChildName, "AddressOnParent"))
822 i.strAddressOnParent = pelmItemChild->getValue();
823 else if (!strcmp(pcszItemChildName, "AllocationUnits"))
824 i.strAllocationUnits = pelmItemChild->getValue();
825 else if (!strcmp(pcszItemChildName, "VirtualQuantity"))
826 pelmItemChild->copyValue(i.ullVirtualQuantity);
827 else if (!strcmp(pcszItemChildName, "Reservation"))
828 pelmItemChild->copyValue(i.ullReservation);
829 else if (!strcmp(pcszItemChildName, "Limit"))
830 pelmItemChild->copyValue(i.ullLimit);
831 else if (!strcmp(pcszItemChildName, "Weight"))
832 pelmItemChild->copyValue(i.ullWeight);
833 else if (!strcmp(pcszItemChildName, "ConsumerVisibility"))
834 i.strConsumerVisibility = pelmItemChild->getValue();
835 else if (!strcmp(pcszItemChildName, "MappingBehavior"))
836 i.strMappingBehavior = pelmItemChild->getValue();
837 else if (!strcmp(pcszItemChildName, "PoolID"))
838 i.strPoolID = pelmItemChild->getValue();
839 else if (!strcmp(pcszItemChildName, "BusNumber"))
840 pelmItemChild->copyValue(i.ulBusNumber);
841 else
842 return setError(VBOX_E_FILE_ERROR,
843 tr("Error reading \"%s\": unknown element \"%s\" under Item element, line %d"),
844 pcszPath,
845 pcszItemChildName,
846 i.ulLineNumber);
847 }
848
849 // store!
850 vsys.mapHardwareItems[i.ulInstanceID] = i;
851 }
852
853 // now go thru all hardware items and handle them according to their type;
854 // in this first loop we handle all items _except_ hard disk images,
855 // which we'll handle in a second loop below
856 HardwareItemsMap::const_iterator itH;
857 for (itH = vsys.mapHardwareItems.begin();
858 itH != vsys.mapHardwareItems.end();
859 ++itH)
860 {
861 const VirtualHardwareItem &i = itH->second;
862
863 // do some analysis
864 switch (i.resourceType)
865 {
866 case OVFResourceType_Processor: // 3
867 /* <rasd:Caption>1 virtual CPU</rasd:Caption>
868 <rasd:Description>Number of virtual CPUs</rasd:Description>
869 <rasd:ElementName>virtual CPU</rasd:ElementName>
870 <rasd:InstanceID>1</rasd:InstanceID>
871 <rasd:ResourceType>3</rasd:ResourceType>
872 <rasd:VirtualQuantity>1</rasd:VirtualQuantity>*/
873 if (i.ullVirtualQuantity < UINT16_MAX)
874 vsys.cCPUs = (uint16_t)i.ullVirtualQuantity;
875 else
876 return setError(VBOX_E_FILE_ERROR,
877 tr("Error reading \"%s\": CPU count %RI64 is larger than %d, line %d"),
878 pcszPath,
879 i.ullVirtualQuantity,
880 UINT16_MAX,
881 i.ulLineNumber);
882 break;
883
884 case OVFResourceType_Memory: // 4
885 if ( (i.strAllocationUnits == "MegaBytes") // found in OVF created by OVF toolkit
886 || (i.strAllocationUnits == "MB") // found in MS docs
887 || (i.strAllocationUnits == "byte * 2^20") // suggested by OVF spec DSP0243 page 21
888 )
889 vsys.ullMemorySize = i.ullVirtualQuantity * 1024 * 1024;
890 else
891 return setError(VBOX_E_FILE_ERROR,
892 tr("Error reading \"%s\": Invalid allocation unit \"%s\" specified with memory size item, line %d"),
893 pcszPath,
894 i.strAllocationUnits.c_str(),
895 i.ulLineNumber);
896 break;
897
898 case OVFResourceType_IDEController: // 5
899 {
900 /* <Item>
901 <rasd:Caption>ideController0</rasd:Caption>
902 <rasd:Description>IDE Controller</rasd:Description>
903 <rasd:InstanceId>5</rasd:InstanceId>
904 <rasd:ResourceType>5</rasd:ResourceType>
905 <rasd:Address>0</rasd:Address>
906 <rasd:BusNumber>0</rasd:BusNumber>
907 </Item> */
908 HardDiskController hdc;
909 hdc.system = HardDiskController::IDE;
910 hdc.idController = i.ulInstanceID;
911 hdc.strControllerType = i.strResourceSubType;
912 hdc.strAddress = i.strAddress;
913 hdc.ulBusNumber = i.ulBusNumber;
914
915 vsys.mapControllers[i.ulInstanceID] = hdc;
916 }
917 break;
918
919 case OVFResourceType_ParallelSCSIHBA: // 6 SCSI controller
920 {
921 /* <Item>
922 <rasd:Caption>SCSI Controller 0 - LSI Logic</rasd:Caption>
923 <rasd:Description>SCI Controller</rasd:Description>
924 <rasd:ElementName>SCSI controller</rasd:ElementName>
925 <rasd:InstanceID>4</rasd:InstanceID>
926 <rasd:ResourceSubType>LsiLogic</rasd:ResourceSubType>
927 <rasd:ResourceType>6</rasd:ResourceType>
928 </Item> */
929 HardDiskController hdc;
930 hdc.system = HardDiskController::SCSI;
931 hdc.idController = i.ulInstanceID;
932 hdc.strControllerType = i.strResourceSubType;
933
934 vsys.mapControllers[i.ulInstanceID] = hdc;
935 }
936 break;
937
938 case OVFResourceType_EthernetAdapter: // 10
939 {
940 /* <Item>
941 <rasd:Caption>Ethernet adapter on 'Bridged'</rasd:Caption>
942 <rasd:AutomaticAllocation>true</rasd:AutomaticAllocation>
943 <rasd:Connection>Bridged</rasd:Connection>
944 <rasd:InstanceID>6</rasd:InstanceID>
945 <rasd:ResourceType>10</rasd:ResourceType>
946 <rasd:ResourceSubType>E1000</rasd:ResourceSubType>
947 </Item>
948
949 OVF spec DSP 0243 page 21:
950 "For an Ethernet adapter, this specifies the abstract network connection name
951 for the virtual machine. All Ethernet adapters that specify the same abstract
952 network connection name within an OVF package shall be deployed on the same
953 network. The abstract network connection name shall be listed in the NetworkSection
954 at the outermost envelope level." */
955
956 // only store the name
957 EthernetAdapter ea;
958 ea.strAdapterType = i.strResourceSubType;
959 ea.strNetworkName = i.strConnection;
960 vsys.llEthernetAdapters.push_back(ea);
961 }
962 break;
963
964 case OVFResourceType_FloppyDrive: // 14
965 vsys.fHasFloppyDrive = true; // we have no additional information
966 break;
967
968 case OVFResourceType_CDDrive: // 15
969 /* <Item ovf:required="false">
970 <rasd:Caption>cdrom1</rasd:Caption>
971 <rasd:InstanceId>7</rasd:InstanceId>
972 <rasd:ResourceType>15</rasd:ResourceType>
973 <rasd:AutomaticAllocation>true</rasd:AutomaticAllocation>
974 <rasd:Parent>5</rasd:Parent>
975 <rasd:AddressOnParent>0</rasd:AddressOnParent>
976 </Item> */
977 // I tried to see what happens if I set an ISO for the CD-ROM in VMware Workstation,
978 // but then the ovftool dies with "Device backing not supported". So I guess if
979 // VMware can't export ISOs, then we don't need to be able to import them right now.
980 vsys.fHasCdromDrive = true; // we have no additional information
981 break;
982
983 case OVFResourceType_HardDisk: // 17
984 // handled separately in second loop below
985 break;
986
987 case OVFResourceType_OtherStorageDevice: // 20 SATA controller
988 {
989 /* <Item>
990 <rasd:Description>SATA Controller</rasd:Description>
991 <rasd:Caption>sataController0</rasd:Caption>
992 <rasd:InstanceID>4</rasd:InstanceID>
993 <rasd:ResourceType>20</rasd:ResourceType>
994 <rasd:ResourceSubType>AHCI</rasd:ResourceSubType>
995 <rasd:Address>0</rasd:Address>
996 <rasd:BusNumber>0</rasd:BusNumber>
997 </Item> */
998 if (i.strCaption.startsWith ("sataController", Utf8Str::CaseInsensitive) &&
999 !i.strResourceSubType.compare ("AHCI", Utf8Str::CaseInsensitive))
1000 {
1001 HardDiskController hdc;
1002 hdc.system = HardDiskController::SATA;
1003 hdc.idController = i.ulInstanceID;
1004 hdc.strControllerType = i.strResourceSubType;
1005
1006 vsys.mapControllers[i.ulInstanceID] = hdc;
1007 }
1008 else
1009 return setError(VBOX_E_FILE_ERROR,
1010 tr("Error reading \"%s\": Host resource of type \"Other Storage Device (%d)\" is supported with SATA AHCI controllers only, line %d"),
1011 pcszPath,
1012 OVFResourceType_OtherStorageDevice,
1013 i.ulLineNumber);
1014 }
1015 break;
1016
1017 case OVFResourceType_USBController: // 23
1018 /* <Item ovf:required="false">
1019 <rasd:Caption>usb</rasd:Caption>
1020 <rasd:Description>USB Controller</rasd:Description>
1021 <rasd:InstanceId>3</rasd:InstanceId>
1022 <rasd:ResourceType>23</rasd:ResourceType>
1023 <rasd:Address>0</rasd:Address>
1024 <rasd:BusNumber>0</rasd:BusNumber>
1025 </Item> */
1026 vsys.fHasUsbController = true; // we have no additional information
1027 break;
1028
1029 case OVFResourceType_SoundCard: // 35
1030 /* <Item ovf:required="false">
1031 <rasd:Caption>sound</rasd:Caption>
1032 <rasd:Description>Sound Card</rasd:Description>
1033 <rasd:InstanceId>10</rasd:InstanceId>
1034 <rasd:ResourceType>35</rasd:ResourceType>
1035 <rasd:ResourceSubType>ensoniq1371</rasd:ResourceSubType>
1036 <rasd:AutomaticAllocation>false</rasd:AutomaticAllocation>
1037 <rasd:AddressOnParent>3</rasd:AddressOnParent>
1038 </Item> */
1039 vsys.strSoundCardType = i.strResourceSubType;
1040 break;
1041
1042 default:
1043 return setError(VBOX_E_FILE_ERROR,
1044 tr("Error reading \"%s\": Unknown resource type %d in hardware item, line %d"),
1045 pcszPath,
1046 i.resourceType,
1047 i.ulLineNumber);
1048 } // end switch
1049 }
1050
1051 // now run through the items for a second time, but handle only
1052 // hard disk images; otherwise the code would fail if a hard
1053 // disk image appears in the OVF before its hard disk controller
1054 for (itH = vsys.mapHardwareItems.begin();
1055 itH != vsys.mapHardwareItems.end();
1056 ++itH)
1057 {
1058 const VirtualHardwareItem &i = itH->second;
1059
1060 // do some analysis
1061 switch (i.resourceType)
1062 {
1063 case OVFResourceType_HardDisk: // 17
1064 {
1065 /* <Item>
1066 <rasd:Caption>Harddisk 1</rasd:Caption>
1067 <rasd:Description>HD</rasd:Description>
1068 <rasd:ElementName>Hard Disk</rasd:ElementName>
1069 <rasd:HostResource>ovf://disk/lamp</rasd:HostResource>
1070 <rasd:InstanceID>5</rasd:InstanceID>
1071 <rasd:Parent>4</rasd:Parent>
1072 <rasd:ResourceType>17</rasd:ResourceType>
1073 </Item> */
1074
1075 // look up the hard disk controller element whose InstanceID equals our Parent;
1076 // this is how the connection is specified in OVF
1077 ControllersMap::const_iterator it = vsys.mapControllers.find(i.ulParent);
1078 if (it == vsys.mapControllers.end())
1079 return setError(VBOX_E_FILE_ERROR,
1080 tr("Error reading \"%s\": Hard disk item with instance ID %d specifies invalid parent %d, line %d"),
1081 pcszPath,
1082 i.ulInstanceID,
1083 i.ulParent,
1084 i.ulLineNumber);
1085 //const HardDiskController &hdc = it->second;
1086
1087 VirtualDisk vd;
1088 vd.idController = i.ulParent;
1089 i.strAddressOnParent.toInt(vd.ulAddressOnParent);
1090 // ovf://disk/lamp
1091 // 123456789012345
1092 if (i.strHostResource.substr(0, 11) == "ovf://disk/")
1093 vd.strDiskId = i.strHostResource.substr(11);
1094 else if (i.strHostResource.substr(0, 6) == "/disk/")
1095 vd.strDiskId = i.strHostResource.substr(6);
1096
1097 if ( !(vd.strDiskId.length())
1098 || (m->mapDisks.find(vd.strDiskId) == m->mapDisks.end())
1099 )
1100 return setError(VBOX_E_FILE_ERROR,
1101 tr("Error reading \"%s\": Hard disk item with instance ID %d specifies invalid host resource \"%s\", line %d"),
1102 pcszPath,
1103 i.ulInstanceID,
1104 i.strHostResource.c_str(),
1105 i.ulLineNumber);
1106
1107 vsys.mapVirtualDisks[vd.strDiskId] = vd;
1108 }
1109 break;
1110 }
1111 }
1112 }
1113 else if ( (!strcmp(pcszElemName, "OperatingSystemSection"))
1114 || (!strcmp(pcszTypeAttr, "ovf:OperatingSystemSection_Type"))
1115 )
1116 {
1117 uint64_t cimos64;
1118 if (!(pelmThis->getAttributeValue("id", cimos64)))
1119 return setError(VBOX_E_FILE_ERROR,
1120 tr("Error reading \"%s\": missing or invalid 'ovf:id' attribute in operating system section element, line %d"),
1121 pcszPath,
1122 pelmThis->getLineNumber());
1123
1124 vsys.cimos = (CIMOSType_T)cimos64;
1125 const xml::ElementNode *pelmCIMOSDescription;
1126 if ((pelmCIMOSDescription = pelmThis->findChildElement("Description")))
1127 vsys.strCimosDesc = pelmCIMOSDescription->getValue();
1128 }
1129 else if ( (!strcmp(pcszElemName, "AnnotationSection"))
1130 || (!strcmp(pcszTypeAttr, "ovf:AnnotationSection_Type"))
1131 )
1132 {
1133 const xml::ElementNode *pelmAnnotation;
1134 if ((pelmAnnotation = pelmThis->findChildElement("Annotation")))
1135 vsys.strDescription = pelmAnnotation->getValue();
1136 }
1137 }
1138
1139 // now create the virtual system
1140 m->llVirtualSystems.push_back(vsys);
1141
1142 return S_OK;
1143}
1144
1145////////////////////////////////////////////////////////////////////////////////
1146//
1147// IAppliance public methods
1148//
1149////////////////////////////////////////////////////////////////////////////////
1150
1151/**
1152 * Public method implementation.
1153 * @param
1154 * @return
1155 */
1156STDMETHODIMP Appliance::COMGETTER(Path)(BSTR *aPath)
1157{
1158 if (!aPath)
1159 return E_POINTER;
1160
1161 AutoCaller autoCaller(this);
1162 CheckComRCReturnRC(autoCaller.rc());
1163
1164 AutoReadLock alock(this);
1165
1166 Bstr bstrPath(m->strPath);
1167 bstrPath.cloneTo(aPath);
1168
1169 return S_OK;
1170}
1171
1172/**
1173 * Public method implementation.
1174 * @param
1175 * @return
1176 */
1177STDMETHODIMP Appliance::COMGETTER(Disks)(ComSafeArrayOut(BSTR, aDisks))
1178{
1179 CheckComArgOutSafeArrayPointerValid(aDisks);
1180
1181 AutoCaller autoCaller(this);
1182 CheckComRCReturnRC(autoCaller.rc());
1183
1184 AutoReadLock alock(this);
1185
1186 size_t c = m->mapDisks.size();
1187 com::SafeArray<BSTR> sfaDisks(c);
1188
1189 DiskImagesMap::const_iterator it;
1190 size_t i = 0;
1191 for (it = m->mapDisks.begin();
1192 it != m->mapDisks.end();
1193 ++it, ++i)
1194 {
1195 // create a string representing this disk
1196 const DiskImage &d = it->second;
1197 char *psz = NULL;
1198 RTStrAPrintf(&psz,
1199 "%s\t"
1200 "%RI64\t"
1201 "%RI64\t"
1202 "%s\t"
1203 "%s\t"
1204 "%RI64\t"
1205 "%RI64\t"
1206 "%s",
1207 d.strDiskId.c_str(),
1208 d.iCapacity,
1209 d.iPopulatedSize,
1210 d.strFormat.c_str(),
1211 d.strHref.c_str(),
1212 d.iSize,
1213 d.iChunkSize,
1214 d.strCompression.c_str());
1215 Utf8Str utf(psz);
1216 Bstr bstr(utf);
1217 // push to safearray
1218 bstr.cloneTo(&sfaDisks[i]);
1219 RTStrFree(psz);
1220 }
1221
1222 sfaDisks.detachTo(ComSafeArrayOutArg(aDisks));
1223
1224 return S_OK;
1225}
1226
1227/**
1228 * Public method implementation.
1229 * @param
1230 * @return
1231 */
1232STDMETHODIMP Appliance::COMGETTER(VirtualSystemDescriptions)(ComSafeArrayOut(IVirtualSystemDescription*, aVirtualSystemDescriptions))
1233{
1234 CheckComArgOutSafeArrayPointerValid(aVirtualSystemDescriptions);
1235
1236 AutoCaller autoCaller(this);
1237 CheckComRCReturnRC(autoCaller.rc());
1238
1239 AutoReadLock alock(this);
1240
1241 SafeIfaceArray<IVirtualSystemDescription> sfaVSD(m->virtualSystemDescriptions);
1242 sfaVSD.detachTo(ComSafeArrayOutArg(aVirtualSystemDescriptions));
1243
1244 return S_OK;
1245}
1246
1247/**
1248 * Public method implementation.
1249 * @param path
1250 * @return
1251 */
1252STDMETHODIMP Appliance::Read(IN_BSTR path)
1253{
1254 HRESULT rc = S_OK;
1255
1256 if (!path)
1257 return E_POINTER;
1258
1259 AutoCaller autoCaller(this);
1260 CheckComRCReturnRC(autoCaller.rc());
1261
1262 AutoWriteLock alock(this);
1263
1264 // see if we can handle this file; for now we insist it has an ".ovf" extension
1265 m->strPath = path;
1266 if (!m->strPath.endsWith(".ovf", Utf8Str::CaseInsensitive))
1267 return setError(VBOX_E_FILE_ERROR,
1268 tr("Appliance file must have .ovf extension"));
1269
1270 try
1271 {
1272 xml::XmlFileParser parser;
1273 xml::Document doc;
1274 parser.read(m->strPath.raw(),
1275 doc);
1276
1277 const xml::ElementNode *pRootElem = doc.getRootElement();
1278 if (strcmp(pRootElem->getName(), "Envelope"))
1279 return setError(VBOX_E_FILE_ERROR,
1280 tr("Root element in OVF file must be \"Envelope\"."));
1281
1282 // OVF has the following rough layout:
1283 /*
1284 -- <References> .... files referenced from other parts of the file, such as VMDK images
1285 -- Metadata, comprised of several section commands
1286 -- virtual machines, either a single <VirtualSystem>, or a <VirtualSystemCollection>
1287 -- optionally <Strings> for localization
1288 */
1289
1290 // get all "File" child elements of "References" section so we can look up files easily;
1291 // first find the "References" sections so we can look up files
1292 xml::ElementNodesList listFileElements; // receives all /Envelope/References/File nodes
1293 const xml::ElementNode *pReferencesElem;
1294 if ((pReferencesElem = pRootElem->findChildElement("References")))
1295 pReferencesElem->getChildElements(listFileElements, "File");
1296
1297 // now go though the sections
1298 if (!(SUCCEEDED(rc = LoopThruSections(m->strPath.raw(), pReferencesElem, pRootElem))))
1299 return rc;
1300 }
1301 catch(xml::Error &x)
1302 {
1303 return setError(VBOX_E_FILE_ERROR,
1304 x.what());
1305 }
1306
1307 return S_OK;
1308}
1309
1310/**
1311 * Public method implementation.
1312 * @return
1313 */
1314STDMETHODIMP Appliance::Interpret()
1315{
1316 // @todo:
1317 // - don't use COM methods but the methods directly (faster, but needs appropriate locking of that objects itself (s. HardDisk))
1318 // - Appropriate handle errors like not supported file formats
1319 AutoCaller autoCaller(this);
1320 CheckComRCReturnRC(autoCaller.rc());
1321
1322 AutoWriteLock(this);
1323
1324 HRESULT rc = S_OK;
1325
1326 /* Clear any previous virtual system descriptions */
1327 m->virtualSystemDescriptions.clear();
1328
1329 /* We need the default path for storing disk images */
1330 ComPtr<ISystemProperties> systemProps;
1331 rc = mVirtualBox->COMGETTER(SystemProperties)(systemProps.asOutParam());
1332 CheckComRCReturnRC(rc);
1333 Bstr bstrDefaultHardDiskLocation;
1334 rc = systemProps->COMGETTER(DefaultHardDiskFolder)(bstrDefaultHardDiskLocation.asOutParam());
1335 CheckComRCReturnRC(rc);
1336
1337 /* Try/catch so we can clean up on error */
1338 try
1339 {
1340 list<VirtualSystem>::const_iterator it;
1341 /* Iterate through all virtual systems */
1342 for (it = m->llVirtualSystems.begin();
1343 it != m->llVirtualSystems.end();
1344 ++it)
1345 {
1346 const VirtualSystem &vsysThis = *it;
1347
1348 ComObjPtr<VirtualSystemDescription> pNewDesc;
1349 rc = pNewDesc.createObject();
1350 CheckComRCThrowRC(rc);
1351 rc = pNewDesc->init();
1352 CheckComRCThrowRC(rc);
1353
1354 /* Guest OS type */
1355 Utf8Str strOsTypeVBox,
1356 strCIMOSType = Utf8StrFmt("%RI32", (uint32_t)vsysThis.cimos);
1357 convertCIMOSType2VBoxOSType(strOsTypeVBox, vsysThis.cimos, vsysThis.strCimosDesc);
1358 pNewDesc->addEntry(VirtualSystemDescriptionType_OS,
1359 "",
1360 strCIMOSType,
1361 strOsTypeVBox);
1362
1363 /* VM name */
1364 /* If the there isn't any name specified create a default one out of
1365 * the OS type */
1366 Utf8Str nameVBox = vsysThis.strName;
1367 if (nameVBox.isEmpty())
1368 nameVBox = strOsTypeVBox;
1369 searchUniqueVMName(nameVBox);
1370 pNewDesc->addEntry(VirtualSystemDescriptionType_Name,
1371 "",
1372 vsysThis.strName,
1373 nameVBox);
1374
1375 /* VM Product */
1376 if (!vsysThis.strProduct.isEmpty())
1377 pNewDesc->addEntry(VirtualSystemDescriptionType_Product,
1378 "",
1379 vsysThis.strProduct,
1380 vsysThis.strProduct);
1381
1382 /* VM Vendor */
1383 if (!vsysThis.strVendor.isEmpty())
1384 pNewDesc->addEntry(VirtualSystemDescriptionType_Vendor,
1385 "",
1386 vsysThis.strVendor,
1387 vsysThis.strVendor);
1388
1389 /* VM Version */
1390 if (!vsysThis.strVersion.isEmpty())
1391 pNewDesc->addEntry(VirtualSystemDescriptionType_Version,
1392 "",
1393 vsysThis.strVersion,
1394 vsysThis.strVersion);
1395
1396 /* VM ProductUrl */
1397 if (!vsysThis.strProductUrl.isEmpty())
1398 pNewDesc->addEntry(VirtualSystemDescriptionType_ProductUrl,
1399 "",
1400 vsysThis.strProductUrl,
1401 vsysThis.strProductUrl);
1402
1403 /* VM VendorUrl */
1404 if (!vsysThis.strVendorUrl.isEmpty())
1405 pNewDesc->addEntry(VirtualSystemDescriptionType_VendorUrl,
1406 "",
1407 vsysThis.strVendorUrl,
1408 vsysThis.strVendorUrl);
1409
1410 /* VM description */
1411 if (!vsysThis.strDescription.isEmpty())
1412 pNewDesc->addEntry(VirtualSystemDescriptionType_Description,
1413 "",
1414 vsysThis.strDescription,
1415 vsysThis.strDescription);
1416
1417 /* VM license */
1418 if (!vsysThis.strLicenseText.isEmpty())
1419 pNewDesc->addEntry(VirtualSystemDescriptionType_License,
1420 "",
1421 vsysThis.strLicenseText,
1422 vsysThis.strLicenseText);
1423
1424 /* Now that we know the OS type, get our internal defaults based on that. */
1425 ComPtr<IGuestOSType> pGuestOSType;
1426 rc = mVirtualBox->GetGuestOSType(Bstr(strOsTypeVBox), pGuestOSType.asOutParam());
1427 CheckComRCThrowRC(rc);
1428
1429 /* CPU count */
1430 ULONG cpuCountVBox = vsysThis.cCPUs;
1431 /* Check for the constrains */
1432 if (cpuCountVBox > 1) //SchemaDefs::MaxCPUCount)
1433 {
1434 addWarning(tr("The virtual system \"%s\" claims support for %u CPU's, but VirtualBox has support for max %u CPU's only."),
1435 vsysThis.strName.c_str(), cpuCountVBox, 1); //SchemaDefs::MaxCPUCount);
1436 cpuCountVBox = 1; //SchemaDefs::MaxCPUCount;
1437 }
1438 if (vsysThis.cCPUs == 0)
1439 cpuCountVBox = 1;
1440 pNewDesc->addEntry(VirtualSystemDescriptionType_CPU,
1441 "",
1442 Utf8StrFmt("%RI32", (uint32_t)vsysThis.cCPUs),
1443 Utf8StrFmt("%RI32", (uint32_t)cpuCountVBox));
1444
1445 /* RAM */
1446 uint64_t ullMemSizeVBox = vsysThis.ullMemorySize / _1M;
1447 /* Check for the constrains */
1448 if (ullMemSizeVBox != 0 &&
1449 (ullMemSizeVBox < MM_RAM_MIN_IN_MB ||
1450 ullMemSizeVBox > MM_RAM_MAX_IN_MB))
1451 {
1452 addWarning(tr("The virtual system \"%s\" claims support for %llu MB RAM size, but VirtualBox has support for min %u & max %u MB RAM size only."),
1453 vsysThis.strName.c_str(), ullMemSizeVBox, MM_RAM_MIN_IN_MB, MM_RAM_MAX_IN_MB);
1454 ullMemSizeVBox = RT_MIN(RT_MAX(ullMemSizeVBox, MM_RAM_MIN_IN_MB), MM_RAM_MAX_IN_MB);
1455 }
1456 if (vsysThis.ullMemorySize == 0)
1457 {
1458 /* If the RAM of the OVF is zero, use our predefined values */
1459 ULONG memSizeVBox2;
1460 rc = pGuestOSType->COMGETTER(RecommendedRAM)(&memSizeVBox2);
1461 CheckComRCThrowRC(rc);
1462 /* VBox stores that in MByte */
1463 ullMemSizeVBox = (uint64_t)memSizeVBox2;
1464 }
1465 pNewDesc->addEntry(VirtualSystemDescriptionType_Memory,
1466 "",
1467 Utf8StrFmt("%RI64", (uint64_t)vsysThis.ullMemorySize),
1468 Utf8StrFmt("%RI64", (uint64_t)ullMemSizeVBox));
1469
1470 /* Audio */
1471 if (!vsysThis.strSoundCardType.isNull())
1472 /* Currently we set the AC97 always.
1473 @todo: figure out the hardware which could be possible */
1474 pNewDesc->addEntry(VirtualSystemDescriptionType_SoundCard,
1475 "",
1476 vsysThis.strSoundCardType,
1477 Utf8StrFmt("%RI32", (uint32_t)AudioControllerType_AC97));
1478
1479#ifdef VBOX_WITH_USB
1480 /* USB Controller */
1481 if (vsysThis.fHasUsbController)
1482 pNewDesc->addEntry(VirtualSystemDescriptionType_USBController, "", "", "");
1483#endif /* VBOX_WITH_USB */
1484
1485 /* Network Controller */
1486 size_t cEthernetAdapters = vsysThis.llEthernetAdapters.size();
1487 if (cEthernetAdapters > 0)
1488 {
1489 /* Check for the constrains */
1490 if (cEthernetAdapters > SchemaDefs::NetworkAdapterCount)
1491 addWarning(tr("The virtual system \"%s\" claims support for %zu network adapters, but VirtualBox has support for max %u network adapter only."),
1492 vsysThis.strName.c_str(), cEthernetAdapters, SchemaDefs::NetworkAdapterCount);
1493
1494 /* Get the default network adapter type for the selected guest OS */
1495 NetworkAdapterType_T defaultAdapterVBox = NetworkAdapterType_Am79C970A;
1496 rc = pGuestOSType->COMGETTER(AdapterType)(&defaultAdapterVBox);
1497 CheckComRCThrowRC(rc);
1498
1499 EthernetAdaptersList::const_iterator itEA;
1500 /* Iterate through all abstract networks. We support 8 network
1501 * adapters at the maximum, so the first 8 will be added only. */
1502 size_t a = 0;
1503 for (itEA = vsysThis.llEthernetAdapters.begin();
1504 itEA != vsysThis.llEthernetAdapters.end() && a < SchemaDefs::NetworkAdapterCount;
1505 ++itEA, ++a)
1506 {
1507 const EthernetAdapter &ea = *itEA; // logical network to connect to
1508 Utf8Str strNetwork = ea.strNetworkName;
1509 // make sure it's one of these two
1510 if ( (strNetwork.compare("Null", Utf8Str::CaseInsensitive))
1511 && (strNetwork.compare("Bridged", Utf8Str::CaseInsensitive))
1512 && (strNetwork.compare("Internal", Utf8Str::CaseInsensitive))
1513 && (strNetwork.compare("HostOnly", Utf8Str::CaseInsensitive))
1514 )
1515 strNetwork = "Bridged"; // VMware assumes this is the default apparently
1516
1517 /* Figure out the hardware type */
1518 NetworkAdapterType_T nwAdapterVBox = defaultAdapterVBox;
1519 if (!ea.strAdapterType.compare("PCNet32", Utf8Str::CaseInsensitive))
1520 {
1521 /* If the default adapter is already one of the two
1522 * PCNet adapters use the default one. If not use the
1523 * Am79C970A as fallback. */
1524 if (!(defaultAdapterVBox == NetworkAdapterType_Am79C970A ||
1525 defaultAdapterVBox == NetworkAdapterType_Am79C973))
1526 nwAdapterVBox = NetworkAdapterType_Am79C970A;
1527 }
1528#ifdef VBOX_WITH_E1000
1529 else if (!ea.strAdapterType.compare("E1000", Utf8Str::CaseInsensitive))
1530 {
1531 /* If the default adapter is already one of the three
1532 * E1000 adapters use the default one. If not use the
1533 * I82540EM as fallback. */
1534 if (!(defaultAdapterVBox == NetworkAdapterType_I82540EM ||
1535 defaultAdapterVBox == NetworkAdapterType_I82543GC ||
1536 defaultAdapterVBox == NetworkAdapterType_I82545EM))
1537 nwAdapterVBox = NetworkAdapterType_I82540EM;
1538 }
1539#endif /* VBOX_WITH_E1000 */
1540
1541 pNewDesc->addEntry(VirtualSystemDescriptionType_NetworkAdapter,
1542 "", // ref
1543 ea.strNetworkName, // orig
1544 Utf8StrFmt("%RI32", (uint32_t)nwAdapterVBox), // conf
1545 0,
1546 Utf8StrFmt("type=%s", strNetwork.c_str())); // extra conf
1547 }
1548 }
1549
1550 /* Floppy Drive */
1551 if (vsysThis.fHasFloppyDrive)
1552 pNewDesc->addEntry(VirtualSystemDescriptionType_Floppy, "", "", "");
1553
1554 /* CD Drive */
1555 /* @todo: I can't disable the CDROM. So nothing to do for now */
1556 /*
1557 if (vsysThis.fHasCdromDrive)
1558 pNewDesc->addEntry(VirtualSystemDescriptionType_CDROM, "", "", "");*/
1559
1560 /* Hard disk Controller */
1561 uint16_t cIDEused = 0;
1562 uint16_t cSATAused = 0;
1563 uint16_t cSCSIused = 0;
1564 ControllersMap::const_iterator hdcIt;
1565 /* Iterate through all hard disk controllers */
1566 for (hdcIt = vsysThis.mapControllers.begin();
1567 hdcIt != vsysThis.mapControllers.end();
1568 ++hdcIt)
1569 {
1570 const HardDiskController &hdc = hdcIt->second;
1571 Utf8Str strControllerID = Utf8StrFmt("%RI32", (uint32_t)hdc.idController);
1572
1573 switch (hdc.system)
1574 {
1575 case HardDiskController::IDE:
1576 {
1577 /* Check for the constrains */
1578 /* @todo: I'm very confused! Are these bits *one* controller or
1579 is every port/bus declared as an extra controller. */
1580 if (cIDEused < 4)
1581 {
1582 // @todo: figure out the IDE types
1583 /* Use PIIX4 as default */
1584 Utf8Str strType = "PIIX4";
1585 if (!hdc.strControllerType.compare("PIIX3", Utf8Str::CaseInsensitive))
1586 strType = "PIIX3";
1587 else if (!hdc.strControllerType.compare("ICH6", Utf8Str::CaseInsensitive))
1588 strType = "ICH6";
1589 pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskControllerIDE,
1590 strControllerID,
1591 hdc.strControllerType,
1592 strType);
1593 }
1594 else
1595 {
1596 /* Warn only once */
1597 if (cIDEused == 1)
1598 addWarning(tr("The virtual \"%s\" system requests support for more than one IDE controller, but VirtualBox has support for only one."),
1599 vsysThis.strName.c_str());
1600
1601 }
1602 ++cIDEused;
1603 break;
1604 }
1605
1606#ifdef VBOX_WITH_AHCI
1607 case HardDiskController::SATA:
1608 {
1609 /* Check for the constrains */
1610 if (cSATAused < 1)
1611 {
1612 // @todo: figure out the SATA types
1613 /* We only support a plain AHCI controller, so use them always */
1614 pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskControllerSATA,
1615 strControllerID,
1616 hdc.strControllerType,
1617 "AHCI");
1618 }
1619 else
1620 {
1621 /* Warn only once */
1622 if (cSATAused == 1)
1623 addWarning(tr("The virtual system \"%s\" requests support for more than one SATA controller, but VirtualBox has support for only one"),
1624 vsysThis.strName.c_str());
1625
1626 }
1627 ++cSATAused;
1628 break;
1629 }
1630#endif /* VBOX_WITH_AHCI */
1631
1632 case HardDiskController::SCSI:
1633 {
1634 /* Check for the constrains */
1635 if (cSCSIused < 1)
1636 {
1637 Utf8Str hdcController = "LsiLogic";
1638 if (!hdc.strControllerType.compare("BusLogic", Utf8Str::CaseInsensitive))
1639 hdcController = "BusLogic";
1640 pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskControllerSCSI,
1641 strControllerID,
1642 hdc.strControllerType,
1643 hdcController);
1644 }
1645 else
1646 addWarning(tr("The virtual system \"%s\" requests support for an additional SCSI controller of type \"%s\" with ID %s, but VirtualBox presently supports only one SCSI controller."),
1647 vsysThis.strName.c_str(),
1648 hdc.strControllerType.c_str(),
1649 strControllerID.c_str());
1650 ++cSCSIused;
1651 break;
1652 }
1653 }
1654 }
1655
1656 /* Hard disks */
1657 if (vsysThis.mapVirtualDisks.size() > 0)
1658 {
1659 VirtualDisksMap::const_iterator itVD;
1660 /* Iterate through all hard disks ()*/
1661 for (itVD = vsysThis.mapVirtualDisks.begin();
1662 itVD != vsysThis.mapVirtualDisks.end();
1663 ++itVD)
1664 {
1665 const VirtualDisk &hd = itVD->second;
1666 /* Get the associated disk image */
1667 const DiskImage &di = m->mapDisks[hd.strDiskId];
1668
1669 // @todo:
1670 // - figure out all possible vmdk formats we also support
1671 // - figure out if there is a url specifier for vhd already
1672 // - we need a url specifier for the vdi format
1673 if ( di.strFormat.compare("http://www.vmware.com/specifications/vmdk.html#sparse", Utf8Str::CaseInsensitive)
1674 || di.strFormat.compare("http://www.vmware.com/specifications/vmdk.html#compressed", Utf8Str::CaseInsensitive))
1675 {
1676 /* If the href is empty use the VM name as filename */
1677 Utf8Str strFilename = di.strHref;
1678 if (!strFilename.length())
1679 strFilename = Utf8StrFmt("%s.vmdk", nameVBox.c_str());
1680 /* Construct a unique target path */
1681 Utf8StrFmt strPath("%ls%c%s",
1682 bstrDefaultHardDiskLocation.raw(),
1683 RTPATH_DELIMITER,
1684 strFilename.c_str());
1685 searchUniqueDiskImageFilePath(strPath);
1686
1687 /* find the description for the hard disk controller
1688 * that has the same ID as hd.idController */
1689 const VirtualSystemDescriptionEntry *pController;
1690 if (!(pController = pNewDesc->findControllerFromID(hd.idController)))
1691 throw setError(E_FAIL,
1692 tr("Cannot find hard disk controller with OVF instance ID %RI32 to which disk \"%s\" should be attached"),
1693 hd.idController,
1694 di.strHref.c_str());
1695
1696 /* controller to attach to, and the bus within that controller */
1697 Utf8StrFmt strExtraConfig("controller=%RI16;channel=%RI16",
1698 pController->ulIndex,
1699 hd.ulAddressOnParent);
1700 ULONG ulSize = 0;
1701 if (di.iCapacity != -1)
1702 ulSize = (ULONG)(di.iCapacity / _1M);
1703 else if (di.iPopulatedSize != -1)
1704 ulSize = (ULONG)(di.iPopulatedSize / _1M);
1705 else if (di.iSize != -1)
1706 ulSize = (ULONG)(di.iSize / _1M);
1707 if (ulSize == 0)
1708 ulSize = 10000; // assume 10 GB, this is for the progress bar only anyway
1709 pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskImage,
1710 hd.strDiskId,
1711 di.strHref,
1712 strPath,
1713 ulSize,
1714 strExtraConfig);
1715 }
1716 else
1717 throw setError(VBOX_E_FILE_ERROR,
1718 tr("Unsupported format for virtual disk image in OVF: \"%s\"", di.strFormat.c_str()));
1719 }
1720 }
1721
1722 m->virtualSystemDescriptions.push_back(pNewDesc);
1723 }
1724 }
1725 catch (HRESULT aRC)
1726 {
1727 /* On error we clear the list & return */
1728 m->virtualSystemDescriptions.clear();
1729 rc = aRC;
1730 }
1731
1732 return rc;
1733}
1734
1735struct Appliance::TaskImportMachines
1736{
1737 TaskImportMachines(Appliance *aThat, Progress *aProgress)
1738 : pAppliance(aThat)
1739 , progress(aProgress)
1740 , rc(S_OK)
1741 {}
1742 ~TaskImportMachines() {}
1743
1744 HRESULT startThread();
1745
1746 Appliance *pAppliance;
1747 ComObjPtr<Progress> progress;
1748 HRESULT rc;
1749};
1750
1751HRESULT Appliance::TaskImportMachines::startThread()
1752{
1753 int vrc = RTThreadCreate(NULL, Appliance::taskThreadImportMachines, this,
1754 0, RTTHREADTYPE_MAIN_HEAVY_WORKER, 0,
1755 "Appliance::Task");
1756 ComAssertMsgRCRet(vrc,
1757 ("Could not create taskThreadImportMachines (%Rrc)\n", vrc), E_FAIL);
1758
1759 return S_OK;
1760}
1761
1762/**
1763 * Public method implementation.
1764 * @param aProgress
1765 * @return
1766 */
1767STDMETHODIMP Appliance::ImportMachines(IProgress **aProgress)
1768{
1769 CheckComArgOutPointerValid(aProgress);
1770
1771 AutoCaller autoCaller(this);
1772 CheckComRCReturnRC(autoCaller.rc());
1773
1774 AutoReadLock(this);
1775
1776 HRESULT rc = S_OK;
1777
1778 ComObjPtr<Progress> progress;
1779 try
1780 {
1781 Bstr progressDesc = BstrFmt(tr("Import appliance '%s'"),
1782 m->strPath.raw());
1783 rc = setUpProgress(progress, progressDesc);
1784 if (FAILED(rc)) throw rc;
1785
1786 /* Initialize our worker task */
1787 std::auto_ptr<TaskImportMachines> task(new TaskImportMachines(this, progress));
1788 //AssertComRCThrowRC (task->autoCaller.rc());
1789
1790 rc = task->startThread();
1791 if (FAILED(rc)) throw rc;
1792
1793 task.release();
1794 }
1795 catch (HRESULT aRC)
1796 {
1797 rc = aRC;
1798 }
1799
1800 if (SUCCEEDED(rc))
1801 /* Return progress to the caller */
1802 progress.queryInterfaceTo(aProgress);
1803
1804 return rc;
1805}
1806
1807struct MyHardDiskAttachment
1808{
1809 Guid uuid;
1810 ComPtr<IMachine> pMachine;
1811 Bstr controllerType;
1812 int32_t lChannel;
1813 int32_t lDevice;
1814};
1815
1816/**
1817 * Worker thread implementation for ImportMachines().
1818 * @param aThread
1819 * @param pvUser
1820 */
1821/* static */
1822DECLCALLBACK(int) Appliance::taskThreadImportMachines(RTTHREAD /* aThread */, void *pvUser)
1823{
1824 std::auto_ptr<TaskImportMachines> task(static_cast<TaskImportMachines*>(pvUser));
1825 AssertReturn(task.get(), VERR_GENERAL_FAILURE);
1826
1827 Appliance *pAppliance = task->pAppliance;
1828
1829 LogFlowFuncEnter();
1830 LogFlowFunc(("Appliance %p\n", pAppliance));
1831
1832 AutoCaller autoCaller(pAppliance);
1833 CheckComRCReturnRC(autoCaller.rc());
1834
1835 AutoWriteLock appLock(pAppliance);
1836
1837 HRESULT rc = S_OK;
1838
1839 ComPtr<IVirtualBox> pVirtualBox(pAppliance->mVirtualBox);
1840
1841 // rollback for errors:
1842 // 1) a list of images that we created/imported
1843 list<MyHardDiskAttachment> llHardDiskAttachments;
1844 list< ComPtr<IHardDisk> > llHardDisksCreated;
1845 list<Guid> llMachinesRegistered;
1846
1847 ComPtr<ISession> session;
1848 bool fSessionOpen = false;
1849 rc = session.createInprocObject(CLSID_Session);
1850 CheckComRCReturnRC(rc);
1851
1852 list<VirtualSystem>::const_iterator it;
1853 list< ComObjPtr<VirtualSystemDescription> >::const_iterator it1;
1854 /* Iterate through all virtual systems of that appliance */
1855 size_t i = 0;
1856 for (it = pAppliance->m->llVirtualSystems.begin(),
1857 it1 = pAppliance->m->virtualSystemDescriptions.begin();
1858 it != pAppliance->m->llVirtualSystems.end();
1859 ++it, ++it1, ++i)
1860 {
1861 const VirtualSystem &vsysThis = *it;
1862 ComObjPtr<VirtualSystemDescription> vsdescThis = (*it1);
1863
1864 ComPtr<IMachine> pNewMachine;
1865
1866 /* Catch possible errors */
1867 try
1868 {
1869 /* Guest OS type */
1870 std::list<VirtualSystemDescriptionEntry*> vsdeOS;
1871 vsdeOS = vsdescThis->findByType(VirtualSystemDescriptionType_OS);
1872 if (vsdeOS.size() < 1)
1873 throw setError(VBOX_E_FILE_ERROR,
1874 tr("Missing guest OS type"));
1875 const Utf8Str &strOsTypeVBox = vsdeOS.front()->strVbox;
1876
1877 /* Now that we know the base system get our internal defaults based on that. */
1878 ComPtr<IGuestOSType> osType;
1879 rc = pVirtualBox->GetGuestOSType(Bstr(strOsTypeVBox), osType.asOutParam());
1880 if (FAILED(rc)) throw rc;
1881
1882 /* Create the machine */
1883 /* First get the name */
1884 std::list<VirtualSystemDescriptionEntry*> vsdeName = vsdescThis->findByType(VirtualSystemDescriptionType_Name);
1885 if (vsdeName.size() < 1)
1886 throw setError(VBOX_E_FILE_ERROR,
1887 tr("Missing VM name"));
1888 const Utf8Str &strNameVBox = vsdeName.front()->strVbox;
1889 rc = pVirtualBox->CreateMachine(Bstr(strNameVBox), Bstr(strOsTypeVBox),
1890 Bstr(), Guid(),
1891 pNewMachine.asOutParam());
1892 if (FAILED(rc)) throw rc;
1893
1894 // and the description
1895 std::list<VirtualSystemDescriptionEntry*> vsdeDescription = vsdescThis->findByType(VirtualSystemDescriptionType_Description);
1896 if (vsdeDescription.size())
1897 {
1898 const Utf8Str &strDescription = vsdeDescription.front()->strVbox;
1899 rc = pNewMachine->COMSETTER(Description)(Bstr(strDescription));
1900 if (FAILED(rc)) throw rc;
1901 }
1902
1903 /* CPU count (ignored for now) */
1904 // EntriesList vsdeCPU = vsd->findByType (VirtualSystemDescriptionType_CPU);
1905
1906 /* RAM */
1907 std::list<VirtualSystemDescriptionEntry*> vsdeRAM = vsdescThis->findByType(VirtualSystemDescriptionType_Memory);
1908 ComAssertMsgThrow(vsdeRAM.size() == 1, ("RAM size missing"), E_FAIL);
1909 const Utf8Str &memoryVBox = vsdeRAM.front()->strVbox;
1910 ULONG tt = (ULONG)RTStrToUInt64(memoryVBox.c_str());
1911 rc = pNewMachine->COMSETTER(MemorySize)(tt);
1912 if (FAILED(rc)) throw rc;
1913
1914 /* VRAM */
1915 /* Get the recommended VRAM for this guest OS type */
1916 ULONG vramVBox;
1917 rc = osType->COMGETTER(RecommendedVRAM)(&vramVBox);
1918 if (FAILED(rc)) throw rc;
1919
1920 /* Set the VRAM */
1921 rc = pNewMachine->COMSETTER(VRAMSize)(vramVBox);
1922 if (FAILED(rc)) throw rc;
1923
1924 /* Audio Adapter */
1925 std::list<VirtualSystemDescriptionEntry*> vsdeAudioAdapter = vsdescThis->findByType(VirtualSystemDescriptionType_SoundCard);
1926 /* @todo: we support one audio adapter only */
1927 if (vsdeAudioAdapter.size() > 0)
1928 {
1929 const Utf8Str& audioAdapterVBox = vsdeAudioAdapter.front()->strVbox;
1930 if (audioAdapterVBox.compare("null", Utf8Str::CaseInsensitive) != 0)
1931 {
1932 uint32_t audio = RTStrToUInt32(audioAdapterVBox.c_str());
1933 ComPtr<IAudioAdapter> audioAdapter;
1934 rc = pNewMachine->COMGETTER(AudioAdapter)(audioAdapter.asOutParam());
1935 if (FAILED(rc)) throw rc;
1936 rc = audioAdapter->COMSETTER(Enabled)(true);
1937 if (FAILED(rc)) throw rc;
1938 rc = audioAdapter->COMSETTER(AudioController)(static_cast<AudioControllerType_T>(audio));
1939 if (FAILED(rc)) throw rc;
1940 }
1941 }
1942
1943#ifdef VBOX_WITH_USB
1944 /* USB Controller */
1945 std::list<VirtualSystemDescriptionEntry*> vsdeUSBController = vsdescThis->findByType(VirtualSystemDescriptionType_USBController);
1946 // USB support is enabled if there's at least one such entry; to disable USB support,
1947 // the type of the USB item would have been changed to "ignore"
1948 bool fUSBEnabled = vsdeUSBController.size() > 0;
1949
1950 ComPtr<IUSBController> usbController;
1951 rc = pNewMachine->COMGETTER(USBController)(usbController.asOutParam());
1952 if (FAILED(rc)) throw rc;
1953 rc = usbController->COMSETTER(Enabled)(fUSBEnabled);
1954 if (FAILED(rc)) throw rc;
1955#endif /* VBOX_WITH_USB */
1956
1957 /* Change the network adapters */
1958 std::list<VirtualSystemDescriptionEntry*> vsdeNW = vsdescThis->findByType(VirtualSystemDescriptionType_NetworkAdapter);
1959 if (vsdeNW.size() == 0)
1960 {
1961 /* No network adapters, so we have to disable our default one */
1962 ComPtr<INetworkAdapter> nwVBox;
1963 rc = pNewMachine->GetNetworkAdapter(0, nwVBox.asOutParam());
1964 if (FAILED(rc)) throw rc;
1965 rc = nwVBox->COMSETTER(Enabled)(false);
1966 if (FAILED(rc)) throw rc;
1967 }
1968 else
1969 {
1970 list<VirtualSystemDescriptionEntry*>::const_iterator nwIt;
1971 /* Iterate through all network cards. We support 8 network adapters
1972 * at the maximum. (@todo: warn if there are more!) */
1973 size_t a = 0;
1974 for (nwIt = vsdeNW.begin();
1975 (nwIt != vsdeNW.end() && a < SchemaDefs::NetworkAdapterCount);
1976 ++nwIt, ++a)
1977 {
1978 const VirtualSystemDescriptionEntry* pvsys = *nwIt;
1979
1980 const Utf8Str &nwTypeVBox = pvsys->strVbox;
1981 uint32_t tt1 = RTStrToUInt32(nwTypeVBox.c_str());
1982 ComPtr<INetworkAdapter> pNetworkAdapter;
1983 rc = pNewMachine->GetNetworkAdapter((ULONG)a, pNetworkAdapter.asOutParam());
1984 if (FAILED(rc)) throw rc;
1985 /* Enable the network card & set the adapter type */
1986 rc = pNetworkAdapter->COMSETTER(Enabled)(true);
1987 if (FAILED(rc)) throw rc;
1988 rc = pNetworkAdapter->COMSETTER(AdapterType)(static_cast<NetworkAdapterType_T>(tt1));
1989 if (FAILED(rc)) throw rc;
1990
1991 // default is NAT; change to "bridged" if extra conf says so
1992 if (!pvsys->strExtraConfig.compare("type=Bridged", Utf8Str::CaseInsensitive))
1993 {
1994 /* Attach to the right interface */
1995 rc = pNetworkAdapter->AttachToBridgedInterface();
1996 if (FAILED(rc)) throw rc;
1997 ComPtr<IHost> host;
1998 rc = pVirtualBox->COMGETTER(Host)(host.asOutParam());
1999 if (FAILED(rc)) throw rc;
2000 com::SafeIfaceArray<IHostNetworkInterface> nwInterfaces;
2001 rc = host->COMGETTER(NetworkInterfaces)(ComSafeArrayAsOutParam(nwInterfaces));
2002 if (FAILED(rc)) throw rc;
2003 /* We search for the first host network interface which
2004 * is usable for bridged networking */
2005 for (size_t i=0; i < nwInterfaces.size(); ++i)
2006 {
2007 HostNetworkInterfaceType_T itype;
2008 rc = nwInterfaces[i]->COMGETTER(InterfaceType)(&itype);
2009 if (FAILED(rc)) throw rc;
2010 if (itype == HostNetworkInterfaceType_Bridged)
2011 {
2012 Bstr name;
2013 rc = nwInterfaces[i]->COMGETTER(Name)(name.asOutParam());
2014 if (FAILED(rc)) throw rc;
2015 /* Set the interface name to attach to */
2016 pNetworkAdapter->COMSETTER(HostInterface)(name);
2017 if (FAILED(rc)) throw rc;
2018 break;
2019 }
2020 }
2021 }
2022 /* Next test for host only interfaces */
2023 else if (!pvsys->strExtraConfig.compare("type=HostOnly", Utf8Str::CaseInsensitive))
2024 {
2025 /* Attach to the right interface */
2026 rc = pNetworkAdapter->AttachToHostOnlyInterface();
2027 if (FAILED(rc)) throw rc;
2028 ComPtr<IHost> host;
2029 rc = pVirtualBox->COMGETTER(Host)(host.asOutParam());
2030 if (FAILED(rc)) throw rc;
2031 com::SafeIfaceArray<IHostNetworkInterface> nwInterfaces;
2032 rc = host->COMGETTER(NetworkInterfaces)(ComSafeArrayAsOutParam(nwInterfaces));
2033 if (FAILED(rc)) throw rc;
2034 /* We search for the first host network interface which
2035 * is usable for host only networking */
2036 for (size_t i=0; i < nwInterfaces.size(); ++i)
2037 {
2038 HostNetworkInterfaceType_T itype;
2039 rc = nwInterfaces[i]->COMGETTER(InterfaceType)(&itype);
2040 if (FAILED(rc)) throw rc;
2041 if (itype == HostNetworkInterfaceType_HostOnly)
2042 {
2043 Bstr name;
2044 rc = nwInterfaces[i]->COMGETTER(Name)(name.asOutParam());
2045 if (FAILED(rc)) throw rc;
2046 /* Set the interface name to attach to */
2047 pNetworkAdapter->COMSETTER(HostInterface)(name);
2048 if (FAILED(rc)) throw rc;
2049 break;
2050 }
2051 }
2052 }
2053 }
2054 }
2055
2056 /* Floppy drive */
2057 std::list<VirtualSystemDescriptionEntry*> vsdeFloppy = vsdescThis->findByType(VirtualSystemDescriptionType_Floppy);
2058 // Floppy support is enabled if there's at least one such entry; to disable floppy support,
2059 // the type of the floppy item would have been changed to "ignore"
2060 bool fFloppyEnabled = vsdeFloppy.size() > 0;
2061 ComPtr<IFloppyDrive> floppyDrive;
2062 rc = pNewMachine->COMGETTER(FloppyDrive)(floppyDrive.asOutParam());
2063 if (FAILED(rc)) throw rc;
2064 rc = floppyDrive->COMSETTER(Enabled)(fFloppyEnabled);
2065 if (FAILED(rc)) throw rc;
2066
2067 /* CDROM drive */
2068 /* @todo: I can't disable the CDROM. So nothing to do for now */
2069 // std::list<VirtualSystemDescriptionEntry*> vsdeFloppy = vsd->findByType(VirtualSystemDescriptionType_CDROM);
2070
2071 /* Hard disk controller IDE */
2072 std::list<VirtualSystemDescriptionEntry*> vsdeHDCIDE = vsdescThis->findByType(VirtualSystemDescriptionType_HardDiskControllerIDE);
2073 if (vsdeHDCIDE.size() > 1)
2074 throw setError(VBOX_E_FILE_ERROR,
2075 tr("Too many IDE controllers in OVF; VirtualBox only supports one"));
2076 if (vsdeHDCIDE.size() == 1)
2077 {
2078 ComPtr<IStorageController> pController;
2079 rc = pNewMachine->GetStorageControllerByName(Bstr("IDE"), pController.asOutParam());
2080 if (FAILED(rc)) throw rc;
2081
2082 const char *pcszIDEType = vsdeHDCIDE.front()->strVbox.c_str();
2083 if (!strcmp(pcszIDEType, "PIIX3"))
2084 rc = pController->COMSETTER(ControllerType)(StorageControllerType_PIIX3);
2085 else if (!strcmp(pcszIDEType, "PIIX4"))
2086 rc = pController->COMSETTER(ControllerType)(StorageControllerType_PIIX4);
2087 else if (!strcmp(pcszIDEType, "ICH6"))
2088 rc = pController->COMSETTER(ControllerType)(StorageControllerType_ICH6);
2089 else
2090 throw setError(VBOX_E_FILE_ERROR,
2091 tr("Invalid IDE controller type \"%s\""),
2092 pcszIDEType);
2093 if (FAILED(rc)) throw rc;
2094 }
2095#ifdef VBOX_WITH_AHCI
2096 /* Hard disk controller SATA */
2097 std::list<VirtualSystemDescriptionEntry*> vsdeHDCSATA = vsdescThis->findByType(VirtualSystemDescriptionType_HardDiskControllerSATA);
2098 if (vsdeHDCSATA.size() > 1)
2099 throw setError(VBOX_E_FILE_ERROR,
2100 tr("Too many SATA controllers in OVF; VirtualBox only supports one"));
2101 if (vsdeHDCSATA.size() > 0)
2102 {
2103 ComPtr<IStorageController> pController;
2104 const Utf8Str &hdcVBox = vsdeHDCSATA.front()->strVbox;
2105 if (hdcVBox == "AHCI")
2106 {
2107 rc = pNewMachine->AddStorageController(Bstr("SATA"), StorageBus_SATA, pController.asOutParam());
2108 if (FAILED(rc)) throw rc;
2109 }
2110 else
2111 throw setError(VBOX_E_FILE_ERROR,
2112 tr("Invalid SATA controller type \"%s\""),
2113 hdcVBox.c_str());
2114 }
2115#endif /* VBOX_WITH_AHCI */
2116
2117 /* Hard disk controller SCSI */
2118 std::list<VirtualSystemDescriptionEntry*> vsdeHDCSCSI = vsdescThis->findByType(VirtualSystemDescriptionType_HardDiskControllerSCSI);
2119 if (vsdeHDCSCSI.size() > 1)
2120 throw setError(VBOX_E_FILE_ERROR,
2121 tr("Too many SCSI controllers in OVF; VirtualBox only supports one"));
2122 if (vsdeHDCSCSI.size() > 0)
2123 {
2124 ComPtr<IStorageController> pController;
2125 StorageControllerType_T controllerType;
2126 const Utf8Str &hdcVBox = vsdeHDCSCSI.front()->strVbox;
2127 if (hdcVBox == "LsiLogic")
2128 controllerType = StorageControllerType_LsiLogic;
2129 else if (hdcVBox == "BusLogic")
2130 controllerType = StorageControllerType_BusLogic;
2131 else
2132 throw setError(VBOX_E_FILE_ERROR,
2133 tr("Invalid SCSI controller type \"%s\""),
2134 hdcVBox.c_str());
2135
2136 rc = pNewMachine->AddStorageController(Bstr("SCSI"), StorageBus_SCSI, pController.asOutParam());
2137 if (FAILED(rc)) throw rc;
2138 rc = pController->COMSETTER(ControllerType)(controllerType);
2139 if (FAILED(rc)) throw rc;
2140 }
2141
2142 /* Now its time to register the machine before we add any hard disks */
2143 rc = pVirtualBox->RegisterMachine(pNewMachine);
2144 if (FAILED(rc)) throw rc;
2145
2146 Guid newMachineId;
2147 rc = pNewMachine->COMGETTER(Id)(newMachineId.asOutParam());
2148 if (FAILED(rc)) throw rc;
2149
2150 // store new machine for roll-back in case of errors
2151 llMachinesRegistered.push_back(newMachineId);
2152
2153 /* Create the hard disks & connect them to the appropriate controllers. */
2154 std::list<VirtualSystemDescriptionEntry*> avsdeHDs = vsdescThis->findByType(VirtualSystemDescriptionType_HardDiskImage);
2155 if (avsdeHDs.size() > 0)
2156 {
2157 /* If in the next block an error occur we have to deregister
2158 the machine, so make an extra try/catch block. */
2159 ComPtr<IHardDisk> srcHdVBox;
2160 bool fSourceHdNeedsClosing = false;
2161
2162 try
2163 {
2164 /* In order to attach hard disks we need to open a session
2165 * for the new machine */
2166 rc = pVirtualBox->OpenSession(session, newMachineId);
2167 if (FAILED(rc)) throw rc;
2168 fSessionOpen = true;
2169
2170 /* The disk image has to be on the same place as the OVF file. So
2171 * strip the filename out of the full file path. */
2172 Utf8Str strSrcDir = stripFilename(pAppliance->m->strPath);
2173
2174 /* Iterate over all given disk images */
2175 list<VirtualSystemDescriptionEntry*>::const_iterator itHD;
2176 for (itHD = avsdeHDs.begin();
2177 itHD != avsdeHDs.end();
2178 ++itHD)
2179 {
2180 VirtualSystemDescriptionEntry *vsdeHD = *itHD;
2181
2182 const char *pcszDstFilePath = vsdeHD->strVbox.c_str();
2183 /* Check if the destination file exists already or the
2184 * destination path is empty. */
2185 if ( !(*pcszDstFilePath)
2186 || RTPathExists(pcszDstFilePath)
2187 )
2188 /* This isn't allowed */
2189 throw setError(VBOX_E_FILE_ERROR,
2190 tr("Destination file '%s' exists",
2191 pcszDstFilePath));
2192
2193 /* Find the disk from the OVF's disk list */
2194 DiskImagesMap::const_iterator itDiskImage = pAppliance->m->mapDisks.find(vsdeHD->strRef);
2195 /* vsdeHD->strRef contains the disk identifier (e.g. "vmdisk1"), which should exist
2196 in the virtual system's disks map under that ID and also in the global images map. */
2197 VirtualDisksMap::const_iterator itVirtualDisk = vsysThis.mapVirtualDisks.find(vsdeHD->strRef);
2198
2199 if ( itDiskImage == pAppliance->m->mapDisks.end()
2200 || itVirtualDisk == vsysThis.mapVirtualDisks.end()
2201 )
2202 throw setError(E_FAIL,
2203 tr("Internal inconsistency looking up disk images."));
2204
2205 const DiskImage &di = itDiskImage->second;
2206 const VirtualDisk &vd = itVirtualDisk->second;
2207
2208 /* Make sure all target directories exists */
2209 rc = VirtualBox::ensureFilePathExists(pcszDstFilePath);
2210 if (FAILED(rc))
2211 throw rc;
2212
2213 // subprogress object for hard disk
2214 ComPtr<IProgress> pProgress2;
2215
2216 ComPtr<IHardDisk> dstHdVBox;
2217 /* If strHref is empty we have to create a new file */
2218 if (di.strHref.isEmpty())
2219 {
2220 /* Which format to use? */
2221 Bstr srcFormat = L"VDI";
2222 if ( di.strFormat.compare("http://www.vmware.com/specifications/vmdk.html#sparse", Utf8Str::CaseInsensitive)
2223 || di.strFormat.compare("http://www.vmware.com/specifications/vmdk.html#compressed", Utf8Str::CaseInsensitive))
2224 srcFormat = L"VMDK";
2225 /* Create an empty hard disk */
2226 rc = pVirtualBox->CreateHardDisk(srcFormat, Bstr(pcszDstFilePath), dstHdVBox.asOutParam());
2227 if (FAILED(rc)) throw rc;
2228
2229 /* Create a dynamic growing disk image with the given capacity */
2230 rc = dstHdVBox->CreateBaseStorage(di.iCapacity / _1M, HardDiskVariant_Standard, pProgress2.asOutParam());
2231 if (FAILED(rc)) throw rc;
2232
2233 /* Advance to the next operation */
2234 if (!task->progress.isNull())
2235 task->progress->setNextOperation(BstrFmt(tr("Creating virtual disk image '%s'"), pcszDstFilePath),
2236 vsdeHD->ulSizeMB); // operation's weight, as set up with the IProgress originally
2237 }
2238 else
2239 {
2240 /* Construct the source file path */
2241 Utf8StrFmt strSrcFilePath("%s%c%s", strSrcDir.c_str(), RTPATH_DELIMITER, di.strHref.c_str());
2242 /* Check if the source file exists */
2243 if (!RTPathExists(strSrcFilePath.c_str()))
2244 /* This isn't allowed */
2245 throw setError(VBOX_E_FILE_ERROR,
2246 tr("Source virtual disk image file '%s' doesn't exist"),
2247 strSrcFilePath.c_str());
2248
2249 /* Clone the disk image (this is necessary cause the id has
2250 * to be recreated for the case the same hard disk is
2251 * attached already from a previous import) */
2252
2253 /* First open the existing disk image */
2254 rc = pVirtualBox->OpenHardDisk(Bstr(strSrcFilePath),
2255 AccessMode_ReadOnly,
2256 srcHdVBox.asOutParam());
2257 if (FAILED(rc)) throw rc;
2258 fSourceHdNeedsClosing = true;
2259
2260 /* We need the format description of the source disk image */
2261 Bstr srcFormat;
2262 rc = srcHdVBox->COMGETTER(Format)(srcFormat.asOutParam());
2263 if (FAILED(rc)) throw rc;
2264 /* Create a new hard disk interface for the destination disk image */
2265 rc = pVirtualBox->CreateHardDisk(srcFormat, Bstr(pcszDstFilePath), dstHdVBox.asOutParam());
2266 if (FAILED(rc)) throw rc;
2267 /* Clone the source disk image */
2268 rc = srcHdVBox->CloneTo(dstHdVBox, HardDiskVariant_Standard, NULL, pProgress2.asOutParam());
2269 if (FAILED(rc)) throw rc;
2270
2271 /* Advance to the next operation */
2272 if (!task->progress.isNull())
2273 task->progress->setNextOperation(BstrFmt(tr("Importing virtual disk image '%s'"), strSrcFilePath.c_str()),
2274 vsdeHD->ulSizeMB); // operation's weight, as set up with the IProgress originally);
2275 }
2276
2277 // now wait for the background disk operation to complete; this throws HRESULTs on error
2278 pAppliance->waitForAsyncProgress(task->progress, pProgress2);
2279
2280 if (fSourceHdNeedsClosing)
2281 {
2282 rc = srcHdVBox->Close();
2283 if (FAILED(rc)) throw rc;
2284 fSourceHdNeedsClosing = false;
2285 }
2286
2287 llHardDisksCreated.push_back(dstHdVBox);
2288 /* Now use the new uuid to attach the disk image to our new machine */
2289 ComPtr<IMachine> sMachine;
2290 rc = session->COMGETTER(Machine)(sMachine.asOutParam());
2291 if (FAILED(rc)) throw rc;
2292 Guid hdId;
2293 rc = dstHdVBox->COMGETTER(Id)(hdId.asOutParam());
2294 if (FAILED(rc)) throw rc;
2295
2296 /* For now we assume we have one controller of every type only */
2297 HardDiskController hdc = (*vsysThis.mapControllers.find(vd.idController)).second;
2298
2299 // this is for rollback later
2300 MyHardDiskAttachment mhda;
2301 mhda.uuid = newMachineId;
2302 mhda.pMachine = pNewMachine;
2303
2304 switch (hdc.system)
2305 {
2306 case HardDiskController::IDE:
2307 // For the IDE bus, the channel parameter can be either 0 or 1, to specify the primary
2308 // or secondary IDE controller, respectively. For the primary controller of the IDE bus,
2309 // the device number can be either 0 or 1, to specify the master or the slave device,
2310 // respectively. For the secondary IDE controller, the device number is always 1 because
2311 // the master device is reserved for the CD-ROM drive.
2312 mhda.controllerType = Bstr("IDE");
2313 switch (vd.ulAddressOnParent)
2314 {
2315 case 0: // interpret this as primary master
2316 mhda.lChannel = (long)0;
2317 mhda.lDevice = (long)0;
2318 break;
2319
2320 case 1: // interpret this as primary slave
2321 mhda.lChannel = (long)0;
2322 mhda.lDevice = (long)1;
2323 break;
2324
2325 case 2: // interpret this as secondary slave
2326 mhda.lChannel = (long)1;
2327 mhda.lDevice = (long)1;
2328 break;
2329
2330 default:
2331 throw setError(VBOX_E_NOT_SUPPORTED,
2332 tr("Invalid channel %RI16 specified; IDE controllers support only 0, 1 or 2"), vd.ulAddressOnParent);
2333 break;
2334 }
2335 break;
2336
2337 case HardDiskController::SATA:
2338 mhda.controllerType = Bstr("SATA");
2339 mhda.lChannel = (long)vd.ulAddressOnParent;
2340 mhda.lDevice = (long)0;
2341 break;
2342
2343 case HardDiskController::SCSI:
2344 mhda.controllerType = Bstr("SCSI");
2345 mhda.lChannel = (long)vd.ulAddressOnParent;
2346 mhda.lDevice = (long)0;
2347 break;
2348
2349 default: break;
2350 }
2351
2352 Log(("Attaching disk %s to channel %d on device %d\n", pcszDstFilePath, mhda.lChannel, mhda.lDevice));
2353
2354 rc = sMachine->AttachHardDisk(hdId,
2355 mhda.controllerType,
2356 mhda.lChannel,
2357 mhda.lDevice);
2358 if (FAILED(rc)) throw rc;
2359
2360 llHardDiskAttachments.push_back(mhda);
2361
2362 rc = sMachine->SaveSettings();
2363 if (FAILED(rc)) throw rc;
2364 } // end for (itHD = avsdeHDs.begin();
2365
2366 // only now that we're done with all disks, close the session
2367 rc = session->Close();
2368 if (FAILED(rc)) throw rc;
2369 fSessionOpen = false;
2370 }
2371 catch(HRESULT /* aRC */)
2372 {
2373 if (fSourceHdNeedsClosing)
2374 srcHdVBox->Close();
2375
2376 if (fSessionOpen)
2377 session->Close();
2378
2379 throw;
2380 }
2381 }
2382 }
2383 catch(HRESULT aRC)
2384 {
2385 rc = aRC;
2386 }
2387
2388 if (FAILED(rc))
2389 break;
2390
2391 } // for (it = pAppliance->m->llVirtualSystems.begin(),
2392
2393 if (FAILED(rc))
2394 {
2395 // with _whatever_ error we've had, do a complete roll-back of
2396 // machines and disks we've created; unfortunately this is
2397 // not so trivially done...
2398
2399 HRESULT rc2;
2400 // detach all hard disks from all machines we created
2401 list<MyHardDiskAttachment>::iterator itM;
2402 for (itM = llHardDiskAttachments.begin();
2403 itM != llHardDiskAttachments.end();
2404 ++itM)
2405 {
2406 const MyHardDiskAttachment &mhda = *itM;
2407 rc2 = pVirtualBox->OpenSession(session, mhda.uuid);
2408 if (SUCCEEDED(rc2))
2409 {
2410 ComPtr<IMachine> sMachine;
2411 rc2 = session->COMGETTER(Machine)(sMachine.asOutParam());
2412 if (SUCCEEDED(rc2))
2413 {
2414 rc2 = sMachine->DetachHardDisk(Bstr(mhda.controllerType), mhda.lChannel, mhda.lDevice);
2415 rc2 = sMachine->SaveSettings();
2416 }
2417 session->Close();
2418 }
2419 }
2420
2421 // now clean up all hard disks we created
2422 list< ComPtr<IHardDisk> >::iterator itHD;
2423 for (itHD = llHardDisksCreated.begin();
2424 itHD != llHardDisksCreated.end();
2425 ++itHD)
2426 {
2427 ComPtr<IHardDisk> pDisk = *itHD;
2428 ComPtr<IProgress> pProgress;
2429 rc2 = pDisk->DeleteStorage(pProgress.asOutParam());
2430 rc2 = pProgress->WaitForCompletion(-1);
2431 }
2432
2433 // finally, deregister and remove all machines
2434 list<Guid>::iterator itID;
2435 for (itID = llMachinesRegistered.begin();
2436 itID != llMachinesRegistered.end();
2437 ++itID)
2438 {
2439 const Guid &guid = *itID;
2440 ComPtr<IMachine> failedMachine;
2441 rc2 = pVirtualBox->UnregisterMachine(guid, failedMachine.asOutParam());
2442 if (SUCCEEDED(rc2))
2443 rc2 = failedMachine->DeleteSettings();
2444 }
2445 }
2446
2447 task->rc = rc;
2448
2449 if (!task->progress.isNull())
2450 task->progress->notifyComplete(rc);
2451
2452 LogFlowFunc(("rc=%Rhrc\n", rc));
2453 LogFlowFuncLeave();
2454
2455 return VINF_SUCCESS;
2456}
2457
2458struct Appliance::TaskWriteOVF
2459{
2460 TaskWriteOVF(Appliance *aThat, Progress *aProgress)
2461 : pAppliance(aThat)
2462 , progress(aProgress)
2463 , rc(S_OK)
2464 {}
2465 ~TaskWriteOVF() {}
2466
2467 HRESULT startThread();
2468
2469 Appliance *pAppliance;
2470 ComObjPtr<Progress> progress;
2471 HRESULT rc;
2472};
2473
2474HRESULT Appliance::TaskWriteOVF::startThread()
2475{
2476 int vrc = RTThreadCreate(NULL, Appliance::taskThreadWriteOVF, this,
2477 0, RTTHREADTYPE_MAIN_HEAVY_WORKER, 0,
2478 "Appliance::Task");
2479 ComAssertMsgRCRet(vrc,
2480 ("Could not create taskThreadExportOVF (%Rrc)\n", vrc), E_FAIL);
2481
2482 return S_OK;
2483}
2484
2485STDMETHODIMP Appliance::Write(IN_BSTR path, IProgress **aProgress)
2486{
2487 HRESULT rc = S_OK;
2488
2489 CheckComArgOutPointerValid(aProgress);
2490
2491 AutoCaller autoCaller(this);
2492 if (FAILED(rc = autoCaller.rc())) return rc;
2493
2494 AutoWriteLock(this);
2495
2496 // see if we can handle this file; for now we insist it has an ".ovf" extension
2497 m->strPath = path;
2498 if (!m->strPath.endsWith(".ovf", Utf8Str::CaseInsensitive))
2499 return setError(VBOX_E_FILE_ERROR,
2500 tr("Appliance file must have .ovf extension"));
2501
2502 ComObjPtr<Progress> progress;
2503 try
2504 {
2505 Bstr progressDesc = BstrFmt(tr("Export appliance '%s'"),
2506 m->strPath.raw());
2507 rc = setUpProgress(progress, progressDesc);
2508 if (FAILED(rc)) throw rc;
2509
2510 /* Initialize our worker task */
2511 std::auto_ptr<TaskWriteOVF> task(new TaskWriteOVF(this, progress));
2512 //AssertComRCThrowRC (task->autoCaller.rc());
2513
2514 rc = task->startThread();
2515 CheckComRCThrowRC(rc);
2516
2517 task.release();
2518 }
2519 catch (HRESULT aRC)
2520 {
2521 rc = aRC;
2522 }
2523
2524 if (SUCCEEDED(rc))
2525 /* Return progress to the caller */
2526 progress.queryInterfaceTo(aProgress);
2527
2528 return rc;
2529}
2530
2531/**
2532 * Worker thread implementation for Write() (ovf writer).
2533 * @param aThread
2534 * @param pvUser
2535 */
2536/* static */
2537DECLCALLBACK(int) Appliance::taskThreadWriteOVF(RTTHREAD /* aThread */, void *pvUser)
2538{
2539 std::auto_ptr<TaskWriteOVF> task(static_cast<TaskWriteOVF*>(pvUser));
2540 AssertReturn(task.get(), VERR_GENERAL_FAILURE);
2541
2542 Appliance *pAppliance = task->pAppliance;
2543
2544 LogFlowFuncEnter();
2545 LogFlowFunc(("Appliance %p\n", pAppliance));
2546
2547 AutoCaller autoCaller(pAppliance);
2548 CheckComRCReturnRC(autoCaller.rc());
2549
2550 AutoWriteLock appLock(pAppliance);
2551
2552 HRESULT rc = S_OK;
2553
2554 ComPtr<IVirtualBox> pVirtualBox(pAppliance->mVirtualBox);
2555
2556 try
2557 {
2558 xml::Document doc;
2559 xml::ElementNode *pelmRoot = doc.createRootElement("Envelope");
2560
2561 pelmRoot->setAttribute("ovf:version", "1.0");
2562 pelmRoot->setAttribute("xml:lang", "en-US");
2563 pelmRoot->setAttribute("xmlns", "http://schemas.dmtf.org/ovf/envelope/1");
2564 pelmRoot->setAttribute("xmlns:ovf", "http://schemas.dmtf.org/ovf/envelope/1");
2565 pelmRoot->setAttribute("xmlns:ovfstr", "http://schema.dmtf.org/ovf/strings/1");
2566 pelmRoot->setAttribute("xmlns:rasd", "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData");
2567 pelmRoot->setAttribute("xmlns:vssd", "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_VirtualSystemSettingData");
2568 pelmRoot->setAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
2569 pelmRoot->setAttribute("xsi:schemaLocation", "http://schemas.dmtf.org/ovf/envelope/1 ../ovf-envelope.xsd");
2570
2571 // <Envelope>/<References>
2572 xml::ElementNode *pelmReferences = pelmRoot->createChild("References");
2573
2574 /* <Envelope>/<DiskSection>:
2575 <DiskSection>
2576 <Info>List of the virtual disks used in the package</Info>
2577 <Disk ovf:capacity="4294967296" ovf:diskId="lamp" ovf:format="http://www.vmware.com/specifications/vmdk.html#compressed" ovf:populatedSize="1924967692"/>
2578 </DiskSection> */
2579 xml::ElementNode *pelmDiskSection = pelmRoot->createChild("DiskSection");
2580 xml::ElementNode *pelmDiskSectionInfo = pelmDiskSection->createChild("Info");
2581 pelmDiskSectionInfo->addContent("List of the virtual disks used in the package");
2582 // for now, set up a map so we have a list of unique disk names (to make
2583 // sure the same disk name is only added once)
2584 map<Utf8Str, const VirtualSystemDescriptionEntry*> mapDisks;
2585
2586 /* <Envelope>/<NetworkSection>:
2587 <NetworkSection>
2588 <Info>Logical networks used in the package</Info>
2589 <Network ovf:name="VM Network">
2590 <Description>The network that the LAMP Service will be available on</Description>
2591 </Network>
2592 </NetworkSection> */
2593 xml::ElementNode *pelmNetworkSection = pelmRoot->createChild("NetworkSection");
2594 xml::ElementNode *pelmNetworkSectionInfo = pelmNetworkSection->createChild("Info");
2595 pelmNetworkSectionInfo->addContent("Logical networks used in the package");
2596 // for now, set up a map so we have a list of unique network names (to make
2597 // sure the same network name is only added once)
2598 map<Utf8Str, bool> mapNetworks;
2599 // we fill this later below when we iterate over the networks
2600
2601 // and here come the virtual systems:
2602 xml::ElementNode *pelmVirtualSystemCollection = pelmRoot->createChild("VirtualSystemCollection");
2603 /* xml::AttributeNode *pattrVirtualSystemCollectionId = */ pelmVirtualSystemCollection->setAttribute("ovf:id", "ExportedVirtualBoxMachines"); // whatever
2604
2605 list< ComObjPtr<VirtualSystemDescription> >::const_iterator it;
2606 /* Iterate through all virtual systems of that appliance */
2607 for (it = pAppliance->m->virtualSystemDescriptions.begin();
2608 it != pAppliance->m->virtualSystemDescriptions.end();
2609 ++it)
2610 {
2611 ComObjPtr<VirtualSystemDescription> vsdescThis = (*it);
2612
2613 xml::ElementNode *pelmVirtualSystem = pelmVirtualSystemCollection->createChild("VirtualSystem");
2614
2615 /*xml::ElementNode *pelmVirtualSystemInfo =*/ pelmVirtualSystem->createChild("Info")->addContent("A virtual machine");
2616
2617 std::list<VirtualSystemDescriptionEntry*> llName = vsdescThis->findByType(VirtualSystemDescriptionType_Name);
2618 if (llName.size() != 1)
2619 throw setError(VBOX_E_NOT_SUPPORTED,
2620 tr("Missing VM name"));
2621 pelmVirtualSystem->setAttribute("ovf:id", llName.front()->strVbox);
2622
2623 // product info
2624 std::list<VirtualSystemDescriptionEntry*> llProduct = vsdescThis->findByType(VirtualSystemDescriptionType_Product);
2625 std::list<VirtualSystemDescriptionEntry*> llProductUrl = vsdescThis->findByType(VirtualSystemDescriptionType_ProductUrl);
2626 std::list<VirtualSystemDescriptionEntry*> llVendor = vsdescThis->findByType(VirtualSystemDescriptionType_Vendor);
2627 std::list<VirtualSystemDescriptionEntry*> llVendorUrl = vsdescThis->findByType(VirtualSystemDescriptionType_VendorUrl);
2628 std::list<VirtualSystemDescriptionEntry*> llVersion = vsdescThis->findByType(VirtualSystemDescriptionType_Version);
2629 bool fProduct = llProduct.size() && !llProduct.front()->strVbox.isEmpty();
2630 bool fProductUrl = llProductUrl.size() && !llProductUrl.front()->strVbox.isEmpty();
2631 bool fVendor = llVendor.size() && !llVendor.front()->strVbox.isEmpty();
2632 bool fVendorUrl = llVendorUrl.size() && !llVendorUrl.front()->strVbox.isEmpty();
2633 bool fVersion = llVersion.size() && !llVersion.front()->strVbox.isEmpty();
2634 if (fProduct ||
2635 fProductUrl ||
2636 fVersion ||
2637 fVendorUrl ||
2638 fVersion)
2639 {
2640 /* <Section ovf:required="false" xsi:type="ovf:ProductSection_Type">
2641 <Info>Meta-information about the installed software</Info>
2642 <Product>VAtest</Product>
2643 <Vendor>SUN Microsystems</Vendor>
2644 <Version>10.0</Version>
2645 <ProductUrl>http://blogs.sun.com/VirtualGuru</ProductUrl>
2646 <VendorUrl>http://www.sun.com</VendorUrl>
2647 </Section> */
2648 xml::ElementNode *pelmAnnotationSection = pelmVirtualSystem->createChild("ProductSection");
2649 pelmAnnotationSection->createChild("Info")->addContent("Meta-information about the installed software");
2650 if (fProduct)
2651 pelmAnnotationSection->createChild("Product")->addContent(llProduct.front()->strVbox);
2652 if (fVendor)
2653 pelmAnnotationSection->createChild("Vendor")->addContent(llVendor.front()->strVbox);
2654 if (fVersion)
2655 pelmAnnotationSection->createChild("Version")->addContent(llVersion.front()->strVbox);
2656 if (fProductUrl)
2657 pelmAnnotationSection->createChild("ProductUrl")->addContent(llProductUrl.front()->strVbox);
2658 if (fVendorUrl)
2659 pelmAnnotationSection->createChild("VendorUrl")->addContent(llVendorUrl.front()->strVbox);
2660 }
2661
2662 // description
2663 std::list<VirtualSystemDescriptionEntry*> llDescription = vsdescThis->findByType(VirtualSystemDescriptionType_Description);
2664 if (llDescription.size() &&
2665 !llDescription.front()->strVbox.isEmpty())
2666 {
2667 /* <Section ovf:required="false" xsi:type="ovf:AnnotationSection_Type">
2668 <Info>A human-readable annotation</Info>
2669 <Annotation>Plan 9</Annotation>
2670 </Section> */
2671 xml::ElementNode *pelmAnnotationSection = pelmVirtualSystem->createChild("AnnotationSection");
2672 pelmAnnotationSection->createChild("Info")->addContent("A human-readable annotation");
2673 pelmAnnotationSection->createChild("Annotation")->addContent(llDescription.front()->strVbox);
2674 }
2675
2676 // license
2677 std::list<VirtualSystemDescriptionEntry*> llLicense = vsdescThis->findByType(VirtualSystemDescriptionType_License);
2678 if (llLicense.size() &&
2679 !llLicense.front()->strVbox.isEmpty())
2680 {
2681 /* <EulaSection>
2682 <Info ovf:msgid="6">License agreement for the Virtual System.</Info>
2683 <License ovf:msgid="1">License terms can go in here.</License>
2684 </EulaSection> */
2685 xml::ElementNode *pelmAnnotationSection = pelmVirtualSystem->createChild("EulaSection");
2686 pelmAnnotationSection->createChild("Info")->addContent("License agreement for the Virtual System.");
2687 pelmAnnotationSection->createChild("License")->addContent(llLicense.front()->strVbox);
2688 }
2689
2690 // operating system
2691 std::list<VirtualSystemDescriptionEntry*> llOS = vsdescThis->findByType(VirtualSystemDescriptionType_OS);
2692 if (llOS.size() != 1)
2693 throw setError(VBOX_E_NOT_SUPPORTED,
2694 tr("Missing OS type"));
2695 /* <OperatingSystemSection ovf:id="82">
2696 <Info>Guest Operating System</Info>
2697 <Description>Linux 2.6.x</Description>
2698 </OperatingSystemSection> */
2699 xml::ElementNode *pelmOperatingSystemSection = pelmVirtualSystem->createChild("OperatingSystemSection");
2700 pelmOperatingSystemSection->setAttribute("ovf:id", llOS.front()->strOvf);
2701// pelmOperatingSystemSection->createChild("Info")->addContent("blah"); // @todo
2702// pelmOperatingSystemSection->createChild("Description")->addContent("blah"); // @todo
2703
2704 // <VirtualHardwareSection ovf:id="hw1" ovf:transport="iso">
2705 xml::ElementNode *pelmVirtualHardwareSection = pelmVirtualSystem->createChild("VirtualHardwareSection");
2706
2707 /* <System>
2708 <vssd:Description>Description of the virtual hardware section.</vssd:Description>
2709 <vssd:ElementName>vmware</vssd:ElementName>
2710 <vssd:InstanceID>1</vssd:InstanceID>
2711 <vssd:VirtualSystemIdentifier>MyLampService</vssd:VirtualSystemIdentifier>
2712 <vssd:VirtualSystemType>vmx-4</vssd:VirtualSystemType>
2713 </System> */
2714 xml::ElementNode *pelmSystem = pelmVirtualHardwareSection->createChild("System");
2715
2716 // <vssd:VirtualSystemType>vmx-4</vssd:VirtualSystemType>
2717 xml::ElementNode *pelmVirtualSystemType = pelmSystem->createChild("VirtualSystemType");
2718 pelmVirtualSystemType->addContent("virtualbox-2.2"); // instead of vmx-7?
2719
2720 // loop thru all description entries twice; once to write out all
2721 // devices _except_ disk images, and a second time to assign the
2722 // disk images; this is because disk images need to reference
2723 // IDE controllers, and we can't know their instance IDs without
2724 // assigning them first
2725
2726 uint32_t idIDEController = 0;
2727 int32_t lIDEControllerIndex = 0;
2728 uint32_t idSATAController = 0;
2729 int32_t lSATAControllerIndex = 0;
2730 uint32_t idSCSIController = 0;
2731 int32_t lSCSIControllerIndex = 0;
2732
2733 uint32_t ulInstanceID = 1;
2734 uint32_t cDisks = 0;
2735
2736 for (size_t uLoop = 1;
2737 uLoop <= 2;
2738 ++uLoop)
2739 {
2740 int32_t lIndexThis = 0;
2741 list<VirtualSystemDescriptionEntry>::const_iterator itD;
2742 for (itD = vsdescThis->m->llDescriptions.begin();
2743 itD != vsdescThis->m->llDescriptions.end();
2744 ++itD, ++lIndexThis)
2745 {
2746 const VirtualSystemDescriptionEntry &desc = *itD;
2747
2748 OVFResourceType_T type = (OVFResourceType_T)0; // if this becomes != 0 then we do stuff
2749 Utf8Str strResourceSubType;
2750
2751 Utf8Str strDescription; // results in <rasd:Description>...</rasd:Description> block
2752 Utf8Str strCaption; // results in <rasd:Caption>...</rasd:Caption> block
2753
2754 uint32_t ulParent = 0;
2755
2756 int32_t lVirtualQuantity = -1;
2757 Utf8Str strAllocationUnits;
2758
2759 int32_t lAddress = -1;
2760 int32_t lBusNumber = -1;
2761 int32_t lAddressOnParent = -1;
2762
2763 int32_t lAutomaticAllocation = -1; // 0 means "false", 1 means "true"
2764 Utf8Str strConnection; // results in <rasd:Connection>...</rasd:Connection> block
2765 Utf8Str strHostResource;
2766
2767 uint64_t uTemp;
2768
2769 switch (desc.type)
2770 {
2771 case VirtualSystemDescriptionType_CPU:
2772 /* <Item>
2773 <rasd:Caption>1 virtual CPU</rasd:Caption>
2774 <rasd:Description>Number of virtual CPUs</rasd:Description>
2775 <rasd:ElementName>virtual CPU</rasd:ElementName>
2776 <rasd:InstanceID>1</rasd:InstanceID>
2777 <rasd:ResourceType>3</rasd:ResourceType>
2778 <rasd:VirtualQuantity>1</rasd:VirtualQuantity>
2779 </Item> */
2780 if (uLoop == 1)
2781 {
2782 strDescription = "Number of virtual CPUs";
2783 type = OVFResourceType_Processor; // 3
2784 lVirtualQuantity = 1;
2785 }
2786 break;
2787
2788 case VirtualSystemDescriptionType_Memory:
2789 /* <Item>
2790 <rasd:AllocationUnits>MegaBytes</rasd:AllocationUnits>
2791 <rasd:Caption>256 MB of memory</rasd:Caption>
2792 <rasd:Description>Memory Size</rasd:Description>
2793 <rasd:ElementName>Memory</rasd:ElementName>
2794 <rasd:InstanceID>2</rasd:InstanceID>
2795 <rasd:ResourceType>4</rasd:ResourceType>
2796 <rasd:VirtualQuantity>256</rasd:VirtualQuantity>
2797 </Item> */
2798 if (uLoop == 1)
2799 {
2800 strDescription = "Memory Size";
2801 type = OVFResourceType_Memory; // 4
2802 desc.strVbox.toInt(uTemp);
2803 lVirtualQuantity = (int32_t)(uTemp / _1M);
2804 strAllocationUnits = "MegaBytes";
2805 }
2806 break;
2807
2808 case VirtualSystemDescriptionType_HardDiskControllerIDE:
2809 /* <Item>
2810 <rasd:Caption>ideController1</rasd:Caption>
2811 <rasd:Description>IDE Controller</rasd:Description>
2812 <rasd:InstanceId>5</rasd:InstanceId>
2813 <rasd:ResourceType>5</rasd:ResourceType>
2814 <rasd:Address>1</rasd:Address>
2815 <rasd:BusNumber>1</rasd:BusNumber>
2816 </Item> */
2817 if (uLoop == 1)
2818 {
2819 strDescription = "IDE Controller";
2820 type = OVFResourceType_IDEController; // 5
2821 strResourceSubType = desc.strVbox;
2822 // it seems that OVFTool always writes these two, and since we can only
2823 // have one IDE controller, we'll use this as well
2824 lAddress = 1;
2825 lBusNumber = 1;
2826
2827 // remember this ID
2828 idIDEController = ulInstanceID;
2829 lIDEControllerIndex = lIndexThis;
2830 }
2831 break;
2832
2833 case VirtualSystemDescriptionType_HardDiskControllerSATA:
2834 /* <Item>
2835 <rasd:Caption>sataController0</rasd:Caption>
2836 <rasd:Description>SATA Controller</rasd:Description>
2837 <rasd:InstanceId>4</rasd:InstanceId>
2838 <rasd:ResourceType>20</rasd:ResourceType>
2839 <rasd:ResourceSubType>ahci</rasd:ResourceSubType>
2840 <rasd:Address>0</rasd:Address>
2841 <rasd:BusNumber>0</rasd:BusNumber>
2842 </Item>
2843 */
2844 if (uLoop == 1)
2845 {
2846 strDescription = "SATA Controller";
2847 strCaption = "sataController0";
2848 type = OVFResourceType_OtherStorageDevice; // 20
2849 // it seems that OVFTool always writes these two, and since we can only
2850 // have one SATA controller, we'll use this as well
2851 lAddress = 0;
2852 lBusNumber = 0;
2853
2854 if ( desc.strVbox.isEmpty() // AHCI is the default in VirtualBox
2855 || (!desc.strVbox.compare("ahci", Utf8Str::CaseInsensitive))
2856 )
2857 strResourceSubType = "AHCI";
2858 else
2859 throw setError(VBOX_E_NOT_SUPPORTED,
2860 tr("Invalid config string \"%s\" in SATA controller"), desc.strVbox.c_str());
2861
2862 // remember this ID
2863 idSATAController = ulInstanceID;
2864 lSATAControllerIndex = lIndexThis;
2865 }
2866 break;
2867
2868 case VirtualSystemDescriptionType_HardDiskControllerSCSI:
2869 /* <Item>
2870 <rasd:Caption>scsiController0</rasd:Caption>
2871 <rasd:Description>SCSI Controller</rasd:Description>
2872 <rasd:InstanceId>4</rasd:InstanceId>
2873 <rasd:ResourceType>6</rasd:ResourceType>
2874 <rasd:ResourceSubType>buslogic</rasd:ResourceSubType>
2875 <rasd:Address>0</rasd:Address>
2876 <rasd:BusNumber>0</rasd:BusNumber>
2877 </Item>
2878 */
2879 if (uLoop == 1)
2880 {
2881 strDescription = "SCSI Controller";
2882 strCaption = "scsiController0";
2883 type = OVFResourceType_ParallelSCSIHBA; // 6
2884 // it seems that OVFTool always writes these two, and since we can only
2885 // have one SATA controller, we'll use this as well
2886 lAddress = 0;
2887 lBusNumber = 0;
2888
2889 if ( desc.strVbox.isEmpty() // LsiLogic is the default in VirtualBox
2890 || (!desc.strVbox.compare("lsilogic", Utf8Str::CaseInsensitive))
2891 )
2892 strResourceSubType = "lsilogic";
2893 else if (!desc.strVbox.compare("buslogic", Utf8Str::CaseInsensitive))
2894 strResourceSubType = "buslogic";
2895 else
2896 throw setError(VBOX_E_NOT_SUPPORTED,
2897 tr("Invalid config string \"%s\" in SCSI controller"), desc.strVbox.c_str());
2898
2899 // remember this ID
2900 idSCSIController = ulInstanceID;
2901 lSCSIControllerIndex = lIndexThis;
2902 }
2903 break;
2904
2905 case VirtualSystemDescriptionType_HardDiskImage:
2906 /* <Item>
2907 <rasd:Caption>disk1</rasd:Caption>
2908 <rasd:InstanceId>8</rasd:InstanceId>
2909 <rasd:ResourceType>17</rasd:ResourceType>
2910 <rasd:HostResource>/disk/vmdisk1</rasd:HostResource>
2911 <rasd:Parent>4</rasd:Parent>
2912 <rasd:AddressOnParent>0</rasd:AddressOnParent>
2913 </Item> */
2914 if (uLoop == 2)
2915 {
2916 Utf8Str strDiskID = Utf8StrFmt("vmdisk%RI32", ++cDisks);
2917
2918 strDescription = "Disk Image";
2919 strCaption = Utf8StrFmt("disk%RI32", cDisks); // this is not used for anything else
2920 type = OVFResourceType_HardDisk; // 17
2921
2922 // the following references the "<Disks>" XML block
2923 strHostResource = Utf8StrFmt("/disk/%s", strDiskID.c_str());
2924
2925 // controller=<index>;channel=<c>
2926 size_t pos1 = desc.strExtraConfig.find("controller=");
2927 size_t pos2 = desc.strExtraConfig.find("channel=");
2928 if (pos1 != Utf8Str::npos)
2929 {
2930 int32_t lControllerIndex = -1;
2931 RTStrToInt32Ex(desc.strExtraConfig.c_str() + pos1 + 11, NULL, 0, &lControllerIndex);
2932 if (lControllerIndex == lIDEControllerIndex)
2933 ulParent = idIDEController;
2934 else if (lControllerIndex == lSCSIControllerIndex)
2935 ulParent = idSCSIController;
2936 else if (lControllerIndex == lSATAControllerIndex)
2937 ulParent = idSATAController;
2938 }
2939 if (pos2 != Utf8Str::npos)
2940 RTStrToInt32Ex(desc.strExtraConfig.c_str() + pos2 + 8, NULL, 0, &lAddressOnParent);
2941
2942 if ( !ulParent
2943 || lAddressOnParent == -1
2944 )
2945 throw setError(VBOX_E_NOT_SUPPORTED,
2946 tr("Missing or bad extra config string in hard disk image: \"%s\""), desc.strExtraConfig.c_str());
2947
2948 mapDisks[strDiskID] = &desc;
2949 }
2950 break;
2951
2952 case VirtualSystemDescriptionType_Floppy:
2953 if (uLoop == 1)
2954 {
2955 strDescription = "Floppy Drive";
2956 strCaption = "floppy0"; // this is what OVFTool writes
2957 type = OVFResourceType_FloppyDrive; // 14
2958 lAutomaticAllocation = 0;
2959 lAddressOnParent = 0; // this is what OVFTool writes
2960 }
2961 break;
2962
2963 case VirtualSystemDescriptionType_CDROM:
2964 if (uLoop == 2)
2965 {
2966 // we can't have a CD without an IDE controller
2967 if (!idIDEController)
2968 throw setError(VBOX_E_NOT_SUPPORTED,
2969 tr("Can't have CD-ROM without IDE controller"));
2970
2971 strDescription = "CD-ROM Drive";
2972 strCaption = "cdrom1"; // this is what OVFTool writes
2973 type = OVFResourceType_CDDrive; // 15
2974 lAutomaticAllocation = 1;
2975 ulParent = idIDEController;
2976 lAddressOnParent = 0; // this is what OVFTool writes
2977 }
2978 break;
2979
2980 case VirtualSystemDescriptionType_NetworkAdapter:
2981 /* <Item>
2982 <rasd:AutomaticAllocation>true</rasd:AutomaticAllocation>
2983 <rasd:Caption>Ethernet adapter on 'VM Network'</rasd:Caption>
2984 <rasd:Connection>VM Network</rasd:Connection>
2985 <rasd:ElementName>VM network</rasd:ElementName>
2986 <rasd:InstanceID>3</rasd:InstanceID>
2987 <rasd:ResourceType>10</rasd:ResourceType>
2988 </Item> */
2989 if (uLoop == 1)
2990 {
2991 lAutomaticAllocation = 1;
2992 strCaption = Utf8StrFmt("Ethernet adapter on '%s'", desc.strOvf.c_str());
2993 type = OVFResourceType_EthernetAdapter; // 10
2994 /* Set the hardware type to something useful.
2995 * To be compatible with vmware & others we set
2996 * PCNet32 for our PCNet types & E1000 for the
2997 * E1000 cards. */
2998 switch (desc.strVbox.toInt32())
2999 {
3000 case NetworkAdapterType_Am79C970A:
3001 case NetworkAdapterType_Am79C973: strResourceSubType = "PCNet32"; break;
3002#ifdef VBOX_WITH_E1000
3003 case NetworkAdapterType_I82540EM:
3004 case NetworkAdapterType_I82545EM:
3005 case NetworkAdapterType_I82543GC: strResourceSubType = "E1000"; break;
3006#endif /* VBOX_WITH_E1000 */
3007 }
3008 strConnection = desc.strOvf;
3009
3010 mapNetworks[desc.strOvf] = true;
3011 }
3012 break;
3013
3014 case VirtualSystemDescriptionType_USBController:
3015 /* <Item ovf:required="false">
3016 <rasd:Caption>usb</rasd:Caption>
3017 <rasd:Description>USB Controller</rasd:Description>
3018 <rasd:InstanceId>3</rasd:InstanceId>
3019 <rasd:ResourceType>23</rasd:ResourceType>
3020 <rasd:Address>0</rasd:Address>
3021 <rasd:BusNumber>0</rasd:BusNumber>
3022 </Item> */
3023 if (uLoop == 1)
3024 {
3025 strDescription = "USB Controller";
3026 strCaption = "usb";
3027 type = OVFResourceType_USBController; // 23
3028 lAddress = 0; // this is what OVFTool writes
3029 lBusNumber = 0; // this is what OVFTool writes
3030 }
3031 break;
3032
3033 case VirtualSystemDescriptionType_SoundCard:
3034 /* <Item ovf:required="false">
3035 <rasd:Caption>sound</rasd:Caption>
3036 <rasd:Description>Sound Card</rasd:Description>
3037 <rasd:InstanceId>10</rasd:InstanceId>
3038 <rasd:ResourceType>35</rasd:ResourceType>
3039 <rasd:ResourceSubType>ensoniq1371</rasd:ResourceSubType>
3040 <rasd:AutomaticAllocation>false</rasd:AutomaticAllocation>
3041 <rasd:AddressOnParent>3</rasd:AddressOnParent>
3042 </Item> */
3043 if (uLoop == 1)
3044 {
3045 strDescription = "Sound Card";
3046 strCaption = "sound";
3047 type = OVFResourceType_SoundCard; // 35
3048 strResourceSubType = desc.strOvf; // e.g. ensoniq1371
3049 lAutomaticAllocation = 0;
3050 lAddressOnParent = 3; // what gives? this is what OVFTool writes
3051 }
3052 break;
3053 }
3054
3055 if (type)
3056 {
3057 xml::ElementNode *pItem;
3058
3059 pItem = pelmVirtualHardwareSection->createChild("Item");
3060
3061 if (!strDescription.isEmpty())
3062 pItem->createChild("rasd:Description")->addContent(strDescription);
3063 if (!strCaption.isEmpty())
3064 pItem->createChild("rasd:Caption")->addContent(strCaption);
3065
3066 if (!strAllocationUnits.isEmpty())
3067 pItem->createChild("rasd:AllocationUnits")->addContent(strAllocationUnits);
3068
3069 if (lAutomaticAllocation != -1)
3070 pItem->createChild("rasd:AutomaticAllocation")->addContent( (lAutomaticAllocation) ? "true" : "false" );
3071
3072 if (!strConnection.isEmpty())
3073 pItem->createChild("rasd:Connection")->addContent(strConnection);
3074
3075 // <rasd:InstanceID>1</rasd:InstanceID>
3076 pItem->createChild("rasd:InstanceID")->addContent(Utf8StrFmt("%d", ulInstanceID));
3077 ++ulInstanceID;
3078
3079 // <rasd:ResourceType>3</rasd:ResourceType>
3080 pItem->createChild("rasd:ResourceType")->addContent(Utf8StrFmt("%d", type));
3081 if (!strResourceSubType.isEmpty())
3082 pItem->createChild("rasd:ResourceSubType")->addContent(strResourceSubType);
3083
3084 // <rasd:VirtualQuantity>1</rasd:VirtualQuantity>
3085 if (lVirtualQuantity != -1)
3086 pItem->createChild("rasd:VirtualQuantity")->addContent(Utf8StrFmt("%d", lVirtualQuantity));
3087
3088 if (lAddress != -1)
3089 pItem->createChild("rasd:Address")->addContent(Utf8StrFmt("%d", lAddress));
3090
3091 if (lBusNumber != -1)
3092 pItem->createChild("rasd:BusNumber")->addContent(Utf8StrFmt("%d", lBusNumber));
3093
3094 if (ulParent)
3095 pItem->createChild("rasd:Parent")->addContent(Utf8StrFmt("%d", ulParent));
3096 if (lAddressOnParent != -1)
3097 pItem->createChild("rasd:AddressOnParent")->addContent(Utf8StrFmt("%d", lAddressOnParent));
3098
3099 if (!strHostResource.isEmpty())
3100 pItem->createChild("rasd:HostResource")->addContent(strHostResource);
3101 }
3102 }
3103 } // for (size_t uLoop = 0; ...
3104 }
3105
3106 // finally, fill in the network section we set up empty above according
3107 // to the networks we found with the hardware items
3108 map<Utf8Str, bool>::const_iterator itN;
3109 for (itN = mapNetworks.begin();
3110 itN != mapNetworks.end();
3111 ++itN)
3112 {
3113 const Utf8Str &strNetwork = itN->first;
3114 xml::ElementNode *pelmNetwork = pelmNetworkSection->createChild("Network");
3115 pelmNetwork->setAttribute("ovf:name", strNetwork.c_str());
3116 pelmNetwork->createChild("Description")->addContent("Logical network used by this appliance.");
3117 }
3118
3119 map<Utf8Str, const VirtualSystemDescriptionEntry*>::const_iterator itS;
3120 uint32_t ulFile = 1;
3121 for (itS = mapDisks.begin();
3122 itS != mapDisks.end();
3123 ++itS)
3124 {
3125 const Utf8Str &strDiskID = itS->first;
3126 const VirtualSystemDescriptionEntry *pDiskEntry = itS->second;
3127
3128 // source path: where the VBox image is
3129 const Utf8Str &strSrcFilePath = pDiskEntry->strVbox;
3130 Bstr bstrSrcFilePath(strSrcFilePath);
3131 if (!RTPathExists(strSrcFilePath.c_str()))
3132 /* This isn't allowed */
3133 throw setError(VBOX_E_FILE_ERROR,
3134 tr("Source virtual disk image file '%s' doesn't exist"),
3135 strSrcFilePath.c_str());
3136
3137 // output filename
3138 const Utf8Str &strTargetFileNameOnly = pDiskEntry->strOvf;
3139 // target path needs to be composed from where the output OVF is
3140 Utf8Str strTargetFilePath = stripFilename(pAppliance->m->strPath);
3141 strTargetFilePath.append("/");
3142 strTargetFilePath.append(strTargetFileNameOnly);
3143
3144 // clone the disk:
3145 ComPtr<IHardDisk> pSourceDisk;
3146 ComPtr<IHardDisk> pTargetDisk;
3147 ComPtr<IProgress> pProgress2;
3148
3149 Log(("Finding source disk \"%ls\"\n", bstrSrcFilePath.raw()));
3150 rc = pVirtualBox->FindHardDisk(bstrSrcFilePath, pSourceDisk.asOutParam());
3151 if (FAILED(rc)) throw rc;
3152
3153 /* We are always exporting to vmdfk stream optimized for now */
3154 Bstr bstrSrcFormat = L"VMDK";
3155
3156 // create a new hard disk interface for the destination disk image
3157 Log(("Creating target disk \"%s\"\n", strTargetFilePath.raw()));
3158 rc = pVirtualBox->CreateHardDisk(bstrSrcFormat, Bstr(strTargetFilePath), pTargetDisk.asOutParam());
3159 if (FAILED(rc)) throw rc;
3160
3161 // the target disk is now registered and needs to be removed again,
3162 // both after successful cloning or if anything goes bad!
3163 try
3164 {
3165 // create a flat copy of the source disk image
3166 rc = pSourceDisk->CloneTo(pTargetDisk, HardDiskVariant_VmdkStreamOptimized, NULL, pProgress2.asOutParam());
3167 if (FAILED(rc)) throw rc;
3168
3169 // advance to the next operation
3170 if (!task->progress.isNull())
3171 task->progress->setNextOperation(BstrFmt(tr("Exporting virtual disk image '%s'"), strSrcFilePath.c_str()),
3172 pDiskEntry->ulSizeMB); // operation's weight, as set up with the IProgress originally);
3173
3174 // now wait for the background disk operation to complete; this throws HRESULTs on error
3175 pAppliance->waitForAsyncProgress(task->progress, pProgress2);
3176 }
3177 catch (HRESULT rc3)
3178 {
3179 // upon error after registering, close the disk or
3180 // it'll stick in the registry forever
3181 pTargetDisk->Close();
3182 throw rc3;
3183 }
3184
3185 // we need the following for the XML
3186 uint64_t cbFile = 0; // actual file size
3187 rc = pTargetDisk->COMGETTER(Size)(&cbFile);
3188 if (FAILED(rc)) throw rc;
3189
3190 ULONG64 cbCapacity = 0; // size reported to guest
3191 rc = pTargetDisk->COMGETTER(LogicalSize)(&cbCapacity);
3192 if (FAILED(rc)) throw rc;
3193 // capacity is reported in megabytes, so...
3194 cbCapacity *= _1M;
3195
3196 // upon success, close the disk as well
3197 rc = pTargetDisk->Close();
3198 if (FAILED(rc)) throw rc;
3199
3200 // now handle the XML for the disk:
3201 Utf8StrFmt strFileRef("file%RI32", ulFile++);
3202 // <File ovf:href="WindowsXpProfessional-disk1.vmdk" ovf:id="file1" ovf:size="1710381056"/>
3203 xml::ElementNode *pelmFile = pelmReferences->createChild("File");
3204 pelmFile->setAttribute("ovf:href", strTargetFileNameOnly);
3205 pelmFile->setAttribute("ovf:id", strFileRef);
3206 pelmFile->setAttribute("ovf:size", Utf8StrFmt("%RI64", cbFile).c_str());
3207
3208 // add disk to XML Disks section
3209 // <Disk ovf:capacity="8589934592" ovf:diskId="vmdisk1" ovf:fileRef="file1" ovf:format="http://www.vmware.com/specifications/vmdk.html#sparse"/>
3210 xml::ElementNode *pelmDisk = pelmDiskSection->createChild("Disk");
3211 pelmDisk->setAttribute("ovf:capacity", Utf8StrFmt("%RI64", cbCapacity).c_str());
3212 pelmDisk->setAttribute("ovf:diskId", strDiskID);
3213 pelmDisk->setAttribute("ovf:fileRef", strFileRef);
3214 pelmDisk->setAttribute("ovf:format", "http://www.vmware.com/specifications/vmdk.html#compressed");
3215 }
3216
3217 // now go write the XML
3218 xml::XmlFileWriter writer(doc);
3219 writer.write(pAppliance->m->strPath.c_str());
3220 }
3221 catch(xml::Error &x)
3222 {
3223 rc = setError(VBOX_E_FILE_ERROR,
3224 x.what());
3225 }
3226 catch(HRESULT aRC)
3227 {
3228 rc = aRC;
3229 }
3230
3231 task->rc = rc;
3232
3233 if (!task->progress.isNull())
3234 task->progress->notifyComplete(rc);
3235
3236 LogFlowFunc(("rc=%Rhrc\n", rc));
3237 LogFlowFuncLeave();
3238
3239 return VINF_SUCCESS;
3240}
3241
3242/**
3243* Public method implementation.
3244 * @return
3245 */
3246STDMETHODIMP Appliance::GetWarnings(ComSafeArrayOut(BSTR, aWarnings))
3247{
3248 if (ComSafeArrayOutIsNull(aWarnings))
3249 return E_POINTER;
3250
3251 AutoCaller autoCaller(this);
3252 CheckComRCReturnRC(autoCaller.rc());
3253
3254 AutoReadLock alock(this);
3255
3256 com::SafeArray<BSTR> sfaWarnings(m->llWarnings.size());
3257
3258 list<Utf8Str>::const_iterator it;
3259 size_t i = 0;
3260 for (it = m->llWarnings.begin();
3261 it != m->llWarnings.end();
3262 ++it, ++i)
3263 {
3264 Bstr bstr = *it;
3265 bstr.cloneTo(&sfaWarnings[i]);
3266 }
3267
3268 sfaWarnings.detachTo(ComSafeArrayOutArg(aWarnings));
3269
3270 return S_OK;
3271}
3272
3273HRESULT Appliance::searchUniqueVMName(Utf8Str& aName) const
3274{
3275 IMachine *machine = NULL;
3276 char *tmpName = RTStrDup(aName.c_str());
3277 int i = 1;
3278 /* @todo: Maybe too cost-intensive; try to find a lighter way */
3279 while (mVirtualBox->FindMachine(Bstr(tmpName), &machine) != VBOX_E_OBJECT_NOT_FOUND)
3280 {
3281 RTStrFree(tmpName);
3282 RTStrAPrintf(&tmpName, "%s_%d", aName.c_str(), i);
3283 ++i;
3284 }
3285 aName = tmpName;
3286 RTStrFree(tmpName);
3287
3288 return S_OK;
3289}
3290
3291HRESULT Appliance::searchUniqueDiskImageFilePath(Utf8Str& aName) const
3292{
3293 IHardDisk *harddisk = NULL;
3294 char *tmpName = RTStrDup(aName.c_str());
3295 int i = 1;
3296 /* Check if the file exists or if a file with this path is registered
3297 * already */
3298 /* @todo: Maybe too cost-intensive; try to find a lighter way */
3299 while (RTPathExists(tmpName) ||
3300 mVirtualBox->FindHardDisk(Bstr(tmpName), &harddisk) != VBOX_E_OBJECT_NOT_FOUND)
3301 {
3302 RTStrFree(tmpName);
3303 char *tmpDir = RTStrDup(aName.c_str());
3304 RTPathStripFilename(tmpDir);;
3305 char *tmpFile = RTStrDup(RTPathFilename(aName.c_str()));
3306 RTPathStripExt(tmpFile);
3307 const char *tmpExt = RTPathExt(aName.c_str());
3308 RTStrAPrintf(&tmpName, "%s%c%s_%d%s", tmpDir, RTPATH_DELIMITER, tmpFile, i, tmpExt);
3309 RTStrFree(tmpFile);
3310 RTStrFree(tmpDir);
3311 ++i;
3312 }
3313 aName = tmpName;
3314 RTStrFree(tmpName);
3315
3316 return S_OK;
3317}
3318
3319/**
3320 * Sets up the given progress object so that it represents disk images accurately
3321 * during importMachines() and write().
3322 * @param pProgress
3323 * @param bstrDescription
3324 * @return
3325 */
3326HRESULT Appliance::setUpProgress(ComObjPtr<Progress> &pProgress, const Bstr &bstrDescription)
3327{
3328 HRESULT rc;
3329
3330 /* Create the progress object */
3331 pProgress.createObject();
3332
3333 // weigh the disk images according to their sizes
3334 uint32_t ulTotalMB = 0;
3335 uint32_t cDisks = 0;
3336 list< ComObjPtr<VirtualSystemDescription> >::const_iterator it;
3337 for (it = m->virtualSystemDescriptions.begin();
3338 it != m->virtualSystemDescriptions.end();
3339 ++it)
3340 {
3341 ComObjPtr<VirtualSystemDescription> vsdescThis = (*it);
3342 /* One for every hard disk of the Virtual System */
3343 std::list<VirtualSystemDescriptionEntry*> avsdeHDs = vsdescThis->findByType(VirtualSystemDescriptionType_HardDiskImage);
3344 std::list<VirtualSystemDescriptionEntry*>::const_iterator itH;
3345 for (itH = avsdeHDs.begin();
3346 itH != avsdeHDs.end();
3347 ++itH)
3348 {
3349 const VirtualSystemDescriptionEntry *pHD = *itH;
3350 ulTotalMB += pHD->ulSizeMB;
3351 ++cDisks;
3352 }
3353 }
3354
3355 ULONG cOperations = 1 + cDisks; // one op per disk plus 1 for the XML
3356
3357 ULONG ulTotalOperationsWeight;
3358 if (ulTotalMB)
3359 {
3360 m->ulWeightPerOperation = (ULONG)((double)ulTotalMB * 1 / 100); // use 1% of the progress for the XML
3361 ulTotalOperationsWeight = ulTotalMB + m->ulWeightPerOperation;
3362 }
3363 else
3364 {
3365 // no disks to export:
3366 ulTotalOperationsWeight = 1;
3367 m->ulWeightPerOperation = 1;
3368 }
3369
3370 Log(("Setting up progress object: ulTotalMB = %d, cDisks = %d, => cOperations = %d, ulTotalOperationsWeight = %d, m->ulWeightPerOperation = %d\n",
3371 ulTotalMB, cDisks, cOperations, ulTotalOperationsWeight, m->ulWeightPerOperation));
3372
3373 rc = pProgress->init(mVirtualBox, static_cast<IAppliance*>(this),
3374 bstrDescription,
3375 TRUE /* aCancelable */,
3376 cOperations, // ULONG cOperations,
3377 ulTotalOperationsWeight, // ULONG ulTotalOperationsWeight,
3378 bstrDescription, // CBSTR bstrFirstOperationDescription,
3379 m->ulWeightPerOperation); // ULONG ulFirstOperationWeight,
3380 return rc;
3381}
3382
3383/**
3384 * Called from the import and export background threads to synchronize the second
3385 * background disk thread's progress object with the current progress object so
3386 * that the user interface sees progress correctly and that cancel signals are
3387 * passed on to the second thread.
3388 * @param pProgressThis Progress object of the current thread.
3389 * @param pProgressAsync Progress object of asynchronous task running in background.
3390 */
3391void Appliance::waitForAsyncProgress(ComObjPtr<Progress> &pProgressThis,
3392 ComPtr<IProgress> &pProgressAsync)
3393{
3394 HRESULT rc;
3395
3396 // now loop until the asynchronous operation completes and then report its result
3397 BOOL fCompleted;
3398 BOOL fCanceled;
3399 ULONG currentPercent;
3400 while (SUCCEEDED(pProgressAsync->COMGETTER(Completed(&fCompleted))))
3401 {
3402 rc = pProgressThis->COMGETTER(Canceled)(&fCanceled);
3403 if (FAILED(rc)) throw rc;
3404 if (fCanceled)
3405 {
3406 pProgressAsync->Cancel();
3407 break;
3408 }
3409
3410 rc = pProgressAsync->COMGETTER(Percent(&currentPercent));
3411 if (FAILED(rc)) throw rc;
3412 if (!pProgressThis.isNull())
3413 pProgressThis->setCurrentOperationProgress(currentPercent);
3414 if (fCompleted)
3415 break;
3416
3417 /* Make sure the loop is not too tight */
3418 rc = pProgressAsync->WaitForCompletion(100);
3419 if (FAILED(rc)) throw rc;
3420 }
3421 // report result of asynchronous operation
3422 HRESULT vrc;
3423 rc = pProgressAsync->COMGETTER(ResultCode)(&vrc);
3424 if (FAILED(rc)) throw rc;
3425
3426
3427 // if the thread of the progress object has an error, then
3428 // retrieve the error info from there, or it'll be lost
3429 if (FAILED(vrc))
3430 {
3431 ProgressErrorInfo info(pProgressAsync);
3432 Utf8Str str(info.getText());
3433 const char *pcsz = str.c_str();
3434 HRESULT rc2 = setError(vrc, pcsz);
3435 throw rc2;
3436 }
3437}
3438
3439void Appliance::addWarning(const char* aWarning, ...)
3440{
3441 va_list args;
3442 va_start(args, aWarning);
3443 Utf8StrFmtVA str(aWarning, args);
3444 va_end(args);
3445 m->llWarnings.push_back(str);
3446}
3447
3448////////////////////////////////////////////////////////////////////////////////
3449//
3450// IVirtualSystemDescription constructor / destructor
3451//
3452////////////////////////////////////////////////////////////////////////////////
3453
3454DEFINE_EMPTY_CTOR_DTOR(VirtualSystemDescription)
3455struct shutup3 {};
3456
3457/**
3458 * COM initializer.
3459 * @return
3460 */
3461HRESULT VirtualSystemDescription::init()
3462{
3463 /* Enclose the state transition NotReady->InInit->Ready */
3464 AutoInitSpan autoInitSpan(this);
3465 AssertReturn(autoInitSpan.isOk(), E_FAIL);
3466
3467 /* Initialize data */
3468 m = new Data();
3469
3470 /* Confirm a successful initialization */
3471 autoInitSpan.setSucceeded();
3472 return S_OK;
3473}
3474
3475/**
3476* COM uninitializer.
3477*/
3478
3479void VirtualSystemDescription::uninit()
3480{
3481 delete m;
3482 m = NULL;
3483}
3484
3485////////////////////////////////////////////////////////////////////////////////
3486//
3487// IVirtualSystemDescription public methods
3488//
3489////////////////////////////////////////////////////////////////////////////////
3490
3491/**
3492 * Public method implementation.
3493 * @param
3494 * @return
3495 */
3496STDMETHODIMP VirtualSystemDescription::COMGETTER(Count)(ULONG *aCount)
3497{
3498 if (!aCount)
3499 return E_POINTER;
3500
3501 AutoCaller autoCaller(this);
3502 CheckComRCReturnRC(autoCaller.rc());
3503
3504 AutoReadLock alock(this);
3505
3506 *aCount = (ULONG)m->llDescriptions.size();
3507
3508 return S_OK;
3509}
3510
3511/**
3512 * Public method implementation.
3513 * @return
3514 */
3515STDMETHODIMP VirtualSystemDescription::GetDescription(ComSafeArrayOut(VirtualSystemDescriptionType_T, aTypes),
3516 ComSafeArrayOut(BSTR, aRefs),
3517 ComSafeArrayOut(BSTR, aOrigValues),
3518 ComSafeArrayOut(BSTR, aVboxValues),
3519 ComSafeArrayOut(BSTR, aExtraConfigValues))
3520{
3521 if (ComSafeArrayOutIsNull(aTypes) ||
3522 ComSafeArrayOutIsNull(aRefs) ||
3523 ComSafeArrayOutIsNull(aOrigValues) ||
3524 ComSafeArrayOutIsNull(aVboxValues) ||
3525 ComSafeArrayOutIsNull(aExtraConfigValues))
3526 return E_POINTER;
3527
3528 AutoCaller autoCaller(this);
3529 CheckComRCReturnRC(autoCaller.rc());
3530
3531 AutoReadLock alock(this);
3532
3533 ULONG c = (ULONG)m->llDescriptions.size();
3534 com::SafeArray<VirtualSystemDescriptionType_T> sfaTypes(c);
3535 com::SafeArray<BSTR> sfaRefs(c);
3536 com::SafeArray<BSTR> sfaOrigValues(c);
3537 com::SafeArray<BSTR> sfaVboxValues(c);
3538 com::SafeArray<BSTR> sfaExtraConfigValues(c);
3539
3540 list<VirtualSystemDescriptionEntry>::const_iterator it;
3541 size_t i = 0;
3542 for (it = m->llDescriptions.begin();
3543 it != m->llDescriptions.end();
3544 ++it, ++i)
3545 {
3546 const VirtualSystemDescriptionEntry &vsde = (*it);
3547
3548 sfaTypes[i] = vsde.type;
3549
3550 Bstr bstr = vsde.strRef;
3551 bstr.cloneTo(&sfaRefs[i]);
3552
3553 bstr = vsde.strOvf;
3554 bstr.cloneTo(&sfaOrigValues[i]);
3555
3556 bstr = vsde.strVbox;
3557 bstr.cloneTo(&sfaVboxValues[i]);
3558
3559 bstr = vsde.strExtraConfig;
3560 bstr.cloneTo(&sfaExtraConfigValues[i]);
3561 }
3562
3563 sfaTypes.detachTo(ComSafeArrayOutArg(aTypes));
3564 sfaRefs.detachTo(ComSafeArrayOutArg(aRefs));
3565 sfaOrigValues.detachTo(ComSafeArrayOutArg(aOrigValues));
3566 sfaVboxValues.detachTo(ComSafeArrayOutArg(aVboxValues));
3567 sfaExtraConfigValues.detachTo(ComSafeArrayOutArg(aExtraConfigValues));
3568
3569 return S_OK;
3570}
3571
3572/**
3573 * Public method implementation.
3574 * @return
3575 */
3576STDMETHODIMP VirtualSystemDescription::GetDescriptionByType(VirtualSystemDescriptionType_T aType,
3577 ComSafeArrayOut(VirtualSystemDescriptionType_T, aTypes),
3578 ComSafeArrayOut(BSTR, aRefs),
3579 ComSafeArrayOut(BSTR, aOrigValues),
3580 ComSafeArrayOut(BSTR, aVboxValues),
3581 ComSafeArrayOut(BSTR, aExtraConfigValues))
3582{
3583 if (ComSafeArrayOutIsNull(aTypes) ||
3584 ComSafeArrayOutIsNull(aRefs) ||
3585 ComSafeArrayOutIsNull(aOrigValues) ||
3586 ComSafeArrayOutIsNull(aVboxValues) ||
3587 ComSafeArrayOutIsNull(aExtraConfigValues))
3588 return E_POINTER;
3589
3590 AutoCaller autoCaller(this);
3591 CheckComRCReturnRC(autoCaller.rc());
3592
3593 AutoReadLock alock(this);
3594
3595 std::list<VirtualSystemDescriptionEntry*> vsd = findByType (aType);
3596 ULONG c = (ULONG)vsd.size();
3597 com::SafeArray<VirtualSystemDescriptionType_T> sfaTypes(c);
3598 com::SafeArray<BSTR> sfaRefs(c);
3599 com::SafeArray<BSTR> sfaOrigValues(c);
3600 com::SafeArray<BSTR> sfaVboxValues(c);
3601 com::SafeArray<BSTR> sfaExtraConfigValues(c);
3602
3603 list<VirtualSystemDescriptionEntry*>::const_iterator it;
3604 size_t i = 0;
3605 for (it = vsd.begin();
3606 it != vsd.end();
3607 ++it, ++i)
3608 {
3609 const VirtualSystemDescriptionEntry *vsde = (*it);
3610
3611 sfaTypes[i] = vsde->type;
3612
3613 Bstr bstr = vsde->strRef;
3614 bstr.cloneTo(&sfaRefs[i]);
3615
3616 bstr = vsde->strOvf;
3617 bstr.cloneTo(&sfaOrigValues[i]);
3618
3619 bstr = vsde->strVbox;
3620 bstr.cloneTo(&sfaVboxValues[i]);
3621
3622 bstr = vsde->strExtraConfig;
3623 bstr.cloneTo(&sfaExtraConfigValues[i]);
3624 }
3625
3626 sfaTypes.detachTo(ComSafeArrayOutArg(aTypes));
3627 sfaRefs.detachTo(ComSafeArrayOutArg(aRefs));
3628 sfaOrigValues.detachTo(ComSafeArrayOutArg(aOrigValues));
3629 sfaVboxValues.detachTo(ComSafeArrayOutArg(aVboxValues));
3630 sfaExtraConfigValues.detachTo(ComSafeArrayOutArg(aExtraConfigValues));
3631
3632 return S_OK;
3633}
3634
3635/**
3636 * Public method implementation.
3637 * @return
3638 */
3639STDMETHODIMP VirtualSystemDescription::GetValuesByType(VirtualSystemDescriptionType_T aType,
3640 VirtualSystemDescriptionValueType_T aWhich,
3641 ComSafeArrayOut(BSTR, aValues))
3642{
3643 if (ComSafeArrayOutIsNull(aValues))
3644 return E_POINTER;
3645
3646 AutoCaller autoCaller(this);
3647 CheckComRCReturnRC(autoCaller.rc());
3648
3649 AutoReadLock alock(this);
3650
3651 std::list<VirtualSystemDescriptionEntry*> vsd = findByType (aType);
3652 com::SafeArray<BSTR> sfaValues((ULONG)vsd.size());
3653
3654 list<VirtualSystemDescriptionEntry*>::const_iterator it;
3655 size_t i = 0;
3656 for (it = vsd.begin();
3657 it != vsd.end();
3658 ++it, ++i)
3659 {
3660 const VirtualSystemDescriptionEntry *vsde = (*it);
3661
3662 Bstr bstr;
3663 switch (aWhich)
3664 {
3665 case VirtualSystemDescriptionValueType_Reference: bstr = vsde->strRef; break;
3666 case VirtualSystemDescriptionValueType_Original: bstr = vsde->strOvf; break;
3667 case VirtualSystemDescriptionValueType_Auto: bstr = vsde->strVbox; break;
3668 case VirtualSystemDescriptionValueType_ExtraConfig: bstr = vsde->strExtraConfig; break;
3669 }
3670
3671 bstr.cloneTo(&sfaValues[i]);
3672 }
3673
3674 sfaValues.detachTo(ComSafeArrayOutArg(aValues));
3675
3676 return S_OK;
3677}
3678
3679/**
3680 * Public method implementation.
3681 * @return
3682 */
3683STDMETHODIMP VirtualSystemDescription::SetFinalValues(ComSafeArrayIn(BOOL, aEnabled),
3684 ComSafeArrayIn(IN_BSTR, argVboxValues),
3685 ComSafeArrayIn(IN_BSTR, argExtraConfigValues))
3686{
3687#ifndef RT_OS_WINDOWS
3688 NOREF(aEnabledSize);
3689#endif /* RT_OS_WINDOWS */
3690
3691 CheckComArgSafeArrayNotNull(aEnabled);
3692 CheckComArgSafeArrayNotNull(argVboxValues);
3693 CheckComArgSafeArrayNotNull(argExtraConfigValues);
3694
3695 AutoCaller autoCaller(this);
3696 CheckComRCReturnRC(autoCaller.rc());
3697
3698 AutoWriteLock alock(this);
3699
3700 com::SafeArray<BOOL> sfaEnabled(ComSafeArrayInArg(aEnabled));
3701 com::SafeArray<IN_BSTR> sfaVboxValues(ComSafeArrayInArg(argVboxValues));
3702 com::SafeArray<IN_BSTR> sfaExtraConfigValues(ComSafeArrayInArg(argExtraConfigValues));
3703
3704 if ( (sfaEnabled.size() != m->llDescriptions.size())
3705 || (sfaVboxValues.size() != m->llDescriptions.size())
3706 || (sfaExtraConfigValues.size() != m->llDescriptions.size())
3707 )
3708 return E_INVALIDARG;
3709
3710 list<VirtualSystemDescriptionEntry>::iterator it;
3711 size_t i = 0;
3712 for (it = m->llDescriptions.begin();
3713 it != m->llDescriptions.end();
3714 ++it, ++i)
3715 {
3716 VirtualSystemDescriptionEntry& vsde = *it;
3717
3718 if (sfaEnabled[i])
3719 {
3720 vsde.strVbox = sfaVboxValues[i];
3721 vsde.strExtraConfig = sfaExtraConfigValues[i];
3722 }
3723 else
3724 vsde.type = VirtualSystemDescriptionType_Ignore;
3725 }
3726
3727 return S_OK;
3728}
3729
3730/**
3731 * Public method implementation.
3732 * @return
3733 */
3734STDMETHODIMP VirtualSystemDescription::AddDescription(VirtualSystemDescriptionType_T aType,
3735 IN_BSTR aVboxValue,
3736 IN_BSTR aExtraConfigValue)
3737{
3738 CheckComArgNotNull(aVboxValue);
3739 CheckComArgNotNull(aExtraConfigValue);
3740
3741 AutoCaller autoCaller(this);
3742 CheckComRCReturnRC(autoCaller.rc());
3743
3744 AutoWriteLock alock(this);
3745
3746 addEntry(aType, "", aVboxValue, aVboxValue, 0, aExtraConfigValue);
3747
3748 return S_OK;
3749}
3750
3751/**
3752 * Internal method; adds a new description item to the member list.
3753 * @param aType Type of description for the new item.
3754 * @param strRef Reference item; only used with hard disk controllers.
3755 * @param aOrigValue Corresponding original value from OVF.
3756 * @param aAutoValue Initial configuration value (can be overridden by caller with setFinalValues).
3757 * @param strExtraConfig Extra configuration; meaning dependent on type.
3758 */
3759void VirtualSystemDescription::addEntry(VirtualSystemDescriptionType_T aType,
3760 const Utf8Str &strRef,
3761 const Utf8Str &aOrigValue,
3762 const Utf8Str &aAutoValue,
3763 uint32_t ulSizeMB,
3764 const Utf8Str &strExtraConfig /*= ""*/)
3765{
3766 VirtualSystemDescriptionEntry vsde;
3767 vsde.ulIndex = (uint32_t)m->llDescriptions.size(); // each entry gets an index so the client side can reference them
3768 vsde.type = aType;
3769 vsde.strRef = strRef;
3770 vsde.strOvf = aOrigValue;
3771 vsde.strVbox = aAutoValue;
3772 vsde.strExtraConfig = strExtraConfig;
3773 vsde.ulSizeMB = ulSizeMB;
3774
3775 m->llDescriptions.push_back(vsde);
3776}
3777
3778/**
3779 * Private method; returns a list of description items containing all the items from the member
3780 * description items of this virtual system that match the given type.
3781 * @param aType
3782 * @return
3783 */
3784std::list<VirtualSystemDescriptionEntry*> VirtualSystemDescription::findByType(VirtualSystemDescriptionType_T aType)
3785{
3786 std::list<VirtualSystemDescriptionEntry*> vsd;
3787
3788 list<VirtualSystemDescriptionEntry>::iterator it;
3789 for (it = m->llDescriptions.begin();
3790 it != m->llDescriptions.end();
3791 ++it)
3792 {
3793 if (it->type == aType)
3794 vsd.push_back(&(*it));
3795 }
3796
3797 return vsd;
3798}
3799
3800/**
3801 * Private method; looks thru the member hardware items for the IDE, SATA, or SCSI controller with
3802 * the given reference ID. Useful when needing the controller for a particular
3803 * virtual disk.
3804 * @param id
3805 * @return
3806 */
3807const VirtualSystemDescriptionEntry* VirtualSystemDescription::findControllerFromID(uint32_t id)
3808{
3809 Utf8Str strRef = Utf8StrFmt("%RI32", id);
3810 list<VirtualSystemDescriptionEntry>::const_iterator it;
3811 for (it = m->llDescriptions.begin();
3812 it != m->llDescriptions.end();
3813 ++it)
3814 {
3815 const VirtualSystemDescriptionEntry &d = *it;
3816 switch (d.type)
3817 {
3818 case VirtualSystemDescriptionType_HardDiskControllerIDE:
3819 case VirtualSystemDescriptionType_HardDiskControllerSATA:
3820 case VirtualSystemDescriptionType_HardDiskControllerSCSI:
3821 if (d.strRef == strRef)
3822 return &d;
3823 break;
3824 }
3825 }
3826
3827 return NULL;
3828}
3829
3830////////////////////////////////////////////////////////////////////////////////
3831//
3832// IMachine public methods
3833//
3834////////////////////////////////////////////////////////////////////////////////
3835
3836// This code is here so we won't have to include the appliance headers in the
3837// IMachine implementation, and we also need to access private appliance data.
3838
3839/**
3840* Public method implementation.
3841* @param appliance
3842* @return
3843*/
3844
3845STDMETHODIMP Machine::Export(IAppliance *aAppliance, IVirtualSystemDescription **aDescription)
3846{
3847 HRESULT rc = S_OK;
3848
3849 if (!aAppliance)
3850 return E_POINTER;
3851
3852 AutoCaller autoCaller(this);
3853 CheckComRCReturnRC(autoCaller.rc());
3854
3855 AutoReadLock alock(this);
3856
3857 ComObjPtr<VirtualSystemDescription> pNewDesc;
3858
3859 try
3860 {
3861 Bstr bstrName;
3862 Bstr bstrDescription;
3863 Bstr bstrGuestOSType;
3864 uint32_t cCPUs;
3865 uint32_t ulMemSizeMB;
3866 BOOL fDVDEnabled;
3867 BOOL fFloppyEnabled;
3868 BOOL fUSBEnabled;
3869 BOOL fAudioEnabled;
3870 AudioControllerType_T audioController;
3871
3872 ComPtr<IUSBController> pUsbController;
3873 ComPtr<IAudioAdapter> pAudioAdapter;
3874
3875 // get name
3876 bstrName = mUserData->mName;
3877 // get description
3878 bstrDescription = mUserData->mDescription;
3879 // get guest OS
3880 bstrGuestOSType = mUserData->mOSTypeId;
3881 // CPU count
3882 cCPUs = mHWData->mCPUCount;
3883 // memory size in MB
3884 ulMemSizeMB = mHWData->mMemorySize;
3885 // VRAM size?
3886 // BIOS settings?
3887 // 3D acceleration enabled?
3888 // hardware virtualization enabled?
3889 // nested paging enabled?
3890 // HWVirtExVPIDEnabled?
3891 // PAEEnabled?
3892 // snapshotFolder?
3893 // VRDPServer?
3894
3895 // floppy
3896 rc = mFloppyDrive->COMGETTER(Enabled)(&fFloppyEnabled);
3897 if (FAILED(rc)) throw rc;
3898
3899 // CD-ROM ?!?
3900 // ComPtr<IDVDDrive> pDVDDrive;
3901 fDVDEnabled = 1;
3902
3903 // this is more tricky so use the COM method
3904 rc = COMGETTER(USBController)(pUsbController.asOutParam());
3905 if (FAILED(rc)) throw rc;
3906 rc = pUsbController->COMGETTER(Enabled)(&fUSBEnabled);
3907
3908 pAudioAdapter = mAudioAdapter;
3909 rc = pAudioAdapter->COMGETTER(Enabled)(&fAudioEnabled);
3910 if (FAILED(rc)) throw rc;
3911 rc = pAudioAdapter->COMGETTER(AudioController)(&audioController);
3912 if (FAILED(rc)) throw rc;
3913
3914 // create a new virtual system
3915 rc = pNewDesc.createObject();
3916 CheckComRCThrowRC(rc);
3917 rc = pNewDesc->init();
3918 CheckComRCThrowRC(rc);
3919
3920 /* Guest OS type */
3921 Utf8Str strOsTypeVBox(bstrGuestOSType);
3922 CIMOSType_T cim = convertVBoxOSType2CIMOSType(strOsTypeVBox.c_str());
3923 pNewDesc->addEntry(VirtualSystemDescriptionType_OS,
3924 "",
3925 Utf8StrFmt("%RI32", cim),
3926 strOsTypeVBox);
3927
3928 /* VM name */
3929 Utf8Str strVMName(bstrName);
3930 pNewDesc->addEntry(VirtualSystemDescriptionType_Name,
3931 "",
3932 strVMName,
3933 strVMName);
3934
3935 // description
3936 Utf8Str strDescription(bstrDescription);
3937 pNewDesc->addEntry(VirtualSystemDescriptionType_Description,
3938 "",
3939 strDescription,
3940 strDescription);
3941
3942 /* CPU count*/
3943 Utf8Str strCpuCount = Utf8StrFmt("%RI32", cCPUs);
3944 pNewDesc->addEntry(VirtualSystemDescriptionType_CPU,
3945 "",
3946 strCpuCount,
3947 strCpuCount);
3948
3949 /* Memory */
3950 Utf8Str strMemory = Utf8StrFmt("%RI32", (uint64_t)ulMemSizeMB * _1M);
3951 pNewDesc->addEntry(VirtualSystemDescriptionType_Memory,
3952 "",
3953 strMemory,
3954 strMemory);
3955
3956 int32_t lIDEControllerIndex = 0;
3957 int32_t lSATAControllerIndex = 0;
3958 int32_t lSCSIControllerIndex = 0;
3959
3960// <const name="HardDiskControllerIDE" value="6" />
3961 ComPtr<IStorageController> pController;
3962 rc = GetStorageControllerByName(Bstr("IDE"), pController.asOutParam());
3963 if (FAILED(rc)) throw rc;
3964 Utf8Str strVbox;
3965 StorageControllerType_T ctlr;
3966 rc = pController->COMGETTER(ControllerType)(&ctlr);
3967 if (FAILED(rc)) throw rc;
3968 switch(ctlr)
3969 {
3970 case StorageControllerType_PIIX3: strVbox = "PIIX3"; break;
3971 case StorageControllerType_PIIX4: strVbox = "PIIX4"; break;
3972 case StorageControllerType_ICH6: strVbox = "ICH6"; break;
3973 }
3974
3975 if (strVbox.length())
3976 {
3977 lIDEControllerIndex = (int32_t)pNewDesc->m->llDescriptions.size();
3978 pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskControllerIDE,
3979 Utf8StrFmt("%d", lIDEControllerIndex),
3980 strVbox,
3981 strVbox);
3982 }
3983
3984#ifdef VBOX_WITH_AHCI
3985// <const name="HardDiskControllerSATA" value="7" />
3986 rc = GetStorageControllerByName(Bstr("SATA"), pController.asOutParam());
3987 if (SUCCEEDED(rc))
3988 {
3989 strVbox = "AHCI";
3990 lSATAControllerIndex = (int32_t)pNewDesc->m->llDescriptions.size();
3991 pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskControllerSATA,
3992 Utf8StrFmt("%d", lSATAControllerIndex),
3993 strVbox,
3994 strVbox);
3995 }
3996#endif // VBOX_WITH_AHCI
3997
3998// <const name="HardDiskControllerSCSI" value="8" />
3999 rc = GetStorageControllerByName(Bstr("SCSI"), pController.asOutParam());
4000 if (SUCCEEDED(rc))
4001 {
4002 rc = pController->COMGETTER(ControllerType)(&ctlr);
4003 if (SUCCEEDED(rc))
4004 {
4005 strVbox = "LsiLogic"; // the default in VBox
4006 switch(ctlr)
4007 {
4008 case StorageControllerType_LsiLogic: strVbox = "LsiLogic"; break;
4009 case StorageControllerType_BusLogic: strVbox = "BusLogic"; break;
4010 }
4011 lSCSIControllerIndex = (int32_t)pNewDesc->m->llDescriptions.size();
4012 pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskControllerSCSI,
4013 Utf8StrFmt("%d", lSCSIControllerIndex),
4014 strVbox,
4015 strVbox);
4016 }
4017 else
4018 throw rc;
4019 }
4020
4021// <const name="HardDiskImage" value="9" />
4022 HDData::AttachmentList::iterator itA;
4023 for (itA = mHDData->mAttachments.begin();
4024 itA != mHDData->mAttachments.end();
4025 ++itA)
4026 {
4027 ComObjPtr<HardDiskAttachment> pHDA = *itA;
4028
4029 // the attachment's data
4030 ComPtr<IHardDisk> pHardDisk;
4031 ComPtr<IStorageController> ctl;
4032 Bstr controllerName;
4033
4034 rc = pHDA->COMGETTER(Controller)(controllerName.asOutParam());
4035 if (FAILED(rc)) throw rc;
4036
4037 rc = GetStorageControllerByName(controllerName, ctl.asOutParam());
4038 if (FAILED(rc)) throw rc;
4039
4040 StorageBus_T storageBus;
4041 LONG lChannel;
4042 LONG lDevice;
4043
4044 rc = ctl->COMGETTER(Bus)(&storageBus);
4045 if (FAILED(rc)) throw rc;
4046
4047 rc = pHDA->COMGETTER(HardDisk)(pHardDisk.asOutParam());
4048 if (FAILED(rc)) throw rc;
4049
4050 rc = pHDA->COMGETTER(Port)(&lChannel);
4051 if (FAILED(rc)) throw rc;
4052
4053 rc = pHDA->COMGETTER(Device)(&lDevice);
4054 if (FAILED(rc)) throw rc;
4055
4056 Bstr bstrLocation;
4057 rc = pHardDisk->COMGETTER(Location)(bstrLocation.asOutParam());
4058 if (FAILED(rc)) throw rc;
4059 Bstr bstrName;
4060 rc = pHardDisk->COMGETTER(Name)(bstrName.asOutParam());
4061 if (FAILED(rc)) throw rc;
4062
4063 // force reading state, or else size will be returned as 0
4064 MediaState_T ms;
4065 rc = pHardDisk->COMGETTER(State)(&ms);
4066 if (FAILED(rc)) throw rc;
4067
4068 ULONG64 ullSize;
4069 rc = pHardDisk->COMGETTER(Size)(&ullSize);
4070 if (FAILED(rc)) throw rc;
4071
4072 // and how this translates to the virtual system
4073 int32_t lControllerVsys = 0;
4074 LONG lChannelVsys;
4075
4076 switch (storageBus)
4077 {
4078 case StorageBus_IDE:
4079 // this is the exact reverse to what we're doing in Appliance::taskThreadImportMachines,
4080 // and it must be updated when that is changed!
4081
4082 if (lChannel == 0 && lDevice == 0) // primary master
4083 lChannelVsys = 0;
4084 else if (lChannel == 0 && lDevice == 1) // primary slave
4085 lChannelVsys = 1;
4086 else if (lChannel == 1 && lDevice == 1) // secondary slave; secondary master is always CDROM
4087 lChannelVsys = 2;
4088 else
4089 throw setError(VBOX_E_NOT_SUPPORTED,
4090 tr("Cannot handle hard disk attachment: channel is %d, device is %d"), lChannel, lDevice);
4091
4092 lControllerVsys = lIDEControllerIndex;
4093 break;
4094
4095 case StorageBus_SATA:
4096 lChannelVsys = lChannel; // should be between 0 and 29
4097 lControllerVsys = lSATAControllerIndex;
4098 break;
4099
4100 case StorageBus_SCSI:
4101 lChannelVsys = lChannel; // should be between 0 and 15
4102 lControllerVsys = lSCSIControllerIndex;
4103 break;
4104
4105 default:
4106 throw setError(VBOX_E_NOT_SUPPORTED,
4107 tr("Cannot handle hard disk attachment: storageBus is %d, channel is %d, device is %d"), storageBus, lChannel, lDevice);
4108 break;
4109 }
4110
4111 Utf8Str strTargetVmdkName(bstrName);
4112 RTPathStripExt(strTargetVmdkName.mutableRaw());
4113 strTargetVmdkName.append(".vmdk");
4114
4115 pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskImage,
4116 strTargetVmdkName, // disk ID: let's use the name
4117 strTargetVmdkName, // OVF value:
4118 Utf8Str(bstrLocation), // vbox value: media path
4119 (uint32_t)(ullSize / _1M),
4120 Utf8StrFmt("controller=%RI32;channel=%RI32", lControllerVsys, lChannelVsys));
4121 }
4122
4123 /* Floppy Drive */
4124 if (fFloppyEnabled)
4125 pNewDesc->addEntry(VirtualSystemDescriptionType_Floppy, "", "", "");
4126
4127 /* CD Drive */
4128 if (fDVDEnabled)
4129 pNewDesc->addEntry(VirtualSystemDescriptionType_CDROM, "", "", "");
4130
4131// <const name="NetworkAdapter" />
4132 size_t a;
4133 for (a = 0;
4134 a < SchemaDefs::NetworkAdapterCount;
4135 ++a)
4136 {
4137 ComPtr<INetworkAdapter> pNetworkAdapter;
4138 BOOL fEnabled;
4139 NetworkAdapterType_T adapterType;
4140 NetworkAttachmentType_T attachmentType;
4141
4142 rc = GetNetworkAdapter((ULONG)a, pNetworkAdapter.asOutParam());
4143 if (FAILED(rc)) throw rc;
4144 /* Enable the network card & set the adapter type */
4145 rc = pNetworkAdapter->COMGETTER(Enabled)(&fEnabled);
4146 if (FAILED(rc)) throw rc;
4147
4148 if (fEnabled)
4149 {
4150 Utf8Str strAttachmentType;
4151
4152 rc = pNetworkAdapter->COMGETTER(AdapterType)(&adapterType);
4153 if (FAILED(rc)) throw rc;
4154
4155 rc = pNetworkAdapter->COMGETTER(AttachmentType)(&attachmentType);
4156 if (FAILED(rc)) throw rc;
4157
4158 switch (attachmentType)
4159 {
4160 case NetworkAttachmentType_Null:
4161 strAttachmentType = "Null";
4162 break;
4163
4164 case NetworkAttachmentType_NAT:
4165 strAttachmentType = "NAT";
4166 break;
4167
4168 case NetworkAttachmentType_Bridged:
4169 strAttachmentType = "Bridged";
4170 break;
4171
4172 case NetworkAttachmentType_Internal:
4173 strAttachmentType = "Internal";
4174 break;
4175
4176 case NetworkAttachmentType_HostOnly:
4177 strAttachmentType = "HostOnly";
4178 break;
4179 }
4180
4181 pNewDesc->addEntry(VirtualSystemDescriptionType_NetworkAdapter,
4182 "", // ref
4183 strAttachmentType, // orig
4184 Utf8StrFmt("%RI32", (uint32_t)adapterType), // conf
4185 Utf8StrFmt("type=%s", strAttachmentType.c_str())); // extra conf
4186 }
4187 }
4188
4189// <const name="USBController" />
4190#ifdef VBOX_WITH_USB
4191 if (fUSBEnabled)
4192 pNewDesc->addEntry(VirtualSystemDescriptionType_USBController, "", "", "");
4193#endif /* VBOX_WITH_USB */
4194
4195// <const name="SoundCard" />
4196 if (fAudioEnabled)
4197 {
4198 pNewDesc->addEntry(VirtualSystemDescriptionType_SoundCard,
4199 "",
4200 "ensoniq1371", // this is what OVFTool writes and VMware supports
4201 Utf8StrFmt("%RI32", audioController));
4202 }
4203
4204 // finally, add the virtual system to the appliance
4205 Appliance *pAppliance = static_cast<Appliance*>(aAppliance);
4206 AutoCaller autoCaller1(pAppliance);
4207 CheckComRCReturnRC(autoCaller1.rc());
4208
4209 /* We return the new description to the caller */
4210 ComPtr<IVirtualSystemDescription> copy(pNewDesc);
4211 copy.queryInterfaceTo(aDescription);
4212
4213 AutoWriteLock alock(pAppliance);
4214
4215 pAppliance->m->virtualSystemDescriptions.push_back(pNewDesc);
4216 }
4217 catch(HRESULT arc)
4218 {
4219 rc = arc;
4220 }
4221
4222 return rc;
4223}
4224
4225/* vi: set tabstop=4 shiftwidth=4 expandtab: */
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette