vbox: Handle different array representations of XPCOM and MSCOM

Add a vboxArray to hide the details from the general driver code.

diff --git a/src/vbox/vbox_MSCOMGlue.c b/src/vbox/vbox_MSCOMGlue.c
index b1663b1b459e904688f2e6348a2e2dd850600c7d..cf68d384be039a137a6ffa86756263d9dcddf961 100644 (file)
--- a/src/vbox/vbox_MSCOMGlue.c
+++ b/src/vbox/vbox_MSCOMGlue.c
@@ -646,3 +646,110 @@ void
 VBoxCGlueTerm(void)
 {
 }
+
+
+
+/*
+ * In MSCOM an array is represented by a SAFEARRAY pointer. To access the items
+ * in the array the SafeArrayAccessData function is used to lock the array and
+ * get its contents. When the items aren't needed anymore the
+ * SafeArrayUnaccessData function is used to unlock the array. The pointer
+ * retuned by SafeArrayAccessData function becomes invalid. Finally the
+ * SafeArrayDestroy function is called to destroy the array, it also releases
+ * or frees all items in the array according to their type.
+ */
+
+typedef HRESULT __stdcall (*SafeArrayGetter)(void *self, SAFEARRAY **array);
+typedef HRESULT __stdcall (*SafeArrayGetterWithArg)(void *self, void *arg, SAFEARRAY **array);
+
+/*
+ * Call the getter with self as first argument and fill the array with the
+ * returned items.
+ */
+nsresult
+vboxArrayGet(vboxArray *array, void *self, void *getter)
+{
+    HRESULT hrc;
+    SAFEARRAY *safeArray = NULL;
+    void **items = NULL;
+
+    array->items = NULL;
+    array->count = 0;
+    array->handle = NULL;
+
+    hrc = ((SafeArrayGetter)getter)(self, &safeArray);
+
+    if (FAILED(hrc)) {
+        return hrc;
+    }
+
+    hrc = SafeArrayAccessData(safeArray, (void **)&items);
+
+    if (FAILED(hrc)) {
+        SafeArrayDestroy(safeArray);
+        return hrc;
+    }
+
+    array->items = items;
+    array->count = safeArray->rgsabound[0].cElements;
+    array->handle = safeArray;
+
+    return hrc;
+}
+
+/*
+ * Call the getter with self as first argument and arg as second argument
+ * and fill the array with the returned items.
+ */
+nsresult
+vboxArrayGetWithArg(vboxArray *array, void *self, void *getter, void *arg)
+{
+    HRESULT hrc;
+    SAFEARRAY *safeArray = NULL;
+    void **items = NULL;
+
+    array->items = NULL;
+    array->count = 0;
+    array->handle = NULL;
+
+    hrc = ((SafeArrayGetterWithArg)getter)(self, arg, &safeArray);
+
+    if (FAILED(hrc)) {
+        return hrc;
+    }
+
+    hrc = SafeArrayAccessData(safeArray, (void **)&items);
+
+    if (FAILED(hrc)) {
+        SafeArrayDestroy(safeArray);
+        return hrc;
+    }
+
+    array->items = items;
+    array->count = safeArray->rgsabound[0].cElements;
+    array->handle = safeArray;
+
+    return hrc;
+}
+
+/*
+ * Release all items in the array and reset it.
+ *
+ * SafeArrayDestroy is aware of the item's type and calls release or free
+ * for each item according to its type. Therefore, vboxArrayUnalloc and
+ * vboxArrayRelease are the same for MSCOM.
+ */
+void
+vboxArrayRelease(vboxArray *array)
+{
+    if (array->handle == NULL) {
+        return;
+    }
+
+    SafeArrayUnaccessData(array->handle);
+    SafeArrayDestroy(array->handle);
+
+    array->items = NULL;
+    array->count = 0;
+    array->handle = NULL;
+}

diff --git a/src/vbox/vbox_MSCOMGlue.h b/src/vbox/vbox_MSCOMGlue.h
index 1d91f09f814d70ce177d1fa053d20feab38b3578..f1d6c74b614c59b0321c018a3d753fdc9edd6eb5 100644 (file)
--- a/src/vbox/vbox_MSCOMGlue.h
+++ b/src/vbox/vbox_MSCOMGlue.h
@@ -30,4 +30,19 @@ extern PFNVBOXGETXPCOMCFUNCTIONS g_pfnGetFunctions;
 int VBoxCGlueInit(unsigned int *version);
 void VBoxCGlueTerm(void);
 
+typedef struct _vboxArray vboxArray;
+
+struct _vboxArray {
+    void **items;
+    size_t count;
+    void *handle;
+};
+
+# define VBOX_ARRAY_INITIALIZER { NULL, 0, NULL }
+
+nsresult vboxArrayGet(vboxArray *array, void *self, void *getter);
+nsresult vboxArrayGetWithArg(vboxArray *array, void *self, void *getter, void *arg);
+void vboxArrayRelease(vboxArray *array);
+# define vboxArrayUnalloc vboxArrayRelease
+
 #endif /* __VBOX_MSCOMGLUE_H__ */

diff --git a/src/vbox/vbox_XPCOMCGlue.c b/src/vbox/vbox_XPCOMCGlue.c
index 03e66bc2e7fe4e7141789e3d34df020216be82d1..5992350104e87b712da65f05c68f7d0924f853d4 100644 (file)
--- a/src/vbox/vbox_XPCOMCGlue.c
+++ b/src/vbox/vbox_XPCOMCGlue.c
@@ -253,3 +253,118 @@ VBoxCGlueTerm(void)
     pVBoxFuncs_v2_2 = NULL;
     g_pfnGetFunctions = NULL;
 }
+
+
+
+/*
+ * In XPCOM an array is represented by 1) a pointer to an array of pointers
+ * that point to the items and 2) an unsigned int representing the number of
+ * items in the array. When the items aren't needed anymore they are released
+ * or freed according to their type.
+ */
+
+typedef nsresult (*ArrayGetter)(void *self, PRUint32 *count, void ***items);
+typedef nsresult (*ArrayGetterWithArg)(void *self, void *arg, PRUint32 *count, void ***items);
+
+/*
+ * Call the getter with self as first argument and fill the array with the
+ * returned items.
+ */
+nsresult
+vboxArrayGet(vboxArray *array, void *self, void *getter)
+{
+    nsresult nsrc;
+    void **items = NULL;
+    PRUint32 count = 0;
+
+    array->items = NULL;
+    array->count = 0;
+
+    nsrc = ((ArrayGetter)getter)(self, &count, &items);
+
+    if (NS_FAILED(nsrc)) {
+        return nsrc;
+    }
+
+    array->items = items;
+    array->count = count;
+
+    return nsrc;
+}
+
+/*
+ * Call the getter with self as first argument and arg as second argument
+ * and fill the array with the returned items.
+ */
+nsresult
+vboxArrayGetWithArg(vboxArray *array, void *self, void *getter, void *arg)
+{
+    nsresult nsrc;
+    void **items = NULL;
+    PRUint32 count = 0;
+
+    array->items = NULL;
+    array->count = 0;
+
+    nsrc = ((ArrayGetterWithArg)getter)(self, arg, &count, &items);
+
+    if (NS_FAILED(nsrc)) {
+        return nsrc;
+    }
+
+    array->items = items;
+    array->count = count;
+
+    return nsrc;
+}
+
+/*
+ * Release all items in the array and reset it.
+ */
+void
+vboxArrayRelease(vboxArray *array)
+{
+    int i;
+    nsISupports *supports;
+
+    if (array->items == NULL) {
+        return;
+    }
+
+    for (i = 0; i < array->count; ++i) {
+        supports = array->items[i];
+
+        if (supports != NULL) {
+            supports->vtbl->Release(supports);
+        }
+    }
+
+    array->items = NULL;
+    array->count = 0;
+}
+
+
+/*
+ * Unalloc all items in the array and reset it.
+ */
+void
+vboxArrayUnalloc(vboxArray *array)
+{
+    int i;
+    void *item;
+
+    if (array->items == NULL) {
+        return;
+    }
+
+    for (i = 0; i < array->count; ++i) {
+        item = array->items[i];
+
+        if (item != NULL) {
+            pVBoxFuncs_v2_2->pfnComUnallocMem(item);
+        }
+    }
+
+    array->items = NULL;
+    array->count = 0;
+}

