Changeset 79672 in vbox for trunk/src/VBox/HostServices/SharedClipboard

Timestamp:

Jul 10, 2019 1:02:50 PM (6 years ago)

Author:

vboxsync

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

131985

Message:

Shared Clipboard/URI: More code for root entries handling.

Location:

trunk/src/VBox/HostServices/SharedClipboard

Files:

• VBoxSharedClipboardSvc-uri.cpp (modified) (5 diffs)
• VBoxSharedClipboardSvc.cpp (modified) (2 diffs)

trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-uri.cpp

@@ -73 +73 @@
 }
 
+DECLCALLBACK(int) vboxSvcClipboardURIGetRoots(PSHAREDCLIPBOARDPROVIDERCTX pCtx,
+                                              char **ppapszRoots, uint32_t *pcRoots)
+{
+    LogFlowFuncEnter();
+
+    PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pCtx->pvUser;
+    AssertPtr(pClient);
+
+    int rc;
+
+    size_t   cbRootsRecv = 0;
+
+    char    *pszRoots = NULL;
+    uint32_t cRoots   = 0;
+
+    /* There might be more than one message needed for retrieving all root items. */
+    for (;;)
+    {
+        PVBOXCLIPBOARDCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOTS,
+                                                                VBOX_SHARED_CLIPBOARD_CPARMS_ROOTS);
+        if (pMsg)
+        {
+            HGCMSvcSetU32(&pMsg->m_paParms[0], 0 /* uContextID */);
+            HGCMSvcSetU32(&pMsg->m_paParms[1], 0 /* fRoots */);
+            HGCMSvcSetU32(&pMsg->m_paParms[2], 0 /* fMore */);
+            HGCMSvcSetU32(&pMsg->m_paParms[3], 0 /* cRoots */);
+
+            uint32_t  cbData = _64K;
+            void     *pvData = RTMemAlloc(cbData);
+            AssertPtrBreakStmt(pvData, rc = VERR_NO_MEMORY);
+
+            HGCMSvcSetU32(&pMsg->m_paParms[4], cbData);
+            HGCMSvcSetPv (&pMsg->m_paParms[5], pvData, cbData);
+
+            rc = vboxSvcClipboardMsgAdd(pClient->pData, pMsg, true /* fAppend */);
+            if (RT_SUCCESS(rc))
+            {
+                int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer,
+                                                                  SHAREDCLIPBOARDURITRANSFEREVENTTYPE_GET_ROOTS);
+                AssertRC(rc2);
+
+                vboxSvcClipboardClientWakeup(pClient);
+            }
+        }
+        else
+            rc = VERR_NO_MEMORY;
+
+        if (RT_SUCCESS(rc))
+        {
+            PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
+            rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_GET_ROOTS,
+                                                     30 * 1000 /* Timeout in ms */, &pPayload);
+            if (RT_SUCCESS(rc))
+            {
+                PVBOXCLIPBOARDROOTS pRoots = (PVBOXCLIPBOARDROOTS)pPayload->pvData;
+                Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDROOTS));
+
+                LogFlowFunc(("cbRoots=%RU32, fRoots=%RU32, fMore=%RTbool\n", pRoots->cbRoots, pRoots->fRoots, pRoots->fMore));
+
+                if (!pRoots->cbRoots)
+                    break;
+                AssertPtr(pRoots->pszRoots);
+
+                if (pszRoots == NULL)
+                    pszRoots = (char *)RTMemDup((void *)pRoots->pszRoots, pRoots->cbRoots);
+                else
+                    pszRoots = (char *)RTMemRealloc(pszRoots, cbRootsRecv + pRoots->cbRoots);
+
+                AssertPtrBreakStmt(pszRoots, rc = VERR_NO_MEMORY);
+
+                cbRootsRecv += pRoots->cbRoots;
+
+                if (cbRootsRecv > _32M) /* Don't allow more than 32MB root entries for now. */
+                {
+                    rc = VERR_ALLOCATION_TOO_BIG; /** @todo Find a better rc. */
+                    break;
+                }
+
+                cRoots += pRoots->cRoots;
+
+                const bool fDone = !RT_BOOL(pRoots->fMore); /* More root entries to be retrieved? Otherwise bail out. */
+
+                SharedClipboardURITransferPayloadFree(pPayload);
+
+                if (fDone)
+                    break;
+            }
+        }
+
+        if (RT_FAILURE(rc))
+            break;
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        LogFlowFunc(("cRoots=%RU32\n", cRoots));
+
+        *ppapszRoots = pszRoots;
+        *pcRoots     = cRoots;
+    }
+    else
+    {
+        RTMemFree(pszRoots);
+        pszRoots = NULL;
+    }
+
+    LogFlowFuncLeave();
+    return rc;
+}
+
 DECLCALLBACK(int) vboxSvcClipboardURIListOpen(PSHAREDCLIPBOARDPROVIDERCTX pCtx,
                                               PVBOXCLIPBOARDLISTOPENPARMS pOpenParms, PSHAREDCLIPBOARDLISTHANDLE phList)
