Changeset 16495 in vbox

Timestamp:

Feb 3, 2009 9:20:36 PM (16 years ago)

Author:

vboxsync

Message:

OVF: VBoxManage import implementation (to be continued), back-end fixes, documentation updates

Location:

trunk

Files:

• include/VBox/com/string.h (modified) (1 diff)
• src/VBox/Frontends/VBoxManage/VBoxManageImport.cpp (modified) (3 diffs)
• src/VBox/Main/ApplianceImpl.cpp (modified) (48 diffs)
• src/VBox/Main/glue/string.cpp (modified) (1 diff)
• src/VBox/Main/idl/VirtualBox.xidl (modified) (3 diffs)
• src/VBox/Main/include/ApplianceImpl.h (modified) (3 diffs)

trunk/include/VBox/com/string.h

@@ -513 +513 @@
 
     /**
+     * Attempts to convert the member string into an unsigned 64-bit integer.
+     * @return IPRT error code.
+     * @param i Output buffer.
+     */
+    int toInt(uint64_t &i) const;
+
+    /**
+     * Attempts to convert the member string into an unsigned 32-bit integer.
+     * @return IPRT error code.
+     * @param i Output buffer.
+     */
+    int toInt(uint32_t &i) const;
+
+    /**
      *  Intended to pass instances as out (|char **|) parameters to methods.
      *  Takes the ownership of the returned data.

trunk/src/VBox/Frontends/VBoxManage/VBoxManageImport.cpp

@@ -25 +25 @@
 *   Header Files                                                               *
 *******************************************************************************/
+#ifndef VBOX_ONLY_DOCS
+#include <VBox/com/com.h>
+#include <VBox/com/string.h>
+#include <VBox/com/Guid.h>
+#include <VBox/com/array.h>
+#include <VBox/com/ErrorInfo.h>
+#include <VBox/com/EventQueue.h>
+
+#include <VBox/com/VirtualBox.h>
+
+#include <list>
+#endif /* !VBOX_ONLY_DOCS */
+
+#include <iprt/stream.h>
+
+#include <VBox/log.h>
+
 #include "VBoxManage.h"
 using namespace com;
@@ -31 +48 @@
 // funcs
 ///////////////////////////////////////////////////////////////////////////////
-
-
 
 int handleImportAppliance(HandlerArg *a)
@@ -38 +53 @@
     HRESULT rc = S_OK;
 
+    Utf8Str strOvfFilename;
+
+    for (int i = 0; i < a->argc; i++)
+    {
+        if (!strOvfFilename)
+            strOvfFilename = a->argv[i];
+        else
+            return errorSyntax(USAGE_IMPORTAPPLIANCE, "Too many arguments for \"import\" command.");
+    }
+
+    if (!strOvfFilename)
+        return errorSyntax(USAGE_IMPORTAPPLIANCE, "Not enough arguments for \"import\" command.");
+
+    do
+    {
+        Bstr bstrOvfFilename(strOvfFilename);
+        ComPtr<IAppliance> appliance;
+        CHECK_ERROR_BREAK(a->virtualBox, OpenAppliance(bstrOvfFilename, appliance.asOutParam()));
+
+        RTPrintf("Interpreting...\n");
+        CHECK_ERROR_BREAK(appliance, Interpret());
+        RTPrintf("OK.\n");
+
+        // fetch all disks
+        com::SafeArray<BSTR> retDisks;
+        CHECK_ERROR_BREAK(appliance,
+                          COMGETTER(Disks)(ComSafeArrayAsOutParam(retDisks)));
+        if (retDisks.size() > 0)
+        {
+            RTPrintf("Disks:");
+            for (unsigned i = 0; i < retDisks.size(); i++)
+                RTPrintf("  %ls", retDisks[i]);
+            RTPrintf("\n");
+        }
+
+        // fetch virtual system descriptions
+        com::SafeIfaceArray<IVirtualSystemDescription> aVirtualSystemDescriptions;
+        CHECK_ERROR_BREAK(appliance,
+                          COMGETTER(VirtualSystemDescriptions)(ComSafeArrayAsOutParam(aVirtualSystemDescriptions)));
+        if (aVirtualSystemDescriptions.size() > 0)
+        {
+            for (unsigned i = 0; i < aVirtualSystemDescriptions.size(); ++i)
+            {
+                com::SafeArray<VirtualSystemDescriptionType_T> retTypes;
+                com::SafeArray<ULONG> aRefs;
+                com::SafeArray<BSTR> aOrigValues;
+                com::SafeArray<BSTR> aConfigValues;
+                com::SafeArray<BSTR> aExtraConfigValues;
+                CHECK_ERROR_BREAK(aVirtualSystemDescriptions[i],
+                                  GetDescription(ComSafeArrayAsOutParam(retTypes),
+                                                 ComSafeArrayAsOutParam(aRefs),
+                                                 ComSafeArrayAsOutParam(aOrigValues),
+                                                 ComSafeArrayAsOutParam(aConfigValues),
+                                                 ComSafeArrayAsOutParam(aExtraConfigValues)));
+
+                RTPrintf("Virtual system %i:\n", i);
+                for (unsigned a = 0; a < retTypes.size(); ++a)
+                {
+                    VirtualSystemDescriptionType_T t = retTypes[a];
+
+                    Bstr bstrVMname;
+                    Bstr bstrOstype;
+                    uint32_t ulMemMB;
+                    bool fUSB = false;
+
+                    switch (t)
+                    {
+                        case VirtualSystemDescriptionType_Name:
+                            bstrVMname = aConfigValues[a];
+                            RTPrintf("%2d: Suggested VM name \"%ls\""
+                                     "\n    (change with \"-vsys %d -vmname <name>\")\n",
+                                     a, bstrVMname.raw(), i);
+                        break;
+
+                        case VirtualSystemDescriptionType_OS:
+                            bstrOstype = aConfigValues[a];
+                            RTPrintf("%2d: Suggested OS type: \"%ls\""
+                                     "\n    (change with \"-vsys %d -ostype <type>\"; use \"list ostypes\" to list all)\n",
+                                     a, bstrOstype.raw(), i);
+                        break;
+
+                        case VirtualSystemDescriptionType_CPU:
+                            RTPrintf("%2d: Number of CPUs (ignored): %ls\n",
+                                     a, aConfigValues[a]);
+                        break;
+
+                        case VirtualSystemDescriptionType_Memory:
+                            Utf8Str(Bstr(aConfigValues[a])).toInt(ulMemMB);
+                            ulMemMB /= 1024 * 1024;
+                            RTPrintf("%2d: Guest memory: %u MB\n    (change with \"-vsys %d -memory <MB>\")\n",
+                                     a, ulMemMB, i);
+                        break;
+
+                        case VirtualSystemDescriptionType_HardDiskControllerIDE:
+                            RTPrintf("%2d: IDE controller: reference ID %d"
+                                     "\n    (disable with \"-vsys %d -ignore %d\")\n",
+                                     a,
+                                     aRefs[a],
+                                     i, a);
+                        break;
+
+                        case VirtualSystemDescriptionType_HardDiskControllerSATA:
+                            RTPrintf("%2d: SATA controller: reference ID %d"
+                                     "\n    (disable with \"-vsys %d -ignore %d\")\n",
+                                     a,
+                                     aRefs[a],
+                                     i, a);
+                        break;
+
+                        case VirtualSystemDescriptionType_HardDiskControllerSCSI:
+                            RTPrintf("%2d: SCSI controller: reference ID %d, type %ls"
+                                     "\n    (change with \"-vsys %d -scsitype%d={BusLogic|LsiLogic}\";"
+                                     "\n    disable with \"-vsys %d -ignore %d\")\n",
+                                     a,
+                                     aRefs[a],
+                                     aConfigValues[a],
+                                     i, a, i, a);
+                        break;
+
+                        case VirtualSystemDescriptionType_HardDiskImage:
+                            RTPrintf("%2d: Hard disk image: controller %d, source image \"%ls\", target image \"%ls\""
+                                     "\n    (change controller with \"-vsys %d -controller%d=<id>\";"
+                                     "\n    disable with \"-vsys %d -ignore %d\")\n",
+                                     a,
+                                     aRefs[a],
+                                     aOrigValues[a],
+                                     aConfigValues[a],
+                                     i, a, i, a);
+                        break;
+
+                        case VirtualSystemDescriptionType_CDROM:
+                            RTPrintf("%2d: CD-ROM"
+                                     "\n    (disable with \"-vsys %d -ignore %d\")\n",
+                                     a, i, a);
+                        break;
+
+                        case VirtualSystemDescriptionType_Floppy:
+                            RTPrintf("%2d: Floppy"
+                                     "\n    (disable with \"-vsys %d -ignore %d\")\n",
+                                     a, i, a);
+                        break;
+
+                        case VirtualSystemDescriptionType_NetworkAdapter:
+                            RTPrintf("%2d: Network adapter: orig %ls, auto %ls, conf %ls\n",
+                                     a,
+                                     aOrigValues[a],
+                                     aConfigValues[a],
+                                     aExtraConfigValues[a]);
+                        break;
+
+                        case VirtualSystemDescriptionType_USBController:
+                            RTPrintf("%2d: USB controller"
+                                     "\n    (disable with \"-vsys %d -ignore %d\")\n",
+                                     a, i, a);
+                        break;
+
+                        case VirtualSystemDescriptionType_SoundCard:
+                            RTPrintf("%2d: Sound card (appliance expects \"%ls\", can change on import)"
+                                     "\n    (disable with \"-vsys %d -ignore %d\")\n",
+                                     a,
+                                     aOrigValues[a],
+                                     i,
+                                     a);
+                        break;
+                    }
+                }
+            }
+            RTPrintf("\n");
+        }
+    } while (0);
+
     return SUCCEEDED(rc) ? 0 : 1;
 }

trunk/src/VBox/Main/ApplianceImpl.cpp

@@ -108 +108 @@
 };
 
