Changeset 99085 in vbox

Timestamp:

Mar 21, 2023 12:15:00 PM (2 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

156450

Message:

Guest Control: Added directory listing support via IDirectory::list(). Added (randomized) testcase support for it. bugref:9783

Location:

trunk

Files:

• include/VBox/GuestHost/GuestControl.h (modified) (2 diffs)
• include/VBox/HostServices/GuestControlSvc.h (modified) (8 diffs)
• include/VBox/VBoxGuestLib.h (modified) (2 diffs)
• src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR3LibGuestCtrl.cpp (modified) (3 diffs)
• src/VBox/Additions/common/VBoxService/VBoxServiceControl.h (modified) (2 diffs)
• src/VBox/Additions/common/VBoxService/VBoxServiceControlSession.cpp (modified) (8 diffs)
• src/VBox/Main/idl/VirtualBox.xidl (modified) (2 diffs)
• src/VBox/Main/include/GuestCtrlImplPrivate.h (modified) (3 diffs)
• src/VBox/Main/include/GuestDirectoryImpl.h (modified) (3 diffs)
• src/VBox/Main/src-client/GuestDirectoryImpl.cpp (modified) (18 diffs)
• src/VBox/ValidationKit/tests/additions/tdAddGuestCtrl.py (modified) (8 diffs)

trunk/include/VBox/GuestHost/GuestControl.h

@@ -432 +432 @@
 /** GSTCTL_PATH_F_XXX flag valid mask. */
 #define GSTCTL_PATH_F_VALID_MASK         UINT32_C(0x00000007)
+/** @} */
+
+/** @name GSTCTL_DIRLIST_F_XXX - Flags for guest directory listings.
+ * @{ */
+/** No guest listing flags specified. */
+#define GSTCTL_DIRLIST_F_NONE               UINT32_C(0)
+/** GSTCTL_DIRLIST_F_XXX valid mask. */
+#define GSTCTL_DIRLIST_F_VALID_MASK         UINT32_C(0x00000000)
 /** @} */
 
@@ -553 +561 @@
 
 /** The maximum size (in bytes) of an entry file name (at least RT_UOFFSETOF(GSTCTLDIRENTRYEX, szName[2]). */
-#define GSTCTL_DIRENTRY_MAX_SIZE    4096
-
+#define GSTCTL_DIRENTRY_MAX_SIZE                4096
+/** Maximum characters of the resolved user name. Including terminator. */
+#define GSTCTL_DIRENTRY_MAX_USER_NAME           255
+/** Maximum characters of the resolved user groups list. Including terminator. */
+#define GSTCTL_DIRENTRY_MAX_USER_GROUPS         _1K
+/** The resolved user groups delimiter as a string. */
+#define GSTCTL_DIRENTRY_GROUPS_DELIMITER_STR    "\r\n"
+
+/**
+ * Guest directory entry header.
+ *
+ * This is needed for (un-)packing multiple directory entries with its resolved user name + groups
+ * with the HOST_MSG_DIR_LIST command.
+ *
+ * The order of the attributes also mark their packed order, so be careful when changing this!
+ *
+ * @since 7.1.
+ */
+#pragma pack(1)
+typedef struct GSTCTLDIRENTRYLISTHDR
+{
+    /** Size (in bytes) of the directory header). */
+    uint32_t          cbDirEntryEx;
+    /** Size (in bytes) of the resolved user name as a string
+     *  Includes terminator. */
+    uint32_t          cbUser;
+    /** Size (in bytes) of the resolved user groups as a string.
+     *  Delimited by GSTCTL_DIRENTRY_GROUPS_DELIMITER_STR. Includes terminator. */
+    uint32_t          cbGroups;
+} GSTCTLDIRENTRYBLOCK;
+/** Pointer to a guest directory header entry. */
+typedef GSTCTLDIRENTRYLISTHDR *PGSTCTLDIRENTRYLISTHDR;
+#pragma pack()
 } /* namespace guestControl */
 

trunk/include/VBox/HostServices/GuestControlSvc.h

@@ -232 +232 @@
      */
     HOST_MSG_DIR_CREATE = 314,
+    /**
+     * Lists one or multiple directory entries at once.
+     *
+     * @since   7.1
+     */
+    HOST_MSG_DIR_LIST = 315,
 #endif /* VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS */
     /**
@@ -302 +308 @@
         RT_CASE_RET_STR(HOST_MSG_DIR_REWIND);
         RT_CASE_RET_STR(HOST_MSG_DIR_CREATE);
+        RT_CASE_RET_STR(HOST_MSG_DIR_LIST);
 #endif /* VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS */
         RT_CASE_RET_STR(HOST_MSG_DIR_REMOVE);
@@ -729 +736 @@
     /** Guest directory was rewind. */
     GUEST_DIR_NOTIFYTYPE_REWIND = 22,
+    /** Guest directory listing. */
+    GUEST_DIR_NOTIFYTYPE_LIST = 23,
 #endif
     /** Information about an open guest directory. */
@@ -1092 +1101 @@
     HGCMFunctionParameter flags;
 } HGCMMsgDirCreate;
+
+/**
+ * Lists the entries of a directory on the guest.
+ */
+typedef struct HGCMMsgDirList
+{
+    VBGLIOCHGCMCALL hdr;
+    /** Context ID. */
+    HGCMFunctionParameter context;
+    /** Handle of directory listing to list. */
+    HGCMFunctionParameter handle;
+    /** Number of entries to read at once.
+     *  Specify UINT32_MAX to read as much as possible. 0 is not allowed. */
+    HGCMFunctionParameter num_entries;
+    /** Listing flags (GSTCTL_DIRLIST_F_XXX). */
+    HGCMFunctionParameter flags;
+} HGCMMsgDirList;
 #endif /* VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS */
 
@@ -1528 +1554 @@
     {
         /**
-         * Parameters used for \a type GUEST_DIR_NOTIFYTYPE_OPEN.
+         * Parameters used for \a reply_hdr.type GUEST_DIR_NOTIFYTYPE_OPEN.
          *
          * @since 7.1
@@ -1538 +1564 @@
         } open;
         /**
-         * Parameters used for \a type GUEST_DIR_NOTIFYTYPE_READ.
+         * Parameters used for \a reply_hdr.type GUEST_DIR_NOTIFYTYPE_READ.
          *
          * @since 7.1
@@ -1550 +1576 @@
             /** Resolved group IDs as a string.
              *
-             *  Multiple groups are delimited by "\r\n", whereas
+             *  Multiple groups are delimited by GSTCTL_DIRENTRY_GROUPS_DELIMITER_STR, whereas
              *  the first group always is the primary group. */
             HGCMFunctionParameter groups;
         } read;
+        /**
+         * Parameters used for \a reply_hdr.type GUEST_DIR_NOTIFYTYPE_LIST.
+         *
+         * @since 7.1
+         */
+        struct
+        {
+            /** Number of entries in \a buffer. */
+            HGCMFunctionParameter num_entries;
+            /** Buffer containing the GSTCTLDIRENTRYEX entries, immediately followed
+             *  by resolved user + groups as a string (empty strings if not resolved).
+             *
+             *  Only will be sent if \a num_entries > 0. */
+            HGCMFunctionParameter buffer;
+        } list;
     } u;
 } HGCMReplyDirNotify;
@@ -1582 +1623 @@
             /** Resolved group IDs as a string.
              *
-             *  Multiple groups are delimited by "\r\n", whereas
+             *  Multiple groups are delimited by GSTCTL_DIRENTRY_GROUPS_DELIMITER_STR, whereas
              *  the first group always is the primary group. */
             HGCMFunctionParameter groups;

trunk/include/VBox/VBoxGuestLib.h

@@ -1122 +1122 @@
 VBGLR3DECL(int) VbglR3GuestCtrlDirGetRead(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *puHandle);
 VBGLR3DECL(int) VbglR3GuestCtrlDirGetRewind(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *puHandle);
+VBGLR3DECL(int) VbglR3GuestCtrlDirGetList(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *puHandle, uint32_t *pcEntries, uint32_t *pfFlags);
 /** @} */
 #  endif /* VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS */
@@ -1155 +1156 @@
 VBGLR3DECL(int) VbglR3GuestCtrlDirCbRead(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc, PGSTCTLDIRENTRYEX pEntry, uint32_t cbSize);
 VBGLR3DECL(int) VbglR3GuestCtrlDirCbRewind(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc);
+VBGLR3DECL(int) VbglR3GuestCtrlDirCbList(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc, uint32_t cEntries, void *pvBuf, uint32_t cbBuf);
 /** @} */
 #  endif /* VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS */

trunk/src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR3LibGuestCtrl.cpp

@@ -1129 +1129 @@
     return rc;
 }
+
+
+/**
+ * Retrieves a HOST_MSG_DIR_LIST message.
+ *
+ * @returns VBox status code.
+ * @param   pCtx                Guest control command context to use.
+ * @param   puHandle            Where to return the directory handle to rewind.
+ * @param   pcEntries           Where to return the number of directory entries to read.
+ * @param   pfFlags             Where to return the directory listing flags.
+ */
+VBGLR3DECL(int) VbglR3GuestCtrlDirGetList(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *puHandle, uint32_t *pcEntries, uint32_t *pfFlags)
+{
+    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
+    AssertReturn(pCtx->uNumParms == 4, VERR_INVALID_PARAMETER);
+
+    AssertPtrReturn(puHandle, VERR_INVALID_POINTER);
+    AssertPtrReturn(pcEntries, VERR_INVALID_POINTER);
+    AssertPtrReturn(pfFlags, VERR_INVALID_POINTER);
+
+    int rc;
+    do
+    {
+        HGCMMsgDirList Msg;
+        VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, vbglR3GuestCtrlGetMsgFunctionNo(pCtx->uClientID), pCtx->uNumParms);
+        VbglHGCMParmUInt32Set(&Msg.context, HOST_MSG_DIR_LIST);
+        VbglHGCMParmUInt32Set(&Msg.handle, 0);
+        VbglHGCMParmUInt32Set(&Msg.num_entries, 0);
+        VbglHGCMParmUInt32Set(&Msg.flags, 0);
+
+        rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
+        if (RT_SUCCESS(rc))
+        {
+            Msg.context.GetUInt32(&pCtx->uContextID);
+            Msg.handle.GetUInt32(puHandle);
+            Msg.num_entries.GetUInt32(pcEntries);
+            Msg.flags.GetUInt32(pfFlags);
+        }
+    } while (rc == VERR_INTERRUPTED && g_fVbglR3GuestCtrlHavePeekGetCancel);
+    return rc;
+}
 #endif /* VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS */
 
