VirtualBox

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

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

OVF: partial implementation of write support in XML classes.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 120.3 KB
Line 
1/* $Id: ApplianceImpl.cpp 17362 2009-03-04 18:10:58Z 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 <iprt/stream.h>
24#include <iprt/path.h>
25#include <iprt/dir.h>
26#include <iprt/file.h>
27
28#include "ApplianceImpl.h"
29#include "VirtualBoxImpl.h"
30#include "GuestOSTypeImpl.h"
31#include "ProgressImpl.h"
32#include "MachineImpl.h"
33
34#include "Logging.h"
35
36#include "VBox/xml.h"
37
38using namespace std;
39
40// defines
41////////////////////////////////////////////////////////////////////////////////
42
43struct DiskImage
44{
45 Utf8Str strDiskId; // value from DiskSection/Disk/@diskId
46 int64_t iCapacity; // value from DiskSection/Disk/@capacity;
47 // (maximum size for dynamic images, I guess; we always translate this to bytes)
48 int64_t iPopulatedSize; // value from DiskSection/Disk/@populatedSize
49 // (actual used size of disk, always in bytes; can be an estimate of used disk
50 // space, but cannot be larger than iCapacity)
51 Utf8Str strFormat; // value from DiskSection/Disk/@format
52 // typically http://www.vmware.com/specifications/vmdk.html#sparse
53
54 // fields from /References/File; the spec says the file reference from disk can be empty,
55 // so in that case, strFilename will be empty, then a new disk should be created
56 Utf8Str strHref; // value from /References/File/@href (filename); if empty, then the remaining fields are ignored
57 int64_t iSize; // value from /References/File/@size (optional according to spec; then we set -1 here)
58 int64_t iChunkSize; // value from /References/File/@chunkSize (optional, unsupported)
59 Utf8Str strCompression; // value from /References/File/@compression (optional, can be "gzip" according to spec)
60};
61
62struct Network
63{
64 Utf8Str strNetworkName; // value from NetworkSection/Network/@name
65 // unfortunately the OVF spec is unspecific about how networks should be specified further
66};
67
68struct VirtualHardwareItem
69{
70 Utf8Str strDescription;
71 Utf8Str strCaption;
72 Utf8Str strElementName;
73
74 uint32_t ulInstanceID;
75 uint32_t ulParent;
76
77 OVFResourceType_T resourceType;
78 Utf8Str strOtherResourceType;
79 Utf8Str strResourceSubType;
80
81 Utf8Str strHostResource; // "Abstractly specifies how a device shall connect to a resource on the deployment platform.
82 // Not all devices need a backing." Used with disk items, for which this references a virtual
83 // disk from the Disks section.
84 bool fAutomaticAllocation;
85 bool fAutomaticDeallocation;
86 Utf8Str strConnection; // "All Ethernet adapters that specify the same abstract network connection name within an OVF
87 // package shall be deployed on the same network. The abstract network connection name shall be
88 // listed in the NetworkSection at the outermost envelope level."
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;
110typedef map<Utf8Str, Network> NetworksMap;
111
112struct VirtualSystem;
113
114// opaque private instance data of Appliance class
115struct Appliance::Data
116{
117 Utf8Str strPath; // file name last given to either read() or write()
118
119 DiskImagesMap mapDisks; // map of DiskImage structs, sorted by DiskImage.strDiskId
120
121 NetworksMap mapNetworks; // map of Network structs, sorted by Network.strNetworkName
122
123 list<VirtualSystem> llVirtualSystems;
124
125 list< ComObjPtr<VirtualSystemDescription> > virtualSystemDescriptions;
126};
127
128typedef map<uint32_t, VirtualHardwareItem> HardwareItemsMap;
129
130struct HardDiskController
131{
132 uint32_t idController; // instance ID (Item/InstanceId); this gets referenced from HardDisk
133 enum ControllerSystemType { IDE, SATA, SCSI };
134 ControllerSystemType system; // one of IDE, SATA, SCSI
135 Utf8Str strControllerType; // controller subtype (Item/ResourceSubType); e.g. "LsiLogic"; can be empty (esp. for IDE)
136 Utf8Str strAddress; // for IDE
137 uint32_t ulBusNumber; // for IDE
138
139 HardDiskController()
140 : idController(0),
141 ulBusNumber(0)
142 {
143 }
144};
145
146typedef map<uint32_t, HardDiskController> ControllersMap;
147
148struct VirtualDisk
149{
150 uint32_t idController; // SCSI (or IDE) controller this disk is connected to;
151 // points into VirtualSystem.mapControllers
152 uint32_t ulAddressOnParent; // parsed strAddressOnParent of hardware item; will be 0 or 1 for IDE
153 // and possibly higher for disks attached to SCSI controllers (untested)
154 Utf8Str strDiskId; // if the hard disk has an ovf:/disk/<id> reference,
155 // this receives the <id> component; points to one of the
156 // references in Appliance::Data.mapDisks
157};
158
159typedef map<Utf8Str, VirtualDisk> VirtualDisksMap;
160
161struct VirtualSystem
162{
163 Utf8Str strName; // copy of VirtualSystem/@id
164
165 CIMOSType_T cimos;
166 Utf8Str strVirtualSystemType; // generic hardware description; OVF says this can be something like "vmx-4" or "xen";
167 // VMware Workstation 6.5 is "vmx-07"
168
169 HardwareItemsMap mapHardwareItems; // map of virtual hardware items, sorted by unique instance ID
170
171 uint64_t ullMemorySize; // always in bytes, copied from llHardwareItems; default = 0 (unspecified)
172 uint16_t cCPUs; // no. of CPUs, copied from llHardwareItems; default = 1
173
174 list<Utf8Str> llNetworkNames;
175 // list of strings referring to network names
176 // (one for each VirtualSystem/Item[@ResourceType=10]/Connection element)
177
178 ControllersMap mapControllers;
179 // list of hard disk controllers
180 // (one for each VirtualSystem/Item[@ResourceType=6] element with accumulated data from children)
181
182 VirtualDisksMap mapVirtualDisks;
183 // (one for each VirtualSystem/Item[@ResourceType=17] element with accumulated data from children)
184
185 bool fHasFloppyDrive; // true if there's a floppy item in mapHardwareItems
186 bool fHasCdromDrive; // true if there's a CD-ROM item in mapHardwareItems; ISO images are not yet supported by OVFtool
187 bool fHasUsbController; // true if there's a USB controller item in mapHardwareItems
188
189 Utf8Str strSoundCardType; // if not empty, then the system wants a soundcard; this then specifies the hardware;
190 // VMware Workstation 6.5 uses "ensoniq1371" for example
191
192 Utf8Str strLicenceInfo; // license info if any; receives contents of VirtualSystem/EulaSection/Info
193 Utf8Str strLicenceText; // license info if any; receives contents of VirtualSystem/EulaSection/License
194
195 VirtualSystem()
196 : ullMemorySize(0), cCPUs(1), fHasFloppyDrive(false), fHasCdromDrive(false), fHasUsbController(false)
197 {
198 }
199};
200
201struct Appliance::TaskImportMachines
202{
203 TaskImportMachines(Appliance *aThat, Progress *aProgress)
204 : pAppliance(aThat)
205 , progress(aProgress)
206 , rc(S_OK)
207 {}
208 ~TaskImportMachines() {}
209
210 HRESULT startThread();
211
212 Appliance *pAppliance;
213 ComObjPtr<Progress> progress;
214 HRESULT rc;
215};
216
217struct Appliance::TaskExportOVF
218{
219 TaskExportOVF(Appliance *aThat, Progress *aProgress)
220 : pAppliance(aThat)
221 , progress(aProgress)
222 , rc(S_OK)
223 {}
224 ~TaskExportOVF() {}
225
226 HRESULT startThread();
227
228 Appliance *pAppliance;
229 ComObjPtr<Progress> progress;
230 HRESULT rc;
231};
232
233////////////////////////////////////////////////////////////////////////////////
234//
235// globals
236//
237////////////////////////////////////////////////////////////////////////////////
238
239static Utf8Str stripFilename(const Utf8Str &strFile)
240{
241 Utf8Str str2(strFile);
242 RTPathStripFilename(str2.mutableRaw());
243 return str2;
244}
245
246////////////////////////////////////////////////////////////////////////////////
247//
248// IVirtualBox public methods
249//
250////////////////////////////////////////////////////////////////////////////////
251
252// This code is here so we won't have to include the appliance headers in the
253// IVirtualBox implementation.
254
255/**
256 * Implementation for IVirtualBox::createAppliance.
257 *
258 * @param anAppliance IAppliance object created if S_OK is returned.
259 * @return S_OK or error.
260 */
261STDMETHODIMP VirtualBox::CreateAppliance(IAppliance** anAppliance)
262{
263 HRESULT rc;
264
265 ComObjPtr<Appliance> appliance;
266 appliance.createObject();
267 rc = appliance->init(this);
268
269 if (SUCCEEDED(rc))
270 appliance.queryInterfaceTo(anAppliance);
271
272 return rc;
273}
274
275////////////////////////////////////////////////////////////////////////////////
276//
277// Appliance::task methods
278//
279////////////////////////////////////////////////////////////////////////////////
280
281HRESULT Appliance::TaskImportMachines::startThread()
282{
283 int vrc = RTThreadCreate(NULL, Appliance::taskThreadImportMachines, this,
284 0, RTTHREADTYPE_MAIN_HEAVY_WORKER, 0,
285 "Appliance::Task");
286 ComAssertMsgRCRet(vrc,
287 ("Could not create taskThreadImportMachines (%Rrc)\n", vrc), E_FAIL);
288
289 return S_OK;
290}
291
292HRESULT Appliance::TaskExportOVF::startThread()
293{
294 int vrc = RTThreadCreate(NULL, Appliance::taskThreadExportOVF, this,
295 0, RTTHREADTYPE_MAIN_HEAVY_WORKER, 0,
296 "Appliance::Task");
297 ComAssertMsgRCRet(vrc,
298 ("Could not create taskThreadExportOVF (%Rrc)\n", vrc), E_FAIL);
299
300 return S_OK;
301}
302
303////////////////////////////////////////////////////////////////////////////////
304//
305// Appliance constructor / destructor
306//
307////////////////////////////////////////////////////////////////////////////////
308
309DEFINE_EMPTY_CTOR_DTOR(Appliance)
310struct shutup {};
311
312/**
313 * Appliance COM initializer.
314 * @param
315 * @return
316 */
317
318HRESULT Appliance::init(VirtualBox *aVirtualBox)
319{
320 /* Enclose the state transition NotReady->InInit->Ready */
321 AutoInitSpan autoInitSpan(this);
322 AssertReturn(autoInitSpan.isOk(), E_FAIL);
323
324 /* Weak reference to a VirtualBox object */
325 unconst(mVirtualBox) = aVirtualBox;
326
327 // initialize data
328 m = new Data;
329
330 /* Confirm a successful initialization */
331 autoInitSpan.setSucceeded();
332
333 return S_OK;
334}
335
336/**
337 * Appliance COM uninitializer.
338 * @return
339 */
340void Appliance::uninit()
341{
342 delete m;
343 m = NULL;
344}
345
346////////////////////////////////////////////////////////////////////////////////
347//
348// Appliance private methods
349//
350////////////////////////////////////////////////////////////////////////////////
351
352/**
353 * Private helper method that goes thru the elements of the given "current" element in the OVF XML
354 * and handles the contained child elements (which can be "Section" or "Content" elements).
355 *
356 * @param pcszPath Path spec of the XML file, for error messages.
357 * @param pReferencesElement "References" element from OVF, for looking up file specifications; can be NULL if no such element is present.
358 * @param pCurElem Element whose children are to be analyzed here.
359 * @return
360 */
361HRESULT Appliance::LoopThruSections(const char *pcszPath,
362 const xml::Node *pReferencesElem,
363 const xml::Node *pCurElem)
364{
365 HRESULT rc;
366
367 xml::NodesLoop loopChildren(*pCurElem);
368 const xml::Node *pElem;
369 while ((pElem = loopChildren.forAllNodes()))
370 {
371 const char *pcszElemName = pElem->getName();
372 const char *pcszTypeAttr = "";
373 const xml::Node *pTypeAttr;
374 if ((pTypeAttr = pElem->findAttribute("type")))
375 pcszTypeAttr = pTypeAttr->getValue();
376
377 if ( (!strcmp(pcszElemName, "DiskSection"))
378 || ( (!strcmp(pcszElemName, "Section"))
379 && (!strcmp(pcszTypeAttr, "ovf:DiskSection_Type"))
380 )
381 )
382 {
383 if (!(SUCCEEDED((rc = HandleDiskSection(pcszPath, pReferencesElem, pElem)))))
384 return rc;
385 }
386 else if ( (!strcmp(pcszElemName, "NetworkSection"))
387 || ( (!strcmp(pcszElemName, "Section"))
388 && (!strcmp(pcszTypeAttr, "ovf:NetworkSection_Type"))
389 )
390 )
391 {
392 if (!(SUCCEEDED((rc = HandleNetworkSection(pcszPath, pElem)))))
393 return rc;
394 }
395 else if ( (!strcmp(pcszElemName, "DeploymentOptionSection>")))
396 {
397 // TODO
398 }
399 else if ( (!strcmp(pcszElemName, "Info")))
400 {
401 // child of VirtualSystemCollection -- TODO
402 }
403 else if ( (!strcmp(pcszElemName, "ResourceAllocationSection")))
404 {
405 // child of VirtualSystemCollection -- TODO
406 }
407 else if ( (!strcmp(pcszElemName, "StartupSection")))
408 {
409 // child of VirtualSystemCollection -- TODO
410 }
411 else if ( (!strcmp(pcszElemName, "VirtualSystem"))
412 || ( (!strcmp(pcszElemName, "Content"))
413 && (!strcmp(pcszTypeAttr, "ovf:VirtualSystem_Type"))
414 )
415 )
416 {
417 if (!(SUCCEEDED((rc = HandleVirtualSystemContent(pcszPath, pElem)))))
418 return rc;
419 }
420 else if ( (!strcmp(pcszElemName, "VirtualSystemCollection"))
421 || ( (!strcmp(pcszElemName, "Content"))
422 && (!strcmp(pcszTypeAttr, "ovf:VirtualSystemCollection_Type"))
423 )
424 )
425 {
426 // TODO ResourceAllocationSection
427
428 // recurse for this, since it has VirtualSystem elements as children
429 if (!(SUCCEEDED((rc = LoopThruSections(pcszPath, pReferencesElem, pElem)))))
430 return rc;
431 }
432 }
433
434 return S_OK;
435}
436
437/**
438 * Private helper method that handles disk sections in the OVF XML.
439 * Gets called indirectly from IAppliance::read().
440 *
441 * @param pcszPath Path spec of the XML file, for error messages.
442 * @param pReferencesElement "References" element from OVF, for looking up file specifications; can be NULL if no such element is present.
443 * @param pSectionElem Section element for which this helper is getting called.
444 * @return
445 */
446HRESULT Appliance::HandleDiskSection(const char *pcszPath,
447 const xml::Node *pReferencesElem,
448 const xml::Node *pSectionElem)
449{
450 // contains "Disk" child elements
451 xml::NodesLoop loopDisks(*pSectionElem, "Disk");
452 const xml::Node *pelmDisk;
453 while ((pelmDisk = loopDisks.forAllNodes()))
454 {
455 DiskImage d;
456 const char *pcszBad = NULL;
457 if (!(pelmDisk->getAttributeValue("diskId", d.strDiskId)))
458 pcszBad = "diskId";
459 else if (!(pelmDisk->getAttributeValue("format", d.strFormat)))
460 pcszBad = "format";
461 else if (!(pelmDisk->getAttributeValue("capacity", d.iCapacity)))
462 pcszBad = "capacity";
463 else
464 {
465 if (!(pelmDisk->getAttributeValue("populatedSize", d.iPopulatedSize)))
466 // optional
467 d.iPopulatedSize = -1;
468
469 Utf8Str strFileRef;
470 if (pelmDisk->getAttributeValue("fileRef", strFileRef)) // optional
471 {
472 // look up corresponding /References/File nodes (list built above)
473 const xml::Node *pFileElem;
474 if ( pReferencesElem
475 && ((pFileElem = pReferencesElem->findChildElementFromId(strFileRef.c_str())))
476 )
477 {
478 // copy remaining values from file node then
479 const char *pcszBadInFile = NULL;
480 if (!(pFileElem->getAttributeValue("href", d.strHref)))
481 pcszBadInFile = "href";
482 else if (!(pFileElem->getAttributeValue("size", d.iSize)))
483 d.iSize = -1; // optional
484 // if (!(pFileElem->getAttributeValue("size", d.iChunkSize))) TODO
485 d.iChunkSize = -1; // optional
486 pFileElem->getAttributeValue("compression", d.strCompression);
487
488 if (pcszBadInFile)
489 return setError(VBOX_E_FILE_ERROR,
490 tr("Error reading \"%s\": missing or invalid attribute '%s' in 'File' element, line %d"),
491 pcszPath,
492 pcszBadInFile,
493 pFileElem->getLineNumber());
494 }
495 else
496 return setError(VBOX_E_FILE_ERROR,
497 tr("Error reading \"%s\": cannot find References/File element for ID '%s' referenced by 'Disk' element, line %d"),
498 pcszPath,
499 strFileRef.c_str(),
500 pelmDisk->getLineNumber());
501 }
502 }
503
504 if (pcszBad)
505 return setError(VBOX_E_FILE_ERROR,
506 tr("Error reading \"%s\": missing or invalid attribute '%s' in 'DiskSection' element, line %d"),
507 pcszPath,
508 pcszBad,
509 pelmDisk->getLineNumber());
510
511 m->mapDisks[d.strDiskId] = d;
512 }
513
514 return S_OK;
515}
516
517/**
518 * Private helper method that handles network sections in the OVF XML.
519 * Gets called indirectly from IAppliance::read().
520 *
521 * @param pcszPath Path spec of the XML file, for error messages.
522 * @param pSectionElem Section element for which this helper is getting called.
523 * @return
524 */
525HRESULT Appliance::HandleNetworkSection(const char *pcszPath,
526 const xml::Node *pSectionElem)
527{
528 // contains "Disk" child elements
529 xml::NodesLoop loopNetworks(*pSectionElem, "Network");
530 const xml::Node *pelmNetwork;
531 while ((pelmNetwork = loopNetworks.forAllNodes()))
532 {
533 Network n;
534 if (!(pelmNetwork->getAttributeValue("name", n.strNetworkName)))
535 return setError(VBOX_E_FILE_ERROR,
536 tr("Error reading \"%s\": missing 'name' attribute in 'Network', line %d"),
537 pcszPath,
538 pelmNetwork->getLineNumber());
539
540 m->mapNetworks[n.strNetworkName] = n;
541 }
542
543 return S_OK;
544}
545
546/**
547 * Private helper method that handles a "VirtualSystem" element in the OVF XML.
548 * Gets called indirectly from IAppliance::read().
549 *
550 * @param pcszPath
551 * @param pContentElem
552 * @return
553 */
554HRESULT Appliance::HandleVirtualSystemContent(const char *pcszPath,
555 const xml::Node *pelmVirtualSystem)
556{
557 VirtualSystem vsys;
558
559 const xml::Node *pIdAttr = pelmVirtualSystem->findAttribute("id");
560 if (pIdAttr)
561 vsys.strName = pIdAttr->getValue();
562
563 xml::NodesLoop loop(*pelmVirtualSystem); // all child elements
564 const xml::Node *pelmThis;
565 while ((pelmThis = loop.forAllNodes()))
566 {
567 const char *pcszElemName = pelmThis->getName();
568 const xml::Node *pTypeAttr = pelmThis->findAttribute("type");
569 const char *pcszTypeAttr = (pTypeAttr) ? pTypeAttr->getValue() : "";
570
571 if (!strcmp(pcszElemName, "EulaSection"))
572 {
573 /* <EulaSection>
574 <Info ovf:msgid="6">License agreement for the Virtual System.</Info>
575 <License ovf:msgid="1">License terms can go in here.</License>
576 </EulaSection> */
577
578 const xml::Node *pelmInfo, *pelmLicense;
579 if ( ((pelmInfo = pelmThis->findChildElement("Info")))
580 && ((pelmLicense = pelmThis->findChildElement("License")))
581 )
582 {
583 vsys.strLicenceInfo = pelmInfo->getValue();
584 vsys.strLicenceText = pelmLicense->getValue();
585 }
586 }
587 else if ( (!strcmp(pcszElemName, "VirtualHardwareSection"))
588 || (!strcmp(pcszTypeAttr, "ovf:VirtualHardwareSection_Type"))
589 )
590 {
591 const xml::Node *pelmSystem, *pelmVirtualSystemType;
592 if ((pelmSystem = pelmThis->findChildElement("System")))
593 {
594 /* <System>
595 <vssd:Description>Description of the virtual hardware section.</vssd:Description>
596 <vssd:ElementName>vmware</vssd:ElementName>
597 <vssd:InstanceID>1</vssd:InstanceID>
598 <vssd:VirtualSystemIdentifier>MyLampService</vssd:VirtualSystemIdentifier>
599 <vssd:VirtualSystemType>vmx-4</vssd:VirtualSystemType>
600 </System>*/
601 if ((pelmVirtualSystemType = pelmSystem->findChildElement("VirtualSystemType")))
602 vsys.strVirtualSystemType = pelmVirtualSystemType->getValue();
603 }
604
605 xml::NodesLoop loopVirtualHardwareItems(*pelmThis, "Item"); // all "Item" child elements
606 const xml::Node *pelmItem;
607 while ((pelmItem = loopVirtualHardwareItems.forAllNodes()))
608 {
609 VirtualHardwareItem i;
610
611 i.ulLineNumber = pelmItem->getLineNumber();
612
613 xml::NodesLoop loopItemChildren(*pelmItem); // all child elements
614 const xml::Node *pelmItemChild;
615 while ((pelmItemChild = loopItemChildren.forAllNodes()))
616 {
617 const char *pcszItemChildName = pelmItemChild->getName();
618 if (!strcmp(pcszItemChildName, "Description"))
619 i.strDescription = pelmItemChild->getValue();
620 else if (!strcmp(pcszItemChildName, "Caption"))
621 i.strCaption = pelmItemChild->getValue();
622 else if (!strcmp(pcszItemChildName, "ElementName"))
623 i.strElementName = pelmItemChild->getValue();
624 else if ( (!strcmp(pcszItemChildName, "InstanceID"))
625 || (!strcmp(pcszItemChildName, "InstanceId"))
626 )
627 pelmItemChild->copyValue(i.ulInstanceID);
628 else if (!strcmp(pcszItemChildName, "HostResource"))
629 i.strHostResource = pelmItemChild->getValue();
630 else if (!strcmp(pcszItemChildName, "ResourceType"))
631 {
632 int32_t iType; /** @todo how to fix correctly? (enum fun.) */
633 pelmItemChild->copyValue(iType);
634 i.resourceType = (OVFResourceType_T)iType;
635 }
636 else if (!strcmp(pcszItemChildName, "OtherResourceType"))
637 i.strOtherResourceType = pelmItemChild->getValue();
638 else if (!strcmp(pcszItemChildName, "ResourceSubType"))
639 i.strResourceSubType = pelmItemChild->getValue();
640 else if (!strcmp(pcszItemChildName, "AutomaticAllocation"))
641 i.fAutomaticAllocation = (!strcmp(pelmItemChild->getValue(), "true")) ? true : false;
642 else if (!strcmp(pcszItemChildName, "AutomaticDeallocation"))
643 i.fAutomaticDeallocation = (!strcmp(pelmItemChild->getValue(), "true")) ? true : false;
644 else if (!strcmp(pcszItemChildName, "Parent"))
645 pelmItemChild->copyValue(i.ulParent);
646 else if (!strcmp(pcszItemChildName, "Connection"))
647 i.strConnection = pelmItemChild->getValue();
648 else if (!strcmp(pcszItemChildName, "Address"))
649 i.strAddress = pelmItemChild->getValue();
650 else if (!strcmp(pcszItemChildName, "AddressOnParent"))
651 i.strAddressOnParent = pelmItemChild->getValue();
652 else if (!strcmp(pcszItemChildName, "AllocationUnits"))
653 i.strAllocationUnits = pelmItemChild->getValue();
654 else if (!strcmp(pcszItemChildName, "VirtualQuantity"))
655 pelmItemChild->copyValue(i.ullVirtualQuantity);
656 else if (!strcmp(pcszItemChildName, "Reservation"))
657 pelmItemChild->copyValue(i.ullReservation);
658 else if (!strcmp(pcszItemChildName, "Limit"))
659 pelmItemChild->copyValue(i.ullLimit);
660 else if (!strcmp(pcszItemChildName, "Weight"))
661 pelmItemChild->copyValue(i.ullWeight);
662 else if (!strcmp(pcszItemChildName, "ConsumerVisibility"))
663 i.strConsumerVisibility = pelmItemChild->getValue();
664 else if (!strcmp(pcszItemChildName, "MappingBehavior"))
665 i.strMappingBehavior = pelmItemChild->getValue();
666 else if (!strcmp(pcszItemChildName, "PoolID"))
667 i.strPoolID = pelmItemChild->getValue();
668 else if (!strcmp(pcszItemChildName, "BusNumber"))
669 pelmItemChild->copyValue(i.ulBusNumber);
670 else
671 return setError(VBOX_E_FILE_ERROR,
672 tr("Error reading \"%s\": unknown element \"%s\" under Item element, line %d"),
673 pcszPath,
674 pcszItemChildName,
675 i.ulLineNumber);
676 }
677
678 // store!
679 vsys.mapHardwareItems[i.ulInstanceID] = i;
680 }
681
682 HardwareItemsMap::const_iterator itH;
683
684 for (itH = vsys.mapHardwareItems.begin();
685 itH != vsys.mapHardwareItems.end();
686 ++itH)
687 {
688 const VirtualHardwareItem &i = itH->second;
689
690 // do some analysis
691 switch (i.resourceType)
692 {
693 case OVFResourceType_Processor: // 3
694 /* <rasd:Caption>1 virtual CPU</rasd:Caption>
695 <rasd:Description>Number of virtual CPUs</rasd:Description>
696 <rasd:ElementName>virtual CPU</rasd:ElementName>
697 <rasd:InstanceID>1</rasd:InstanceID>
698 <rasd:ResourceType>3</rasd:ResourceType>
699 <rasd:VirtualQuantity>1</rasd:VirtualQuantity>*/
700 if (i.ullVirtualQuantity < UINT16_MAX)
701 vsys.cCPUs = (uint16_t)i.ullVirtualQuantity;
702 else
703 return setError(VBOX_E_FILE_ERROR,
704 tr("Error reading \"%s\": CPU count %RI64 is larger than %d, line %d"),
705 pcszPath,
706 i.ullVirtualQuantity,
707 UINT16_MAX,
708 i.ulLineNumber);
709 break;
710
711 case OVFResourceType_Memory: // 4
712 if ( (i.strAllocationUnits == "MegaBytes") // found in OVF created by OVF toolkit
713 || (i.strAllocationUnits == "MB") // found in MS docs
714 || (i.strAllocationUnits == "byte * 2^20") // suggested by OVF spec DSP0243 page 21
715 )
716 vsys.ullMemorySize = i.ullVirtualQuantity * 1024 * 1024;
717 else
718 return setError(VBOX_E_FILE_ERROR,
719 tr("Error reading \"%s\": Invalid allocation unit \"%s\" specified with memory size item, line %d"),
720 pcszPath,
721 i.strAllocationUnits.c_str(),
722 i.ulLineNumber);
723 break;
724
725 case OVFResourceType_IdeController: // 5 IdeController
726 {
727 /* <Item>
728 <rasd:Caption>ideController0</rasd:Caption>
729 <rasd:Description>IDE Controller</rasd:Description>
730 <rasd:InstanceId>5</rasd:InstanceId>
731 <rasd:ResourceType>5</rasd:ResourceType>
732 <rasd:Address>0</rasd:Address>
733 <rasd:BusNumber>0</rasd:BusNumber>
734 </Item> */
735 HardDiskController hdc;
736 hdc.system = HardDiskController::IDE;
737 hdc.idController = i.ulInstanceID;
738 hdc.strAddress = i.strAddress;
739 hdc.ulBusNumber = i.ulBusNumber;
740
741 vsys.mapControllers[i.ulInstanceID] = hdc;
742 }
743 break;
744
745 case OVFResourceType_ParallelScsiHba: // 6 SCSI controller
746 {
747 /* <Item>
748 <rasd:Caption>SCSI Controller 0 - LSI Logic</rasd:Caption>
749 <rasd:Description>SCI Controller</rasd:Description>
750 <rasd:ElementName>SCSI controller</rasd:ElementName>
751 <rasd:InstanceID>4</rasd:InstanceID>
752 <rasd:ResourceSubType>LsiLogic</rasd:ResourceSubType>
753 <rasd:ResourceType>6</rasd:ResourceType>
754 </Item> */
755 HardDiskController hdc;
756 hdc.system = HardDiskController::SCSI;
757 hdc.idController = i.ulInstanceID;
758 hdc.strControllerType = i.strResourceSubType;
759
760 vsys.mapControllers[i.ulInstanceID] = hdc;
761 }
762 break;
763
764 case OVFResourceType_EthernetAdapter: // 10
765 {
766 /* <Item>
767 <rasd:AutomaticAllocation>true</rasd:AutomaticAllocation>
768 <rasd:Caption>Ethernet adapter on 'VM Network'</rasd:Caption>
769 <rasd:Connection>VM Network</rasd:Connection>
770 <rasd:Description>VM Network?</rasd:Description>
771 <rasd:ElementName>Ethernet adapter</rasd:ElementName>
772 <rasd:InstanceID>3</rasd:InstanceID>
773 <rasd:ResourceType>10</rasd:ResourceType>
774 </Item>
775
776 OVF spec DSP 0243 page 21:
777 "For an Ethernet adapter, this specifies the abstract network connection name
778 for the virtual machine. All Ethernet adapters that specify the same abstract
779 network connection name within an OVF package shall be deployed on the same
780 network. The abstract network connection name shall be listed in the NetworkSection
781 at the outermost envelope level." */
782
783 // make sure we have a matching NetworkSection/Network
784 NetworksMap::iterator it = m->mapNetworks.find(i.strConnection);
785 if (it == m->mapNetworks.end())
786 return setError(VBOX_E_FILE_ERROR,
787 tr("Error reading \"%s\": Invalid connection \"%s\"; cannot find matching NetworkSection/Network element, line %d"),
788 pcszPath,
789 i.strConnection.c_str(),
790 i.ulLineNumber);
791
792 vsys.llNetworkNames.push_back(i.strConnection);
793 }
794 break;
795
796 case OVFResourceType_FloppyDrive: // 14
797 vsys.fHasFloppyDrive = true; // we have no additional information
798 break;
799
800 case OVFResourceType_CdDrive: // 15
801 /* <Item ovf:required="false">
802 <rasd:Caption>cdrom1</rasd:Caption>
803 <rasd:InstanceId>7</rasd:InstanceId>
804 <rasd:ResourceType>15</rasd:ResourceType>
805 <rasd:AutomaticAllocation>true</rasd:AutomaticAllocation>
806 <rasd:Parent>5</rasd:Parent>
807 <rasd:AddressOnParent>0</rasd:AddressOnParent>
808 </Item> */
809 // I tried to see what happens if I set an ISO for the CD-ROM in VMware Workstation,
810 // but then the ovftool dies with "Device backing not supported". So I guess if
811 // VMware can't export ISOs, then we don't need to be able to import them right now.
812 vsys.fHasCdromDrive = true; // we have no additional information
813 break;
814
815 case OVFResourceType_HardDisk: // 17
816 {
817 /* <Item>
818 <rasd:Caption>Harddisk 1</rasd:Caption>
819 <rasd:Description>HD</rasd:Description>
820 <rasd:ElementName>Hard Disk</rasd:ElementName>
821 <rasd:HostResource>ovf://disk/lamp</rasd:HostResource>
822 <rasd:InstanceID>5</rasd:InstanceID>
823 <rasd:Parent>4</rasd:Parent>
824 <rasd:ResourceType>17</rasd:ResourceType>
825 </Item> */
826
827 // look up the hard disk controller element whose InstanceID equals our Parent;
828 // this is how the connection is specified in OVF
829 ControllersMap::const_iterator it = vsys.mapControllers.find(i.ulParent);
830 if (it == vsys.mapControllers.end())
831 return setError(VBOX_E_FILE_ERROR,
832 tr("Error reading \"%s\": Hard disk item with instance ID %d specifies invalid parent %d, line %d"),
833 pcszPath,
834 i.ulInstanceID,
835 i.ulParent,
836 i.ulLineNumber);
837 const HardDiskController &hdc = it->second;
838
839 VirtualDisk vd;
840 vd.idController = i.ulParent;
841 i.strAddressOnParent.toInt(vd.ulAddressOnParent);
842 bool fFound = false;
843 // ovf://disk/lamp
844 // 12345678901234
845 if (i.strHostResource.substr(0, 11) == "ovf://disk/")
846 vd.strDiskId = i.strHostResource.substr(11);
847 else if (i.strHostResource.substr(0, 6) == "/disk/")
848 vd.strDiskId = i.strHostResource.substr(6);
849
850 if ( !(vd.strDiskId.length())
851 || (m->mapDisks.find(vd.strDiskId) == m->mapDisks.end())
852 )
853 return setError(VBOX_E_FILE_ERROR,
854 tr("Error reading \"%s\": Hard disk item with instance ID %d specifies invalid host resource \"%s\", line %d"),
855 pcszPath,
856 i.ulInstanceID,
857 i.strHostResource.c_str(),
858 i.ulLineNumber);
859
860 vsys.mapVirtualDisks[vd.strDiskId] = vd;
861 }
862 break;
863
864 case OVFResourceType_UsbController: // 23
865 /* <Item ovf:required="false">
866 <rasd:Caption>usb</rasd:Caption>
867 <rasd:Description>USB Controller</rasd:Description>
868 <rasd:InstanceId>3</rasd:InstanceId>
869 <rasd:ResourceType>23</rasd:ResourceType>
870 <rasd:Address>0</rasd:Address>
871 <rasd:BusNumber>0</rasd:BusNumber>
872 </Item> */
873 vsys.fHasUsbController = true; // we have no additional information
874 break;
875
876 case OVFResourceType_SoundCard: // 35
877 /* <Item ovf:required="false">
878 <rasd:Caption>sound</rasd:Caption>
879 <rasd:Description>Sound Card</rasd:Description>
880 <rasd:InstanceId>10</rasd:InstanceId>
881 <rasd:ResourceType>35</rasd:ResourceType>
882 <rasd:ResourceSubType>ensoniq1371</rasd:ResourceSubType>
883 <rasd:AutomaticAllocation>false</rasd:AutomaticAllocation>
884 <rasd:AddressOnParent>3</rasd:AddressOnParent>
885 </Item> */
886 vsys.strSoundCardType = i.strResourceSubType;
887 break;
888
889 default:
890 return setError(VBOX_E_FILE_ERROR,
891 tr("Error reading \"%s\": Unknown resource type %d in hardware item, line %d"),
892 pcszPath,
893 i.resourceType,
894 i.ulLineNumber);
895 }
896 }
897 }
898 else if ( (!strcmp(pcszElemName, "OperatingSystemSection"))
899 || (!strcmp(pcszTypeAttr, "ovf:OperatingSystemSection_Type"))
900 )
901 {
902 uint64_t cimos64;
903 if (!(pelmThis->getAttributeValue("id", cimos64)))
904 return setError(VBOX_E_FILE_ERROR,
905 tr("Error reading \"%s\": missing or invalid 'ovf:id' attribute in operating system section element, line %d"),
906 pcszPath,
907 pelmThis->getLineNumber());
908
909 vsys.cimos = (CIMOSType_T)cimos64;
910 }
911 }
912
913 // now create the virtual system
914 m->llVirtualSystems.push_back(vsys);
915
916 return S_OK;
917}
918
919////////////////////////////////////////////////////////////////////////////////
920//
921// IAppliance public methods
922//
923////////////////////////////////////////////////////////////////////////////////
924
925/**
926 * Public method implementation.
927 * @param
928 * @return
929 */
930STDMETHODIMP Appliance::COMGETTER(Path)(BSTR *aPath)
931{
932 if (!aPath)
933 return E_POINTER;
934
935 AutoCaller autoCaller(this);
936 CheckComRCReturnRC(autoCaller.rc());
937
938 AutoReadLock alock(this);
939
940 Bstr bstrPath(m->strPath);
941 bstrPath.cloneTo(aPath);
942
943 return S_OK;
944}
945
946/**
947 * Public method implementation.
948 * @param
949 * @return
950 */
951STDMETHODIMP Appliance::COMGETTER(Disks)(ComSafeArrayOut(BSTR, aDisks))
952{
953 CheckComArgOutSafeArrayPointerValid(aDisks);
954
955 AutoCaller autoCaller(this);
956 CheckComRCReturnRC(autoCaller.rc());
957
958 AutoReadLock alock(this);
959
960 size_t c = m->mapDisks.size();
961 com::SafeArray<BSTR> sfaDisks(c);
962
963 DiskImagesMap::const_iterator it;
964 size_t i = 0;
965 for (it = m->mapDisks.begin();
966 it != m->mapDisks.end();
967 ++it, ++i)
968 {
969 // create a string representing this disk
970 const DiskImage &d = it->second;
971 char *psz = NULL;
972 RTStrAPrintf(&psz,
973 "%s\t"
974 "%RI64\t"
975 "%RI64\t"
976 "%s\t"
977 "%s\t"
978 "%RI64\t"
979 "%RI64\t"
980 "%s",
981 d.strDiskId.c_str(),
982 d.iCapacity,
983 d.iPopulatedSize,
984 d.strFormat.c_str(),
985 d.strHref.c_str(),
986 d.iSize,
987 d.iChunkSize,
988 d.strCompression.c_str());
989 Utf8Str utf(psz);
990 Bstr bstr(utf);
991 // push to safearray
992 bstr.cloneTo(&sfaDisks[i]);
993 RTStrFree(psz);
994 }
995
996 sfaDisks.detachTo(ComSafeArrayOutArg(aDisks));
997
998 return S_OK;
999}
1000
1001/**
1002 * Public method implementation.
1003 * @param
1004 * @return
1005 */
1006STDMETHODIMP Appliance::COMGETTER(VirtualSystemDescriptions)(ComSafeArrayOut(IVirtualSystemDescription*, aVirtualSystemDescriptions))
1007{
1008 CheckComArgOutSafeArrayPointerValid(aVirtualSystemDescriptions);
1009
1010 AutoCaller autoCaller(this);
1011 CheckComRCReturnRC(autoCaller.rc());
1012
1013 AutoReadLock alock(this);
1014
1015 SafeIfaceArray<IVirtualSystemDescription> sfaVSD(m->virtualSystemDescriptions);
1016 sfaVSD.detachTo(ComSafeArrayOutArg(aVirtualSystemDescriptions));
1017
1018 return S_OK;
1019}
1020
1021/**
1022 * Private helper func that suggests a VirtualBox guest OS type
1023 * for the given OVF operating system type.
1024 * @param osTypeVBox
1025 * @param c
1026 */
1027static void convertCIMOSType2VBoxOSType(Utf8Str &osTypeVBox, CIMOSType_T c)
1028{
1029 switch (c)
1030 {
1031 case CIMOSType_CIMOS_Unknown: // 0 - Unknown
1032 osTypeVBox = SchemaDefs_OSTypeId_Other;
1033 break;
1034
1035 case CIMOSType_CIMOS_OS2: // 12 - OS/2
1036 osTypeVBox = SchemaDefs_OSTypeId_OS2;
1037 break;
1038
1039 case CIMOSType_CIMOS_MSDOS: // 14 - MSDOS
1040 osTypeVBox = SchemaDefs_OSTypeId_DOS;
1041 break;
1042
1043 case CIMOSType_CIMOS_WIN3x: // 15 - WIN3x
1044 osTypeVBox = SchemaDefs_OSTypeId_Windows31;
1045 break;
1046
1047 case CIMOSType_CIMOS_WIN95: // 16 - WIN95
1048 osTypeVBox = SchemaDefs_OSTypeId_Windows95;
1049 break;
1050
1051 case CIMOSType_CIMOS_WIN98: // 17 - WIN98
1052 osTypeVBox = SchemaDefs_OSTypeId_Windows98;
1053 break;
1054
1055 case CIMOSType_CIMOS_WINNT: // 18 - WINNT
1056 osTypeVBox = SchemaDefs_OSTypeId_WindowsNT4;
1057 break;
1058
1059 case CIMOSType_CIMOS_NetWare: // 21 - NetWare
1060 case CIMOSType_CIMOS_NovellOES: // 86 - Novell OES
1061 osTypeVBox = SchemaDefs_OSTypeId_Netware;
1062 break;
1063
1064 case CIMOSType_CIMOS_Solaris: // 29 - Solaris
1065 case CIMOSType_CIMOS_SunOS: // 30 - SunOS
1066 osTypeVBox = SchemaDefs_OSTypeId_Solaris;
1067 break;
1068
1069 case CIMOSType_CIMOS_FreeBSD: // 42 - FreeBSD
1070 osTypeVBox = SchemaDefs_OSTypeId_FreeBSD;
1071 break;
1072
1073 case CIMOSType_CIMOS_NetBSD: // 43 - NetBSD
1074 osTypeVBox = SchemaDefs_OSTypeId_NetBSD;
1075 break;
1076
1077 case CIMOSType_CIMOS_QNX: // 48 - QNX
1078 osTypeVBox = SchemaDefs_OSTypeId_QNX;
1079 break;
1080
1081 case CIMOSType_CIMOS_Windows2000: // 58 - Windows 2000
1082 osTypeVBox = SchemaDefs_OSTypeId_Windows2000;
1083 break;
1084
1085 case CIMOSType_CIMOS_WindowsMe: // 63 - Windows (R) Me
1086 osTypeVBox = SchemaDefs_OSTypeId_WindowsMe;
1087 break;
1088
1089 case CIMOSType_CIMOS_OpenBSD: // 65 - OpenBSD
1090 osTypeVBox = SchemaDefs_OSTypeId_OpenBSD;
1091 break;
1092
1093 case CIMOSType_CIMOS_WindowsXP: // 67 - Windows XP
1094 case CIMOSType_CIMOS_WindowsXPEmbedded: // 72 - Windows XP Embedded
1095 case CIMOSType_CIMOS_WindowsEmbeddedforPointofService: // 75 - Windows Embedded for Point of Service
1096 osTypeVBox = SchemaDefs_OSTypeId_WindowsXP;
1097 break;
1098
1099 case CIMOSType_CIMOS_MicrosoftWindowsServer2003: // 69 - Microsoft Windows Server 2003
1100 osTypeVBox = SchemaDefs_OSTypeId_Windows2003;
1101 break;
1102
1103 case CIMOSType_CIMOS_MicrosoftWindowsServer2003_64: // 70 - Microsoft Windows Server 2003 64-Bit
1104 osTypeVBox = SchemaDefs_OSTypeId_Windows2003_64;
1105 break;
1106
1107 case CIMOSType_CIMOS_WindowsXP_64: // 71 - Windows XP 64-Bit
1108 osTypeVBox = SchemaDefs_OSTypeId_WindowsXP_64;
1109 break;
1110
1111 case CIMOSType_CIMOS_WindowsVista: // 73 - Windows Vista
1112 osTypeVBox = SchemaDefs_OSTypeId_WindowsVista;
1113 break;
1114
1115 case CIMOSType_CIMOS_WindowsVista_64: // 74 - Windows Vista 64-Bit
1116 osTypeVBox = SchemaDefs_OSTypeId_WindowsVista_64;
1117 break;
1118
1119 case CIMOSType_CIMOS_MicrosoftWindowsServer2008: // 76 - Microsoft Windows Server 2008
1120 osTypeVBox = SchemaDefs_OSTypeId_Windows2008;
1121 break;
1122
1123 case CIMOSType_CIMOS_MicrosoftWindowsServer2008_64: // 77 - Microsoft Windows Server 2008 64-Bit
1124 osTypeVBox = SchemaDefs_OSTypeId_Windows2008_64;
1125 break;
1126
1127 case CIMOSType_CIMOS_FreeBSD_64: // 78 - FreeBSD 64-Bit
1128 osTypeVBox = SchemaDefs_OSTypeId_FreeBSD_64;
1129 break;
1130
1131 case CIMOSType_CIMOS_RedHatEnterpriseLinux: // 79 - RedHat Enterprise Linux
1132 osTypeVBox = SchemaDefs_OSTypeId_RedHat;
1133 break;
1134
1135 case CIMOSType_CIMOS_RedHatEnterpriseLinux_64: // 80 - RedHat Enterprise Linux 64-Bit
1136 osTypeVBox = SchemaDefs_OSTypeId_RedHat_64;
1137 break;
1138
1139 case CIMOSType_CIMOS_Solaris_64: // 81 - Solaris 64-Bit
1140 osTypeVBox = SchemaDefs_OSTypeId_Solaris_64;
1141 break;
1142
1143 case CIMOSType_CIMOS_SUSE: // 82 - SUSE
1144 case CIMOSType_CIMOS_SLES: // 84 - SLES
1145 case CIMOSType_CIMOS_NovellLinuxDesktop: // 87 - Novell Linux Desktop
1146 osTypeVBox = SchemaDefs_OSTypeId_OpenSUSE;
1147 break;
1148
1149 case CIMOSType_CIMOS_SUSE_64: // 83 - SUSE 64-Bit
1150 case CIMOSType_CIMOS_SLES_64: // 85 - SLES 64-Bit
1151 osTypeVBox = SchemaDefs_OSTypeId_OpenSUSE_64;
1152 break;
1153
1154 case CIMOSType_CIMOS_LINUX: // 36 - LINUX
1155 case CIMOSType_CIMOS_SunJavaDesktopSystem: // 88 - Sun Java Desktop System
1156 case CIMOSType_CIMOS_TurboLinux: // 91 - TurboLinux
1157 osTypeVBox = SchemaDefs_OSTypeId_Linux;
1158 break;
1159
1160 // case CIMOSType_CIMOS_TurboLinux_64: // 92 - TurboLinux 64-Bit
1161 // case CIMOSType_CIMOS_Linux_64: // 101 - Linux 64-Bit
1162 // osTypeVBox = VBOXOSTYPE_Linux_x64;
1163 // break;
1164
1165 case CIMOSType_CIMOS_Mandriva: // 89 - Mandriva
1166 osTypeVBox = SchemaDefs_OSTypeId_Mandriva;
1167 break;
1168
1169 case CIMOSType_CIMOS_Mandriva_64: // 90 - Mandriva 64-Bit
1170 osTypeVBox = SchemaDefs_OSTypeId_Mandriva_64;
1171 break;
1172
1173 case CIMOSType_CIMOS_Ubuntu: // 93 - Ubuntu
1174 osTypeVBox = SchemaDefs_OSTypeId_Ubuntu;
1175 break;
1176
1177 case CIMOSType_CIMOS_Ubuntu_64: // 94 - Ubuntu 64-Bit
1178 osTypeVBox = SchemaDefs_OSTypeId_Ubuntu_64;
1179 break;
1180
1181 case CIMOSType_CIMOS_Debian: // 95 - Debian
1182 osTypeVBox = SchemaDefs_OSTypeId_Debian;
1183 break;
1184
1185 case CIMOSType_CIMOS_Debian_64: // 96 - Debian 64-Bit
1186 osTypeVBox = SchemaDefs_OSTypeId_Debian_64;
1187 break;
1188
1189 case CIMOSType_CIMOS_Linux_2_4_x: // 97 - Linux 2.4.x
1190 osTypeVBox = SchemaDefs_OSTypeId_Linux24;
1191 break;
1192
1193 case CIMOSType_CIMOS_Linux_2_4_x_64: // 98 - Linux 2.4.x 64-Bit
1194 osTypeVBox = SchemaDefs_OSTypeId_Linux24_64;
1195 break;
1196
1197 case CIMOSType_CIMOS_Linux_2_6_x: // 99 - Linux 2.6.x
1198 osTypeVBox = SchemaDefs_OSTypeId_Linux26;
1199 break;
1200
1201 case CIMOSType_CIMOS_Linux_2_6_x_64: // 100 - Linux 2.6.x 64-Bit
1202 osTypeVBox = SchemaDefs_OSTypeId_Linux26_64;
1203 break;
1204 default:
1205 {
1206 /* If we are here we have no clue what OS this should be. Set
1207 to other type as default. */
1208 osTypeVBox = SchemaDefs_OSTypeId_Other;
1209 }
1210 }
1211}
1212
1213/**
1214 * Public method implementation.
1215 * @param path
1216 * @return
1217 */
1218STDMETHODIMP Appliance::Read(IN_BSTR path)
1219{
1220 HRESULT rc = S_OK;
1221
1222 if (!path)
1223 return E_POINTER;
1224
1225 AutoCaller autoCaller(this);
1226 CheckComRCReturnRC(autoCaller.rc());
1227
1228 AutoWriteLock alock(this);
1229
1230 // see if we can handle this file; for now we insist it has an ".ovf" extension
1231 m->strPath = path;
1232 const char *pcszLastDot = strrchr(m->strPath, '.');
1233 if ( (!pcszLastDot)
1234 || ( strcmp(pcszLastDot, ".ovf")
1235 && strcmp(pcszLastDot, ".OVF")
1236 )
1237 )
1238 return setError(VBOX_E_FILE_ERROR,
1239 tr("Appliance file must have .ovf extension"));
1240
1241 try
1242 {
1243 xml::XmlFileParser parser;
1244 xml::Document doc;
1245 parser.read(m->strPath.raw(),
1246 doc);
1247
1248 const xml::Node *pRootElem = doc.getRootElement();
1249 if (strcmp(pRootElem->getName(), "Envelope"))
1250 return setError(VBOX_E_FILE_ERROR,
1251 tr("Root element in OVF file must be \"Envelope\"."));
1252
1253 // OVF has the following rough layout:
1254 /*
1255 -- <References> .... files referenced from other parts of the file, such as VMDK images
1256 -- Metadata, comprised of several section commands
1257 -- virtual machines, either a single <VirtualSystem>, or a <VirtualSystemCollection>
1258 -- optionally <Strings> for localization
1259 */
1260
1261 // get all "File" child elements of "References" section so we can look up files easily;
1262 // first find the "References" sections so we can look up files
1263 xml::NodesList listFileElements; // receives all /Envelope/References/File nodes
1264 const xml::Node *pReferencesElem;
1265 if ((pReferencesElem = pRootElem->findChildElement("References")))
1266 pReferencesElem->getChildElements(listFileElements, "File");
1267
1268 // now go though the sections
1269 if (!(SUCCEEDED(rc = LoopThruSections(m->strPath.raw(), pReferencesElem, pRootElem))))
1270 return rc;
1271 }
1272 catch(xml::Error &x)
1273 {
1274 return setError(VBOX_E_FILE_ERROR,
1275 x.what());
1276 }
1277
1278 return S_OK;
1279}
1280
1281/**
1282 * Public method implementation.
1283 * @return
1284 */
1285STDMETHODIMP Appliance::Interpret()
1286{
1287 // @todo:
1288 // - don't use COM methods but the methods directly (faster, but needs appropriate locking of that objects itself (s. HardDisk))
1289 // - Appropriate handle errors like not supported file formats
1290 AutoCaller autoCaller(this);
1291 CheckComRCReturnRC(autoCaller.rc());
1292
1293 AutoWriteLock(this);
1294
1295 HRESULT rc = S_OK;
1296
1297 /* Clear any previous virtual system descriptions */
1298 // @todo: have the entries deleted also?
1299 m->virtualSystemDescriptions.clear();
1300
1301 /* We need the default path for storing disk images */
1302 ComPtr<ISystemProperties> systemProps;
1303 rc = mVirtualBox->COMGETTER(SystemProperties)(systemProps.asOutParam());
1304 CheckComRCReturnRC(rc);
1305 Bstr bstrDefaultHardDiskLocation;
1306 rc = systemProps->COMGETTER(DefaultHardDiskFolder)(bstrDefaultHardDiskLocation.asOutParam());
1307 CheckComRCReturnRC(rc);
1308
1309 /* Try/catch so we can clean up on error */
1310 try
1311 {
1312 list<VirtualSystem>::const_iterator it;
1313 /* Iterate through all virtual systems */
1314 for (it = m->llVirtualSystems.begin();
1315 it != m->llVirtualSystems.end();
1316 ++it)
1317 {
1318 const VirtualSystem &vsysThis = *it;
1319
1320 ComObjPtr<VirtualSystemDescription> pNewDesc;
1321 rc = pNewDesc.createObject();
1322 CheckComRCThrowRC(rc);
1323 rc = pNewDesc->init();
1324 CheckComRCThrowRC(rc);
1325
1326 /* Guest OS type */
1327 Utf8Str strOsTypeVBox,
1328 strCIMOSType = Utf8StrFmt("%RI32", (uint32_t)vsysThis.cimos);
1329 convertCIMOSType2VBoxOSType(strOsTypeVBox, vsysThis.cimos);
1330 pNewDesc->addEntry(VirtualSystemDescriptionType_OS,
1331 "",
1332 strCIMOSType,
1333 strOsTypeVBox);
1334
1335 /* VM name */
1336 /* If the there isn't any name specified create a default one out of
1337 * the OS type */
1338 Utf8Str nameVBox = vsysThis.strName;
1339 if (nameVBox == "")
1340 nameVBox = strOsTypeVBox;
1341 searchUniqueVMName(nameVBox);
1342 pNewDesc->addEntry(VirtualSystemDescriptionType_Name,
1343 "",
1344 vsysThis.strName,
1345 nameVBox);
1346
1347 /* Now that we know the OS type, get our internal defaults based on that. */
1348 ComPtr<IGuestOSType> pGuestOSType;
1349 rc = mVirtualBox->GetGuestOSType(Bstr(strOsTypeVBox), pGuestOSType.asOutParam());
1350 CheckComRCThrowRC(rc);
1351
1352 /* CPU count */
1353 ULONG cpuCountVBox = vsysThis.cCPUs;
1354 /* Check for the constrains */
1355 if (cpuCountVBox > 1) //SchemaDefs::MaxCPUCount)
1356 {
1357 pNewDesc->addWarning(tr("The virtual system claims support for %u CPU's, but VirtualBox has support for max %u CPU's only."),
1358 cpuCountVBox, 1); //SchemaDefs::MaxCPUCount);
1359 cpuCountVBox = 1; //SchemaDefs::MaxCPUCount;
1360 }
1361 if (vsysThis.cCPUs == 0)
1362 cpuCountVBox = 1;
1363 pNewDesc->addEntry(VirtualSystemDescriptionType_CPU,
1364 "",
1365 Utf8StrFmt("%RI32", (uint32_t)vsysThis.cCPUs),
1366 Utf8StrFmt("%RI32", (uint32_t)cpuCountVBox));
1367
1368 /* RAM */
1369 uint64_t ullMemSizeVBox = vsysThis.ullMemorySize / _1M;
1370 /* Check for the constrains */
1371 if (ullMemSizeVBox != 0 &&
1372 (ullMemSizeVBox < static_cast<uint64_t>(SchemaDefs::MinGuestRAM) ||
1373 ullMemSizeVBox > static_cast<uint64_t>(SchemaDefs::MaxGuestRAM)))
1374 {
1375 pNewDesc->addWarning(tr("The virtual system claims support for %llu MB RAM size, but VirtualBox has support for min %u & max %u MB RAM size only."),
1376 ullMemSizeVBox, SchemaDefs::MinGuestRAM, SchemaDefs::MaxGuestRAM);
1377 ullMemSizeVBox = RT_MIN(RT_MAX(ullMemSizeVBox, static_cast<uint64_t>(SchemaDefs::MinGuestRAM)), static_cast<uint64_t>(SchemaDefs::MaxGuestRAM));
1378 }
1379 if (vsysThis.ullMemorySize == 0)
1380 {
1381 /* If the RAM of the OVF is zero, use our predefined values */
1382 ULONG memSizeVBox2;
1383 rc = pGuestOSType->COMGETTER(RecommendedRAM)(&memSizeVBox2);
1384 CheckComRCThrowRC(rc);
1385 /* VBox stores that in MByte */
1386 ullMemSizeVBox = (uint64_t)memSizeVBox2;
1387 }
1388 pNewDesc->addEntry(VirtualSystemDescriptionType_Memory,
1389 "",
1390 Utf8StrFmt("%RI64", (uint64_t)vsysThis.ullMemorySize),
1391 Utf8StrFmt("%RI64", (uint64_t)ullMemSizeVBox));
1392
1393 /* Audio */
1394 if (!vsysThis.strSoundCardType.isNull())
1395 /* Currently we set the AC97 always.
1396 @todo: figure out the hardware which could be possible */
1397 pNewDesc->addEntry(VirtualSystemDescriptionType_SoundCard,
1398 "",
1399 vsysThis.strSoundCardType,
1400 Utf8StrFmt("%RI32", (uint32_t)AudioControllerType_AC97));
1401
1402#ifdef VBOX_WITH_USB
1403 /* USB Controller */
1404 if (vsysThis.fHasUsbController)
1405 pNewDesc->addEntry(VirtualSystemDescriptionType_USBController, "", "", "");
1406#endif /* VBOX_WITH_USB */
1407
1408 NetworksMap::const_iterator itN;
1409 for (itN = m->mapNetworks.begin();
1410 itN != m->mapNetworks.end();
1411 ++itN)
1412 {
1413 const Network &nw = itN->second;
1414 pNewDesc->addEntry(VirtualSystemDescriptionType_LogicalNetwork,
1415 "",
1416 nw.strNetworkName,
1417 nw.strNetworkName);
1418 }
1419
1420 /* Network Controller */
1421 // @todo: there is no hardware specification in the OVF file; supposedly the
1422 // hardware will then be determined by the VirtualSystemType element (e.g. "vmx-07")
1423 if (vsysThis.llNetworkNames.size() > 0)
1424 {
1425 /* Check for the constrains */
1426 if (vsysThis.llNetworkNames.size() > SchemaDefs::NetworkAdapterCount)
1427 {
1428 pNewDesc->addWarning(tr("The virtual system claims support for %u network adapters, but VirtualBox has support for max %u network adapter only."),
1429 vsysThis.llNetworkNames.size(), SchemaDefs::NetworkAdapterCount);
1430
1431 }
1432 /* Get the default network adapter type for the selected guest OS */
1433 NetworkAdapterType_T nwAdapterVBox = NetworkAdapterType_Am79C970A;
1434 rc = pGuestOSType->COMGETTER(AdapterType)(&nwAdapterVBox);
1435 CheckComRCThrowRC(rc);
1436 list<Utf8Str>::const_iterator nwIt;
1437 /* Iterate through all abstract networks. We support 8 network
1438 * adapters at the maximum, so the first 8 will be added only. */
1439 size_t a = 0;
1440 for (nwIt = vsysThis.llNetworkNames.begin();
1441 nwIt != vsysThis.llNetworkNames.end() && a < SchemaDefs::NetworkAdapterCount;
1442 ++nwIt, ++a)
1443 {
1444 Utf8Str strNetwork = *nwIt; // logical network to connect to
1445 pNewDesc->addEntry(VirtualSystemDescriptionType_NetworkAdapter,
1446 "", // ref
1447 strNetwork, // orig
1448 Utf8StrFmt("%RI32", (uint32_t)nwAdapterVBox), // conf
1449 Utf8StrFmt("network=%s", strNetwork.c_str())); // extra conf
1450 }
1451 }
1452
1453 /* Floppy Drive */
1454 if (vsysThis.fHasFloppyDrive)
1455 pNewDesc->addEntry(VirtualSystemDescriptionType_Floppy, "", "", "");
1456
1457 /* CD Drive */
1458 /* @todo: I can't disable the CDROM. So nothing to do for now */
1459 /*
1460 if (vsysThis.fHasCdromDrive)
1461 pNewDesc->addEntry(VirtualSystemDescriptionType_CDROM, "", "", "");*/
1462
1463 /* Hard disk Controller */
1464 uint16_t cIDEused = 0;
1465 uint16_t cSATAused = 0;
1466 uint16_t cSCSIused = 0;
1467 ControllersMap::const_iterator hdcIt;
1468 /* Iterate through all hard disk controllers */
1469 for (hdcIt = vsysThis.mapControllers.begin();
1470 hdcIt != vsysThis.mapControllers.end();
1471 ++hdcIt)
1472 {
1473 const HardDiskController &hdc = hdcIt->second;
1474 Utf8Str strControllerID = Utf8StrFmt("%RI32", (uint32_t)hdc.idController);
1475
1476 switch (hdc.system)
1477 {
1478 case HardDiskController::IDE:
1479 {
1480 /* Check for the constrains */
1481 /* @todo: I'm very confused! Are these bits *one* controller or
1482 is every port/bus declared as an extra controller. */
1483 if (cIDEused < 4)
1484 {
1485 // @todo: figure out the IDE types
1486 /* Use PIIX4 as default */
1487 Utf8Str strType = "PIIX4";
1488 if (!RTStrICmp(hdc.strControllerType.c_str(), "PIIX3"))
1489 strType = "PIIX3";
1490 pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskControllerIDE,
1491 strControllerID,
1492 hdc.strControllerType,
1493 strType);
1494 }
1495 else
1496 {
1497 /* Warn only once */
1498 if (cIDEused == 1)
1499 pNewDesc->addWarning(tr("The virtual system claims support for more than one IDE controller, but VirtualBox has support for only one."));
1500
1501 }
1502 ++cIDEused;
1503 break;
1504 }
1505
1506#ifdef VBOX_WITH_AHCI
1507 case HardDiskController::SATA:
1508 {
1509 /* Check for the constrains */
1510 if (cSATAused < 1)
1511 {
1512 // @todo: figure out the SATA types
1513 /* We only support a plain AHCI controller, so use them always */
1514 pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskControllerSATA,
1515 strControllerID,
1516 hdc.strControllerType,
1517 "AHCI");
1518 }
1519 else
1520 {
1521 /* Warn only once */
1522 if (cSATAused == 1)
1523 pNewDesc->addWarning(tr("The virtual system claims support for more than one SATA controller, but VirtualBox has support for only one."));
1524
1525 }
1526 ++cSATAused;
1527 break;
1528 }
1529#endif /* VBOX_WITH_AHCI */
1530
1531 case HardDiskController::SCSI:
1532 {
1533 /* Check for the constrains */
1534 if (cSCSIused < 1)
1535 {
1536 // @todo: figure out the SCSI types
1537 Utf8Str hdcController = "LsiLogic";
1538 /* if (!RTStrICmp(hdc.strControllerType.c_str(), "LsiLogic"))
1539 hdcController = "LsiLogic";
1540 else*/
1541 if (!RTStrICmp(hdc.strControllerType.c_str(), "BusLogic"))
1542 hdcController = "BusLogic";
1543 pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskControllerSCSI,
1544 strControllerID,
1545 hdc.strControllerType,
1546 hdcController);
1547 }
1548 else
1549 {
1550 /* Warn only once */
1551 if (cSCSIused == 1)
1552 pNewDesc->addWarning(tr("The virtual system claims support for more than one SCSI controller, but VirtualBox has support for only one."));
1553
1554 }
1555 ++cSCSIused;
1556 break;
1557 }
1558 default:
1559 {
1560 /* @todo: should we stop? */
1561 }
1562 }
1563 }
1564
1565 /* Hard disks */
1566 if (vsysThis.mapVirtualDisks.size() > 0)
1567 {
1568 VirtualDisksMap::const_iterator itVD;
1569 /* Iterate through all hard disks ()*/
1570 for (itVD = vsysThis.mapVirtualDisks.begin();
1571 itVD != vsysThis.mapVirtualDisks.end();
1572 ++itVD)
1573 {
1574 const VirtualDisk &hd = itVD->second;
1575 /* Get the associated disk image */
1576 const DiskImage &di = m->mapDisks[hd.strDiskId];
1577
1578 // @todo:
1579 // - figure out all possible vmdk formats we also support
1580 // - figure out if there is a url specifier for vhd already
1581 // - we need a url specifier for the vdi format
1582 if ( (!RTStrICmp(di.strFormat.c_str(), "http://www.vmware.com/specifications/vmdk.html#sparse"))
1583 || (!RTStrICmp(di.strFormat.c_str(), "http://www.vmware.com/specifications/vmdk.html#compressed"))
1584 )
1585 {
1586 /* If the href is empty use the VM name as filename */
1587 Utf8Str strFilename = di.strHref;
1588 if (!strFilename.length())
1589 strFilename = Utf8StrFmt("%s.vmdk", nameVBox.c_str());
1590 /* Construct a unique target path */
1591 Utf8StrFmt strPath("%ls%c%s",
1592 bstrDefaultHardDiskLocation.raw(),
1593 RTPATH_DELIMITER,
1594 strFilename.c_str());
1595 searchUniqueDiskImageFilePath(strPath);
1596
1597 /* find the description for the hard disk controller
1598 * that has the same ID as hd.idController */
1599 const VirtualSystemDescriptionEntry *pController;
1600 if (!(pController = pNewDesc->findControllerFromID(hd.idController)))
1601 throw setError(E_FAIL,
1602 tr("Internal inconsistency looking up hard disk controller."));
1603
1604 /* controller to attach to, and the bus within that controller */
1605 Utf8StrFmt strExtraConfig("controller=%RI16;channel=%RI16",
1606 pController->ulIndex,
1607 hd.ulAddressOnParent);
1608 pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskImage,
1609 hd.strDiskId,
1610 di.strHref,
1611 strPath,
1612 strExtraConfig);
1613 }
1614 else
1615 {
1616 /* @todo: should we stop here? */
1617 pNewDesc->addWarning(tr("The virtual system claims support for the following virtual disk image format which VirtualBox not support: %s"),
1618 di.strFormat.c_str());
1619 }
1620 }
1621 }
1622
1623 m->virtualSystemDescriptions.push_back(pNewDesc);
1624 }
1625 }
1626 catch (HRESULT aRC)
1627 {
1628 /* On error we clear the list & return */
1629 m->virtualSystemDescriptions.clear();
1630 rc = aRC;
1631 }
1632
1633 return rc;
1634}
1635
1636/**
1637 * Public method implementation.
1638 * @param aProgress
1639 * @return
1640 */
1641STDMETHODIMP Appliance::ImportMachines(IProgress **aProgress)
1642{
1643 CheckComArgOutPointerValid(aProgress);
1644
1645 AutoCaller autoCaller(this);
1646 CheckComRCReturnRC(autoCaller.rc());
1647
1648 AutoReadLock(this);
1649
1650 HRESULT rc = S_OK;
1651
1652 ComObjPtr<Progress> progress;
1653 try
1654 {
1655 uint32_t opCount = calcMaxProgress();
1656 Bstr progressDesc = BstrFmt(tr("Import appliance '%s'"),
1657 m->strPath.raw());
1658 /* Create the progress object */
1659 progress.createObject();
1660 rc = progress->init(mVirtualBox, static_cast<IAppliance*>(this),
1661 progressDesc,
1662 FALSE /* aCancelable */,
1663 opCount,
1664 progressDesc);
1665 if (FAILED(rc)) throw rc;
1666
1667 /* Initialize our worker task */
1668 std::auto_ptr<TaskImportMachines> task(new TaskImportMachines(this, progress));
1669 //AssertComRCThrowRC (task->autoCaller.rc());
1670
1671 rc = task->startThread();
1672 if (FAILED(rc)) throw rc;
1673
1674 task.release();
1675 }
1676 catch (HRESULT aRC)
1677 {
1678 rc = aRC;
1679 }
1680
1681 if (SUCCEEDED(rc))
1682 /* Return progress to the caller */
1683 progress.queryInterfaceTo(aProgress);
1684
1685 return rc;
1686}
1687
1688STDMETHODIMP Appliance::Write(IN_BSTR path, IProgress **aProgress)
1689{
1690 HRESULT rc = S_OK;
1691
1692 CheckComArgOutPointerValid(aProgress);
1693
1694 AutoCaller autoCaller(this);
1695 if (FAILED(rc = autoCaller.rc())) return rc;
1696
1697 AutoWriteLock(this);
1698
1699 // see if we can handle this file; for now we insist it has an ".ovf" extension
1700 m->strPath = path;
1701 const char *pcszLastDot = strrchr(m->strPath, '.');
1702 if ( (!pcszLastDot)
1703 || ( strcmp(pcszLastDot, ".ovf")
1704 && strcmp(pcszLastDot, ".OVF")
1705 )
1706 )
1707 return setError(VBOX_E_FILE_ERROR,
1708 tr("Appliance file must have .ovf extension"));
1709
1710 ComObjPtr<Progress> progress;
1711 try
1712 {
1713 uint32_t opCount = calcMaxProgress();
1714 Bstr progressDesc = BstrFmt(tr("Write appliance '%s'"),
1715 m->strPath.raw());
1716 /* Create the progress object */
1717 progress.createObject();
1718 rc = progress->init(mVirtualBox, static_cast<IAppliance*>(this),
1719 progressDesc,
1720 FALSE /* aCancelable */,
1721 opCount,
1722 progressDesc);
1723 CheckComRCThrowRC(rc);
1724
1725 /* Initialize our worker task */
1726 std::auto_ptr<TaskExportOVF> task(new TaskExportOVF(this, progress));
1727 //AssertComRCThrowRC (task->autoCaller.rc());
1728
1729 rc = task->startThread();
1730 CheckComRCThrowRC(rc);
1731
1732 task.release();
1733 }
1734 catch (HRESULT aRC)
1735 {
1736 rc = aRC;
1737 }
1738
1739 if (SUCCEEDED(rc))
1740 /* Return progress to the caller */
1741 progress.queryInterfaceTo(aProgress);
1742
1743 return rc;
1744}
1745
1746HRESULT Appliance::searchUniqueVMName(Utf8Str& aName) const
1747{
1748 IMachine *machine = NULL;
1749 char *tmpName = RTStrDup(aName.c_str());
1750 int i = 1;
1751 /* @todo: Maybe too cost-intensive; try to find a lighter way */
1752 while (mVirtualBox->FindMachine(Bstr(tmpName), &machine) != VBOX_E_OBJECT_NOT_FOUND)
1753 {
1754 RTStrFree(tmpName);
1755 RTStrAPrintf(&tmpName, "%s_%d", aName.c_str(), i);
1756 ++i;
1757 }
1758 aName = tmpName;
1759 RTStrFree(tmpName);
1760
1761 return S_OK;
1762}
1763
1764HRESULT Appliance::searchUniqueDiskImageFilePath(Utf8Str& aName) const
1765{
1766 IHardDisk *harddisk = NULL;
1767 char *tmpName = RTStrDup(aName.c_str());
1768 int i = 1;
1769 /* Check if the file exists or if a file with this path is registered
1770 * already */
1771 /* @todo: Maybe too cost-intensive; try to find a lighter way */
1772 while (RTPathExists(tmpName) ||
1773 mVirtualBox->FindHardDisk(Bstr(tmpName), &harddisk) != VBOX_E_OBJECT_NOT_FOUND)
1774 {
1775 RTStrFree(tmpName);
1776 char *tmpDir = RTStrDup(aName.c_str());
1777 RTPathStripFilename(tmpDir);;
1778 char *tmpFile = RTStrDup(RTPathFilename(aName.c_str()));
1779 RTPathStripExt(tmpFile);
1780 const char *tmpExt = RTPathExt(aName.c_str());
1781 RTStrAPrintf(&tmpName, "%s%c%s_%d%s", tmpDir, RTPATH_DELIMITER, tmpFile, i, tmpExt);
1782 RTStrFree(tmpFile);
1783 RTStrFree(tmpDir);
1784 ++i;
1785 }
1786 aName = tmpName;
1787 RTStrFree(tmpName);
1788
1789 return S_OK;
1790}
1791
1792/**
1793 * Calculates the maximum progress value for importMachines() and write().
1794 * @return
1795 */
1796uint32_t Appliance::calcMaxProgress()
1797{
1798 /* Figure out how many sub operation the import will need */
1799 /* One for the appliance */
1800 uint32_t opCount = 1;
1801 list< ComObjPtr<VirtualSystemDescription> >::const_iterator it;
1802 for (it = m->virtualSystemDescriptions.begin();
1803 it != m->virtualSystemDescriptions.end();
1804 ++it)
1805 {
1806 /* One for every Virtual System */
1807 ++opCount;
1808 ComObjPtr<VirtualSystemDescription> vsdescThis = (*it);
1809 /* One for every hard disk of the Virtual System */
1810 std::list<VirtualSystemDescriptionEntry*> avsdeHDs = vsdescThis->findByType(VirtualSystemDescriptionType_HardDiskImage);
1811 opCount += (uint32_t)avsdeHDs.size();
1812 }
1813
1814 return opCount;
1815}
1816
1817struct MyHardDiskAttachment
1818{
1819 Guid uuid;
1820 ComPtr<IMachine> pMachine;
1821 StorageBus_T busType;
1822 int32_t lChannel;
1823 int32_t lDevice;
1824};
1825
1826/**
1827 * Worker thread implementation for ImportMachines().
1828 * @param aThread
1829 * @param pvUser
1830 */
1831/* static */
1832DECLCALLBACK(int) Appliance::taskThreadImportMachines(RTTHREAD aThread, void *pvUser)
1833{
1834 std::auto_ptr<TaskImportMachines> task(static_cast<TaskImportMachines*>(pvUser));
1835 AssertReturn(task.get(), VERR_GENERAL_FAILURE);
1836
1837 Appliance *pAppliance = task->pAppliance;
1838
1839 LogFlowFuncEnter();
1840 LogFlowFunc(("Appliance %p\n", pAppliance));
1841
1842 AutoCaller autoCaller(pAppliance);
1843 CheckComRCReturnRC(autoCaller.rc());
1844
1845 AutoWriteLock appLock(pAppliance);
1846
1847 HRESULT rc = S_OK;
1848
1849 ComPtr<IVirtualBox> pVirtualBox(pAppliance->mVirtualBox);
1850
1851 // rollback for errors:
1852 // 1) a list of images that we created/imported
1853 list<MyHardDiskAttachment> llHardDiskAttachments;
1854 list< ComPtr<IHardDisk> > llHardDisksCreated;
1855 list<Guid> llMachinesRegistered;
1856
1857 ComPtr<ISession> session;
1858 bool fSessionOpen = false;
1859 rc = session.createInprocObject(CLSID_Session);
1860 CheckComRCReturnRC(rc);
1861
1862 list<VirtualSystem>::const_iterator it;
1863 list< ComObjPtr<VirtualSystemDescription> >::const_iterator it1;
1864 /* Iterate through all virtual systems of that appliance */
1865 size_t i = 0;
1866 for (it = pAppliance->m->llVirtualSystems.begin(),
1867 it1 = pAppliance->m->virtualSystemDescriptions.begin();
1868 it != pAppliance->m->llVirtualSystems.end();
1869 ++it, ++it1, ++i)
1870 {
1871 const VirtualSystem &vsysThis = *it;
1872 ComObjPtr<VirtualSystemDescription> vsdescThis = (*it1);
1873
1874 ComPtr<IMachine> pNewMachine;
1875
1876 /* Catch possible errors */
1877 try
1878 {
1879 if (!task->progress.isNull())
1880 task->progress->advanceOperation(BstrFmt(tr("Importing Virtual System %d"), i + 1));
1881
1882 /* How many sub notifications are necessary? */
1883 const float opCountMax = 100.0/5;
1884 uint32_t opCount = 0;
1885
1886 /* Guest OS type */
1887 std::list<VirtualSystemDescriptionEntry*> vsdeOS;
1888 vsdeOS = vsdescThis->findByType(VirtualSystemDescriptionType_OS);
1889 if (vsdeOS.size() < 1)
1890 throw setError(VBOX_E_FILE_ERROR,
1891 tr("Missing guest OS type"));
1892 const Utf8Str &strOsTypeVBox = vsdeOS.front()->strVbox;
1893
1894 /* Now that we know the base system get our internal defaults based on that. */
1895 ComPtr<IGuestOSType> osType;
1896 rc = pVirtualBox->GetGuestOSType(Bstr(strOsTypeVBox), osType.asOutParam());
1897 if (FAILED(rc)) throw rc;
1898
1899 /* Create the machine */
1900 /* First get the name */
1901 std::list<VirtualSystemDescriptionEntry*> vsdeName = vsdescThis->findByType(VirtualSystemDescriptionType_Name);
1902 if (vsdeName.size() < 1)
1903 throw setError(VBOX_E_FILE_ERROR,
1904 tr("Missing VM name"));
1905 const Utf8Str &strNameVBox = vsdeName.front()->strVbox;
1906 rc = pVirtualBox->CreateMachine(Bstr(strNameVBox), Bstr(strOsTypeVBox),
1907 Bstr(), Guid(),
1908 pNewMachine.asOutParam());
1909 if (FAILED(rc)) throw rc;
1910
1911 if (!task->progress.isNull())
1912 rc = task->progress->notifyProgress((uint32_t)(opCountMax * opCount++));
1913
1914 /* CPU count (ignored for now) */
1915 // EntriesList vsdeCPU = vsd->findByType (VirtualSystemDescriptionType_CPU);
1916
1917 /* RAM */
1918 std::list<VirtualSystemDescriptionEntry*> vsdeRAM = vsdescThis->findByType(VirtualSystemDescriptionType_Memory);
1919 ComAssertMsgThrow(vsdeRAM.size() == 1, ("RAM size missing"), E_FAIL);
1920 const Utf8Str &memoryVBox = vsdeRAM.front()->strVbox;
1921 ULONG tt = (ULONG)RTStrToUInt64(memoryVBox.c_str());
1922 rc = pNewMachine->COMSETTER(MemorySize)(tt);
1923 if (FAILED(rc)) throw rc;
1924
1925 /* VRAM */
1926 /* Get the recommended VRAM for this guest OS type */
1927 ULONG vramVBox;
1928 rc = osType->COMGETTER(RecommendedVRAM)(&vramVBox);
1929 if (FAILED(rc)) throw rc;
1930
1931 /* Set the VRAM */
1932 rc = pNewMachine->COMSETTER(VRAMSize)(vramVBox);
1933 if (FAILED(rc)) throw rc;
1934
1935 if (!task->progress.isNull())
1936 task->progress->notifyProgress((uint32_t)(opCountMax * opCount++));
1937
1938 /* Audio Adapter */
1939 std::list<VirtualSystemDescriptionEntry*> vsdeAudioAdapter = vsdescThis->findByType(VirtualSystemDescriptionType_SoundCard);
1940 /* @todo: we support one audio adapter only */
1941 if (vsdeAudioAdapter.size() > 0)
1942 {
1943 const Utf8Str& audioAdapterVBox = vsdeAudioAdapter.front()->strVbox;
1944 if (RTStrICmp(audioAdapterVBox, "null") != 0)
1945 {
1946 uint32_t audio = RTStrToUInt32(audioAdapterVBox.c_str());
1947 ComPtr<IAudioAdapter> audioAdapter;
1948 rc = pNewMachine->COMGETTER(AudioAdapter)(audioAdapter.asOutParam());
1949 if (FAILED(rc)) throw rc;
1950 rc = audioAdapter->COMSETTER(Enabled)(true);
1951 if (FAILED(rc)) throw rc;
1952 rc = audioAdapter->COMSETTER(AudioController)(static_cast<AudioControllerType_T>(audio));
1953 if (FAILED(rc)) throw rc;
1954 }
1955 }
1956
1957#ifdef VBOX_WITH_USB
1958 /* USB Controller */
1959 std::list<VirtualSystemDescriptionEntry*> vsdeUSBController = vsdescThis->findByType(VirtualSystemDescriptionType_USBController);
1960 // USB support is enabled if there's at least one such entry; to disable USB support,
1961 // the type of the USB item would have been changed to "ignore"
1962 bool fUSBEnabled = vsdeUSBController.size() > 0;
1963
1964 ComPtr<IUSBController> usbController;
1965 rc = pNewMachine->COMGETTER(USBController)(usbController.asOutParam());
1966 if (FAILED(rc)) throw rc;
1967 rc = usbController->COMSETTER(Enabled)(fUSBEnabled);
1968 if (FAILED(rc)) throw rc;
1969#endif /* VBOX_WITH_USB */
1970
1971 if (!task->progress.isNull())
1972 task->progress->notifyProgress((uint32_t)(opCountMax * opCount++));
1973
1974 /* Change the network adapters */
1975 std::list<VirtualSystemDescriptionEntry*> vsdeNW = vsdescThis->findByType(VirtualSystemDescriptionType_NetworkAdapter);
1976 if (vsdeNW.size() == 0)
1977 {
1978 /* No network adapters, so we have to disable our default one */
1979 ComPtr<INetworkAdapter> nwVBox;
1980 rc = pNewMachine->GetNetworkAdapter(0, nwVBox.asOutParam());
1981 if (FAILED(rc)) throw rc;
1982 rc = nwVBox->COMSETTER(Enabled)(false);
1983 if (FAILED(rc)) throw rc;
1984 }
1985 else
1986 {
1987 list<VirtualSystemDescriptionEntry*>::const_iterator nwIt;
1988 /* Iterate through all network cards. We support 8 network adapters
1989 * at the maximum. (@todo: warn if there are more!) */
1990 size_t a = 0;
1991 for (nwIt = vsdeNW.begin();
1992 (nwIt != vsdeNW.end() && a < SchemaDefs::NetworkAdapterCount);
1993 ++nwIt, ++a)
1994 {
1995 const Utf8Str &nwTypeVBox = (*nwIt)->strVbox;
1996 uint32_t tt1 = RTStrToUInt32(nwTypeVBox.c_str());
1997 ComPtr<INetworkAdapter> nwVBox;
1998 rc = pNewMachine->GetNetworkAdapter((ULONG)a, nwVBox.asOutParam());
1999 if (FAILED(rc)) throw rc;
2000 /* Enable the network card & set the adapter type */
2001 /* NAT is set as default */
2002 rc = nwVBox->COMSETTER(Enabled)(true);
2003 if (FAILED(rc)) throw rc;
2004 rc = nwVBox->COMSETTER(AdapterType)(static_cast<NetworkAdapterType_T>(tt1));
2005 if (FAILED(rc)) throw rc;
2006 }
2007 }
2008
2009 /* Floppy drive */
2010 std::list<VirtualSystemDescriptionEntry*> vsdeFloppy = vsdescThis->findByType(VirtualSystemDescriptionType_Floppy);
2011 // Floppy support is enabled if there's at least one such entry; to disable floppy support,
2012 // the type of the floppy item would have been changed to "ignore"
2013 bool fFloppyEnabled = vsdeFloppy.size() > 0;
2014 ComPtr<IFloppyDrive> floppyDrive;
2015 rc = pNewMachine->COMGETTER(FloppyDrive)(floppyDrive.asOutParam());
2016 if (FAILED(rc)) throw rc;
2017 rc = floppyDrive->COMSETTER(Enabled)(fFloppyEnabled);
2018 if (FAILED(rc)) throw rc;
2019
2020 if (!task->progress.isNull())
2021 task->progress->notifyProgress((uint32_t)(opCountMax * opCount++));
2022
2023 /* CDROM drive */
2024 /* @todo: I can't disable the CDROM. So nothing to do for now */
2025 // std::list<VirtualSystemDescriptionEntry*> vsdeFloppy = vsd->findByType(VirtualSystemDescriptionType_CDROM);
2026
2027 /* Hard disk controller IDE */
2028 std::list<VirtualSystemDescriptionEntry*> vsdeHDCIDE = vsdescThis->findByType(VirtualSystemDescriptionType_HardDiskControllerIDE);
2029 /* @todo: we support one IDE controller only */
2030 if (vsdeHDCIDE.size() > 0)
2031 {
2032 /* Set the appropriate IDE controller in the virtual BIOS of the VM */
2033 ComPtr<IBIOSSettings> biosSettings;
2034 rc = pNewMachine->COMGETTER(BIOSSettings)(biosSettings.asOutParam());
2035 if (FAILED(rc)) throw rc;
2036
2037 const char *pcszIDEType = vsdeHDCIDE.front()->strVbox.c_str();
2038 if (!strcmp(pcszIDEType, "PIIX3"))
2039 rc = biosSettings->COMSETTER(IDEControllerType)(IDEControllerType_PIIX3);
2040 else if (!strcmp(pcszIDEType, "PIIX4"))
2041 rc = biosSettings->COMSETTER(IDEControllerType)(IDEControllerType_PIIX4);
2042 else if (!strcmp(pcszIDEType, "ICH6"))
2043 rc = biosSettings->COMSETTER(IDEControllerType)(IDEControllerType_ICH6);
2044 else
2045 throw setError(VBOX_E_FILE_ERROR,
2046 tr("Invalid IDE controller type \"%s\""),
2047 pcszIDEType);
2048 if (FAILED(rc)) throw rc;
2049 }
2050#ifdef VBOX_WITH_AHCI
2051 /* Hard disk controller SATA */
2052 std::list<VirtualSystemDescriptionEntry*> vsdeHDCSATA = vsdescThis->findByType(VirtualSystemDescriptionType_HardDiskControllerSATA);
2053 /* @todo: we support one SATA controller only */
2054 if (vsdeHDCSATA.size() > 0)
2055 {
2056 const Utf8Str &hdcVBox = vsdeHDCIDE.front()->strVbox;
2057 if (hdcVBox == "AHCI")
2058 {
2059 /* For now we have just to enable the AHCI controller. */
2060 ComPtr<ISATAController> hdcSATAVBox;
2061 rc = pNewMachine->COMGETTER(SATAController)(hdcSATAVBox.asOutParam());
2062 if (FAILED(rc)) throw rc;
2063 rc = hdcSATAVBox->COMSETTER(Enabled)(true);
2064 if (FAILED(rc)) throw rc;
2065 }
2066 else
2067 {
2068 throw setError(VBOX_E_FILE_ERROR,
2069 tr("Invalid SATA controller type \"%s\""),
2070 hdcVBox.c_str());
2071 }
2072 }
2073#endif /* VBOX_WITH_AHCI */
2074
2075 /* Hard disk controller SCSI */
2076 std::list<VirtualSystemDescriptionEntry*> vsdeHDCSCSI = vsdescThis->findByType(VirtualSystemDescriptionType_HardDiskControllerSCSI);
2077 /* @todo: do we support more than one SCSI controller? */
2078 if (vsdeHDCSCSI.size() > 0)
2079 {
2080 /* @todo: revisit when Main support for SCSI is ready */
2081 }
2082
2083 /* Now its time to register the machine before we add any hard disks */
2084 rc = pVirtualBox->RegisterMachine(pNewMachine);
2085 if (FAILED(rc)) throw rc;
2086
2087 Guid newMachineId;
2088 rc = pNewMachine->COMGETTER(Id)(newMachineId.asOutParam());
2089 if (FAILED(rc)) throw rc;
2090
2091 if (!task->progress.isNull())
2092 task->progress->notifyProgress((uint32_t)(opCountMax * opCount++));
2093
2094 // store new machine for roll-back in case of errors
2095 llMachinesRegistered.push_back(newMachineId);
2096
2097 /* Create the hard disks & connect them to the appropriate controllers. */
2098 std::list<VirtualSystemDescriptionEntry*> avsdeHDs = vsdescThis->findByType(VirtualSystemDescriptionType_HardDiskImage);
2099 if (avsdeHDs.size() > 0)
2100 {
2101 /* If in the next block an error occur we have to deregister
2102 the machine, so make an extra try/catch block. */
2103 ComPtr<IHardDisk> srcHdVBox;
2104 bool fSourceHdNeedsClosing = false;
2105
2106 try
2107 {
2108 /* In order to attach hard disks we need to open a session
2109 * for the new machine */
2110 rc = pVirtualBox->OpenSession(session, newMachineId);
2111 if (FAILED(rc)) throw rc;
2112 fSessionOpen = true;
2113
2114 /* The disk image has to be on the same place as the OVF file. So
2115 * strip the filename out of the full file path. */
2116 Utf8Str strSrcDir = stripFilename(pAppliance->m->strPath);
2117
2118 /* Iterate over all given disk images */
2119 list<VirtualSystemDescriptionEntry*>::const_iterator itHD;
2120 for (itHD = avsdeHDs.begin();
2121 itHD != avsdeHDs.end();
2122 ++itHD)
2123 {
2124 VirtualSystemDescriptionEntry *vsdeHD = *itHD;
2125
2126 const char *pcszDstFilePath = vsdeHD->strVbox.c_str();
2127 /* Check if the destination file exists already or the
2128 * destination path is empty. */
2129 if ( !(*pcszDstFilePath)
2130 || RTPathExists(pcszDstFilePath)
2131 )
2132 /* This isn't allowed */
2133 throw setError(VBOX_E_FILE_ERROR,
2134 tr("Destination file '%s' exists",
2135 pcszDstFilePath));
2136
2137 /* Find the disk from the OVF's disk list */
2138 DiskImagesMap::const_iterator itDiskImage = pAppliance->m->mapDisks.find(vsdeHD->strRef);
2139 /* vsdeHD->strRef contains the disk identifier (e.g. "vmdisk1"), which should exist
2140 in the virtual system's disks map under that ID and also in the global images map. */
2141 VirtualDisksMap::const_iterator itVirtualDisk = vsysThis.mapVirtualDisks.find(vsdeHD->strRef);
2142
2143 if ( itDiskImage == pAppliance->m->mapDisks.end()
2144 || itVirtualDisk == vsysThis.mapVirtualDisks.end()
2145 )
2146 throw setError(E_FAIL,
2147 tr("Internal inconsistency looking up disk images."));
2148
2149 const DiskImage &di = itDiskImage->second;
2150 const VirtualDisk &vd = itVirtualDisk->second;
2151
2152 /* Make sure all target directories exists */
2153 rc = VirtualBox::ensureFilePathExists(pcszDstFilePath);
2154 if (FAILED(rc))
2155 throw rc;
2156
2157 ComPtr<IProgress> progress;
2158
2159 ComPtr<IHardDisk> dstHdVBox;
2160 /* If strHref is empty we have to create a new file */
2161 if (di.strHref.c_str()[0] == 0)
2162 {
2163 /* Which format to use? */
2164 Bstr srcFormat = L"VDI";
2165 if ( (!RTStrICmp(di.strFormat.c_str(), "http://www.vmware.com/specifications/vmdk.html#sparse"))
2166 || (!RTStrICmp(di.strFormat.c_str(), "http://www.vmware.com/specifications/vmdk.html#compressed")))
2167 srcFormat = L"VMDK";
2168 /* Create an empty hard disk */
2169 rc = pVirtualBox->CreateHardDisk(srcFormat, Bstr(pcszDstFilePath), dstHdVBox.asOutParam());
2170 if (FAILED(rc)) throw rc;
2171
2172 /* Create a dynamic growing disk image with the given capacity */
2173 ComPtr<IProgress> progress;
2174 rc = dstHdVBox->CreateDynamicStorage(di.iCapacity / _1M, progress.asOutParam());
2175 if (FAILED(rc)) throw rc;
2176
2177 /* Advance to the next operation */
2178 if (!task->progress.isNull())
2179 task->progress->advanceOperation (BstrFmt(tr("Creating virtual disk image '%s'"), pcszDstFilePath));
2180 }
2181 else
2182 {
2183 /* Construct the source file path */
2184 Utf8StrFmt strSrcFilePath("%s%c%s", strSrcDir.c_str(), RTPATH_DELIMITER, di.strHref.c_str());
2185 /* Check if the source file exists */
2186 if (!RTPathExists(strSrcFilePath.c_str()))
2187 /* This isn't allowed */
2188 throw setError(VBOX_E_FILE_ERROR,
2189 tr("Source virtual disk image file '%s' doesn't exist"),
2190 strSrcFilePath.c_str());
2191
2192 /* Clone the disk image (this is necessary cause the id has
2193 * to be recreated for the case the same hard disk is
2194 * attached already from a previous import) */
2195
2196 /* First open the existing disk image */
2197 rc = pVirtualBox->OpenHardDisk(Bstr(strSrcFilePath), srcHdVBox.asOutParam());
2198 if (FAILED(rc)) throw rc;
2199 fSourceHdNeedsClosing = true;
2200
2201 /* We need the format description of the source disk image */
2202 Bstr srcFormat;
2203 rc = srcHdVBox->COMGETTER(Format)(srcFormat.asOutParam());
2204 if (FAILED(rc)) throw rc;
2205 /* Create a new hard disk interface for the destination disk image */
2206 rc = pVirtualBox->CreateHardDisk(srcFormat, Bstr(pcszDstFilePath), dstHdVBox.asOutParam());
2207 if (FAILED(rc)) throw rc;
2208 /* Clone the source disk image */
2209 rc = srcHdVBox->CloneTo(dstHdVBox, progress.asOutParam());
2210 if (FAILED(rc)) throw rc;
2211
2212 /* Advance to the next operation */
2213 if (!task->progress.isNull())
2214 task->progress->advanceOperation (BstrFmt(tr("Importing virtual disk image '%s'"), strSrcFilePath.c_str()));
2215 }
2216
2217 // now loop until the asynchronous operation completes and then
2218 // report its result
2219 BOOL fCompleted;
2220 LONG currentPercent;
2221 while (SUCCEEDED(progress->COMGETTER(Completed(&fCompleted))))
2222 {
2223 rc = progress->COMGETTER(Percent(&currentPercent));
2224 if (FAILED(rc)) throw rc;
2225 if (!task->progress.isNull())
2226 task->progress->notifyProgress(currentPercent);
2227 if (fCompleted)
2228 break;
2229 /* Make sure the loop is not too tight */
2230 rc = progress->WaitForCompletion(100);
2231 if (FAILED(rc)) throw rc;
2232 }
2233 // report result of asynchronous operation
2234 HRESULT vrc;
2235 rc = progress->COMGETTER(ResultCode)(&vrc);
2236 if (FAILED(rc)) throw rc;
2237
2238 // if the thread of the progress object has an error, then
2239 // retrieve the error info from there, or it'll be lost
2240 if (FAILED(vrc))
2241 {
2242 com::ErrorInfo info(progress);
2243 const char *pcsz = Utf8Str(info.getText()).c_str();
2244 HRESULT rc2 = setError(vrc,
2245 pcsz);
2246 throw rc2;
2247 }
2248
2249 if (fSourceHdNeedsClosing)
2250 {
2251 rc = srcHdVBox->Close();
2252 if (FAILED(rc)) throw rc;
2253 fSourceHdNeedsClosing = false;
2254 }
2255
2256 llHardDisksCreated.push_back(dstHdVBox);
2257
2258 /* Now use the new uuid to attach the disk image to our new machine */
2259 ComPtr<IMachine> sMachine;
2260 rc = session->COMGETTER(Machine)(sMachine.asOutParam());
2261 if (FAILED(rc)) throw rc;
2262 Guid hdId;
2263 rc = dstHdVBox->COMGETTER(Id)(hdId.asOutParam());
2264 if (FAILED(rc)) throw rc;
2265
2266 /* For now we assume we have one controller of every type only */
2267 HardDiskController hdc = (*vsysThis.mapControllers.find(vd.idController)).second;
2268
2269 // this is for rollback later
2270 MyHardDiskAttachment mhda;
2271 mhda.uuid = newMachineId;
2272 mhda.pMachine = pNewMachine;
2273 mhda.busType = StorageBus_IDE;
2274
2275 switch (hdc.system)
2276 {
2277 case HardDiskController::IDE:
2278 // For the IDE bus, the channel parameter can be either 0 or 1, to specify the primary
2279 // or secondary IDE controller, respectively. For the primary controller of the IDE bus,
2280 // the device number can be either 0 or 1, to specify the master or the slave device,
2281 // respectively. For the secondary IDE controller, the device number is always 1 because
2282 // the master device is reserved for the CD-ROM drive.
2283 switch (vd.ulAddressOnParent)
2284 {
2285 case 0: // interpret this as primary master
2286 mhda.lChannel = (long)0;
2287 mhda.lDevice = (long)0;
2288 break;
2289
2290 case 1: // interpret this as primary slave
2291 mhda.lChannel = (long)0;
2292 mhda.lDevice = (long)1;
2293 break;
2294
2295 case 2: // interpret this as secondary slave
2296 mhda.lChannel = (long)1;
2297 mhda.lDevice = (long)1;
2298 break;
2299
2300 default:
2301 throw setError(VBOX_E_NOT_SUPPORTED,
2302 tr("Invalid channel %RI16 specified; IDE controllers support only 0, 1 or 2"), vd.ulAddressOnParent);
2303 break;
2304 }
2305 break;
2306
2307 case HardDiskController::SATA:
2308 mhda.busType = StorageBus_SATA;
2309 mhda.lChannel = (long)vd.ulAddressOnParent;
2310 mhda.lDevice = (long)0;
2311 break;
2312
2313 case HardDiskController::SCSI:
2314// mhda.busType = StorageBus_SCSI;
2315 throw setError(VBOX_E_NOT_SUPPORTED,
2316 tr("SCSI controller support is not available yet in VirtualBox"));
2317 // @todo
2318 break;
2319
2320 default: break;
2321 }
2322
2323 Log(("Attaching disk %s to channel %d on device %d\n", pcszDstFilePath, mhda.lChannel, mhda.lDevice));
2324
2325 rc = sMachine->AttachHardDisk(hdId,
2326 mhda.busType,
2327 mhda.lChannel,
2328 mhda.lDevice);
2329 if (FAILED(rc)) throw rc;
2330
2331 llHardDiskAttachments.push_back(mhda);
2332
2333 rc = sMachine->SaveSettings();
2334 if (FAILED(rc)) throw rc;
2335 } // end for (itHD = avsdeHDs.begin();
2336
2337 // only now that we're done with all disks, close the session
2338 rc = session->Close();
2339 if (FAILED(rc)) throw rc;
2340 fSessionOpen = false;
2341 }
2342 catch(HRESULT /* aRC */)
2343 {
2344 if (fSourceHdNeedsClosing)
2345 srcHdVBox->Close();
2346
2347 if (fSessionOpen)
2348 session->Close();
2349
2350 throw;
2351 }
2352 }
2353 }
2354 catch(HRESULT aRC)
2355 {
2356 rc = aRC;
2357 }
2358
2359 if (FAILED(rc))
2360 break;
2361
2362 } // for (it = pAppliance->m->llVirtualSystems.begin(),
2363
2364 if (FAILED(rc))
2365 {
2366 // with _whatever_ error we've had, do a complete roll-back of
2367 // machines and disks we've created; unfortunately this is
2368 // not so trivially done...
2369
2370 HRESULT rc2;
2371 // detach all hard disks from all machines we created
2372 list<MyHardDiskAttachment>::iterator itM;
2373 for (itM = llHardDiskAttachments.begin();
2374 itM != llHardDiskAttachments.end();
2375 ++itM)
2376 {
2377 const MyHardDiskAttachment &mhda = *itM;
2378 rc2 = pVirtualBox->OpenSession(session, mhda.uuid);
2379 if (SUCCEEDED(rc2))
2380 {
2381 ComPtr<IMachine> sMachine;
2382 rc2 = session->COMGETTER(Machine)(sMachine.asOutParam());
2383 if (SUCCEEDED(rc2))
2384 {
2385 rc2 = sMachine->DetachHardDisk(mhda.busType, mhda.lChannel, mhda.lDevice);
2386 rc2 = sMachine->SaveSettings();
2387 }
2388 session->Close();
2389 }
2390 }
2391
2392 // now clean up all hard disks we created
2393 list< ComPtr<IHardDisk> >::iterator itHD;
2394 for (itHD = llHardDisksCreated.begin();
2395 itHD != llHardDisksCreated.end();
2396 ++itHD)
2397 {
2398 ComPtr<IHardDisk> pDisk = *itHD;
2399 ComPtr<IProgress> pProgress;
2400 rc2 = pDisk->DeleteStorage(pProgress.asOutParam());
2401 rc2 = pProgress->WaitForCompletion(-1);
2402 }
2403
2404 // finally, deregister and remove all machines
2405 list<Guid>::iterator itID;
2406 for (itID = llMachinesRegistered.begin();
2407 itID != llMachinesRegistered.end();
2408 ++itID)
2409 {
2410 const Guid &guid = *itID;
2411 ComPtr<IMachine> failedMachine;
2412 rc2 = pVirtualBox->UnregisterMachine(guid, failedMachine.asOutParam());
2413 if (SUCCEEDED(rc2))
2414 rc2 = failedMachine->DeleteSettings();
2415 }
2416 }
2417
2418 task->rc = rc;
2419
2420 if (!task->progress.isNull())
2421 task->progress->notifyComplete(rc);
2422
2423 LogFlowFunc(("rc=%Rhrc\n", rc));
2424 LogFlowFuncLeave();
2425
2426 return VINF_SUCCESS;
2427}
2428
2429/**
2430 * Worker thread implementation for ImportMachines().
2431 * @param aThread
2432 * @param pvUser
2433 */
2434/* static */
2435DECLCALLBACK(int) Appliance::taskThreadExportOVF(RTTHREAD aThread, void *pvUser)
2436{
2437 std::auto_ptr<TaskImportMachines> task(static_cast<TaskImportMachines*>(pvUser));
2438 AssertReturn(task.get(), VERR_GENERAL_FAILURE);
2439
2440 Appliance *pAppliance = task->pAppliance;
2441
2442 LogFlowFuncEnter();
2443 LogFlowFunc(("Appliance %p\n", pAppliance));
2444
2445 AutoCaller autoCaller(pAppliance);
2446 CheckComRCReturnRC(autoCaller.rc());
2447
2448 AutoWriteLock appLock(pAppliance);
2449
2450 HRESULT rc = S_OK;
2451
2452 ComPtr<IVirtualBox> pVirtualBox(pAppliance->mVirtualBox);
2453
2454 try
2455 {
2456 xml::Document doc;
2457 doc.createRootElement("Envelope");
2458
2459 xml::XmlFileWriter writer(doc);
2460 writer.write(pAppliance->m->strPath.c_str());
2461 }
2462 catch(HRESULT aRC)
2463 {
2464 rc = aRC;
2465 }
2466
2467 task->rc = rc;
2468
2469 if (!task->progress.isNull())
2470 task->progress->notifyComplete(rc);
2471
2472 LogFlowFunc(("rc=%Rhrc\n", rc));
2473 LogFlowFuncLeave();
2474
2475 return VINF_SUCCESS;
2476}
2477
2478#
2479////////////////////////////////////////////////////////////////////////////////
2480//
2481// IVirtualSystemDescription constructor / destructor
2482//
2483////////////////////////////////////////////////////////////////////////////////
2484
2485DEFINE_EMPTY_CTOR_DTOR(VirtualSystemDescription)
2486struct shutup3 {};
2487
2488struct VirtualSystemDescription::Data
2489{
2490 list<VirtualSystemDescriptionEntry> descriptions;
2491 list<Utf8Str> warnings;
2492};
2493
2494/**
2495 * COM initializer.
2496 * @return
2497 */
2498HRESULT VirtualSystemDescription::init()
2499{
2500 /* Enclose the state transition NotReady->InInit->Ready */
2501 AutoInitSpan autoInitSpan(this);
2502 AssertReturn(autoInitSpan.isOk(), E_FAIL);
2503
2504 /* Initialize data */
2505 m = new Data();
2506
2507 /* Confirm a successful initialization */
2508 autoInitSpan.setSucceeded();
2509 return S_OK;
2510}
2511
2512/**
2513* COM uninitializer.
2514*/
2515
2516void VirtualSystemDescription::uninit()
2517{
2518 delete m;
2519 m = NULL;
2520}
2521
2522////////////////////////////////////////////////////////////////////////////////
2523//
2524// IVirtualSystemDescription public methods
2525//
2526////////////////////////////////////////////////////////////////////////////////
2527
2528/**
2529 * Public method implementation.
2530 * @param
2531 * @return
2532 */
2533STDMETHODIMP VirtualSystemDescription::COMGETTER(Count)(ULONG *aCount)
2534{
2535 if (!aCount)
2536 return E_POINTER;
2537
2538 AutoCaller autoCaller(this);
2539 CheckComRCReturnRC(autoCaller.rc());
2540
2541 AutoReadLock alock(this);
2542
2543 *aCount = (ULONG)m->descriptions.size();
2544
2545 return S_OK;
2546}
2547
2548/**
2549 * Public method implementation.
2550 * @return
2551 */
2552STDMETHODIMP VirtualSystemDescription::GetDescription(ComSafeArrayOut(VirtualSystemDescriptionType_T, aTypes),
2553 ComSafeArrayOut(BSTR, aRefs),
2554 ComSafeArrayOut(BSTR, aOrigValues),
2555 ComSafeArrayOut(BSTR, aVboxValues),
2556 ComSafeArrayOut(BSTR, aExtraConfigValues))
2557{
2558 if (ComSafeArrayOutIsNull(aTypes) ||
2559 ComSafeArrayOutIsNull(aRefs) ||
2560 ComSafeArrayOutIsNull(aOrigValues) ||
2561 ComSafeArrayOutIsNull(aVboxValues) ||
2562 ComSafeArrayOutIsNull(aExtraConfigValues))
2563 return E_POINTER;
2564
2565 AutoCaller autoCaller(this);
2566 CheckComRCReturnRC(autoCaller.rc());
2567
2568 AutoReadLock alock(this);
2569
2570 ULONG c = (ULONG)m->descriptions.size();
2571 com::SafeArray<VirtualSystemDescriptionType_T> sfaTypes(c);
2572 com::SafeArray<BSTR> sfaRefs(c);
2573 com::SafeArray<BSTR> sfaOrigValues(c);
2574 com::SafeArray<BSTR> sfaVboxValues(c);
2575 com::SafeArray<BSTR> sfaExtraConfigValues(c);
2576
2577 list<VirtualSystemDescriptionEntry>::const_iterator it;
2578 size_t i = 0;
2579 for (it = m->descriptions.begin();
2580 it != m->descriptions.end();
2581 ++it, ++i)
2582 {
2583 const VirtualSystemDescriptionEntry &vsde = (*it);
2584
2585 sfaTypes[i] = vsde.type;
2586
2587 Bstr bstr = vsde.strRef;
2588 bstr.cloneTo(&sfaRefs[i]);
2589
2590 bstr = vsde.strOvf;
2591 bstr.cloneTo(&sfaOrigValues[i]);
2592
2593 bstr = vsde.strVbox;
2594 bstr.cloneTo(&sfaVboxValues[i]);
2595
2596 bstr = vsde.strExtraConfig;
2597 bstr.cloneTo(&sfaExtraConfigValues[i]);
2598 }
2599
2600 sfaTypes.detachTo(ComSafeArrayOutArg(aTypes));
2601 sfaRefs.detachTo(ComSafeArrayOutArg(aRefs));
2602 sfaOrigValues.detachTo(ComSafeArrayOutArg(aOrigValues));
2603 sfaVboxValues.detachTo(ComSafeArrayOutArg(aVboxValues));
2604 sfaExtraConfigValues.detachTo(ComSafeArrayOutArg(aExtraConfigValues));
2605
2606 return S_OK;
2607}
2608
2609/**
2610 * Public method implementation.
2611 * @return
2612 */
2613STDMETHODIMP VirtualSystemDescription::SetFinalValues(ComSafeArrayIn(BOOL, aEnabled),
2614 ComSafeArrayIn(IN_BSTR, argVboxValues),
2615 ComSafeArrayIn(IN_BSTR, argExtraConfigValues))
2616{
2617 CheckComArgSafeArrayNotNull(argVboxValues);
2618 CheckComArgSafeArrayNotNull(argExtraConfigValues);
2619
2620 AutoCaller autoCaller(this);
2621 CheckComRCReturnRC(autoCaller.rc());
2622
2623 AutoWriteLock alock(this);
2624
2625 com::SafeArray<IN_BSTR> aVboxValues(ComSafeArrayInArg(argVboxValues));
2626 com::SafeArray<IN_BSTR> aExtraConfigValues(ComSafeArrayInArg(argExtraConfigValues));
2627
2628 if ( (aVboxValues.size() != m->descriptions.size())
2629 || (aExtraConfigValues.size() != m->descriptions.size())
2630 )
2631 return E_INVALIDARG;
2632
2633 list<VirtualSystemDescriptionEntry>::iterator it;
2634 size_t i = 0;
2635 for (it = m->descriptions.begin();
2636 it != m->descriptions.end();
2637 ++it, ++i)
2638 {
2639 VirtualSystemDescriptionEntry& vsde = *it;
2640
2641 if (aEnabled[i])
2642 {
2643 vsde.strVbox = aVboxValues[i];
2644 vsde.strExtraConfig = aExtraConfigValues[i];
2645 }
2646 else
2647 vsde.type = VirtualSystemDescriptionType_Ignore;
2648 }
2649
2650 return S_OK;
2651}
2652
2653/**
2654* Public method implementation.
2655 * @return
2656 */
2657STDMETHODIMP VirtualSystemDescription::GetWarnings(ComSafeArrayOut(BSTR, aWarnings))
2658{
2659 if (ComSafeArrayOutIsNull(aWarnings))
2660 return E_POINTER;
2661
2662 AutoCaller autoCaller(this);
2663 CheckComRCReturnRC(autoCaller.rc());
2664
2665 AutoReadLock alock(this);
2666
2667 com::SafeArray<BSTR> sfaWarnings(m->warnings.size());
2668
2669 list<Utf8Str>::const_iterator it;
2670 size_t i = 0;
2671 for (it = m->warnings.begin();
2672 it != m->warnings.end();
2673 ++it, ++i)
2674 {
2675 Bstr bstr = *it;
2676 bstr.cloneTo(&sfaWarnings[i]);
2677 }
2678
2679 sfaWarnings.detachTo(ComSafeArrayOutArg(aWarnings));
2680
2681 return S_OK;
2682}
2683
2684/**
2685 * Internal method; adds a new description item to the member list.
2686 * @param aType Type of description for the new item.
2687 * @param strRef Reference item; only used with hard disk controllers.
2688 * @param aOrigValue Corresponding original value from OVF.
2689 * @param aAutoValue Initial configuration value (can be overridden by caller with setFinalValues).
2690 * @param strExtraConfig Extra configuration; meaning dependent on type.
2691 */
2692void VirtualSystemDescription::addEntry(VirtualSystemDescriptionType_T aType,
2693 const Utf8Str &strRef,
2694 const Utf8Str &aOrigValue,
2695 const Utf8Str &aAutoValue,
2696 const Utf8Str &strExtraConfig /*= ""*/)
2697{
2698 VirtualSystemDescriptionEntry vsde;
2699 vsde.ulIndex = (uint32_t)m->descriptions.size(); // each entry gets an index so the client side can reference them
2700 vsde.type = aType;
2701 vsde.strRef = strRef;
2702 vsde.strOvf = aOrigValue;
2703 vsde.strVbox = aAutoValue;
2704 vsde.strExtraConfig = strExtraConfig;
2705
2706 m->descriptions.push_back(vsde);
2707}
2708
2709void VirtualSystemDescription::addWarning(const char* aWarning, ...)
2710{
2711 va_list args;
2712 va_start(args, aWarning);
2713 Utf8StrFmtVA str(aWarning, args);
2714 va_end(args);
2715 m->warnings.push_back(str);
2716}
2717
2718/**
2719 * Private method; returns a list of description items containing all the items from the member
2720 * description items of this virtual system that match the given type.
2721 * @param aType
2722 * @return
2723 */
2724std::list<VirtualSystemDescriptionEntry*> VirtualSystemDescription::findByType(VirtualSystemDescriptionType_T aType)
2725{
2726 std::list<VirtualSystemDescriptionEntry*> vsd;
2727
2728 list<VirtualSystemDescriptionEntry>::iterator it;
2729 for (it = m->descriptions.begin();
2730 it != m->descriptions.end();
2731 ++it)
2732 {
2733 if (it->type == aType)
2734 vsd.push_back(&(*it));
2735 }
2736
2737 return vsd;
2738}
2739
2740/**
2741 * Private method; looks thru the member hardware items for the IDE, SATA, or SCSI controller with
2742 * the given reference ID. Useful when needing the controller for a particular
2743 * virtual disk.
2744 * @param id
2745 * @return
2746 */
2747const VirtualSystemDescriptionEntry* VirtualSystemDescription::findControllerFromID(uint32_t id)
2748{
2749 Utf8Str strRef = Utf8StrFmt("%RI32", id);
2750 list<VirtualSystemDescriptionEntry>::const_iterator it;
2751 for (it = m->descriptions.begin();
2752 it != m->descriptions.end();
2753 ++it)
2754 {
2755 switch (it->type)
2756 {
2757 case VirtualSystemDescriptionType_HardDiskControllerIDE:
2758 case VirtualSystemDescriptionType_HardDiskControllerSATA:
2759 case VirtualSystemDescriptionType_HardDiskControllerSCSI:
2760 if (it->strRef == strRef)
2761 return &(*it);
2762 break;
2763 }
2764 }
2765
2766 return NULL;
2767}
2768
2769////////////////////////////////////////////////////////////////////////////////
2770//
2771// IMachine public methods
2772//
2773////////////////////////////////////////////////////////////////////////////////
2774
2775// This code is here so we won't have to include the appliance headers in the
2776// IMachine implementation, and we also need to access private appliance data.
2777
2778/**
2779* Public method implementation.
2780* @param appliance
2781* @return
2782*/
2783
2784STDMETHODIMP Machine::Export(IAppliance *appliance)
2785{
2786 HRESULT rc = S_OK;
2787
2788 if (!appliance)
2789 return E_POINTER;
2790
2791 AutoCaller autoCaller(this);
2792 CheckComRCReturnRC(autoCaller.rc());
2793
2794 AutoReadLock alock(this);
2795
2796 ComObjPtr<VirtualSystemDescription> pNewDesc;
2797
2798 try
2799 {
2800 Bstr bstrName;
2801 Bstr bstrDescription;
2802 Bstr bstrGuestOSType;
2803 uint32_t cCPUs;
2804 uint32_t ulMemSizeMB;
2805 BOOL fDVDEnabled;
2806 BOOL fFloppyEnabled;
2807 ComPtr<IUSBController> pUsbController;
2808 ComPtr<IAudioAdapter> pAudioAdapter;
2809
2810 // get name
2811 bstrName = mUserData->mName;
2812 // get description
2813 bstrName = mUserData->mDescription;
2814 // get guest OS
2815 bstrGuestOSType = mUserData->mOSTypeId;
2816 // CPU count
2817 cCPUs = mHWData->mCPUCount;
2818 // memory size in MB
2819 ulMemSizeMB = mHWData->mMemorySize;
2820 // VRAM size?
2821 // BIOS settings?
2822 // 3D acceleration enabled?
2823 // hardware virtualization enabled?
2824 // nested paging enabled?
2825 // HWVirtExVPIDEnabled?
2826 // PAEEnabled?
2827 // snapshotFolder?
2828 // VRDPServer?
2829
2830 // floppy
2831 rc = mFloppyDrive->COMGETTER(Enabled)(&fFloppyEnabled);
2832 if (FAILED(rc)) throw rc;
2833
2834 // CD-ROM ?!?
2835 // ComPtr<IDVDDrive> pDVDDrive;
2836 fDVDEnabled = 1;
2837
2838 // this is more tricky so use the COM method
2839 rc = COMGETTER(USBController)(pUsbController.asOutParam());
2840 if (FAILED(rc)) throw rc;
2841
2842 pAudioAdapter = mAudioAdapter;
2843
2844 // create a new virtual system
2845 rc = pNewDesc.createObject();
2846 CheckComRCThrowRC(rc);
2847 rc = pNewDesc->init();
2848 CheckComRCThrowRC(rc);
2849
2850 /* Guest OS type */
2851 Utf8Str strOsTypeVBox(bstrGuestOSType),
2852 strCIMOSType = "Linux"; // @todo convert back
2853 pNewDesc->addEntry(VirtualSystemDescriptionType_OS,
2854 "",
2855 strCIMOSType,
2856 strOsTypeVBox);
2857
2858 /* VM name */
2859 Utf8Str strVMName(bstrName);
2860 pNewDesc->addEntry(VirtualSystemDescriptionType_Name,
2861 "",
2862 strVMName,
2863 Utf8Str(bstrName));
2864
2865 /* CPU count*/
2866 Utf8Str strCpuCount = Utf8StrFmt("%RI32", cCPUs);
2867 pNewDesc->addEntry(VirtualSystemDescriptionType_CPU,
2868 "",
2869 strCpuCount,
2870 strCpuCount);
2871
2872 /* Memory */
2873 Utf8Str strMemory = Utf8StrFmt("%RI32", (uint64_t)ulMemSizeMB * _1M);
2874 pNewDesc->addEntry(VirtualSystemDescriptionType_CPU,
2875 "",
2876 strMemory,
2877 strMemory);
2878
2879 uint32_t uControllerId = 1;
2880 uint32_t uidIdeController;
2881 uint32_t uidSataController;
2882
2883// <const name="HardDiskControllerIDE" value="6" />
2884 ComPtr<IBIOSSettings> pBiosSettings;
2885 pBiosSettings = mBIOSSettings;
2886 Utf8Str strVbox;
2887 IDEControllerType_T ctlr;
2888 rc = pBiosSettings->COMGETTER(IDEControllerType)(&ctlr);
2889 if (FAILED(rc)) throw rc;
2890 switch(ctlr)
2891 {
2892 case IDEControllerType_PIIX3: strVbox = "PIIX3"; break;
2893 case IDEControllerType_PIIX4: strVbox = "PIIX4"; break;
2894 case IDEControllerType_ICH6: strVbox = "ICH6"; break;
2895 }
2896
2897 if (strVbox.length())
2898 {
2899 uidIdeController = uControllerId++;
2900 pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskControllerIDE, Utf8StrFmt("%d", uidIdeController), strVbox, "");
2901 }
2902
2903#ifdef VBOX_WITH_AHCI
2904// <const name="HardDiskControllerSATA" value="7" />
2905 ComPtr<ISATAController> pSataController;
2906 pSataController = mSATAController;
2907 BOOL fSataEnabled;
2908 rc = pSataController->COMGETTER(Enabled)(&fSataEnabled);
2909 if (FAILED(rc)) throw rc;
2910 if (fSataEnabled)
2911 {
2912 uidSataController = uControllerId++;
2913 pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskControllerSATA, Utf8StrFmt("%d", uidSataController), strVbox, "");
2914 }
2915#endif // VBOX_WITH_AHCI
2916
2917// <const name="HardDiskControllerSCSI" value="8" />
2918 // @todo
2919
2920// <const name="HardDiskImage" value="9" />
2921 // hardDiskAttachments
2922// mHDData->mAttachments @todo
2923 HDData::AttachmentList::iterator itA;
2924 for (itA = mHDData->mAttachments.begin();
2925 itA != mHDData->mAttachments.end();
2926 ++itA)
2927 {
2928 ComObjPtr<HardDiskAttachment> pHDA = *itA;
2929
2930 // the attachment's data
2931 ComPtr<IHardDisk> pHardDisk;
2932 StorageBus_T storageBus;
2933 LONG lChannel;
2934 LONG lDevice;
2935
2936 // and how this translates to the virtual system
2937 LONG lChannelVsys;
2938
2939 rc = pHDA->COMGETTER(HardDisk)(pHardDisk.asOutParam());
2940 if (FAILED(rc)) throw rc;
2941
2942 rc = pHDA->COMGETTER(Bus)(&storageBus);
2943 if (FAILED(rc)) throw rc;
2944
2945 rc = pHDA->COMGETTER(Channel)(&lChannel);
2946 if (FAILED(rc)) throw rc;
2947
2948 rc = pHDA->COMGETTER(Device)(&lDevice);
2949 if (FAILED(rc)) throw rc;
2950
2951 Bstr bstrLocation;
2952 rc = pHardDisk->COMGETTER(Location)(bstrLocation.asOutParam());
2953 Bstr bstrName;
2954 rc = pHardDisk->COMGETTER(Name)(bstrName.asOutParam());
2955
2956 uint32_t uidControllerVsys;
2957
2958 switch (storageBus)
2959 {
2960 case HardDiskController::IDE:
2961 // this is the exact reverse to what we're doing in Appliance::taskThreadImportMachines,
2962 // and it must be updated when that is changed!
2963
2964 if (lChannel == 0 && lDevice == 0) // primary master
2965 lChannelVsys = 0;
2966 else if (lChannel == 0 && lDevice == 1) // primary slave
2967 lChannelVsys = 1;
2968 else if (lChannel == 1 && lDevice == 1) // secondary slave; secondary master is always CDROM
2969 lChannelVsys = 2;
2970 else
2971 throw setError(VBOX_E_NOT_SUPPORTED,
2972 tr("Cannot handle hard disk attachment: channel is %d, device is %d"), lChannel, lDevice);
2973 break;
2974
2975 uidControllerVsys = uidIdeController;
2976 break;
2977
2978 case HardDiskController::SATA:
2979 lChannelVsys = lChannel; // should be between 0 and 29
2980 uidControllerVsys = uidSataController;
2981 break;
2982
2983 case HardDiskController::SCSI:
2984 // mhda.busType = StorageBus_SCSI;
2985 throw setError(VBOX_E_NOT_SUPPORTED,
2986 tr("SCSI controller support is not available yet in VirtualBox"));
2987 // @todo
2988 break;
2989
2990 default: break;
2991 }
2992
2993 pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskImage,
2994 Utf8Str(bstrName), // disk ID: let's use the name
2995 "", // OVF value: unknown as of now
2996 Utf8Str(bstrLocation), // vbox value: media path
2997 Utf8StrFmt("controller=%d;channel=%d", uidControllerVsys, lChannelVsys));
2998 }
2999
3000 /* Floppy Drive */
3001 if (fFloppyEnabled)
3002 pNewDesc->addEntry(VirtualSystemDescriptionType_Floppy, "", "", "");
3003
3004 /* CD Drive */
3005 if (fDVDEnabled)
3006 pNewDesc->addEntry(VirtualSystemDescriptionType_CDROM, "", "", "");
3007
3008// <const name="LogicalNetwork" value="12" />
3009
3010// <const name="NetworkAdapter" value="13" />
3011
3012// <const name="USBController" value="14" />
3013
3014// <const name="SoundCard" value="15" />
3015
3016 // finally, add the virtual system to the appliance
3017 Appliance *pAppliance = static_cast<Appliance*>(appliance);
3018 AutoCaller autoCaller(pAppliance);
3019 if (FAILED(rc)) throw rc;
3020
3021 AutoWriteLock alock(pAppliance);
3022
3023 pAppliance->m->virtualSystemDescriptions.push_back(pNewDesc);
3024 }
3025 catch(HRESULT arc)
3026 {
3027 rc = arc;
3028 }
3029
3030 return rc;
3031}
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