-typedef map<Utf8Str, DiskImage> DiskImagesMap;
+typedef map<uint32_t, DiskImage> DiskImagesMap;
 typedef map<Utf8Str, Network> NetworksMap;
 
@@ -129 +129 @@
 typedef map<uint32_t, VirtualHardwareItem> HardwareItemsMap;
 
-enum ControllerSystemType { IDE, SATA, SCSI };
 struct HardDiskController
 {
     uint32_t             idController;           // instance ID (Item/InstanceId); this gets referenced from HardDisk
-    ControllerSystemType controllerSystem;       // one of IDE, SATA, SCSI
+    enum ControllerSystemType { IDE, SATA, SCSI };
+    ControllerSystemType system;                 // one of IDE, SATA, SCSI
     Utf8Str              strControllerType;      // controllertype (Item/ResourceSubType); e.g. "LsiLogic"; can be empty (esp. for IDE)
     Utf8Str              strAddress;             // for IDE
@@ -446 +446 @@
                                               const xml::Node *pelmVirtualSystem)
 {
-    VirtualSystem d;
+    VirtualSystem vsys;
 
     const xml::Node *pIdAttr = pelmVirtualSystem->findAttribute("id");
     if (pIdAttr)
-        d.strName = pIdAttr->getValue();
+        vsys.strName = pIdAttr->getValue();
 
     xml::NodesLoop loop(*pelmVirtualSystem);      // all child elements
@@ -472 +472 @@
                )
             {
-                d.strLicenceInfo = pelmInfo->getValue();
-                d.strLicenceText = pelmLicense->getValue();
+                vsys.strLicenceInfo = pelmInfo->getValue();
+                vsys.strLicenceText = pelmLicense->getValue();
             }
         }
@@ -491 +491 @@
                 </System>*/
                 if ((pelmVirtualSystemType = pelmSystem->findChildElement("VirtualSystemType")))
-                    d.strVirtualSystemType = pelmVirtualSystemType->getValue();
+                    vsys.strVirtualSystemType = pelmVirtualSystemType->getValue();
             }
 
@@ -568 +568 @@
 
                 // store!
-                d.mapHardwareItems[i.ulInstanceID] = i;
+                vsys.mapHardwareItems[i.ulInstanceID] = i;
             }
 
             HardwareItemsMap::const_iterator itH;
 
-            for (itH = d.mapHardwareItems.begin();
-                 itH != d.mapHardwareItems.end();
+            for (itH = vsys.mapHardwareItems.begin();
+                 itH != vsys.mapHardwareItems.end();
                  ++itH)
             {
@@ -590 +590 @@
                             <rasd:VirtualQuantity>1</rasd:VirtualQuantity>*/
                         if (i.ullVirtualQuantity < UINT16_MAX)
-                            d.cCPUs = (uint16_t)i.ullVirtualQuantity;
+                            vsys.cCPUs = (uint16_t)i.ullVirtualQuantity;
                         else
                             return setError(VBOX_E_FILE_ERROR,
@@ -605 +605 @@
                              || (i.strAllocationUnits == "byte * 2^20")         // suggested by OVF spec DSP0243 page 21
                            )
-                            d.ullMemorySize = i.ullVirtualQuantity * 1024 * 1024;
+                            vsys.ullMemorySize = i.ullVirtualQuantity * 1024 * 1024;
                         else
                             return setError(VBOX_E_FILE_ERROR,
@@ -625 +625 @@
                             </Item> */
                         HardDiskController hdc;
+                        hdc.system = HardDiskController::IDE;
                         hdc.idController = i.ulInstanceID;
-                        hdc.controllerSystem = IDE;
                         hdc.strAddress = i.strAddress;
                         hdc.ulBusNumber = i.ulBusNumber;
 
-                        d.mapControllers[i.ulInstanceID] = hdc;
+                        vsys.mapControllers[i.ulInstanceID] = hdc;
                     }
+                    break;
 
                     case OVFResourceType_ParallelScsiHba:        // 6       SCSI controller
@@ -644 +645 @@
                             </Item> */
                         HardDiskController hdc;
+                        hdc.system = HardDiskController::SCSI;
                         hdc.idController = i.ulInstanceID;
-                        hdc.controllerSystem = SCSI;
                         hdc.strControllerType = i.strResourceSubType;
 
-                        d.mapControllers[i.ulInstanceID] = hdc;
+                        vsys.mapControllers[i.ulInstanceID] = hdc;
                     }
                     break;
@@ -680 +681 @@
                                             i.ulLineNumber);
 
-                        d.llNetworkNames.push_back(i.strConnection);
+                        vsys.llNetworkNames.push_back(i.strConnection);
                     }
                     break;
 
                     case OVFResourceType_FloppyDrive: // 14
-                        d.fHasFloppyDrive = true;           // we have no additional information
+                        vsys.fHasFloppyDrive = true;           // we have no additional information
                     break;
 
@@ -700 +701 @@
                             // but then the ovftool dies with "Device backing not supported". So I guess if
                             // VMware can't export ISOs, then we don't need to be able to import them right now.
-                        d.fHasCdromDrive = true;           // we have no additional information
+                        vsys.fHasCdromDrive = true;           // we have no additional information
                     break;
 
@@ -717 +718 @@
                         // look up the hard disk controller element whose InstanceID equals our Parent;
                         // this is how the connection is specified in OVF
-                        ControllersMap::const_iterator it = d.mapControllers.find(i.ulParent);
-                        if (it == d.mapControllers.end())
+                        ControllersMap::const_iterator it = vsys.mapControllers.find(i.ulParent);
+                        if (it == vsys.mapControllers.end())
                             return setError(VBOX_E_FILE_ERROR,
                                             tr("Error reading \"%s\": Hard disk item with instance ID %d specifies invalid parent %d, line %d"),
@@ -747 +748 @@
                                             i.ulLineNumber);
 
-                        d.mapVirtualDisks[vd.strDiskId] = vd;
+                        vsys.mapVirtualDisks[vd.strDiskId] = vd;
                     }
                     break;
@@ -760 +761 @@
                                 <rasd:BusNumber>0</rasd:BusNumber>
                             </Item> */
-                        d.fHasUsbController = true;           // we have no additional information
+                        vsys.fHasUsbController = true;           // we have no additional information
                     break;
 
@@ -773 +774 @@
                                 <rasd:AddressOnParent>3</rasd:AddressOnParent>
                             </Item> */
-                        d.strSoundCardType = i.strResourceSubType;
+                        vsys.strSoundCardType = i.strResourceSubType;
                     break;
 
@@ -796 +797 @@
                                 pelmThis->getLineNumber());
 
-            d.cimos = (CIMOSType_T)cimos64;
+            vsys.cimos = (CIMOSType_T)cimos64;
         }
     }
 
     // now create the virtual system
-    m->llVirtualSystems.push_back(d);
+    m->llVirtualSystems.push_back(vsys);
 
     return S_OK;
@@ -972 +973 @@
 }
 
