Changeset 43462 in vbox

Timestamp:

Sep 28, 2012 10:46:41 AM (13 years ago)

Author:

vboxsync

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

80995

Message:

HGCM Host Channel service: implemented a generic Query function.

Location:

trunk

Files:

• include/VBox/HostServices/VBoxHostChannel.h (modified) (4 diffs)
• include/VBox/VBoxGuestLib.h (modified) (1 diff)
• src/VBox/Additions/common/VBoxGuestLib/VBoxGuestR3LibHostChannel.cpp (modified) (1 diff)
• src/VBox/HostServices/HostChannel/HostChannel.cpp (modified) (1 diff)
• src/VBox/HostServices/HostChannel/HostChannel.h (modified) (1 diff)
• src/VBox/HostServices/HostChannel/service.cpp (modified) (2 diffs)
• src/VBox/Main/src-client/ConsoleVRDPServer.cpp (modified) (1 diff)

trunk/include/VBox/HostServices/VBoxHostChannel.h

@@ -45 +45 @@
 #define VBOX_HOST_CHANNEL_FN_SEND         3 /* Send data to the host. */
 #define VBOX_HOST_CHANNEL_FN_RECV         4 /* Receive data from the host. */
-#define VBOX_HOST_CHANNEL_FN_CONTROL      5 /* Generic data exchange. */
+#define VBOX_HOST_CHANNEL_FN_CONTROL      5 /* Generic data exchange using a channel instance. */
 #define VBOX_HOST_CHANNEL_FN_EVENT_WAIT   6 /* Blocking wait for a host event. */
 #define VBOX_HOST_CHANNEL_FN_EVENT_CANCEL 7 /* Cancel the blocking wait. */
+#define VBOX_HOST_CHANNEL_FN_QUERY        8 /* Generic data exchange using a channel name. */
 
 /*
@@ -56 +57 @@
 #define VBOX_HOST_CHANNEL_EVENT_RECV         2    /* Data is available for receiving. */
 #define VBOX_HOST_CHANNEL_EVENT_USER         1000 /* Base of channel specific events. */
+
+/*
+ * The common control code ids for the VBOX_HOST_CHANNEL_FN_[CONTROL|QUERY]
+ */
+#define VBOX_HOST_CHANNEL_CTRL_EXISTS     0    /* Whether the channel instance or provider exists. */
+#define VBOX_HOST_CHANNEL_CTRL_USER       1000 /* Base of channel specific events. */
 
 #pragma pack(1)
@@ -122 +129 @@
     VBoxGuestHGCMCallInfo hdr;
 } VBoxHostChannelEventCancel;
+
+typedef struct VBoxHostChannelQuery
+{
+    VBoxGuestHGCMCallInfo hdr;
+    HGCMFunctionParameter name;   /* IN linear ptr: Channel name utf8 nul terminated. */
+    HGCMFunctionParameter code;   /* IN uint32_t: The control code. */
+    HGCMFunctionParameter parm;   /* IN linear pointer: Parameters of the function. */
+    HGCMFunctionParameter data;   /* OUT linear pointer: Buffer for results. */
+    HGCMFunctionParameter sizeDataReturned; /* OUT uint32_t: Bytes returned in the 'data' buffer. */
+} VBoxHostChannelQuery;
 
 
@@ -180 +197 @@
                                                    uint32_t *pcbReceived, uint32_t *pcbRemaining));
 