@@ -2280 +2321 @@
 {
     AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
-    AssertPtrReturn(pszUser, VERR_INVALID_POINTER);
-    AssertPtrReturn(pszGroups, VERR_INVALID_POINTER);
 
     HGCMReplyDirNotify Msg;
@@ -2332 +2371 @@
 
     return VbglR3HGCMCall(&Msg.reply_hdr.hdr, RT_UOFFSET_AFTER(HGCMReplyDirNotify, u));
+}
+
+
+/**
+ * Replies to a HOST_MSG_DIR_LIST message.
+ *
+ * @returns VBox status code.
+ * @param   pCtx                Guest control command context to use.
+ * @param   uRc                 Guest rc of operation (note: IPRT-style signed int).
+ * @þaram   cEntries            Number of directory entries to send.
+ * @param   pvBuf               Buffer of directory entries to send.
+ * @param   cbBuf               Size (in bytes) of \a pvBuf.
+ */
+VBGLR3DECL(int) VbglR3GuestCtrlDirCbList(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc,
+                                         uint32_t cEntries, void *pvBuf, uint32_t cbBuf)
+{
+    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
+
+    HGCMReplyDirNotify Msg;
+    VBGL_HGCM_HDR_INIT(&Msg.reply_hdr.hdr, pCtx->uClientID, GUEST_MSG_DIR_NOTIFY, GSTCTL_HGCM_REPLY_HDR_PARMS + 2);
+    VbglHGCMParmUInt32Set(&Msg.reply_hdr.context, pCtx->uContextID);
+    VbglHGCMParmUInt32Set(&Msg.reply_hdr.type, GUEST_DIR_NOTIFYTYPE_LIST);
+    VbglHGCMParmUInt32Set(&Msg.reply_hdr.rc, uRc);
+
+    VbglHGCMParmUInt32Set(&Msg.u.list.num_entries, cEntries);
+    VbglHGCMParmPtrSet(&Msg.u.list.buffer, pvBuf, cbBuf);
+
+    return VbglR3HGCMCall(&Msg.reply_hdr.hdr, RT_UOFFSET_AFTER(HGCMReplyDirNotify, u.list));
 }
 #endif /* VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS */

trunk/src/VBox/Additions/common/VBoxService/VBoxServiceControl.h

@@ -87 +87 @@
     /** Additional attributes enumeration to use for reading directory entries. */
     GSTCTLFSOBJATTRADD              enmReadAttrAdd;
+    /** Scratch buffer for holding the directory reading entry.
+     *  Currently NOT serialized, i.e. only can be used for one read at a time. */
+    PRTDIRENTRYEX                   pDirEntryEx;
+    /** Size (in bytes) of \a pDirEntryEx. */
+    size_t                          cbDirEntryEx;
 } VBOXSERVICECTRLDIR;
 /** Pointer to a guest directory. */
@@ -233 +238 @@
     /** The gid cache for this session. */
     VGSVCIDCACHE                    GidCache;
-    /** Scratch buffer for holding the directory reading entry.
-     *  Currently NOT serialized, i.e. only can be used for one read at a time. */
-    PRTDIRENTRYEX                   pDirEntryEx;
-    /** Size (in bytes) of \a pDirEntryEx. */
-    size_t                          cbDirEntryEx;
 #endif
 } VBOXSERVICECTRLSESSION;

trunk/src/VBox/Additions/common/VBoxService/VBoxServiceControlSession.cpp

@@ -113 +113 @@
     if (!pDir)
         return VINF_SUCCESS;
+
+    RTMemFree(pDir->pDirEntryEx);
 
     int rc;
@@ -1038 +1040 @@
             pDir->enmReadAttrAdd = enmAttrAdd;
 
