[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]

[libvirt] [PATCH 40/66] vbox: Rewrite vboxDomainGetXMLDesc



---
 src/vbox/vbox_common.c        | 1076 ++++++++++++++++++++++++++++++++++-
 src/vbox/vbox_common.h        |    9 +
 src/vbox/vbox_tmpl.c          | 1261 +----------------------------------------
 src/vbox/vbox_uniformed_api.h |    1 +
 4 files changed, 1094 insertions(+), 1253 deletions(-)

diff --git a/src/vbox/vbox_common.c b/src/vbox/vbox_common.c
index 24d2ddb..fa9c0b0 100644
--- a/src/vbox/vbox_common.c
+++ b/src/vbox/vbox_common.c
@@ -109,7 +109,6 @@ if (!data->vboxObj) {\
 #define ARRAY_GET_MACHINES \
     (gVBoxAPI.UArray.handleGetMachines(data->vboxObj))
 
-
 /* global vbox API, used for all common codes. */
 static vboxUniformedAPI gVBoxAPI;
 
@@ -277,6 +276,66 @@ static bool vboxGetDeviceDetails(const char *deviceName,
     return true;
 }
 
+/**
+ * function to generate the name for medium,
+ * for e.g: hda, sda, etc
+ *
+ * @returns     null terminated string with device name or NULL
+ *              for failures
+ * @param       conn            Input Connection Pointer
+ * @param       storageBus      Input storage bus type
+ * @param       deviceInst      Input device instance number
+ * @param       devicePort      Input port number
+ * @param       deviceSlot      Input slot number
+ * @param       aMaxPortPerInst Input array of max port per device instance
+ * @param       aMaxSlotPerPort Input array of max slot per device port
+ *
+ */
+static char *vboxGenerateMediumName(PRUint32  storageBus,
+                                    PRInt32   deviceInst,
+                                    PRInt32   devicePort,
+                                    PRInt32   deviceSlot,
+                                    PRUint32 *aMaxPortPerInst,
+                                    PRUint32 *aMaxSlotPerPort)
+{
+    const char *prefix = NULL;
+    char *name  = NULL;
+    int   total = 0;
+    PRUint32 maxPortPerInst = 0;
+    PRUint32 maxSlotPerPort = 0;
+
+    if (!aMaxPortPerInst ||
+        !aMaxSlotPerPort)
+        return NULL;
+
+    if ((storageBus < StorageBus_IDE) ||
+        (storageBus > StorageBus_Floppy))
+        return NULL;
+
+    maxPortPerInst = aMaxPortPerInst[storageBus];
+    maxSlotPerPort = aMaxSlotPerPort[storageBus];
+    total =   (deviceInst * maxPortPerInst * maxSlotPerPort)
+            + (devicePort * maxSlotPerPort)
+            + deviceSlot;
+
+    if (storageBus == StorageBus_IDE) {
+        prefix = "hd";
+    } else if ((storageBus == StorageBus_SATA) ||
+               (storageBus == StorageBus_SCSI)) {
+        prefix = "sd";
+    } else if (storageBus == StorageBus_Floppy) {
+        prefix = "fd";
+    }
+
+    name = virIndexToDiskName(total, prefix);
+
+    VIR_DEBUG("name=%s, total=%d, storageBus=%u, deviceInst=%d, "
+          "devicePort=%d deviceSlot=%d, maxPortPerInst=%u maxSlotPerPort=%u",
+          NULLSTR(name), total, storageBus, deviceInst, devicePort,
+          deviceSlot, maxPortPerInst, maxSlotPerPort);
+    return name;
+}
+
 static virDomainDefParserConfig vboxDomainDefParserConfig = {
     .macPrefix = { 0x08, 0x00, 0x27 },
 };
@@ -2860,3 +2919,1018 @@ int vboxDomainGetMaxVcpus(virDomainPtr dom)
     return vboxDomainGetVcpusFlags(dom, (VIR_DOMAIN_AFFECT_LIVE |
                                          VIR_DOMAIN_VCPU_MAXIMUM));
 }