-    /* The guest talks to the provider of the channel. */
+    /* The guest talks to the provider of the channel.
+     * @param pvChannel The channel instance. NULL if the target is the provider, rather than a channel.
+     */
     DECLR3CALLBACKMEMBER(int, HostChannelControl, (void *pvChannel, uint32_t u32Code,
                                                    const void *pvParm, uint32_t cbParm,

trunk/include/VBox/VBoxGuestLib.h

@@ -737 +737 @@
                                             uint32_t *pu32SizeReturned);
 VBGLR3DECL(int)  VbglR3HostChannelEventCancel(uint32_t u32ChannelHandle, uint32_t u32HGCMClientId);
+VBGLR3DECL(int)  VbglR3HostChannelQuery(const char *pszName, uint32_t u32HGCMClientId, uint32_t u32Code,
+                                        void *pvParm, uint32_t cbParm, void *pvData, uint32_t cbData,
+                                        uint32_t *pu32SizeDataReturned);
 
 #endif /* IN_RING3 */

trunk/src/VBox/Additions/common/VBoxGuestLib/VBoxGuestR3LibHostChannel.cpp

@@ -276 +276 @@
     return rc;
 }
+
+VBGLR3DECL(int) VbglR3HostChannelQuery(const char *pszName,
+                                       uint32_t u32HGCMClientId,
+                                       uint32_t u32Code,
+                                       void *pvParm,
+                                       uint32_t cbParm,
+                                       void *pvData,
+                                       uint32_t cbData,
+                                       uint32_t *pu32SizeDataReturned)
+{
+    /* Make a heap copy of the name, because HGCM can not use some of other memory types. */
+    size_t cbName = strlen(pszName) + 1;
+    char *pszCopy = (char *)RTMemAlloc(cbName);
+    if (pszCopy == NULL)
+    {
+        return VERR_NO_MEMORY;
+    }
+
+    memcpy(pszCopy, pszName, cbName);
+
+    VBoxHostChannelQuery parms;
+
+    parms.hdr.result = VERR_WRONG_ORDER;
+    parms.hdr.u32ClientID = u32HGCMClientId;
+    parms.hdr.u32Function = VBOX_HOST_CHANNEL_FN_QUERY;
+    parms.hdr.cParms = 5;
+
+    VbglHGCMParmPtrSet(&parms.name, pszCopy, (uint32_t)cbName);
+    VbglHGCMParmUInt32Set(&parms.code, u32Code);
+    VbglHGCMParmPtrSet(&parms.parm, pvParm, cbParm);
+    VbglHGCMParmPtrSet(&parms.data, pvData, cbData);
+    VbglHGCMParmUInt32Set(&parms.sizeDataReturned, 0);
+
+    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(parms)), &parms, sizeof(parms));
+
+    if (RT_SUCCESS(rc))
+    {
+        rc = parms.hdr.result;
+
+        if (RT_SUCCESS(rc))
+        {
+            *pu32SizeDataReturned = parms.sizeDataReturned.u.value32;
+        }
+    }
+
+    RTMemFree(pszCopy);
+
+    return rc;
+}

trunk/src/VBox/HostServices/HostChannel/HostChannel.cpp

@@ -699 +699 @@
 }
 
+int vboxHostChannelQuery(VBOXHOSTCHCLIENT *pClient,
+                         const char *pszName,
+                         uint32_t u32Code,
+                         void *pvParm,
+                         uint32_t cbParm,
+                         void *pvData,
+                         uint32_t cbData,
+                         uint32_t *pu32SizeDataReturned)
+{
+    HOSTCHLOG(("HostChannel: Query: (%d) name [%s], cbData %d\n", pClient->u32ClientID, pszName, cbData));
+
+    int rc = VINF_SUCCESS;
+
+    /* Look if there is a provider. */
+    VBOXHOSTCHPROVIDER *pProvider = vhcProviderFind(pClient->pCtx, pszName);
+
+    if (pProvider)
+    {
+        pProvider->iface.HostChannelControl(NULL, u32Code,
+                                            pvParm, cbParm,
+                                            pvData, cbData, pu32SizeDataReturned);
+
+        vhcProviderRelease(pProvider);
+    }
+    else
+    {
+        rc = VERR_NOT_SUPPORTED;
+    }
+
+    return rc;
+}
+
 int vboxHostChannelRegister(const char *pszName,
                             const VBOXHOSTCHANNELINTERFACE *pInterface,

trunk/src/VBox/HostServices/HostChannel/HostChannel.h

@@ -104 +104 @@
                               uint32_t *pcbParmOut);
 