@@ -403 +513 @@
                     break;
             }
+        }
+    }
+    else
+        rc = VERR_INVALID_PARAMETER;
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+int VBoxSvcClipboardURIGetRoots(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
+                                PVBOXCLIPBOARDROOTS pRoots)
+{
+    int rc;
+
+    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_ROOTS)
+    {
+        /* Note: Context ID (paParms[0]) not used yet. */
+        rc = HGCMSvcGetU32(&paParms[1], &pRoots->fRoots);
+        if (RT_SUCCESS(rc))
+        {
+            uint32_t fMore;
+            rc = HGCMSvcGetU32(&paParms[2], &fMore);
+            if (RT_SUCCESS(rc))
+                pRoots->fMore = RT_BOOL(fMore);
+        }
+        if (RT_SUCCESS(rc))
+            rc = HGCMSvcGetU32(&paParms[3], &pRoots->cRoots);
+        if (RT_SUCCESS(rc))
+        {
+            uint32_t cbRoots;
+            rc = HGCMSvcGetU32(&paParms[4], &cbRoots);
+            if (RT_SUCCESS(rc))
+                rc = HGCMSvcGetPv(&paParms[5], (void **)&pRoots->pszRoots, &pRoots->cbRoots);
+
+            AssertReturn(cbRoots == pRoots->cbRoots, VERR_INVALID_PARAMETER);
         }
     }
@@ -582 +727 @@
             rc = HGCMSvcGetU32(&paParms[2], &pListEntry->fInfo);
         if (RT_SUCCESS(rc))
-            rc = HGCMSvcGetU32(&paParms[3], &pListEntry->cbInfo);
-        if (RT_SUCCESS(rc))
-            rc = HGCMSvcGetPv(&paParms[4], &pListEntry->pvInfo, &pListEntry->cbInfo);
+            rc = HGCMSvcGetPv(&paParms[3], (void **)&pListEntry->pszName, &pListEntry->cbName);
+        if (RT_SUCCESS(rc))
+        {
+            uint32_t cbInfo;
+            rc = HGCMSvcGetU32(&paParms[4], &cbInfo);
+            if (RT_SUCCESS(rc))
+            {
+                rc = HGCMSvcGetPv(&paParms[5], &pListEntry->pvInfo, &pListEntry->cbInfo);
+                AssertReturn(cbInfo == pListEntry->cbInfo, VERR_INVALID_PARAMETER);
+            }
+        }
 
         if (RT_SUCCESS(rc))