+void convertCIMOSType2VBoxOSType(Utf8Str &osTypeVBox, CIMOSType_T c)
+{
+    switch (c)
+    {
+        case CIMOSType_CIMOS_Unknown: // 0 - Unknown
+            osTypeVBox = SchemaDefs_OSTypeId_Other;
+            break;
+
+        case CIMOSType_CIMOS_OS2: // 12 - OS/2
+            osTypeVBox = SchemaDefs_OSTypeId_OS2;
+            break;
+
+        case CIMOSType_CIMOS_MSDOS: // 14 - MSDOS
+            osTypeVBox = SchemaDefs_OSTypeId_DOS;
+            break;
+
+        case CIMOSType_CIMOS_WIN3x: // 15 - WIN3x
+            osTypeVBox = SchemaDefs_OSTypeId_Windows31;
+            break;
+
+        case CIMOSType_CIMOS_WIN95: // 16 - WIN95
+            osTypeVBox = SchemaDefs_OSTypeId_Windows95;
+            break;
+
+        case CIMOSType_CIMOS_WIN98: // 17 - WIN98
+            osTypeVBox = SchemaDefs_OSTypeId_Windows98;
+            break;
+
+        case CIMOSType_CIMOS_WINNT: // 18 - WINNT
+            osTypeVBox = SchemaDefs_OSTypeId_WindowsNT4;
+            break;
+
+        case CIMOSType_CIMOS_NetWare: // 21 - NetWare
+        case CIMOSType_CIMOS_NovellOES: // 86 - Novell OES
+            osTypeVBox = SchemaDefs_OSTypeId_Netware;
+            break;
+
+        case CIMOSType_CIMOS_Solaris: // 29 - Solaris
+        case CIMOSType_CIMOS_SunOS: // 30 - SunOS
+            osTypeVBox = SchemaDefs_OSTypeId_Solaris;
+            break;
+
+        case CIMOSType_CIMOS_FreeBSD: // 42 - FreeBSD
+            osTypeVBox = SchemaDefs_OSTypeId_FreeBSD;
+            break;
+
+        case CIMOSType_CIMOS_NetBSD: // 43 - NetBSD
+            osTypeVBox = SchemaDefs_OSTypeId_NetBSD;
+            break;
+
+        case CIMOSType_CIMOS_QNX: // 48 - QNX
+            osTypeVBox = SchemaDefs_OSTypeId_QNX;
+            break;
+
+        case CIMOSType_CIMOS_Windows2000: // 58 - Windows 2000
+            osTypeVBox = SchemaDefs_OSTypeId_Windows2000;
+            break;
+
+        case CIMOSType_CIMOS_WindowsMe: // 63 - Windows (R) Me
+            osTypeVBox = SchemaDefs_OSTypeId_WindowsMe;
+            break;
+
+        case CIMOSType_CIMOS_OpenBSD: // 65 - OpenBSD
+            osTypeVBox = SchemaDefs_OSTypeId_OpenBSD;
+            break;
+
+        case CIMOSType_CIMOS_WindowsXP: // 67 - Windows XP
+        case CIMOSType_CIMOS_WindowsXPEmbedded: // 72 - Windows XP Embedded
+        case CIMOSType_CIMOS_WindowsEmbeddedforPointofService: // 75 - Windows Embedded for Point of Service
+            osTypeVBox = SchemaDefs_OSTypeId_WindowsXP;
+            break;
+
+        case CIMOSType_CIMOS_MicrosoftWindowsServer2003: // 69 - Microsoft Windows Server 2003
+            osTypeVBox = SchemaDefs_OSTypeId_Windows2003;
+            break;
+
+        case CIMOSType_CIMOS_MicrosoftWindowsServer2003_64: // 70 - Microsoft Windows Server 2003 64-Bit
+            osTypeVBox = SchemaDefs_OSTypeId_Windows2003_64;
+            break;
+
+        case CIMOSType_CIMOS_WindowsXP_64: // 71 - Windows XP 64-Bit
+            osTypeVBox = SchemaDefs_OSTypeId_WindowsXP_64;
+            break;
+
+        case CIMOSType_CIMOS_WindowsVista: // 73 - Windows Vista
+            osTypeVBox = SchemaDefs_OSTypeId_WindowsVista;
+            break;
+
+        case CIMOSType_CIMOS_WindowsVista_64: // 74 - Windows Vista 64-Bit
+            osTypeVBox = SchemaDefs_OSTypeId_WindowsVista_64;
+            break;
+
+        case CIMOSType_CIMOS_MicrosoftWindowsServer2008: // 76 - Microsoft Windows Server 2008
+            osTypeVBox = SchemaDefs_OSTypeId_Windows2008;
+            break;
+
+        case CIMOSType_CIMOS_MicrosoftWindowsServer2008_64: // 77 - Microsoft Windows Server 2008 64-Bit
+            osTypeVBox = SchemaDefs_OSTypeId_Windows2008_64;
+            break;
+
+        case CIMOSType_CIMOS_FreeBSD_64: // 78 - FreeBSD 64-Bit
+            osTypeVBox = SchemaDefs_OSTypeId_FreeBSD_64;
+            break;
+
+        case CIMOSType_CIMOS_RedHatEnterpriseLinux: // 79 - RedHat Enterprise Linux
+            osTypeVBox = SchemaDefs_OSTypeId_RedHat;
+            break;
+
+        case CIMOSType_CIMOS_RedHatEnterpriseLinux_64: // 80 - RedHat Enterprise Linux 64-Bit
+            osTypeVBox = SchemaDefs_OSTypeId_RedHat_64;
+            break;
+
+        case CIMOSType_CIMOS_Solaris_64: // 81 - Solaris 64-Bit
+            osTypeVBox = SchemaDefs_OSTypeId_Solaris_64;
+            break;
+
+        case CIMOSType_CIMOS_SUSE: // 82 - SUSE
+        case CIMOSType_CIMOS_SLES: // 84 - SLES
+        case CIMOSType_CIMOS_NovellLinuxDesktop: // 87 - Novell Linux Desktop
+            osTypeVBox = SchemaDefs_OSTypeId_OpenSUSE;
+            break;
+
+        case CIMOSType_CIMOS_SUSE_64: // 83 - SUSE 64-Bit
+        case CIMOSType_CIMOS_SLES_64: // 85 - SLES 64-Bit
+            osTypeVBox = SchemaDefs_OSTypeId_OpenSUSE_64;
+            break;
+
+        case CIMOSType_CIMOS_LINUX: // 36 - LINUX
+        case CIMOSType_CIMOS_SunJavaDesktopSystem: // 88 - Sun Java Desktop System
+        case CIMOSType_CIMOS_TurboLinux: // 91 - TurboLinux
+            osTypeVBox = SchemaDefs_OSTypeId_Linux;
+            break;
+
+            //                case CIMOSType_CIMOS_TurboLinux_64: // 92 - TurboLinux 64-Bit
+            //                case CIMOSType_CIMOS_Linux_64: // 101 - Linux 64-Bit
+            //                    osTypeVBox = VBOXOSTYPE_Linux_x64;
+            //                    break;
+
+        case CIMOSType_CIMOS_Mandriva: // 89 - Mandriva
+            osTypeVBox = SchemaDefs_OSTypeId_Mandriva;
+            break;
+
+        case CIMOSType_CIMOS_Mandriva_64: // 90 - Mandriva 64-Bit
+            osTypeVBox = SchemaDefs_OSTypeId_Mandriva_64;
+            break;
+
+        case CIMOSType_CIMOS_Ubuntu: // 93 - Ubuntu
+            osTypeVBox = SchemaDefs_OSTypeId_Ubuntu;
+            break;
+
+        case CIMOSType_CIMOS_Ubuntu_64: // 94 - Ubuntu 64-Bit
+            osTypeVBox = SchemaDefs_OSTypeId_Ubuntu_64;
+            break;
+
+        case CIMOSType_CIMOS_Debian: // 95 - Debian
+            osTypeVBox = SchemaDefs_OSTypeId_Debian;
+            break;
+
+        case CIMOSType_CIMOS_Debian_64: // 96 - Debian 64-Bit
+            osTypeVBox = SchemaDefs_OSTypeId_Debian_64;
+            break;
+
+        case CIMOSType_CIMOS_Linux_2_4_x: // 97 - Linux 2.4.x
+            osTypeVBox = SchemaDefs_OSTypeId_Linux24;
+            break;
+
+        case CIMOSType_CIMOS_Linux_2_4_x_64: // 98 - Linux 2.4.x 64-Bit
+            osTypeVBox = SchemaDefs_OSTypeId_Linux24_64;
+            break;
+
+        case CIMOSType_CIMOS_Linux_2_6_x: // 99 - Linux 2.6.x
+            osTypeVBox = SchemaDefs_OSTypeId_Linux26;
+            break;
+
+        case CIMOSType_CIMOS_Linux_2_6_x_64: // 100 - Linux 2.6.x 64-Bit
+            osTypeVBox = SchemaDefs_OSTypeId_Linux26_64;
+            break;
+        default:
+            {
+                /* If we are here we have no clue what OS this should be. Set to
+                    * other type as default. */
+                osTypeVBox = SchemaDefs_OSTypeId_Other;
+            }
+    }
+}
+
 STDMETHODIMP Appliance::Interpret()
 {
@@ -992 +1179 @@
     rc = mVirtualBox->COMGETTER(SystemProperties)(systemProps.asOutParam());
     ComAssertComRCThrowRC(rc);
-    BSTR defaultHardDiskLocation;
-    rc = systemProps->COMGETTER(DefaultHardDiskFolder)(&defaultHardDiskLocation);
+    Bstr bstrDefaultHardDiskLocation;
+    rc = systemProps->COMGETTER(DefaultHardDiskFolder)(bstrDefaultHardDiskLocation.asOutParam());
     ComAssertComRCThrowRC(rc);
 
@@ -1002 +1189 @@
          ++it)
     {
-        const VirtualSystem &vs = *it;
-        ComObjPtr <VirtualSystemDescription> vsd;
-        vsd.createObject();
-        rc = vsd->init();
+        const VirtualSystem &vsysThis = *it;
+
+        ComObjPtr<VirtualSystemDescription> pNewDesc;
+        pNewDesc.createObject();
+        rc = pNewDesc->init();
         ComAssertComRCThrowRC(rc);
 
-        Utf8Str osTypeVBox = SchemaDefs_OSTypeId_Other;
         /* Guest OS type */
-        switch (vs.cimos)
-        {
-            case CIMOSType_CIMOS_Unknown: // 0 - Unknown
-                osTypeVBox = SchemaDefs_OSTypeId_Other;
-                break;
-
-            case CIMOSType_CIMOS_OS2: // 12 - OS/2
-                osTypeVBox = SchemaDefs_OSTypeId_OS2;
-                break;
-
-            case CIMOSType_CIMOS_MSDOS: // 14 - MSDOS
-                osTypeVBox = SchemaDefs_OSTypeId_DOS;
-                break;
-
-            case CIMOSType_CIMOS_WIN3x: // 15 - WIN3x
-                osTypeVBox = SchemaDefs_OSTypeId_Windows31;
-                break;
-
-            case CIMOSType_CIMOS_WIN95: // 16 - WIN95
-                osTypeVBox = SchemaDefs_OSTypeId_Windows95;
-                break;
-
-            case CIMOSType_CIMOS_WIN98: // 17 - WIN98
-                osTypeVBox = SchemaDefs_OSTypeId_Windows98;
-                break;
-
-            case CIMOSType_CIMOS_WINNT: // 18 - WINNT
-                osTypeVBox = SchemaDefs_OSTypeId_WindowsNT4;
-                break;
-
-            case CIMOSType_CIMOS_NetWare: // 21 - NetWare
-            case CIMOSType_CIMOS_NovellOES: // 86 - Novell OES
-                osTypeVBox = SchemaDefs_OSTypeId_Netware;
-                break;
-
-            case CIMOSType_CIMOS_Solaris: // 29 - Solaris
-            case CIMOSType_CIMOS_SunOS: // 30 - SunOS
-                osTypeVBox = SchemaDefs_OSTypeId_Solaris;
-                break;
-
-            case CIMOSType_CIMOS_FreeBSD: // 42 - FreeBSD
-                osTypeVBox = SchemaDefs_OSTypeId_FreeBSD;
-                break;
-
-            case CIMOSType_CIMOS_NetBSD: // 43 - NetBSD
-                osTypeVBox = SchemaDefs_OSTypeId_NetBSD;
-                break;
-
-            case CIMOSType_CIMOS_QNX: // 48 - QNX
-                osTypeVBox = SchemaDefs_OSTypeId_QNX;
-                break;
-
-            case CIMOSType_CIMOS_Windows2000: // 58 - Windows 2000
-                osTypeVBox = SchemaDefs_OSTypeId_Windows2000;
-                break;
-
-            case CIMOSType_CIMOS_WindowsMe: // 63 - Windows (R) Me
-                osTypeVBox = SchemaDefs_OSTypeId_WindowsMe;
-                break;
-
-            case CIMOSType_CIMOS_OpenBSD: // 65 - OpenBSD
-                osTypeVBox = SchemaDefs_OSTypeId_OpenBSD;
-                break;
-
-            case CIMOSType_CIMOS_WindowsXP: // 67 - Windows XP
-            case CIMOSType_CIMOS_WindowsXPEmbedded: // 72 - Windows XP Embedded
-            case CIMOSType_CIMOS_WindowsEmbeddedforPointofService: // 75 - Windows Embedded for Point of Service
-                osTypeVBox = SchemaDefs_OSTypeId_WindowsXP;
-                break;
-
-            case CIMOSType_CIMOS_MicrosoftWindowsServer2003: // 69 - Microsoft Windows Server 2003
-                osTypeVBox = SchemaDefs_OSTypeId_Windows2003;
-                break;
-
-            case CIMOSType_CIMOS_MicrosoftWindowsServer2003_64: // 70 - Microsoft Windows Server 2003 64-Bit
-                osTypeVBox = SchemaDefs_OSTypeId_Windows2003_64;
-                break;
-
-            case CIMOSType_CIMOS_WindowsXP_64: // 71 - Windows XP 64-Bit
-                osTypeVBox = SchemaDefs_OSTypeId_WindowsXP_64;
-                break;
-
-            case CIMOSType_CIMOS_WindowsVista: // 73 - Windows Vista
-                osTypeVBox = SchemaDefs_OSTypeId_WindowsVista;
-                break;
-
-            case CIMOSType_CIMOS_WindowsVista_64: // 74 - Windows Vista 64-Bit
-                osTypeVBox = SchemaDefs_OSTypeId_WindowsVista_64;
-                break;
-
-            case CIMOSType_CIMOS_MicrosoftWindowsServer2008: // 76 - Microsoft Windows Server 2008
-                osTypeVBox = SchemaDefs_OSTypeId_Windows2008;
-                break;
-
-            case CIMOSType_CIMOS_MicrosoftWindowsServer2008_64: // 77 - Microsoft Windows Server 2008 64-Bit
-                osTypeVBox = SchemaDefs_OSTypeId_Windows2008_64;
-                break;
-
-            case CIMOSType_CIMOS_FreeBSD_64: // 78 - FreeBSD 64-Bit
-                osTypeVBox = SchemaDefs_OSTypeId_FreeBSD_64;
-                break;
-
-            case CIMOSType_CIMOS_RedHatEnterpriseLinux: // 79 - RedHat Enterprise Linux
-                osTypeVBox = SchemaDefs_OSTypeId_RedHat;
-                break;
-
-            case CIMOSType_CIMOS_RedHatEnterpriseLinux_64: // 80 - RedHat Enterprise Linux 64-Bit
-                osTypeVBox = SchemaDefs_OSTypeId_RedHat_64;
-                break;
-
-            case CIMOSType_CIMOS_Solaris_64: // 81 - Solaris 64-Bit
-                osTypeVBox = SchemaDefs_OSTypeId_Solaris_64;
-                break;
-
-            case CIMOSType_CIMOS_SUSE: // 82 - SUSE
-            case CIMOSType_CIMOS_SLES: // 84 - SLES
-            case CIMOSType_CIMOS_NovellLinuxDesktop: // 87 - Novell Linux Desktop
-                osTypeVBox = SchemaDefs_OSTypeId_OpenSUSE;
-                break;
-
-            case CIMOSType_CIMOS_SUSE_64: // 83 - SUSE 64-Bit
-            case CIMOSType_CIMOS_SLES_64: // 85 - SLES 64-Bit
-                osTypeVBox = SchemaDefs_OSTypeId_OpenSUSE_64;
-                break;
-
-            case CIMOSType_CIMOS_LINUX: // 36 - LINUX
-            case CIMOSType_CIMOS_SunJavaDesktopSystem: // 88 - Sun Java Desktop System
-            case CIMOSType_CIMOS_TurboLinux: // 91 - TurboLinux
-                osTypeVBox = SchemaDefs_OSTypeId_Linux;
-                break;
-
-                //                case CIMOSType_CIMOS_TurboLinux_64: // 92 - TurboLinux 64-Bit
-                //                case CIMOSType_CIMOS_Linux_64: // 101 - Linux 64-Bit
-                //                    osTypeVBox = VBOXOSTYPE_Linux_x64;
-                //                    break;
-
-            case CIMOSType_CIMOS_Mandriva: // 89 - Mandriva
-                osTypeVBox = SchemaDefs_OSTypeId_Mandriva;
-                break;
-
-            case CIMOSType_CIMOS_Mandriva_64: // 90 - Mandriva 64-Bit
-                osTypeVBox = SchemaDefs_OSTypeId_Mandriva_64;
-                break;
-
-            case CIMOSType_CIMOS_Ubuntu: // 93 - Ubuntu
-                osTypeVBox = SchemaDefs_OSTypeId_Ubuntu;
-                break;
-
-            case CIMOSType_CIMOS_Ubuntu_64: // 94 - Ubuntu 64-Bit
-                osTypeVBox = SchemaDefs_OSTypeId_Ubuntu_64;
-                break;
-
-            case CIMOSType_CIMOS_Debian: // 95 - Debian
-                osTypeVBox = SchemaDefs_OSTypeId_Debian;
-                break;
-
-            case CIMOSType_CIMOS_Debian_64: // 96 - Debian 64-Bit
-                osTypeVBox = SchemaDefs_OSTypeId_Debian_64;
-                break;
-
-            case CIMOSType_CIMOS_Linux_2_4_x: // 97 - Linux 2.4.x
-                osTypeVBox = SchemaDefs_OSTypeId_Linux24;
-                break;
-
-            case CIMOSType_CIMOS_Linux_2_4_x_64: // 98 - Linux 2.4.x 64-Bit
-                osTypeVBox = SchemaDefs_OSTypeId_Linux24_64;
-                break;
-
-            case CIMOSType_CIMOS_Linux_2_6_x: // 99 - Linux 2.6.x
-                osTypeVBox = SchemaDefs_OSTypeId_Linux26;
-                break;
-
-            case CIMOSType_CIMOS_Linux_2_6_x_64: // 100 - Linux 2.6.x 64-Bit
-                osTypeVBox = SchemaDefs_OSTypeId_Linux26_64;
-                break;
-            default:
-                {
-                    /* If we are here we have no clue what OS this should be. Set to
-                     * other type as default. */
-                    osTypeVBox = SchemaDefs_OSTypeId_Other;
-                }
-        }
-        vsd->addEntry(VirtualSystemDescriptionType_OS, "", toString<ULONG>(vs.cimos), osTypeVBox);
+        Utf8Str strOsTypeVBox,
+                strCIMOSType = toString<ULONG>(vsysThis.cimos);
+        convertCIMOSType2VBoxOSType(strOsTypeVBox, vsysThis.cimos);
+        pNewDesc->addEntry(VirtualSystemDescriptionType_OS,
+                      0,
+                      strCIMOSType,
+                      strOsTypeVBox);
 
         /* VM name */
         /* If the there isn't any name specified create a default one out of
          * the OS type */
-        Utf8Str nameVBox = vs.strName;
+        Utf8Str nameVBox = vsysThis.strName;
         if (nameVBox == "")
-            nameVBox = osTypeVBox;
+            nameVBox = strOsTypeVBox;
         searchUniqueVMName(nameVBox);
-        vsd->addEntry(VirtualSystemDescriptionType_Name, "", vs.strName, nameVBox);
-
-        /* Now that we know the base system get our internal defaults based on that. */
-        ComPtr<IGuestOSType> osType;
-        rc = mVirtualBox->GetGuestOSType(Bstr(osTypeVBox), osType.asOutParam());
+        pNewDesc->addEntry(VirtualSystemDescriptionType_Name,
+                           0,
+                           vsysThis.strName,
+                           nameVBox);
+
+        /* Now that we know the OS type, get our internal defaults based on that. */
+        ComPtr<IGuestOSType> pGuestOSType;
+        rc = mVirtualBox->GetGuestOSType(Bstr(strOsTypeVBox), pGuestOSType.asOutParam());
         ComAssertComRCThrowRC(rc);
 
         /* CPU count */
         /* @todo: check min/max requirements of VBox (SchemaDefs::Min/MaxCPUCount) */
-        ULONG cpuCountVBox = vs.cCPUs;
-        if (vs.cCPUs == 0)
+        ULONG cpuCountVBox = vsysThis.cCPUs;
+        if (vsysThis.cCPUs == 0)
             cpuCountVBox = 1;
-        vsd->addEntry(VirtualSystemDescriptionType_CPU, "", toString<ULONG>(vs.cCPUs), toString<ULONG>(cpuCountVBox));
+        pNewDesc->addEntry(VirtualSystemDescriptionType_CPU,
+                           0,
+                           toString<ULONG>(vsysThis.cCPUs),
+                           toString<ULONG>(cpuCountVBox));
 
         /* RAM */
         /* @todo: check min/max requirements of VBox (SchemaDefs::Min/MaxGuestRAM) */
-        uint64_t ullMemSizeVBox = vs.ullMemorySize;
-        if (vs.ullMemorySize == 0)
+        uint64_t ullMemSizeVBox = vsysThis.ullMemorySize;
+        if (vsysThis.ullMemorySize == 0)
         {
             /* If the RAM of the OVF is zero, use our predefined values */
             ULONG memSizeVBox2;
-            rc = osType->COMGETTER(RecommendedRAM)(&memSizeVBox2);
+            rc = pGuestOSType->COMGETTER(RecommendedRAM)(&memSizeVBox2);
             ComAssertComRCThrowRC(rc);
             /* VBox stores that in MByte */
             ullMemSizeVBox = (uint64_t)memSizeVBox2 * _1M;
         }
-        vsd->addEntry(VirtualSystemDescriptionType_Memory, "", toString<uint64_t>(vs.ullMemorySize), toString<uint64_t>(ullMemSizeVBox));
+        pNewDesc->addEntry(VirtualSystemDescriptionType_Memory,
+                           0,
+                           toString<uint64_t>(vsysThis.ullMemorySize),
+                           toString<uint64_t>(ullMemSizeVBox));
 
         /* Audio */
-        if (!vs.strSoundCardType.isNull())
+        if (!vsysThis.strSoundCardType.isNull())
             /* Currently we set the AC97 always.
                @todo: figure out the hardware which could be possible */
-            vsd->addEntry(VirtualSystemDescriptionType_SoundCard, "", vs.strSoundCardType, toString<uint32_t>(AudioControllerType_AC97));
+            pNewDesc->addEntry(VirtualSystemDescriptionType_SoundCard,
+                               0,
+                               vsysThis.strSoundCardType,
+                               "");
 
         /* USB Controller */
-        if (vs.fHasUsbController)
-            vsd->addEntry(VirtualSystemDescriptionType_USBController, "", "", "1");
+        if (vsysThis.fHasUsbController)
+            pNewDesc->addEntry(VirtualSystemDescriptionType_USBController, 0, "", "");
 
         /* Network Controller */
-        // @todo: is there no hardware specified in the OVF-Format?
-        if (vs.llNetworkNames.size() > 0)
+        // @todo: there is no hardware specification in the OVF file; supposedly the
+        // hardware will then be determined by the VirtualSystemType element (e.g. "vmx-07")
+        if (vsysThis.llNetworkNames.size() > 0)
         {
             /* Get the default network adapter type for the selected guest OS */
             NetworkAdapterType_T nwAdapterVBox = NetworkAdapterType_Am79C970A;
-            rc = osType->COMGETTER(AdapterType)(&nwAdapterVBox);
+            rc = pGuestOSType->COMGETTER(AdapterType)(&nwAdapterVBox);
             ComAssertComRCThrowRC(rc);
             list<Utf8Str>::const_iterator nwIt;
@@ -1251 +1275 @@
              * adapters at the maximum. (@todo: warn if it are more!) */
             size_t a = 0;
-            for (nwIt = vs.llNetworkNames.begin();
-                 nwIt != vs.llNetworkNames.end() && a < SchemaDefs::NetworkAdapterCount;
+            for (nwIt = vsysThis.llNetworkNames.begin();
+                 nwIt != vsysThis.llNetworkNames.end() && a < SchemaDefs::NetworkAdapterCount;
                  ++nwIt, ++a)
             {
-                // Utf8Str nwController = *nwIt; // @todo: not used yet
-                vsd->addEntry(VirtualSystemDescriptionType_NetworkAdapter, "", "", toString<ULONG>(nwAdapterVBox));
+                Utf8Str nwController = *nwIt; // @todo: not used yet
+                pNewDesc->addEntry(VirtualSystemDescriptionType_NetworkAdapter, 0, "", toString<ULONG>(nwAdapterVBox));
             }
         }
 
         /* Floppy Drive */
-        if (vs.fHasFloppyDrive)
-            vsd->addEntry(VirtualSystemDescriptionType_Floppy, "", "", "1");
+        if (vsysThis.fHasFloppyDrive)
+            pNewDesc->addEntry(VirtualSystemDescriptionType_Floppy, 0, "", "");
 
         /* CD Drive */
-        /* @todo: I can't disable the CDROM. So nothing to do for now. */
-        //if (vs.fHasCdromDrive)
-        //    vsd->addEntry(VirtualSystemDescriptionType_CDROM, "", "", "1");
+        if (vsysThis.fHasCdromDrive)
+           pNewDesc->addEntry(VirtualSystemDescriptionType_CDROM, 0, "", "");
 
         /* Hard disk Controller */
         ControllersMap::const_iterator hdcIt;
         /* Iterate through all hard disk controllers */
-        for (hdcIt = vs.mapControllers.begin();
-             hdcIt != vs.mapControllers.end();
+        for (hdcIt = vsysThis.mapControllers.begin();
+             hdcIt != vsysThis.mapControllers.end();
              ++hdcIt)
         {
-            HardDiskController hdc = hdcIt->second;
-            switch (hdc.controllerSystem)
+            const HardDiskController &hdc = hdcIt->second;
+            switch (hdc.system)
             {
-                case IDE:
-                    {
-                        // @todo: figure out the IDE types
-                        /* Use PIIX4 as default */
-                        IDEControllerType_T hdcController = IDEControllerType_PIIX4;
-                        if (!RTStrICmp(hdc.strControllerType.c_str(), "PIIX3"))
-                            hdcController = IDEControllerType_PIIX3;
-                        else if (!RTStrICmp(hdc.strControllerType.c_str(), "PIIX4"))
-                            hdcController = IDEControllerType_PIIX4;
-                        vsd->addEntry(VirtualSystemDescriptionType_HardDiskControllerIDE, toString<uint32_t>(hdc.idController), hdc.strControllerType, toString<ULONG>(hdcController));
-                        break;
-                    }
-#ifdef VBOX_WITH_AHCI
-                case SATA:
-                    {
-                        // @todo: figure out the SATA types
-                        /* We only support a plain AHCI controller, so use them always */
-                        vsd->addEntry(VirtualSystemDescriptionType_HardDiskControllerSATA, toString<uint32_t>(hdc.idController), hdc.strControllerType, "AHCI");
-                        break;
-                    }
-#endif /* VBOX_WITH_AHCI */
-#ifdef VBOX_WITH_SCSI
-                case SCSI:
-                    {
-                        // @todo: figure out the SCSI types
-# ifdef VBOX_WITH_LSILOGIC
-                        Utf8Str hdcController = "LsiLogic";
-# elif VBOX_WITH_BUSLOGIC
-                        Utf8Str hdcController = "BusLogic";
-# else /* !VBOX_WITH_BUSLOGIC */
-                        Utf8Str hdcController;
-# endif
-# ifdef VBOX_WITH_LSILOGIC
-                        if (!RTStrICmp(hdc.strControllerType.c_str(), "LsiLogic"))
-                            hdcController = "LsiLogic";
-# endif /* VBOX_WITH_LSILOGIC */
-# ifdef VBOX_WITH_BUSLOGIC
-                        if (!RTStrICmp(hdc.strControllerType.c_str(), "BusLogic"))
-                            hdcController = "BusLogic";
-# endif /* VBOX_WITH_BUSLOGIC */
-                        vsd->addEntry(VirtualSystemDescriptionType_HardDiskControllerSCSI, toString<uint32_t>(hdc.idController), hdc.strControllerType, hdcController);
-                        break;
-                    }
-#endif /* VBOX_WITH_SCSI */
-                default:
-                    {
-                    /* @todo: hmm, ok, this needs some explanation to the user,
-                     * so set an error! The other possibility is to set IDE
-                     * PIIX4 as default & redirect all hard disks to this
-                     * controller. */
+                case HardDiskController::IDE:
+                {
+                    // @todo: figure out the IDE types
+                    /* Use PIIX4 as default */
+                    IDEControllerType_T hdcController = IDEControllerType_PIIX4;
+                    if (!RTStrICmp(hdc.strControllerType.c_str(), "PIIX3"))
+                        hdcController = IDEControllerType_PIIX3;
+                    else if (!RTStrICmp(hdc.strControllerType.c_str(), "PIIX4"))
+                        hdcController = IDEControllerType_PIIX4;
+                    pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskControllerIDE,
+                                       hdc.idController,
+                                       hdc.strControllerType,
+                                       toString<ULONG>(hdcController));
                     break;
-                    }
+                }
+
+                case HardDiskController::SATA:
+                {
+                    // @todo: figure out the SATA types
+                    /* We only support a plain AHCI controller, so use them always */
+                    pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskControllerSATA,
+                                       hdc.idController,
+                                       hdc.strControllerType,
+                                       "AHCI");
+                    break;
+                }
+
+                case HardDiskController::SCSI:
+                {
+                    // @todo: figure out the SCSI types
+                    Utf8Str hdcController = "LsiLogic";
+                    if (!RTStrICmp(hdc.strControllerType.c_str(), "LsiLogic"))
+                        hdcController = "LsiLogic";
+                    else if (!RTStrICmp(hdc.strControllerType.c_str(), "BusLogic"))
+                        hdcController = "BusLogic";
+                    pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskControllerSCSI,
+                                       hdc.idController,
+                                       hdc.strControllerType,
+                                       hdcController);
+                    break;
+                }
             }
         }
 
         /* Hard disks */
