Changeset 85712 in vbox for trunk/src

Timestamp:

Aug 12, 2020 12:24:30 PM (5 years ago)

Author:

vboxsync

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

139856

Message:

DnD: Added wire protocol support for querying and reporting guest / host features in host service and VbglR3. Untested.

Location:

trunk/src/VBox

Files:

• Additions/common/VBoxGuest/lib/VBoxGuestR3LibDragAndDrop.cpp (modified) (5 diffs)
• HostServices/DragAndDrop/VBoxDragAndDropSvc.cpp (modified) (8 diffs)

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

@@ -685 +685 @@
     AssertPtrReturn(pDataHdr, VERR_INVALID_POINTER);
 
-    Assert(pCtx->uProtocol >= 3); /* Only for protocol v3 and up. */
+    Assert(pCtx->uProtocolDeprecated >= 3); /* Only for protocol v3 and up. */
 
     HGCMMsgHGSendDataHdr Msg;
@@ -1012 +1012 @@
     Assert(pCtx->uClientID);
 
-    /* Set the default protocol version we would like to use. */
-    pCtx->uProtocol = 3;
+    /* Set the default protocol version we would like to use.
+     * Deprecated since VBox 6.1.x, but let this set to 3 to (hopefully) not break things. */
+    pCtx->uProtocolDeprecated = 3;
+
+    pCtx->fHostFeatures  = VBOX_DND_HF_NONE;
+    pCtx->fGuestFeatures = VBOX_DND_GF_NONE;
 
     /*
@@ -1030 +1034 @@
     HGCMMsgConnect Msg;
     VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, GUEST_DND_CONNECT, 3);
-    /** @todo Context ID not used yet. */
-    Msg.u.v3.uContext.SetUInt32(0);
-    Msg.u.v3.uProtocol.SetUInt32(pCtx->uProtocol);
-    Msg.u.v3.uFlags.SetUInt32(0); /* Unused at the moment. */
+    Msg.u.v3.uContext.SetUInt32(0);                /** @todo Context ID not used yet. */
+    Msg.u.v3.uProtocol.SetUInt32(pCtx->uProtocolDeprecated); /* Deprecated since VBox 6.1.x. */
+    Msg.u.v3.uFlags.SetUInt32(0);                  /* Unused at the moment. */
 
     rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
@@ -1039 +1042 @@
     {
         /* Set the protocol version we're going to use as told by the host. */
-        rc = Msg.u.v3.uProtocol.GetUInt32(&pCtx->uProtocol); AssertRC(rc);
+        rc = Msg.u.v3.uProtocol.GetUInt32(&pCtx->uProtocolDeprecated); AssertRC(rc);
+
+        /*
+         * Next is reporting our features.  If this fails, assume older host.
+         */
+        rc2 = VbglR3DnDReportFeatures(pCtx->uClientID, pCtx->fGuestFeatures, &pCtx->fHostFeatures);
+        if (RT_SUCCESS(rc2))
+        {
+            LogRel2(("DnD: Guest features: %#RX64 - Host features: %#RX64\n",
+                     pCtx->fGuestFeatures, pCtx->fHostFeatures));
+        }
+        else /* Failing here is not fatal; might be running with an older host. */
+        {
+            AssertLogRelMsg(rc2 == VERR_NOT_SUPPORTED || rc2 == VERR_NOT_IMPLEMENTED,
+                            ("Reporting features failed: %Rrc\n", rc2));
+        }
 
         pCtx->cbMaxChunkSize = DND_DEFAULT_CHUNK_SIZE; /** @todo Use a scratch buffer on the heap? */
     }
     else
-        pCtx->uProtocol = 0; /*  We're using protocol v0 (initial draft) as a fallback. */
-
-    /** @todo Implement protocol feature flags. */
-
-    LogFlowFunc(("uClient=%RU32, uProtocol=%RU32, rc=%Rrc\n", pCtx->uClientID, pCtx->uProtocol, rc));
+        pCtx->uProtocolDeprecated = 0; /*  We're using protocol v0 (initial draft) as a fallback. */
+
+    LogFlowFunc(("uClient=%RU32, uProtocol=%RU32, rc=%Rrc\n", pCtx->uClientID, pCtx->uProtocolDeprecated, rc));
     return rc;
 }
@@ -1066 +1082 @@
         pCtx->uClientID = 0;
     return rc;