+int vboxHostChannelQuery(VBOXHOSTCHCLIENT *pClient,
+                         const char *pszName,
+                         uint32_t u32Code,
+                         void *pvParm,
+                         uint32_t cbParm,
+                         void *pvData,
+                         uint32_t cbData,
+                         uint32_t *pu32SizeDataReturned);
+
 int vboxHostChannelRegister(const char *pszName,
                             const VBOXHOSTCHANNELINTERFACE *pInterface,

trunk/src/VBox/HostServices/HostChannel/service.cpp

@@ -243 +243 @@
                         uint32_t u32Handle = 0;
 
+                        /* @todo make sure that pvName is a nul terminated */
                         rc = vboxHostChannelAttach(pClient, &u32Handle, (const char *)pvName, u32Flags);
 
@@ -516 +517 @@
 
                     vboxHostChannelUnlock();
+                }
+            }
+        } break;
+
+        case VBOX_HOST_CHANNEL_FN_QUERY:
+        {
+            LogRel2(("svcCall: VBOX_HOST_CHANNEL_FN_QUERY\n"));
+
+            if (cParms != 5)
+            {
+                rc = VERR_INVALID_PARAMETER;
+            }
+            else if (   paParms[0].type != VBOX_HGCM_SVC_PARM_PTR     /* channel name */
+                     || paParms[1].type != VBOX_HGCM_SVC_PARM_32BIT   /* code */
+                     || paParms[2].type != VBOX_HGCM_SVC_PARM_PTR     /* parm */
+                     || paParms[3].type != VBOX_HGCM_SVC_PARM_PTR     /* data */
+                     || paParms[4].type != VBOX_HGCM_SVC_PARM_32BIT   /* sizeDataReturned */
+                    )
+            {
+                rc = VERR_INVALID_PARAMETER;
+            }
+            else
+            {
+                void *pvName;
+                uint32_t cbName;
+                uint32_t u32Code;
+                void *pvParm;
+                uint32_t cbParm;
+                void *pvData;
+                uint32_t cbData;
+
+                rc = VBoxHGCMParmPtrGet(&paParms[0], &pvName, &cbName);
+
+                if (RT_SUCCESS (rc))
+                {
+                    rc = VBoxHGCMParmUInt32Get (&paParms[1], &u32Code);
+
+                    if (RT_SUCCESS (rc))
+                    {
+                        rc = VBoxHGCMParmPtrGet (&paParms[2], &pvParm, &cbParm);
+
+                        if (RT_SUCCESS (rc))
+                        {
+                            rc = VBoxHGCMParmPtrGet (&paParms[3], &pvData, &cbData);
+
+                            if (RT_SUCCESS (rc))
+                            {
+                                uint32_t u32SizeDataReturned = 0;
+
+                                /* @todo make sure that pvName is a nul terminated */
+                                rc = vboxHostChannelQuery(pClient, (const char *)pvName, u32Code,
+                                                          pvParm, cbParm,
+                                                          pvData, cbData, &u32SizeDataReturned);
+                                if (RT_SUCCESS(rc))
+                                {
+                                    VBoxHGCMParmUInt32Set(&paParms[4], u32SizeDataReturned);
+                                }
+                            }
+                        }
+                    }
                 }
             }

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

@@ -2214 +2214 @@
 {
     LogFlowFunc(("\n"));
+    if (!pvChannel)
+    {
+        /* Special case, the provider must answer rather than a channel instance. */
+        if (u32Code == VBOX_HOST_CHANNEL_CTRL_EXISTS)
+        {
+            *pcbDataReturned = 0;
+            return VINF_SUCCESS;
+        }
+
+        return VERR_NOT_IMPLEMENTED;
+    }
+
+    /* Channels do not support this. */
     return VERR_NOT_IMPLEMENTED;
 }