VirtualBox

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

Last change on this file since 18626 was 18623, checked in by vboxsync, 16 years ago

OVF: add support for writing OVF 0.9 instead of 1.0 and make it the default in front-ends for now
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 188.5 KB
Line 
1/* $Id: ApplianceImpl.cpp 18623 2009-04-02 10:00:48Z 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 enFormat(unspecified),
2463 progress(aProgress),
2464 rc(S_OK)
2465 {}
2466 ~TaskWriteOVF() {}
2467
2468 HRESULT startThread();
2469
2470 Appliance *pAppliance;
2471 enum { unspecified, OVF_0_9, OVF_1_0 }
2472 enFormat;
2473
2474 ComObjPtr<Progress> progress;
2475 HRESULT rc;
2476};
2477
2478HRESULT Appliance::TaskWriteOVF::startThread()
2479{
2480 int vrc = RTThreadCreate(NULL, Appliance::taskThreadWriteOVF, this,
2481 0, RTTHREADTYPE_MAIN_HEAVY_WORKER, 0,
2482 "Appliance::Task");
2483 ComAssertMsgRCRet(vrc,
2484 ("Could not create taskThreadExportOVF (%Rrc)\n", vrc), E_FAIL);
2485
2486 return S_OK;
2487}
2488
2489STDMETHODIMP Appliance::Write(IN_BSTR format, IN_BSTR path, IProgress **aProgress)
2490{
2491 HRESULT rc = S_OK;
2492
2493 CheckComArgOutPointerValid(aProgress);
2494
2495 AutoCaller autoCaller(this);
2496 if (FAILED(rc = autoCaller.rc())) return rc;
2497
2498 AutoWriteLock(this);
2499
2500 // see if we can handle this file; for now we insist it has an ".ovf" extension
2501 m->strPath = path;
2502 if (!m->strPath.endsWith(".ovf", Utf8Str::CaseInsensitive))
2503 return setError(VBOX_E_FILE_ERROR,
2504 tr("Appliance file must have .ovf extension"));
2505
2506 ComObjPtr<Progress> progress;
2507 try
2508 {
2509 Bstr progressDesc = BstrFmt(tr("Export appliance '%s'"),
2510 m->strPath.raw());
2511 rc = setUpProgress(progress, progressDesc);
2512 if (FAILED(rc)) throw rc;
2513
2514 /* Initialize our worker task */
2515 std::auto_ptr<TaskWriteOVF> task(new TaskWriteOVF(this, progress));
2516 //AssertComRCThrowRC (task->autoCaller.rc());
2517
2518 Utf8Str strFormat(format);
2519 if (strFormat == "ovf-0.9")
2520 task->enFormat = TaskWriteOVF::OVF_0_9;
2521 else if (strFormat == "ovf-1.0")
2522 task->enFormat = TaskWriteOVF::OVF_1_0;
2523 else
2524 return setError(VBOX_E_FILE_ERROR,
2525 tr("Invalid format \"%s\" specified"), strFormat.c_str());
2526
2527 rc = task->startThread();
2528 CheckComRCThrowRC(rc);
2529
2530 task.release();
2531 }
2532 catch (HRESULT aRC)
2533 {
2534 rc = aRC;
2535 }
2536
2537 if (SUCCEEDED(rc))
2538 /* Return progress to the caller */
2539 progress.queryInterfaceTo(aProgress);
2540
2541 return rc;
2542}
2543
2544/**
2545 * Worker thread implementation for Write() (ovf writer).
2546 * @param aThread
2547 * @param pvUser
2548 */
2549/* static */
2550DECLCALLBACK(int) Appliance::taskThreadWriteOVF(RTTHREAD /* aThread */, void *pvUser)
2551{
2552 std::auto_ptr<TaskWriteOVF> task(static_cast<TaskWriteOVF*>(pvUser));
2553 AssertReturn(task.get(), VERR_GENERAL_FAILURE);
2554
2555 Appliance *pAppliance = task->pAppliance;
2556
2557 LogFlowFuncEnter();
2558 LogFlowFunc(("Appliance %p\n", pAppliance));
2559
2560 AutoCaller autoCaller(pAppliance);
2561 CheckComRCReturnRC(autoCaller.rc());
2562
2563 AutoWriteLock appLock(pAppliance);
2564
2565 HRESULT rc = S_OK;
2566
2567 ComPtr<IVirtualBox> pVirtualBox(pAppliance->mVirtualBox);
2568
2569 try
2570 {
2571 xml::Document doc;
2572 xml::ElementNode *pelmRoot = doc.createRootElement("Envelope");
2573
2574 pelmRoot->setAttribute("ovf:version", (task->enFormat == TaskWriteOVF::OVF_1_0) ? "1.0" : "0.9");
2575 pelmRoot->setAttribute("xml:lang", "en-US");
2576 pelmRoot->setAttribute("xmlns", "http://schemas.dmtf.org/ovf/envelope/1");
2577 pelmRoot->setAttribute("xmlns:ovf", "http://schemas.dmtf.org/ovf/envelope/1");
2578// pelmRoot->setAttribute("xmlns:ovfstr", "http://schema.dmtf.org/ovf/strings/1");
2579 pelmRoot->setAttribute("xmlns:rasd", "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData");
2580 pelmRoot->setAttribute("xmlns:vssd", "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_VirtualSystemSettingData");
2581 pelmRoot->setAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
2582// pelmRoot->setAttribute("xsi:schemaLocation", "http://schemas.dmtf.org/ovf/envelope/1 ../ovf-envelope.xsd");
2583
2584 // <Envelope>/<References>
2585 xml::ElementNode *pelmReferences = pelmRoot->createChild("References"); // 0.9 and 1.0
2586
2587 /* <Envelope>/<DiskSection>:
2588 <DiskSection>
2589 <Info>List of the virtual disks used in the package</Info>
2590 <Disk ovf:capacity="4294967296" ovf:diskId="lamp" ovf:format="http://www.vmware.com/specifications/vmdk.html#compressed" ovf:populatedSize="1924967692"/>
2591 </DiskSection> */
2592 xml::ElementNode *pelmDiskSection;
2593 if (task->enFormat == TaskWriteOVF::OVF_0_9)
2594 {
2595 // <Section xsi:type="ovf:DiskSection_Type">
2596 pelmDiskSection = pelmRoot->createChild("Section");
2597 pelmDiskSection->setAttribute("xsi:type", "ovf:DiskSection_Type");
2598 }
2599 else
2600 pelmDiskSection = pelmRoot->createChild("DiskSection");
2601
2602 xml::ElementNode *pelmDiskSectionInfo = pelmDiskSection->createChild("Info");
2603 pelmDiskSectionInfo->addContent("List of the virtual disks used in the package");
2604 // for now, set up a map so we have a list of unique disk names (to make
2605 // sure the same disk name is only added once)
2606 map<Utf8Str, const VirtualSystemDescriptionEntry*> mapDisks;
2607
2608 /* <Envelope>/<NetworkSection>:
2609 <NetworkSection>
2610 <Info>Logical networks used in the package</Info>
2611 <Network ovf:name="VM Network">
2612 <Description>The network that the LAMP Service will be available on</Description>
2613 </Network>
2614 </NetworkSection> */
2615 xml::ElementNode *pelmNetworkSection;
2616 if (task->enFormat == TaskWriteOVF::OVF_0_9)
2617 {
2618 // <Section xsi:type="ovf:NetworkSection_Type">
2619 pelmNetworkSection = pelmRoot->createChild("Section");
2620 pelmNetworkSection->setAttribute("xsi:type", "ovf:NetworkSection_Type");
2621 }
2622 else
2623 pelmNetworkSection = pelmRoot->createChild("NetworkSection");
2624
2625 xml::ElementNode *pelmNetworkSectionInfo = pelmNetworkSection->createChild("Info");
2626 pelmNetworkSectionInfo->addContent("Logical networks used in the package");
2627 // for now, set up a map so we have a list of unique network names (to make
2628 // sure the same network name is only added once)
2629 map<Utf8Str, bool> mapNetworks;
2630 // we fill this later below when we iterate over the networks
2631
2632 // and here come the virtual systems:
2633 xml::ElementNode *pelmVirtualSystemCollection;
2634 if (task->enFormat == TaskWriteOVF::OVF_0_9)
2635 {
2636 // <Section xsi:type="ovf:NetworkSection_Type">
2637 pelmVirtualSystemCollection = pelmRoot->createChild("Content");
2638 pelmVirtualSystemCollection->setAttribute("xsi:type", "ovf:VirtualSystemCollection_Type");
2639 }
2640 else
2641 pelmVirtualSystemCollection = pelmRoot->createChild("VirtualSystemCollection");
2642 /* xml::AttributeNode *pattrVirtualSystemCollectionId = */ pelmVirtualSystemCollection->setAttribute("ovf:id", "ExportedVirtualBoxMachines"); // whatever
2643
2644 list< ComObjPtr<VirtualSystemDescription> >::const_iterator it;
2645 /* Iterate through all virtual systems of that appliance */
2646 for (it = pAppliance->m->virtualSystemDescriptions.begin();
2647 it != pAppliance->m->virtualSystemDescriptions.end();
2648 ++it)
2649 {
2650 ComObjPtr<VirtualSystemDescription> vsdescThis = (*it);
2651
2652 xml::ElementNode *pelmVirtualSystem;
2653 if (task->enFormat == TaskWriteOVF::OVF_0_9)
2654 {
2655 // <Section xsi:type="ovf:NetworkSection_Type">
2656 pelmVirtualSystem = pelmVirtualSystemCollection->createChild("Content");
2657 pelmVirtualSystem->setAttribute("xsi:type", "ovf:VirtualSystem_Type");
2658 }
2659 else
2660 pelmVirtualSystem = pelmVirtualSystemCollection->createChild("VirtualSystem");
2661
2662 /*xml::ElementNode *pelmVirtualSystemInfo =*/ pelmVirtualSystem->createChild("Info")->addContent("A virtual machine");
2663
2664 std::list<VirtualSystemDescriptionEntry*> llName = vsdescThis->findByType(VirtualSystemDescriptionType_Name);
2665 if (llName.size() != 1)
2666 throw setError(VBOX_E_NOT_SUPPORTED,
2667 tr("Missing VM name"));
2668 Utf8Str &strVMName = llName.front()->strVbox;
2669 pelmVirtualSystem->setAttribute("ovf:id", strVMName);
2670
2671 // product info
2672 std::list<VirtualSystemDescriptionEntry*> llProduct = vsdescThis->findByType(VirtualSystemDescriptionType_Product);
2673 std::list<VirtualSystemDescriptionEntry*> llProductUrl = vsdescThis->findByType(VirtualSystemDescriptionType_ProductUrl);
2674 std::list<VirtualSystemDescriptionEntry*> llVendor = vsdescThis->findByType(VirtualSystemDescriptionType_Vendor);
2675 std::list<VirtualSystemDescriptionEntry*> llVendorUrl = vsdescThis->findByType(VirtualSystemDescriptionType_VendorUrl);
2676 std::list<VirtualSystemDescriptionEntry*> llVersion = vsdescThis->findByType(VirtualSystemDescriptionType_Version);
2677 bool fProduct = llProduct.size() && !llProduct.front()->strVbox.isEmpty();
2678 bool fProductUrl = llProductUrl.size() && !llProductUrl.front()->strVbox.isEmpty();
2679 bool fVendor = llVendor.size() && !llVendor.front()->strVbox.isEmpty();
2680 bool fVendorUrl = llVendorUrl.size() && !llVendorUrl.front()->strVbox.isEmpty();
2681 bool fVersion = llVersion.size() && !llVersion.front()->strVbox.isEmpty();
2682 if (fProduct ||
2683 fProductUrl ||
2684 fVersion ||
2685 fVendorUrl ||
2686 fVersion)
2687 {
2688 /* <Section ovf:required="false" xsi:type="ovf:ProductSection_Type">
2689 <Info>Meta-information about the installed software</Info>
2690 <Product>VAtest</Product>
2691 <Vendor>SUN Microsystems</Vendor>
2692 <Version>10.0</Version>
2693 <ProductUrl>http://blogs.sun.com/VirtualGuru</ProductUrl>
2694 <VendorUrl>http://www.sun.com</VendorUrl>
2695 </Section> */
2696 xml::ElementNode *pelmAnnotationSection;
2697 if (task->enFormat == TaskWriteOVF::OVF_0_9)
2698 {
2699 // <Section ovf:required="false" xsi:type="ovf:ProductSection_Type">
2700 pelmAnnotationSection = pelmVirtualSystem->createChild("Section");
2701 pelmAnnotationSection->setAttribute("xsi:type", "ovf:ProductSection_Type");
2702 }
2703 else
2704 pelmAnnotationSection = pelmVirtualSystem->createChild("ProductSection");
2705
2706 pelmAnnotationSection->createChild("Info")->addContent("Meta-information about the installed software");
2707 if (fProduct)
2708 pelmAnnotationSection->createChild("Product")->addContent(llProduct.front()->strVbox);
2709 if (fVendor)
2710 pelmAnnotationSection->createChild("Vendor")->addContent(llVendor.front()->strVbox);
2711 if (fVersion)
2712 pelmAnnotationSection->createChild("Version")->addContent(llVersion.front()->strVbox);
2713 if (fProductUrl)
2714 pelmAnnotationSection->createChild("ProductUrl")->addContent(llProductUrl.front()->strVbox);
2715 if (fVendorUrl)
2716 pelmAnnotationSection->createChild("VendorUrl")->addContent(llVendorUrl.front()->strVbox);
2717 }
2718
2719 // description
2720 std::list<VirtualSystemDescriptionEntry*> llDescription = vsdescThis->findByType(VirtualSystemDescriptionType_Description);
2721 if (llDescription.size() &&
2722 !llDescription.front()->strVbox.isEmpty())
2723 {
2724 /* <Section ovf:required="false" xsi:type="ovf:AnnotationSection_Type">
2725 <Info>A human-readable annotation</Info>
2726 <Annotation>Plan 9</Annotation>
2727 </Section> */
2728 xml::ElementNode *pelmAnnotationSection;
2729 if (task->enFormat == TaskWriteOVF::OVF_0_9)
2730 {
2731 // <Section ovf:required="false" xsi:type="ovf:AnnotationSection_Type">
2732 pelmAnnotationSection = pelmVirtualSystem->createChild("Section");
2733 pelmAnnotationSection->setAttribute("xsi:type", "ovf:AnnotationSection_Type");
2734 }
2735 else
2736 pelmAnnotationSection = pelmVirtualSystem->createChild("AnnotationSection");
2737
2738 pelmAnnotationSection->createChild("Info")->addContent("A human-readable annotation");
2739 pelmAnnotationSection->createChild("Annotation")->addContent(llDescription.front()->strVbox);
2740 }
2741
2742 // license
2743 std::list<VirtualSystemDescriptionEntry*> llLicense = vsdescThis->findByType(VirtualSystemDescriptionType_License);
2744 if (llLicense.size() &&
2745 !llLicense.front()->strVbox.isEmpty())
2746 {
2747 /* <EulaSection>
2748 <Info ovf:msgid="6">License agreement for the Virtual System.</Info>
2749 <License ovf:msgid="1">License terms can go in here.</License>
2750 </EulaSection> */
2751 xml::ElementNode *pelmEulaSection;
2752 if (task->enFormat == TaskWriteOVF::OVF_0_9)
2753 {
2754 pelmEulaSection = pelmVirtualSystem->createChild("Section");
2755 pelmEulaSection->setAttribute("xsi:type", "ovf:EulaSection_Type");
2756 }
2757 else
2758 pelmEulaSection = pelmVirtualSystem->createChild("EulaSection");
2759
2760 pelmEulaSection->createChild("Info")->addContent("License agreement for the virtual system");
2761 pelmEulaSection->createChild("License")->addContent(llLicense.front()->strVbox);
2762 }
2763
2764 // operating system
2765 std::list<VirtualSystemDescriptionEntry*> llOS = vsdescThis->findByType(VirtualSystemDescriptionType_OS);
2766 if (llOS.size() != 1)
2767 throw setError(VBOX_E_NOT_SUPPORTED,
2768 tr("Missing OS type"));
2769 /* <OperatingSystemSection ovf:id="82">
2770 <Info>Guest Operating System</Info>
2771 <Description>Linux 2.6.x</Description>
2772 </OperatingSystemSection> */
2773 xml::ElementNode *pelmOperatingSystemSection;
2774 if (task->enFormat == TaskWriteOVF::OVF_0_9)
2775 {
2776 pelmOperatingSystemSection = pelmVirtualSystem->createChild("Section");
2777 pelmOperatingSystemSection->setAttribute("xsi:type", "ovf:OperatingSystemSection_Type");
2778 }
2779 else
2780 pelmOperatingSystemSection = pelmVirtualSystem->createChild("OperatingSystemSection");
2781
2782 pelmOperatingSystemSection->setAttribute("ovf:id", llOS.front()->strOvf);
2783 pelmOperatingSystemSection->createChild("Info")->addContent("The kind of installed guest operating system");
2784// pelmOperatingSystemSection->createChild("Description")->addContent("blah"); // @todo
2785
2786 // <VirtualHardwareSection ovf:id="hw1" ovf:transport="iso">
2787 xml::ElementNode *pelmVirtualHardwareSection;
2788 if (task->enFormat == TaskWriteOVF::OVF_0_9)
2789 {
2790 // <Section xsi:type="ovf:VirtualHardwareSection_Type">
2791 pelmVirtualHardwareSection = pelmVirtualSystem->createChild("Section");
2792 pelmVirtualHardwareSection->setAttribute("xsi:type", "ovf:VirtualHardwareSection_Type");
2793 }
2794 else
2795 pelmVirtualHardwareSection = pelmVirtualSystem->createChild("VirtualHardwareSection");
2796
2797 pelmVirtualHardwareSection->createChild("Info")->addContent("Virtual hardware requirements for a virtual machine");
2798
2799 /* <System>
2800 <vssd:Description>Description of the virtual hardware section.</vssd:Description>
2801 <vssd:ElementName>vmware</vssd:ElementName>
2802 <vssd:InstanceID>1</vssd:InstanceID>
2803 <vssd:VirtualSystemIdentifier>MyLampService</vssd:VirtualSystemIdentifier>
2804 <vssd:VirtualSystemType>vmx-4</vssd:VirtualSystemType>
2805 </System> */
2806 xml::ElementNode *pelmSystem = pelmVirtualHardwareSection->createChild("System");
2807
2808 // <vssd:InstanceId>0</vssd:InstanceId>
2809 pelmSystem->createChild("vssd:InstanceId")->addContent("0");
2810 // <vssd:VirtualSystemIdentifier>VAtest</vssd:VirtualSystemIdentifier>
2811 pelmSystem->createChild("vssd:VirtualSystemIdentifier")->addContent(strVMName);
2812 // <vssd:VirtualSystemType>vmx-4</vssd:VirtualSystemType>
2813 pelmSystem->createChild("vssd:VirtualSystemType")->addContent("virtualbox-2.2"); // instead of vmx-7?
2814
2815 // loop thru all description entries twice; once to write out all
2816 // devices _except_ disk images, and a second time to assign the
2817 // disk images; this is because disk images need to reference
2818 // IDE controllers, and we can't know their instance IDs without
2819 // assigning them first
2820
2821 uint32_t idIDEController = 0;
2822 int32_t lIDEControllerIndex = 0;
2823 uint32_t idSATAController = 0;
2824 int32_t lSATAControllerIndex = 0;
2825 uint32_t idSCSIController = 0;
2826 int32_t lSCSIControllerIndex = 0;
2827
2828 uint32_t ulInstanceID = 1;
2829 uint32_t cDisks = 0;
2830
2831 for (size_t uLoop = 1;
2832 uLoop <= 2;
2833 ++uLoop)
2834 {
2835 int32_t lIndexThis = 0;
2836 list<VirtualSystemDescriptionEntry>::const_iterator itD;
2837 for (itD = vsdescThis->m->llDescriptions.begin();
2838 itD != vsdescThis->m->llDescriptions.end();
2839 ++itD, ++lIndexThis)
2840 {
2841 const VirtualSystemDescriptionEntry &desc = *itD;
2842
2843 OVFResourceType_T type = (OVFResourceType_T)0; // if this becomes != 0 then we do stuff
2844 Utf8Str strResourceSubType;
2845
2846 Utf8Str strDescription; // results in <rasd:Description>...</rasd:Description> block
2847 Utf8Str strCaption; // results in <rasd:Caption>...</rasd:Caption> block
2848
2849 uint32_t ulParent = 0;
2850
2851 int32_t lVirtualQuantity = -1;
2852 Utf8Str strAllocationUnits;
2853
2854 int32_t lAddress = -1;
2855 int32_t lBusNumber = -1;
2856 int32_t lAddressOnParent = -1;
2857
2858 int32_t lAutomaticAllocation = -1; // 0 means "false", 1 means "true"
2859 Utf8Str strConnection; // results in <rasd:Connection>...</rasd:Connection> block
2860 Utf8Str strHostResource;
2861
2862 uint64_t uTemp;
2863
2864 switch (desc.type)
2865 {
2866 case VirtualSystemDescriptionType_CPU:
2867 /* <Item>
2868 <rasd:Caption>1 virtual CPU</rasd:Caption>
2869 <rasd:Description>Number of virtual CPUs</rasd:Description>
2870 <rasd:ElementName>virtual CPU</rasd:ElementName>
2871 <rasd:InstanceID>1</rasd:InstanceID>
2872 <rasd:ResourceType>3</rasd:ResourceType>
2873 <rasd:VirtualQuantity>1</rasd:VirtualQuantity>
2874 </Item> */
2875 if (uLoop == 1)
2876 {
2877 strDescription = "Number of virtual CPUs";
2878 type = OVFResourceType_Processor; // 3
2879 lVirtualQuantity = 1;
2880 }
2881 break;
2882
2883 case VirtualSystemDescriptionType_Memory:
2884 /* <Item>
2885 <rasd:AllocationUnits>MegaBytes</rasd:AllocationUnits>
2886 <rasd:Caption>256 MB of memory</rasd:Caption>
2887 <rasd:Description>Memory Size</rasd:Description>
2888 <rasd:ElementName>Memory</rasd:ElementName>
2889 <rasd:InstanceID>2</rasd:InstanceID>
2890 <rasd:ResourceType>4</rasd:ResourceType>
2891 <rasd:VirtualQuantity>256</rasd:VirtualQuantity>
2892 </Item> */
2893 if (uLoop == 1)
2894 {
2895 strDescription = "Memory Size";
2896 type = OVFResourceType_Memory; // 4
2897 desc.strVbox.toInt(uTemp);
2898 lVirtualQuantity = (int32_t)(uTemp / _1M);
2899 strAllocationUnits = "MegaBytes";
2900 }
2901 break;
2902
2903 case VirtualSystemDescriptionType_HardDiskControllerIDE:
2904 /* <Item>
2905 <rasd:Caption>ideController1</rasd:Caption>
2906 <rasd:Description>IDE Controller</rasd:Description>
2907 <rasd:InstanceId>5</rasd:InstanceId>
2908 <rasd:ResourceType>5</rasd:ResourceType>
2909 <rasd:Address>1</rasd:Address>
2910 <rasd:BusNumber>1</rasd:BusNumber>
2911 </Item> */
2912 if (uLoop == 1)
2913 {
2914 strDescription = "IDE Controller";
2915 type = OVFResourceType_IDEController; // 5
2916 strResourceSubType = desc.strVbox;
2917 // it seems that OVFTool always writes these two, and since we can only
2918 // have one IDE controller, we'll use this as well
2919 lAddress = 1;
2920 lBusNumber = 1;
2921
2922 // remember this ID
2923 idIDEController = ulInstanceID;
2924 lIDEControllerIndex = lIndexThis;
2925 }
2926 break;
2927
2928 case VirtualSystemDescriptionType_HardDiskControllerSATA:
2929 /* <Item>
2930 <rasd:Caption>sataController0</rasd:Caption>
2931 <rasd:Description>SATA Controller</rasd:Description>
2932 <rasd:InstanceId>4</rasd:InstanceId>
2933 <rasd:ResourceType>20</rasd:ResourceType>
2934 <rasd:ResourceSubType>ahci</rasd:ResourceSubType>
2935 <rasd:Address>0</rasd:Address>
2936 <rasd:BusNumber>0</rasd:BusNumber>
2937 </Item>
2938 */
2939 if (uLoop == 1)
2940 {
2941 strDescription = "SATA Controller";
2942 strCaption = "sataController0";
2943 type = OVFResourceType_OtherStorageDevice; // 20
2944 // it seems that OVFTool always writes these two, and since we can only
2945 // have one SATA controller, we'll use this as well
2946 lAddress = 0;
2947 lBusNumber = 0;
2948
2949 if ( desc.strVbox.isEmpty() // AHCI is the default in VirtualBox
2950 || (!desc.strVbox.compare("ahci", Utf8Str::CaseInsensitive))
2951 )
2952 strResourceSubType = "AHCI";
2953 else
2954 throw setError(VBOX_E_NOT_SUPPORTED,
2955 tr("Invalid config string \"%s\" in SATA controller"), desc.strVbox.c_str());
2956
2957 // remember this ID
2958 idSATAController = ulInstanceID;
2959 lSATAControllerIndex = lIndexThis;
2960 }
2961 break;
2962
2963 case VirtualSystemDescriptionType_HardDiskControllerSCSI:
2964 /* <Item>
2965 <rasd:Caption>scsiController0</rasd:Caption>
2966 <rasd:Description>SCSI Controller</rasd:Description>
2967 <rasd:InstanceId>4</rasd:InstanceId>
2968 <rasd:ResourceType>6</rasd:ResourceType>
2969 <rasd:ResourceSubType>buslogic</rasd:ResourceSubType>
2970 <rasd:Address>0</rasd:Address>
2971 <rasd:BusNumber>0</rasd:BusNumber>
2972 </Item>
2973 */
2974 if (uLoop == 1)
2975 {
2976 strDescription = "SCSI Controller";
2977 strCaption = "scsiController0";
2978 type = OVFResourceType_ParallelSCSIHBA; // 6
2979 // it seems that OVFTool always writes these two, and since we can only
2980 // have one SATA controller, we'll use this as well
2981 lAddress = 0;
2982 lBusNumber = 0;
2983
2984 if ( desc.strVbox.isEmpty() // LsiLogic is the default in VirtualBox
2985 || (!desc.strVbox.compare("lsilogic", Utf8Str::CaseInsensitive))
2986 )
2987 strResourceSubType = "lsilogic";
2988 else if (!desc.strVbox.compare("buslogic", Utf8Str::CaseInsensitive))
2989 strResourceSubType = "buslogic";
2990 else
2991 throw setError(VBOX_E_NOT_SUPPORTED,
2992 tr("Invalid config string \"%s\" in SCSI controller"), desc.strVbox.c_str());
2993
2994 // remember this ID
2995 idSCSIController = ulInstanceID;
2996 lSCSIControllerIndex = lIndexThis;
2997 }
2998 break;
2999
3000 case VirtualSystemDescriptionType_HardDiskImage:
3001 /* <Item>
3002 <rasd:Caption>disk1</rasd:Caption>
3003 <rasd:InstanceId>8</rasd:InstanceId>
3004 <rasd:ResourceType>17</rasd:ResourceType>
3005 <rasd:HostResource>/disk/vmdisk1</rasd:HostResource>
3006 <rasd:Parent>4</rasd:Parent>
3007 <rasd:AddressOnParent>0</rasd:AddressOnParent>
3008 </Item> */
3009 if (uLoop == 2)
3010 {
3011 Utf8Str strDiskID = Utf8StrFmt("vmdisk%RI32", ++cDisks);
3012
3013 strDescription = "Disk Image";
3014 strCaption = Utf8StrFmt("disk%RI32", cDisks); // this is not used for anything else
3015 type = OVFResourceType_HardDisk; // 17
3016
3017 // the following references the "<Disks>" XML block
3018 strHostResource = Utf8StrFmt("/disk/%s", strDiskID.c_str());
3019
3020 // controller=<index>;channel=<c>
3021 size_t pos1 = desc.strExtraConfig.find("controller=");
3022 size_t pos2 = desc.strExtraConfig.find("channel=");
3023 if (pos1 != Utf8Str::npos)
3024 {
3025 int32_t lControllerIndex = -1;
3026 RTStrToInt32Ex(desc.strExtraConfig.c_str() + pos1 + 11, NULL, 0, &lControllerIndex);
3027 if (lControllerIndex == lIDEControllerIndex)
3028 ulParent = idIDEController;
3029 else if (lControllerIndex == lSCSIControllerIndex)
3030 ulParent = idSCSIController;
3031 else if (lControllerIndex == lSATAControllerIndex)
3032 ulParent = idSATAController;
3033 }
3034 if (pos2 != Utf8Str::npos)
3035 RTStrToInt32Ex(desc.strExtraConfig.c_str() + pos2 + 8, NULL, 0, &lAddressOnParent);
3036
3037 if ( !ulParent
3038 || lAddressOnParent == -1
3039 )
3040 throw setError(VBOX_E_NOT_SUPPORTED,
3041 tr("Missing or bad extra config string in hard disk image: \"%s\""), desc.strExtraConfig.c_str());
3042
3043 mapDisks[strDiskID] = &desc;
3044 }
3045 break;
3046
3047 case VirtualSystemDescriptionType_Floppy:
3048 if (uLoop == 1)
3049 {
3050 strDescription = "Floppy Drive";
3051 strCaption = "floppy0"; // this is what OVFTool writes
3052 type = OVFResourceType_FloppyDrive; // 14
3053 lAutomaticAllocation = 0;
3054 lAddressOnParent = 0; // this is what OVFTool writes
3055 }
3056 break;
3057
3058 case VirtualSystemDescriptionType_CDROM:
3059 if (uLoop == 2)
3060 {
3061 // we can't have a CD without an IDE controller
3062 if (!idIDEController)
3063 throw setError(VBOX_E_NOT_SUPPORTED,
3064 tr("Can't have CD-ROM without IDE controller"));
3065
3066 strDescription = "CD-ROM Drive";
3067 strCaption = "cdrom1"; // this is what OVFTool writes
3068 type = OVFResourceType_CDDrive; // 15
3069 lAutomaticAllocation = 1;
3070 ulParent = idIDEController;
3071 lAddressOnParent = 0; // this is what OVFTool writes
3072 }
3073 break;
3074
3075 case VirtualSystemDescriptionType_NetworkAdapter:
3076 /* <Item>
3077 <rasd:AutomaticAllocation>true</rasd:AutomaticAllocation>
3078 <rasd:Caption>Ethernet adapter on 'VM Network'</rasd:Caption>
3079 <rasd:Connection>VM Network</rasd:Connection>
3080 <rasd:ElementName>VM network</rasd:ElementName>
3081 <rasd:InstanceID>3</rasd:InstanceID>
3082 <rasd:ResourceType>10</rasd:ResourceType>
3083 </Item> */
3084 if (uLoop == 1)
3085 {
3086 lAutomaticAllocation = 1;
3087 strCaption = Utf8StrFmt("Ethernet adapter on '%s'", desc.strOvf.c_str());
3088 type = OVFResourceType_EthernetAdapter; // 10
3089 /* Set the hardware type to something useful.
3090 * To be compatible with vmware & others we set
3091 * PCNet32 for our PCNet types & E1000 for the
3092 * E1000 cards. */
3093 switch (desc.strVbox.toInt32())
3094 {
3095 case NetworkAdapterType_Am79C970A:
3096 case NetworkAdapterType_Am79C973: strResourceSubType = "PCNet32"; break;
3097#ifdef VBOX_WITH_E1000
3098 case NetworkAdapterType_I82540EM:
3099 case NetworkAdapterType_I82545EM:
3100 case NetworkAdapterType_I82543GC: strResourceSubType = "E1000"; break;
3101#endif /* VBOX_WITH_E1000 */
3102 }
3103 strConnection = desc.strOvf;
3104
3105 mapNetworks[desc.strOvf] = true;
3106 }
3107 break;
3108
3109 case VirtualSystemDescriptionType_USBController:
3110 /* <Item ovf:required="false">
3111 <rasd:Caption>usb</rasd:Caption>
3112 <rasd:Description>USB Controller</rasd:Description>
3113 <rasd:InstanceId>3</rasd:InstanceId>
3114 <rasd:ResourceType>23</rasd:ResourceType>
3115 <rasd:Address>0</rasd:Address>
3116 <rasd:BusNumber>0</rasd:BusNumber>
3117 </Item> */
3118 if (uLoop == 1)
3119 {
3120 strDescription = "USB Controller";
3121 strCaption = "usb";
3122 type = OVFResourceType_USBController; // 23
3123 lAddress = 0; // this is what OVFTool writes
3124 lBusNumber = 0; // this is what OVFTool writes
3125 }
3126 break;
3127
3128 case VirtualSystemDescriptionType_SoundCard:
3129 /* <Item ovf:required="false">
3130 <rasd:Caption>sound</rasd:Caption>
3131 <rasd:Description>Sound Card</rasd:Description>
3132 <rasd:InstanceId>10</rasd:InstanceId>
3133 <rasd:ResourceType>35</rasd:ResourceType>
3134 <rasd:ResourceSubType>ensoniq1371</rasd:ResourceSubType>
3135 <rasd:AutomaticAllocation>false</rasd:AutomaticAllocation>
3136 <rasd:AddressOnParent>3</rasd:AddressOnParent>
3137 </Item> */
3138 if (uLoop == 1)
3139 {
3140 strDescription = "Sound Card";
3141 strCaption = "sound";
3142 type = OVFResourceType_SoundCard; // 35
3143 strResourceSubType = desc.strOvf; // e.g. ensoniq1371
3144 lAutomaticAllocation = 0;
3145 lAddressOnParent = 3; // what gives? this is what OVFTool writes
3146 }
3147 break;
3148 }
3149
3150 if (type)
3151 {
3152 xml::ElementNode *pItem;
3153
3154 pItem = pelmVirtualHardwareSection->createChild("Item");
3155
3156 if (!strDescription.isEmpty())
3157 pItem->createChild("rasd:Description")->addContent(strDescription);
3158 if (!strCaption.isEmpty())
3159 pItem->createChild("rasd:Caption")->addContent(strCaption);
3160
3161 if (!strAllocationUnits.isEmpty())
3162 pItem->createChild("rasd:AllocationUnits")->addContent(strAllocationUnits);
3163
3164 if (lAutomaticAllocation != -1)
3165 pItem->createChild("rasd:AutomaticAllocation")->addContent( (lAutomaticAllocation) ? "true" : "false" );
3166
3167 if (!strConnection.isEmpty())
3168 pItem->createChild("rasd:Connection")->addContent(strConnection);
3169
3170 // <rasd:InstanceID>1</rasd:InstanceID>
3171 pItem->createChild("rasd:InstanceID")->addContent(Utf8StrFmt("%d", ulInstanceID));
3172 ++ulInstanceID;
3173
3174 // <rasd:ResourceType>3</rasd:ResourceType>
3175 pItem->createChild("rasd:ResourceType")->addContent(Utf8StrFmt("%d", type));
3176 if (!strResourceSubType.isEmpty())
3177 pItem->createChild("rasd:ResourceSubType")->addContent(strResourceSubType);
3178
3179 // <rasd:VirtualQuantity>1</rasd:VirtualQuantity>
3180 if (lVirtualQuantity != -1)
3181 pItem->createChild("rasd:VirtualQuantity")->addContent(Utf8StrFmt("%d", lVirtualQuantity));
3182
3183 if (lAddress != -1)
3184 pItem->createChild("rasd:Address")->addContent(Utf8StrFmt("%d", lAddress));
3185
3186 if (lBusNumber != -1)
3187 pItem->createChild("rasd:BusNumber")->addContent(Utf8StrFmt("%d", lBusNumber));
3188
3189 if (ulParent)
3190 pItem->createChild("rasd:Parent")->addContent(Utf8StrFmt("%d", ulParent));
3191 if (lAddressOnParent != -1)
3192 pItem->createChild("rasd:AddressOnParent")->addContent(Utf8StrFmt("%d", lAddressOnParent));
3193
3194 if (!strHostResource.isEmpty())
3195 pItem->createChild("rasd:HostResource")->addContent(strHostResource);
3196 }
3197 }
3198 } // for (size_t uLoop = 0; ...
3199 }
3200
3201 // finally, fill in the network section we set up empty above according
3202 // to the networks we found with the hardware items
3203 map<Utf8Str, bool>::const_iterator itN;
3204 for (itN = mapNetworks.begin();
3205 itN != mapNetworks.end();
3206 ++itN)
3207 {
3208 const Utf8Str &strNetwork = itN->first;
3209 xml::ElementNode *pelmNetwork = pelmNetworkSection->createChild("Network");
3210 pelmNetwork->setAttribute("ovf:name", strNetwork.c_str());
3211 pelmNetwork->createChild("Description")->addContent("Logical network used by this appliance.");
3212 }
3213
3214 map<Utf8Str, const VirtualSystemDescriptionEntry*>::const_iterator itS;
3215 uint32_t ulFile = 1;
3216 for (itS = mapDisks.begin();
3217 itS != mapDisks.end();
3218 ++itS)
3219 {
3220 const Utf8Str &strDiskID = itS->first;
3221 const VirtualSystemDescriptionEntry *pDiskEntry = itS->second;
3222
3223 // source path: where the VBox image is
3224 const Utf8Str &strSrcFilePath = pDiskEntry->strVbox;
3225 Bstr bstrSrcFilePath(strSrcFilePath);
3226 if (!RTPathExists(strSrcFilePath.c_str()))
3227 /* This isn't allowed */
3228 throw setError(VBOX_E_FILE_ERROR,
3229 tr("Source virtual disk image file '%s' doesn't exist"),
3230 strSrcFilePath.c_str());
3231
3232 // output filename
3233 const Utf8Str &strTargetFileNameOnly = pDiskEntry->strOvf;
3234 // target path needs to be composed from where the output OVF is
3235 Utf8Str strTargetFilePath = stripFilename(pAppliance->m->strPath);
3236 strTargetFilePath.append("/");
3237 strTargetFilePath.append(strTargetFileNameOnly);
3238
3239 // clone the disk:
3240 ComPtr<IHardDisk> pSourceDisk;
3241 ComPtr<IHardDisk> pTargetDisk;
3242 ComPtr<IProgress> pProgress2;
3243
3244 Log(("Finding source disk \"%ls\"\n", bstrSrcFilePath.raw()));
3245 rc = pVirtualBox->FindHardDisk(bstrSrcFilePath, pSourceDisk.asOutParam());
3246 if (FAILED(rc)) throw rc;
3247
3248 /* We are always exporting to vmdfk stream optimized for now */
3249 Bstr bstrSrcFormat = L"VMDK";
3250
3251 // create a new hard disk interface for the destination disk image
3252 Log(("Creating target disk \"%s\"\n", strTargetFilePath.raw()));
3253 rc = pVirtualBox->CreateHardDisk(bstrSrcFormat, Bstr(strTargetFilePath), pTargetDisk.asOutParam());
3254 if (FAILED(rc)) throw rc;
3255
3256 // the target disk is now registered and needs to be removed again,
3257 // both after successful cloning or if anything goes bad!
3258 try
3259 {
3260 // create a flat copy of the source disk image
3261 rc = pSourceDisk->CloneTo(pTargetDisk, HardDiskVariant_VmdkStreamOptimized, NULL, pProgress2.asOutParam());
3262 if (FAILED(rc)) throw rc;
3263
3264 // advance to the next operation
3265 if (!task->progress.isNull())
3266 task->progress->setNextOperation(BstrFmt(tr("Exporting virtual disk image '%s'"), strSrcFilePath.c_str()),
3267 pDiskEntry->ulSizeMB); // operation's weight, as set up with the IProgress originally);
3268
3269 // now wait for the background disk operation to complete; this throws HRESULTs on error
3270 pAppliance->waitForAsyncProgress(task->progress, pProgress2);
3271 }
3272 catch (HRESULT rc3)
3273 {
3274 // upon error after registering, close the disk or
3275 // it'll stick in the registry forever
3276 pTargetDisk->Close();
3277 throw rc3;
3278 }
3279
3280 // we need the following for the XML
3281 uint64_t cbFile = 0; // actual file size
3282 rc = pTargetDisk->COMGETTER(Size)(&cbFile);
3283 if (FAILED(rc)) throw rc;
3284
3285 ULONG64 cbCapacity = 0; // size reported to guest
3286 rc = pTargetDisk->COMGETTER(LogicalSize)(&cbCapacity);
3287 if (FAILED(rc)) throw rc;
3288 // capacity is reported in megabytes, so...
3289 cbCapacity *= _1M;
3290
3291 // upon success, close the disk as well
3292 rc = pTargetDisk->Close();
3293 if (FAILED(rc)) throw rc;
3294
3295 // now handle the XML for the disk:
3296 Utf8StrFmt strFileRef("file%RI32", ulFile++);
3297 // <File ovf:href="WindowsXpProfessional-disk1.vmdk" ovf:id="file1" ovf:size="1710381056"/>
3298 xml::ElementNode *pelmFile = pelmReferences->createChild("File");
3299 pelmFile->setAttribute("ovf:href", strTargetFileNameOnly);
3300 pelmFile->setAttribute("ovf:id", strFileRef);
3301 pelmFile->setAttribute("ovf:size", Utf8StrFmt("%RI64", cbFile).c_str());
3302
3303 // add disk to XML Disks section
3304 // <Disk ovf:capacity="8589934592" ovf:diskId="vmdisk1" ovf:fileRef="file1" ovf:format="http://www.vmware.com/specifications/vmdk.html#sparse"/>
3305 xml::ElementNode *pelmDisk = pelmDiskSection->createChild("Disk");
3306 pelmDisk->setAttribute("ovf:capacity", Utf8StrFmt("%RI64", cbCapacity).c_str());
3307 pelmDisk->setAttribute("ovf:diskId", strDiskID);
3308 pelmDisk->setAttribute("ovf:fileRef", strFileRef);
3309 pelmDisk->setAttribute("ovf:format", "http://www.vmware.com/specifications/vmdk.html#compressed");
3310 }
3311
3312 // now go write the XML
3313 xml::XmlFileWriter writer(doc);
3314 writer.write(pAppliance->m->strPath.c_str());
3315 }
3316 catch(xml::Error &x)
3317 {
3318 rc = setError(VBOX_E_FILE_ERROR,
3319 x.what());
3320 }
3321 catch(HRESULT aRC)
3322 {
3323 rc = aRC;
3324 }
3325
3326 task->rc = rc;
3327
3328 if (!task->progress.isNull())
3329 task->progress->notifyComplete(rc);
3330
3331 LogFlowFunc(("rc=%Rhrc\n", rc));
3332 LogFlowFuncLeave();
3333
3334 return VINF_SUCCESS;
3335}
3336
3337/**
3338* Public method implementation.
3339 * @return
3340 */
3341STDMETHODIMP Appliance::GetWarnings(ComSafeArrayOut(BSTR, aWarnings))
3342{
3343 if (ComSafeArrayOutIsNull(aWarnings))
3344 return E_POINTER;
3345
3346 AutoCaller autoCaller(this);
3347 CheckComRCReturnRC(autoCaller.rc());
3348
3349 AutoReadLock alock(this);
3350
3351 com::SafeArray<BSTR> sfaWarnings(m->llWarnings.size());
3352
3353 list<Utf8Str>::const_iterator it;
3354 size_t i = 0;
3355 for (it = m->llWarnings.begin();
3356 it != m->llWarnings.end();
3357 ++it, ++i)
3358 {
3359 Bstr bstr = *it;
3360 bstr.cloneTo(&sfaWarnings[i]);
3361 }
3362
3363 sfaWarnings.detachTo(ComSafeArrayOutArg(aWarnings));
3364
3365 return S_OK;
3366}
3367
3368HRESULT Appliance::searchUniqueVMName(Utf8Str& aName) const
3369{
3370 IMachine *machine = NULL;
3371 char *tmpName = RTStrDup(aName.c_str());
3372 int i = 1;
3373 /* @todo: Maybe too cost-intensive; try to find a lighter way */
3374 while (mVirtualBox->FindMachine(Bstr(tmpName), &machine) != VBOX_E_OBJECT_NOT_FOUND)
3375 {
3376 RTStrFree(tmpName);
3377 RTStrAPrintf(&tmpName, "%s_%d", aName.c_str(), i);
3378 ++i;
3379 }
3380 aName = tmpName;
3381 RTStrFree(tmpName);
3382
3383 return S_OK;
3384}
3385
3386HRESULT Appliance::searchUniqueDiskImageFilePath(Utf8Str& aName) const
3387{
3388 IHardDisk *harddisk = NULL;
3389 char *tmpName = RTStrDup(aName.c_str());
3390 int i = 1;
3391 /* Check if the file exists or if a file with this path is registered
3392 * already */
3393 /* @todo: Maybe too cost-intensive; try to find a lighter way */
3394 while (RTPathExists(tmpName) ||
3395 mVirtualBox->FindHardDisk(Bstr(tmpName), &harddisk) != VBOX_E_OBJECT_NOT_FOUND)
3396 {
3397 RTStrFree(tmpName);
3398 char *tmpDir = RTStrDup(aName.c_str());
3399 RTPathStripFilename(tmpDir);;
3400 char *tmpFile = RTStrDup(RTPathFilename(aName.c_str()));
3401 RTPathStripExt(tmpFile);
3402 const char *tmpExt = RTPathExt(aName.c_str());
3403 RTStrAPrintf(&tmpName, "%s%c%s_%d%s", tmpDir, RTPATH_DELIMITER, tmpFile, i, tmpExt);
3404 RTStrFree(tmpFile);
3405 RTStrFree(tmpDir);
3406 ++i;
3407 }
3408 aName = tmpName;
3409 RTStrFree(tmpName);
3410
3411 return S_OK;
3412}
3413
3414/**
3415 * Sets up the given progress object so that it represents disk images accurately
3416 * during importMachines() and write().
3417 * @param pProgress
3418 * @param bstrDescription
3419 * @return
3420 */
3421HRESULT Appliance::setUpProgress(ComObjPtr<Progress> &pProgress, const Bstr &bstrDescription)
3422{
3423 HRESULT rc;
3424
3425 /* Create the progress object */
3426 pProgress.createObject();
3427
3428 // weigh the disk images according to their sizes
3429 uint32_t ulTotalMB = 0;
3430 uint32_t cDisks = 0;
3431 list< ComObjPtr<VirtualSystemDescription> >::const_iterator it;
3432 for (it = m->virtualSystemDescriptions.begin();
3433 it != m->virtualSystemDescriptions.end();
3434 ++it)
3435 {
3436 ComObjPtr<VirtualSystemDescription> vsdescThis = (*it);
3437 /* One for every hard disk of the Virtual System */
3438 std::list<VirtualSystemDescriptionEntry*> avsdeHDs = vsdescThis->findByType(VirtualSystemDescriptionType_HardDiskImage);
3439 std::list<VirtualSystemDescriptionEntry*>::const_iterator itH;
3440 for (itH = avsdeHDs.begin();
3441 itH != avsdeHDs.end();
3442 ++itH)
3443 {
3444 const VirtualSystemDescriptionEntry *pHD = *itH;
3445 ulTotalMB += pHD->ulSizeMB;
3446 ++cDisks;
3447 }
3448 }
3449
3450 ULONG cOperations = 1 + cDisks; // one op per disk plus 1 for the XML
3451
3452 ULONG ulTotalOperationsWeight;
3453 if (ulTotalMB)
3454 {
3455 m->ulWeightPerOperation = (ULONG)((double)ulTotalMB * 1 / 100); // use 1% of the progress for the XML
3456 ulTotalOperationsWeight = ulTotalMB + m->ulWeightPerOperation;
3457 }
3458 else
3459 {
3460 // no disks to export:
3461 ulTotalOperationsWeight = 1;
3462 m->ulWeightPerOperation = 1;
3463 }
3464
3465 Log(("Setting up progress object: ulTotalMB = %d, cDisks = %d, => cOperations = %d, ulTotalOperationsWeight = %d, m->ulWeightPerOperation = %d\n",
3466 ulTotalMB, cDisks, cOperations, ulTotalOperationsWeight, m->ulWeightPerOperation));
3467
3468 rc = pProgress->init(mVirtualBox, static_cast<IAppliance*>(this),
3469 bstrDescription,
3470 TRUE /* aCancelable */,
3471 cOperations, // ULONG cOperations,
3472 ulTotalOperationsWeight, // ULONG ulTotalOperationsWeight,
3473 bstrDescription, // CBSTR bstrFirstOperationDescription,
3474 m->ulWeightPerOperation); // ULONG ulFirstOperationWeight,
3475 return rc;
3476}
3477
3478/**
3479 * Called from the import and export background threads to synchronize the second
3480 * background disk thread's progress object with the current progress object so
3481 * that the user interface sees progress correctly and that cancel signals are
3482 * passed on to the second thread.
3483 * @param pProgressThis Progress object of the current thread.
3484 * @param pProgressAsync Progress object of asynchronous task running in background.
3485 */
3486void Appliance::waitForAsyncProgress(ComObjPtr<Progress> &pProgressThis,
3487 ComPtr<IProgress> &pProgressAsync)
3488{
3489 HRESULT rc;
3490
3491 // now loop until the asynchronous operation completes and then report its result
3492 BOOL fCompleted;
3493 BOOL fCanceled;
3494 ULONG currentPercent;
3495 while (SUCCEEDED(pProgressAsync->COMGETTER(Completed(&fCompleted))))
3496 {
3497 rc = pProgressThis->COMGETTER(Canceled)(&fCanceled);
3498 if (FAILED(rc)) throw rc;
3499 if (fCanceled)
3500 {
3501 pProgressAsync->Cancel();
3502 break;
3503 }
3504
3505 rc = pProgressAsync->COMGETTER(Percent(&currentPercent));
3506 if (FAILED(rc)) throw rc;
3507 if (!pProgressThis.isNull())
3508 pProgressThis->setCurrentOperationProgress(currentPercent);
3509 if (fCompleted)
3510 break;
3511
3512 /* Make sure the loop is not too tight */
3513 rc = pProgressAsync->WaitForCompletion(100);
3514 if (FAILED(rc)) throw rc;
3515 }
3516 // report result of asynchronous operation
3517 HRESULT vrc;
3518 rc = pProgressAsync->COMGETTER(ResultCode)(&vrc);
3519 if (FAILED(rc)) throw rc;
3520
3521
3522 // if the thread of the progress object has an error, then
3523 // retrieve the error info from there, or it'll be lost
3524 if (FAILED(vrc))
3525 {
3526 ProgressErrorInfo info(pProgressAsync);
3527 Utf8Str str(info.getText());
3528 const char *pcsz = str.c_str();
3529 HRESULT rc2 = setError(vrc, pcsz);
3530 throw rc2;
3531 }
3532}
3533
3534void Appliance::addWarning(const char* aWarning, ...)
3535{
3536 va_list args;
3537 va_start(args, aWarning);
3538 Utf8StrFmtVA str(aWarning, args);
3539 va_end(args);
3540 m->llWarnings.push_back(str);
3541}
3542
3543////////////////////////////////////////////////////////////////////////////////
3544//
3545// IVirtualSystemDescription constructor / destructor
3546//
3547////////////////////////////////////////////////////////////////////////////////
3548
3549DEFINE_EMPTY_CTOR_DTOR(VirtualSystemDescription)
3550struct shutup3 {};
3551
3552/**
3553 * COM initializer.
3554 * @return
3555 */
3556HRESULT VirtualSystemDescription::init()
3557{
3558 /* Enclose the state transition NotReady->InInit->Ready */
3559 AutoInitSpan autoInitSpan(this);
3560 AssertReturn(autoInitSpan.isOk(), E_FAIL);
3561
3562 /* Initialize data */
3563 m = new Data();
3564
3565 /* Confirm a successful initialization */
3566 autoInitSpan.setSucceeded();
3567 return S_OK;
3568}
3569
3570/**
3571* COM uninitializer.
3572*/
3573
3574void VirtualSystemDescription::uninit()
3575{
3576 delete m;
3577 m = NULL;
3578}
3579
3580////////////////////////////////////////////////////////////////////////////////
3581//
3582// IVirtualSystemDescription public methods
3583//
3584////////////////////////////////////////////////////////////////////////////////
3585
3586/**
3587 * Public method implementation.
3588 * @param
3589 * @return
3590 */
3591STDMETHODIMP VirtualSystemDescription::COMGETTER(Count)(ULONG *aCount)
3592{
3593 if (!aCount)
3594 return E_POINTER;
3595
3596 AutoCaller autoCaller(this);
3597 CheckComRCReturnRC(autoCaller.rc());
3598
3599 AutoReadLock alock(this);
3600
3601 *aCount = (ULONG)m->llDescriptions.size();
3602
3603 return S_OK;
3604}
3605
3606/**
3607 * Public method implementation.
3608 * @return
3609 */
3610STDMETHODIMP VirtualSystemDescription::GetDescription(ComSafeArrayOut(VirtualSystemDescriptionType_T, aTypes),
3611 ComSafeArrayOut(BSTR, aRefs),
3612 ComSafeArrayOut(BSTR, aOrigValues),
3613 ComSafeArrayOut(BSTR, aVboxValues),
3614 ComSafeArrayOut(BSTR, aExtraConfigValues))
3615{
3616 if (ComSafeArrayOutIsNull(aTypes) ||
3617 ComSafeArrayOutIsNull(aRefs) ||
3618 ComSafeArrayOutIsNull(aOrigValues) ||
3619 ComSafeArrayOutIsNull(aVboxValues) ||
3620 ComSafeArrayOutIsNull(aExtraConfigValues))
3621 return E_POINTER;
3622
3623 AutoCaller autoCaller(this);
3624 CheckComRCReturnRC(autoCaller.rc());
3625
3626 AutoReadLock alock(this);
3627
3628 ULONG c = (ULONG)m->llDescriptions.size();
3629 com::SafeArray<VirtualSystemDescriptionType_T> sfaTypes(c);
3630 com::SafeArray<BSTR> sfaRefs(c);
3631 com::SafeArray<BSTR> sfaOrigValues(c);
3632 com::SafeArray<BSTR> sfaVboxValues(c);
3633 com::SafeArray<BSTR> sfaExtraConfigValues(c);
3634
3635 list<VirtualSystemDescriptionEntry>::const_iterator it;
3636 size_t i = 0;
3637 for (it = m->llDescriptions.begin();
3638 it != m->llDescriptions.end();
3639 ++it, ++i)
3640 {
3641 const VirtualSystemDescriptionEntry &vsde = (*it);
3642
3643 sfaTypes[i] = vsde.type;
3644
3645 Bstr bstr = vsde.strRef;
3646 bstr.cloneTo(&sfaRefs[i]);
3647
3648 bstr = vsde.strOvf;
3649 bstr.cloneTo(&sfaOrigValues[i]);
3650
3651 bstr = vsde.strVbox;
3652 bstr.cloneTo(&sfaVboxValues[i]);
3653
3654 bstr = vsde.strExtraConfig;
3655 bstr.cloneTo(&sfaExtraConfigValues[i]);
3656 }
3657
3658 sfaTypes.detachTo(ComSafeArrayOutArg(aTypes));
3659 sfaRefs.detachTo(ComSafeArrayOutArg(aRefs));
3660 sfaOrigValues.detachTo(ComSafeArrayOutArg(aOrigValues));
3661 sfaVboxValues.detachTo(ComSafeArrayOutArg(aVboxValues));
3662 sfaExtraConfigValues.detachTo(ComSafeArrayOutArg(aExtraConfigValues));
3663
3664 return S_OK;
3665}
3666
3667/**
3668 * Public method implementation.
3669 * @return
3670 */
3671STDMETHODIMP VirtualSystemDescription::GetDescriptionByType(VirtualSystemDescriptionType_T aType,
3672 ComSafeArrayOut(VirtualSystemDescriptionType_T, aTypes),
3673 ComSafeArrayOut(BSTR, aRefs),
3674 ComSafeArrayOut(BSTR, aOrigValues),
3675 ComSafeArrayOut(BSTR, aVboxValues),
3676 ComSafeArrayOut(BSTR, aExtraConfigValues))
3677{
3678 if (ComSafeArrayOutIsNull(aTypes) ||
3679 ComSafeArrayOutIsNull(aRefs) ||
3680 ComSafeArrayOutIsNull(aOrigValues) ||
3681 ComSafeArrayOutIsNull(aVboxValues) ||
3682 ComSafeArrayOutIsNull(aExtraConfigValues))
3683 return E_POINTER;
3684
3685 AutoCaller autoCaller(this);
3686 CheckComRCReturnRC(autoCaller.rc());
3687
3688 AutoReadLock alock(this);
3689
3690 std::list<VirtualSystemDescriptionEntry*> vsd = findByType (aType);
3691 ULONG c = (ULONG)vsd.size();
3692 com::SafeArray<VirtualSystemDescriptionType_T> sfaTypes(c);
3693 com::SafeArray<BSTR> sfaRefs(c);
3694 com::SafeArray<BSTR> sfaOrigValues(c);
3695 com::SafeArray<BSTR> sfaVboxValues(c);
3696 com::SafeArray<BSTR> sfaExtraConfigValues(c);
3697
3698 list<VirtualSystemDescriptionEntry*>::const_iterator it;
3699 size_t i = 0;
3700 for (it = vsd.begin();
3701 it != vsd.end();
3702 ++it, ++i)
3703 {
3704 const VirtualSystemDescriptionEntry *vsde = (*it);
3705
3706 sfaTypes[i] = vsde->type;
3707
3708 Bstr bstr = vsde->strRef;
3709 bstr.cloneTo(&sfaRefs[i]);
3710
3711 bstr = vsde->strOvf;
3712 bstr.cloneTo(&sfaOrigValues[i]);
3713
3714 bstr = vsde->strVbox;
3715 bstr.cloneTo(&sfaVboxValues[i]);
3716
3717 bstr = vsde->strExtraConfig;
3718 bstr.cloneTo(&sfaExtraConfigValues[i]);
3719 }
3720
3721 sfaTypes.detachTo(ComSafeArrayOutArg(aTypes));
3722 sfaRefs.detachTo(ComSafeArrayOutArg(aRefs));
3723 sfaOrigValues.detachTo(ComSafeArrayOutArg(aOrigValues));
3724 sfaVboxValues.detachTo(ComSafeArrayOutArg(aVboxValues));
3725 sfaExtraConfigValues.detachTo(ComSafeArrayOutArg(aExtraConfigValues));
3726
3727 return S_OK;
3728}
3729
3730/**
3731 * Public method implementation.
3732 * @return
3733 */
3734STDMETHODIMP VirtualSystemDescription::GetValuesByType(VirtualSystemDescriptionType_T aType,
3735 VirtualSystemDescriptionValueType_T aWhich,
3736 ComSafeArrayOut(BSTR, aValues))
3737{
3738 if (ComSafeArrayOutIsNull(aValues))
3739 return E_POINTER;
3740
3741 AutoCaller autoCaller(this);
3742 CheckComRCReturnRC(autoCaller.rc());
3743
3744 AutoReadLock alock(this);
3745
3746 std::list<VirtualSystemDescriptionEntry*> vsd = findByType (aType);
3747 com::SafeArray<BSTR> sfaValues((ULONG)vsd.size());
3748
3749 list<VirtualSystemDescriptionEntry*>::const_iterator it;
3750 size_t i = 0;
3751 for (it = vsd.begin();
3752 it != vsd.end();
3753 ++it, ++i)
3754 {
3755 const VirtualSystemDescriptionEntry *vsde = (*it);
3756
3757 Bstr bstr;
3758 switch (aWhich)
3759 {
3760 case VirtualSystemDescriptionValueType_Reference: bstr = vsde->strRef; break;
3761 case VirtualSystemDescriptionValueType_Original: bstr = vsde->strOvf; break;
3762 case VirtualSystemDescriptionValueType_Auto: bstr = vsde->strVbox; break;
3763 case VirtualSystemDescriptionValueType_ExtraConfig: bstr = vsde->strExtraConfig; break;
3764 }
3765
3766 bstr.cloneTo(&sfaValues[i]);
3767 }
3768
3769 sfaValues.detachTo(ComSafeArrayOutArg(aValues));
3770
3771 return S_OK;
3772}
3773
3774/**
3775 * Public method implementation.
3776 * @return
3777 */
3778STDMETHODIMP VirtualSystemDescription::SetFinalValues(ComSafeArrayIn(BOOL, aEnabled),
3779 ComSafeArrayIn(IN_BSTR, argVboxValues),
3780 ComSafeArrayIn(IN_BSTR, argExtraConfigValues))
3781{
3782#ifndef RT_OS_WINDOWS
3783 NOREF(aEnabledSize);
3784#endif /* RT_OS_WINDOWS */
3785
3786 CheckComArgSafeArrayNotNull(aEnabled);
3787 CheckComArgSafeArrayNotNull(argVboxValues);
3788 CheckComArgSafeArrayNotNull(argExtraConfigValues);
3789
3790 AutoCaller autoCaller(this);
3791 CheckComRCReturnRC(autoCaller.rc());
3792
3793 AutoWriteLock alock(this);
3794
3795 com::SafeArray<BOOL> sfaEnabled(ComSafeArrayInArg(aEnabled));
3796 com::SafeArray<IN_BSTR> sfaVboxValues(ComSafeArrayInArg(argVboxValues));
3797 com::SafeArray<IN_BSTR> sfaExtraConfigValues(ComSafeArrayInArg(argExtraConfigValues));
3798
3799 if ( (sfaEnabled.size() != m->llDescriptions.size())
3800 || (sfaVboxValues.size() != m->llDescriptions.size())
3801 || (sfaExtraConfigValues.size() != m->llDescriptions.size())
3802 )
3803 return E_INVALIDARG;
3804
3805 list<VirtualSystemDescriptionEntry>::iterator it;
3806 size_t i = 0;
3807 for (it = m->llDescriptions.begin();
3808 it != m->llDescriptions.end();
3809 ++it, ++i)
3810 {
3811 VirtualSystemDescriptionEntry& vsde = *it;
3812
3813 if (sfaEnabled[i])
3814 {
3815 vsde.strVbox = sfaVboxValues[i];
3816 vsde.strExtraConfig = sfaExtraConfigValues[i];
3817 }
3818 else
3819 vsde.type = VirtualSystemDescriptionType_Ignore;
3820 }
3821
3822 return S_OK;
3823}
3824
3825/**
3826 * Public method implementation.
3827 * @return
3828 */
3829STDMETHODIMP VirtualSystemDescription::AddDescription(VirtualSystemDescriptionType_T aType,
3830 IN_BSTR aVboxValue,
3831 IN_BSTR aExtraConfigValue)
3832{
3833 CheckComArgNotNull(aVboxValue);
3834 CheckComArgNotNull(aExtraConfigValue);
3835
3836 AutoCaller autoCaller(this);
3837 CheckComRCReturnRC(autoCaller.rc());
3838
3839 AutoWriteLock alock(this);
3840
3841 addEntry(aType, "", aVboxValue, aVboxValue, 0, aExtraConfigValue);
3842
3843 return S_OK;
3844}
3845
3846/**
3847 * Internal method; adds a new description item to the member list.
3848 * @param aType Type of description for the new item.
3849 * @param strRef Reference item; only used with hard disk controllers.
3850 * @param aOrigValue Corresponding original value from OVF.
3851 * @param aAutoValue Initial configuration value (can be overridden by caller with setFinalValues).
3852 * @param strExtraConfig Extra configuration; meaning dependent on type.
3853 */
3854void VirtualSystemDescription::addEntry(VirtualSystemDescriptionType_T aType,
3855 const Utf8Str &strRef,
3856 const Utf8Str &aOrigValue,
3857 const Utf8Str &aAutoValue,
3858 uint32_t ulSizeMB,
3859 const Utf8Str &strExtraConfig /*= ""*/)
3860{
3861 VirtualSystemDescriptionEntry vsde;
3862 vsde.ulIndex = (uint32_t)m->llDescriptions.size(); // each entry gets an index so the client side can reference them
3863 vsde.type = aType;
3864 vsde.strRef = strRef;
3865 vsde.strOvf = aOrigValue;
3866 vsde.strVbox = aAutoValue;
3867 vsde.strExtraConfig = strExtraConfig;
3868 vsde.ulSizeMB = ulSizeMB;
3869
3870 m->llDescriptions.push_back(vsde);
3871}
3872
3873/**
3874 * Private method; returns a list of description items containing all the items from the member
3875 * description items of this virtual system that match the given type.
3876 * @param aType
3877 * @return
3878 */
3879std::list<VirtualSystemDescriptionEntry*> VirtualSystemDescription::findByType(VirtualSystemDescriptionType_T aType)
3880{
3881 std::list<VirtualSystemDescriptionEntry*> vsd;
3882
3883 list<VirtualSystemDescriptionEntry>::iterator it;
3884 for (it = m->llDescriptions.begin();
3885 it != m->llDescriptions.end();
3886 ++it)
3887 {
3888 if (it->type == aType)
3889 vsd.push_back(&(*it));
3890 }
3891
3892 return vsd;
3893}
3894
3895/**
3896 * Private method; looks thru the member hardware items for the IDE, SATA, or SCSI controller with
3897 * the given reference ID. Useful when needing the controller for a particular
3898 * virtual disk.
3899 * @param id
3900 * @return
3901 */
3902const VirtualSystemDescriptionEntry* VirtualSystemDescription::findControllerFromID(uint32_t id)
3903{
3904 Utf8Str strRef = Utf8StrFmt("%RI32", id);
3905 list<VirtualSystemDescriptionEntry>::const_iterator it;
3906 for (it = m->llDescriptions.begin();
3907 it != m->llDescriptions.end();
3908 ++it)
3909 {
3910 const VirtualSystemDescriptionEntry &d = *it;
3911 switch (d.type)
3912 {
3913 case VirtualSystemDescriptionType_HardDiskControllerIDE:
3914 case VirtualSystemDescriptionType_HardDiskControllerSATA:
3915 case VirtualSystemDescriptionType_HardDiskControllerSCSI:
3916 if (d.strRef == strRef)
3917 return &d;
3918 break;
3919 }
3920 }
3921
3922 return NULL;
3923}
3924
3925////////////////////////////////////////////////////////////////////////////////
3926//
3927// IMachine public methods
3928//
3929////////////////////////////////////////////////////////////////////////////////
3930
3931// This code is here so we won't have to include the appliance headers in the
3932// IMachine implementation, and we also need to access private appliance data.
3933
3934/**
3935* Public method implementation.
3936* @param appliance
3937* @return
3938*/
3939
3940STDMETHODIMP Machine::Export(IAppliance *aAppliance, IVirtualSystemDescription **aDescription)
3941{
3942 HRESULT rc = S_OK;
3943
3944 if (!aAppliance)
3945 return E_POINTER;
3946
3947 AutoCaller autoCaller(this);
3948 CheckComRCReturnRC(autoCaller.rc());
3949
3950 AutoReadLock alock(this);
3951
3952 ComObjPtr<VirtualSystemDescription> pNewDesc;
3953
3954 try
3955 {
3956 Bstr bstrName;
3957 Bstr bstrDescription;
3958 Bstr bstrGuestOSType;
3959 uint32_t cCPUs;
3960 uint32_t ulMemSizeMB;
3961 BOOL fDVDEnabled;
3962 BOOL fFloppyEnabled;
3963 BOOL fUSBEnabled;
3964 BOOL fAudioEnabled;
3965 AudioControllerType_T audioController;
3966
3967 ComPtr<IUSBController> pUsbController;
3968 ComPtr<IAudioAdapter> pAudioAdapter;
3969
3970 // get name
3971 bstrName = mUserData->mName;
3972 // get description
3973 bstrDescription = mUserData->mDescription;
3974 // get guest OS
3975 bstrGuestOSType = mUserData->mOSTypeId;
3976 // CPU count
3977 cCPUs = mHWData->mCPUCount;
3978 // memory size in MB
3979 ulMemSizeMB = mHWData->mMemorySize;
3980 // VRAM size?
3981 // BIOS settings?
3982 // 3D acceleration enabled?
3983 // hardware virtualization enabled?
3984 // nested paging enabled?
3985 // HWVirtExVPIDEnabled?
3986 // PAEEnabled?
3987 // snapshotFolder?
3988 // VRDPServer?
3989
3990 // floppy
3991 rc = mFloppyDrive->COMGETTER(Enabled)(&fFloppyEnabled);
3992 if (FAILED(rc)) throw rc;
3993
3994 // CD-ROM ?!?
3995 // ComPtr<IDVDDrive> pDVDDrive;
3996 fDVDEnabled = 1;
3997
3998 // this is more tricky so use the COM method
3999 rc = COMGETTER(USBController)(pUsbController.asOutParam());
4000 if (FAILED(rc)) throw rc;
4001 rc = pUsbController->COMGETTER(Enabled)(&fUSBEnabled);
4002
4003 pAudioAdapter = mAudioAdapter;
4004 rc = pAudioAdapter->COMGETTER(Enabled)(&fAudioEnabled);
4005 if (FAILED(rc)) throw rc;
4006 rc = pAudioAdapter->COMGETTER(AudioController)(&audioController);
4007 if (FAILED(rc)) throw rc;
4008
4009 // create a new virtual system
4010 rc = pNewDesc.createObject();
4011 CheckComRCThrowRC(rc);
4012 rc = pNewDesc->init();
4013 CheckComRCThrowRC(rc);
4014
4015 /* Guest OS type */
4016 Utf8Str strOsTypeVBox(bstrGuestOSType);
4017 CIMOSType_T cim = convertVBoxOSType2CIMOSType(strOsTypeVBox.c_str());
4018 pNewDesc->addEntry(VirtualSystemDescriptionType_OS,
4019 "",
4020 Utf8StrFmt("%RI32", cim),
4021 strOsTypeVBox);
4022
4023 /* VM name */
4024 Utf8Str strVMName(bstrName);
4025 pNewDesc->addEntry(VirtualSystemDescriptionType_Name,
4026 "",
4027 strVMName,
4028 strVMName);
4029
4030 // description
4031 Utf8Str strDescription(bstrDescription);
4032 pNewDesc->addEntry(VirtualSystemDescriptionType_Description,
4033 "",
4034 strDescription,
4035 strDescription);
4036
4037 /* CPU count*/
4038 Utf8Str strCpuCount = Utf8StrFmt("%RI32", cCPUs);
4039 pNewDesc->addEntry(VirtualSystemDescriptionType_CPU,
4040 "",
4041 strCpuCount,
4042 strCpuCount);
4043
4044 /* Memory */
4045 Utf8Str strMemory = Utf8StrFmt("%RI32", (uint64_t)ulMemSizeMB * _1M);
4046 pNewDesc->addEntry(VirtualSystemDescriptionType_Memory,
4047 "",
4048 strMemory,
4049 strMemory);
4050
4051 int32_t lIDEControllerIndex = 0;
4052 int32_t lSATAControllerIndex = 0;
4053 int32_t lSCSIControllerIndex = 0;
4054
4055// <const name="HardDiskControllerIDE" value="6" />
4056 ComPtr<IStorageController> pController;
4057 rc = GetStorageControllerByName(Bstr("IDE"), pController.asOutParam());
4058 if (FAILED(rc)) throw rc;
4059 Utf8Str strVbox;
4060 StorageControllerType_T ctlr;
4061 rc = pController->COMGETTER(ControllerType)(&ctlr);
4062 if (FAILED(rc)) throw rc;
4063 switch(ctlr)
4064 {
4065 case StorageControllerType_PIIX3: strVbox = "PIIX3"; break;
4066 case StorageControllerType_PIIX4: strVbox = "PIIX4"; break;
4067 case StorageControllerType_ICH6: strVbox = "ICH6"; break;
4068 }
4069
4070 if (strVbox.length())
4071 {
4072 lIDEControllerIndex = (int32_t)pNewDesc->m->llDescriptions.size();
4073 pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskControllerIDE,
4074 Utf8StrFmt("%d", lIDEControllerIndex),
4075 strVbox,
4076 strVbox);
4077 }
4078
4079#ifdef VBOX_WITH_AHCI
4080// <const name="HardDiskControllerSATA" value="7" />
4081 rc = GetStorageControllerByName(Bstr("SATA"), pController.asOutParam());
4082 if (SUCCEEDED(rc))
4083 {
4084 strVbox = "AHCI";
4085 lSATAControllerIndex = (int32_t)pNewDesc->m->llDescriptions.size();
4086 pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskControllerSATA,
4087 Utf8StrFmt("%d", lSATAControllerIndex),
4088 strVbox,
4089 strVbox);
4090 }
4091#endif // VBOX_WITH_AHCI
4092
4093// <const name="HardDiskControllerSCSI" value="8" />
4094 rc = GetStorageControllerByName(Bstr("SCSI"), pController.asOutParam());
4095 if (SUCCEEDED(rc))
4096 {
4097 rc = pController->COMGETTER(ControllerType)(&ctlr);
4098 if (SUCCEEDED(rc))
4099 {
4100 strVbox = "LsiLogic"; // the default in VBox
4101 switch(ctlr)
4102 {
4103 case StorageControllerType_LsiLogic: strVbox = "LsiLogic"; break;
4104 case StorageControllerType_BusLogic: strVbox = "BusLogic"; break;
4105 }
4106 lSCSIControllerIndex = (int32_t)pNewDesc->m->llDescriptions.size();
4107 pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskControllerSCSI,
4108 Utf8StrFmt("%d", lSCSIControllerIndex),
4109 strVbox,
4110 strVbox);
4111 }
4112 else
4113 throw rc;
4114 }
4115
4116// <const name="HardDiskImage" value="9" />
4117 HDData::AttachmentList::iterator itA;
4118 for (itA = mHDData->mAttachments.begin();
4119 itA != mHDData->mAttachments.end();
4120 ++itA)
4121 {
4122 ComObjPtr<HardDiskAttachment> pHDA = *itA;
4123
4124 // the attachment's data
4125 ComPtr<IHardDisk> pHardDisk;
4126 ComPtr<IStorageController> ctl;
4127 Bstr controllerName;
4128
4129 rc = pHDA->COMGETTER(Controller)(controllerName.asOutParam());
4130 if (FAILED(rc)) throw rc;
4131
4132 rc = GetStorageControllerByName(controllerName, ctl.asOutParam());
4133 if (FAILED(rc)) throw rc;
4134
4135 StorageBus_T storageBus;
4136 LONG lChannel;
4137 LONG lDevice;
4138
4139 rc = ctl->COMGETTER(Bus)(&storageBus);
4140 if (FAILED(rc)) throw rc;
4141
4142 rc = pHDA->COMGETTER(HardDisk)(pHardDisk.asOutParam());
4143 if (FAILED(rc)) throw rc;
4144
4145 rc = pHDA->COMGETTER(Port)(&lChannel);
4146 if (FAILED(rc)) throw rc;
4147
4148 rc = pHDA->COMGETTER(Device)(&lDevice);
4149 if (FAILED(rc)) throw rc;
4150
4151 Bstr bstrLocation;
4152 rc = pHardDisk->COMGETTER(Location)(bstrLocation.asOutParam());
4153 if (FAILED(rc)) throw rc;
4154 Bstr bstrName;
4155 rc = pHardDisk->COMGETTER(Name)(bstrName.asOutParam());
4156 if (FAILED(rc)) throw rc;
4157
4158 // force reading state, or else size will be returned as 0
4159 MediaState_T ms;
4160 rc = pHardDisk->COMGETTER(State)(&ms);
4161 if (FAILED(rc)) throw rc;
4162
4163 ULONG64 ullSize;
4164 rc = pHardDisk->COMGETTER(Size)(&ullSize);
4165 if (FAILED(rc)) throw rc;
4166
4167 // and how this translates to the virtual system
4168 int32_t lControllerVsys = 0;
4169 LONG lChannelVsys;
4170
4171 switch (storageBus)
4172 {
4173 case StorageBus_IDE:
4174 // this is the exact reverse to what we're doing in Appliance::taskThreadImportMachines,
4175 // and it must be updated when that is changed!
4176
4177 if (lChannel == 0 && lDevice == 0) // primary master
4178 lChannelVsys = 0;
4179 else if (lChannel == 0 && lDevice == 1) // primary slave
4180 lChannelVsys = 1;
4181 else if (lChannel == 1 && lDevice == 1) // secondary slave; secondary master is always CDROM
4182 lChannelVsys = 2;
4183 else
4184 throw setError(VBOX_E_NOT_SUPPORTED,
4185 tr("Cannot handle hard disk attachment: channel is %d, device is %d"), lChannel, lDevice);
4186
4187 lControllerVsys = lIDEControllerIndex;
4188 break;
4189
4190 case StorageBus_SATA:
4191 lChannelVsys = lChannel; // should be between 0 and 29
4192 lControllerVsys = lSATAControllerIndex;
4193 break;
4194
4195 case StorageBus_SCSI:
4196 lChannelVsys = lChannel; // should be between 0 and 15
4197 lControllerVsys = lSCSIControllerIndex;
4198 break;
4199
4200 default:
4201 throw setError(VBOX_E_NOT_SUPPORTED,
4202 tr("Cannot handle hard disk attachment: storageBus is %d, channel is %d, device is %d"), storageBus, lChannel, lDevice);
4203 break;
4204 }
4205
4206 Utf8Str strTargetVmdkName(bstrName);
4207 RTPathStripExt(strTargetVmdkName.mutableRaw());
4208 strTargetVmdkName.append(".vmdk");
4209
4210 pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskImage,
4211 strTargetVmdkName, // disk ID: let's use the name
4212 strTargetVmdkName, // OVF value:
4213 Utf8Str(bstrLocation), // vbox value: media path
4214 (uint32_t)(ullSize / _1M),
4215 Utf8StrFmt("controller=%RI32;channel=%RI32", lControllerVsys, lChannelVsys));
4216 }
4217
4218 /* Floppy Drive */
4219 if (fFloppyEnabled)
4220 pNewDesc->addEntry(VirtualSystemDescriptionType_Floppy, "", "", "");
4221
4222 /* CD Drive */
4223 if (fDVDEnabled)
4224 pNewDesc->addEntry(VirtualSystemDescriptionType_CDROM, "", "", "");
4225
4226// <const name="NetworkAdapter" />
4227 size_t a;
4228 for (a = 0;
4229 a < SchemaDefs::NetworkAdapterCount;
4230 ++a)
4231 {
4232 ComPtr<INetworkAdapter> pNetworkAdapter;
4233 BOOL fEnabled;
4234 NetworkAdapterType_T adapterType;
4235 NetworkAttachmentType_T attachmentType;
4236
4237 rc = GetNetworkAdapter((ULONG)a, pNetworkAdapter.asOutParam());
4238 if (FAILED(rc)) throw rc;
4239 /* Enable the network card & set the adapter type */
4240 rc = pNetworkAdapter->COMGETTER(Enabled)(&fEnabled);
4241 if (FAILED(rc)) throw rc;
4242
4243 if (fEnabled)
4244 {
4245 Utf8Str strAttachmentType;
4246
4247 rc = pNetworkAdapter->COMGETTER(AdapterType)(&adapterType);
4248 if (FAILED(rc)) throw rc;
4249
4250 rc = pNetworkAdapter->COMGETTER(AttachmentType)(&attachmentType);
4251 if (FAILED(rc)) throw rc;
4252
4253 switch (attachmentType)
4254 {
4255 case NetworkAttachmentType_Null:
4256 strAttachmentType = "Null";
4257 break;
4258
4259 case NetworkAttachmentType_NAT:
4260 strAttachmentType = "NAT";
4261 break;
4262
4263 case NetworkAttachmentType_Bridged:
4264 strAttachmentType = "Bridged";
4265 break;
4266
4267 case NetworkAttachmentType_Internal:
4268 strAttachmentType = "Internal";
4269 break;
4270
4271 case NetworkAttachmentType_HostOnly:
4272 strAttachmentType = "HostOnly";
4273 break;
4274 }
4275
4276 pNewDesc->addEntry(VirtualSystemDescriptionType_NetworkAdapter,
4277 "", // ref
4278 strAttachmentType, // orig
4279 Utf8StrFmt("%RI32", (uint32_t)adapterType), // conf
4280 Utf8StrFmt("type=%s", strAttachmentType.c_str())); // extra conf
4281 }
4282 }
4283
4284// <const name="USBController" />
4285#ifdef VBOX_WITH_USB
4286 if (fUSBEnabled)
4287 pNewDesc->addEntry(VirtualSystemDescriptionType_USBController, "", "", "");
4288#endif /* VBOX_WITH_USB */
4289
4290// <const name="SoundCard" />
4291 if (fAudioEnabled)
4292 {
4293 pNewDesc->addEntry(VirtualSystemDescriptionType_SoundCard,
4294 "",
4295 "ensoniq1371", // this is what OVFTool writes and VMware supports
4296 Utf8StrFmt("%RI32", audioController));
4297 }
4298
4299 // finally, add the virtual system to the appliance
4300 Appliance *pAppliance = static_cast<Appliance*>(aAppliance);
4301 AutoCaller autoCaller1(pAppliance);
4302 CheckComRCReturnRC(autoCaller1.rc());
4303
4304 /* We return the new description to the caller */
4305 ComPtr<IVirtualSystemDescription> copy(pNewDesc);
4306 copy.queryInterfaceTo(aDescription);
4307
4308 AutoWriteLock alock(pAppliance);
4309
4310 pAppliance->m->virtualSystemDescriptions.push_back(pNewDesc);
4311 }
4312 catch(HRESULT arc)
4313 {
4314 rc = arc;
4315 }
4316
4317 return rc;
4318}
4319
4320/* vi: set tabstop=4 shiftwidth=4 expandtab: */
Note: See TracBrowser for help on using the repository browser.

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