+}
+
+/**
+ * Reports features to the host and retrieve host feature set.
+ *
+ * @returns VBox status code.
+ * @param   idClient        The client ID returned by VbglR3DnDConnect().
+ * @param   fGuestFeatures  Features to report, VBOX_DND_GF_XXX.
+ * @param   pfHostFeatures  Where to store the features VBOX_DND_HF_XXX.
+ */
+VBGLR3DECL(int) VbglR3DnDReportFeatures(uint32_t idClient, uint64_t fGuestFeatures, uint64_t *pfHostFeatures)
+{
+    int rc;
+    do
+    {
+        struct
+        {
+            VBGLIOCHGCMCALL         Hdr;
+            HGCMFunctionParameter   f64Features0;
+            HGCMFunctionParameter   f64Features1;
+        } Msg;
+        VBGL_HGCM_HDR_INIT(&Msg.Hdr, idClient, GUEST_DND_REPORT_FEATURES, 2);
+        VbglHGCMParmUInt64Set(&Msg.f64Features0, fGuestFeatures);
+        VbglHGCMParmUInt64Set(&Msg.f64Features1, VBOX_DND_GF_1_MUST_BE_ONE);
+
+        rc = VbglR3HGCMCall(&Msg.Hdr, sizeof(Msg));
+        if (RT_SUCCESS(rc))
+        {
+            Assert(Msg.f64Features0.type == VMMDevHGCMParmType_64bit);
+            Assert(Msg.f64Features1.type == VMMDevHGCMParmType_64bit);
+            if (Msg.f64Features1.u.value64 & VBOX_DND_GF_1_MUST_BE_ONE)
+                rc = VERR_NOT_SUPPORTED;
+            else if (pfHostFeatures)
+                *pfHostFeatures = Msg.f64Features0.u.value64;
+            break;
+        }
+    } while (rc == VERR_INTERRUPTED);
+    return rc;
+
 }
 

trunk/src/VBox/HostServices/DragAndDrop/VBoxDragAndDropSvc.cpp

@@ -50 +50 @@
 {
 public:
+
     DragAndDropClient(uint32_t idClient)
         : HGCM::Client(idClient)
+        , fGuestFeatures0(VBOX_DND_GF_NONE)
+        , fGuestFeatures1(VBOX_DND_GF_NONE)
     {
         RT_ZERO(m_SvcCtx);
@@ -62 +65 @@
 
 public:
+
     void disconnect(void) RT_NOEXCEPT;
+
+public:
+
+    /** Guest feature flags, VBOX_DND_GF_0_XXX. */
+    uint64_t                fGuestFeatures0;
+    /** Guest feature flags, VBOX_DND_GF_1_XXX. */
+    uint64_t                fGuestFeatures1;
 };
 
@@ -88 +99 @@
     int  clientConnect(uint32_t idClient, void *pvClient) RT_NOEXCEPT RT_OVERRIDE;
     int  clientDisconnect(uint32_t idClient, void *pvClient) RT_NOEXCEPT RT_OVERRIDE;
+    int  clientQueryFeatures(DragAndDropClient *pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[]) RT_NOEXCEPT;
+    int  clientReportFeatures(DragAndDropClient *pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[]) RT_NOEXCEPT;
     void guestCall(VBOXHGCMCALLHANDLE callHandle, uint32_t idClient, void *pvClient, uint32_t u32Function,
                    uint32_t cParms, VBOXHGCMSVCPARM paParms[]) RT_NOEXCEPT RT_OVERRIDE;
@@ -112 +125 @@
     /** Current drag and drop mode, VBOX_DRAG_AND_DROP_MODE_XXX. */
     uint32_t                           m_u32Mode;
+    /** Host feature mask (VBOX_DND_HF_0_XXX) for DND_GUEST_REPORT_FEATURES
+     * and DND_GUEST_QUERY_FEATURES. */
+    uint64_t                           m_fHostFeatures0;
 };
 
@@ -166 +182 @@
     modeSet(VBOX_DRAG_AND_DROP_MODE_OFF);
 
+    /* Set host features. */
+    m_fHostFeatures0 = VBOX_DND_HF_NONE;
+
     int rc = VINF_SUCCESS;
 
@@ -274 +293 @@
 }
 