+            pDir->cbDirEntryEx = GSTCTL_DIRENTRY_MAX_SIZE;
+            pDir->pDirEntryEx  = (PRTDIRENTRYEX)RTMemAlloc(pDir->cbDirEntryEx);
+            AssertPtrReturn(pDir->pDirEntryEx, VERR_NO_MEMORY);
+
             if (RT_SUCCESS(rc))
             {
@@ -1134 +1140 @@
 
 
+/**
+ * Worker function for reading a next guest directory entry.
+ *
+ * @returns VBox status code.
+ * @param   pSession            Guest Control session to use.
+ * @param   pDir                Guest directory to read the next entry for.
+ * @param   ppDirEntryEx        Where to store the pointer to the next guest directory entry on success.
+ * @param   pcbDirEntryEx       Where to return the size (in bytes) of \a ppGstCtlDirEntryEx on success.
+ * @param   ppszUser            Where to return the resolved user name string.
+ * @param   ppszGroups          Where to return the resolved groups string.
+ */
+static int vgsvcGstCtrlSessionDirReadNext(const PVBOXSERVICECTRLSESSION pSession,
+                                          PVBOXSERVICECTRLDIR pDir,
+                                          PGSTCTLDIRENTRYEX *ppDirEntryEx, size_t *pcbDirEntryEx,
+                                          const char **ppszUser, const char **ppszGroups)
+{
+    PRTDIRENTRYEX pDirEntryEx = pDir->pDirEntryEx;
+
+    size_t cbDirEntryEx = pDir->cbDirEntryEx;
+    int rc = RTDirReadEx(pDir->hDir, pDir->pDirEntryEx, &cbDirEntryEx, (RTFSOBJATTRADD)pDir->enmReadAttrAdd, pDir->fRead);
+
+    VGSvcVerbose(2, "[Dir %s] Read next entry '%s' -> %Rrc (%zu bytes)\n",
+                 pDir->pszPathAbs, RT_SUCCESS(rc) ? pDirEntryEx->szName : "<None>", rc, cbDirEntryEx);
+
+    if (RT_FAILURE(rc))
+        return rc;
+
+    /* Paranoia. */
+    AssertReturn(cbDirEntryEx <= pDir->cbDirEntryEx, VERR_BUFFER_OVERFLOW);
+
+    *ppszUser   = VGSvcIdCacheGetUidName(&pSession->UidCache,
+                                         pDirEntryEx->Info.Attr.u.Unix.uid, pDirEntryEx->szName, pDir->pszPathAbs);
+    *ppszGroups = VGSvcIdCacheGetGidName(&pSession->GidCache,
+                                         pDirEntryEx->Info.Attr.u.Unix.gid, pDirEntryEx->szName, pDir->pszPathAbs);
+
+    VGSvcVerbose(2, "[Dir %s] Entry '%s': %zu bytes, uid=%s (%d), gid=%s (%d)\n",
+                 pDir->pszPathAbs, pDirEntryEx->szName, pDirEntryEx->Info.cbObject,
+                 *ppszUser, pDirEntryEx->Info.Attr.u.UnixOwner.uid,
+                 *ppszGroups, pDirEntryEx->Info.Attr.u.UnixGroup.gid);
+
+    /*
+     * For now we ASSUME that RTDIRENTRYEX == GSTCTLDIRENTRYEX, which implies that we simply can cast RTDIRENTRYEX
+     * to GSTCTLDIRENTRYEX. This might change in the future, however, so be extra cautious here.
+     *
+     * Ditto for RTFSOBJATTRADD == GSTCTLFSOBJATTRADD.
+     */
+    AssertCompile(sizeof(GSTCTLDIRENTRYEX)              == sizeof(RTDIRENTRYEX));
+    AssertCompile(RT_OFFSETOF(GSTCTLDIRENTRYEX, Info)   == RT_OFFSETOF(RTDIRENTRYEX, Info));
+    AssertCompile(RT_OFFSETOF(GSTCTLDIRENTRYEX, cbName) == RT_OFFSETOF(RTDIRENTRYEX, cbName));
+    AssertCompile(RT_OFFSETOF(GSTCTLDIRENTRYEX, szName) == RT_OFFSETOF(RTDIRENTRYEX, szName));
+    AssertCompile(RT_OFFSETOF(GSTCTLFSOBJINFO,  Attr)   == RT_OFFSETOF(RTFSOBJINFO,  Attr));
+
+    if (RT_SUCCESS(rc))
+    {
+        *ppDirEntryEx  = (PGSTCTLDIRENTRYEX)pDirEntryEx;
+        *pcbDirEntryEx = cbDirEntryEx;
+    }
+
+    return rc;
+}
+
+
 static int vgsvcGstCtrlSessionHandleDirRead(const PVBOXSERVICECTRLSESSION pSession, PVBGLR3GUESTCTRLCMDCTX pHostCtx)
 {
@@ -1149 +1217 @@
         if (pDir)
         {
-            PRTDIRENTRYEX pDirEntryEx = pSession->pDirEntryEx;
-
-            size_t cbDirEntry = pSession->cbDirEntryEx;
-            rc = RTDirReadEx(pDir->hDir, pDirEntryEx, &cbDirEntry, (RTFSOBJATTRADD)pDir->enmReadAttrAdd, pDir->fRead);
-
-            /* Paranoia. */
-            AssertStmt(cbDirEntry <= pSession->cbDirEntryEx, rc = VERR_BUFFER_OVERFLOW);
-
-            VGSvcVerbose(2, "[Dir %s] Read next entry '%s' -> %Rrc (%zu bytes)\n",
-                         pDir->pszPathAbs, RT_SUCCESS(rc) ? pDirEntryEx->szName : "<None>", rc, cbDirEntry);
-
-            const char *pszUser  = VGSvcIdCacheGetUidName(&pSession->UidCache,
-                                                          pDirEntryEx->Info.Attr.u.Unix.uid, pDirEntryEx->szName, pDir->pszPathAbs);
-            const char *pszGroup = VGSvcIdCacheGetGidName(&pSession->GidCache,
-                                                          pDirEntryEx->Info.Attr.u.Unix.gid, pDirEntryEx->szName, pDir->pszPathAbs);
-
-            VGSvcVerbose(2, "[Dir %s] Entry '%s': %zu bytes, uid=%s (%d), gid=%s (%d)\n",
-                         pDir->pszPathAbs, pDirEntryEx->szName, pDirEntryEx->Info.cbObject,
-                         pszUser ? pszUser : "", pDirEntryEx->Info.Attr.u.UnixOwner.uid,
-                         pszGroup ? pszGroup : "", pDirEntryEx->Info.Attr.u.UnixGroup.gid);
-
-            /*
-             * For now we ASSUME that RTDIRENTRYEX == GSTCTLDIRENTRYEX, which implies that we simply can cast RTDIRENTRYEX
-             * to GSTCTLDIRENTRYEX. This might change in the future, however, so be extra cautious here.
-             *
-             * Ditto for RTFSOBJATTRADD == GSTCTLFSOBJATTRADD.
-             */
-            AssertCompile(sizeof(GSTCTLDIRENTRYEX)              == sizeof(RTDIRENTRYEX));
-            AssertCompile(RT_OFFSETOF(GSTCTLDIRENTRYEX, Info)   == RT_OFFSETOF(RTDIRENTRYEX, Info));
-            AssertCompile(RT_OFFSETOF(GSTCTLDIRENTRYEX, cbName) == RT_OFFSETOF(RTDIRENTRYEX, cbName));
-            AssertCompile(RT_OFFSETOF(GSTCTLDIRENTRYEX, szName) == RT_OFFSETOF(RTDIRENTRYEX, szName));
-            AssertCompile(RT_OFFSETOF(GSTCTLFSOBJINFO,  Attr)   == RT_OFFSETOF(RTFSOBJINFO,  Attr));
-
-            PGSTCTLDIRENTRYEX pGstCtlDirEntryEx = (PGSTCTLDIRENTRYEX)pDirEntryEx;
-
-            int rc2 = VbglR3GuestCtrlDirCbReadEx(pHostCtx, rc, pGstCtlDirEntryEx, (uint32_t)cbDirEntry, pszUser, pszGroup);
+            PGSTCTLDIRENTRYEX pDirEntryEx;
+            size_t            cbDirEntryEx;
+            const char       *pszUser   = NULL;
+            const char       *pszGroups = NULL;
+            rc = vgsvcGstCtrlSessionDirReadNext(pSession, pDir,
+                                                &pDirEntryEx, &cbDirEntryEx, &pszUser, &pszGroups);
+
+            VGSvcVerbose(2, "[Dir %s] %Rrc\n", pDir->pszPathAbs, rc);
+
+            int rc2;
+            if (RT_SUCCESS(rc))
+                rc2 = VbglR3GuestCtrlDirCbReadEx(pHostCtx, rc, pDirEntryEx, cbDirEntryEx, pszUser, pszGroups);
+            else
+                rc2 = VbglR3GuestCtrlDirCbRead(pHostCtx, rc, NULL /* pEntry */, 0 /* cbSize */);
             if (RT_FAILURE(rc2))
                 VGSvcError("Failed to report directory read status (%Rrc), rc=%Rrc\n", rc, rc2);
+
+            VGSvcVerbose(2, "[Dir %s] 2 %Rrc\n", pDir->pszPathAbs, rc);
 
             if (rc == VERR_NO_MORE_FILES) /* Directory reading done. */
@@ -1308 +1356 @@
     }
     VGSvcVerbose(5, "Creating directory returned rc=%Rrc\n", rc);
+    return rc;
+}
+
+static int vgsvcGstCtrlSessionHandleDirList(const PVBOXSERVICECTRLSESSION pSession, PVBGLR3GUESTCTRLCMDCTX pHostCtx)
+{
+    AssertPtrReturn(pSession, VERR_INVALID_POINTER);
+    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
+
+    /*
+     * Retrieve the request.
+     */
+    uint32_t uHandle;
+    uint32_t cEntries;
+    uint32_t cEntriesRead = 0;
+    uint32_t fFlags;
+    int rc = VbglR3GuestCtrlDirGetList(pHostCtx, &uHandle, &cEntries, &fFlags);
+    if (RT_SUCCESS(rc))
+    {
+        size_t cbGrowSize = _64K;
+        void  *pvBuf      = RTMemAlloc(cbGrowSize);
+        if (!pvBuf)
+            rc = VERR_NO_MEMORY;
+        size_t cbBufUsed  = 0;
+        if (RT_SUCCESS(rc))
+        {
+            if (!(fFlags & ~GSTCTL_DIRLIST_F_VALID_MASK))
+            {
+                size_t cbBufSize = cbGrowSize;
+
+                PVBOXSERVICECTRLDIR pDir = vgsvcGstCtrlSessionDirAcquire(pSession, uHandle);
+                if (pDir)
+                {
+                    PGSTCTLDIRENTRYEX pDirEntryEx;
+                    size_t            cbDirEntryEx;
+                    const char       *pszUser   = NULL;
+                    const char       *pszGroups = NULL;
+
+                    while (cEntries--)
+                    {
+                        rc = vgsvcGstCtrlSessionDirReadNext(pSession, pDir,
+                                                            &pDirEntryEx, &cbDirEntryEx, &pszUser, &pszGroups);
+                        if (RT_FAILURE(rc)) /* Might be VERR_NO_MORE_FILES. */
+                            break;
+
+                        size_t const cbHdr    = sizeof(GSTCTLDIRENTRYLISTHDR);
+                        size_t const cbUser   = strlen(pszUser)   + 1; /* Include terminator. */
+                        size_t const cbGroups = strlen(pszGroups) + 1; /* Ditto. */
+                        size_t const cbTotal  = cbHdr + cbDirEntryEx + cbUser + cbGroups;
+
+                        if (cbBufSize - cbBufUsed < cbTotal) /* Grow buffer, if needed. */
+                        {
+                            AssertBreakStmt(cbTotal <= cbGrowSize, VERR_BUFFER_OVERFLOW);
+                            pvBuf      = RTMemRealloc(pvBuf, cbBufSize + cbGrowSize);
+                            AssertPtrBreakStmt(pvBuf, VERR_NO_MEMORY);
+                            cbBufSize += cbGrowSize;
+                        }
+
+                        GSTCTLDIRENTRYLISTHDR Hdr;
+                        Hdr.cbDirEntryEx = cbDirEntryEx;
+                        Hdr.cbUser       = cbUser;
+                        Hdr.cbGroups     = cbGroups;
+
+                        memcpy((uint8_t *)pvBuf + cbBufUsed, &Hdr, cbHdr);
+                        cbBufUsed += cbHdr;
+                        memcpy((uint8_t *)pvBuf + cbBufUsed, pDirEntryEx, cbDirEntryEx);
+                        cbBufUsed += cbDirEntryEx;
+                        memcpy((uint8_t *)pvBuf + cbBufUsed, pszUser, cbUser);
+                        cbBufUsed += cbUser;
+                        memcpy((uint8_t *)pvBuf + cbBufUsed, pszGroups, cbGroups);
+                        cbBufUsed += cbGroups;
+
+                        Assert(cbBufUsed <= cbBufSize);
+                        cEntriesRead++;
+                    }
+
+                    vgsvcGstCtrlSessionDirRelease(pDir);
+                }
+
+                VGSvcVerbose(4, "Read %RU32 directory entries (requested %RU32 entries) -> %zu bytes, rc=%Rrc\n",
+                             cEntriesRead, cEntries, cbBufUsed, rc);
+
+                /* Directory reading done? */
+                if (   cEntriesRead
+                    && rc == VERR_NO_MORE_FILES)
+                    rc = VINF_SUCCESS;
+
+                /* Note: Subsequent calls will return VERR_NO_MORE_FILES to the host. */
+            }
+            else
+            {
+                VGSvcError("Unsupported directory listing flags: %#x (all %#x)\n", (fFlags & ~GSTCTL_DIRLIST_F_VALID_MASK), fFlags);
+                rc = VERR_NOT_SUPPORTED;
+            }
+        }
+
+        /*
+         * Report result back to host.
+         */
+        int rc2 = VbglR3GuestCtrlDirCbList(pHostCtx, rc, cEntriesRead, pvBuf, (uint32_t)cbBufUsed);
+        if (RT_FAILURE(rc2))
+            VGSvcError("Failed to report directory listing (%Rrc), rc=%Rrc\n", rc, rc2);
+
+        if (rc == VERR_NO_MORE_FILES) /* Directory reading done? */
+            rc = VINF_SUCCESS;
+
+        RTMemFree(pvBuf);
+    }
+    else
+    {
+        VGSvcError("Error fetching parameters for directory listing operation: %Rrc\n", rc);
+        VbglR3GuestCtrlMsgSkip(pHostCtx->uClientID, rc, UINT32_MAX);
+    }
+    VGSvcVerbose(5, "Listing directory returned rc=%Rrc\n", rc);
     return rc;
 }
@@ -2123 +2284 @@
                 rc = vgsvcGstCtrlSessionHandleDirCreate(pSession, pHostCtx);
             break;
+
+        case HOST_MSG_DIR_LIST:
+            if (fImpersonated)
+                rc = vgsvcGstCtrlSessionHandleDirList(pSession, pHostCtx);
+            break;
 #endif /* VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS */
 
@@ -2726 +2892 @@
     int rc = VGSvcGstCtrlSessionClose(pSession);
 
-#ifdef VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS
-    RTMemFree(pSession->pDirEntryEx);
-#endif
-
     /* Destroy critical section. */
     RTCritSectDelete(&pSession->CritSect);
@@ -2755 +2917 @@
     RT_ZERO(pSession->UidCache);
     RT_ZERO(pSession->GidCache);
-
-    pSession->cbDirEntryEx = GSTCTL_DIRENTRY_MAX_SIZE;
-    pSession->pDirEntryEx  = (PRTDIRENTRYEX)RTMemAlloc(pSession->cbDirEntryEx);
-    AssertPtrReturn(pSession->pDirEntryEx, VERR_NO_MEMORY);
 #endif
 

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

@@ -16425 +16425 @@
   <interface
     name="IDirectory" extends="$unknown"
-    uuid="c7b24ad6-dba7-486c-b1ed-5f16d8d6da22"
+    uuid="a508e094-bf24-4eca-80c6-467766a1e4c0"
     wsmap="managed"
     reservedMethods="4" reservedAttributes="8"
@@ -16464 +16464 @@
         directory entry will not be possible anymore.
       </desc>
+    </method>
+
+    <method name="list">
+      <desc>
+        Lists directory entries of this directory.
+        <result name="VBOX_E_OBJECT_NOT_FOUND">
+          No more directory entries to read.
+        </result>
+      </desc>
+      <param name="maxEntries" type="unsigned long" dir="in">
+        <desc>Maximum entries to return per call. The guest might decide to return less than the given maximum, depending on
+          the guest OS.</desc>
+      </param>
+      <param name="objInfo" type="IFsObjInfo" safearray="yes" dir="return">
+        <desc>Array of object information of the current directory entry read. Also see
+          <link to="IFsObjInfo"/>.</desc>
+      </param>
     </method>
 

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

@@ -1457 +1457 @@
 
 
-/*******************************************************************************
-* Callback data structures.                                                    *
-*                                                                              *
-* These structures make up the actual low level HGCM callback data sent from   *
-* the guest back to the host.                                                  *
-*******************************************************************************/
+/*********************************************************************************************************************************
+ * Callback data structures.                                                                                                     *
+ *                                                                                                                               *
+ * These structures make up the actual low level HGCM callback data sent from                                                    *
+ * the guest back to the host.                                                                                                   *
+ ********************************************************************************************************************************/
 
 /**
@@ -1636 +1636 @@
 
 /**
+ * Callback data for a single GSTCTLDIRENTRYEX entry.
+ */
+typedef struct CALLBACKDATA_DIR_ENTRY
+{
+    /** Pointer to directory entry information. */
+    PGSTCTLDIRENTRYEX pDirEntryEx;
+    /** Size (in bytes) of directory entry information. */
+    uint32_t          cbDirEntryEx;
+    /** Resolved user name.
+     *  This is the object owner for UNIX-y Oses. */
+    char             *pszUser;
+    /** Size (in bytes) of \a pszUser. */
+    uint32_t          cbUser;
+    /** Resolved user group(s). */
+    char             *pszGroups;
+    /** Size (in bytes) of \a pszGroups. */
+    uint32_t          cbGroups;
+} CALLBACKDATA_DIR_ENTRY;
+/** Pointer to a CALLBACKDATA_DIR_ENTRY struct. */
+typedef CALLBACKDATA_DIR_ENTRY *PCALLBACKDATA_DIR_ENTRY;
+
+/**
  * Callback data for guest directory operations.
  */
@@ -1661 +1683 @@
         struct
         {
-            /** Pointer to directory entry information. */
-            PGSTCTLDIRENTRYEX pEntry;
-            /** Size (in bytes) of directory entry information. */
-            uint32_t          cbEntry;
-            /** Resolved user name.
-             *  This is the object owner for UNIX-y Oses. */
-            char             *pszUser;
-            /** Size (in bytes) of \a pszUser. */
-            uint32_t          cbUser;
-            /** Resolved user group(s). */
-            char             *pszGroups;
-            /** Size (in bytes) of \a pszGroups. */
-            uint32_t          cbGroups;
+            /** Single entry read. */
+            CALLBACKDATA_DIR_ENTRY Entry;
         } read;
+        struct
+        {
+            /** Number of entries in \a paEntries. */
+            uint32_t                 cEntries;
+            /** Array of entries read. */
+            CALLBACKDATA_DIR_ENTRY **paEntries;
+        } list;
     } u;
 } CALLBACKDATA_DIR_NOTIFY;

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