+
+static void
+vboxHostDeviceGetXMLDesc(vboxGlobalData *data, virDomainDefPtr def, IMachine *machine)
+{
+    IUSBCommon *USBCommon = NULL;
+    PRBool enabled = PR_FALSE;
+    vboxArray deviceFilters = VBOX_ARRAY_INITIALIZER;
+    size_t i;
+    PRUint32 USBFilterCount = 0;
+
+    def->nhostdevs = 0;
+
+    gVBoxAPI.UIMachine.GetUSBCommon(machine, &USBCommon);
+    if (!USBCommon)
+        return;
+
+    gVBoxAPI.UIUSBCommon.GetEnabled(USBCommon, &enabled);
+    if (!enabled)
+        goto release_controller;
+
+    gVBoxAPI.UArray.vboxArrayGet(&deviceFilters, USBCommon,
+                                 gVBoxAPI.UArray.handleUSBGetDeviceFilters(USBCommon));
+
+    if (deviceFilters.count <= 0)
+        goto release_filters;
+
+    /* check if the filters are active and then only
+     * alloc mem and set def->nhostdevs
+     */
+
+    for (i = 0; i < deviceFilters.count; i++) {
+        PRBool active = PR_FALSE;
+        IUSBDeviceFilter *deviceFilter = deviceFilters.items[i];
+
+        gVBoxAPI.UIUSBDeviceFilter.GetActive(deviceFilter, &active);
+        if (active) {
+            def->nhostdevs++;
+        }
+    }
+
+    if (def->nhostdevs == 0)
+        goto release_filters;
+
+    /* Alloc mem needed for the filters now */
+    if (VIR_ALLOC_N(def->hostdevs, def->nhostdevs) < 0)
+        goto release_filters;
+
+    for (i = 0; i < def->nhostdevs; i++) {
+        def->hostdevs[i] = virDomainHostdevDefAlloc();
+        if (!def->hostdevs[i])
+            goto release_hostdevs;
+    }
+
+    for (i = 0; i < deviceFilters.count; i++) {
+        PRBool active                  = PR_FALSE;
+        IUSBDeviceFilter *deviceFilter = deviceFilters.items[i];
+        PRUnichar *vendorIdUtf16       = NULL;
+        char *vendorIdUtf8             = NULL;
+        unsigned vendorId              = 0;
+        PRUnichar *productIdUtf16      = NULL;
+        char *productIdUtf8            = NULL;
+        unsigned productId             = 0;
+        char *endptr                   = NULL;
+
+        gVBoxAPI.UIUSBDeviceFilter.GetActive(deviceFilter, &active);
+        if (!active)
+            continue;
+
+        def->hostdevs[USBFilterCount]->mode =
+            VIR_DOMAIN_HOSTDEV_MODE_SUBSYS;
+        def->hostdevs[USBFilterCount]->source.subsys.type =
+            VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB;
+
+        gVBoxAPI.UIUSBDeviceFilter.GetVendorId(deviceFilter, &vendorIdUtf16);
+        gVBoxAPI.UIUSBDeviceFilter.GetProductId(deviceFilter, &productIdUtf16);
+
+        VBOX_UTF16_TO_UTF8(vendorIdUtf16, &vendorIdUtf8);
+        VBOX_UTF16_TO_UTF8(productIdUtf16, &productIdUtf8);
+
+        ignore_value(virStrToLong_ui(vendorIdUtf8, &endptr, 16, &vendorId));
+        ignore_value(virStrToLong_ui(productIdUtf8, &endptr, 16, &productId));
+
+        def->hostdevs[USBFilterCount]->source.subsys.u.usb.vendor  = vendorId;
+        def->hostdevs[USBFilterCount]->source.subsys.u.usb.product = productId;
+
+        VBOX_UTF16_FREE(vendorIdUtf16);
+        VBOX_UTF8_FREE(vendorIdUtf8);
+
+        VBOX_UTF16_FREE(productIdUtf16);
+        VBOX_UTF8_FREE(productIdUtf8);
+
+        USBFilterCount++;
+    }
+
+ release_filters:
+    gVBoxAPI.UArray.vboxArrayRelease(&deviceFilters);
+ release_controller:
+    VBOX_RELEASE(USBCommon);
+    return;
+
+ release_hostdevs:
+    for (i = 0; i < def->nhostdevs; i++)
+        virDomainHostdevDefFree(def->hostdevs[i]);
+    VIR_FREE(def->hostdevs);
+
+    goto release_filters;
+}
+
+static void
+vboxDumpIDEHDDsNew(virDomainDefPtr def, vboxGlobalData *data, IMachine *machine)
+{
+    /* dump IDE hdds if present */
+    vboxArray mediumAttachments         = VBOX_ARRAY_INITIALIZER;
+    bool error = false;
+    int diskCount = 0;
+    size_t i;
+    PRUint32   maxPortPerInst[StorageBus_Floppy + 1] = {};
+    PRUint32   maxSlotPerPort[StorageBus_Floppy + 1] = {};
+
+    if (gVBoxAPI.oldMediumInterface)
+        VIR_WARN("This function may not work in current vbox version");
+
+    def->ndisks = 0;
+    gVBoxAPI.UArray.vboxArrayGet(&mediumAttachments, machine,
+                                 gVBoxAPI.UArray.handleMachineGetMediumAttachments(machine));
+
+    /* get the number of attachments */
+    for (i = 0; i < mediumAttachments.count; i++) {
+        IMediumAttachment *imediumattach = mediumAttachments.items[i];
+        if (imediumattach) {
+            IMedium *medium = NULL;
+
+            gVBoxAPI.UIMediumAttachment.GetMedium(imediumattach, &medium);
+            if (medium) {
+                def->ndisks++;
+                VBOX_RELEASE(medium);
+            }
+        }
+    }
+
+    /* Allocate mem, if fails return error */
+    if (VIR_ALLOC_N(def->disks, def->ndisks) >= 0) {
+        for (i = 0; i < def->ndisks; i++) {
+            virDomainDiskDefPtr disk = virDomainDiskDefNew();
+            if (!disk) {
+                error = true;
+                break;
+            }
+            def->disks[i] = disk;
+        }
+    } else {
+        error = true;
+    }
+
+    if (!error)
+        error = !vboxGetMaxPortSlotValues(data->vboxObj, maxPortPerInst, maxSlotPerPort);
+
+    /* get the attachment details here */
+    for (i = 0; i < mediumAttachments.count && diskCount < def->ndisks && !error; i++) {
+        IMediumAttachment *imediumattach = mediumAttachments.items[i];
+        IStorageController *storageController = NULL;
+        PRUnichar *storageControllerName = NULL;
+        PRUint32   deviceType     = DeviceType_Null;
+        PRUint32   storageBus     = StorageBus_Null;
+        PRBool     readOnly       = PR_FALSE;
+        IMedium   *medium         = NULL;
+        PRUnichar *mediumLocUtf16 = NULL;
+        char      *mediumLocUtf8  = NULL;
+        PRUint32   deviceInst     = 0;
+        PRInt32    devicePort     = 0;
+        PRInt32    deviceSlot     = 0;
+
+        if (!imediumattach)
+            continue;
+
+        gVBoxAPI.UIMediumAttachment.GetMedium(imediumattach, &medium);
+        if (!medium)
+            continue;
+
+        gVBoxAPI.UIMediumAttachment.GetController(imediumattach, &storageControllerName);
+        if (!storageControllerName) {
+            VBOX_RELEASE(medium);
+            continue;
+        }
+
+        gVBoxAPI.UIMachine.GetStorageControllerByName(machine,
+                                                      storageControllerName,
+                                                      &storageController);
+        VBOX_UTF16_FREE(storageControllerName);
+        if (!storageController) {
+            VBOX_RELEASE(medium);
+            continue;
+        }
+
+        gVBoxAPI.UIMedium.GetLocation(medium, &mediumLocUtf16);
+        VBOX_UTF16_TO_UTF8(mediumLocUtf16, &mediumLocUtf8);
+        VBOX_UTF16_FREE(mediumLocUtf16);
+        ignore_value(virDomainDiskSetSource(def->disks[diskCount],
+                                            mediumLocUtf8));
+        VBOX_UTF8_FREE(mediumLocUtf8);
+
+        if (!virDomainDiskGetSource(def->disks[diskCount])) {
+            VBOX_RELEASE(medium);
+            VBOX_RELEASE(storageController);
+            error = true;
+            break;
+        }
+
+        gVBoxAPI.UIStorageController.GetBus(storageController, &storageBus);
+        if (storageBus == StorageBus_IDE) {
+            def->disks[diskCount]->bus = VIR_DOMAIN_DISK_BUS_IDE;
+        } else if (storageBus == StorageBus_SATA) {
+            def->disks[diskCount]->bus = VIR_DOMAIN_DISK_BUS_SATA;
+        } else if (storageBus == StorageBus_SCSI) {
+            def->disks[diskCount]->bus = VIR_DOMAIN_DISK_BUS_SCSI;
+        } else if (storageBus == StorageBus_Floppy) {
+            def->disks[diskCount]->bus = VIR_DOMAIN_DISK_BUS_FDC;
+        }
+
+        gVBoxAPI.UIMediumAttachment.GetType(imediumattach, &deviceType);
+        if (deviceType == DeviceType_HardDisk)
+            def->disks[diskCount]->device = VIR_DOMAIN_DISK_DEVICE_DISK;
+        else if (deviceType == DeviceType_Floppy)
+            def->disks[diskCount]->device = VIR_DOMAIN_DISK_DEVICE_FLOPPY;
+        else if (deviceType == DeviceType_DVD)
+            def->disks[diskCount]->device = VIR_DOMAIN_DISK_DEVICE_CDROM;
+
+        gVBoxAPI.UIMediumAttachment.GetPort(imediumattach, &devicePort);
+        gVBoxAPI.UIMediumAttachment.GetDevice(imediumattach, &deviceSlot);
+        def->disks[diskCount]->dst = vboxGenerateMediumName(storageBus,
+                                                            deviceInst,
+                                                            devicePort,
+                                                            deviceSlot,
+                                                            maxPortPerInst,
+                                                            maxSlotPerPort);
+        if (!def->disks[diskCount]->dst) {
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("Could not generate medium name for the disk "
+                             "at: controller instance:%u, port:%d, slot:%d"),
+                           deviceInst, devicePort, deviceSlot);
+            VBOX_RELEASE(medium);
+            VBOX_RELEASE(storageController);
+            error = true;
+            break;
+        }
+
+        gVBoxAPI.UIMedium.GetReadOnly(medium, &readOnly);
+        if (readOnly == PR_TRUE)
+            def->disks[diskCount]->src->readonly = true;
+
+        virDomainDiskSetType(def->disks[diskCount],
+                             VIR_STORAGE_TYPE_FILE);
+
+        VBOX_RELEASE(medium);
+        VBOX_RELEASE(storageController);
+        diskCount++;
+    }
+
+    gVBoxAPI.UArray.vboxArrayRelease(&mediumAttachments);
+
+    /* cleanup on error */
+    if (error) {
+        for (i = 0; i < def->ndisks; i++) {
+            VIR_FREE(def->disks[i]);
+        }
+        VIR_FREE(def->disks);
+        def->ndisks = 0;
+    }
+}
+
+static void
+vboxDumpVideo(virDomainDefPtr def, vboxGlobalData *data ATTRIBUTE_UNUSED,
+              IMachine *machine)
+{
+    /* dump video options vram/2d/3d/directx/etc. */
+    /* Currently supports only one graphics card */
+    def->nvideos = 1;
+    if (VIR_ALLOC_N(def->videos, def->nvideos) >= 0) {
+        if (VIR_ALLOC(def->videos[0]) >= 0) {
+            /* the default is: vram is 8MB, One monitor, 3dAccel Off */
+            PRUint32 VRAMSize          = 8;
+            PRUint32 monitorCount      = 1;
+            PRBool accelerate3DEnabled = PR_FALSE;
+            PRBool accelerate2DEnabled = PR_FALSE;
+
+            gVBoxAPI.UIMachine.GetVRAMSize(machine, &VRAMSize);
+            gVBoxAPI.UIMachine.GetMonitorCount(machine, &monitorCount);
+            gVBoxAPI.UIMachine.GetAccelerate3DEnabled(machine, &accelerate3DEnabled);
+            if (gVBoxAPI.accelerate2DVideo)
+                gVBoxAPI.UIMachine.GetAccelerate2DVideoEnabled(machine, &accelerate2DEnabled);
+
+            def->videos[0]->type            = VIR_DOMAIN_VIDEO_TYPE_VBOX;
+            def->videos[0]->vram            = VRAMSize * 1024;
+            def->videos[0]->heads           = monitorCount;
+            if (VIR_ALLOC(def->videos[0]->accel) >= 0) {
+                def->videos[0]->accel->support3d = accelerate3DEnabled;
+                def->videos[0]->accel->support2d = accelerate2DEnabled;
+            }
+        }
+    }
+}
+
+static void
+vboxDumpDisplay(virDomainDefPtr def, vboxGlobalData *data, IMachine *machine)
+{
+    /* dump display options vrdp/gui/sdl */
+    int vrdpPresent           = 0;
+    int sdlPresent            = 0;
+    int guiPresent            = 0;
+    int totalPresent          = 0;
+    char *guiDisplay          = NULL;
+    char *sdlDisplay          = NULL;
+    PRUnichar *keyTypeUtf16   = NULL;
+    PRUnichar *valueTypeUtf16 = NULL;
+    char      *valueTypeUtf8  = NULL;
+    IVRDxServer *VRDxServer   = NULL;
+    PRBool VRDxEnabled        = PR_FALSE;
+
+    def->ngraphics = 0;
+
+    VBOX_UTF8_TO_UTF16("FRONTEND/Type", &keyTypeUtf16);
+    gVBoxAPI.UIMachine.GetExtraData(machine, keyTypeUtf16, &valueTypeUtf16);
+    VBOX_UTF16_FREE(keyTypeUtf16);
+
+    if (valueTypeUtf16) {
+        VBOX_UTF16_TO_UTF8(valueTypeUtf16, &valueTypeUtf8);
+        VBOX_UTF16_FREE(valueTypeUtf16);
+
+        if (STREQ(valueTypeUtf8, "sdl") || STREQ(valueTypeUtf8, "gui")) {
+            PRUnichar *keyDislpayUtf16   = NULL;
+            PRUnichar *valueDisplayUtf16 = NULL;
+            char      *valueDisplayUtf8  = NULL;
+
+            VBOX_UTF8_TO_UTF16("FRONTEND/Display", &keyDislpayUtf16);
+            gVBoxAPI.UIMachine.GetExtraData(machine, keyDislpayUtf16, &valueDisplayUtf16);
+            VBOX_UTF16_FREE(keyDislpayUtf16);
+
+            if (valueDisplayUtf16) {
+                VBOX_UTF16_TO_UTF8(valueDisplayUtf16, &valueDisplayUtf8);
+                VBOX_UTF16_FREE(valueDisplayUtf16);
+
+                if (strlen(valueDisplayUtf8) <= 0)
+                    VBOX_UTF8_FREE(valueDisplayUtf8);
+            }
+
+            if (STREQ(valueTypeUtf8, "sdl")) {
+                sdlPresent = 1;
+                if (VIR_STRDUP(sdlDisplay, valueDisplayUtf8) < 0) {
+                    /* just don't go to cleanup yet as it is ok to have
+                     * sdlDisplay as NULL and we check it below if it
+                     * exist and then only use it there
+                     */
+                }
+                totalPresent++;
+            }
+
+            if (STREQ(valueTypeUtf8, "gui")) {
+                guiPresent = 1;
+                if (VIR_STRDUP(guiDisplay, valueDisplayUtf8) < 0) {
+                    /* just don't go to cleanup yet as it is ok to have
+                     * guiDisplay as NULL and we check it below if it
+                     * exist and then only use it there
+                     */
+                }
+                totalPresent++;
+            }
+            VBOX_UTF8_FREE(valueDisplayUtf8);
+        }
+
+        if (STREQ(valueTypeUtf8, "vrdp"))
+            vrdpPresent = 1;
+
+        VBOX_UTF8_FREE(valueTypeUtf8);
+    }
+
+    if ((totalPresent > 0) && (VIR_ALLOC_N(def->graphics, totalPresent) >= 0)) {
+        if ((guiPresent) && (VIR_ALLOC(def->graphics[def->ngraphics]) >= 0)) {
+            def->graphics[def->ngraphics]->type = VIR_DOMAIN_GRAPHICS_TYPE_DESKTOP;
+            if (guiDisplay)
+                def->graphics[def->ngraphics]->data.desktop.display = guiDisplay;
+            def->ngraphics++;
+        }
+
+        if ((sdlPresent) && (VIR_ALLOC(def->graphics[def->ngraphics]) >= 0)) {
+            def->graphics[def->ngraphics]->type = VIR_DOMAIN_GRAPHICS_TYPE_SDL;
+            if (sdlDisplay)
+                def->graphics[def->ngraphics]->data.sdl.display = sdlDisplay;
+            def->ngraphics++;
+        }
+    } else if ((vrdpPresent != 1) && (totalPresent == 0) && (VIR_ALLOC_N(def->graphics, 1) >= 0)) {
+        if (VIR_ALLOC(def->graphics[def->ngraphics]) >= 0) {
+            const char *tmp;
+            def->graphics[def->ngraphics]->type = VIR_DOMAIN_GRAPHICS_TYPE_DESKTOP;
+            tmp = virGetEnvBlockSUID("DISPLAY");
+            if (VIR_STRDUP(def->graphics[def->ngraphics]->data.desktop.display, tmp) < 0) {
+                /* just don't go to cleanup yet as it is ok to have
+                 * display as NULL
+                 */
+            }
+            totalPresent++;
+            def->ngraphics++;
+        }
+    }
+
+    gVBoxAPI.UIMachine.GetVRDxServer(machine, &VRDxServer);
+    if (VRDxServer) {
+        gVBoxAPI.UIVRDxServer.GetEnabled(VRDxServer, &VRDxEnabled);
+        if (VRDxEnabled) {
+
+            totalPresent++;
+
+            if ((VIR_REALLOC_N(def->graphics, totalPresent) >= 0) &&
+                (VIR_ALLOC(def->graphics[def->ngraphics]) >= 0)) {
+                PRUnichar *netAddressUtf16   = NULL;
+                char      *netAddressUtf8    = NULL;
+                PRBool allowMultiConnection  = PR_FALSE;
+                PRBool reuseSingleConnection = PR_FALSE;
+
+                gVBoxAPI.UIVRDxServer.GetPorts(data, VRDxServer, def->graphics[def->ngraphics]);
+
+                def->graphics[def->ngraphics]->type = VIR_DOMAIN_GRAPHICS_TYPE_RDP;
+
+                gVBoxAPI.UIVRDxServer.GetNetAddress(data, VRDxServer, &netAddressUtf16);
+                if (netAddressUtf16) {
+                    VBOX_UTF16_TO_UTF8(netAddressUtf16, &netAddressUtf8);
+                    if (STRNEQ(netAddressUtf8, ""))
+                        virDomainGraphicsListenSetAddress(def->graphics[def->ngraphics], 0,
+                                                          netAddressUtf8, -1, true);
+                    VBOX_UTF16_FREE(netAddressUtf16);
+                    VBOX_UTF8_FREE(netAddressUtf8);
+                }
+
+                gVBoxAPI.UIVRDxServer.GetAllowMultiConnection(VRDxServer, &allowMultiConnection);
+                if (allowMultiConnection) {
+                    def->graphics[def->ngraphics]->data.rdp.multiUser = true;
+                }
+
+                gVBoxAPI.UIVRDxServer.GetReuseSingleConnection(VRDxServer, &reuseSingleConnection);
+                if (reuseSingleConnection) {
+                    def->graphics[def->ngraphics]->data.rdp.replaceUser = true;
+                }
+
+                def->ngraphics++;
+            } else
+                virReportOOMError();
+        }
+        VBOX_RELEASE(VRDxServer);
+    }
+}
+
+static void
+vboxDumpSharedFolders(virDomainDefPtr def, vboxGlobalData *data, IMachine *machine)
+{
+    /* shared folders */
+    vboxArray sharedFolders = VBOX_ARRAY_INITIALIZER;
+    size_t i = 0;
+
+    def->nfss = 0;
+
+    gVBoxAPI.UArray.vboxArrayGet(&sharedFolders, machine,
+                                 gVBoxAPI.UArray.handleMachineGetSharedFolders(machine));
+
+    if (sharedFolders.count <= 0)
+        goto sharedFoldersCleanup;
+
+    if (VIR_ALLOC_N(def->fss, sharedFolders.count) < 0)
+        goto sharedFoldersCleanup;
+
+    for (i = 0; i < sharedFolders.count; i++) {
+        ISharedFolder *sharedFolder = sharedFolders.items[i];
+        PRUnichar *nameUtf16 = NULL;
+        char *name = NULL;
+        PRUnichar *hostPathUtf16 = NULL;
+        char *hostPath = NULL;
+        PRBool writable = PR_FALSE;
+
+        if (VIR_ALLOC(def->fss[i]) < 0)
+            goto sharedFoldersCleanup;
+
+        def->fss[i]->type = VIR_DOMAIN_FS_TYPE_MOUNT;
+
+        gVBoxAPI.UISharedFolder.GetHostPath(sharedFolder, &hostPathUtf16);
+        VBOX_UTF16_TO_UTF8(hostPathUtf16, &hostPath);
+        if (VIR_STRDUP(def->fss[i]->src, hostPath) < 0) {
+            VBOX_UTF8_FREE(hostPath);
+            VBOX_UTF16_FREE(hostPathUtf16);
+            goto sharedFoldersCleanup;
+        }
+        VBOX_UTF8_FREE(hostPath);
+        VBOX_UTF16_FREE(hostPathUtf16);
+
+        gVBoxAPI.UISharedFolder.GetName(sharedFolder, &nameUtf16);
+        VBOX_UTF16_TO_UTF8(nameUtf16, &name);
+        if (VIR_STRDUP(def->fss[i]->dst, name) < 0) {
+            VBOX_UTF8_FREE(name);
+            VBOX_UTF16_FREE(nameUtf16);
+            goto sharedFoldersCleanup;
+        }
+        VBOX_UTF8_FREE(name);
+        VBOX_UTF16_FREE(nameUtf16);
+
+        gVBoxAPI.UISharedFolder.GetWritable(sharedFolder, &writable);
+        def->fss[i]->readonly = !writable;
+
+        ++def->nfss;
+    }
+
+ sharedFoldersCleanup:
+    gVBoxAPI.UArray.vboxArrayRelease(&sharedFolders);
+}
+
+static void
+vboxDumpNetwork(virDomainDefPtr def, vboxGlobalData *data, IMachine *machine, PRUint32 networkAdapterCount)
+{
+    PRUint32 netAdpIncCnt = 0;
+    size_t i = 0;
+    /* dump network cards if present */
+    def->nnets = 0;
+    /* Get which network cards are enabled */
+    for (i = 0; i < networkAdapterCount; i++) {
+        INetworkAdapter *adapter = NULL;
+
+        gVBoxAPI.UIMachine.GetNetworkAdapter(machine, i, &adapter);
+        if (adapter) {
+            PRBool enabled = PR_FALSE;
+
+            gVBoxAPI.UINetworkAdapter.GetEnabled(adapter, &enabled);
+            if (enabled) {
+                def->nnets++;
+            }
+
+            VBOX_RELEASE(adapter);
+        }
+    }
+
+    /* Allocate memory for the networkcards which are enabled */
+    if ((def->nnets > 0) && (VIR_ALLOC_N(def->nets, def->nnets) >= 0)) {
+        for (i = 0; i < def->nnets; i++) {
+            ignore_value(VIR_ALLOC(def->nets[i]));
+        }
+    }
+
+    /* Now get the details about the network cards here */
+    for (i = 0; netAdpIncCnt < def->nnets && i < networkAdapterCount; i++) {
+        INetworkAdapter *adapter = NULL;
+
+        gVBoxAPI.UIMachine.GetNetworkAdapter(machine, i, &adapter);
+        if (adapter) {
+            PRBool enabled = PR_FALSE;
+
+            gVBoxAPI.UINetworkAdapter.GetEnabled(adapter, &enabled);
+            if (enabled) {
+                PRUint32 attachmentType    = NetworkAttachmentType_Null;
+                PRUint32 adapterType       = NetworkAdapterType_Null;
+                PRUnichar *MACAddressUtf16 = NULL;
+                char *MACAddress           = NULL;
+                char macaddr[VIR_MAC_STRING_BUFLEN] = {0};
+
+                gVBoxAPI.UINetworkAdapter.GetAttachmentType(adapter, &attachmentType);
+                if (attachmentType == NetworkAttachmentType_NAT) {
+
+                    def->nets[netAdpIncCnt]->type = VIR_DOMAIN_NET_TYPE_USER;
+
+                } else if (attachmentType == NetworkAttachmentType_Bridged) {
+                    PRUnichar *hostIntUtf16 = NULL;
+                    char *hostInt           = NULL;
+
+                    def->nets[netAdpIncCnt]->type = VIR_DOMAIN_NET_TYPE_BRIDGE;
+
+                    gVBoxAPI.UINetworkAdapter.GetBridgedInterface(adapter, &hostIntUtf16);
+
+                    VBOX_UTF16_TO_UTF8(hostIntUtf16, &hostInt);
+                    ignore_value(VIR_STRDUP(def->nets[netAdpIncCnt]->data.bridge.brname, hostInt));
+
+                    VBOX_UTF8_FREE(hostInt);
+                    VBOX_UTF16_FREE(hostIntUtf16);
+
+                } else if (attachmentType == NetworkAttachmentType_Internal) {
+                    PRUnichar *intNetUtf16 = NULL;
+                    char *intNet           = NULL;
+
+                    def->nets[netAdpIncCnt]->type = VIR_DOMAIN_NET_TYPE_INTERNAL;
+
+                    gVBoxAPI.UINetworkAdapter.GetInternalNetwork(adapter, &intNetUtf16);
+
+                    VBOX_UTF16_TO_UTF8(intNetUtf16, &intNet);
+                    ignore_value(VIR_STRDUP(def->nets[netAdpIncCnt]->data.internal.name, intNet));
+
+                    VBOX_UTF8_FREE(intNet);
+                    VBOX_UTF16_FREE(intNetUtf16);
+
+                } else if (attachmentType == NetworkAttachmentType_HostOnly) {
+                    PRUnichar *hostIntUtf16 = NULL;
+                    char *hostInt           = NULL;
+
+                    def->nets[netAdpIncCnt]->type = VIR_DOMAIN_NET_TYPE_NETWORK;
+
+                    gVBoxAPI.UINetworkAdapter.GetHostOnlyInterface(adapter, &hostIntUtf16);
+
+                    VBOX_UTF16_TO_UTF8(hostIntUtf16, &hostInt);
+                    ignore_value(VIR_STRDUP(def->nets[netAdpIncCnt]->data.network.name, hostInt));
+
+                    VBOX_UTF8_FREE(hostInt);
+                    VBOX_UTF16_FREE(hostIntUtf16);
+
+                } else {
+                    /* default to user type i.e. NAT in VirtualBox if this
+                     * dump is ever used to create a machine.
+                     */
+                    def->nets[netAdpIncCnt]->type = VIR_DOMAIN_NET_TYPE_USER;
+                }
+
+                gVBoxAPI.UINetworkAdapter.GetAdapterType(adapter, &adapterType);
+                if (adapterType == NetworkAdapterType_Am79C970A) {
+                    ignore_value(VIR_STRDUP(def->nets[netAdpIncCnt]->model, "Am79C970A"));
+                } else if (adapterType == NetworkAdapterType_Am79C973) {
+                    ignore_value(VIR_STRDUP(def->nets[netAdpIncCnt]->model, "Am79C973"));
+                } else if (adapterType == NetworkAdapterType_I82540EM) {
+                    ignore_value(VIR_STRDUP(def->nets[netAdpIncCnt]->model, "82540EM"));
+                } else if (adapterType == NetworkAdapterType_I82545EM) {
+                    ignore_value(VIR_STRDUP(def->nets[netAdpIncCnt]->model, "82545EM"));
+                } else if (adapterType == NetworkAdapterType_I82543GC) {
+                    ignore_value(VIR_STRDUP(def->nets[netAdpIncCnt]->model, "82543GC"));
+                } else if (gVBoxAPI.APIVersion >= 3000051 &&
+                           adapterType == NetworkAdapterType_Virtio) {
+                    /* Only vbox 3.1 and later support NetworkAdapterType_Virto */
+                    ignore_value(VIR_STRDUP(def->nets[netAdpIncCnt]->model, "virtio"));
+                }
+
+                gVBoxAPI.UINetworkAdapter.GetMACAddress(adapter, &MACAddressUtf16);
+                VBOX_UTF16_TO_UTF8(MACAddressUtf16, &MACAddress);
+                snprintf(macaddr, VIR_MAC_STRING_BUFLEN,
+                         "%c%c:%c%c:%c%c:%c%c:%c%c:%c%c",
+                         MACAddress[0], MACAddress[1], MACAddress[2], MACAddress[3],
+                         MACAddress[4], MACAddress[5], MACAddress[6], MACAddress[7],
+                         MACAddress[8], MACAddress[9], MACAddress[10], MACAddress[11]);
+
+                /* XXX some real error handling here some day ... */
+                if (virMacAddrParse(macaddr, &def->nets[netAdpIncCnt]->mac) < 0)
+                {}
+
+                netAdpIncCnt++;
+
+                VBOX_UTF16_FREE(MACAddressUtf16);
+                VBOX_UTF8_FREE(MACAddress);
+            }
+
+            VBOX_RELEASE(adapter);
+        }
+    }
+}
+
+static void
+vboxDumpAudio(virDomainDefPtr def, vboxGlobalData *data ATTRIBUTE_UNUSED,
+              IMachine *machine)
+{
+    /* dump sound card if active */
+
+    /* Set def->nsounds to one as VirtualBox currently supports
+     * only one sound card
+     */
+    IAudioAdapter *audioAdapter = NULL;
+
+    gVBoxAPI.UIMachine.GetAudioAdapter(machine, &audioAdapter);
+    if (audioAdapter) {
+        PRBool enabled = PR_FALSE;
+
+        gVBoxAPI.UIAudioAdapter.GetEnabled(audioAdapter, &enabled);
+        if (enabled) {
+            PRUint32 audioController = AudioControllerType_AC97;
+
+            def->nsounds = 1;
+            if (VIR_ALLOC_N(def->sounds, def->nsounds) >= 0) {
+                if (VIR_ALLOC(def->sounds[0]) >= 0) {
+                    gVBoxAPI.UIAudioAdapter.GetAudioController(audioAdapter, &audioController);
+                    if (audioController == AudioControllerType_SB16) {
+                        def->sounds[0]->model = VIR_DOMAIN_SOUND_MODEL_SB16;
+                    } else if (audioController == AudioControllerType_AC97) {
+                        def->sounds[0]->model = VIR_DOMAIN_SOUND_MODEL_AC97;
+                    }
+                } else {
+                    VIR_FREE(def->sounds);
+                    def->nsounds = 0;
+                }
+            } else {
+                def->nsounds = 0;
+            }
+        }
+        VBOX_RELEASE(audioAdapter);
+    }
+}
+
+static void
+vboxDumpSerial(virDomainDefPtr def, vboxGlobalData *data, IMachine *machine, PRUint32 serialPortCount)
+{
+    PRUint32 serialPortIncCount = 0;
+    size_t i = 0;
+    /* dump serial port if active */
+    def->nserials = 0;
+    /* Get which serial ports are enabled/active */
+    for (i = 0; i < serialPortCount; i++) {
+        ISerialPort *serialPort = NULL;
+
+        gVBoxAPI.UIMachine.GetSerialPort(machine, i, &serialPort);
+        if (serialPort) {
+            PRBool enabled = PR_FALSE;
+
+            gVBoxAPI.UISerialPort.GetEnabled(serialPort, &enabled);
+            if (enabled) {
+                def->nserials++;
+            }
+
+            VBOX_RELEASE(serialPort);
+        }
+    }
+
+    /* Allocate memory for the serial ports which are enabled */
+    if ((def->nserials > 0) && (VIR_ALLOC_N(def->serials, def->nserials) >= 0)) {
+        for (i = 0; i < def->nserials; i++) {
+            ignore_value(VIR_ALLOC(def->serials[i]));
+        }
+    }
+
+    /* Now get the details about the serial ports here */
+    for (i = 0;
+         serialPortIncCount < def->nserials && i < serialPortCount;
+         i++) {
+        ISerialPort *serialPort = NULL;
+
+        gVBoxAPI.UIMachine.GetSerialPort(machine, i, &serialPort);
+        if (serialPort) {
+            PRBool enabled = PR_FALSE;
+
+            gVBoxAPI.UISerialPort.GetEnabled(serialPort, &enabled);
+            if (enabled) {
+                PRUint32 hostMode    = PortMode_Disconnected;
+                PRUint32 IOBase      = 0;
+                PRUint32 IRQ         = 0;
+                PRUnichar *pathUtf16 = NULL;
+                char *path           = NULL;
+
+                gVBoxAPI.UISerialPort.GetHostMode(serialPort, &hostMode);
+                if (hostMode == PortMode_HostPipe) {
+                    def->serials[serialPortIncCount]->source.type = VIR_DOMAIN_CHR_TYPE_PIPE;
+                } else if (hostMode == PortMode_HostDevice) {
+                    def->serials[serialPortIncCount]->source.type = VIR_DOMAIN_CHR_TYPE_DEV;
+                } else if (gVBoxAPI.APIVersion >= 2002051 &&
+                           hostMode == PortMode_RawFile) {
+                    /* PortMode RawFile is used for vbox 3.0 or later */
+                    def->serials[serialPortIncCount]->source.type = VIR_DOMAIN_CHR_TYPE_FILE;
+                } else {
+                    def->serials[serialPortIncCount]->source.type = VIR_DOMAIN_CHR_TYPE_NULL;
+                }
+
+                def->serials[serialPortIncCount]->deviceType = VIR_DOMAIN_CHR_DEVICE_TYPE_SERIAL;
+
+                gVBoxAPI.UISerialPort.GetIRQ(serialPort, &IRQ);
+                gVBoxAPI.UISerialPort.GetIOBase(serialPort, &IOBase);
+                if ((IRQ == 4) && (IOBase == 1016)) {
+                    def->serials[serialPortIncCount]->target.port = 0;
+                } else if ((IRQ == 3) && (IOBase == 760)) {
+                    def->serials[serialPortIncCount]->target.port = 1;
+                }
+
+                gVBoxAPI.UISerialPort.GetPath(serialPort, &pathUtf16);
+
+                if (pathUtf16) {
+                    VBOX_UTF16_TO_UTF8(pathUtf16, &path);
+                    ignore_value(VIR_STRDUP(def->serials[serialPortIncCount]->source.data.file.path, path));
+                }
+
+                serialPortIncCount++;
+
+                VBOX_UTF16_FREE(pathUtf16);
+                VBOX_UTF8_FREE(path);
+            }
+
+            VBOX_RELEASE(serialPort);
+        }
+    }
+}
+
+static void
+vboxDumpParallel(virDomainDefPtr def, vboxGlobalData *data, IMachine *machine, PRUint32 parallelPortCount)
+{
+    PRUint32 parallelPortIncCount = 0;
+    size_t i = 0;
+    /* dump parallel ports if active */
+    def->nparallels = 0;
+    /* Get which parallel ports are enabled/active */
+    for (i = 0; i < parallelPortCount; i++) {
+        IParallelPort *parallelPort = NULL;
+
+        gVBoxAPI.UIMachine.GetParallelPort(machine, i, &parallelPort);
+        if (parallelPort) {
+            PRBool enabled = PR_FALSE;
+
+            gVBoxAPI.UIParallelPort.GetEnabled(parallelPort, &enabled);
+            if (enabled) {
+                def->nparallels++;
+            }
+
+            VBOX_RELEASE(parallelPort);
+        }
+    }
+
+    /* Allocate memory for the parallel ports which are enabled */
+    if ((def->nparallels > 0) && (VIR_ALLOC_N(def->parallels, def->nparallels) >= 0)) {
+        for (i = 0; i < def->nparallels; i++) {
+            ignore_value(VIR_ALLOC(def->parallels[i]));
+        }
+    }
+
+    /* Now get the details about the parallel ports here */
+    for (i = 0;
+         parallelPortIncCount < def->nparallels &&
+             i < parallelPortCount;
+         i++) {
+        IParallelPort *parallelPort = NULL;
+
+        gVBoxAPI.UIMachine.GetParallelPort(machine, i, &parallelPort);
+        if (parallelPort) {
+            PRBool enabled = PR_FALSE;
+
+            gVBoxAPI.UIParallelPort.GetEnabled(parallelPort, &enabled);
+            if (enabled) {
+                PRUint32 IOBase      = 0;
+                PRUint32 IRQ         = 0;
+                PRUnichar *pathUtf16 = NULL;
+                char *path           = NULL;
+
+                gVBoxAPI.UIParallelPort.GetIRQ(parallelPort, &IRQ);
+                gVBoxAPI.UIParallelPort.GetIOBase(parallelPort, &IOBase);
+                if ((IRQ == 7) && (IOBase == 888)) {
+                    def->parallels[parallelPortIncCount]->target.port = 0;
+                } else if ((IRQ == 5) && (IOBase == 632)) {
+                    def->parallels[parallelPortIncCount]->target.port = 1;
+                }
+
+                def->parallels[parallelPortIncCount]->source.type = VIR_DOMAIN_CHR_TYPE_FILE;
+                def->parallels[parallelPortIncCount]->deviceType = VIR_DOMAIN_CHR_DEVICE_TYPE_PARALLEL;
+
+                gVBoxAPI.UIParallelPort.GetPath(parallelPort, &pathUtf16);
+
+                VBOX_UTF16_TO_UTF8(pathUtf16, &path);
+                ignore_value(VIR_STRDUP(def->parallels[parallelPortIncCount]->source.data.file.path, path));
+
+                parallelPortIncCount++;
+
+                VBOX_UTF16_FREE(pathUtf16);
+                VBOX_UTF8_FREE(path);
+            }
+
+            VBOX_RELEASE(parallelPort);
+        }
+    }
+}
+
+char *vboxDomainGetXMLDesc(virDomainPtr dom, unsigned int flags)
+{
+    VBOX_OBJECT_CHECK(dom->conn, char *, NULL);
+    virDomainDefPtr def  = NULL;
+    IMachine *machine    = NULL;
+    vboxIIDUnion iid;
+    PRBool accessible = PR_FALSE;
+    size_t i = 0;
+    PRBool PAEEnabled                   = PR_FALSE;
+    PRBool ACPIEnabled                  = PR_FALSE;
+    PRBool IOAPICEnabled                = PR_FALSE;
+    PRUint32 CPUCount                   = 0;
+    PRUint32 memorySize                 = 0;
+    PRUint32 networkAdapterCount        = 0;
+    PRUint32 maxMemorySize              = 4 * 1024;
+    PRUint32 maxBootPosition            = 0;
+    PRUint32 serialPortCount            = 0;
+    PRUint32 parallelPortCount          = 0;
+    IBIOSSettings *bios                 = NULL;
+    PRUint32 chipsetType                = ChipsetType_Null;
+    ISystemProperties *systemProperties = NULL;
+
+    /* Flags checked by virDomainDefFormat */
+
+    if (openSessionForMachine(data, dom->uuid, &iid, &machine, false) < 0)
+        goto cleanup;
+
+    if (VIR_ALLOC(def) < 0)
+        goto cleanup;
+
+    gVBoxAPI.UIMachine.GetAccessible(machine, &accessible);
+    if (!accessible)
+        goto cleanup;
+
+    def->virtType = VIR_DOMAIN_VIRT_VBOX;
+    def->id = dom->id;
+    memcpy(def->uuid, dom->uuid, VIR_UUID_BUFLEN);
+    if (VIR_STRDUP(def->name, dom->name) < 0)
+        goto cleanup;
+
+    gVBoxAPI.UIMachine.GetMemorySize(machine, &memorySize);
+    def->mem.cur_balloon = memorySize * 1024;
+
+    if (gVBoxAPI.chipsetType)
+        gVBoxAPI.UIMachine.GetChipsetType(machine, &chipsetType);
+
+    gVBoxAPI.UIVirtualBox.GetSystemProperties(data->vboxObj, &systemProperties);
+    if (systemProperties) {
+        gVBoxAPI.UISystemProperties.GetMaxGuestRAM(systemProperties, &maxMemorySize);
+        gVBoxAPI.UISystemProperties.GetMaxBootPosition(systemProperties, &maxBootPosition);
+        gVBoxAPI.UISystemProperties.GetMaxNetworkAdapters(systemProperties, chipsetType, &networkAdapterCount);
+        gVBoxAPI.UISystemProperties.GetSerialPortCount(systemProperties, &serialPortCount);
+        gVBoxAPI.UISystemProperties.GetParallelPortCount(systemProperties, &parallelPortCount);
+        VBOX_RELEASE(systemProperties);
+        systemProperties = NULL;
+    }
+    /* Currently setting memory and maxMemory as same, cause
+     * the notation here seems to be inconsistent while
+     * reading and while dumping xml
+     */
+    /* def->mem.max_balloon = maxMemorySize * 1024; */
+    def->mem.max_balloon = memorySize * 1024;
+
+    gVBoxAPI.UIMachine.GetCPUCount(machine, &CPUCount);
+    def->maxvcpus = def->vcpus = CPUCount;
+
+    /* Skip cpumasklen, cpumask, onReboot, onPoweroff, onCrash */
+
+    if (VIR_STRDUP(def->os.type, "hvm") < 0)
+        goto cleanup;
+
+    def->os.arch = virArchFromHost();
+
+    def->os.nBootDevs = 0;
+    for (i = 0; (i < VIR_DOMAIN_BOOT_LAST) && (i < maxBootPosition); i++) {
+        PRUint32 device = DeviceType_Null;
+
+        gVBoxAPI.UIMachine.GetBootOrder(machine, i+1, &device);
+
+        if (device == DeviceType_Floppy) {
+            def->os.bootDevs[i] = VIR_DOMAIN_BOOT_FLOPPY;
+            def->os.nBootDevs++;
+        } else if (device == DeviceType_DVD) {
+            def->os.bootDevs[i] = VIR_DOMAIN_BOOT_CDROM;
+            def->os.nBootDevs++;
+        } else if (device == DeviceType_HardDisk) {
+            def->os.bootDevs[i] = VIR_DOMAIN_BOOT_DISK;
+            def->os.nBootDevs++;
+        } else if (device == DeviceType_Network) {
+            def->os.bootDevs[i] = VIR_DOMAIN_BOOT_NET;
+            def->os.nBootDevs++;
+        } else if (device == DeviceType_USB) {
+            /* Not supported by libvirt yet */
+        } else if (device == DeviceType_SharedFolder) {
+            /* Not supported by libvirt yet */
+            /* Can VirtualBox really boot from a shared folder? */
+        }
+    }
+
+    gVBoxAPI.UIMachine.GetCPUProperty(machine, CPUPropertyType_PAE, &PAEEnabled);
+    if (PAEEnabled)
+        def->features[VIR_DOMAIN_FEATURE_PAE] = VIR_TRISTATE_SWITCH_ON;
+
+    gVBoxAPI.UIMachine.GetBIOSSettings(machine, &bios);
+    if (bios) {
+        gVBoxAPI.UIBIOSSettings.GetACPIEnabled(bios, &ACPIEnabled);
+        if (ACPIEnabled)
+            def->features[VIR_DOMAIN_FEATURE_ACPI] = VIR_TRISTATE_SWITCH_ON;
+
+        gVBoxAPI.UIBIOSSettings.GetIOAPICEnabled(bios, &IOAPICEnabled);
+        if (IOAPICEnabled)
+            def->features[VIR_DOMAIN_FEATURE_APIC] = VIR_TRISTATE_SWITCH_ON;
+
+        VBOX_RELEASE(bios);
+    }
+
+    /* Currently VirtualBox always uses locatime
+     * so locatime is always true here */
+    def->clock.offset = VIR_DOMAIN_CLOCK_OFFSET_LOCALTIME;
+
+    vboxDumpVideo(def, data, machine);
+    vboxDumpDisplay(def, data, machine);
+
+    /* As the medium interface changed from 3.0 to 3.1.
+     * There are two totally different implementations.
+     * The old one would be version specified, while the
+     * new one is using the vboxUniformedAPI and be put
+     * into the common code.
+     */
+    if (gVBoxAPI.oldMediumInterface)
+        gVBoxAPI.dumpIDEHDDsOld(def, data, machine);
+    else
+        vboxDumpIDEHDDsNew(def, data, machine);
+
+    vboxDumpSharedFolders(def, data, machine);
+    vboxDumpNetwork(def, data, machine, networkAdapterCount);
+    vboxDumpAudio(def, data, machine);
+
+    if (gVBoxAPI.oldMediumInterface) {
+        gVBoxAPI.dumpDVD(def, data, machine);
+        gVBoxAPI.dumpFloppy(def, data, machine);
+    }
+
+    vboxDumpSerial(def, data, machine, serialPortCount);
+    vboxDumpParallel(def, data, machine, parallelPortCount);
+
+    /* dump USB devices/filters if active */
+    vboxHostDeviceGetXMLDesc(data, def, machine);
+
+    ret = virDomainDefFormat(def, flags);
+
+ cleanup:
+    VBOX_RELEASE(machine);
+    vboxIIDUnalloc(&iid);
+    virDomainDefFree(def);
+    return ret;
+}
diff --git a/src/vbox/vbox_common.h b/src/vbox/vbox_common.h
index c4e7ae5..434689b 100644
--- a/src/vbox/vbox_common.h
+++ b/src/vbox/vbox_common.h
@@ -196,6 +196,15 @@ enum NetworkAdapterType
     NetworkAdapterType_Virtio = 6
 };
 