diff --git a/src/vbox/vbox_XPCOMCGlue.h b/src/vbox/vbox_XPCOMCGlue.h
index 1fa873a26aea976e611b2cccd26ac27ac0a1e934..8fd2f130247d4a40a13a375855cd0f84c4303ff7 100644 (file)
--- a/src/vbox/vbox_XPCOMCGlue.h
+++ b/src/vbox/vbox_XPCOMCGlue.h
@@ -38,4 +38,18 @@ extern PFNVBOXGETXPCOMCFUNCTIONS g_pfnGetFunctions;
 int VBoxCGlueInit(unsigned int *version);
 void VBoxCGlueTerm(void);
 
+typedef struct _vboxArray vboxArray;
+
+struct _vboxArray {
+    void **items;
+    size_t count;
+};
+
+# define VBOX_ARRAY_INITIALIZER { NULL, 0 }
+
+nsresult vboxArrayGet(vboxArray *array, void *self, void *getter);
+nsresult vboxArrayGetWithArg(vboxArray *array, void *self, void *getter, void *arg);
+void vboxArrayRelease(vboxArray *array);
+void vboxArrayUnalloc(vboxArray *array);
+
 #endif

diff --git a/src/vbox/vbox_tmpl.c b/src/vbox/vbox_tmpl.c
index 6a4589c87d45dd11bdfad317955decf6a35b0802..c283609343aead6d65912df04de7fc1433c044df 100644 (file)
--- a/src/vbox/vbox_tmpl.c
+++ b/src/vbox/vbox_tmpl.c
@@ -77,6 +77,8 @@
 #define VBOX_UTF16_TO_UTF8(arg1, arg2)  data->pFuncs->pfnUtf16ToUtf8(arg1, arg2)
 #define VBOX_UTF8_TO_UTF16(arg1, arg2)  data->pFuncs->pfnUtf8ToUtf16(arg1, arg2)
 
+#define VBOX_ADDREF(arg) (arg)->vtbl->nsisupports.AddRef((nsISupports *)(arg))
+
 #define VBOX_RELEASE(arg) \
 if(arg)\
     (arg)->vtbl->nsisupports.Release((nsISupports *)(arg))