@@ -72 +72 @@
     EventSource   *i_getEventSource(void) { return mEventSource; }
     int            i_onDirNotify(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData);
+    int            i_listInternal(uint32_t cMaxEntries, uint32_t fFlags, std::vector<GuestFsObjData> &vecObjData, int *pvrcGuest);
+    int            i_listEx(uint32_t cMaxEntries, uint32_t fFlags, std::vector<ComObjPtr<GuestFsObjInfo>> &vecObjInfo, int *pvrcGuest);
+    int            i_list(uint32_t cMaxEntries, std::vector<ComObjPtr<GuestFsObjInfo>> &vecObjInfo, int *pvrcGuest);
     int            i_read(ComObjPtr<GuestFsObjInfo> &fsObjInfo, int *pvrcGuest);
     int            i_readInternal(GuestFsObjData &objData, int *pvrcGuest);
@@ -89 +92 @@
      * @{ */
     static Utf8Str i_guestErrorToString(int vrcGuest, const char *pcszWhat);
+    static void    i_dirNotifyDataDestroy(PCALLBACKDATA_DIR_NOTIFY pDirNotify);
     /** @}  */
 
@@ -105 +109 @@
     HRESULT getId(ULONG *aId);
     HRESULT getStatus(DirectoryStatus_T *aStatus);
+    HRESULT list(ULONG aMaxEntries, std::vector<ComPtr<IFsObjInfo> > &aObjInfos);
     HRESULT read(ComPtr<IFsObjInfo> &aObjInfo);
     HRESULT rewind(void);

trunk/src/VBox/Main/src-client/GuestDirectoryImpl.cpp

@@ -467 +467 @@
     HGCMSvcGetU32(&pSvcCbData->mpaParms[idx++], &dataCb.rc);
 
-    int vrcGuest = (int)dataCb.rc; /* uint32_t vs. int. */
+    int const vrcGuest = (int)dataCb.rc; /* uint32_t vs. int. */
 
     LogFlowThisFunc(("uType=%RU32, vrcGuest=%Rrc\n", dataCb.uType, vrcGuest));
@@ -523 +523 @@
                                         ("type=%u\n", pSvcCbData->mpaParms[idx].type),
                                         vrc = VERR_WRONG_PARAMETER_TYPE);
-            PGSTCTLDIRENTRYEX pEntry;
-            uint32_t          cbEntry;
-            vrc = HGCMSvcGetPv(&pSvcCbData->mpaParms[idx++], (void **)&pEntry, &cbEntry);
+            PGSTCTLDIRENTRYEX pDirEntryEx;
+            uint32_t          cbDirEntryEx;
+            vrc = HGCMSvcGetPv(&pSvcCbData->mpaParms[idx++], (void **)&pDirEntryEx, &cbDirEntryEx);
             AssertRCBreak(vrc);
-            AssertBreakStmt(   cbEntry >= RT_UOFFSETOF(GSTCTLDIRENTRYEX, szName[2])
-                            && cbEntry <= GSTCTL_DIRENTRY_MAX_SIZE, VERR_INVALID_PARAMETER);
-            dataCb.u.read.pEntry  = (PGSTCTLDIRENTRYEX)RTMemDup(pEntry, cbEntry);
-            AssertPtrBreakStmt(dataCb.u.read.pEntry, vrc = VERR_NO_MEMORY);
-            dataCb.u.read.cbEntry = cbEntry;
+            AssertBreakStmt(   cbDirEntryEx >= RT_UOFFSETOF(GSTCTLDIRENTRYEX, szName[2])
+                            && cbDirEntryEx <= GSTCTL_DIRENTRY_MAX_SIZE, vrc = VERR_INVALID_PARAMETER);
+            dataCb.u.read.Entry.pDirEntryEx  = (PGSTCTLDIRENTRYEX)RTMemDup(pDirEntryEx, cbDirEntryEx);
+            AssertPtrBreakStmt(dataCb.u.read.Entry.pDirEntryEx, vrc = VERR_NO_MEMORY);
+            dataCb.u.read.Entry.cbDirEntryEx = cbDirEntryEx;
 
             char    *pszUser;
@@ -537 +537 @@
             vrc = HGCMSvcGetStr(&pSvcCbData->mpaParms[idx++], &pszUser, &cbUser);
             AssertRCBreak(vrc);
-            dataCb.u.read.pszUser = RTStrDup(pszUser);
-            AssertPtrBreakStmt(dataCb.u.read.pszUser, vrc = VERR_NO_MEMORY);
-            dataCb.u.read.cbUser  = cbUser;
+            AssertBreakStmt(cbUser <= GSTCTL_DIRENTRY_MAX_USER_NAME, vrc = VERR_TOO_MUCH_DATA);
+            dataCb.u.read.Entry.pszUser = RTStrDup(pszUser);
+            AssertPtrBreakStmt(dataCb.u.read.Entry.pszUser, vrc = VERR_NO_MEMORY);
+            dataCb.u.read.Entry.cbUser  = cbUser;
 
             char    *pszGroups;
@@ -545 +546 @@
             vrc = HGCMSvcGetStr(&pSvcCbData->mpaParms[idx++], &pszGroups, &cbGroups);
             AssertRCBreak(vrc);
-            dataCb.u.read.pszGroups = RTStrDup(pszGroups);
-            AssertPtrBreakStmt(dataCb.u.read.pszGroups, vrc = VERR_NO_MEMORY);
-            dataCb.u.read.cbGroups  = cbGroups;
+            AssertBreakStmt(cbGroups <= GSTCTL_DIRENTRY_MAX_USER_GROUPS, vrc = VERR_TOO_MUCH_DATA);
+            dataCb.u.read.Entry.pszGroups = RTStrDup(pszGroups);
+            AssertPtrBreakStmt(dataCb.u.read.Entry.pszGroups, vrc = VERR_NO_MEMORY);
+            dataCb.u.read.Entry.cbGroups  = cbGroups;
 
             /** @todo ACLs not implemented yet. */
 