+enum NetworkAttachmentType
+{
+    NetworkAttachmentType_Null = 0,
+    NetworkAttachmentType_NAT = 1,
+    NetworkAttachmentType_Bridged = 2,
+    NetworkAttachmentType_Internal = 3,
+    NetworkAttachmentType_HostOnly = 4
+};
+
 enum PortMode
 {
     PortMode_Disconnected = 0,
diff --git a/src/vbox/vbox_tmpl.c b/src/vbox/vbox_tmpl.c
index 803b0cc..f017840 100644
--- a/src/vbox/vbox_tmpl.c
+++ b/src/vbox/vbox_tmpl.c
@@ -676,7 +676,6 @@ _vboxIIDFromArrayItem(vboxGlobalData *data, vboxIIDUnion *iidu,
 
 #endif /* !(VBOX_API_VERSION == 2002000) */
 
-#if VBOX_API_VERSION >= 3001000
 
 /**
  * function to generate the name for medium,
@@ -693,6 +692,9 @@ _vboxIIDFromArrayItem(vboxGlobalData *data, vboxIIDUnion *iidu,
  * @param       aMaxSlotPerPort Input array of max slot per device port
  *
  */
+/* This functions is used for 4.2 and later only since vboxDomainGetXMLDesc
+ * is rewritten. */
+#if VBOX_API_VERSION >= 4002000
 static char *vboxGenerateMediumName(PRUint32  storageBus,
                                     PRInt32   deviceInst,
                                     PRInt32   devicePort,
@@ -737,6 +739,7 @@ static char *vboxGenerateMediumName(PRUint32  storageBus,
           deviceSlot, maxPortPerInst, maxSlotPerPort);
     return name;
 }
+#endif /* VBOX_API_VERSION >= 4002000 */
 
 /**
  * function to get the StorageBus, Port number
@@ -754,6 +757,7 @@ static char *vboxGenerateMediumName(PRUint32  storageBus,
  * @param       deviceSlot      Output slot number
  *
  */
+#if VBOX_API_VERSION >= 3001000
 # if VBOX_API_VERSION < 4000000
 /* Only 3.x will use this function. */
 static bool vboxGetDeviceDetails(const char *deviceName,
@@ -813,6 +817,9 @@ static bool vboxGetDeviceDetails(const char *deviceName,
  *
  */
 
+/* This function would not be used in 4.0 and 4.1 since
+ * vboxDomainGetXMLDesc is written*/
+# if VBOX_API_VERSION >= 4002000 || VBOX_API_VERSION < 4000000
 static bool vboxGetMaxPortSlotValues(IVirtualBox *vbox,
                                      PRUint32 *maxPortPerInst,
                                      PRUint32 *maxSlotPerPort)
@@ -857,6 +864,7 @@ static bool vboxGetMaxPortSlotValues(IVirtualBox *vbox,
 
     return true;
 }
+# endif /* VBOX_API_VERSION >= 4002000 || VBOX_API_VERSION < 4000000 */
 
 /**
  * Converts Utf-16 string to int
@@ -958,1257 +966,6 @@ static virDomainState _vboxConvertState(PRUint32 state)
     }
 }
 
-static void vboxHostDeviceGetXMLDesc(vboxGlobalData *data, virDomainDefPtr def, IMachine *machine)
-{
-#if VBOX_API_VERSION < 4003000
-    IUSBController *USBController = NULL;
-    PRBool enabled = PR_FALSE;
-#else
-    IUSBDeviceFilters *USBDeviceFilters = NULL;
-#endif
-    vboxArray deviceFilters = VBOX_ARRAY_INITIALIZER;
-    size_t i;
-    PRUint32 USBFilterCount = 0;
-
-    def->nhostdevs = 0;
-
-#if VBOX_API_VERSION < 4003000
-    machine->vtbl->GetUSBController(machine, &USBController);
-
-    if (!USBController)
-        return;
-
-    USBController->vtbl->GetEnabled(USBController, &enabled);
-    if (!enabled)
-        goto release_controller;
-
-    vboxArrayGet(&deviceFilters, USBController,
-                 USBController->vtbl->GetDeviceFilters);
-
-#else
-    machine->vtbl->GetUSBDeviceFilters(machine, &USBDeviceFilters);
-
-    if (!USBDeviceFilters)
-        return;
-
-    vboxArrayGet(&deviceFilters, USBDeviceFilters,
-                 USBDeviceFilters->vtbl->GetDeviceFilters);
-#endif
-
-    if (deviceFilters.count <= 0)
-        goto release_filters;
-
-    /* check if the filters are active and then only
-     * alloc mem and set def->nhostdevs
-     */
-
-    for (i = 0; i < deviceFilters.count; i++) {
-        PRBool active = PR_FALSE;
-        IUSBDeviceFilter *deviceFilter = deviceFilters.items[i];
-
-        deviceFilter->vtbl->GetActive(deviceFilter, &active);
-        if (active) {
-            def->nhostdevs++;
-        }
-    }
-
-    if (def->nhostdevs == 0)
-        goto release_filters;
-
-    /* Alloc mem needed for the filters now */
-    if (VIR_ALLOC_N(def->hostdevs, def->nhostdevs) < 0)
-        goto release_filters;
-
-    for (i = 0; i < def->nhostdevs; i++) {
-        def->hostdevs[i] = virDomainHostdevDefAlloc();
-        if (!def->hostdevs[i])
-            goto release_hostdevs;
-    }
-
-    for (i = 0; i < deviceFilters.count; i++) {
-        PRBool active                  = PR_FALSE;
-        IUSBDeviceFilter *deviceFilter = deviceFilters.items[i];
-        PRUnichar *vendorIdUtf16       = NULL;
-        char *vendorIdUtf8             = NULL;
-        unsigned vendorId              = 0;
-        PRUnichar *productIdUtf16      = NULL;
-        char *productIdUtf8            = NULL;
-        unsigned productId             = 0;
-        char *endptr                   = NULL;
-
-        deviceFilter->vtbl->GetActive(deviceFilter, &active);
-        if (!active)
-            continue;
-
-        def->hostdevs[USBFilterCount]->mode =
-            VIR_DOMAIN_HOSTDEV_MODE_SUBSYS;
-        def->hostdevs[USBFilterCount]->source.subsys.type =
-            VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB;
-
-        deviceFilter->vtbl->GetVendorId(deviceFilter, &vendorIdUtf16);
-        deviceFilter->vtbl->GetProductId(deviceFilter, &productIdUtf16);
-
-        VBOX_UTF16_TO_UTF8(vendorIdUtf16, &vendorIdUtf8);
-        VBOX_UTF16_TO_UTF8(productIdUtf16, &productIdUtf8);
-
-        ignore_value(virStrToLong_ui(vendorIdUtf8, &endptr, 16, &vendorId));
-        ignore_value(virStrToLong_ui(productIdUtf8, &endptr, 16, &productId));
-
-        def->hostdevs[USBFilterCount]->source.subsys.u.usb.vendor  = vendorId;
-        def->hostdevs[USBFilterCount]->source.subsys.u.usb.product = productId;
-
-        VBOX_UTF16_FREE(vendorIdUtf16);
-        VBOX_UTF8_FREE(vendorIdUtf8);
-
-        VBOX_UTF16_FREE(productIdUtf16);
-        VBOX_UTF8_FREE(productIdUtf8);
-
-        USBFilterCount++;
-    }
-
- release_filters:
-    vboxArrayRelease(&deviceFilters);
-#if VBOX_API_VERSION < 4003000
- release_controller:
-    VBOX_RELEASE(USBController);
-#else
-    VBOX_RELEASE(USBDeviceFilters);
-#endif
-
-    return;
-
- release_hostdevs:
-    for (i = 0; i < def->nhostdevs; i++)
-        virDomainHostdevDefFree(def->hostdevs[i]);
-    VIR_FREE(def->hostdevs);
-
-    goto release_filters;
-}
-
-static char *vboxDomainGetXMLDesc(virDomainPtr dom, unsigned int flags) {
-    VBOX_OBJECT_CHECK(dom->conn, char *, NULL);
-    virDomainDefPtr def  = NULL;
-    IMachine *machine    = NULL;
-    vboxIID iid = VBOX_IID_INITIALIZER;
-    int gotAllABoutDef   = -1;
-    nsresult rc;
-
-    /* Flags checked by virDomainDefFormat */
-
-    if (VIR_ALLOC(def) < 0)
-        goto cleanup;
-
-    vboxIIDFromUUID(&iid, dom->uuid);
-    rc = VBOX_OBJECT_GET_MACHINE(iid.value, &machine);
-    if (NS_SUCCEEDED(rc)) {
-        PRBool accessible = PR_FALSE;
-
-        machine->vtbl->GetAccessible(machine, &accessible);
-        if (accessible) {
-            size_t i = 0;
-            PRBool PAEEnabled                   = PR_FALSE;
-            PRBool ACPIEnabled                  = PR_FALSE;
-            PRBool IOAPICEnabled                = PR_FALSE;
-            PRBool VRDxEnabled                  = PR_FALSE;
-            PRUint32 CPUCount                   = 0;
-            PRUint32 memorySize                 = 0;
-            PRUint32 netAdpCnt                  = 0;
-            PRUint32 netAdpIncCnt               = 0;
-            PRUint32 maxMemorySize              = 4 * 1024;
-            PRUint32 maxBootPosition            = 0;
-            PRUint32 serialPortCount            = 0;
-            PRUint32 serialPortIncCount         = 0;
-            PRUint32 parallelPortCount          = 0;
-            PRUint32 parallelPortIncCount       = 0;
-            IBIOSSettings *bios                 = NULL;
-#if VBOX_API_VERSION < 3001000
-            PRInt32       hddNum                = 0;
-            IDVDDrive    *dvdDrive              = NULL;
-            IHardDisk    *hardDiskPM            = NULL;
-            IHardDisk    *hardDiskPS            = NULL;
-            IHardDisk    *hardDiskSS            = NULL;
-            const char   *hddBus                = "IDE";
-            PRUnichar    *hddBusUtf16           = NULL;
-            IFloppyDrive *floppyDrive           = NULL;
-#else  /* VBOX_API_VERSION >= 3001000 */
-            vboxArray mediumAttachments         = VBOX_ARRAY_INITIALIZER;
-#endif /* VBOX_API_VERSION >= 3001000 */
-#if VBOX_API_VERSION < 4000000
-            IVRDPServer *VRDxServer             = NULL;
-#else  /* VBOX_API_VERSION >= 4000000 */
-            IVRDEServer *VRDxServer             = NULL;
-#endif /* VBOX_API_VERSION >= 4000000 */
-            IAudioAdapter *audioAdapter         = NULL;
-#if VBOX_API_VERSION >= 4001000
-            PRUint32 chipsetType                = ChipsetType_Null;
-#endif /* VBOX_API_VERSION >= 4001000 */
-            ISystemProperties *systemProperties = NULL;
-
-
-            def->virtType = VIR_DOMAIN_VIRT_VBOX;
-            def->id = dom->id;
-            memcpy(def->uuid, dom->uuid, VIR_UUID_BUFLEN);
-            if (VIR_STRDUP(def->name, dom->name) < 0)
-                goto cleanup;
-
-            machine->vtbl->GetMemorySize(machine, &memorySize);
-            def->mem.cur_balloon = memorySize * 1024;
-
-#if VBOX_API_VERSION >= 4001000
-            machine->vtbl->GetChipsetType(machine, &chipsetType);
-#endif /* VBOX_API_VERSION >= 4001000 */
-
-            data->vboxObj->vtbl->GetSystemProperties(data->vboxObj, &systemProperties);
-            if (systemProperties) {
-                systemProperties->vtbl->GetMaxGuestRAM(systemProperties, &maxMemorySize);
-                systemProperties->vtbl->GetMaxBootPosition(systemProperties, &maxBootPosition);
-#if VBOX_API_VERSION < 4001000
-                systemProperties->vtbl->GetNetworkAdapterCount(systemProperties, &netAdpCnt);
-#else  /* VBOX_API_VERSION >= 4000000 */
-                systemProperties->vtbl->GetMaxNetworkAdapters(systemProperties, chipsetType, &netAdpCnt);
-#endif /* VBOX_API_VERSION >= 4000000 */
-                systemProperties->vtbl->GetSerialPortCount(systemProperties, &serialPortCount);
-                systemProperties->vtbl->GetParallelPortCount(systemProperties, &parallelPortCount);
-                VBOX_RELEASE(systemProperties);
-                systemProperties = NULL;
-            }
-            /* Currently setting memory and maxMemory as same, cause
-             * the notation here seems to be inconsistent while
-             * reading and while dumping xml
-             */
-            /* def->mem.max_balloon = maxMemorySize * 1024; */
-            def->mem.max_balloon = memorySize * 1024;
-
-            machine->vtbl->GetCPUCount(machine, &CPUCount);
-            def->maxvcpus = def->vcpus = CPUCount;
-
-            /* Skip cpumasklen, cpumask, onReboot, onPoweroff, onCrash */
-
-            if (VIR_STRDUP(def->os.type, "hvm") < 0)
-                goto cleanup;
-
-            def->os.arch = virArchFromHost();
-
-            def->os.nBootDevs = 0;
-            for (i = 0; (i < VIR_DOMAIN_BOOT_LAST) && (i < maxBootPosition); i++) {
-                PRUint32 device = DeviceType_Null;
-
-                machine->vtbl->GetBootOrder(machine, i+1, &device);
-
-                if (device == DeviceType_Floppy) {
-                    def->os.bootDevs[i] = VIR_DOMAIN_BOOT_FLOPPY;
-                    def->os.nBootDevs++;
-                } else if (device == DeviceType_DVD) {
-                    def->os.bootDevs[i] = VIR_DOMAIN_BOOT_CDROM;
-                    def->os.nBootDevs++;
-                } else if (device == DeviceType_HardDisk) {
-                    def->os.bootDevs[i] = VIR_DOMAIN_BOOT_DISK;
-                    def->os.nBootDevs++;
-                } else if (device == DeviceType_Network) {
-                    def->os.bootDevs[i] = VIR_DOMAIN_BOOT_NET;
-                    def->os.nBootDevs++;
-                } else if (device == DeviceType_USB) {
-                    /* Not supported by libvirt yet */
-                } else if (device == DeviceType_SharedFolder) {
-                    /* Not supported by libvirt yet */
-                    /* Can VirtualBox really boot from a shared folder? */
-                }
-            }
-
-#if VBOX_API_VERSION < 3001000
-            machine->vtbl->GetPAEEnabled(machine, &PAEEnabled);
-#elif VBOX_API_VERSION == 3001000
-            machine->vtbl->GetCpuProperty(machine, CpuPropertyType_PAE, &PAEEnabled);
-#elif VBOX_API_VERSION >= 3002000
-            machine->vtbl->GetCPUProperty(machine, CPUPropertyType_PAE, &PAEEnabled);
-#endif
-            if (PAEEnabled)
-                def->features[VIR_DOMAIN_FEATURE_PAE] = VIR_TRISTATE_SWITCH_ON;
-
-            machine->vtbl->GetBIOSSettings(machine, &bios);
-            if (bios) {
-                bios->vtbl->GetACPIEnabled(bios, &ACPIEnabled);
-                if (ACPIEnabled)
-                    def->features[VIR_DOMAIN_FEATURE_ACPI] = VIR_TRISTATE_SWITCH_ON;
-
-                bios->vtbl->GetIOAPICEnabled(bios, &IOAPICEnabled);
-                if (IOAPICEnabled)
-                    def->features[VIR_DOMAIN_FEATURE_APIC] = VIR_TRISTATE_SWITCH_ON;
-
-                VBOX_RELEASE(bios);
-            }
-
-            /* Currently VirtualBox always uses locatime
-             * so locatime is always true here */
-            def->clock.offset = VIR_DOMAIN_CLOCK_OFFSET_LOCALTIME;
-
-            /* dump video options vram/2d/3d/directx/etc. */
-            {
-                /* Currently supports only one graphics card */
-                def->nvideos = 1;
-                if (VIR_ALLOC_N(def->videos, def->nvideos) >= 0) {
-                    if (VIR_ALLOC(def->videos[0]) >= 0) {
-                        /* the default is: vram is 8MB, One monitor, 3dAccel Off */
-                        PRUint32 VRAMSize          = 8;
-                        PRUint32 monitorCount      = 1;
-                        PRBool accelerate3DEnabled = PR_FALSE;
-                        PRBool accelerate2DEnabled = PR_FALSE;
-
-                        machine->vtbl->GetVRAMSize(machine, &VRAMSize);
-                        machine->vtbl->GetMonitorCount(machine, &monitorCount);
-                        machine->vtbl->GetAccelerate3DEnabled(machine, &accelerate3DEnabled);
-#if VBOX_API_VERSION >= 3001000
-                        machine->vtbl->GetAccelerate2DVideoEnabled(machine, &accelerate2DEnabled);
-#endif /* VBOX_API_VERSION >= 3001000 */
-
-                        def->videos[0]->type            = VIR_DOMAIN_VIDEO_TYPE_VBOX;
-                        def->videos[0]->vram            = VRAMSize * 1024;
-                        def->videos[0]->heads           = monitorCount;
-                        if (VIR_ALLOC(def->videos[0]->accel) >= 0) {
-                            def->videos[0]->accel->support3d = accelerate3DEnabled;
-                            def->videos[0]->accel->support2d = accelerate2DEnabled;
-                        }
-                    }
-                }
-            }
-
-            /* dump display options vrdp/gui/sdl */
-            {
-                int vrdpPresent           = 0;
-                int sdlPresent            = 0;
-                int guiPresent            = 0;
-                int totalPresent          = 0;
-                char *guiDisplay          = NULL;
-                char *sdlDisplay          = NULL;
-                PRUnichar *keyTypeUtf16   = NULL;
-                PRUnichar *valueTypeUtf16 = NULL;
-                char      *valueTypeUtf8  = NULL;
-
-                def->ngraphics = 0;
-
-                VBOX_UTF8_TO_UTF16("FRONTEND/Type", &keyTypeUtf16);
-                machine->vtbl->GetExtraData(machine, keyTypeUtf16, &valueTypeUtf16);
-                VBOX_UTF16_FREE(keyTypeUtf16);
-
-                if (valueTypeUtf16) {
-                    VBOX_UTF16_TO_UTF8(valueTypeUtf16, &valueTypeUtf8);
-                    VBOX_UTF16_FREE(valueTypeUtf16);
-
-                    if (STREQ(valueTypeUtf8, "sdl") || STREQ(valueTypeUtf8, "gui")) {
-                        PRUnichar *keyDislpayUtf16   = NULL;
-                        PRUnichar *valueDisplayUtf16 = NULL;
-                        char      *valueDisplayUtf8  = NULL;
-
-                        VBOX_UTF8_TO_UTF16("FRONTEND/Display", &keyDislpayUtf16);
-                        machine->vtbl->GetExtraData(machine, keyDislpayUtf16, &valueDisplayUtf16);
-                        VBOX_UTF16_FREE(keyDislpayUtf16);
-
-                        if (valueDisplayUtf16) {
-                            VBOX_UTF16_TO_UTF8(valueDisplayUtf16, &valueDisplayUtf8);
-                            VBOX_UTF16_FREE(valueDisplayUtf16);
-
-                            if (strlen(valueDisplayUtf8) <= 0)
-                                VBOX_UTF8_FREE(valueDisplayUtf8);
-                        }
-
-                        if (STREQ(valueTypeUtf8, "sdl")) {
-                            sdlPresent = 1;
-                            if (VIR_STRDUP(sdlDisplay, valueDisplayUtf8) < 0) {
-                                /* just don't go to cleanup yet as it is ok to have
-                                 * sdlDisplay as NULL and we check it below if it
-                                 * exist and then only use it there
-                                 */
-                            }
-                            totalPresent++;
-                        }
-
-                        if (STREQ(valueTypeUtf8, "gui")) {
-                            guiPresent = 1;
-                            if (VIR_STRDUP(guiDisplay, valueDisplayUtf8) < 0) {
-                                /* just don't go to cleanup yet as it is ok to have
-                                 * guiDisplay as NULL and we check it below if it
-                                 * exist and then only use it there
-                                 */
-                            }
-                            totalPresent++;
-                        }
-                        VBOX_UTF8_FREE(valueDisplayUtf8);
-                    }
-
-                    if (STREQ(valueTypeUtf8, "vrdp"))
-                        vrdpPresent = 1;
-
-                    VBOX_UTF8_FREE(valueTypeUtf8);
-                }
-
-                if ((totalPresent > 0) && (VIR_ALLOC_N(def->graphics, totalPresent) >= 0)) {
-                    if ((guiPresent) && (VIR_ALLOC(def->graphics[def->ngraphics]) >= 0)) {
-                        def->graphics[def->ngraphics]->type = VIR_DOMAIN_GRAPHICS_TYPE_DESKTOP;
-                        if (guiDisplay)
-                            def->graphics[def->ngraphics]->data.desktop.display = guiDisplay;
-                        def->ngraphics++;
-                    }
-
-                    if ((sdlPresent) && (VIR_ALLOC(def->graphics[def->ngraphics]) >= 0)) {
-                        def->graphics[def->ngraphics]->type = VIR_DOMAIN_GRAPHICS_TYPE_SDL;
-                        if (sdlDisplay)
-                            def->graphics[def->ngraphics]->data.sdl.display = sdlDisplay;
-                        def->ngraphics++;
-                    }
-                } else if ((vrdpPresent != 1) && (totalPresent == 0) && (VIR_ALLOC_N(def->graphics, 1) >= 0)) {
-                    if (VIR_ALLOC(def->graphics[def->ngraphics]) >= 0) {
-                        const char *tmp;
-                        def->graphics[def->ngraphics]->type = VIR_DOMAIN_GRAPHICS_TYPE_DESKTOP;
-                        tmp = virGetEnvBlockSUID("DISPLAY");
-                        if (VIR_STRDUP(def->graphics[def->ngraphics]->data.desktop.display, tmp) < 0) {
-                            /* just don't go to cleanup yet as it is ok to have
-                             * display as NULL
-                             */
-                        }
-                        totalPresent++;
-                        def->ngraphics++;
-                    }
-                }
-
-#if VBOX_API_VERSION < 4000000
-                machine->vtbl->GetVRDPServer(machine, &VRDxServer);
-#else  /* VBOX_API_VERSION >= 4000000 */
-                machine->vtbl->GetVRDEServer(machine, &VRDxServer);
-#endif /* VBOX_API_VERSION >= 4000000 */
-                if (VRDxServer) {
-                    VRDxServer->vtbl->GetEnabled(VRDxServer, &VRDxEnabled);
-                    if (VRDxEnabled) {
-
-                        totalPresent++;
-
-                        if ((VIR_REALLOC_N(def->graphics, totalPresent) >= 0) &&
-                            (VIR_ALLOC(def->graphics[def->ngraphics]) >= 0)) {
-                            PRUnichar *netAddressUtf16   = NULL;
-                            char      *netAddressUtf8    = NULL;
-                            PRBool allowMultiConnection  = PR_FALSE;
-                            PRBool reuseSingleConnection = PR_FALSE;
-#if VBOX_API_VERSION < 3001000
-                            PRUint32 VRDPport = 0;
-                            VRDxServer->vtbl->GetPort(VRDxServer, &VRDPport);
-                            if (VRDPport) {
-                                def->graphics[def->ngraphics]->data.rdp.port = VRDPport;
-                            } else {
-                                def->graphics[def->ngraphics]->data.rdp.autoport = true;
-                            }
-#elif VBOX_API_VERSION < 4000000 /* 3001000 <= VBOX_API_VERSION < 4000000 */
-                            PRUnichar *VRDPport = NULL;
-                            VRDxServer->vtbl->GetPorts(VRDxServer, &VRDPport);
-                            if (VRDPport) {
-                                /* even if vbox supports mutilpe ports, single port for now here */
-                                def->graphics[def->ngraphics]->data.rdp.port = PRUnicharToInt(VRDPport);
-                                VBOX_UTF16_FREE(VRDPport);
-                            } else {
-                                def->graphics[def->ngraphics]->data.rdp.autoport = true;
-                            }
-#else /* VBOX_API_VERSION >= 4000000 */
-                            PRUnichar *VRDEPortsKey = NULL;
-                            PRUnichar *VRDEPortsValue = NULL;
-                            VBOX_UTF8_TO_UTF16("TCP/Ports", &VRDEPortsKey);
-                            VRDxServer->vtbl->GetVRDEProperty(VRDxServer, VRDEPortsKey, &VRDEPortsValue);
-                            VBOX_UTF16_FREE(VRDEPortsKey);
-                            if (VRDEPortsValue) {
-                                /* even if vbox supports mutilpe ports, single port for now here */
-                                def->graphics[def->ngraphics]->data.rdp.port = PRUnicharToInt(VRDEPortsValue);
-                                VBOX_UTF16_FREE(VRDEPortsValue);
-                            } else {
-                                def->graphics[def->ngraphics]->data.rdp.autoport = true;
-                            }
-#endif /* VBOX_API_VERSION >= 4000000 */
-
-                            def->graphics[def->ngraphics]->type = VIR_DOMAIN_GRAPHICS_TYPE_RDP;
-
-#if VBOX_API_VERSION >= 4000000
-                            PRUnichar *VRDENetAddressKey = NULL;
-                            VBOX_UTF8_TO_UTF16("TCP/Address", &VRDENetAddressKey);
-                            VRDxServer->vtbl->GetVRDEProperty(VRDxServer, VRDENetAddressKey, &netAddressUtf16);
-                            VBOX_UTF16_FREE(VRDENetAddressKey);
-#else /* VBOX_API_VERSION < 4000000 */
-                            VRDxServer->vtbl->GetNetAddress(VRDxServer, &netAddressUtf16);
-#endif /* VBOX_API_VERSION < 4000000 */
-                            if (netAddressUtf16) {
-                                VBOX_UTF16_TO_UTF8(netAddressUtf16, &netAddressUtf8);
-                                if (STRNEQ(netAddressUtf8, ""))
-                                    virDomainGraphicsListenSetAddress(def->graphics[def->ngraphics], 0,
-                                                                      netAddressUtf8, -1, true);
-                                VBOX_UTF16_FREE(netAddressUtf16);
-                                VBOX_UTF8_FREE(netAddressUtf8);
-                            }
-
-                            VRDxServer->vtbl->GetAllowMultiConnection(VRDxServer, &allowMultiConnection);
-                            if (allowMultiConnection) {
-                                def->graphics[def->ngraphics]->data.rdp.multiUser = true;
-                            }
-
-                            VRDxServer->vtbl->GetReuseSingleConnection(VRDxServer, &reuseSingleConnection);
-                            if (reuseSingleConnection) {
-                                def->graphics[def->ngraphics]->data.rdp.replaceUser = true;
-                            }
-
-                            def->ngraphics++;
-                        } else
-                            virReportOOMError();
-                    }
-                    VBOX_RELEASE(VRDxServer);
-                }
-            }
-
-#if VBOX_API_VERSION < 3001000
-            /* dump IDE hdds if present */
-            VBOX_UTF8_TO_UTF16(hddBus, &hddBusUtf16);
-
-            def->ndisks = 0;
-            machine->vtbl->GetHardDisk(machine, hddBusUtf16, 0, 0,  &hardDiskPM);
-            if (hardDiskPM)
-                def->ndisks++;
-
-            machine->vtbl->GetHardDisk(machine, hddBusUtf16, 0, 1,  &hardDiskPS);
-            if (hardDiskPS)
-                def->ndisks++;
-
-            machine->vtbl->GetHardDisk(machine, hddBusUtf16, 1, 1,  &hardDiskSS);
-            if (hardDiskSS)
-                def->ndisks++;
-
-            VBOX_UTF16_FREE(hddBusUtf16);
-
-            if ((def->ndisks > 0) && (VIR_ALLOC_N(def->disks, def->ndisks) >= 0)) {
-                for (i = 0; i < def->ndisks; i++) {
-                    if ((def->disks[i] = virDomainDiskDefNew())) {
-                        def->disks[i]->device = VIR_DOMAIN_DISK_DEVICE_DISK;
-                        def->disks[i]->bus = VIR_DOMAIN_DISK_BUS_IDE;
-                        virDomainDiskSetType(def->disks[i],
-                                             VIR_STORAGE_TYPE_FILE);
-                    }
-                }
-            }
-
-            if (hardDiskPM) {
-                PRUnichar *hddlocationUtf16 = NULL;
-                char *hddlocation           = NULL;
-                PRUint32 hddType            = HardDiskType_Normal;
-
-                hardDiskPM->vtbl->imedium.GetLocation((IMedium *)hardDiskPM, &hddlocationUtf16);
-                VBOX_UTF16_TO_UTF8(hddlocationUtf16, &hddlocation);
-
-                hardDiskPM->vtbl->GetType(hardDiskPM, &hddType);
-
-                if (hddType == HardDiskType_Immutable)
-                    def->disks[hddNum]->src->readonly = true;
-                ignore_value(virDomainDiskSetSource(def->disks[hddNum],
-                                                    hddlocation));
-                ignore_value(VIR_STRDUP(def->disks[hddNum]->dst, "hda"));
-                hddNum++;
-
-                VBOX_UTF8_FREE(hddlocation);
-                VBOX_UTF16_FREE(hddlocationUtf16);
-                VBOX_MEDIUM_RELEASE(hardDiskPM);
-            }
-
-            if (hardDiskPS) {
-                PRUnichar *hddlocationUtf16 = NULL;
-                char *hddlocation           = NULL;
-                PRUint32 hddType            = HardDiskType_Normal;
-
-                hardDiskPS->vtbl->imedium.GetLocation((IMedium *)hardDiskPS, &hddlocationUtf16);
-                VBOX_UTF16_TO_UTF8(hddlocationUtf16, &hddlocation);
-
-                hardDiskPS->vtbl->GetType(hardDiskPS, &hddType);
-
-                if (hddType == HardDiskType_Immutable)
-                    def->disks[hddNum]->src->readonly = true;
-                ignore_value(virDomainDiskSetSource(def->disks[hddNum],
-                                                    hddlocation));
-                ignore_value(VIR_STRDUP(def->disks[hddNum]->dst, "hdb"));
-                hddNum++;
-
-                VBOX_UTF8_FREE(hddlocation);
-                VBOX_UTF16_FREE(hddlocationUtf16);
-                VBOX_MEDIUM_RELEASE(hardDiskPS);
-            }
-
-            if (hardDiskSS) {
-                PRUnichar *hddlocationUtf16 = NULL;
-                char *hddlocation           = NULL;
-                PRUint32 hddType            = HardDiskType_Normal;
-
-                hardDiskSS->vtbl->imedium.GetLocation((IMedium *)hardDiskSS, &hddlocationUtf16);
-                VBOX_UTF16_TO_UTF8(hddlocationUtf16, &hddlocation);
-
-                hardDiskSS->vtbl->GetType(hardDiskSS, &hddType);
-
-                if (hddType == HardDiskType_Immutable)
-                    def->disks[hddNum]->src->readonly = true;
-                ignore_value(virDomainDiskSetSource(def->disks[hddNum],
-                                                    hddlocation));
-                ignore_value(VIR_STRDUP(def->disks[hddNum]->dst, "hdd"));
-                hddNum++;
-
-                VBOX_UTF8_FREE(hddlocation);
-                VBOX_UTF16_FREE(hddlocationUtf16);
-                VBOX_MEDIUM_RELEASE(hardDiskSS);
-            }
-#else  /* VBOX_API_VERSION >= 3001000 */
-            /* dump IDE hdds if present */
-
-            bool error = false;
-            int diskCount = 0;
-            PRUint32   maxPortPerInst[StorageBus_Floppy + 1] = {};
-            PRUint32   maxSlotPerPort[StorageBus_Floppy + 1] = {};
-            def->ndisks = 0;
-            vboxArrayGet(&mediumAttachments, machine, machine->vtbl->GetMediumAttachments);
-
-            /* get the number of attachments */
-            for (i = 0; i < mediumAttachments.count; i++) {
-                IMediumAttachment *imediumattach = mediumAttachments.items[i];
-                if (imediumattach) {
-                    IMedium *medium = NULL;
-
-                    imediumattach->vtbl->GetMedium(imediumattach, &medium);
-                    if (medium) {
-                        def->ndisks++;
-                        VBOX_RELEASE(medium);
-                    }
-                }
-            }
-
-            /* Allocate mem, if fails return error */
-            if (VIR_ALLOC_N(def->disks, def->ndisks) >= 0) {
-                for (i = 0; i < def->ndisks; i++) {
-                    virDomainDiskDefPtr disk = virDomainDiskDefNew();
-                    if (!disk) {
-                        error = true;
-                        break;
-                    }
-                    def->disks[i] = disk;
-                }
-            } else {
-                error = true;
-            }
-
-            if (!error)
-                error = !vboxGetMaxPortSlotValues(data->vboxObj, maxPortPerInst, maxSlotPerPort);
-
-            /* get the attachment details here */
-            for (i = 0; i < mediumAttachments.count && diskCount < def->ndisks && !error; i++) {
-                IMediumAttachment *imediumattach = mediumAttachments.items[i];
-                IStorageController *storageController = NULL;
-                PRUnichar *storageControllerName = NULL;
-                PRUint32   deviceType     = DeviceType_Null;
-                PRUint32   storageBus     = StorageBus_Null;
-                PRBool     readOnly       = PR_FALSE;
-                IMedium   *medium         = NULL;
-                PRUnichar *mediumLocUtf16 = NULL;
-                char      *mediumLocUtf8  = NULL;
-                PRUint32   deviceInst     = 0;
-                PRInt32    devicePort     = 0;
-                PRInt32    deviceSlot     = 0;
-
-                if (!imediumattach)
-                    continue;
-
-                imediumattach->vtbl->GetMedium(imediumattach, &medium);
-                if (!medium)
-                    continue;
-
-                imediumattach->vtbl->GetController(imediumattach, &storageControllerName);
-                if (!storageControllerName) {
-                    VBOX_RELEASE(medium);
-                    continue;
-                }
-
-                machine->vtbl->GetStorageControllerByName(machine,
-                                                          storageControllerName,
-                                                          &storageController);
-                VBOX_UTF16_FREE(storageControllerName);
-                if (!storageController) {
-                    VBOX_RELEASE(medium);
-                    continue;
-                }
-
-                medium->vtbl->GetLocation(medium, &mediumLocUtf16);
-                VBOX_UTF16_TO_UTF8(mediumLocUtf16, &mediumLocUtf8);
-                VBOX_UTF16_FREE(mediumLocUtf16);
-                ignore_value(virDomainDiskSetSource(def->disks[diskCount],
-                                                    mediumLocUtf8));
-                VBOX_UTF8_FREE(mediumLocUtf8);
-
-                if (!virDomainDiskGetSource(def->disks[diskCount])) {
-                    VBOX_RELEASE(medium);
-                    VBOX_RELEASE(storageController);
-                    error = true;
-                    break;
-                }
-
-                storageController->vtbl->GetBus(storageController, &storageBus);
-                if (storageBus == StorageBus_IDE) {
-                    def->disks[diskCount]->bus = VIR_DOMAIN_DISK_BUS_IDE;
-                } else if (storageBus == StorageBus_SATA) {
-                    def->disks[diskCount]->bus = VIR_DOMAIN_DISK_BUS_SATA;
-                } else if (storageBus == StorageBus_SCSI) {
-                    def->disks[diskCount]->bus = VIR_DOMAIN_DISK_BUS_SCSI;
-                } else if (storageBus == StorageBus_Floppy) {
-                    def->disks[diskCount]->bus = VIR_DOMAIN_DISK_BUS_FDC;
-                }
-
-                imediumattach->vtbl->GetType(imediumattach, &deviceType);
-                if (deviceType == DeviceType_HardDisk)
-                    def->disks[diskCount]->device = VIR_DOMAIN_DISK_DEVICE_DISK;
-                else if (deviceType == DeviceType_Floppy)
-                    def->disks[diskCount]->device = VIR_DOMAIN_DISK_DEVICE_FLOPPY;
-                else if (deviceType == DeviceType_DVD)
-                    def->disks[diskCount]->device = VIR_DOMAIN_DISK_DEVICE_CDROM;
-
-                imediumattach->vtbl->GetPort(imediumattach, &devicePort);
-                imediumattach->vtbl->GetDevice(imediumattach, &deviceSlot);
-                def->disks[diskCount]->dst = vboxGenerateMediumName(storageBus,
-                                                                    deviceInst,
-                                                                    devicePort,
-                                                                    deviceSlot,
-                                                                    maxPortPerInst,
-                                                                    maxSlotPerPort);
-                if (!def->disks[diskCount]->dst) {
-                    virReportError(VIR_ERR_INTERNAL_ERROR,
-                                   _("Could not generate medium name for the disk "
-                                     "at: controller instance:%u, port:%d, slot:%d"),
-                                   deviceInst, devicePort, deviceSlot);
-                    VBOX_RELEASE(medium);
-                    VBOX_RELEASE(storageController);
-                    error = true;
-                    break;
-                }
-
-                medium->vtbl->GetReadOnly(medium, &readOnly);
-                if (readOnly == PR_TRUE)
-                    def->disks[diskCount]->src->readonly = true;
-
-                virDomainDiskSetType(def->disks[diskCount],
-                                     VIR_STORAGE_TYPE_FILE);
-
-                VBOX_RELEASE(medium);
-                VBOX_RELEASE(storageController);
-                diskCount++;
-            }
-
-            vboxArrayRelease(&mediumAttachments);
-
-            /* cleanup on error */
-            if (error) {
-                for (i = 0; i < def->ndisks; i++) {
-                    VIR_FREE(def->disks[i]);
-                }
-                VIR_FREE(def->disks);
-                def->ndisks = 0;
-            }
-
-#endif /* VBOX_API_VERSION >= 3001000 */
-
-            /* shared folders */
-            vboxArray sharedFolders = VBOX_ARRAY_INITIALIZER;
-
-            def->nfss = 0;
-
-            vboxArrayGet(&sharedFolders, machine,
-                         machine->vtbl->GetSharedFolders);
-
-            if (sharedFolders.count > 0) {
-                if (VIR_ALLOC_N(def->fss, sharedFolders.count) < 0)
-                    goto sharedFoldersCleanup;
-
-                for (i = 0; i < sharedFolders.count; i++) {
-                    ISharedFolder *sharedFolder = sharedFolders.items[i];
-                    PRUnichar *nameUtf16 = NULL;
-                    char *name = NULL;
-                    PRUnichar *hostPathUtf16 = NULL;
-                    char *hostPath = NULL;
-                    PRBool writable = PR_FALSE;
-
-                    if (VIR_ALLOC(def->fss[i]) < 0)
-                        goto sharedFoldersCleanup;
-
-                    def->fss[i]->type = VIR_DOMAIN_FS_TYPE_MOUNT;
-
-                    sharedFolder->vtbl->GetHostPath(sharedFolder, &hostPathUtf16);
-                    VBOX_UTF16_TO_UTF8(hostPathUtf16, &hostPath);
-                    if (VIR_STRDUP(def->fss[i]->src, hostPath) < 0) {
-                        VBOX_UTF8_FREE(hostPath);
-                        VBOX_UTF16_FREE(hostPathUtf16);
-                        goto sharedFoldersCleanup;
-                    }
-                    VBOX_UTF8_FREE(hostPath);
-                    VBOX_UTF16_FREE(hostPathUtf16);
-
-                    sharedFolder->vtbl->GetName(sharedFolder, &nameUtf16);
-                    VBOX_UTF16_TO_UTF8(nameUtf16, &name);
-                    if (VIR_STRDUP(def->fss[i]->dst, name) < 0) {
-                        VBOX_UTF8_FREE(name);
-                        VBOX_UTF16_FREE(nameUtf16);
-                        goto sharedFoldersCleanup;
-                    }
-                    VBOX_UTF8_FREE(name);
-                    VBOX_UTF16_FREE(nameUtf16);
-
-                    sharedFolder->vtbl->GetWritable(sharedFolder, &writable);
-                    def->fss[i]->readonly = !writable;
-
-                    ++def->nfss;
-                }
-            }
-
- sharedFoldersCleanup:
-            vboxArrayRelease(&sharedFolders);
-
-            /* dump network cards if present */
-            def->nnets = 0;
-            /* Get which network cards are enabled */
-            for (i = 0; i < netAdpCnt; i++) {
-                INetworkAdapter *adapter = NULL;
-
-                machine->vtbl->GetNetworkAdapter(machine, i, &adapter);
-                if (adapter) {
-                    PRBool enabled = PR_FALSE;
-
-                    adapter->vtbl->GetEnabled(adapter, &enabled);
-                    if (enabled) {
-                        def->nnets++;
-                    }
-
-                    VBOX_RELEASE(adapter);
-                }
-            }
-
-            /* Allocate memory for the networkcards which are enabled */
-            if ((def->nnets > 0) && (VIR_ALLOC_N(def->nets, def->nnets) >= 0)) {
-                for (i = 0; i < def->nnets; i++) {
-                    ignore_value(VIR_ALLOC(def->nets[i]));
-                }
-            }
-
-            /* Now get the details about the network cards here */
-            for (i = 0; netAdpIncCnt < def->nnets && i < netAdpCnt; i++) {
-                INetworkAdapter *adapter = NULL;
-
-                machine->vtbl->GetNetworkAdapter(machine, i, &adapter);
-                if (adapter) {
-                    PRBool enabled = PR_FALSE;
-
-                    adapter->vtbl->GetEnabled(adapter, &enabled);
-                    if (enabled) {
-                        PRUint32 attachmentType    = NetworkAttachmentType_Null;
-                        PRUint32 adapterType       = NetworkAdapterType_Null;
-                        PRUnichar *MACAddressUtf16 = NULL;
-                        char *MACAddress           = NULL;
-                        char macaddr[VIR_MAC_STRING_BUFLEN] = {0};
-
-                        adapter->vtbl->GetAttachmentType(adapter, &attachmentType);
-                        if (attachmentType == NetworkAttachmentType_NAT) {
-
-                            def->nets[netAdpIncCnt]->type = VIR_DOMAIN_NET_TYPE_USER;
-
-                        } else if (attachmentType == NetworkAttachmentType_Bridged) {
-                            PRUnichar *hostIntUtf16 = NULL;
-                            char *hostInt           = NULL;
-
-                            def->nets[netAdpIncCnt]->type = VIR_DOMAIN_NET_TYPE_BRIDGE;
-
-#if VBOX_API_VERSION < 4001000
-                            adapter->vtbl->GetHostInterface(adapter, &hostIntUtf16);
-#else /* VBOX_API_VERSION >= 4001000 */
-                            adapter->vtbl->GetBridgedInterface(adapter, &hostIntUtf16);
-#endif /* VBOX_API_VERSION >= 4001000 */
-
-                            VBOX_UTF16_TO_UTF8(hostIntUtf16, &hostInt);
-                            ignore_value(VIR_STRDUP(def->nets[netAdpIncCnt]->data.bridge.brname, hostInt));
-
-                            VBOX_UTF8_FREE(hostInt);
-                            VBOX_UTF16_FREE(hostIntUtf16);
-
-                        } else if (attachmentType == NetworkAttachmentType_Internal) {
-                            PRUnichar *intNetUtf16 = NULL;
-                            char *intNet           = NULL;
-
-                            def->nets[netAdpIncCnt]->type = VIR_DOMAIN_NET_TYPE_INTERNAL;
-
-                            adapter->vtbl->GetInternalNetwork(adapter, &intNetUtf16);
-
-                            VBOX_UTF16_TO_UTF8(intNetUtf16, &intNet);
-                            ignore_value(VIR_STRDUP(def->nets[netAdpIncCnt]->data.internal.name, intNet));
-
-                            VBOX_UTF8_FREE(intNet);
-                            VBOX_UTF16_FREE(intNetUtf16);
-
-                        } else if (attachmentType == NetworkAttachmentType_HostOnly) {
-                            PRUnichar *hostIntUtf16 = NULL;
-                            char *hostInt           = NULL;
-
-                            def->nets[netAdpIncCnt]->type = VIR_DOMAIN_NET_TYPE_NETWORK;
-
-#if VBOX_API_VERSION < 4001000
-                            adapter->vtbl->GetHostInterface(adapter, &hostIntUtf16);
-#else /* VBOX_API_VERSION >= 4001000 */
-                            adapter->vtbl->GetHostOnlyInterface(adapter, &hostIntUtf16);
-#endif /* VBOX_API_VERSION >= 4001000 */
-
-                            VBOX_UTF16_TO_UTF8(hostIntUtf16, &hostInt);
-                            ignore_value(VIR_STRDUP(def->nets[netAdpIncCnt]->data.network.name, hostInt));
-
-                            VBOX_UTF8_FREE(hostInt);
-                            VBOX_UTF16_FREE(hostIntUtf16);
-
-                        } else {
-                            /* default to user type i.e. NAT in VirtualBox if this
-                             * dump is ever used to create a machine.
-                             */
-                            def->nets[netAdpIncCnt]->type = VIR_DOMAIN_NET_TYPE_USER;
-                        }
-
-                        adapter->vtbl->GetAdapterType(adapter, &adapterType);
-                        if (adapterType == NetworkAdapterType_Am79C970A) {
-                            ignore_value(VIR_STRDUP(def->nets[netAdpIncCnt]->model, "Am79C970A"));
-                        } else if (adapterType == NetworkAdapterType_Am79C973) {
-                            ignore_value(VIR_STRDUP(def->nets[netAdpIncCnt]->model, "Am79C973"));
-                        } else if (adapterType == NetworkAdapterType_I82540EM) {
-                            ignore_value(VIR_STRDUP(def->nets[netAdpIncCnt]->model, "82540EM"));
-                        } else if (adapterType == NetworkAdapterType_I82545EM) {
-                            ignore_value(VIR_STRDUP(def->nets[netAdpIncCnt]->model, "82545EM"));
-                        } else if (adapterType == NetworkAdapterType_I82543GC) {
-                            ignore_value(VIR_STRDUP(def->nets[netAdpIncCnt]->model, "82543GC"));
-#if VBOX_API_VERSION >= 3001000
-                        } else if (adapterType == NetworkAdapterType_Virtio) {
-                            ignore_value(VIR_STRDUP(def->nets[netAdpIncCnt]->model, "virtio"));
-#endif /* VBOX_API_VERSION >= 3001000 */
-                        }
-
-                        adapter->vtbl->GetMACAddress(adapter, &MACAddressUtf16);
-                        VBOX_UTF16_TO_UTF8(MACAddressUtf16, &MACAddress);
-                        snprintf(macaddr, VIR_MAC_STRING_BUFLEN,
-                                 "%c%c:%c%c:%c%c:%c%c:%c%c:%c%c",
-                                 MACAddress[0], MACAddress[1], MACAddress[2], MACAddress[3],
-                                 MACAddress[4], MACAddress[5], MACAddress[6], MACAddress[7],
-                                 MACAddress[8], MACAddress[9], MACAddress[10], MACAddress[11]);
-
-                        /* XXX some real error handling here some day ... */
-                        if (virMacAddrParse(macaddr, &def->nets[netAdpIncCnt]->mac) < 0)
-                        {}
-
-                        netAdpIncCnt++;
-
-                        VBOX_UTF16_FREE(MACAddressUtf16);
-                        VBOX_UTF8_FREE(MACAddress);
-                    }
-
-                    VBOX_RELEASE(adapter);
-                }
-            }
-
-            /* dump sound card if active */
-
-            /* Set def->nsounds to one as VirtualBox currently supports
-             * only one sound card
-             */
-
-            machine->vtbl->GetAudioAdapter(machine, &audioAdapter);
-            if (audioAdapter) {
-                PRBool enabled = PR_FALSE;
-
-                audioAdapter->vtbl->GetEnabled(audioAdapter, &enabled);
-                if (enabled) {
-                    PRUint32 audioController = AudioControllerType_AC97;
-
-                    def->nsounds = 1;
-                    if (VIR_ALLOC_N(def->sounds, def->nsounds) >= 0) {
-                        if (VIR_ALLOC(def->sounds[0]) >= 0) {
-                            audioAdapter->vtbl->GetAudioController(audioAdapter, &audioController);
-                            if (audioController == AudioControllerType_SB16) {
-                                def->sounds[0]->model = VIR_DOMAIN_SOUND_MODEL_SB16;
-                            } else if (audioController == AudioControllerType_AC97) {
-                                def->sounds[0]->model = VIR_DOMAIN_SOUND_MODEL_AC97;
-                            }
-                        } else {
-                            VIR_FREE(def->sounds);
-                            def->nsounds = 0;
-                        }
-                    } else {
-                        def->nsounds = 0;
-                    }
-                }
-                VBOX_RELEASE(audioAdapter);
-            }
-
-#if VBOX_API_VERSION < 3001000
-            /* dump CDROM/DVD if the drive is attached and has DVD/CD in it */
-            machine->vtbl->GetDVDDrive(machine, &dvdDrive);
-            if (dvdDrive) {
-                PRUint32 state = DriveState_Null;
-
-                dvdDrive->vtbl->GetState(dvdDrive, &state);
-                if (state == DriveState_ImageMounted) {
-                    IDVDImage *dvdImage = NULL;
-
-                    dvdDrive->vtbl->GetImage(dvdDrive, &dvdImage);
-                    if (dvdImage) {
-                        PRUnichar *locationUtf16 = NULL;
-                        char *location           = NULL;
-
-                        dvdImage->vtbl->imedium.GetLocation((IMedium *)dvdImage, &locationUtf16);
-                        VBOX_UTF16_TO_UTF8(locationUtf16, &location);
-
-                        def->ndisks++;
-                        if (VIR_REALLOC_N(def->disks, def->ndisks) >= 0) {
-                            if ((def->disks[def->ndisks - 1] = virDomainDiskDefNew())) {
-                                def->disks[def->ndisks - 1]->device = VIR_DOMAIN_DISK_DEVICE_CDROM;
-                                def->disks[def->ndisks - 1]->bus = VIR_DOMAIN_DISK_BUS_IDE;
-                                virDomainDiskSetType(def->disks[def->ndisks - 1],
-                                                     VIR_STORAGE_TYPE_FILE);
-                                def->disks[def->ndisks - 1]->src->readonly = true;
-                                ignore_value(virDomainDiskSetSource(def->disks[def->ndisks - 1], location));
-                                ignore_value(VIR_STRDUP(def->disks[def->ndisks - 1]->dst, "hdc"));
-                                def->ndisks--;
-                            } else {
-                                def->ndisks--;
-                            }
-                        } else {
-                            def->ndisks--;
-                        }
-
-                        VBOX_UTF8_FREE(location);
-                        VBOX_UTF16_FREE(locationUtf16);
-                        VBOX_MEDIUM_RELEASE(dvdImage);
-                    }
-                }
-                VBOX_RELEASE(dvdDrive);
-            }
-
-            /* dump Floppy if the drive is attached and has floppy in it */
-            machine->vtbl->GetFloppyDrive(machine, &floppyDrive);
-            if (floppyDrive) {
-                PRBool enabled = PR_FALSE;
-
-                floppyDrive->vtbl->GetEnabled(floppyDrive, &enabled);
-                if (enabled) {
-                    PRUint32 state = DriveState_Null;
-
-                    floppyDrive->vtbl->GetState(floppyDrive, &state);
-                    if (state == DriveState_ImageMounted) {
-                        IFloppyImage *floppyImage = NULL;
-
-                        floppyDrive->vtbl->GetImage(floppyDrive, &floppyImage);
-                        if (floppyImage) {
-                            PRUnichar *locationUtf16 = NULL;
-                            char *location           = NULL;
-
-                            floppyImage->vtbl->imedium.GetLocation((IMedium *)floppyImage, &locationUtf16);
-                            VBOX_UTF16_TO_UTF8(locationUtf16, &location);
-
-                            def->ndisks++;
-                            if (VIR_REALLOC_N(def->disks, def->ndisks) >= 0) {
-                                if ((def->disks[def->ndisks - 1] = virDomainDiskDefNew())) {
-                                    def->disks[def->ndisks - 1]->device = VIR_DOMAIN_DISK_DEVICE_FLOPPY;
-                                    def->disks[def->ndisks - 1]->bus = VIR_DOMAIN_DISK_BUS_FDC;
-                                    virDomainDiskSetType(def->disks[def->ndisks - 1],
-                                                         VIR_STORAGE_TYPE_FILE);
-                                    def->disks[def->ndisks - 1]->src->readonly = false;
-                                    ignore_value(virDomainDiskSetSource(def->disks[def->ndisks - 1], location));
-                                    ignore_value(VIR_STRDUP(def->disks[def->ndisks - 1]->dst, "fda"));
-                                    def->ndisks--;
-                                } else {
-                                    def->ndisks--;
-                                }
-                            } else {
-                                def->ndisks--;
-                            }
-
-                            VBOX_UTF8_FREE(location);
-                            VBOX_UTF16_FREE(locationUtf16);
-                            VBOX_MEDIUM_RELEASE(floppyImage);
-                        }
-                    }
-                }
-
-                VBOX_RELEASE(floppyDrive);
-            }
-#else  /* VBOX_API_VERSION >= 3001000 */
-#endif /* VBOX_API_VERSION >= 3001000 */
-
-            /* dump serial port if active */
-            def->nserials = 0;
-            /* Get which serial ports are enabled/active */
-            for (i = 0; i < serialPortCount; i++) {
-                ISerialPort *serialPort = NULL;
-
-                machine->vtbl->GetSerialPort(machine, i, &serialPort);
-                if (serialPort) {
-                    PRBool enabled = PR_FALSE;
-
-                    serialPort->vtbl->GetEnabled(serialPort, &enabled);
-                    if (enabled) {
-                        def->nserials++;
-                    }
-
-                    VBOX_RELEASE(serialPort);
-                }
-            }
-
-            /* Allocate memory for the serial ports which are enabled */
-            if ((def->nserials > 0) && (VIR_ALLOC_N(def->serials, def->nserials) >= 0)) {
-                for (i = 0; i < def->nserials; i++) {
-                    ignore_value(VIR_ALLOC(def->serials[i]));
-                }
-            }
-
-            /* Now get the details about the serial ports here */
-            for (i = 0;
-                 serialPortIncCount < def->nserials && i < serialPortCount;
-                 i++) {
-                ISerialPort *serialPort = NULL;
-
-                machine->vtbl->GetSerialPort(machine, i, &serialPort);
-                if (serialPort) {
-                    PRBool enabled = PR_FALSE;
-
-                    serialPort->vtbl->GetEnabled(serialPort, &enabled);
-                    if (enabled) {
-                        PRUint32 hostMode    = PortMode_Disconnected;
-                        PRUint32 IOBase      = 0;
-                        PRUint32 IRQ         = 0;
-                        PRUnichar *pathUtf16 = NULL;
-                        char *path           = NULL;
-
-                        serialPort->vtbl->GetHostMode(serialPort, &hostMode);
-                        if (hostMode == PortMode_HostPipe) {
-                            def->serials[serialPortIncCount]->source.type = VIR_DOMAIN_CHR_TYPE_PIPE;
-                        } else if (hostMode == PortMode_HostDevice) {
-                            def->serials[serialPortIncCount]->source.type = VIR_DOMAIN_CHR_TYPE_DEV;
-#if VBOX_API_VERSION >= 3000000
-                        } else if (hostMode == PortMode_RawFile) {
-                            def->serials[serialPortIncCount]->source.type = VIR_DOMAIN_CHR_TYPE_FILE;
-#endif /* VBOX_API_VERSION >= 3000000 */
-                        } else {
-                            def->serials[serialPortIncCount]->source.type = VIR_DOMAIN_CHR_TYPE_NULL;
-                        }
-
-                        def->serials[serialPortIncCount]->deviceType = VIR_DOMAIN_CHR_DEVICE_TYPE_SERIAL;
-
-                        serialPort->vtbl->GetIRQ(serialPort, &IRQ);
-                        serialPort->vtbl->GetIOBase(serialPort, &IOBase);
-                        if ((IRQ == 4) && (IOBase == 1016)) {
-                            def->serials[serialPortIncCount]->target.port = 0;
-                        } else if ((IRQ == 3) && (IOBase == 760)) {
-                            def->serials[serialPortIncCount]->target.port = 1;
-                        }
-
-                        serialPort->vtbl->GetPath(serialPort, &pathUtf16);
-
-                        if (pathUtf16) {
-                            VBOX_UTF16_TO_UTF8(pathUtf16, &path);
-                            ignore_value(VIR_STRDUP(def->serials[serialPortIncCount]->source.data.file.path, path));
-                        }
-
-                        serialPortIncCount++;
-
-                        VBOX_UTF16_FREE(pathUtf16);
-                        VBOX_UTF8_FREE(path);
-                    }
-
-                    VBOX_RELEASE(serialPort);
-                }
-            }
-
-            /* dump parallel ports if active */
-            def->nparallels = 0;
-            /* Get which parallel ports are enabled/active */
-            for (i = 0; i < parallelPortCount; i++) {
-                IParallelPort *parallelPort = NULL;
-
-                machine->vtbl->GetParallelPort(machine, i, &parallelPort);
-                if (parallelPort) {
-                    PRBool enabled = PR_FALSE;
-
-                    parallelPort->vtbl->GetEnabled(parallelPort, &enabled);
-                    if (enabled) {
-                        def->nparallels++;
-                    }
-
-                    VBOX_RELEASE(parallelPort);
-                }
-            }
-
-            /* Allocate memory for the parallel ports which are enabled */
-            if ((def->nparallels > 0) && (VIR_ALLOC_N(def->parallels, def->nparallels) >= 0)) {
-                for (i = 0; i < def->nparallels; i++) {
-                    ignore_value(VIR_ALLOC(def->parallels[i]));
-                }
-            }
-
-            /* Now get the details about the parallel ports here */
-            for (i = 0;
-                 parallelPortIncCount < def->nparallels &&
-                     i < parallelPortCount;
-                 i++) {
-                IParallelPort *parallelPort = NULL;
-
-                machine->vtbl->GetParallelPort(machine, i, &parallelPort);
-                if (parallelPort) {
-                    PRBool enabled = PR_FALSE;
-
-                    parallelPort->vtbl->GetEnabled(parallelPort, &enabled);
-                    if (enabled) {
-                        PRUint32 IOBase      = 0;
-                        PRUint32 IRQ         = 0;
-                        PRUnichar *pathUtf16 = NULL;
-                        char *path           = NULL;
-
-                        parallelPort->vtbl->GetIRQ(parallelPort, &IRQ);
-                        parallelPort->vtbl->GetIOBase(parallelPort, &IOBase);
-                        if ((IRQ == 7) && (IOBase == 888)) {
-                            def->parallels[parallelPortIncCount]->target.port = 0;
-                        } else if ((IRQ == 5) && (IOBase == 632)) {
-                            def->parallels[parallelPortIncCount]->target.port = 1;
-                        }
-
-                        def->parallels[parallelPortIncCount]->source.type = VIR_DOMAIN_CHR_TYPE_FILE;
-                        def->parallels[parallelPortIncCount]->deviceType = VIR_DOMAIN_CHR_DEVICE_TYPE_PARALLEL;
-
-                        parallelPort->vtbl->GetPath(parallelPort, &pathUtf16);
-
-                        VBOX_UTF16_TO_UTF8(pathUtf16, &path);
-                        ignore_value(VIR_STRDUP(def->parallels[parallelPortIncCount]->source.data.file.path, path));
-
-                        parallelPortIncCount++;
-
-                        VBOX_UTF16_FREE(pathUtf16);
-                        VBOX_UTF8_FREE(path);
-                    }
-
-                    VBOX_RELEASE(parallelPort);
-                }
-            }
-
-            /* dump USB devices/filters if active */
-            vboxHostDeviceGetXMLDesc(data, def, machine);
-
-            /* all done so set gotAllABoutDef and pass def to virDomainDefFormat
-             * to generate XML for it
-             */
-            gotAllABoutDef = 0;
-        }
-        VBOX_RELEASE(machine);
-        machine = NULL;
-    }
-
-    if (gotAllABoutDef == 0)
-        ret = virDomainDefFormat(def, flags);
-
- cleanup:
-    vboxIIDUnalloc(&iid);
-    virDomainDefFree(def);
-    return ret;
-}
-
 static int vboxConnectListDefinedDomains(virConnectPtr conn, char ** const names, int maxnames) {
     VBOX_OBJECT_CHECK(conn, int, -1);
     vboxArray machines = VBOX_ARRAY_INITIALIZER;
diff --git a/src/vbox/vbox_uniformed_api.h b/src/vbox/vbox_uniformed_api.h
index f72d03f..518dd2a 100644
--- a/src/vbox/vbox_uniformed_api.h
+++ b/src/vbox/vbox_uniformed_api.h
@@ -516,6 +516,7 @@ int vboxDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus,
 int vboxDomainSetVcpus(virDomainPtr dom, unsigned int nvcpus);
 int vboxDomainGetVcpusFlags(virDomainPtr dom, unsigned int flags);
 int vboxDomainGetMaxVcpus(virDomainPtr dom);
+char *vboxDomainGetXMLDesc(virDomainPtr dom, unsigned int flags);
 
 /* Version specified functions for installing uniformed API */
 void vbox22InstallUniformedAPI(vboxUniformedAPI *pVBoxAPI);
-- 
1.7.9.5


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]