Changeset 99085 in vbox for trunk/src/VBox/Additions/common

Timestamp:

Mar 21, 2023 12:15:00 PM (23 months ago)

Author:

vboxsync

Message:

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

Location:

trunk/src/VBox/Additions/common

Files:

• VBoxGuest/lib/VBoxGuestR3LibGuestCtrl.cpp (modified) (3 diffs)
• VBoxService/VBoxServiceControl.h (modified) (2 diffs)
• VBoxService/VBoxServiceControlSession.cpp (modified) (8 diffs)

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