-            GuestFsObjData fsObjData(dataCb.u.read.pEntry->szName);
-            vrc = fsObjData.FromGuestFsObjInfo(&dataCb.u.read.pEntry->Info);
+            GuestFsObjData fsObjData(dataCb.u.read.Entry.pDirEntryEx->szName);
+            vrc = fsObjData.FromGuestFsObjInfo(&dataCb.u.read.Entry.pDirEntryEx->Info);
             AssertRCBreak(vrc);
             ComObjPtr<GuestFsObjInfo> ptrFsObjInfo;
@@ -561 +563 @@
 
             ::FireGuestDirectoryReadEvent(mEventSource, mSession, this,
-                                          dataCb.u.read.pEntry->szName, ptrFsObjInfo, dataCb.u.read.pszUser, dataCb.u.read.pszGroups);
+                                          dataCb.u.read.Entry.pDirEntryEx->szName, ptrFsObjInfo,
+                                          dataCb.u.read.Entry.pszUser, dataCb.u.read.Entry.pszGroups);
             break;
         }
@@ -569 +572 @@
             /* Note: This does not change the overall status of the directory (i.e. open). */
             ::FireGuestDirectoryStateChangedEvent(mEventSource, mSession, this, DirectoryStatus_Rewind, errorInfo);
+            break;
+        }
+
+        case GUEST_DIR_NOTIFYTYPE_LIST:
+        {
+            ASSERT_GUEST_MSG_STMT_BREAK(pSvcCbData->mParms >= 4, ("mParms=%u\n", pSvcCbData->mParms),
+                                        vrc = VERR_WRONG_PARAMETER_COUNT);
+            ASSERT_GUEST_MSG_STMT_BREAK(pSvcCbData->mpaParms[idx].type == VBOX_HGCM_SVC_PARM_32BIT,
+                                        ("type=%u\n", pSvcCbData->mpaParms[idx].type),
+                                        vrc = VERR_WRONG_PARAMETER_TYPE);
+
+            vrc = HGCMSvcGetU32(&pSvcCbData->mpaParms[idx++], &dataCb.u.list.cEntries);
+            AssertRCBreak(vrc);
+            /* We limit this for now to 64K entries max per call.
+             * The guest does not do this check, so we could de/increase this limit in the future. */
+            AssertBreakStmt(dataCb.u.list.cEntries <= _64K, vrc = VERR_TOO_MUCH_DATA);
+
+            if (!dataCb.u.list.cEntries) /* No entries sent? Bail out early. */
+                break;
+
+            /*
+             * Fetch buffer with packed directory entries.
+             */
+            ASSERT_GUEST_MSG_STMT_BREAK(pSvcCbData->mParms == 5, ("mParms=%u\n", pSvcCbData->mParms),
+                                        vrc = VERR_WRONG_PARAMETER_COUNT);
+            ASSERT_GUEST_MSG_STMT_BREAK(pSvcCbData->mpaParms[idx].type == VBOX_HGCM_SVC_PARM_PTR,
+                                        ("type=%u\n", pSvcCbData->mpaParms[idx].type),
+                                        vrc = VERR_WRONG_PARAMETER_TYPE);
+            void    *pvBuf;
+            uint32_t cbBuf;
+            vrc = HGCMSvcGetPv(&pSvcCbData->mpaParms[idx], &pvBuf, &cbBuf);
+            AssertRCBreak(vrc);
+            AssertBreakStmt(cbBuf >= sizeof(GSTCTLDIRENTRYEX), vrc = VERR_INVALID_PARAMETER);
+            dataCb.u.list.paEntries = (PCALLBACKDATA_DIR_ENTRY *)RTMemAllocZ(dataCb.u.list.cEntries * sizeof(PCALLBACKDATA_DIR_ENTRY));
+            AssertPtrBreakStmt(dataCb.u.list.paEntries, vrc = VERR_NO_MEMORY);
+
+            /*
+             * Unpack directory entries.
+             */
+            size_t offBuf = 0;
+            for (uint32_t i = 0; i < dataCb.u.list.cEntries; i++)
+            {
+                dataCb.u.list.paEntries[i] = (PCALLBACKDATA_DIR_ENTRY)RTMemAlloc(sizeof(CALLBACKDATA_DIR_ENTRY));
+                AssertPtrBreakStmt(dataCb.u.list.paEntries[i], vrc = VERR_NO_MEMORY);
+
+                PCALLBACKDATA_DIR_ENTRY pEntry = dataCb.u.list.paEntries[i];
+
+                PGSTCTLDIRENTRYLISTHDR  const pHdr   = (PGSTCTLDIRENTRYLISTHDR)((uint8_t *)pvBuf + offBuf);
+                AssertBreakStmt(pHdr->cbDirEntryEx <= GSTCTL_DIRENTRY_MAX_SIZE, vrc = VERR_TOO_MUCH_DATA);
+                AssertBreakStmt(pHdr->cbUser <= GSTCTL_DIRENTRY_MAX_USER_NAME, vrc = VERR_TOO_MUCH_DATA);
+                AssertBreakStmt(pHdr->cbGroups <= GSTCTL_DIRENTRY_MAX_USER_GROUPS, vrc = VERR_TOO_MUCH_DATA);
+                offBuf += sizeof(GSTCTLDIRENTRYLISTHDR);
+
+                AssertBreakStmt(   pHdr->cbDirEntryEx >= RT_UOFFSETOF(GSTCTLDIRENTRYEX, szName[2])
+                                && pHdr->cbDirEntryEx <= GSTCTL_DIRENTRY_MAX_SIZE, vrc = VERR_INVALID_PARAMETER);
+                pEntry->pDirEntryEx  = (PGSTCTLDIRENTRYEX)RTMemDup((uint8_t *)pvBuf + offBuf, pHdr->cbDirEntryEx);
+                AssertPtrBreakStmt(pEntry->pDirEntryEx, vrc = VERR_NO_MEMORY);
+                pEntry->cbDirEntryEx = pHdr->cbDirEntryEx;
+                offBuf += pHdr->cbDirEntryEx;
+
+                if (pHdr->cbUser)
+                {
+                    pEntry->pszUser = (char *)RTMemDup((uint8_t *)pvBuf + offBuf, pHdr->cbUser);
+                    AssertPtrBreakStmt(pEntry->pszUser, vrc = VERR_NO_MEMORY);
+                    pEntry->cbUser  = pHdr->cbUser;
+                    offBuf += pHdr->cbUser;
+                }
+
+                if (pHdr->cbGroups)
+                {
+                    pEntry->pszGroups = (char *)RTMemDup((uint8_t *)pvBuf + offBuf, pHdr->cbGroups);
+                    AssertPtrBreakStmt(pEntry->pszGroups, vrc = VERR_NO_MEMORY);
+                    pEntry->cbGroups  = pHdr->cbGroups;
+                    offBuf += pHdr->cbGroups;
+                }
+
+#ifdef DEBUG
+                GuestFsObjData obj;
+                AssertRC(obj.FromGuestFsObjInfo(&pEntry->pDirEntryEx->Info, pEntry->pszUser, pEntry->pszGroups));
+                AssertRC(RTStrValidateEncodingEx(pEntry->pszUser,   pHdr->cbUser,   RTSTR_VALIDATE_ENCODING_ZERO_TERMINATED));
+                AssertRC(RTStrValidateEncodingEx(pEntry->pszGroups, pHdr->cbGroups, RTSTR_VALIDATE_ENCODING_ZERO_TERMINATED));
+#endif
+            }
+
+            if (RT_SUCCESS(vrc))
+            {
+                Assert(offBuf == cbBuf);
+            }
+            else /* Roll back on error. */
+            {
+               GuestDirectory::i_dirNotifyDataDestroy(&dataCb);
+            }
             break;
         }
@@ -606 +701 @@
 
 /**
- * Converts a given guest directory error to a string.
+ * Static helper function to convert a given guest directory error to a string.
  *
  * @returns Error string.
@@ -627 +722 @@
         CASE_MSG(VERR_CANT_CREATE,    tr("Guest directory \"%s\" cannot be created"), pcszWhat);
         CASE_MSG(VERR_DIR_NOT_EMPTY,  tr("Guest directory \"%s\" is not empty"), pcszWhat);
+        CASE_MSG(VERR_NO_MORE_FILES,  tr("Guest directory \"%s\" has no more entries"), pcszWhat);
+        CASE_MSG(VERR_PATH_NOT_FOUND, tr("Path of guest directory \"%s\" not found"), pcszWhat);
         default:
             strErr.printf(tr("Error %Rrc for guest directory \"%s\" occurred\n"), vrcGuest, pcszWhat);
@@ -635 +732 @@
 
     return strErr;
+}
+
+/**
+ * Static helper function to destroy direction notification callback data.
+ *
+ * @param   pDirNotify          Pointer to direction notification callback data to destroy.
+ */
+/* static */
+void GuestDirectory::i_dirNotifyDataDestroy(PCALLBACKDATA_DIR_NOTIFY pDirNotify)
+{
+    if (!pDirNotify)
+        return;
+
+    switch (pDirNotify->uType)
+    {
+        case GUEST_DIR_NOTIFYTYPE_LIST:
+        {
+            for (uint32_t i = 0; i < pDirNotify->u.list.cEntries; i++)
+            {
+                PCALLBACKDATA_DIR_ENTRY const pEntry = pDirNotify->u.list.paEntries[i];
+                AssertPtrBreak(pEntry);
+                RTStrFree(pEntry->pszUser);
+                RTStrFree(pEntry->pszGroups);
+                RTMemFree(pEntry->pDirEntryEx);
+                RTMemFree(pEntry);
+            }
+            RTMemFree(pDirNotify->u.list.paEntries);
+            pDirNotify->u.list.paEntries = NULL;
+            pDirNotify->u.list.cEntries  = 0;
+            break;
+        }
+
+        default:
+            break;
+    }
 }
 
@@ -745 +877 @@
  * Reads the next directory entry, internal version.
  *