@@ -846 +999 @@
                         if (enmDir == SHAREDCLIPBOARDURITRANSFERDIR_READ)
                         {
+                            creationCtx.Interface.pfnGetRoots      = vboxSvcClipboardURIGetRoots;
                             creationCtx.Interface.pfnListHdrRead   = vboxSvcClipboardURIListHdrRead;
                             creationCtx.Interface.pfnListEntryRead = vboxSvcClipboardURIListEntryRead;
@@ -921 +1075 @@
         {
             rc = VBoxSvcClipboardURITransferHandleReply(pClient, pTransfer, cParms, paParms);
+            break;
+        }
+
+        case VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOTS:
+        {
+            VBOXCLIPBOARDROOTS Roots;
+            rc = VBoxSvcClipboardURIGetRoots(cParms, paParms, &Roots);
+            if (RT_SUCCESS(rc))
+            {
+                void    *pvData = SharedClipboardURIRootsDup(&Roots);
+                uint32_t cbData = sizeof(VBOXCLIPBOARDROOTS);
+
+                PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
+                rc = SharedClipboardURITransferPayloadAlloc(SHAREDCLIPBOARDURITRANSFEREVENTTYPE_GET_ROOTS,
+                                                            pvData, cbData, &pPayload);
+                if (RT_SUCCESS(rc))
+                    rc = SharedClipboardURITransferEventSignal(pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_GET_ROOTS,
+                                                               pPayload);
+            }
             break;
         }

trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp

@@ -507 +507 @@
      * Return information about the first message if one is pending in the list.
      */
-    PVBOXCLIPBOARDCLIENTMSG pFirstMsg = pClient->pData->queueMsg.first();
-    if (pFirstMsg)
-    {
-        LogFlowFunc(("First message is: %RU32 %s (%RU32 parms)\n",
-                     pFirstMsg->m_uMsg, VBoxSvcClipboardHostMsgToStr(pFirstMsg->m_uMsg), pFirstMsg->m_cParms));
-
-        ASSERT_GUEST_MSG_RETURN(pFirstMsg->m_uMsg == idMsgExpected || idMsgExpected == UINT32_MAX,
-                                ("idMsg=%u (%s) cParms=%u, caller expected %u (%s) and %u\n",
-                                 pFirstMsg->m_uMsg, VBoxSvcClipboardHostMsgToStr(pFirstMsg->m_uMsg), pFirstMsg->m_uMsg,
-                                 idMsgExpected, VBoxSvcClipboardHostMsgToStr(idMsgExpected), cParms),
-                                VERR_MISMATCH);
-        ASSERT_GUEST_MSG_RETURN(pFirstMsg->m_cParms == cParms,
-                                ("idMsg=%u (%s) cParms=%u, caller expected %u (%s) and %u\n",
-                                 pFirstMsg->m_uMsg, VBoxSvcClipboardHostMsgToStr(pFirstMsg->m_uMsg), pFirstMsg->m_cParms,
-                                 idMsgExpected, VBoxSvcClipboardHostMsgToStr(idMsgExpected), cParms),
-                                VERR_WRONG_PARAMETER_COUNT);
-
-        /* Check the parameter types. */
-        for (uint32_t i = 0; i < cParms; i++)
-            ASSERT_GUEST_MSG_RETURN(pFirstMsg->m_paParms[i].type == paParms[i].type,
-                                    ("param #%u: type %u, caller expected %u (idMsg=%u %s)\n", i, pFirstMsg->m_paParms[i].type,
-                                     paParms[i].type, pFirstMsg->m_uMsg, VBoxSvcClipboardHostMsgToStr(pFirstMsg->m_uMsg)),
-                                    VERR_WRONG_PARAMETER_TYPE);
-        /*
-         * Copy out the parameters.
-         *
-         * No assertions on buffer overflows, and keep going till the end so we can
-         * communicate all the required buffer sizes.
-         */
-        int rc = VINF_SUCCESS;
-        for (uint32_t i = 0; i < cParms; i++)
-            switch (pFirstMsg->m_paParms[i].type)
-            {
-                case VBOX_HGCM_SVC_PARM_32BIT:
-                    paParms[i].u.uint32 = pFirstMsg->m_paParms[i].u.uint32;
-                    break;
-
-                case VBOX_HGCM_SVC_PARM_64BIT:
-                    paParms[i].u.uint64 = pFirstMsg->m_paParms[i].u.uint64;
-                    break;
-
-                case VBOX_HGCM_SVC_PARM_PTR:
+    if (!pClient->pData->queueMsg.isEmpty())
+    {
+        PVBOXCLIPBOARDCLIENTMSG pFirstMsg = pClient->pData->queueMsg.first();
+        if (pFirstMsg)
+        {
+            LogFlowFunc(("First message is: %RU32 %s (%RU32 parms)\n",
+                         pFirstMsg->m_uMsg, VBoxSvcClipboardHostMsgToStr(pFirstMsg->m_uMsg), pFirstMsg->m_cParms));
+
+            ASSERT_GUEST_MSG_RETURN(pFirstMsg->m_uMsg == idMsgExpected || idMsgExpected == UINT32_MAX,
+                                    ("idMsg=%u (%s) cParms=%u, caller expected %u (%s) and %u\n",
+                                     pFirstMsg->m_uMsg, VBoxSvcClipboardHostMsgToStr(pFirstMsg->m_uMsg), pFirstMsg->m_cParms,
+                                     idMsgExpected, VBoxSvcClipboardHostMsgToStr(idMsgExpected), cParms),
+                                    VERR_MISMATCH);
+            ASSERT_GUEST_MSG_RETURN(pFirstMsg->m_cParms == cParms,
+                                    ("idMsg=%u (%s) cParms=%u, caller expected %u (%s) and %u\n",
+                                     pFirstMsg->m_uMsg, VBoxSvcClipboardHostMsgToStr(pFirstMsg->m_uMsg), pFirstMsg->m_cParms,
+                                     idMsgExpected, VBoxSvcClipboardHostMsgToStr(idMsgExpected), cParms),
+                                    VERR_WRONG_PARAMETER_COUNT);
+
+            /* Check the parameter types. */
+            for (uint32_t i = 0; i < cParms; i++)
+                ASSERT_GUEST_MSG_RETURN(pFirstMsg->m_paParms[i].type == paParms[i].type,
+                                        ("param #%u: type %u, caller expected %u (idMsg=%u %s)\n", i, pFirstMsg->m_paParms[i].type,
+                                         paParms[i].type, pFirstMsg->m_uMsg, VBoxSvcClipboardHostMsgToStr(pFirstMsg->m_uMsg)),
+                                        VERR_WRONG_PARAMETER_TYPE);
+            /*
+             * Copy out the parameters.
+             *
+             * No assertions on buffer overflows, and keep going till the end so we can
+             * communicate all the required buffer sizes.
+             */
+            int rc = VINF_SUCCESS;
+            for (uint32_t i = 0; i < cParms; i++)
+                switch (pFirstMsg->m_paParms[i].type)
                 {
-                    uint32_t const cbSrc = pFirstMsg->m_paParms[i].u.pointer.size;
-                    uint32_t const cbDst = paParms[i].u.pointer.size;
-                    paParms[i].u.pointer.size = cbSrc; /** @todo Check if this is safe in other layers...
-                                                        * Update: Safe, yes, but VMMDevHGCM doesn't pass it along. */
-                    if (cbSrc <= cbDst)
-                        memcpy(paParms[i].u.pointer.addr, pFirstMsg->m_paParms[i].u.pointer.addr, cbSrc);
-                    else
-                        rc = VERR_BUFFER_OVERFLOW;
-                    break;
+                    case VBOX_HGCM_SVC_PARM_32BIT:
+                        paParms[i].u.uint32 = pFirstMsg->m_paParms[i].u.uint32;
+                        break;
+
+                    case VBOX_HGCM_SVC_PARM_64BIT:
+                        paParms[i].u.uint64 = pFirstMsg->m_paParms[i].u.uint64;
+                        break;
+
+                    case VBOX_HGCM_SVC_PARM_PTR:
+                    {
+                        uint32_t const cbSrc = pFirstMsg->m_paParms[i].u.pointer.size;
+                        uint32_t const cbDst = paParms[i].u.pointer.size;
+                        paParms[i].u.pointer.size = cbSrc; /** @todo Check if this is safe in other layers...
+                                                            * Update: Safe, yes, but VMMDevHGCM doesn't pass it along. */
+                        if (cbSrc <= cbDst)
+                            memcpy(paParms[i].u.pointer.addr, pFirstMsg->m_paParms[i].u.pointer.addr, cbSrc);
+                        else
+                        {
+                            AssertMsgFailed(("#%u: cbSrc=%RU32 is bigger than cbDst=%RU32\n", i, cbSrc, cbDst));
+                            rc = VERR_BUFFER_OVERFLOW;
+                        }
+                        break;
+                    }
+
+                    default:
+                        AssertMsgFailed(("#%u: %u\n", i, pFirstMsg->m_paParms[i].type));
+                        rc = VERR_INTERNAL_ERROR;
+                        break;
                 }
-
-                default:
-                    AssertMsgFailed(("#%u: %u\n", i, pFirstMsg->m_paParms[i].type));
-                    rc = VERR_INTERNAL_ERROR;
-                    break;
+            if (RT_SUCCESS(rc))
+            {
+                /*
+                 * Complete the message and remove the pending message unless the
+                 * guest raced us and cancelled this call in the meantime.
+                 */
+                AssertPtr(g_pHelpers);
+                rc = g_pHelpers->pfnCallComplete(hCall, rc);
+
+                LogFlowFunc(("[Client %RU32] pfnCallComplete -> %Rrc\n", pClient->uClientID, rc));
+
+                if (rc != VERR_CANCELLED)
+                {
+                    pClient->pData->queueMsg.removeFirst();
+                    vboxSvcClipboardMsgFree(pFirstMsg);
+                }
+
+                return VINF_HGCM_ASYNC_EXECUTE; /* The caller must not complete it. */
             }
-        if (RT_SUCCESS(rc))
-        {
-            /*
-             * Complete the message and remove the pending message unless the
-             * guest raced us and cancelled this call in the meantime.
-             */
-            AssertPtr(g_pHelpers);
-            rc = g_pHelpers->pfnCallComplete(hCall, rc);
-
-            LogFlowFunc(("[Client %RU32] pfnCallComplete -> %Rrc\n", pClient->uClientID, rc));
-
-            if (rc != VERR_CANCELLED)
-            {
-                pClient->pData->queueMsg.removeFirst();
-                vboxSvcClipboardMsgFree(pFirstMsg);
-            }
-
-            return VINF_HGCM_ASYNC_EXECUTE; /* The caller must not complete it. */
+
+            LogFlowFunc(("[Client %RU32] Returning %Rrc\n", pClient->uClientID, rc));
+            return rc;
         }
-
-        LogFlowFunc(("[Client %RU32] Returning %Rrc\n", pClient->uClientID, rc));
-        return rc;
     }
 
@@ -1391 +1397 @@
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
             rc = vboxSvcClipboardURIHandler(pClient, callHandle, u32Function, cParms, paParms, tsArrival);
-            if (RT_SUCCESS(rc))
-            {
-                /* The URI handler does deferring on its own. */
-                fDefer = true;
-            }
+
+            /* The URI handler does deferring on its own, so never do any call completion here. */
+            fDefer = true;
 #else
             rc = VERR_NOT_IMPLEMENTED;