-        if (vs.mapVirtualDisks.size() > 0)
+        if (vsysThis.mapVirtualDisks.size() > 0)
         {
             // @todo:
@@ -1342 +1354 @@
             VirtualDisksMap::const_iterator hdIt;
             /* Iterate through all hard disks ()*/
-            for (hdIt = vs.mapVirtualDisks.begin();
-                 hdIt != vs.mapVirtualDisks.end();
+            for (hdIt = vsysThis.mapVirtualDisks.begin();
+                 hdIt != vsysThis.mapVirtualDisks.end();
                  ++hdIt)
             {
-                VirtualDisk hd = hdIt->second;
+                const VirtualDisk &hd = hdIt->second;
                 /* Get the associated disk image */
-                DiskImage di = m->mapDisks [hd.strDiskId];
-                /* We have to check if we support this format */
-                bool fSupported = false;
+                const DiskImage &di = m->mapDisks[hd.strDiskId];
+
                 // @todo:
                 //  - figure out all possible vmdk formats we also support
                 //  - figure out if there is a url specifier for vhd already
                 //  - we need a url specifier for the vdi format
-                if (!RTStrICmp(di.strFormat.c_str(), "http://www.vmware.com/specifications/vmdk.html#sparse"))
-                    fSupported = true;
-                /* enable compressed formats for the first tests also */
-                else if (!RTStrICmp(di.strFormat.c_str(), "http://www.vmware.com/specifications/vmdk.html#compressed"))
-                    fSupported = true;
-                if (fSupported)
+                if (    (!RTStrICmp(di.strFormat.c_str(), "http://www.vmware.com/specifications/vmdk.html#sparse"))
+                     || (!RTStrICmp(di.strFormat.c_str(), "http://www.vmware.com/specifications/vmdk.html#compressed"))
+                   )
                 {
                     /* Construct the path */
-                    Utf8Str path = Utf8StrFmt("%ls%c%s", defaultHardDiskLocation, RTPATH_DELIMITER, di.strHref.c_str());
+                    Utf8StrFmt path("%ls%c%s", bstrDefaultHardDiskLocation.raw(), RTPATH_DELIMITER, di.strHref.c_str());
                     /* Make the path unique to the VBox installation */
                     searchUniqueDiskImageFilePath(path);
-                    vsd->addEntry(VirtualSystemDescriptionType_HardDiskImage, hd.strDiskId, di.strHref, path);
+                    pNewDesc->addEntry(VirtualSystemDescriptionType_HardDiskImage,
+                                       hd.idController,
+                                       di.strHref,
+                                       path);
                 }
             }
         }
 
-        m->virtualSystemDescriptions.push_back(vsd);
+        m->virtualSystemDescriptions.push_back(pNewDesc);
     }
 