@@ -942,26 +944,21 @@ static char *vboxGetCapabilities(virConnectPtr conn) {
 
 static int vboxListDomains(virConnectPtr conn, int *ids, int nids) {
     VBOX_OBJECT_CHECK(conn, int, -1);
-    IMachine **machines  = NULL;
-    PRUint32 machineCnt  = 0;
+    vboxArray machines = VBOX_ARRAY_INITIALIZER;
     PRUint32 state;
     nsresult rc;
     int i, j;
 
-    rc = data->vboxObj->vtbl->GetMachines(data->vboxObj, &machineCnt, &machines);
+    rc = vboxArrayGet(&machines, data->vboxObj, data->vboxObj->vtbl->GetMachines);
     if (NS_FAILED(rc)) {
         vboxError(VIR_ERR_INTERNAL_ERROR,
                   _("Could not get list of Domains, rc=%08x"),(unsigned)rc);
         goto cleanup;
     }
 
-    if (machineCnt == 0) {
-        ret = 0;
-        goto cleanup;
-    }
-
-    for (i = 0,j = 0; (i < machineCnt) && (j < nids); ++i) {
-        IMachine *machine = machines[i];
+    ret = 0;
+    for (i = 0, j = 0; (i < machines.count) && (j < nids); ++i) {
+        IMachine *machine = machines.items[i];
 
         if (machine) {
             PRBool isAccessible = PR_FALSE;
@@ -976,37 +973,29 @@ static int vboxListDomains(virConnectPtr conn, int *ids, int nids) {
             }
         }
     }
-    ret++;
 
 cleanup:
-    for (i = 0; i < machineCnt; ++i)
-        VBOX_RELEASE(machines[i]);
+    vboxArrayRelease(&machines);
     return ret;
 }
 
 static int vboxNumOfDomains(virConnectPtr conn) {
     VBOX_OBJECT_CHECK(conn, int, -1);
-    IMachine **machines  = NULL;
-    PRUint32 machineCnt  = 0;
+    vboxArray machines = VBOX_ARRAY_INITIALIZER;
     PRUint32 state;
     nsresult rc;
     int i;
 
-    rc = data->vboxObj->vtbl->GetMachines(data->vboxObj, &machineCnt, &machines);
+    rc = vboxArrayGet(&machines, data->vboxObj, data->vboxObj->vtbl->GetMachines);
     if (NS_FAILED(rc)) {
         vboxError(VIR_ERR_INTERNAL_ERROR,
                   _("Could not get number of Domains, rc=%08x"), (unsigned)rc);
         goto cleanup;
     }
 
-    if (machineCnt == 0) {
-        ret = 0;
-        goto cleanup;
-    }
-
-    /* Do the cleanup as required by GetMachines() */
-    for (i = 0; i < machineCnt; ++i) {
-        IMachine *machine = machines[i];
+    ret = 0;
+    for (i = 0; i < machines.count; ++i) {
+        IMachine *machine = machines.items[i];
 
         if (machine) {
             PRBool isAccessible = PR_FALSE;
@@ -1019,11 +1008,9 @@ static int vboxNumOfDomains(virConnectPtr conn) {
             }
         }
     }
-    ret++;
 
 cleanup:
-    for (i = 0; i < machineCnt; ++i)
-        VBOX_RELEASE(machines[i]);
+    vboxArrayRelease(&machines);
     return ret;
 }
 
@@ -1056,13 +1043,11 @@ static virDomainPtr vboxDomainCreateXML(virConnectPtr conn, const char *xml,
 
 static virDomainPtr vboxDomainLookupByID(virConnectPtr conn, int id) {
     VBOX_OBJECT_CHECK(conn, virDomainPtr, NULL);
-    IMachine **machines  = NULL;
-    PRUint32 machineCnt  = 0;
+    vboxArray machines = VBOX_ARRAY_INITIALIZER;
     vboxIID *iid         = NULL;
     unsigned char iidl[VIR_UUID_BUFLEN];
     PRUint32 state;
     nsresult rc;
-    int i;
 
     /* Internal vbox IDs start from 0, the public libvirt ID
      * starts from 1, so refuse id==0, and adjust the rest*/
@@ -1073,28 +1058,30 @@ static virDomainPtr vboxDomainLookupByID(virConnectPtr conn, int id) {
     }
     id = id - 1;
 
-    rc = data->vboxObj->vtbl->GetMachines(data->vboxObj, &machineCnt, &machines);
+    rc = vboxArrayGet(&machines, data->vboxObj, data->vboxObj->vtbl->GetMachines);
     if (NS_FAILED(rc)) {
         vboxError(VIR_ERR_INTERNAL_ERROR,
                   _("Could not get list of machines, rc=%08x"), (unsigned)rc);
         return NULL;
     }
 
-    if (id < machineCnt) {
-        if (machines[id]) {
+    if (id < machines.count) {
+        IMachine *machine = machines.items[id];
+
+        if (machine) {
             PRBool isAccessible = PR_FALSE;
-            machines[id]->vtbl->GetAccessible(machines[id], &isAccessible);
+            machine->vtbl->GetAccessible(machine, &isAccessible);
             if (isAccessible) {
-                machines[id]->vtbl->GetState(machines[id], &state);
+                machine->vtbl->GetState(machine, &state);
                 if (   (state >= MachineState_FirstOnline)
                     && (state <= MachineState_LastOnline) ) {
                     PRUnichar *machineNameUtf16 = NULL;
                     char      *machineNameUtf8  = NULL;
 
-                    machines[id]->vtbl->GetName(machines[id], &machineNameUtf16);
+                    machine->vtbl->GetName(machine, &machineNameUtf16);
                     VBOX_UTF16_TO_UTF8(machineNameUtf16, &machineNameUtf8);
 
-                    machines[id]->vtbl->GetId(machines[id], &iid);
+                    machine->vtbl->GetId(machine, &iid);
                     vboxIIDToUUID(iidl, iid);
                     vboxIIDUnalloc(iid);
 
@@ -1116,17 +1103,14 @@ static virDomainPtr vboxDomainLookupByID(virConnectPtr conn, int id) {
         }
     }
 
-    /* Do the cleanup as required by GetMachines() */
-    for (i = 0; i < machineCnt; ++i)
-        VBOX_RELEASE(machines[i]);
+    vboxArrayRelease(&machines);
 
     return ret;
 }
 
 static virDomainPtr vboxDomainLookupByUUID(virConnectPtr conn, const unsigned char *uuid) {
     VBOX_OBJECT_CHECK(conn, virDomainPtr, NULL);
-    IMachine **machines  = NULL;
-    PRUint32 machineCnt  = 0;
+    vboxArray machines = VBOX_ARRAY_INITIALIZER;
     vboxIID *iid         = NULL;
     char      *machineNameUtf8  = NULL;
     PRUnichar *machineNameUtf16 = NULL;
@@ -1134,15 +1118,15 @@ static virDomainPtr vboxDomainLookupByUUID(virConnectPtr conn, const unsigned ch
     int i, matched = 0;
     nsresult rc;
 
-    rc = data->vboxObj->vtbl->GetMachines(data->vboxObj, &machineCnt, &machines);
+    rc = vboxArrayGet(&machines, data->vboxObj, data->vboxObj->vtbl->GetMachines);
     if (NS_FAILED(rc)) {
         vboxError(VIR_ERR_INTERNAL_ERROR,
                   _("Could not get list of machines, rc=%08x"), (unsigned)rc);
         return NULL;
     }
 
-    for (i = 0; i < machineCnt; ++i) {
-        IMachine *machine = machines[i];
+    for (i = 0; i < machines.count; ++i) {
+        IMachine *machine = machines.items[i];
         PRBool isAccessible = PR_FALSE;
 
         if (!machine)
@@ -1189,16 +1173,14 @@ static virDomainPtr vboxDomainLookupByUUID(virConnectPtr conn, const unsigned ch
     /* Do the cleanup and take care you dont leak any memory */
     VBOX_UTF8_FREE(machineNameUtf8);
     VBOX_COM_UNALLOC_MEM(machineNameUtf16);
-    for (i = 0; i < machineCnt; ++i)
-        VBOX_RELEASE(machines[i]);
+    vboxArrayRelease(&machines);
 
     return ret;
 }
 
 static virDomainPtr vboxDomainLookupByName(virConnectPtr conn, const char *name) {
     VBOX_OBJECT_CHECK(conn, virDomainPtr, NULL);
-    IMachine **machines  = NULL;
-    PRUint32 machineCnt  = 0;
+    vboxArray machines = VBOX_ARRAY_INITIALIZER;
     vboxIID *iid         = NULL;
     char      *machineNameUtf8  = NULL;
     PRUnichar *machineNameUtf16 = NULL;
@@ -1206,15 +1188,15 @@ static virDomainPtr vboxDomainLookupByName(virConnectPtr conn, const char *name)
     int i, matched = 0;
     nsresult rc;
 
-    rc = data->vboxObj->vtbl->GetMachines(data->vboxObj, &machineCnt, &machines);
+    rc = vboxArrayGet(&machines, data->vboxObj, data->vboxObj->vtbl->GetMachines);
     if (NS_FAILED(rc)) {
         vboxError(VIR_ERR_INTERNAL_ERROR,
                   _("Could not get list of machines, rc=%08x"), (unsigned)rc);
         return NULL;
     }
 
-    for (i = 0; i < machineCnt; ++i) {
-        IMachine *machine = machines[i];
+    for (i = 0; i < machines.count; ++i) {
+        IMachine *machine = machines.items[i];
         PRBool isAccessible = PR_FALSE;
 
         if (!machine)
@@ -1264,9 +1246,7 @@ static virDomainPtr vboxDomainLookupByName(virConnectPtr conn, const char *name)
         }
     }
 
-    /* Do the cleanup and take care you dont leak any memory */
-    for (i = 0; i < machineCnt; ++i)
-        VBOX_RELEASE(machines[i]);
+    vboxArrayRelease(&machines);
 
     return ret;
 }
@@ -1274,8 +1254,7 @@ static virDomainPtr vboxDomainLookupByName(virConnectPtr conn, const char *name)
 
 static int vboxDomainIsActive(virDomainPtr dom) {
     VBOX_OBJECT_CHECK(dom->conn, int, -1);
-    IMachine **machines  = NULL;
-    PRUint32 machineCnt  = 0;
+    vboxArray machines = VBOX_ARRAY_INITIALIZER;
     vboxIID *iid         = NULL;
     char      *machineNameUtf8  = NULL;
     PRUnichar *machineNameUtf16 = NULL;
@@ -1283,15 +1262,15 @@ static int vboxDomainIsActive(virDomainPtr dom) {
     int i, matched = 0;
     nsresult rc;
 
-    rc = data->vboxObj->vtbl->GetMachines(data->vboxObj, &machineCnt, &machines);
+    rc = vboxArrayGet(&machines, data->vboxObj, data->vboxObj->vtbl->GetMachines);
     if (NS_FAILED(rc)) {
         vboxError(VIR_ERR_INTERNAL_ERROR,
                   _("Could not get list of machines, rc=%08x"), (unsigned)rc);
         return ret;
     }
 
-    for (i = 0; i < machineCnt; ++i) {
-        IMachine *machine = machines[i];
+    for (i = 0; i < machines.count; ++i) {
+        IMachine *machine = machines.items[i];
         PRBool isAccessible = PR_FALSE;
 
         if (!machine)
@@ -1332,8 +1311,7 @@ static int vboxDomainIsActive(virDomainPtr dom) {
     /* Do the cleanup and take care you dont leak any memory */
     VBOX_UTF8_FREE(machineNameUtf8);
     VBOX_COM_UNALLOC_MEM(machineNameUtf16);
-    for (i = 0; i < machineCnt; ++i)
-        VBOX_RELEASE(machines[i]);
+    vboxArrayRelease(&machines);
 
     return ret;
 }
@@ -1718,14 +1696,13 @@ cleanup:
 
 static int vboxDomainGetInfo(virDomainPtr dom, virDomainInfoPtr info) {
     VBOX_OBJECT_CHECK(dom->conn, int, -1);
-    IMachine **machines  = NULL;
-    PRUint32 machineCnt  = 0;
+    vboxArray machines = VBOX_ARRAY_INITIALIZER;
     char *machineName    = NULL;
     PRUnichar *machineNameUtf16 = NULL;
     nsresult rc;
     int i = 0;
 
-    rc = data->vboxObj->vtbl->GetMachines(data->vboxObj, &machineCnt, &machines);
+    rc = vboxArrayGet(&machines, data->vboxObj, data->vboxObj->vtbl->GetMachines);
     if (NS_FAILED(rc)) {
         vboxError(VIR_ERR_INTERNAL_ERROR,
                   _("Could not get list of machines, rc=%08x"), (unsigned)rc);
@@ -1733,8 +1710,8 @@ static int vboxDomainGetInfo(virDomainPtr dom, virDomainInfoPtr info) {
     }
 
     info->nrVirtCpu = 0;
-    for (i = 0; i < machineCnt; ++i) {
-        IMachine *machine = machines[i];
+    for (i = 0; i < machines.count; ++i) {
+        IMachine *machine = machines.items[i];
         PRBool isAccessible = PR_FALSE;
 
         if (!machine)
@@ -1815,9 +1792,7 @@ static int vboxDomainGetInfo(virDomainPtr dom, virDomainInfoPtr info) {
 
     }
 
-    /* Do the cleanup and take care you dont leak any memory */
-    for (i = 0; i < machineCnt; ++i)
-        VBOX_RELEASE(machines[i]);
+    vboxArrayRelease(&machines);
 
 cleanup:
     return ret;
@@ -2034,8 +2009,7 @@ static char *vboxDomainDumpXML(virDomainPtr dom, int flags) {
             PRUnichar    *hddBusUtf16           = NULL;
             IFloppyDrive *floppyDrive           = NULL;
 #else  /* VBOX_API_VERSION >= 3001 */
-            PRUint32      mediumAttachSize      = 0;
-            IMediumAttachment **mediumAttachments = NULL;
+            vboxArray mediumAttachments         = VBOX_ARRAY_INITIALIZER;
 #endif /* VBOX_API_VERSION >= 3001 */
             IVRDPServer *VRDPServer             = NULL;
             IAudioAdapter *audioAdapter         = NULL;
@@ -2436,11 +2410,11 @@ static char *vboxDomainDumpXML(virDomainPtr dom, int flags) {
             PRUint32   maxPortPerInst[StorageBus_Floppy + 1] = {};
             PRUint32   maxSlotPerPort[StorageBus_Floppy + 1] = {};
             def->ndisks = 0;
-            machine->vtbl->GetMediumAttachments(machine, &mediumAttachSize, &mediumAttachments);
+            vboxArrayGet(&mediumAttachments, machine, machine->vtbl->GetMediumAttachments);
 
             /* get the number of attachments */
-            for (i = 0; i < mediumAttachSize; i++) {
-                IMediumAttachment *imediumattach = mediumAttachments[i];
+            for (i = 0; i < mediumAttachments.count; i++) {
+                IMediumAttachment *imediumattach = mediumAttachments.items[i];
                 if (imediumattach) {
                     IMedium *medium = NULL;
 
@@ -2470,8 +2444,8 @@ static char *vboxDomainDumpXML(virDomainPtr dom, int flags) {
                 error = !vboxGetMaxPortSlotValues(data->vboxObj, maxPortPerInst, maxSlotPerPort);
 
             /* get the attachment details here */
-            for (i = 0; i < mediumAttachSize && diskCount < def->ndisks && !error; i++) {
-                IMediumAttachment *imediumattach = mediumAttachments[i];
+            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;
@@ -2569,9 +2543,7 @@ static char *vboxDomainDumpXML(virDomainPtr dom, int flags) {
                 diskCount++;
             }
 
-            /* free the memory */
-            for (i = 0; i < mediumAttachSize; i++)
-                VBOX_RELEASE(mediumAttachments[i]);
+            vboxArrayRelease(&mediumAttachments);
 
             /* cleanup on error */
             if (error) {
@@ -3013,23 +2985,22 @@ static char *vboxDomainDumpXML(virDomainPtr dom, int flags) {
 
                 USBController->vtbl->GetEnabled(USBController, &enabled);
                 if (enabled) {
-                    PRUint32 deviceFiltersNum        = 0;
-                    IUSBDeviceFilter **deviceFilters = NULL;
+                    vboxArray deviceFilters = VBOX_ARRAY_INITIALIZER;
 
-                    USBController->vtbl->GetDeviceFilters(USBController,
-                                                          &deviceFiltersNum,
-                                                          &deviceFilters);
+                    vboxArrayGet(&deviceFilters, USBController,
+                                 USBController->vtbl->GetDeviceFilters);
 
-                    if (deviceFiltersNum > 0) {
+                    if (deviceFilters.count > 0) {
 
                         /* check if the filters are active and then only
                          * alloc mem and set def->nhostdevs
                          */
 
-                        for(i = 0; i < deviceFiltersNum; i++) {
+                        for(i = 0; i < deviceFilters.count; i++) {
                             PRBool active = PR_FALSE;
+                            IUSBDeviceFilter *deviceFilter = deviceFilters.items[i];
 
-                            deviceFilters[i]->vtbl->GetActive(deviceFilters[i], &active);
+                            deviceFilter->vtbl->GetActive(deviceFilter, &active);
                             if (active) {
                                 def->nhostdevs++;
                             }
@@ -3039,10 +3010,11 @@ static char *vboxDomainDumpXML(virDomainPtr dom, int flags) {
                             /* Alloc mem needed for the filters now */
                             if (VIR_ALLOC_N(def->hostdevs, def->nhostdevs) >= 0) {
 
-                                for(i = 0; (USBFilterCount < def->nhostdevs) || (i < deviceFiltersNum); i++) {
+                                for(i = 0; (USBFilterCount < def->nhostdevs) || (i < deviceFilters.count); i++) {
                                     PRBool active = PR_FALSE;
+                                    IUSBDeviceFilter *deviceFilter = deviceFilters.items[i];
 
-                                    deviceFilters[i]->vtbl->GetActive(deviceFilters[i], &active);
+                                    deviceFilter->vtbl->GetActive(deviceFilter, &active);
                                     if (active) {
                                         if (VIR_ALLOC(def->hostdevs[USBFilterCount]) >= 0) {
                                             PRUnichar *vendorIdUtf16  = NULL;
@@ -3058,8 +3030,8 @@ static char *vboxDomainDumpXML(virDomainPtr dom, int flags) {
                                             def->hostdevs[USBFilterCount]->source.subsys.type =
                                                 VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB;
 
-                                            deviceFilters[i]->vtbl->GetVendorId(deviceFilters[i], &vendorIdUtf16);
-                                            deviceFilters[i]->vtbl->GetProductId(deviceFilters[i], &productIdUtf16);
+                                            deviceFilter->vtbl->GetVendorId(deviceFilter, &vendorIdUtf16);
+                                            deviceFilter->vtbl->GetProductId(deviceFilter, &productIdUtf16);
 
                                             VBOX_UTF16_TO_UTF8(vendorIdUtf16, &vendorIdUtf8);
                                             VBOX_UTF16_TO_UTF8(productIdUtf16, &productIdUtf8);
@@ -3087,8 +3059,7 @@ static char *vboxDomainDumpXML(virDomainPtr dom, int flags) {
                     }
 
                     /* Cleanup */
-                    for(i = 0; i < deviceFiltersNum; i++)
-                        VBOX_RELEASE(deviceFilters[i]);
+                    vboxArrayRelease(&deviceFilters);
                 }
                 VBOX_RELEASE(USBController);
             }
@@ -3113,15 +3084,14 @@ cleanup:
 
 static int vboxListDefinedDomains(virConnectPtr conn, char ** const names, int maxnames) {
     VBOX_OBJECT_CHECK(conn, int, -1);
-    IMachine **machines  = NULL;
-    PRUint32 machineCnt  = 0;
+    vboxArray machines = VBOX_ARRAY_INITIALIZER;
     char *machineName    = NULL;
     PRUnichar *machineNameUtf16 = NULL;
     PRUint32 state;
     nsresult rc;
     int i, j;
 
-    rc = data->vboxObj->vtbl->GetMachines(data->vboxObj, &machineCnt, &machines);
+    rc = vboxArrayGet(&machines, data->vboxObj, data->vboxObj->vtbl->GetMachines);
     if (NS_FAILED(rc)) {
         vboxError(VIR_ERR_INTERNAL_ERROR,
                   _("Could not get list of Defined Domains, rc=%08x"),
@@ -3129,13 +3099,9 @@ static int vboxListDefinedDomains(virConnectPtr conn, char ** const names, int m
         goto cleanup;
     }
 
-    if (machineCnt == 0) {
-        ret = 0;
-        goto cleanup;
-    }
-
-    for (i = 0,j = 0; (i < machineCnt) && (j < maxnames); i++) {
-        IMachine *machine = machines[i];
+    ret = 0;
+    for (i = 0, j = 0; (i < machines.count) && (j < maxnames); i++) {
+        IMachine *machine = machines.items[i];
 
         if (machine) {
             PRBool isAccessible = PR_FALSE;
@@ -3158,25 +3124,22 @@ static int vboxListDefinedDomains(virConnectPtr conn, char ** const names, int m
             }
         }
     }
-    ret++;
 
 cleanup:
     VBOX_UTF8_FREE(machineName);
     VBOX_UTF16_FREE(machineNameUtf16);
-    for (i = 0; i < machineCnt; ++i)
-        VBOX_RELEASE(machines[i]);
+    vboxArrayRelease(&machines);
     return ret;
 }
 
 static int vboxNumOfDefinedDomains(virConnectPtr conn) {
     VBOX_OBJECT_CHECK(conn, int, -1);
-    IMachine **machines  = NULL;
-    PRUint32 machineCnt  = 0;
+    vboxArray machines = VBOX_ARRAY_INITIALIZER;
     PRUint32 state       = MachineState_Null;
     nsresult rc;
     int i;
 
-    rc = data->vboxObj->vtbl->GetMachines(data->vboxObj, &machineCnt, &machines);
+    rc = vboxArrayGet(&machines, data->vboxObj, data->vboxObj->vtbl->GetMachines);
     if (NS_FAILED(rc)) {
         vboxError(VIR_ERR_INTERNAL_ERROR,
                   _("Could not get number of Defined Domains, rc=%08x"),
@@ -3184,14 +3147,9 @@ static int vboxNumOfDefinedDomains(virConnectPtr conn) {
         goto cleanup;
     }
 
-    if (machineCnt == 0) {
-        ret = 0;
-        goto cleanup;
-    }
-
-    /* Do the cleanup as required by GetMachines() */
-    for (i = 0; i < machineCnt; ++i) {
-        IMachine *machine = machines[i];
+    ret = 0;
+    for (i = 0; i < machines.count; ++i) {
+        IMachine *machine = machines.items[i];
 
         if (machine) {
             PRBool isAccessible = PR_FALSE;
@@ -3205,11 +3163,9 @@ static int vboxNumOfDefinedDomains(virConnectPtr conn) {
             }
         }
     }
-    ret++;
 
 cleanup:
-    for (i = 0; i < machineCnt; ++i)
-        VBOX_RELEASE(machines[i]);
+    vboxArrayRelease(&machines);
     return ret;
 }
 
@@ -3387,8 +3343,7 @@ vboxStartMachine(virDomainPtr dom, int i, IMachine *machine, vboxIID *iid)
 
 static int vboxDomainCreateWithFlags(virDomainPtr dom, unsigned int flags) {
     VBOX_OBJECT_CHECK(dom->conn, int, -1);
-    IMachine **machines    = NULL;
-    PRUint32 machineCnt    = 0;
+    vboxArray machines = VBOX_ARRAY_INITIALIZER;
     unsigned char iidl[VIR_UUID_BUFLEN] = {0};
     nsresult rc;
     int i = 0;
@@ -3401,15 +3356,15 @@ static int vboxDomainCreateWithFlags(virDomainPtr dom, unsigned int flags) {
         goto cleanup;
     }
 
-    rc = data->vboxObj->vtbl->GetMachines(data->vboxObj, &machineCnt, &machines);
+    rc = vboxArrayGet(&machines, data->vboxObj, data->vboxObj->vtbl->GetMachines);
     if (NS_FAILED(rc)) {
         vboxError(VIR_ERR_INTERNAL_ERROR,
                   _("Could not get list of machines, rc=%08x"), (unsigned)rc);
         goto cleanup;
     }
 
-    for (i = 0; i < machineCnt; ++i) {
-        IMachine *machine = machines[i];
+    for (i = 0; i < machines.count; ++i) {
+        IMachine *machine = machines.items[i];
         PRBool isAccessible = PR_FALSE;
 
         if (!machine)
@@ -3446,8 +3401,7 @@ static int vboxDomainCreateWithFlags(virDomainPtr dom, unsigned int flags) {
     }
 
     /* Do the cleanup and take care you dont leak any memory */
-    for (i = 0; i < machineCnt; ++i)
-        VBOX_RELEASE(machines[i]);
+    vboxArrayRelease(&machines);
 
 cleanup:
     return ret;
@@ -4795,31 +4749,27 @@ static int vboxDomainUndefine(virDomainPtr dom) {
                 /* get all the controller first, then the attachments and
                  * remove them all so that the machine can be undefined
                  */
-                PRUint32 strCtlSize = 0;
-                IStorageController **aStrCtls = NULL;
+                vboxArray storageControllers = VBOX_ARRAY_INITIALIZER;
                 int i = 0, j = 0;
 
-                machine->vtbl->GetStorageControllers(machine,
-                                                     &strCtlSize,
-                                                     &aStrCtls);
+                vboxArrayGet(&storageControllers, machine,
+                             machine->vtbl->GetStorageControllers);
 
-                for (i = 0; i < strCtlSize; i++) {
-                    IStorageController *strCtl = aStrCtls[i];
+                for (i = 0; i < storageControllers.count; i++) {
+                    IStorageController *strCtl = storageControllers.items[i];
                     PRUnichar *strCtlName = NULL;
-                    PRUint32   medAttSize = 0;
-                    IMediumAttachment **aMedAtts = NULL;
+                    vboxArray mediumAttachments = VBOX_ARRAY_INITIALIZER;
 
                     if (!strCtl)
                         continue;
 
                     strCtl->vtbl->GetName(strCtl, &strCtlName);
-                    machine->vtbl->GetMediumAttachmentsOfController(machine,
-                                                                    strCtlName,
-                                                                    &medAttSize,
-                                                                    &aMedAtts);
+                    vboxArrayGetWithArg(&mediumAttachments, machine,
+                                        machine->vtbl->GetMediumAttachmentsOfController,
+                                        strCtlName);
 
-                    for (j = 0; j < medAttSize; j++) {
-                        IMediumAttachment *medAtt = aMedAtts[j];
+                    for (j = 0; j < mediumAttachments.count; j++) {
+                        IMediumAttachment *medAtt = mediumAttachments.items[j];
                         PRInt32 port = ~0U;
                         PRInt32 device = ~0U;
 
@@ -4835,14 +4785,15 @@ static int vboxDomainUndefine(virDomainPtr dom) {
                                                         port,
                                                         device);
                         }
-
-                        VBOX_RELEASE(medAtt);
                     }
 
-                    VBOX_RELEASE(strCtl);
+                    vboxArrayRelease(&storageControllers);
+
                     machine->vtbl->RemoveStorageController(machine, strCtlName);
                     VBOX_UTF16_FREE(strCtlName);
                 }
+
+                vboxArrayRelease(&storageControllers);
 #endif /* VBOX_API_VERSION >= 3001 */
 
                 machine->vtbl->SaveSettings(machine);
@@ -5288,8 +5239,7 @@ vboxDomainSnapshotGetAll(virDomainPtr dom,
     /* BFS walk through snapshot tree */
     top = 1;
     for (next = 0; next < count; next++) {
-        PRUint32 childrenCount = 0;
-        ISnapshot **children = NULL;
+        vboxArray children = VBOX_ARRAY_INITIALIZER;
         unsigned int i;
 
         if (!list[next]) {
@@ -5298,23 +5248,27 @@ vboxDomainSnapshotGetAll(virDomainPtr dom,
             goto error;
         }
 
-        rc = list[next]->vtbl->GetChildren(list[next], &childrenCount,
-                                           &children);
+        rc = vboxArrayGet(&children, list[next],
+                               list[next]->vtbl->GetChildren);
         if (NS_FAILED(rc)) {
             vboxError(VIR_ERR_INTERNAL_ERROR,
                       "%s", _("could not get children snapshots"));
             goto error;
         }
-        for (i = 0; i < childrenCount; i++) {
-            if (!children[i])
+        for (i = 0; i < children.count; i++) {
+            ISnapshot *child = children.items[i];
+            if (!child)
                 continue;
             if (top == count) {
                 vboxError(VIR_ERR_INTERNAL_ERROR,
                           _("unexpected number of snapshots > %u"), count);
+                vboxArrayRelease(&children);
                 goto error;
             }
-            list[top++] = children[i];
+            VBOX_ADDREF(child);
+            list[top++] = child;
         }
+        vboxArrayRelease(&children);
     }
 
 out:
@@ -6137,31 +6091,27 @@ vboxDomainSnapshotDeleteTree(vboxGlobalData *data,
                              IConsole *console,
                              ISnapshot *snapshot)
 {
-    PRUint32 childrenCount = 0;
-    ISnapshot **children = NULL;
+    vboxArray children = VBOX_ARRAY_INITIALIZER;
     int ret = -1;
     nsresult rc;
     unsigned int i;
 
-    rc = snapshot->vtbl->GetChildren(snapshot, &childrenCount, &children);
+    rc = vboxArrayGet(&children, snapshot, snapshot->vtbl->GetChildren);
     if (NS_FAILED(rc)) {
         vboxError(VIR_ERR_INTERNAL_ERROR, "%s",
                   _("could not get children snapshots"));
         goto cleanup;
     }
 
-    if (childrenCount > 0) {
-        for (i = 0; i < childrenCount; i++) {
-            if (vboxDomainSnapshotDeleteTree(data, console, children[i]))
-                goto cleanup;
-        }
+    for (i = 0; i < children.count; i++) {
+        if (vboxDomainSnapshotDeleteTree(data, console, children.items[i]))
+            goto cleanup;
     }
 
     ret = vboxDomainSnapshotDeleteSingle(data, console, snapshot);
 
 cleanup:
-    for (i = 0; i < childrenCount; i++)
-        VBOX_RELEASE(children[i]);
+    vboxArrayRelease(&children);
     return ret;
 }
 
@@ -6829,30 +6779,31 @@ static int vboxNetworkClose(virConnectPtr conn) {
 
 static int vboxNumOfNetworks(virConnectPtr conn) {
     VBOX_OBJECT_HOST_CHECK(conn, int, 0);
-    PRUint32 networkInterfacesSize = 0;
-    IHostNetworkInterface **networkInterfaces = NULL;
+    vboxArray networkInterfaces = VBOX_ARRAY_INITIALIZER;
     int i = 0;
 
-    host->vtbl->GetNetworkInterfaces(host, &networkInterfacesSize, &networkInterfaces);
+    vboxArrayGet(&networkInterfaces, host, host->vtbl->GetNetworkInterfaces);
 
-    for (i = 0; i < networkInterfacesSize; i++) {
-        if (networkInterfaces[i]) {
+    for (i = 0; i < networkInterfaces.count; i++) {
+        IHostNetworkInterface *networkInterface = networkInterfaces.items[i];
+
+        if (networkInterface) {
             PRUint32 interfaceType = 0;
 
-            networkInterfaces[i]->vtbl->GetInterfaceType(networkInterfaces[i], &interfaceType);
+            networkInterface->vtbl->GetInterfaceType(networkInterface, &interfaceType);
             if (interfaceType == HostNetworkInterfaceType_HostOnly) {
                 PRUint32 status = HostNetworkInterfaceStatus_Unknown;
 
-                networkInterfaces[i]->vtbl->GetStatus(networkInterfaces[i], &status);
+                networkInterface->vtbl->GetStatus(networkInterface, &status);
 
                 if (status == HostNetworkInterfaceStatus_Up)
                     ret++;
             }
-
-            VBOX_RELEASE(networkInterfaces[i]);
         }
     }
 
+    vboxArrayRelease(&networkInterfaces);
+
     VBOX_RELEASE(host);
 
     DEBUG("numActive: %d", ret);
@@ -6861,28 +6812,29 @@ static int vboxNumOfNetworks(virConnectPtr conn) {
 
 static int vboxListNetworks(virConnectPtr conn, char **const names, int nnames) {
     VBOX_OBJECT_HOST_CHECK(conn, int, 0);
-    PRUint32 networkInterfacesSize = 0;
-    IHostNetworkInterface **networkInterfaces = NULL;
+    vboxArray networkInterfaces = VBOX_ARRAY_INITIALIZER;
     int i = 0;
 
-    host->vtbl->GetNetworkInterfaces(host, &networkInterfacesSize, &networkInterfaces);
+    vboxArrayGet(&networkInterfaces, host, host->vtbl->GetNetworkInterfaces);
+
+    for (i = 0; (ret < nnames) && (i < networkInterfaces.count); i++) {
+        IHostNetworkInterface *networkInterface = networkInterfaces.items[i];
 
-    for (i = 0; (ret < nnames) && (i < networkInterfacesSize); i++) {
-        if (networkInterfaces[i]) {
+        if (networkInterface) {
             PRUint32 interfaceType = 0;
 
-            networkInterfaces[i]->vtbl->GetInterfaceType(networkInterfaces[i], &interfaceType);
+            networkInterface->vtbl->GetInterfaceType(networkInterface, &interfaceType);
 
             if (interfaceType == HostNetworkInterfaceType_HostOnly) {
                 PRUint32 status = HostNetworkInterfaceStatus_Unknown;
 
-                networkInterfaces[i]->vtbl->GetStatus(networkInterfaces[i], &status);
+                networkInterface->vtbl->GetStatus(networkInterface, &status);
 
                 if (status == HostNetworkInterfaceStatus_Up) {
                     char *nameUtf8       = NULL;
                     PRUnichar *nameUtf16 = NULL;
 
-                    networkInterfaces[i]->vtbl->GetName(networkInterfaces[i], &nameUtf16);
+                    networkInterface->vtbl->GetName(networkInterface, &nameUtf16);
                     VBOX_UTF16_TO_UTF8(nameUtf16, &nameUtf8);
 
                     DEBUG("nnames[%d]: %s", ret, nameUtf8);
@@ -6900,8 +6852,7 @@ static int vboxListNetworks(virConnectPtr conn, char **const names, int nnames)
         }
     }
 
-    for (i = 0; i < networkInterfacesSize; i++)
-        VBOX_RELEASE(networkInterfaces[i]);
+    vboxArrayRelease(&networkInterfaces);
 
     VBOX_RELEASE(host);
 
@@ -6910,30 +6861,31 @@ static int vboxListNetworks(virConnectPtr conn, char **const names, int nnames)
 
 static int vboxNumOfDefinedNetworks(virConnectPtr conn) {
     VBOX_OBJECT_HOST_CHECK(conn, int, 0);
-    PRUint32 networkInterfacesSize = 0;
-    IHostNetworkInterface **networkInterfaces = NULL;
+    vboxArray networkInterfaces = VBOX_ARRAY_INITIALIZER;
     int i = 0;
 
-    host->vtbl->GetNetworkInterfaces(host, &networkInterfacesSize, &networkInterfaces);
+    vboxArrayGet(&networkInterfaces, host, host->vtbl->GetNetworkInterfaces);
 
-    for (i = 0; i < networkInterfacesSize; i++) {
-        if (networkInterfaces[i]) {
+    for (i = 0; i < networkInterfaces.count; i++) {
+        IHostNetworkInterface *networkInterface = networkInterfaces.items[i];
+
+        if (networkInterface) {
             PRUint32 interfaceType = 0;
 
-            networkInterfaces[i]->vtbl->GetInterfaceType(networkInterfaces[i], &interfaceType);
+            networkInterface->vtbl->GetInterfaceType(networkInterface, &interfaceType);
             if (interfaceType == HostNetworkInterfaceType_HostOnly) {
                 PRUint32 status = HostNetworkInterfaceStatus_Unknown;
 
-                networkInterfaces[i]->vtbl->GetStatus(networkInterfaces[i], &status);
+                networkInterface->vtbl->GetStatus(networkInterface, &status);
 
                 if (status == HostNetworkInterfaceStatus_Down)
                     ret++;
             }
-
-            VBOX_RELEASE(networkInterfaces[i]);
         }
     }
 
+    vboxArrayRelease(&networkInterfaces);
+
     VBOX_RELEASE(host);
 
     DEBUG("numActive: %d", ret);
@@ -6942,28 +6894,29 @@ static int vboxNumOfDefinedNetworks(virConnectPtr conn) {
 
 static int vboxListDefinedNetworks(virConnectPtr conn, char **const names, int nnames) {
     VBOX_OBJECT_HOST_CHECK(conn, int, 0);
-    PRUint32 networkInterfacesSize = 0;
-    IHostNetworkInterface **networkInterfaces = NULL;
+    vboxArray networkInterfaces = VBOX_ARRAY_INITIALIZER;
     int i = 0;
 
-    host->vtbl->GetNetworkInterfaces(host, &networkInterfacesSize, &networkInterfaces);
+    vboxArrayGet(&networkInterfaces, host, host->vtbl->GetNetworkInterfaces);
+
+    for (i = 0; (ret < nnames) && (i < networkInterfaces.count); i++) {
+        IHostNetworkInterface *networkInterface = networkInterfaces.items[i];
 
-    for (i = 0; (ret < nnames) && (i < networkInterfacesSize); i++) {
-        if (networkInterfaces[i]) {
+        if (networkInterface) {
             PRUint32 interfaceType = 0;
 
-            networkInterfaces[i]->vtbl->GetInterfaceType(networkInterfaces[i], &interfaceType);
+            networkInterface->vtbl->GetInterfaceType(networkInterface, &interfaceType);
 
             if (interfaceType == HostNetworkInterfaceType_HostOnly) {
                 PRUint32 status = HostNetworkInterfaceStatus_Unknown;
 
-                networkInterfaces[i]->vtbl->GetStatus(networkInterfaces[i], &status);
+                networkInterface->vtbl->GetStatus(networkInterface, &status);
 
                 if (status == HostNetworkInterfaceStatus_Down) {
                     char *nameUtf8       = NULL;
                     PRUnichar *nameUtf16 = NULL;
 
-                    networkInterfaces[i]->vtbl->GetName(networkInterfaces[i], &nameUtf16);
+                    networkInterface->vtbl->GetName(networkInterface, &nameUtf16);
                     VBOX_UTF16_TO_UTF8(nameUtf16, &nameUtf8);
 
                     DEBUG("nnames[%d]: %s", ret, nameUtf8);
@@ -6981,8 +6934,7 @@ static int vboxListDefinedNetworks(virConnectPtr conn, char **const names, int n
         }
     }
 
-    for (i = 0; i < networkInterfacesSize; i++)
-        VBOX_RELEASE(networkInterfaces[i]);
+    vboxArrayRelease(&networkInterfaces);
 
     VBOX_RELEASE(host);
 
@@ -7667,54 +7619,48 @@ static virStoragePoolPtr vboxStoragePoolLookupByName(virConnectPtr conn, const c
 
 static int vboxStoragePoolNumOfVolumes(virStoragePoolPtr pool) {
     VBOX_OBJECT_CHECK(pool->conn, int, -1);
-    IHardDisk **hardDisks       = NULL;
-    PRUint32 hardDiskCount      = 0;
+    vboxArray hardDisks = VBOX_ARRAY_INITIALIZER;
     PRUint32 hardDiskAccessible = 0;
     nsresult rc;
     int i;
 
-    rc = data->vboxObj->vtbl->GetHardDisks(data->vboxObj, &hardDiskCount, &hardDisks);
+    rc = vboxArrayGet(&hardDisks, data->vboxObj, data->vboxObj->vtbl->GetHardDisks);
     if (NS_SUCCEEDED(rc)) {
-        for (i = 0; i < hardDiskCount; ++i) {
-            IHardDisk *hardDisk = hardDisks[i];
+        for (i = 0; i < hardDisks.count; ++i) {
+            IHardDisk *hardDisk = hardDisks.items[i];
             if (hardDisk) {
                 PRUint32 hddstate;
 
                 VBOX_MEDIUM_FUNC_ARG1(hardDisk, GetState, &hddstate);
                 if (hddstate != MediaState_Inaccessible)
                     hardDiskAccessible++;
-
-                VBOX_MEDIUM_RELEASE(hardDisk);
             }
         }
-        hardDiskCount = 0;
+
+        vboxArrayRelease(&hardDisks);
+
+        ret = hardDiskAccessible;
     } else {
-        hardDiskCount = -1;
+        ret = -1;
         vboxError(VIR_ERR_INTERNAL_ERROR,
                   _("could not get number of volumes in the pool: %s, rc=%08x"),
                   pool->name, (unsigned)rc);
     }
 
-    if (hardDiskAccessible)
-        ret = hardDiskAccessible;
-    else
-        ret = hardDiskCount;
-
     return ret;
 }
 
 static int vboxStoragePoolListVolumes(virStoragePoolPtr pool, char **const names, int nnames) {
     VBOX_OBJECT_CHECK(pool->conn, int, -1);
-    IHardDisk **hardDisks  = NULL;
-    PRUint32 hardDiskCount = 0;
+    vboxArray hardDisks = VBOX_ARRAY_INITIALIZER;
     PRUint32 numActive     = 0;
     nsresult rc;
     int i;
 
-    rc = data->vboxObj->vtbl->GetHardDisks(data->vboxObj, &hardDiskCount, &hardDisks);
+    rc = vboxArrayGet(&hardDisks, data->vboxObj, data->vboxObj->vtbl->GetHardDisks);
     if (NS_SUCCEEDED(rc)) {
-        for (i = 0; i < hardDiskCount && numActive < nnames; ++i) {
-            IHardDisk *hardDisk = hardDisks[i];
+        for (i = 0; i < hardDisks.count && numActive < nnames; ++i) {
+            IHardDisk *hardDisk = hardDisks.items[i];
 
             if (hardDisk) {
                 PRUint32 hddstate;
@@ -7740,39 +7686,35 @@ static int vboxStoragePoolListVolumes(virStoragePoolPtr pool, char **const names
                         VBOX_UTF8_FREE(nameUtf8);
                     }
                 }
-                VBOX_MEDIUM_RELEASE(hardDisk);
             }
         }
-        hardDiskCount = 0;
+
+        vboxArrayRelease(&hardDisks);
+
+        ret = numActive;
     } else {
-        hardDiskCount = -1;
+        ret = -1;
         vboxError(VIR_ERR_INTERNAL_ERROR,
                   _("could not get the volume list in the pool: %s, rc=%08x"),
                   pool->name, (unsigned)rc);
     }
 
-    if (numActive)
-        ret = numActive;
-    else
-        ret = hardDiskCount;
-
     return ret;
 }
 
 static virStorageVolPtr vboxStorageVolLookupByName(virStoragePoolPtr pool, const char *name) {
     VBOX_OBJECT_CHECK(pool->conn, virStorageVolPtr, NULL);
-    IHardDisk **hardDisks        = NULL;
-    PRUint32 hardDiskCount       = 0;
+    vboxArray hardDisks = VBOX_ARRAY_INITIALIZER;
     nsresult rc;
     int i;
 
     if(!name)
         return ret;
 
-    rc = data->vboxObj->vtbl->GetHardDisks(data->vboxObj, &hardDiskCount, &hardDisks);
+    rc = vboxArrayGet(&hardDisks, data->vboxObj, data->vboxObj->vtbl->GetHardDisks);
     if (NS_SUCCEEDED(rc)) {
-        for (i = 0; i < hardDiskCount; ++i) {
-            IHardDisk *hardDisk = hardDisks[i];
+        for (i = 0; i < hardDisks.count; ++i) {
+            IHardDisk *hardDisk = hardDisks.items[i];
 
             if (hardDisk) {
                 PRUint32 hddstate;
@@ -7821,8 +7763,7 @@ static virStorageVolPtr vboxStorageVolLookupByName(virStoragePoolPtr pool, const
             }
         }
 
-        for (i = 0; i < hardDiskCount; ++i)
-            VBOX_MEDIUM_RELEASE(hardDisks[i]);
+        vboxArrayRelease(&hardDisks);
     }
 
     return ret;
@@ -8081,28 +8022,36 @@ static int vboxStorageVolDelete(virStorageVolPtr vol,
         VBOX_MEDIUM_FUNC_ARG1(hardDisk, GetState, &hddstate);
         if (hddstate != MediaState_Inaccessible) {
             PRUint32  machineIdsSize = 0;
-            vboxIID **machineIds     = NULL;
+            vboxArray machineIds = VBOX_ARRAY_INITIALIZER;
+
+#if VBOX_API_VERSION < 3001
+            vboxArrayGet(&machineIds, hardDisk, hardDisk->vtbl->imedium.GetMachineIds);
+#else  /* VBOX_API_VERSION >= 3001 */
+            vboxArrayGet(&machineIds, hardDisk, hardDisk->vtbl->GetMachineIds);
+#endif /* VBOX_API_VERSION >= 3001 */
 
-            VBOX_MEDIUM_FUNC_ARG2(hardDisk, GetMachineIds, &machineIdsSize, &machineIds);
+            machineIdsSize = machineIds.count;
 
-            for (i = 0; i < machineIdsSize; i++) {
+            for (i = 0; i < machineIds.count; i++) {
                 IMachine *machine = NULL;
+                vboxIID *machineId = machineIds.items[i];
 
-                rc = data->vboxObj->vtbl->OpenSession(data->vboxObj, data->vboxSession, machineIds[i]);
+                rc = data->vboxObj->vtbl->OpenSession(data->vboxObj, data->vboxSession, machineId);
                 if (NS_SUCCEEDED(rc)) {
 
                     rc = data->vboxSession->vtbl->GetMachine(data->vboxSession, &machine);
                     if (NS_SUCCEEDED(rc)) {
-                        PRUint32 hddAttachSize = 0;
-                        IHardDiskAttachment **hddAttachments = NULL;
+                        vboxArray hddAttachments = VBOX_ARRAY_INITIALIZER;
 
 #if VBOX_API_VERSION < 3001
-                        machine->vtbl->GetHardDiskAttachments(machine, &hddAttachSize, &hddAttachments);
+                        vboxArrayGet(&hddAttachments, machine,
+                                     machine->vtbl->GetHardDiskAttachments);
 #else  /* VBOX_API_VERSION >= 3001 */
-                        machine->vtbl->GetMediumAttachments(machine, &hddAttachSize, &hddAttachments);
+                        vboxArrayGet(&hddAttachments, machine,
+                                     machine->vtbl->GetMediumAttachments);
 #endif /* VBOX_API_VERSION >= 3001 */
-                        for (j = 0; j < hddAttachSize; j++) {
-                            IHardDiskAttachment *hddAttachment = hddAttachments[j];
+                        for (j = 0; j < hddAttachments.count; j++) {
+                            IHardDiskAttachment *hddAttachment = hddAttachments.items[j];
 
                             if (hddAttachment) {
                                 IHardDisk *hdd = NULL;
@@ -8154,18 +8103,16 @@ static int vboxStorageVolDelete(virStorageVolPtr vol,
                                     }
                                     VBOX_MEDIUM_RELEASE(hdd);
                                 }
-                                VBOX_RELEASE(hddAttachment);
                             }
                         }
+                        vboxArrayRelease(&hddAttachments);
                         VBOX_RELEASE(machine);
                     }
                     data->vboxSession->vtbl->Close(data->vboxSession);
                 }
             }
 
-            for (i = 0; i < machineIdsSize; i++)
-                if (machineIds[i])
-                    vboxIIDUnalloc(machineIds[i]);
+            vboxArrayUnalloc(&machineIds);
 
             if (machineIdsSize == 0 || machineIdsSize == deregister) {
                 IProgress *progress = NULL;