- * @return VBox status code. Will return VERR_NO_MORE_FILES if no more entries are available.
+ * @return VBox status code.
+ * @retval VERR_GSTCTL_GUEST_ERROR / VERR_NO_MORE_FILES if no more entries are available.
  * @param  objData              Where to store the read directory entry as internal object data.
  * @param  pvrcGuest            Where to store the guest result code in case VERR_GSTCTL_GUEST_ERROR is returned.
@@ -790 +923 @@
                 {
                     AssertReturn(pDirNotify->uType == GUEST_DIR_NOTIFYTYPE_READ, VERR_INVALID_PARAMETER);
-                    AssertPtrReturn(pDirNotify->u.read.pEntry, VERR_INVALID_POINTER);
-                    objData.Init(pDirNotify->u.read.pEntry->szName);
-                    vrc = objData.FromGuestFsObjInfo(&pDirNotify->u.read.pEntry->Info,
-                                                     pDirNotify->u.read.pszUser, pDirNotify->u.read.pszGroups);
-                    RTMemFree(pDirNotify->u.read.pEntry);
-                    RTStrFree(pDirNotify->u.read.pszUser);
-                    RTStrFree(pDirNotify->u.read.pszGroups);
+                    AssertPtrReturn(pDirNotify->u.read.Entry.pDirEntryEx, VERR_INVALID_POINTER);
+                    objData.Init(pDirNotify->u.read.Entry.pDirEntryEx->szName);
+                    vrc = objData.FromGuestFsObjInfo(&pDirNotify->u.read.Entry.pDirEntryEx->Info,
+                                                     pDirNotify->u.read.Entry.pszUser, pDirNotify->u.read.Entry.pszGroups);
+                    RTMemFree(pDirNotify->u.read.Entry.pDirEntryEx);
+                    RTStrFree(pDirNotify->u.read.Entry.pszUser);
+                    RTStrFree(pDirNotify->u.read.Entry.pszGroups);
                 }
                 else
                 {
-                    if (pvrcGuest)
-                        *pvrcGuest = vrcGuest;
+                    *pvrcGuest = vrcGuest;
                     vrc = VERR_GSTCTL_GUEST_ERROR;
                 }
@@ -851 +983 @@
                 }
                 else
+                {
+#ifdef DEBUG
+                    curBlock.DumpToLog();
+#endif
                     vrc = VERR_PATH_NOT_FOUND;
+                }
             }
             else
@@ -866 +1003 @@
 
 /**
+ * Worker for listing the next directory entries.
+ *
+ * @return VBox status code.
+ * @retval VERR_GSTCTL_GUEST_ERROR / VERR_NO_MORE_FILES if no more entries are available after this iteration.
+ *         \a vecObjData will contain the rest of the entries then (if any).
+ * @param  cMaxEntries          How many directory entries to read at max.
+ * @param  fFlags               Flags of type GSTCTL_DIRLIST_F_XXX.
+ * @param  vecObjData           Where to store the read directory entries on success.
+ * @param  pvrcGuest            Where to store the guest result code in case VERR_GSTCTL_GUEST_ERROR is returned.
+ */
+int GuestDirectory::i_listInternal(uint32_t cMaxEntries, uint32_t fFlags, std::vector<GuestFsObjData> &vecObjData, int *pvrcGuest)
+{
+    int vrc;
+
+#ifdef VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS
+    if (mSession->i_getParent()->i_getGuestControlFeatures0() & VBOX_GUESTCTRL_GF_0_TOOLBOX_AS_CMDS)
+    {
+        GuestWaitEvent *pEvent = NULL;
+        GuestEventTypes eventTypes;
+        try
+        {
+            vrc = registerWaitEvent(eventTypes, &pEvent);
+        }
+        catch (std::bad_alloc &)
+        {
+            vrc = VERR_NO_MEMORY;
+        }
+
+        if (RT_FAILURE(vrc))
+            return vrc;
+
+        /* Prepare HGCM call. */
+        VBOXHGCMSVCPARM paParms[4];
+        int i = 0;
+        HGCMSvcSetU32(&paParms[i++], pEvent->ContextID());
+        HGCMSvcSetU32(&paParms[i++], mObjectID /* Directory handle */);
+        HGCMSvcSetU32(&paParms[i++], cMaxEntries);
+        HGCMSvcSetU32(&paParms[i++], 0 /* Flags */);
+
+        vrc = sendMessage(HOST_MSG_DIR_LIST, i, paParms);
+        if (RT_SUCCESS(vrc))
+        {
+            vrc = pEvent->Wait(30 * 1000);
+            if (RT_SUCCESS(vrc))
+            {
+                PCALLBACKDATA_DIR_NOTIFY const pDirNotify = (PCALLBACKDATA_DIR_NOTIFY)pEvent->Payload().Raw();
+                AssertPtrReturn(pDirNotify, VERR_INVALID_POINTER);
+                int vrcGuest = (int)pDirNotify->rc;
+                if (   RT_SUCCESS(vrcGuest)
+                    /* Guest indicates that there are no more entries to read.
+                     * We still need to check if we have read something with this iteration though. */
+                    || vrcGuest == VERR_NO_MORE_FILES)
+                {
+                    AssertReturn(pDirNotify->uType == GUEST_DIR_NOTIFYTYPE_LIST, VERR_INVALID_PARAMETER);
+
+                    try
+                    {
+                        vecObjData.resize(pDirNotify->u.list.cEntries);
+                    }
+                    catch (std::bad_alloc &)
+                    {
+                        vrc = VERR_NO_MEMORY;
+                    }
+
+                    if (RT_SUCCESS(vrc))
+                    {
+                        for (size_t a = 0; a < pDirNotify->u.list.cEntries; a++)
+                        {
+                            PCALLBACKDATA_DIR_ENTRY const pEntry = pDirNotify->u.list.paEntries[a];
+                            AssertPtr(pEntry);
+
+                            AssertPtr(pEntry->pDirEntryEx);
+                            vecObjData[a].Init(pEntry->pDirEntryEx->szName);
+                            int vrc2 = vecObjData[a].FromGuestFsObjInfo(&pEntry->pDirEntryEx->Info, pEntry->pszUser, pEntry->pszGroups);
+                            if (RT_SUCCESS(vrc))
+                                vrc = vrc2;
+                        }
+                    }
+                }
+                else
+                {
+                    *pvrcGuest = vrcGuest;
+                    vrc = VERR_GSTCTL_GUEST_ERROR;
+                }
+
+                GuestDirectory::i_dirNotifyDataDestroy(pDirNotify);
+            }
+            else if (pEvent->HasGuestError())
+                *pvrcGuest = pEvent->GuestResult();
+        }
+    }
+    else
+#endif /* VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS */
+    {
+        RT_NOREF(cMaxEntries, fFlags, vecObjData, pvrcGuest);
+        vrc = VERR_NOT_SUPPORTED;
+    }
+
+    return vrc;
+}
+
+/**
+ * Lists the next directory entries.
+ *
+ * @return VBox status code.
+ * @retval VERR_GSTCTL_GUEST_ERROR / VERR_NO_MORE_FILES if no more entries are available after this iteration.
+ *         \a vecObjData will contain the rest of the entries then (if any).
+ * @param  cMaxEntries          How many directory entries to read at max.
+ * @param  fFlags               Flags of type GSTCTL_DIRLIST_F_XXX.
+ * @param  vecObjInfo           Where to store the read directory entries on success.
+ * @param  pvrcGuest            Where to store the guest result code in case VERR_GSTCTL_GUEST_ERROR is returned.
+ */
+int GuestDirectory::i_listEx(uint32_t cMaxEntries, uint32_t fFlags, std::vector<ComObjPtr<GuestFsObjInfo>> &vecObjInfo,
+                             int *pvrcGuest)
+{
+    AssertPtrReturn(pvrcGuest, VERR_INVALID_POINTER);
+    AssertReturn(!(fFlags & ~GSTCTL_DIRLIST_F_VALID_MASK), VERR_INVALID_PARAMETER);
+
+    std::vector<GuestFsObjData> vecObjDataInt;
+    int vrc = i_listInternal(cMaxEntries, fFlags, vecObjDataInt, pvrcGuest);
+    if (   RT_SUCCESS(vrc)
+        || (     vrc       == VERR_GSTCTL_GUEST_ERROR
+             && *pvrcGuest == VERR_NO_MORE_FILES))
+    {
+        try
+        {
+            vecObjInfo.resize(vecObjDataInt.size());
+            for (size_t i = 0; i < vecObjDataInt.size(); i++)
+            {
+                HRESULT hrc = vecObjInfo[i].createObject();
+                ComAssertComRCBreak(hrc, vrc = VERR_COM_UNEXPECTED);
+
+                vrc = vecObjInfo[i]->init(vecObjDataInt[i]);
+                if (RT_FAILURE(vrc))
+                    break;
+            }
+        }
+        catch (std::bad_alloc &)
+        {
+            vrc = VERR_NO_MEMORY;
+        }
+    }
+
+    return vrc;
+}
+
+/**
+ * Lists the next directory entries.
+ *
+ * @return VBox status code.
+ * @retval VERR_GSTCTL_GUEST_ERROR / VERR_NO_MORE_FILES if no more entries are available after this iteration.
+ *         \a vecObjData will contain the rest of the entries then (if any).
+ * @param  cMaxEntries          How many directory entries to read at max.
+ * @param  vecObjInfo           Where to store the read directory entries on success.
+ * @param  pvrcGuest            Where to store the guest result code in case VERR_GSTCTL_GUEST_ERROR is returned.
+ */
+int GuestDirectory::i_list(uint32_t cMaxEntries, std::vector<ComObjPtr<GuestFsObjInfo>> &vecObjInfo, int *pvrcGuest)
+{
+    return i_listEx(cMaxEntries, GSTCTL_DIRLIST_F_NONE, vecObjInfo, pvrcGuest);
+}
+
+/**
  * Reads the next directory entry.
  *
- * @return VBox status code. Will return VERR_NO_MORE_FILES if no more entries are available.
+ * @return VBox status code.
+ * @retval VERR_GSTCTL_GUEST_ERROR / VERR_NO_MORE_FILES if no more entries are available.
  * @param  fsObjInfo            Where to store the read directory entry.
  * @param  pvrcGuest            Where to store the guest result code in case VERR_GSTCTL_GUEST_ERROR is returned.
@@ -894 +1194 @@
     else /* Otherwise ask the guest for the next object data. */
     {
-
         GuestFsObjData objData;
         vrc = i_readInternal(objData, pvrcGuest);
@@ -1124 +1423 @@
 }
 