@@ -1390 +1401 @@
     size_t i = 0;
     for (it = m->llVirtualSystems.begin(),
-         it1 = m->virtualSystemDescriptions.begin();
+            it1 = m->virtualSystemDescriptions.begin();
          it != m->llVirtualSystems.end();
          ++it, ++it1, ++i)
     {
-        const VirtualSystem &vs = *it;
-        ComObjPtr<VirtualSystemDescription> vsd = (*it1);
+        const VirtualSystem &vsysThis = *it;
+        ComObjPtr<VirtualSystemDescription> vsdescThis = (*it1);
 
         /* Guest OS type */
-        std::list<VirtualSystemDescriptionEntry*> vsdeOS = vsd->findByType(VirtualSystemDescriptionType_OS);
+        std::list<VirtualSystemDescriptionEntry*> vsdeOS = vsdescThis->findByType(VirtualSystemDescriptionType_OS);
         Assert(vsdeOS.size() == 1);
-        const Utf8Str &osTypeVBox = vsdeOS.front()->strFinalValue;
+        const Utf8Str &osTypeVBox = vsdeOS.front()->strConfig;
 
         /* Now that we know the base system get our internal defaults based on that. */
@@ -1409 +1420 @@
         /* Create the machine */
         /* First get the name */
-        std::list<VirtualSystemDescriptionEntry*> vsdeName = vsd->findByType(VirtualSystemDescriptionType_Name);
+        std::list<VirtualSystemDescriptionEntry*> vsdeName = vsdescThis->findByType(VirtualSystemDescriptionType_Name);
         Assert(vsdeName.size() == 1);
-        const Utf8Str &nameVBox = vsdeName.front()->strFinalValue;
+        const Utf8Str &nameVBox = vsdeName.front()->strConfig;
         ComPtr<IMachine> newMachine;
-        rc = mVirtualBox->CreateMachine(Bstr(nameVBox.c_str()), Bstr(osTypeVBox.c_str()),
+        rc = mVirtualBox->CreateMachine(Bstr(nameVBox), Bstr(osTypeVBox),
                                         Bstr(), Guid(),
                                         newMachine.asOutParam());
@@ -1424 +1435 @@
         /* RAM */
         /* @todo: check min/max requirements of VBox (SchemaDefs::Min/MaxGuestRAM) */
-        std::list<VirtualSystemDescriptionEntry*> vsdeRAM = vsd->findByType(VirtualSystemDescriptionType_Memory);
+        std::list<VirtualSystemDescriptionEntry*> vsdeRAM = vsdescThis->findByType(VirtualSystemDescriptionType_Memory);
         Assert(vsdeRAM.size() == 1);
-        const Utf8Str &memoryVBox = vsdeRAM.front()->strFinalValue;
+        const Utf8Str &memoryVBox = vsdeRAM.front()->strConfig;
         uint64_t tt = RTStrToUInt64(memoryVBox.c_str()) / _1M;
 
@@ -1444 +1455 @@
 
         /* Audio Adapter */
-        std::list<VirtualSystemDescriptionEntry*> vsdeAudioAdapter = vsd->findByType(VirtualSystemDescriptionType_SoundCard);
+        std::list<VirtualSystemDescriptionEntry*> vsdeAudioAdapter = vsdescThis->findByType(VirtualSystemDescriptionType_SoundCard);
         /* @todo: we support one audio adapter only */
         if (vsdeAudioAdapter.size() > 0)
         {
-            const Utf8Str& audioAdapterVBox = vsdeAudioAdapter.front()->strFinalValue;
+            const Utf8Str& audioAdapterVBox = vsdeAudioAdapter.front()->strConfig;
             if (RTStrICmp(audioAdapterVBox, "null") != 0)
             {
@@ -1490 +1501 @@
 
         /* USB Controller */
-        std::list<VirtualSystemDescriptionEntry*> vsdeUSBController = vsd->findByType(VirtualSystemDescriptionType_USBController);
+        std::list<VirtualSystemDescriptionEntry*> vsdeUSBController = vsdescThis->findByType(VirtualSystemDescriptionType_USBController);
         /* If there is no USB controller entry it will be disabled */
         bool fUSBEnabled = vsdeUSBController.size() > 0;
@@ -1496 +1507 @@
         {
             /* Check if the user has disabled the USB controller in the client */
-            const Utf8Str& usbVBox = vsdeUSBController.front()->strFinalValue;
+            const Utf8Str& usbVBox = vsdeUSBController.front()->strConfig;
             fUSBEnabled = usbVBox == "1";
         }
@@ -1506 +1517 @@
 
         /* Change the network adapters */
-        std::list<VirtualSystemDescriptionEntry*> vsdeNW = vsd->findByType(VirtualSystemDescriptionType_NetworkAdapter);
+        std::list<VirtualSystemDescriptionEntry*> vsdeNW = vsdescThis->findByType(VirtualSystemDescriptionType_NetworkAdapter);
         if (vsdeNW.size() == 0)
         {
@@ -1526 +1537 @@
                  ++nwIt, ++a)
             {
-                const Utf8Str &nwTypeVBox = (*nwIt)->strFinalValue;
+                const Utf8Str &nwTypeVBox = (*nwIt)->strConfig;
                 uint32_t tt1 = RTStrToUInt32(nwTypeVBox.c_str());
                 ComPtr<INetworkAdapter> nwVBox;
@@ -1541 +1552 @@
 
         /* Floppy drive */
-        std::list<VirtualSystemDescriptionEntry*> vsdeFloppy = vsd->findByType(VirtualSystemDescriptionType_Floppy);
+        std::list<VirtualSystemDescriptionEntry*> vsdeFloppy = vsdescThis->findByType(VirtualSystemDescriptionType_Floppy);
         /* If there is no floppy drive entry it will be disabled */
         bool fFloppyEnabled = vsdeFloppy.size() > 0;
@@ -1547 +1558 @@
         {
             /* Check if the user has disabled the floppy drive in the client */
-            const Utf8Str& floppyVBox = vsdeFloppy.front()->strFinalValue;
+            const Utf8Str& floppyVBox = vsdeFloppy.front()->strConfig;
             fFloppyEnabled = floppyVBox == "1";
         }
@@ -1561 +1572 @@
 
         /* Hard disk controller IDE */
-        std::list<VirtualSystemDescriptionEntry*> vsdeHDCIDE = vsd->findByType(VirtualSystemDescriptionType_HardDiskControllerIDE);
+        std::list<VirtualSystemDescriptionEntry*> vsdeHDCIDE = vsdescThis->findByType(VirtualSystemDescriptionType_HardDiskControllerIDE);
         /* @todo: we support one IDE controller only */
         if (vsdeHDCIDE.size() > 0)
         {
-             IDEControllerType_T hdcVBox = static_cast<IDEControllerType_T>(RTStrToUInt32(vsdeHDCIDE.front()->strFinalValue.c_str()));
+             IDEControllerType_T hdcVBox = static_cast<IDEControllerType_T>(RTStrToUInt32(vsdeHDCIDE.front()->strConfig.c_str()));
              /* Set the appropriate IDE controller in the virtual BIOS of the
               * VM. */
@@ -1576 +1587 @@
 #ifdef VBOX_WITH_AHCI
         /* Hard disk controller SATA */
-        std::list<VirtualSystemDescriptionEntry*> vsdeHDCSATA = vsd->findByType(VirtualSystemDescriptionType_HardDiskControllerSATA);
+        std::list<VirtualSystemDescriptionEntry*> vsdeHDCSATA = vsdescThis->findByType(VirtualSystemDescriptionType_HardDiskControllerSATA);
         /* @todo: we support one SATA controller only */
         if (vsdeHDCSATA.size() > 0)
         {
-            const Utf8Str &hdcVBox = vsdeHDCIDE.front()->strFinalValue;
+            const Utf8Str &hdcVBox = vsdeHDCIDE.front()->strConfig;
             if (hdcVBox == "AHCI")
             {
@@ -1598 +1609 @@
 #ifdef VBOX_WITH_SCSI
         /* Hard disk controller SCSI */
-        EntriesList vsdeHDCSCSI = vsd->findByType(VirtualSystemDescriptionType_HardDiskControllerSCSI);
+        EntriesList vsdeHDCSCSI = vsdescThis->findByType(VirtualSystemDescriptionType_HardDiskControllerSCSI);
         /* @todo: do we support more than one SCSI controller? */
         if (vsdeHDCSCSI.size() > 0)
@@ -1612 +1623 @@
 
         /* Create the hard disks & connect them to the appropriate controllers. */
-        std::list<VirtualSystemDescriptionEntry*> vsdeHD = vsd->findByType(VirtualSystemDescriptionType_HardDiskImage);
-        if (vsdeHD.size() > 0)
+        std::list<VirtualSystemDescriptionEntry*> avsdeHDs = vsdescThis->findByType(VirtualSystemDescriptionType_HardDiskImage);
+        if (avsdeHDs.size() > 0)
         {
             /* That we can attach hard disks we need to open a session for the
@@ -1629 +1640 @@
             /* The disk image has to be on the same place as the OVF file. So
              * strip the filename out of the full file path. */
-            char *srcDir = RTStrDup(Utf8Str(m->bstrPath).raw());
-            RTPathStripFilename(srcDir);
+            char *pszSrcDir = RTStrDup(Utf8Str(m->bstrPath).raw());
+            RTPathStripFilename(pszSrcDir);
+            Utf8Str strSrcDir(pszSrcDir);
+            RTStrFree(pszSrcDir);
+
             /* Iterate over all given disk images */
             list<VirtualSystemDescriptionEntry*>::const_iterator hdIt;
-            for (hdIt = vsdeHD.begin();
-                 hdIt != vsdeHD.end();
+            for (hdIt = avsdeHDs.begin();
+                 hdIt != avsdeHDs.end();
                  ++hdIt)
             {
-                char *dstFilePath = RTStrDup((*hdIt)->strFinalValue.c_str());
+                const VirtualSystemDescriptionEntry &vsdeHD = (**hdIt);
+
+                const char *pcszDestFilePath = vsdeHD.strConfig.c_str();
                 /* Check if the destination file exists already or the
                  * destination path is empty. */
-                if (RTPathExists(dstFilePath) ||
-                    !RTStrCmp(dstFilePath, ""))
+                if (RTPathExists(pcszDestFilePath) ||
+                    !RTStrCmp(pcszDestFilePath, ""))
                 {
                     /* @todo: what now? For now we override in no
@@ -1647 +1663 @@
                     continue;
                 }
-                const Utf8Str &strRef = (*hdIt)->strRef;
+
+                uint32_t ulRef = (*hdIt)->ulRef;
                 /* Get the associated disk image */
-                if (m->mapDisks.find(strRef) == m->mapDisks.end() ||
-                    vs.mapVirtualDisks.find(strRef) == vs.mapVirtualDisks.end())
+                if (m->mapDisks.find(ulRef) == m->mapDisks.end() ||
+                    vsysThis.mapVirtualDisks.find(ulRef) == vsysThis.mapVirtualDisks.end())
                 {
                     /* @todo: error: entry doesn't exists */
                 }
-                DiskImage di = m->mapDisks[strRef];
-                VirtualDisk vd = (*vs.mapVirtualDisks.find(strRef)).second;
+                DiskImage di = m->mapDisks[ulRef];
+                VirtualDisk vd = (*vsysThis.mapVirtualDisks.find(ulRef)).second;
                 /* Construct the source file path */
-                char *srcFilePath;
-                RTStrAPrintf(&srcFilePath, "%s/%s", srcDir, di.strHref.c_str());
+                Utf8StrFmt strSrcFilePath("%s/%s", strSrcDir.c_str(), di.strHref.c_str());
                 /* Check if the source file exists */
-                if (!RTPathExists(srcFilePath))
+                if (!RTPathExists(strSrcFilePath.c_str()))
                 {
                     /* @todo: we have to create a new one */
@@ -1667 +1683 @@
                 {
                     /* Make sure all target directories exists */
-                    rc = VirtualBox::ensureFilePathExists(dstFilePath);
+                    rc = VirtualBox::ensureFilePathExists(pcszDestFilePath);
                     CheckComRCThrowRC(rc);
                     /* Clone the disk image (this is necessary cause the id has
@@ -1674 +1690 @@
                     /* First open the existing disk image */
                     ComPtr<IHardDisk2> srcHdVBox;
-                    rc = mVirtualBox->OpenHardDisk2(Bstr(srcFilePath), srcHdVBox.asOutParam());
+                    rc = mVirtualBox->OpenHardDisk2(Bstr(strSrcFilePath), srcHdVBox.asOutParam());
                     CheckComRCReturnRC(rc);
                     /* We need the format description of the source disk image */
@@ -1682 +1698 @@
                     /* Create a new hard disk interface for the destination disk image */
                     ComPtr<IHardDisk2> dstHdVBox;
-                    rc = mVirtualBox->CreateHardDisk2(srcFormat, Bstr(dstFilePath), dstHdVBox.asOutParam());
+                    rc = mVirtualBox->CreateHardDisk2(srcFormat, Bstr(pcszDestFilePath), dstHdVBox.asOutParam());
                     CheckComRCReturnRC(rc);
                     /* Clone the source disk image */
@@ -1700 +1716 @@
                     CheckComRCReturnRC(rc);
                     /* For now we assume we have one controller of every type only */
-                    HardDiskController hdc = (*vs.mapControllers.find(vd.idController)).second;
+                    HardDiskController hdc = (*vsysThis.mapControllers.find(vd.idController)).second;
                     StorageBus_T sbt = StorageBus_IDE;
-                    switch (hdc.controllerSystem)
+                    switch (hdc.system)
                     {
-                        case IDE: sbt = StorageBus_IDE; break;
-                        case SATA: sbt = StorageBus_SATA; break;
+                        case HardDiskController::IDE: sbt = StorageBus_IDE; break;
+                        case HardDiskController::SATA: sbt = StorageBus_SATA; break;
                         //case SCSI: sbt = StorageBus_SCSI; break; // @todo: not available yet
                         default: break;
@@ -1716 +1732 @@
                     CheckComRCReturnRC(rc);
                 }
-                RTStrFree(srcFilePath);
-                RTStrFree(dstFilePath);
             }
-            RTStrFree(srcDir);
         }
         /* @todo: Unregister on failure */
@@ -1812 +1825 @@
 
 STDMETHODIMP VirtualSystemDescription::GetDescription(ComSafeArrayOut(VirtualSystemDescriptionType_T, aTypes),
+                                                      ComSafeArrayOut(ULONG, aRefs),
                                                       ComSafeArrayOut(BSTR, aOrigValues),
-                                                      ComSafeArrayOut(BSTR, aAutoValues),
-                                                      ComSafeArrayOut(BSTR, aConfigurations))
+                                                      ComSafeArrayOut(BSTR, aConfigValues),
+                                                      ComSafeArrayOut(BSTR, aExtraConfigValues))
 {
     if (ComSafeArrayOutIsNull(aTypes) ||
+        ComSafeArrayOutIsNull(aRefs) ||
         ComSafeArrayOutIsNull(aOrigValues) ||
-        ComSafeArrayOutIsNull(aAutoValues) ||
-        ComSafeArrayOutIsNull(aConfigurations))
+        ComSafeArrayOutIsNull(aConfigValues) ||
+        ComSafeArrayOutIsNull(aExtraConfigValues))
         return E_POINTER;
 
@@ -1829 +1844 @@
     ULONG c = (ULONG)m->descriptions.size();
     com::SafeArray<VirtualSystemDescriptionType_T> sfaTypes(c);
+    com::SafeArray<ULONG> sfaRefs(c);
     com::SafeArray<BSTR> sfaOrigValues(c);
-    com::SafeArray<BSTR> sfaAutoValues(c);
-    com::SafeArray<BSTR> sfaConfigurations(c);
+    com::SafeArray<BSTR> sfaConfigValues(c);
+    com::SafeArray<BSTR> sfaExtraConfigValues(c);
 
     list<VirtualSystemDescriptionEntry>::const_iterator it;
@@ -1840 +1856 @@
     {
         const VirtualSystemDescriptionEntry &vsde = (*it);
-        /* Types */
-        sfaTypes [i] = vsde.type;
-        /* Original value */
-        Bstr bstr = vsde.strOriginalValue;
+
+        sfaTypes[i] = vsde.type;
+
+        sfaRefs[i] = vsde.ulRef;
+
+        Bstr bstr = vsde.strOrig;
         bstr.cloneTo(&sfaOrigValues[i]);
-        /* Auto value */
-        bstr = vsde.strAutoValue;
-        bstr.cloneTo(&sfaAutoValues[i]);
-        /* Configuration */
-        bstr = vsde.strConfiguration;
-        bstr.cloneTo(&sfaConfigurations[i]);
+
+        bstr = vsde.strConfig;
+        bstr.cloneTo(&sfaConfigValues[i]);
+
+        bstr = vsde.strExtraConfig;
+        bstr.cloneTo(&sfaExtraConfigValues[i]);
     }
 
     sfaTypes.detachTo(ComSafeArrayOutArg(aTypes));
+    sfaRefs.detachTo(ComSafeArrayOutArg(aRefs));
     sfaOrigValues.detachTo(ComSafeArrayOutArg(aOrigValues));
-    sfaAutoValues.detachTo(ComSafeArrayOutArg(aAutoValues));
-    sfaConfigurations.detachTo(ComSafeArrayOutArg(aConfigurations));
+    sfaConfigValues.detachTo(ComSafeArrayOutArg(aConfigValues));
+    sfaExtraConfigValues.detachTo(ComSafeArrayOutArg(aExtraConfigValues));
 
     return S_OK;
@@ -1881 +1900 @@
     {
         VirtualSystemDescriptionEntry vsde = (*it);
-        vsde.strFinalValue = values[i];
+        vsde.strConfig = values[i];
     }
 
@@ -1888 +1907 @@
 
 void VirtualSystemDescription::addEntry(VirtualSystemDescriptionType_T aType,
-                                        const Utf8Str &aRef,
+                                        uint32_t ulRef,
                                         const Utf8Str &aOrigValue,
-                                        const Utf8Str &aAutoValue,
-                                        const Utf8Str &aConfig /* = "" */)
+                                        const Utf8Str &aAutoValue)
 {
     VirtualSystemDescriptionEntry vsde;
     vsde.type = aType;
-    vsde.strRef = aRef;
-    vsde.strOriginalValue = aOrigValue;
-    vsde.strAutoValue = aAutoValue;
-    vsde.strConfiguration = aConfig;
-    /* For now we add the auto value as final value also */
-    vsde.strFinalValue = aAutoValue;
+    vsde.ulRef = ulRef;
+    vsde.strOrig = aOrigValue;
+    vsde.strConfig = aAutoValue;
 
     m->descriptions.push_back(vsde);

trunk/src/VBox/Main/glue/string.cpp

@@ -79 +79 @@
 }
 
+int Utf8Str::toInt(uint64_t &i) const
+{
+    return RTStrToUInt64Ex(str, NULL, 0, &i);
+}
+
+int Utf8Str::toInt(uint32_t &i) const
+{
+    return RTStrToUInt32Ex(str, NULL, 0, &i);
+}
+
 struct FormatData
 {

trunk/src/VBox/Main/idl/VirtualBox.xidl

@@ -2990 +2990 @@
     a configuration value.</desc>
 
-    <const name="Name" value="1" />
-    <const name="OS" value="2" />
-    <const name="CPU" value="3" />
-    <const name="Memory" value="4" />
-    <const name="HardDiskControllerIDE" value="5" />
-    <const name="HardDiskControllerSATA" value="6" />
-    <const name="HardDiskControllerSCSI" value="7" />
-    <const name="HardDiskImage" value="8" />
-    <const name="CDROM" value="9" />
-    <const name="Floppy" value="10" />
-    <const name="NetworkAdapter" value="11" />
-    <const name="USBController" value="12" />
-    <const name="SoundCard" value="13" />
+    <const name="Ignore" value="1" />
+    <const name="Name" value="2" />
+    <const name="OS" value="3" />
+    <const name="CPU" value="4" />
+    <const name="Memory" value="5" />
+    <const name="HardDiskControllerIDE" value="6" />
+    <const name="HardDiskControllerSATA" value="7" />
+    <const name="HardDiskControllerSCSI" value="8" />
+    <const name="HardDiskImage" value="9" />
+    <const name="CDROM" value="10" />
+    <const name="Floppy" value="11" />
+    <const name="NetworkAdapter" value="12" />
+    <const name="USBController" value="13" />
+    <const name="SoundCard" value="14" />
 
   </enum>
@@ -3025 +3026 @@
       The list below identifies the value sets that are possible depending on the
       <link to="VirtualSystemDescriptionType" /> enum value in the array item in aTypes[]. In each case,
-      the array item with the same index in aOrigValues[] will contain the original value as contained
-      in the OVF file, and the corresponding item in aAutoValues[] will contain a suggested value to
-      be used for VirtualBox. Items in the other arrays will be empty, unless specified otherwise below:
+      the array item with the same index in aOrigValue[] will contain the original value as contained
+      in the OVF file (just for informational purposes), and the corresponding item in aConfigValues[]
+      will contain a suggested value to be used for VirtualBox. Depending on the description type,
+      the aExtraConfigValues[] array item may also be used.
 
       <ul>
       <li>
-        "OS": then the corresponding item in aAutoValues[] contains the suggested guest operating system
-        for VirtualBox. The corresponding item in aOrigValues[] will contain a numerical value that
-        described the operating system in the OVF (see <link to="CIMOSType" />).
+        "OS": the guest operating system type. There must be exactly one such array item on import. The
+        corresponding item in aConfigValues[] contains the suggested guest operating system for VirtualBox.
+        This will be one of the values listed in <link to="IVirtualBox::guestOSTypes" />. The corresponding
+        item in aOrigValues[] will contain a numerical value that described the operating system in the OVF
+        (see <link to="CIMOSType" />).
       </li>
       <li>
-        "Name": then the correponding item im aOrigValues[] will contain the suggested virtual machine name
-        from the OVF file, and aAutoValues[] will contain a suggestion for a unique VirtualBox
+        "Name": the name to give to the new virtual machine. There can be at most one such array item;
+        if none is present on import, then an automatic name will be created from the operating system
+        type. The correponding item im aOrigValues[] will contain the suggested virtual machine name
+        from the OVF file, and aConfigValues[] will contain a suggestion for a unique VirtualBox
         <link to="IMachine" /> name that does not exist yet.
       </li>
       <li>
-        "CPU": number of CPUs.
+        "CPU": the number of CPUs. There can be at most one such item, which will presently be ignored.
       </li>
       <li>
-        "Memory": amount of memory, in bytes.
+        "Memory": the amount of guest RAM, in bytes. There can be at most one such array item; if none
+        is present on import, then VirtualBox will set a meaningful default based on the operating system
+        type.
       </li>
       <li>
-        "HarddiskControllerSCSI": a SCSI hard disk controller. Here the items in aOrigValues[] and aAutoValues[] will either be
-        "LsiLogic" or "BusLogic". The matching item in the aRefValue[] array will contain a numerical
-        index that other items of the "Harddisk" type can use to specify which hard disk controller
-        a virtual disk should be connected to.
+        "HarddiskControllerSCSI": a SCSI hard disk controller. There can be at most one such item.
+        The items in aOrigValues[] and aConfigValues[] will either be "LsiLogic" or "BusLogic". The
+        matching item in the aRefs[] array will contain an integer that other items of the "Harddisk"
+        type can use to specify which hard disk controller a virtual disk should be connected to.
       </li>
       <li>
-        "HarddiskControllerIDE": an IDE hard disk controller. This has no value in aOrigValues[] or aAutoValues[];
-        as with SCSI controllers, the matching item in the aRefValues[] array will contain a numerical
-        index that other items of the "Harddisk" type can use to specify which hard disk controller
-        a virtual disk should be connected to.
+        "HarddiskControllerIDE": an IDE hard disk controller. There can be at most one such item. This
+        has no value in aOrigValues[] or aAutoValues[]. The matching item in the aRefs[] array will be
+        used as with SCSI controllers (see above).
       </li>
       <li>
-        "Harddisk": a virtual hard disk, most probably as a reference to an image file. The array item
-        in aOrigValues[] will contain the file specification from the OVF file, whereas the item
-        in aAutoValues[] will contain the fully qualified path to the image, which VirtualBox has verified
-        to exist.
-        The item in the aRefValues[] array specifies the hard disk controller to connect to and has the
-        same value as another aRefValues[] array item of the types listed above.
+        "Harddisk": a virtual hard disk, most probably as a reference to an image file. There can be an
+        arbitrary number of these items, one for each virtual disk image that accompanies the OVF. The
+        array item in aOrigValues[] will contain the file specification from the OVF file, whereas the item
+        in aConfigValues[] will contain a qualified path specification where the hard disk image should
+        be copied to; this target image will then be registered with VirtualBox.
+        The matching item in the aRefs[] array must contain a integer specifying the hard disk controller
+        to connect the image to. This number must be the same as the integer used by one of the hard disk
+        controller items (SCSI, SATA or IDE; see above).
       </li>
       <li>
         "NetworkAdapter": a network adapter. (todo document)
       </li>
+      <li>
+        "SoundCard": a sound card. There can be at most one such item. If and only if such an item is
+        present, sound support will be enabled for the new virtual machine. Note that the virtual
+        machine in VirtualBox will always be presented with the standard VirtualBox soundcard, which
+        may be different from the virtual soundcard expected by the appliance.
+      </li>
       </ul>
 
@@ -3077 +3092 @@
       </param>
 
+      <param name="aRefs" type="unsigned long" dir="out" safearray="yes">
+        <desc></desc>
+      </param>
+
       <param name="aOrigValues" type="wstring" dir="out" safearray="yes">
         <desc></desc>
       </param>
 
-      <param name="aAutoValues" type="wstring" dir="out" safearray="yes">
+      <param name="aConfigValues" type="wstring" dir="out" safearray="yes">
         <desc></desc>
       </param>
 
-      <param name="aConfiguration" type="wstring" dir="out" safearray="yes">
+      <param name="aExtraConfigValues" type="wstring" dir="out" safearray="yes">
         <desc></desc>
       </param>

trunk/src/VBox/Main/include/ApplianceImpl.h

@@ -97 +97 @@
 {
     VirtualSystemDescriptionType_T type; /* Of which type is this value */
-    Utf8Str strRef; /* Reference value to the internal implementation */
-    Utf8Str strOriginalValue; /* The original OVF value */
-    Utf8Str strAutoValue; /* The value which VBox suggest */
-    Utf8Str strFinalValue; /* The value the user select */
-    Utf8Str strConfiguration; /* Additional configuration data for this type */
+    uint32_t ulRef;     // reference number
+    Utf8Str strOrig; /* The original OVF value */
+    Utf8Str strConfig; /* The value which VBox suggest */
+    Utf8Str strExtraConfig; /* Additional configuration data for this type */
 };
 
@@ -141 +140 @@
     /* IVirtualSystemDescription methods */
     STDMETHOD(GetDescription)(ComSafeArrayOut(VirtualSystemDescriptionType_T, aTypes),
+                              ComSafeArrayOut(ULONG, aRefs),
                               ComSafeArrayOut(BSTR, aOrigValues),
-                              ComSafeArrayOut(BSTR, aAutoValues),
-                              ComSafeArrayOut(BSTR, aConfigurations));
+                              ComSafeArrayOut(BSTR, aConfigValues),
+                              ComSafeArrayOut(BSTR, aExtraConfigValues));
     STDMETHOD(SetFinalValues)(ComSafeArrayIn(IN_BSTR, aFinalValues));
 
@@ -151 +151 @@
 private:
     void addEntry(VirtualSystemDescriptionType_T aType,
-                  const Utf8Str &aRef,
+                  uint32_t ulRef,
                   const Utf8Str &aOrigValue,
-                  const Utf8Str &aAutoValue,
-                  const Utf8Str &aConfig = "");
+                  const Utf8Str &aAutoValue);
 
     std::list<VirtualSystemDescriptionEntry*> findByType(VirtualSystemDescriptionType_T aType);