+/**
+ * Implements GUEST_DND_REPORT_FEATURES.
+ *
+ * @returns VBox status code.
+ * @retval  VINF_HGCM_ASYNC_EXECUTE on success (we complete the message here).
+ * @retval  VERR_ACCESS_DENIED if not master
+ * @retval  VERR_INVALID_PARAMETER if bit 63 in the 2nd parameter isn't set.
+ * @retval  VERR_WRONG_PARAMETER_COUNT
+ *
+ * @param   pClient     The client state.
+ * @param   hCall       The client's call handle.
+ * @param   cParms      Number of parameters.
+ * @param   paParms     Array of parameters.
+ */
+int DragAndDropService::clientReportFeatures(DragAndDropClient *pClient,
+                                             VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[]) RT_NOEXCEPT
+{
+    /*
+     * Validate the request.
+     */
+    ASSERT_GUEST_RETURN(cParms == 2, VERR_WRONG_PARAMETER_COUNT);
+    ASSERT_GUEST_RETURN(paParms[0].type == VBOX_HGCM_SVC_PARM_64BIT, VERR_WRONG_PARAMETER_TYPE);
+    uint64_t const fFeatures0 = paParms[0].u.uint64;
+    ASSERT_GUEST_RETURN(paParms[1].type == VBOX_HGCM_SVC_PARM_64BIT, VERR_WRONG_PARAMETER_TYPE);
+    uint64_t const fFeatures1 = paParms[1].u.uint64;
+    ASSERT_GUEST_RETURN(fFeatures1 & VBOX_DND_GF_1_MUST_BE_ONE, VERR_INVALID_PARAMETER);
+
+    /*
+     * Do the work.
+     */
+    paParms[0].u.uint64 = m_fHostFeatures0;
+    paParms[1].u.uint64 = 0;
+
+    int rc = pClient->Complete(hCall, VINF_SUCCESS);
+    if (RT_SUCCESS(rc))
+    {
+        pClient->fGuestFeatures0 = fFeatures0;
+        pClient->fGuestFeatures1 = fFeatures1;
+        Log(("[Client %RU32] features: %#RX64 %#RX64\n", pClient->GetClientID(), fFeatures0, fFeatures1));
+    }
+    else
+        LogFunc(("pfnCallComplete -> %Rrc\n", rc));
+
+    return VINF_HGCM_ASYNC_EXECUTE;
+}
+
+/**
+ * Implements GUEST_DND_QUERY_FEATURES.
+ *
+ * @returns VBox status code.
+ * @retval  VINF_HGCM_ASYNC_EXECUTE on success (we complete the message here).
+ * @retval  VERR_WRONG_PARAMETER_COUNT
+ *
+ * @param   pClient     The client state.
+ * @param   hCall       The client's call handle.
+ * @param   cParms      Number of parameters.
+ * @param   paParms     Array of parameters.
+ */
+int DragAndDropService::clientQueryFeatures(DragAndDropClient *pClient,
+                                            VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[]) RT_NOEXCEPT
+{
+    /*
+     * Validate the request.
+     */
+    ASSERT_GUEST_RETURN(cParms == 2, VERR_WRONG_PARAMETER_COUNT);
+    ASSERT_GUEST_RETURN(paParms[0].type == VBOX_HGCM_SVC_PARM_64BIT, VERR_WRONG_PARAMETER_TYPE);
+    ASSERT_GUEST_RETURN(paParms[1].type == VBOX_HGCM_SVC_PARM_64BIT, VERR_WRONG_PARAMETER_TYPE);
+    ASSERT_GUEST(paParms[1].u.uint64 & RT_BIT_64(63));
+
+    /*
+     * Do the work.
+     */
+    paParms[0].u.uint64 = m_fHostFeatures0;
+    paParms[1].u.uint64 = 0;
+
+    int rc = pClient->Complete(hCall, VINF_SUCCESS);
+    if (RT_FAILURE(rc))
+        LogFunc(("pfnCallComplete -> %Rrc\n", rc));
+
+    return VINF_HGCM_ASYNC_EXECUTE;
+}
+
 int DragAndDropService::modeSet(uint32_t u32Mode) RT_NOEXCEPT
 {
@@ -327 +428 @@
         /* New since protocol v2. */
         case GUEST_DND_CONNECT:
+            RT_FALL_THROUGH();
+        /* New since VBox 6.1.x. */
+        case GUEST_DND_REPORT_FEATURES:
+            RT_FALL_THROUGH();
+        /* New since VBox 6.1.x. */
+        case GUEST_DND_QUERY_FEATURES:
         {
             /*
-             * Never block the initial connect call, as the clients do this when
+             * Never block these calls, as the clients issues those when
              * initializing and might get stuck if drag and drop is set to "disabled" at
              * that time.
@@ -524 +631 @@
                 break;
             }
+            case GUEST_DND_REPORT_FEATURES:
+            {
+                LogFlowFunc(("GUEST_DND_REPORT_FEATURES\n"));
+                rc = clientReportFeatures(pClient, callHandle, cParms, paParms);
+                break;
+            }
+            case GUEST_DND_QUERY_FEATURES:
+            {
+                LogFlowFunc(("GUEST_DND_QUERY_FEATURES"));
+                rc = clientQueryFeatures(pClient, callHandle, cParms, paParms);
+                break;
+            }
             case GUEST_DND_HG_ACK_OP:
             {