+HRESULT GuestDirectory::list(ULONG aMaxEntries, std::vector<ComPtr<IFsObjInfo> > &aObjInfos)
+{
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.hrc())) return autoCaller.hrc();
+
+    LogFlowThisFuncEnter();
+
+    HRESULT hrc = S_OK;
+
+    std::vector<ComObjPtr<GuestFsObjInfo> > vecObjInfo;
+    int vrcGuest = VERR_IPE_UNINITIALIZED_STATUS;
+    int vrc = i_list(aMaxEntries, vecObjInfo, &vrcGuest);
+
+    /* Don't propagate an error to API callers when this is the last listing (i.e. no more files).
+     * For subsequent reads the API caller gets an appropriate error then. */
+    if (    vrc      == VERR_GSTCTL_GUEST_ERROR
+         && vrcGuest == VERR_NO_MORE_FILES
+         && vecObjInfo.size())
+            vrc = VINF_SUCCESS;
+
+    if (RT_SUCCESS(vrc))
+    {
+        try
+        {
+            aObjInfos.resize(vecObjInfo.size());
+
+            for (size_t i = 0; i < vecObjInfo.size(); i++)
+            {
+                hrc = vecObjInfo[i].queryInterfaceTo(aObjInfos[i].asOutParam());
+                ComAssertComRCBreakRC(hrc);
+            }
+        }
+        catch (std::bad_alloc &)
+        {
+            hrc = E_OUTOFMEMORY;
+        }
+    }
+    else
+    {
+        switch (vrc)
+        {
+            case VERR_GSTCTL_GUEST_ERROR:
+            {
+                GuestErrorInfo ge(GuestErrorInfo::Type_Directory, vrcGuest, mData.mOpenInfo.mPath.c_str());
+                hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrcGuest, tr("Listing guest directory failed: %s"),
+                                   GuestBase::getErrorAsString(ge).c_str());
+
+                /* Return a dedicated error code when directory reading is done. See SDK reference. */
+                if (vrcGuest == VERR_NO_MORE_FILES)
+                    hrc = VBOX_E_OBJECT_NOT_FOUND;
+                break;
+            }
+
+            default:
+                hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Listing guest directory \"%s\" returned unhandled error: %Rrc\n"),
+                                   mData.mOpenInfo.mPath.c_str(), vrc);
+                break;
+        }
+    }
+
+    LogFlowThisFunc(("Returning hrc=%Rhrc / vrc=%Rrc\n", hrc, vrc));
+    return hrc;
+}
+
 HRESULT GuestDirectory::read(ComPtr<IFsObjInfo> &aObjInfo)
 {
@@ -1151 +1514 @@
                                   GuestErrorInfo::Type_ToolLs
 #else
-                                  GuestErrorInfo::Type_Fs
+                                  GuestErrorInfo::Type_Directory
 #endif
                 , vrcGuest, mData.mOpenInfo.mPath.c_str());
                 hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrcGuest, tr("Reading guest directory failed: %s"),
                                    GuestBase::getErrorAsString(ge).c_str());
+
+                /* Return a dedicated error code when directory reading is done. See SDK reference. */
+                if (vrcGuest == VERR_NO_MORE_FILES)
+                    hrc = VBOX_E_OBJECT_NOT_FOUND;
                 break;
             }
@@ -1164 +1531 @@
                                    mData.mOpenInfo.mPath.c_str(), mData.mProcessTool.getRc());
                 break;
-#endif
+
             case VERR_PATH_NOT_FOUND:
                 hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Reading guest directory \"%s\" failed: Path not found"),
@@ -1175 +1542 @@
                                    mData.mOpenInfo.mPath.c_str());
                 break;
-
+#endif
             default:
                 hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Reading guest directory \"%s\" returned unhandled error: %Rrc\n"),

trunk/src/VBox/ValidationKit/tests/additions/tdAddGuestCtrl.py

@@ -2024 +2024 @@
         return True;
 
-    def gctrlReadDirTree(self, oTest, oGuestSession, fIsError, sSubDir = None):
+    def gctrlReadDirTree(self, oTest, oGuestSession, fIsError, fUseDirList = False, cEntriesPerRead = 0, sSubDir = None):
         """
         Helper function to recursively read a guest directory tree specified in the current test.
@@ -2039 +2039 @@
         cOthers  = 0;    # Other files.
 
+        cEntriesToRead = cEntriesPerRead; # Only used when listing directories.
+        aFsObjInfo     = [];
+
         # Open the directory:
-        reporter.log2('Directory="%s", filter="%s", afFlags="%s"' % (limitString(sCurDir), sFilter, afFlags));
+        reporter.log2('Directory="%s", filter="%s", afFlags="%s", fUseDirList=%s, cEntriesPerRead=%d'
+                      % (limitString(sCurDir), sFilter, afFlags, fUseDirList, cEntriesPerRead));
         try:
             oCurDir = oGuestSession.directoryOpen(sCurDir, sFilter, afFlags);
@@ -2048 +2052 @@
 
         # Read the directory.
+        fDone = False;
         while fRc is True:
+            reporter.log3('Reading next batch ...');
+            aFsObjInfo = [];
             try:
-                oFsObjInfo = oCurDir.read();
+                if not fUseDirList:
+                    aFsObjInfo.append(oCurDir.read());
+                else:
+                    if not cEntriesToRead:
+                        cEntriesToRead = random.randrange(1, 32768);
+                    aFsObjInfo = oCurDir.list(cEntriesToRead);
             except Exception as oXcpt:
                 if vbox.ComError.notEqual(oXcpt, vbox.ComError.VBOX_E_OBJECT_NOT_FOUND):
-                    if self.oTstDrv.fpApiVer > 5.2:
-                        reporter.errorXcpt('Error reading directory "%s":' % (sCurDir,));
+                    if fUseDirList:
+                        fRc = reporter.errorXcpt('Error listing directory "%s" (cEntriesToRead=%d):' % (sCurDir, cEntriesToRead));
                     else:
-                        # Unlike fileOpen, directoryOpen will not fail if the directory does not exist.
-                        reporter.maybeErrXcpt(fIsError, 'Error reading directory "%s":' % (sCurDir,));
+                        if self.oTstDrv.fpApiVer > 5.2:
+                            reporter.errorXcpt('Error reading directory "%s":' % (sCurDir,));
+                        else:
+                            # Unlike fileOpen, directoryOpen will not fail if the directory does not exist.
+                            reporter.maybeErrXcpt(fIsError, 'Error reading directory "%s":' % (sCurDir,));
                     fRc = False;
                 else:
                     reporter.log2('\tNo more directory entries for "%s"' % (limitString(sCurDir),));
+                    fDone = True;
                 break;
 
-            try:
-                sName = oFsObjInfo.name;
-                eType = oFsObjInfo.type;
-            except:
-                fRc = reporter.errorXcpt();
+            if fDone or not fRc: # Abort reading?
                 break;
 
-            if sName in ('.', '..', ):
-                if eType != vboxcon.FsObjType_Directory:
-                    fRc = reporter.error('Wrong type for "%s": %d, expected %d (Directory)'
-                                         % (sName, eType, vboxcon.FsObjType_Directory));
-            elif eType == vboxcon.FsObjType_Directory:
-                reporter.log2('  Directory "%s"' % limitString(oFsObjInfo.name));
-                aSubResult = self.gctrlReadDirTree(oTest, oGuestSession, fIsError,
-                                                   oTestVm.pathJoin(sSubDir, sName) if sSubDir else sName);
-                fRc      = aSubResult[0];
-                cDirs   += aSubResult[1] + 1;
-                cFiles  += aSubResult[2];
-                cOthers += aSubResult[3];
-            elif eType is vboxcon.FsObjType_File:
-                reporter.log4('  File "%s"' % oFsObjInfo.name);
-                cFiles += 1;
-            elif eType is vboxcon.FsObjType_Symlink:
-                reporter.log4('  Symlink "%s" -- not tested yet' % oFsObjInfo.name);
-                cOthers += 1;
-            elif    oTestVm.isWindows() \
-                 or oTestVm.isOS2() \
-                 or eType not in (vboxcon.FsObjType_Fifo, vboxcon.FsObjType_DevChar, vboxcon.FsObjType_DevBlock,
-                                  vboxcon.FsObjType_Socket, vboxcon.FsObjType_WhiteOut):
-                fRc = reporter.error('Directory "%s" contains invalid directory entry "%s" (type %d)' %
-                                     (sCurDir, oFsObjInfo.name, oFsObjInfo.type,));
-            else:
-                cOthers += 1;
+            reporter.log3('Processing next batch (%d items)...' % (len(aFsObjInfo)));
+            for oFsObjInfo in aFsObjInfo:
+                try:
+                    sName = oFsObjInfo.name;
+                    eType = oFsObjInfo.type;
+                except:
+                    fRc = reporter.errorXcpt();
+                    break;
+
+                if sName in ('.', '..', ):
+                    if eType != vboxcon.FsObjType_Directory:
+                        fRc = reporter.error('Wrong type for "%s": %d, expected %d (Directory)'
+                                            % (sName, eType, vboxcon.FsObjType_Directory));
+                elif eType == vboxcon.FsObjType_Directory:
+                    reporter.log2('  Directory "%s"' % limitString(oFsObjInfo.name));
+                    aSubResult = self.gctrlReadDirTree(oTest, oGuestSession, fIsError,
+                                                       fUseDirList, cEntriesPerRead,
+                                                       oTestVm.pathJoin(sSubDir, sName) if sSubDir else sName);
+                    fRc      = aSubResult[0];
+                    cDirs   += aSubResult[1] + 1;
+                    cFiles  += aSubResult[2];
+                    cOthers += aSubResult[3];
+                elif eType is vboxcon.FsObjType_File:
+                    reporter.log4('  File "%s"' % oFsObjInfo.name);
+                    cFiles += 1;
+                elif eType is vboxcon.FsObjType_Symlink:
+                    reporter.log4('  Symlink "%s" -- not tested yet' % oFsObjInfo.name);
+                    cOthers += 1;
+                elif    oTestVm.isWindows() \
+                    or oTestVm.isOS2() \
+                    or eType not in (vboxcon.FsObjType_Fifo, vboxcon.FsObjType_DevChar, vboxcon.FsObjType_DevBlock,
+                                    vboxcon.FsObjType_Socket, vboxcon.FsObjType_WhiteOut):
+                    fRc = reporter.error('Directory "%s" contains invalid directory entry "%s" (type %d)' %
+                                        (sCurDir, oFsObjInfo.name, oFsObjInfo.type,));
+                else:
+                    cOthers += 1;
 
         # Close the directory
@@ -2105 +2127 @@
         return (fRc, cDirs, cFiles, cOthers);
 
-    def gctrlReadDirTree2(self, oGuestSession, oDir): # type: (testfileset.TestDir) -> bool
+    def gctrlReadDirTree2(self, oGuestSession, oDir, fUseDirList = False, cEntriesPerRead = 0): # type: (testfileset.TestDir) -> bool
         """
         Helper function to recursively read a guest directory tree specified in the current test.
@@ -2121 +2143 @@
 
         # Read the directory.
-        dLeftUpper = dict(oDir.dChildrenUpper);
-        cDot       = 0;
-        cDotDot    = 0;
-        fRc = True;
+        dLeftUpper     = dict(oDir.dChildrenUpper);
+        cDot           = 0;
+        cDotDot        = 0;
+        fRc            = True;
+        cEntriesToRead = cEntriesPerRead; # Only used when listing directories.
+        aFsObjInfo     = [];
         while True:
+            reporter.log3('Reading next batch ...');
+            aFsObjInfo = [];
             try:
-                oFsObjInfo = oCurDir.read();
+                if not fUseDirList:
+                    aFsObjInfo.append(oCurDir.read());
+                else:
+                    if not cEntriesToRead:
+                        cEntriesToRead = random.randrange(1, 32768);
+                    aFsObjInfo = oCurDir.list(cEntriesToRead);
             except Exception as oXcpt:
                 if vbox.ComError.notEqual(oXcpt, vbox.ComError.VBOX_E_OBJECT_NOT_FOUND):
-                    fRc = reporter.errorXcpt('Error reading directory "%s":' % (oDir.sPath,));
+                    if fUseDirList:
+                        fRc = reporter.errorXcpt('Error listing directory "%s" (cEntriesToRead=%d):' % (oDir.sPath, cEntriesToRead));
+                    else:
+                        fRc = reporter.errorXcpt('Error reading directory "%s":' % (oDir.sPath));
+                else:
+                    reporter.log2('\tNo more directory entries for "%s"' % (limitString(oDir.sPath),));
                 break;
 
-            try:
-                sName  = oFsObjInfo.name;
-                eType  = oFsObjInfo.type;
-                cbFile = oFsObjInfo.objectSize;
-                ## @todo check further attributes.
-            except:
-                fRc = reporter.errorXcpt();
-                break;
-
-            # '.' and '..' entries are not present in oDir.aoChildren, so special treatment:
-            if sName in ('.', '..', ):
-                if eType != vboxcon.FsObjType_Directory:
-                    fRc = reporter.error('Wrong type for "%s": %d, expected %d (Directory)'
-                                         % (sName, eType, vboxcon.FsObjType_Directory));
-                if sName == '.': cDot    += 1;
-                else:            cDotDot += 1;
-            else:
-                # Find the child and remove it from the dictionary.
-                sNameUpper = sName.upper();
-                oFsObj = dLeftUpper.get(sNameUpper);
-                if oFsObj is None:
-                    fRc = reporter.error('Unknown object "%s" found in "%s" (type %s, size %s)!'
-                                         % (sName, oDir.sPath, eType, cbFile,));
+            reporter.log3('Processing next batch (%d items)...' % (len(aFsObjInfo)));
+            for oFsObjInfo in aFsObjInfo:
+                try:
+                    sName  = oFsObjInfo.name;
+                    eType  = oFsObjInfo.type;
+                    cbFile = oFsObjInfo.objectSize;
+                    ## @todo check further attributes.
+                except:
+                    fRc = reporter.errorXcpt();
+                    break;
+
+                # '.' and '..' entries are not present in oDir.aoChildren, so special treatment:
+                if sName in ('.', '..', ):
+                    if eType != vboxcon.FsObjType_Directory:
+                        fRc = reporter.error('Wrong type for "%s": %d, expected %d (Directory)'
+                                            % (sName, eType, vboxcon.FsObjType_Directory));
+                    if sName == '.': cDot    += 1;
+                    else:            cDotDot += 1;
                 else:
-                    del dLeftUpper[sNameUpper];
-
-                    # Check type
-                    if isinstance(oFsObj, testfileset.TestDir):
-                        if eType != vboxcon.FsObjType_Directory:
-                            fRc = reporter.error('%s: expected directory (%d), got eType=%d!'
-                                                 % (oFsObj.sPath, vboxcon.FsObjType_Directory, eType,));
-                    elif isinstance(oFsObj, testfileset.TestFile):
-                        if eType != vboxcon.FsObjType_File:
-                            fRc = reporter.error('%s: expected file (%d), got eType=%d!'
-                                                 % (oFsObj.sPath, vboxcon.FsObjType_File, eType,));
+                    # Find the child and remove it from the dictionary.
+                    sNameUpper = sName.upper();
+                    oFsObj = dLeftUpper.get(sNameUpper);
+                    if oFsObj is None:
+                        fRc = reporter.error('Unknown object "%s" found in "%s" (type %s, size %s)!'
+                                            % (sName, oDir.sPath, eType, cbFile,));
                     else:
-                        fRc = reporter.error('%s: WTF? type=%s' % (oFsObj.sPath, type(oFsObj),));
-
-                    # Check the name.
-                    if oFsObj.sName != sName:
-                        fRc = reporter.error('%s: expected name "%s", got "%s" instead!' % (oFsObj.sPath, oFsObj.sName, sName,));
-
-                    # Check the size if a file.
-                    if isinstance(oFsObj, testfileset.TestFile) and cbFile != oFsObj.cbContent:
-                        fRc = reporter.error('%s: expected size %s, got %s instead!' % (oFsObj.sPath, oFsObj.cbContent, cbFile,));
-
-                    ## @todo check timestamps and attributes.
+                        del dLeftUpper[sNameUpper];
+
+                        # Check type
+                        if isinstance(oFsObj, testfileset.TestDir):
+                            if eType != vboxcon.FsObjType_Directory:
+                                fRc = reporter.error('%s: expected directory (%d), got eType=%d!'
+                                                    % (oFsObj.sPath, vboxcon.FsObjType_Directory, eType,));
+                        elif isinstance(oFsObj, testfileset.TestFile):
+                            if eType != vboxcon.FsObjType_File:
+                                fRc = reporter.error('%s: expected file (%d), got eType=%d!'
+                                                    % (oFsObj.sPath, vboxcon.FsObjType_File, eType,));
+                        else:
+                            fRc = reporter.error('%s: WTF? type=%s' % (oFsObj.sPath, type(oFsObj),));
+
+                        # Check the name.
+                        if oFsObj.sName != sName:
+                            fRc = reporter.error('%s: expected name "%s", got "%s" instead!' % (oFsObj.sPath, oFsObj.sName, sName,));
+
+                        # Check the size if a file.
+                        if isinstance(oFsObj, testfileset.TestFile) and cbFile != oFsObj.cbContent:
+                            fRc = reporter.error('%s: expected size %s, got %s instead!' % (oFsObj.sPath, oFsObj.cbContent, cbFile,));
+
+                        ## @todo check timestamps and attributes.
 
         # Close the directory
@@ -2203 +2241 @@
         for oFsObj in oDir.aoChildren:
             if isinstance(oFsObj, testfileset.TestDir):
-                fRc = self.gctrlReadDirTree2(oGuestSession, oFsObj) and fRc;
+                fRc = self.gctrlReadDirTree2(oGuestSession, oFsObj, fUseDirList, cEntriesPerRead) and fRc;
 
         return fRc;
@@ -3823 +3861 @@
             if fRc is not True:
                 break;
-            (fRc2, cDirs, cFiles, cOthers) = self.gctrlReadDirTree(oCurTest, oCurGuestSession, oCurRes.fRc);
+            fUseDirList = False;
+            cEntriesPerRead = random.randrange(1, 32768);
+            if self.oTstDrv.fpApiVer >= 7.1: # Listing directories only is available for >= VBox 7.1.
+                fUseDirList = random.choice( [True, False] );
+            (fRc2, cDirs, cFiles, cOthers) = self.gctrlReadDirTree(oCurTest, oCurGuestSession, oCurRes.fRc,
+                                                                   fUseDirList, cEntriesPerRead);
             fRc = oCurTest.closeSession() and fRc;
 
@@ -3867 +3910 @@
                 for oDir in (self.oTestFiles.oEmptyDir, self.oTestFiles.oManyDir, self.oTestFiles.oTreeDir):
                     reporter.log('Checking "%s" ...' % (oDir.sPath,));
-                    fRc = self.gctrlReadDirTree2(oCurGuestSession, oDir) and fRc;
+                    fUseDirList = False;
+                    cEntriesPerRead = random.randrange(1, 32768);
+                    if self.oTstDrv.fpApiVer >= 7.1: # Listing directories only is available for >= VBox 7.1.
+                        fUseDirList = random.choice( [True, False] );
+                    fRc = self.gctrlReadDirTree2(oCurGuestSession, oDir, fUseDirList, cEntriesPerRead) and fRc;
                 fRc = oCurTest.closeSession() and fRc;