Changeset 76958 in vbox for trunk/src/VBox/HostServices/GuestControl

Timestamp:

Jan 23, 2019 6:23:04 PM (6 years ago)

Author:

vboxsync

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

128342

Message:

Guest Control: Unifying terminology for (client/host) commands, functions and messages; it's all about messages now. Renaming, no functional changes.

Location:

trunk/src/VBox

Files:

• . (modified) (1 prop)
• HostServices/GuestControl/service.cpp (modified) (88 diffs)
• HostServices/GuestControl/testcase/tstGuestControlSvc.cpp (modified) (2 diffs)

trunk/src/VBox

@@ -8 +8 @@
 /branches/VBox-5.0/src/VBox:104938,104943,104950,104987-104988,104990,106453
 /branches/VBox-5.1/src/VBox:112367,116543,116550,116568,116573
-/branches/VBox-5.2/src/VBox:119536,120083,120099,120213,120221,120239,123597-123598,123600-123601,123755,124263,124273,124277-124279,124284-124286,124288-124290,125768,125779-125780,125812
+/branches/VBox-5.2/src/VBox:119536,120083,120099,120213,120221,120239,123597-123598,123600-123601,123755,124263,124273,124277-124279,124284-124286,124288-124290,125768,125779-125780,125812,127158-127159,127162-127167,127180
 /branches/andy/draganddrop/src/VBox:90781-91268
 /branches/andy/guestctrl20/src/VBox:78916,78930

@@ -8 +8 @@
 /branches/VBox-5.0/src/VBox:104938,104943,104950,104987-104988,104990,106453
 /branches/VBox-5.1/src/VBox:112367,116543,116550,116568,116573
-/branches/VBox-5.2/src/VBox:119536,120083,120099,120213,120221,120239,123597-123598,123600-123601,123755,124263,124273,124277-124279,124284-124286,124288-124290,125768,125779-125780,125812
+/branches/VBox-5.2/src/VBox:119536,120083,120099,120213,120221,120239,123597-123598,123600-123601,123755,124263,124273,124277-124279,124284-124286,124288-124290,125768,125779-125780,125812,127158-127159,127162-127167,127180
 /branches/andy/draganddrop/src/VBox:90781-91268
 /branches/andy/guestctrl20/src/VBox:78916,78930

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

@@ -18 +18 @@
 /** @page pg_svc_guest_control   Guest Control HGCM Service
  *
- * This service acts as a proxy for handling and buffering host command requests
+ * This service acts as a proxy for handling and buffering host message requests
  * and clients on the guest. It tries to be as transparent as possible to let
  * the guest (client) and host side do their protocol handling as desired.
@@ -26 +26 @@
  *           which wants to control something on the guest.
  * - Client: A client (e.g. VBoxService) running inside the guest OS waiting for
- *           new host commands to perform. There can be multiple clients connected
+ *           new host messages to perform. There can be multiple clients connected
  *           to this service. A client is represented by its unique HGCM client ID.
  * - Context ID: An (almost) unique ID automatically generated on the host (Main API)
@@ -33 +33 @@
  *               an indicator which it can refer to later. This context ID gets
  *               internally bound by the service to a client which actually processes
- *               the command in order to have a relationship between client<->context ID(s).
- *
- * The host can trigger commands which get buffered by the service (with full HGCM
+ *               the message in order to have a relationship between client<->context ID(s).
+ *
+ * The host can trigger messages which get buffered by the service (with full HGCM
  * parameter info). As soon as a client connects (or is ready to do some new work)
- * it gets a buffered host command to process it. This command then will be immediately
- * removed from the command list. If there are ready clients but no new commands to be
+ * it gets a buffered host message  to process it. This message then will be immediately
+ * removed from the message list. If there are ready clients but no new messages to be
  * processed, these clients will be set into a deferred state (that is being blocked
- * to return until a new command is available).
+ * to return until a new host message is available).
  *
  * If a client needs to inform the host that something happened, it can send a
@@ -104 +104 @@
 
 /**
- * Structure for holding a buffered host command which has
+ * Structure for holding a buffered host message which has
  * not been processed yet.
  *
  * @todo r=bird: It would be nice if we could decide on _one_ term for what the
  *       host passes to the guest.  We currently have:
- *          - The enum is called eHostFn, implying it's a function
- *          - The guest retrieves messages, if the eGuestFn enum is anything to
- *            go by: GUEST_MSG_GET, GUEST_MSG_CANCEL, GUEST_MSG_XXX
- *          - Here it's called a host command.
- *          - But this HostCommand structure has a mMsgType rather than command
- *            number/enum value, impliying it's a message.
- */
-typedef struct HostCommand
-{
-    /** Entry on the ClientState::m_HostCmdList list. */
+ *          - The enum is called eHostMsg, implying it's a function
+ */
+typedef struct HostMsg
+{
+    /** Entry on the ClientState::m_HostMsgList list. */
     RTLISTNODE      m_ListEntry;
     union
@@ -125 +120 @@
          * See VBOX_GUESTCTRL_DST_XXX.  */
         uint64_t    m_idContextAndDst;
-        /** The context ID this command belongs to (extracted from the first parameter). */
+        /** The context ID this message belongs to (extracted from the first parameter). */
         uint32_t    m_idContext;
     };
     /** Dynamic structure for holding the HGCM parms */
-    uint32_t mMsgType;
+    uint32_t mType;
     /** Number of HGCM parameters. */
     uint32_t mParmCount;
@@ -137 +132 @@
     bool m_f60BetaHackInPlay;
 
-    HostCommand()
+    HostMsg()
         : m_idContextAndDst(0)
-        , mMsgType(UINT32_MAX)
+        , mType(UINT32_MAX)
         , mParmCount(0)
         , mpParms(NULL)
@@ -148 +143 @@
 
     /**
-     * Releases the host command, properly deleting it if no further references.
+     * Releases the host message, properly deleting it if no further references.
      */
     void Delete(void)
     {
-        LogFlowThisFunc(("[Cmd %RU32 (%s)] destroying\n", mMsgType, GstCtrlHostFnName((eHostFn)mMsgType)));
+        LogFlowThisFunc(("[Msg %RU32 (%s)] destroying\n", mType, GstCtrlHostMsgtoStr((eHostMsg)mType)));
         Assert(m_ListEntry.pNext == NULL);
         if (mpParms)
@@ -171 +166 @@
 
     /**
-     * Initializes the command.
+     * Initializes the message.
      *
      * The specified parameters are copied and any buffers referenced by it
@@ -177 +172 @@
      *
      * @returns VBox status code.
-     * @param   idFunction  The host function (message) number, eHostFn.
+     * @param   idMsg       The host message number, eHostMsg.
      * @param   cParms      Number of parameters in the HGCM request.
      * @param   paParms     Array of parameters.
      */
-    int Init(uint32_t idFunction, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
-    {
-        LogFlowThisFunc(("[Cmd %RU32 (%s)] Allocating cParms=%RU32, paParms=%p\n",
-                         idFunction, GstCtrlHostFnName((eHostFn)idFunction), cParms, paParms));
+    int Init(uint32_t idMsg, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
+    {
+        LogFlowThisFunc(("[Msg %RU32 (%s)] Allocating cParms=%RU32, paParms=%p\n",
+                         idMsg, GstCtrlHostMsgtoStr((eHostMsg)idMsg), cParms, paParms));
         Assert(mpParms == NULL);
         Assert(mParmCount == 0);
@@ -197 +192 @@
 
         /*
-         * The first parameter is the context ID and the command destiation mask.
+         * The first parameter is the context ID and the message destination mask.
          */
         if (paParms[0].type == VBOX_HGCM_SVC_PARM_64BIT)
@@ -206 +201 @@
         else if (paParms[0].type == VBOX_HGCM_SVC_PARM_32BIT)
         {
-            AssertMsgFailed(("idFunction=%u %s - caller must set dst!\n", idFunction, GstCtrlHostFnName((eHostFn)idFunction)));
+            AssertMsgFailed(("idMsg=%u %s - caller must set dst!\n", idMsg, GstCtrlHostMsgtoStr((eHostMsg)idMsg)));
             m_idContextAndDst = paParms[0].u.uint32 | VBOX_GUESTCTRL_DST_BOTH;
         }
@@ -215 +210 @@
          * Just make a copy of the parameters and any buffers.
          */
-        mMsgType   = idFunction;
+        mType   = idMsg;
         mParmCount = cParms;
         mpParms    = (VBOXHGCMSVCPARM *)RTMemAllocZ(sizeof(VBOXHGCMSVCPARM) * mParmCount);
@@ -244 +239 @@
 
                 default:
-                    AssertMsgFailedReturn(("idFunction=%u (%s) parameter #%u: type=%u\n",
-                                           idFunction, GstCtrlHostFnName((eHostFn)idFunction), i, paParms[i].type),
+                    AssertMsgFailedReturn(("idMsg=%u (%s) parameter #%u: type=%u\n",
+                                           idMsg, GstCtrlHostMsgtoStr((eHostMsg)idMsg), i, paParms[i].type),
                                           VERR_WRONG_PARAMETER_TYPE);
             }
@@ -271 +266 @@
         Assert(cDstParms >= 2);
         if (paDstParms[0].type == VBOX_HGCM_SVC_PARM_32BIT)
-            paDstParms[0].u.uint32 = mMsgType;
+            paDstParms[0].u.uint32 = mType;
         else
-            paDstParms[0].u.uint64 = mMsgType;
+            paDstParms[0].u.uint64 = mType;
         paDstParms[1].u.uint32 = mParmCount;
 
@@ -301 +296 @@
     int CopyTo(VBOXHGCMSVCPARM paDstParms[], uint32_t cDstParms) const
     {
-        LogFlowThisFunc(("[Cmd %RU32] mParmCount=%RU32, m_idContext=%RU32 (Session %RU32)\n",
-                         mMsgType, mParmCount, m_idContext, VBOX_GUESTCTRL_CONTEXTID_GET_SESSION(m_idContext)));
+        LogFlowThisFunc(("[Msg %RU32] mParmCount=%RU32, m_idContext=%RU32 (Session %RU32)\n",
+                         mType, mParmCount, m_idContext, VBOX_GUESTCTRL_CONTEXTID_GET_SESSION(m_idContext)));
 
         int rc = VINF_SUCCESS;
@@ -386 +381 @@
         int rc;
 
-        LogFlowThisFunc(("[Cmd %RU32] mParmCount=%RU32, mpParms=%p\n", mMsgType, mParmCount, mpParms));
-
-        /* Does the current host command need more parameter space which
+        LogFlowThisFunc(("[Msg %RU32] mParmCount=%RU32, mpParms=%p\n", mType, mParmCount, mpParms));
+
+        /* Does the current host message need more parameter space which
          * the client does not provide yet? */
         if (mParmCount > pReq->mNumParms)
         {
-            LogFlowThisFunc(("[Cmd %RU32] Requires %RU32 parms, only got %RU32 from client\n",
-                             mMsgType, mParmCount, pReq->mNumParms));
+            LogFlowThisFunc(("[Msg %RU32] Requires %RU32 parms, only got %RU32 from client\n",
+                             mType, mParmCount, pReq->mNumParms));
             /*
              * So this call apparently failed because the guest wanted to peek
              * how much parameters it has to supply in order to successfully retrieve
-             * this command. Let's tell him so!
+             * this message. Let's tell him so!
              */
             rc = VERR_TOO_MUCH_DATA;
@@ -424 +419 @@
         AssertPtrReturn(pReq, VERR_INVALID_POINTER);
 
-        LogFlowThisFunc(("[Cmd %RU32] mParmCount=%RU32, mpParms=%p\n", mMsgType, mParmCount, mpParms));
+        LogFlowThisFunc(("[Msg %RU32] mParmCount=%RU32, mpParms=%p\n", mType, mParmCount, mpParms));
 
         if (pReq->mNumParms >= 2)
         {
-            HGCMSvcSetU32(&pReq->mParms[0], mMsgType);   /* Message ID */
+            HGCMSvcSetU32(&pReq->mParms[0], mType);   /* Message ID */
             HGCMSvcSetU32(&pReq->mParms[1], mParmCount); /* Required parameters for message */
         }
@@ -438 +433 @@
          * Always return VERR_TOO_MUCH_DATA data here to
          * keep it compatible with older clients and to
-         * have correct accounting (mHostRc + mHostCmdTries).
+         * have correct accounting (mHostRc + mHostMsgTries).
          */
         return VERR_TOO_MUCH_DATA;
@@ -444 +439 @@
 
     /** @} */
-} HostCommand;
+} HostMsg;
 
 /**
  * Per-client structure used for book keeping/state tracking a
- * certain host command.
+ * certain host message.
  */
 typedef struct ClientContext
 {
-    /* Pointer to list node of this command. */
-    HostCommand *mpHostCmd;
+    /* Pointer to list node of this message. */
+    HostMsg *mpHostMsg;
     /** The standard constructor. */
-    ClientContext(void) : mpHostCmd(NULL) {}
+    ClientContext(void) : mpHostMsg(NULL) {}
     /** Internal constrcutor. */
-    ClientContext(HostCommand *pHostCmd) : mpHostCmd(pHostCmd) {}
+    ClientContext(HostMsg *pHostMsg) : mpHostMsg(pHostMsg) {}
 } ClientContext;
 typedef std::map< uint32_t, ClientContext > ClientContextMap;
@@ -467 +462 @@
 {
     PVBOXHGCMSVCHELPERS     m_pSvcHelpers;
-    /** Host command list to process (HostCommand). */
-    RTLISTANCHOR            m_HostCmdList;
+    /** Host message list to process (HostMsg). */
+    RTLISTANCHOR            m_HostMsgList;
     /** The HGCM client ID. */
     uint32_t                m_idClient;
@@ -482 +477 @@
     /** Pending client call (GUEST_MSG_PEEK_WAIT or GUEST_MSG_WAIT), zero if none pending.
      *
-     * This means the client waits for a new host command to reply and won't return
-     * from the waiting call until a new host command is available. */
-    guestControl::eGuestFn  m_enmIsPending;
+     * This means the client waits for a new host message to reply and won't return
+     * from the waiting call until a new host message is available. */
+    guestControl::eGuestMsg m_enmPendingMsg;
     /** Pending peek/wait request details. */
     ClientRequest           m_PendingReq;
@@ -496 +491 @@
         , m_fRestored(false)
         , m_fPendingCancel(false)
-        , m_enmIsPending((guestControl::eGuestFn)0)
-        , mHostCmdRc(VINF_SUCCESS)
-        , mHostCmdTries(0)
+        , m_enmPendingMsg((guestControl::eGuestMsg)0)
+        , mHostMsgRc(VINF_SUCCESS)
+        , mHostMsgTries(0)
         , mPeekCount(0)
     {
-        RTListInit(&m_HostCmdList);
+        RTListInit(&m_HostMsgList);
     }
 
@@ -511 +506 @@
         , m_fRestored(false)
         , m_fPendingCancel(false)
-        , m_enmIsPending((guestControl::eGuestFn)0)
-        , mHostCmdRc(VINF_SUCCESS)
-        , mHostCmdTries(0)
+        , m_enmPendingMsg((guestControl::eGuestMsg)0)
+        , mHostMsgRc(VINF_SUCCESS)
+        , mHostMsgTries(0)
         , mPeekCount(0)
     {
-        RTListInit(&m_HostCmdList);
+        RTListInit(&m_HostMsgList);
     }
 
     /**
-     * Used by for Service::hostProcessCommand().
-     */
-    void EnqueueCommand(HostCommand *pHostCmd)
-    {
-        AssertPtr(pHostCmd);
-        RTListAppend(&m_HostCmdList, &pHostCmd->m_ListEntry);
+     * Used by for Service::hostProcessMessage().
+     */
+    void EnqueueMessage(HostMsg *pHostMsg)
+    {
+        AssertPtr(pHostMsg);
+        RTListAppend(&m_HostMsgList, &pHostMsg->m_ListEntry);
     }
 
     /**
-     * Used by for Service::hostProcessCommand().
+     * Used by for Service::hostProcessMessage().
      *
      * @note This wakes up both GUEST_MSG_WAIT and GUEST_MSG_PEEK_WAIT sleepers.
@@ -537 +532 @@
         int rc = VINF_NO_CHANGE;
 
-        if (m_enmIsPending != 0)
+        if (m_enmPendingMsg != 0)
         {
             LogFlowFunc(("[Client %RU32] Waking up ...\n", m_idClient));
@@ -543 +538 @@
             rc = VINF_SUCCESS;
 
-            HostCommand *pFirstCmd = RTListGetFirstCpp(&m_HostCmdList, HostCommand, m_ListEntry);
-            if (pFirstCmd)
+            HostMsg *pFirstMsg = RTListGetFirstCpp(&m_HostMsgList, HostMsg, m_ListEntry);
+            if (pFirstMsg)
             {
-                LogFlowThisFunc(("[Client %RU32] Current host command is %RU32 (CID=%#RX32, cParms=%RU32)\n",
-                                 m_idClient, pFirstCmd->mMsgType, pFirstCmd->m_idContext, pFirstCmd->mParmCount));
-
-                if (m_enmIsPending == GUEST_MSG_PEEK_WAIT)
+                LogFlowThisFunc(("[Client %RU32] Current host message is %RU32 (CID=%#RX32, cParms=%RU32)\n",
+                                 m_idClient, pFirstMsg->mType, pFirstMsg->m_idContext, pFirstMsg->mParmCount));
+
+                if (m_enmPendingMsg == GUEST_MSG_PEEK_WAIT)
                 {
-                    pFirstCmd->setPeekReturn(m_PendingReq.mParms, m_PendingReq.mNumParms);
+                    pFirstMsg->setPeekReturn(m_PendingReq.mParms, m_PendingReq.mNumParms);
                     rc = m_pSvcHelpers->pfnCallComplete(m_PendingReq.mHandle, VINF_SUCCESS);
 
@@ -557 +552 @@
                     m_PendingReq.mParms    = NULL;
                     m_PendingReq.mNumParms = 0;
-                    m_enmIsPending         = (guestControl::eGuestFn)0;
+                    m_enmPendingMsg         = (guestControl::eGuestMsg)0;
                 }
-                else if (m_enmIsPending == GUEST_MSG_WAIT)
-                    rc = OldRun(&m_PendingReq, pFirstCmd);
+                else if (m_enmPendingMsg == GUEST_MSG_WAIT)
+                    rc = OldRun(&m_PendingReq, pFirstMsg);
                 else
-                    AssertMsgFailed(("m_enmIsPending=%d\n", m_enmIsPending));
+                    AssertMsgFailed(("m_enmIsPending=%d\n", m_enmPendingMsg));
             }
             else
-                AssertMsgFailed(("Waking up client ID=%RU32 with no host command in queue is a bad idea\n", m_idClient));
+                AssertMsgFailed(("Waking up client ID=%RU32 with no host message in queue is a bad idea\n", m_idClient));
 
             return rc;
@@ -581 +576 @@
     {
         LogFlowFunc(("[Client %RU32] Cancelling waiting thread, isPending=%d, pendingNumParms=%RU32, m_idSession=%x\n",
-                     m_idClient, m_enmIsPending, m_PendingReq.mNumParms, m_idSession));
+                     m_idClient, m_enmPendingMsg, m_PendingReq.mNumParms, m_idSession));
 
         /*
@@ -587 +582 @@
          */
         int rcComplete;
-        if (m_enmIsPending == GUEST_MSG_PEEK_WAIT)
-        {
-            HGCMSvcSetU32(&m_PendingReq.mParms[0], HOST_CANCEL_PENDING_WAITS);
+        if (m_enmPendingMsg == GUEST_MSG_PEEK_WAIT)
+        {
+            HGCMSvcSetU32(&m_PendingReq.mParms[0], HOST_MSG_CANCEL_PENDING_WAITS);
             rcComplete = VINF_TRY_AGAIN;
         }
@@ -597 +592 @@
          * aren't two parameters, fail the call.
          */
-        else if (m_enmIsPending != 0)
-        {
-            Assert(m_enmIsPending == GUEST_MSG_WAIT);
+        else if (m_enmPendingMsg != 0)
+        {
+            Assert(m_enmPendingMsg == GUEST_MSG_WAIT);
             if (m_PendingReq.mNumParms > 0)
-                HGCMSvcSetU32(&m_PendingReq.mParms[0], HOST_CANCEL_PENDING_WAITS);
+                HGCMSvcSetU32(&m_PendingReq.mParms[0], HOST_MSG_CANCEL_PENDING_WAITS);
             if (m_PendingReq.mNumParms > 1)
                 HGCMSvcSetU32(&m_PendingReq.mParms[1], 0);
@@ -620 +615 @@
         m_PendingReq.mParms    = NULL;
         m_PendingReq.mNumParms = 0;
-        m_enmIsPending            = (guestControl::eGuestFn)0;
+        m_enmPendingMsg            = (guestControl::eGuestMsg)0;
         m_fPendingCancel      = false;
         return VINF_SUCCESS;
@@ -633 +628 @@
      */
 
-    /** Last (most recent) rc after handling the host command. */
-    int mHostCmdRc;
-    /** How many GUEST_MSG_WAIT calls the client has issued to retrieve one command.
+    /** Last (most recent) rc after handling the host message. */
+    int mHostMsgRc;
+    /** How many GUEST_MSG_WAIT calls the client has issued to retrieve one message.
      *
      * This is used as a heuristic to remove a message that the client appears not
      * to be able to successfully retrieve.  */
-    uint32_t mHostCmdTries;
+    uint32_t mHostMsgTries;
     /** Number of times we've peeked at a pending message.
      *
      * This is necessary for being compatible with older Guest Additions.  In case
-     * there are commands which only have two (2) parameters and therefore would fit
+     * there are messages which only have two (2) parameters and therefore would fit
      * into the GUEST_MSG_WAIT reply immediately, we now can make sure that the
      * client first gets back the GUEST_MSG_WAIT results first.
@@ -650 +645 @@
 
     /**
-     * Ditches the first host command and crazy GUEST_MSG_WAIT state.
+     * Ditches the first host message and crazy GUEST_MSG_WAIT state.
      *
      * @note Only used by GUEST_MSG_WAIT scenarios.
      */
-    void OldDitchFirstHostCmd()
-    {
-        HostCommand *pFirstCmd = RTListGetFirstCpp(&m_HostCmdList, HostCommand, m_ListEntry);
-        Assert(pFirstCmd);
-        RTListNodeRemove(&pFirstCmd->m_ListEntry);
-        pFirstCmd->Delete();
+    void OldDitchFirstHostMsg()
+    {
+        HostMsg *pFirstMsg = RTListGetFirstCpp(&m_HostMsgList, HostMsg, m_ListEntry);
+        Assert(pFirstMsg);
+        RTListNodeRemove(&pFirstMsg->m_ListEntry);
+        pFirstMsg->Delete();
 
         /* Reset state else. */
-        mHostCmdRc    = VINF_SUCCESS;
-        mHostCmdTries = 0;
+        mHostMsgRc    = VINF_SUCCESS;
+        mHostMsgTries = 0;
         mPeekCount    = 0;
     }
@@ -672 +667 @@
      * @note Only used by GUEST_MSG_WAIT scenarios.
      */
-    int OldRun(ClientRequest const *pReq, HostCommand *pHostCmd)
+    int OldRun(ClientRequest const *pReq, HostMsg *pHostMsg)
     {
         AssertPtrReturn(pReq, VERR_INVALID_POINTER);
-        AssertPtrReturn(pHostCmd, VERR_INVALID_POINTER);
-        Assert(RTListNodeIsFirst(&m_HostCmdList, &pHostCmd->m_ListEntry));
-
-        LogFlowFunc(("[Client %RU32] pReq=%p, mHostCmdRc=%Rrc, mHostCmdTries=%RU32, mPeekCount=%RU32\n",
-                      m_idClient, pReq, mHostCmdRc, mHostCmdTries, mPeekCount));
-
-        int rc = mHostCmdRc = OldSendReply(pReq, pHostCmd);
-
-        LogFlowThisFunc(("[Client %RU32] Processing command %RU32 ended with rc=%Rrc\n", m_idClient, pHostCmd->mMsgType, mHostCmdRc));
+        AssertPtrReturn(pHostMsg, VERR_INVALID_POINTER);
+        Assert(RTListNodeIsFirst(&m_HostMsgList, &pHostMsg->m_ListEntry));
+
+        LogFlowFunc(("[Client %RU32] pReq=%p, mHostMsgRc=%Rrc, mHostMsgTries=%RU32, mPeekCount=%RU32\n",
+                      m_idClient, pReq, mHostMsgRc, mHostMsgTries, mPeekCount));
+
+        int rc = mHostMsgRc = OldSendReply(pReq, pHostMsg);
+
+        LogFlowThisFunc(("[Client %RU32] Processing host message %RU32 ended with rc=%Rrc\n",
+                         m_idClient, pHostMsg->mType, mHostMsgRc));
 
         bool fRemove = false;
         if (RT_FAILURE(rc))
         {
-            mHostCmdTries++;
+            mHostMsgTries++;
 
             /*
@@ -695 +691 @@
              *
              * Note: Due to legacy reasons this the retry counter has to be even because on
-             *       every peek there will be the actual command retrieval from the client side.
-             *       To not get the actual command if the client actually only wants to peek for
-             *       the next command, there needs to be two rounds per try, e.g. 3 rounds = 6 tries.
+             *       every peek there will be the actual message retrieval from the client side.
+             *       To not get the actual message if the client actually only wants to peek for
+             *       the next message, there needs to be two rounds per try, e.g. 3 rounds = 6 tries.
              */
             /** @todo Fix the mess stated above. GUEST_MSG_WAIT should be become GUEST_MSG_PEEK, *only*
-             *        (and every time) returning the next upcoming host command (if any, blocking). Then
+             *        (and every time) returning the next upcoming host message (if any, blocking). Then
              *        it's up to the client what to do next, either peeking again or getting the actual
-             *        host command via an own GUEST_ type message.
+             *        host message via an own GUEST_ type message.
              */
             if (   rc == VERR_TOO_MUCH_DATA
                 || rc == VERR_CANCELLED)
             {
-                if (mHostCmdTries == 6)
+                if (mHostMsgTries == 6)
                     fRemove = true;
             }
             /* Client did not understand the message or something else weird happened. Try again one
              * more time and drop it if it didn't get handled then. */
-            else if (mHostCmdTries > 1)
+            else if (mHostMsgTries > 1)
                 fRemove = true;
         }
@@ -718 +714 @@
             fRemove = true; /* Everything went fine, remove it. */
 
-        LogFlowThisFunc(("[Client %RU32] Tried command %RU32 for %RU32 times, (last result=%Rrc, fRemove=%RTbool)\n",
-                         m_idClient, pHostCmd->mMsgType, mHostCmdTries, rc, fRemove));
+        LogFlowThisFunc(("[Client %RU32] Tried host message %RU32 for %RU32 times, (last result=%Rrc, fRemove=%RTbool)\n",
+                         m_idClient, pHostMsg->mType, mHostMsgTries, rc, fRemove));
 
         if (fRemove)
         {
-            Assert(RTListNodeIsFirst(&m_HostCmdList, &pHostCmd->m_ListEntry));
-            OldDitchFirstHostCmd();
+            Assert(RTListNodeIsFirst(&m_HostMsgList, &pHostMsg->m_ListEntry));
+            OldDitchFirstHostMsg();
         }
 
@@ -739 +735 @@
 
         /*
-         * If the host command list is empty, the request must wait for one to be posted.
+         * If the host message list is empty, the request must wait for one to be posted.
          */
-        HostCommand *pFirstCmd = RTListGetFirstCpp(&m_HostCmdList, HostCommand, m_ListEntry);
-        if (!pFirstCmd)
+        HostMsg *pFirstMsg = RTListGetFirstCpp(&m_HostMsgList, HostMsg, m_ListEntry);
+        if (!pFirstMsg)
         {
             if (!m_fPendingCancel)
             {
                 /* Go to sleep. */
-                ASSERT_GUEST_RETURN(m_enmIsPending == 0, VERR_WRONG_ORDER);
+                ASSERT_GUEST_RETURN(m_enmPendingMsg == 0, VERR_WRONG_ORDER);
                 m_PendingReq = *pReq;
-                m_enmIsPending  = GUEST_MSG_WAIT;
+                m_enmPendingMsg  = GUEST_MSG_WAIT;
                 LogFlowFunc(("[Client %RU32] Is now in pending mode\n", m_idClient));
                 return VINF_HGCM_ASYNC_EXECUTE;
@@ -757 +753 @@
             m_fPendingCancel = false;
             if (pReq->mNumParms > 0)
-                HGCMSvcSetU32(&pReq->mParms[0], HOST_CANCEL_PENDING_WAITS);
+                HGCMSvcSetU32(&pReq->mParms[0], HOST_MSG_CANCEL_PENDING_WAITS);
             if (pReq->mNumParms > 1)
                 HGCMSvcSetU32(&pReq->mParms[1], 0);
@@ -764 +760 @@
 
         /*
-         * Return first host command.
+         * Return first host message.
          */
-        return OldRun(pReq, pFirstCmd);
+        return OldRun(pReq, pFirstMsg);
     }
 
@@ -774 +770 @@
      */
     int OldSendReply(ClientRequest const *pReq,
-                     HostCommand         *pHostCmd)
+                     HostMsg         *pHostMsg)
     {
         AssertPtrReturn(pReq, VERR_INVALID_POINTER);
-        AssertPtrReturn(pHostCmd, VERR_INVALID_POINTER);
+        AssertPtrReturn(pHostMsg, VERR_INVALID_POINTER);
 
         /* In case of VERR_CANCELLED. */
@@ -785 +781 @@
         /* If the client is in pending mode, always send back
          * the peek result first. */
-        if (m_enmIsPending)
-        {
-            Assert(m_enmIsPending == GUEST_MSG_WAIT);
-            rc = pHostCmd->Peek(pReq);
+        if (m_enmPendingMsg)
+        {
+            Assert(m_enmPendingMsg == GUEST_MSG_WAIT);
+            rc = pHostMsg->Peek(pReq);
             mPeekCount++;
         }
@@ -794 +790 @@
         {
             /* If this is the very first peek, make sure to *always* give back the peeking answer
-             * instead of the actual command, even if this command would fit into the current
+             * instead of the actual message, even if this message would fit into the current
              * connection buffer. */
             if (!mPeekCount)
             {
-                rc = pHostCmd->Peek(pReq);
+                rc = pHostMsg->Peek(pReq);
                 mPeekCount++;
             }
             else
             {
-                /* Try assigning the host command to the client and store the
+                /* Try assigning the host message to the client and store the
                  * result code for later use. */
-                rc = pHostCmd->Assign(pReq);
+                rc = pHostMsg->Assign(pReq);
                 if (RT_FAILURE(rc)) /* If something failed, let the client peek (again). */
                 {
-                    rc = pHostCmd->Peek(pReq);
+                    rc = pHostMsg->Peek(pReq);
                     mPeekCount++;
                 }
@@ -817 +813 @@
 
         /* Reset pending status. */
-        m_enmIsPending = (guestControl::eGuestFn)0;
+        m_enmPendingMsg = (guestControl::eGuestMsg)0;
 
         /* In any case the client did something, so complete
@@ -831 +827 @@
         }
 
-        LogFlowThisFunc(("[Client %RU32] Command %RU32 ended with %Rrc (mPeekCount=%RU32, pReq=%p)\n",
-                         m_idClient, pHostCmd->mMsgType, rc, mPeekCount, pReq));
+        LogFlowThisFunc(("[Client %RU32] Message %RU32 ended with %Rrc (mPeekCount=%RU32, pReq=%p)\n",
+                         m_idClient, pHostMsg->mType, rc, mPeekCount, pReq));
         return rc;
     }
@@ -867 +863 @@
     typedef GstCtrlService SELF;
     /** HGCM helper functions. */
-    PVBOXHGCMSVCHELPERS mpHelpers;
+    PVBOXHGCMSVCHELPERS     mpHelpers;
     /** Callback function supplied by the host for notification of updates to properties. */
-    PFNHGCMSVCEXT mpfnHostCallback;
+    PFNHGCMSVCEXT           mpfnHostCallback;
     /** User data pointer to be supplied to the host callback function. */
-    void *mpvHostData;
+    void                   *mpvHostData;
     /** Map containing all connected clients, key is HGCM client ID. */
-    ClientStateMap  m_ClientStateMap;
+    ClientStateMap          m_ClientStateMap;
     /** Session ID -> client state. */
-    ClientStateMap  m_SessionIdMap;
+    ClientStateMap          m_SessionIdMap;
     /** The current master client, NULL if none. */
-    ClientState    *m_pMasterClient;
+    ClientState            *m_pMasterClient;
     /** The master HGCM client ID, UINT32_MAX if none. */
-    uint32_t        m_idMasterClient;
+    uint32_t                m_idMasterClient;
     /** Set if we're in legacy mode (pre 6.0). */
-    bool            m_fLegacyMode;
+    bool                    m_fLegacyMode;
     /** Number of prepared sessions. */
-    uint32_t        m_cPreparedSessions;
+    uint32_t                m_cPreparedSessions;
     /** List of prepared session (GstCtrlPreparedSession). */
-    RTLISTANCHOR    m_PreparedSessions;
+    RTLISTANCHOR            m_PreparedSessions;
 
 public:
@@ -921 +917 @@
     int clientSessionAccept(ClientState *pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
     int clientSessionCloseOther(ClientState *pClient, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
-    int clientToMain(ClientState *pClient, uint32_t idFunction, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
+    int clientToMain(ClientState *pClient, uint32_t idMsg, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
 
     int clientMsgOldGet(ClientState *pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
@@ -927 +923 @@
     int clientMsgOldSkip(ClientState *pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms);
 
-    int hostCallback(uint32_t idFunction, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
-    int hostProcessCommand(uint32_t idFunction, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
+    int hostCallback(uint32_t idMsg, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
+    int hostProcessMessage(uint32_t idMsg, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
 
     DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(GstCtrlService);
@@ -1025 +1021 @@
 
     /*
-     * Cancel all pending host commands, replying with GUEST_DISCONNECTED if final recipient.
-     */
-    HostCommand *pCurCmd, *pNextCmd;
-    RTListForEachSafeCpp(&pClient->m_HostCmdList, pCurCmd, pNextCmd, HostCommand, m_ListEntry)
-    {
-        RTListNodeRemove(&pCurCmd->m_ListEntry);
+     * Cancel all pending host messages, replying with GUEST_DISCONNECTED if final recipient.
+     */
+    HostMsg *pCurMsg, *pNextMsg;
+    RTListForEachSafeCpp(&pClient->m_HostMsgList, pCurMsg, pNextMsg, HostMsg, m_ListEntry)
+    {
+        RTListNodeRemove(&pCurMsg->m_ListEntry);
 
         VBOXHGCMSVCPARM Parm;
-        HGCMSvcSetU32(&Parm, pCurCmd->m_idContext);
-        int rc2 = pThis->hostCallback(GUEST_DISCONNECTED, 1, &Parm);
-        LogFlowFunc(("Cancelled host command %u (%s) with idContext=%#x -> %Rrc\n",
-                     pCurCmd->mMsgType, GstCtrlHostFnName((eHostFn)pCurCmd->mMsgType), pCurCmd->m_idContext, rc2));
+        HGCMSvcSetU32(&Parm, pCurMsg->m_idContext);
+        int rc2 = pThis->hostCallback(GUEST_MSG_DISCONNECTED, 1, &Parm);
+        LogFlowFunc(("Cancelled host message %u (%s) with idContext=%#x -> %Rrc\n",
+                     pCurMsg->mType, GstCtrlHostMsgtoStr((eHostMsg)pCurMsg->mType), pCurMsg->m_idContext, rc2));
         RT_NOREF(rc2);
 
-        pCurCmd->Delete();
+        pCurMsg->Delete();
     }
 
@@ -1079 +1075 @@
  * A client asks for the next message to process.
  *
- * This either fills in a pending host command into the client's parameter space
+ * This either fills in a pending host message into the client's parameter space
  * or defers the guest call until we have something from the host.
  *
@@ -1206 +1202 @@
 
     /*
-     * Return information about the first command if one is pending in the list.
-     */
-    HostCommand *pFirstCmd = RTListGetFirstCpp(&pClient->m_HostCmdList, HostCommand, m_ListEntry);
-    if (pFirstCmd)
-    {
-        pFirstCmd->setPeekReturn(paParms, cParms);
+     * Return information about the first message if one is pending in the list.
+     */
+    HostMsg *pFirstMsg = RTListGetFirstCpp(&pClient->m_HostMsgList, HostMsg, m_ListEntry);
+    if (pFirstMsg)
+    {
+        pFirstMsg->setPeekReturn(paParms, cParms);
         LogFlowFunc(("[Client %RU32] GUEST_MSG_PEEK_XXXX -> VINF_SUCCESS (idMsg=%u (%s), cParms=%u)\n",
-                     pClient->m_idClient, pFirstCmd->mMsgType, GstCtrlHostFnName((eHostFn)pFirstCmd->mMsgType), pFirstCmd->mParmCount));
+                     pClient->m_idClient, pFirstMsg->mType, GstCtrlHostMsgtoStr((eHostMsg)pFirstMsg->mType), pFirstMsg->mParmCount));
         return VINF_SUCCESS;
     }
@@ -1229 +1225 @@
      * Wait for the host to queue a message for this client.
      */
-    ASSERT_GUEST_MSG_RETURN(pClient->m_enmIsPending == 0, ("Already pending! (idClient=%RU32)\n", pClient->m_idClient),
+    ASSERT_GUEST_MSG_RETURN(pClient->m_enmPendingMsg == 0, ("Already pending! (idClient=%RU32)\n", pClient->m_idClient),
                             VERR_RESOURCE_BUSY);
     pClient->m_PendingReq.mHandle   = hCall;
     pClient->m_PendingReq.mNumParms = cParms;
     pClient->m_PendingReq.mParms    = paParms;
-    pClient->m_enmIsPending         = GUEST_MSG_PEEK_WAIT;
+    pClient->m_enmPendingMsg         = GUEST_MSG_PEEK_WAIT;
     LogFlowFunc(("[Client %RU32] Is now in pending mode...\n", pClient->m_idClient));
     return VINF_HGCM_ASYNC_EXECUTE;
@@ -1270 +1266 @@
 
     /*
-     * Return information about the first command if one is pending in the list.
-     */
-    HostCommand *pFirstCmd = RTListGetFirstCpp(&pClient->m_HostCmdList, HostCommand, m_ListEntry);
-    if (pFirstCmd)
-    {
-
-        ASSERT_GUEST_MSG_RETURN(pFirstCmd->mMsgType == idMsgExpected || idMsgExpected == UINT32_MAX,
+     * Return information about the first message if one is pending in the list.
+     */
+    HostMsg *pFirstMsg = RTListGetFirstCpp(&pClient->m_HostMsgList, HostMsg, m_ListEntry);
+    if (pFirstMsg)
+    {
+
+        ASSERT_GUEST_MSG_RETURN(pFirstMsg->mType == idMsgExpected || idMsgExpected == UINT32_MAX,
                                 ("idMsg=%u (%s) cParms=%u, caller expected %u (%s) and %u\n",
-                                 pFirstCmd->mMsgType, GstCtrlHostFnName((eHostFn)pFirstCmd->mMsgType), pFirstCmd->mParmCount,
-                                 idMsgExpected, GstCtrlHostFnName((eHostFn)idMsgExpected), cParms),
+                                 pFirstMsg->mType, GstCtrlHostMsgtoStr((eHostMsg)pFirstMsg->mType), pFirstMsg->mParmCount,
+                                 idMsgExpected, GstCtrlHostMsgtoStr((eHostMsg)idMsgExpected), cParms),
                                 VERR_MISMATCH);
-        ASSERT_GUEST_MSG_RETURN(pFirstCmd->mParmCount == cParms,
+        ASSERT_GUEST_MSG_RETURN(pFirstMsg->mParmCount == cParms,
                                 ("idMsg=%u (%s) cParms=%u, caller expected %u (%s) and %u\n",
-                                 pFirstCmd->mMsgType, GstCtrlHostFnName((eHostFn)pFirstCmd->mMsgType), pFirstCmd->mParmCount,
-                                 idMsgExpected, GstCtrlHostFnName((eHostFn)idMsgExpected), cParms),
+                                 pFirstMsg->mType, GstCtrlHostMsgtoStr((eHostMsg)pFirstMsg->mType), pFirstMsg->mParmCount,
+                                 idMsgExpected, GstCtrlHostMsgtoStr((eHostMsg)idMsgExpected), cParms),
                                 VERR_WRONG_PARAMETER_COUNT);
 
         /* Check the parameter types. */
         for (uint32_t i = 0; i < cParms; i++)
-            ASSERT_GUEST_MSG_RETURN(pFirstCmd->mpParms[i].type == paParms[i].type,
-                                    ("param #%u: type %u, caller expected %u (idMsg=%u %s)\n", i, pFirstCmd->mpParms[i].type,
-                                     paParms[i].type, pFirstCmd->mMsgType, GstCtrlHostFnName((eHostFn)pFirstCmd->mMsgType)),
+            ASSERT_GUEST_MSG_RETURN(pFirstMsg->mpParms[i].type == paParms[i].type,
+                                    ("param #%u: type %u, caller expected %u (idMsg=%u %s)\n", i, pFirstMsg->mpParms[i].type,
+                                     paParms[i].type, pFirstMsg->mType, GstCtrlHostMsgtoStr((eHostMsg)pFirstMsg->mType)),
                                     VERR_WRONG_PARAMETER_TYPE);
 
@@ -1302 +1298 @@
         int rc = VINF_SUCCESS;
         for (uint32_t i = 0; i < cParms; i++)
-            switch (pFirstCmd->mpParms[i].type)
+            switch (pFirstMsg->mpParms[i].type)
             {
                 case VBOX_HGCM_SVC_PARM_32BIT:
-                    paParms[i].u.uint32 = pFirstCmd->mpParms[i].u.uint32;
+                    paParms[i].u.uint32 = pFirstMsg->mpParms[i].u.uint32;
                     break;
 
                 case VBOX_HGCM_SVC_PARM_64BIT:
-                    paParms[i].u.uint64 = pFirstCmd->mpParms[i].u.uint64;
+                    paParms[i].u.uint64 = pFirstMsg->mpParms[i].u.uint64;
                     break;
 
                 case VBOX_HGCM_SVC_PARM_PTR:
                 {
-                    uint32_t const cbSrc = pFirstCmd->mpParms[i].u.pointer.size;
+                    uint32_t const cbSrc = pFirstMsg->mpParms[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, pFirstCmd->mpParms[i].u.pointer.addr, cbSrc);
+                        memcpy(paParms[i].u.pointer.addr, pFirstMsg->mpParms[i].u.pointer.addr, cbSrc);
                     else
                         rc = VERR_BUFFER_OVERFLOW;
@@ -1326 +1322 @@
 
                 default:
-                    AssertMsgFailed(("#%u: %u\n", i, pFirstCmd->mpParms[i].type));
+                    AssertMsgFailed(("#%u: %u\n", i, pFirstMsg->mpParms[i].type));
                     rc = VERR_INTERNAL_ERROR;
                     break;
@@ -1333 +1329 @@
         {
             /*
-             * Complete the command and remove the pending message unless the
+             * Complete the message and remove the pending message unless the
              * guest raced us and cancelled this call in the meantime.
              */
@@ -1340 +1336 @@
             if (rc != VERR_CANCELLED)
             {
-                RTListNodeRemove(&pFirstCmd->m_ListEntry);
-                pFirstCmd->Delete();
+                RTListNodeRemove(&pFirstMsg->m_ListEntry);
+                pFirstMsg->Delete();
             }
             else
@@ -1377 +1373 @@
      * Execute.
      */
-    if (pClient->m_enmIsPending != 0)
+    if (pClient->m_enmPendingMsg != 0)
     {
         pClient->CancelWaiting();
@@ -1422 +1418 @@
      * Do the job.
      */
-    HostCommand *pFirstCmd = RTListGetFirstCpp(&pClient->m_HostCmdList, HostCommand, m_ListEntry);
-    if (pFirstCmd)
-    {
-        if (   pFirstCmd->mMsgType == idMsg
+    HostMsg *pFirstMsg = RTListGetFirstCpp(&pClient->m_HostMsgList, HostMsg, m_ListEntry);
+    if (pFirstMsg)
+    {
+        if (   pFirstMsg->mType == idMsg
             || idMsg == UINT32_MAX)
         {
@@ -1432 +1428 @@
             {
                 /*
-                 * Remove the command from the queue.
+                 * Remove the message from the queue.
                  */
-                Assert(RTListNodeIsFirst(&pClient->m_HostCmdList, &pFirstCmd->m_ListEntry) );
-                RTListNodeRemove(&pFirstCmd->m_ListEntry);
+                Assert(RTListNodeIsFirst(&pClient->m_HostMsgList, &pFirstMsg->m_ListEntry) );
+                RTListNodeRemove(&pFirstMsg->m_ListEntry);
 
                 /*
@@ -1441 +1437 @@
                  */
                 VBOXHGCMSVCPARM aReplyParams[5];
-                HGCMSvcSetU32(&aReplyParams[0], pFirstCmd->m_idContext);
-                switch (pFirstCmd->mMsgType)
+                HGCMSvcSetU32(&aReplyParams[0], pFirstMsg->m_idContext);
+                switch (pFirstMsg->mType)
                 {
-                    case HOST_EXEC_CMD:
+                    case HOST_MSG_EXEC_CMD:
                         HGCMSvcSetU32(&aReplyParams[1], 0);              /* pid */
                         HGCMSvcSetU32(&aReplyParams[2], PROC_STS_ERROR); /* status */
                         HGCMSvcSetU32(&aReplyParams[3], rcSkip);         /* flags / whatever */
                         HGCMSvcSetPv(&aReplyParams[4], NULL, 0);         /* data buffer */
-                        hostCallback(GUEST_EXEC_STATUS, 5, aReplyParams);
+                        hostCallback(GUEST_MSG_EXEC_STATUS, 5, aReplyParams);
                         break;
 
-                    case HOST_SESSION_CREATE:
+                    case HOST_MSG_SESSION_CREATE:
                         HGCMSvcSetU32(&aReplyParams[1], GUEST_SESSION_NOTIFYTYPE_ERROR);    /* type */
                         HGCMSvcSetU32(&aReplyParams[2], rcSkip);                            /* result */
-                        hostCallback(GUEST_SESSION_NOTIFY, 3, aReplyParams);
+                        hostCallback(GUEST_MSG_SESSION_NOTIFY, 3, aReplyParams);
                         break;
 
-                    case HOST_EXEC_SET_INPUT:
-                        HGCMSvcSetU32(&aReplyParams[1], pFirstCmd->mParmCount >= 2 ? pFirstCmd->mpParms[1].u.uint32 : 0);
+                    case HOST_MSG_EXEC_SET_INPUT:
+                        HGCMSvcSetU32(&aReplyParams[1], pFirstMsg->mParmCount >= 2 ? pFirstMsg->mpParms[1].u.uint32 : 0);
                         HGCMSvcSetU32(&aReplyParams[2], INPUT_STS_ERROR);   /* status */
                         HGCMSvcSetU32(&aReplyParams[3], rcSkip);            /* flags / whatever */
                         HGCMSvcSetU32(&aReplyParams[4], 0);                 /* bytes consumed */
-                        hostCallback(GUEST_EXEC_INPUT_STATUS, 5, aReplyParams);
+                        hostCallback(GUEST_MSG_EXEC_INPUT_STATUS, 5, aReplyParams);
                         break;
 
-                    case HOST_FILE_OPEN:
+                    case HOST_MSG_FILE_OPEN:
                         HGCMSvcSetU32(&aReplyParams[1], GUEST_FILE_NOTIFYTYPE_OPEN); /* type*/
                         HGCMSvcSetU32(&aReplyParams[2], rcSkip);                     /* rc */
-                        HGCMSvcSetU32(&aReplyParams[3], VBOX_GUESTCTRL_CONTEXTID_GET_OBJECT(pFirstCmd->m_idContext)); /* handle */
-                        hostCallback(GUEST_FILE_NOTIFY, 4, aReplyParams);
+                        HGCMSvcSetU32(&aReplyParams[3], VBOX_GUESTCTRL_CONTEXTID_GET_OBJECT(pFirstMsg->m_idContext)); /* handle */
+                        hostCallback(GUEST_MSG_FILE_NOTIFY, 4, aReplyParams);
                         break;
-                    case HOST_FILE_CLOSE:
+                    case HOST_MSG_FILE_CLOSE:
                         HGCMSvcSetU32(&aReplyParams[1], GUEST_FILE_NOTIFYTYPE_ERROR); /* type*/
                         HGCMSvcSetU32(&aReplyParams[2], rcSkip);                      /* rc */
-                        hostCallback(GUEST_FILE_NOTIFY, 3, aReplyParams);
+                        hostCallback(GUEST_MSG_FILE_NOTIFY, 3, aReplyParams);
                         break;
-                    case HOST_FILE_READ:
-                    case HOST_FILE_READ_AT:
+                    case HOST_MSG_FILE_READ:
+                    case HOST_MSG_FILE_READ_AT:
                         HGCMSvcSetU32(&aReplyParams[1], GUEST_FILE_NOTIFYTYPE_READ);  /* type */
                         HGCMSvcSetU32(&aReplyParams[2], rcSkip);                      /* rc */
                         HGCMSvcSetPv(&aReplyParams[3], NULL, 0);                      /* data buffer */
-                        hostCallback(GUEST_FILE_NOTIFY, 4, aReplyParams);
+                        hostCallback(GUEST_MSG_FILE_NOTIFY, 4, aReplyParams);
                         break;
-                    case HOST_FILE_WRITE:
-                    case HOST_FILE_WRITE_AT:
+                    case HOST_MSG_FILE_WRITE:
+                    case HOST_MSG_FILE_WRITE_AT:
                         HGCMSvcSetU32(&aReplyParams[1], GUEST_FILE_NOTIFYTYPE_WRITE); /* type */
                         HGCMSvcSetU32(&aReplyParams[2], rcSkip);                      /* rc */
                         HGCMSvcSetU32(&aReplyParams[3], 0);                           /* bytes written */
-                        hostCallback(GUEST_FILE_NOTIFY, 4, aReplyParams);
+                        hostCallback(GUEST_MSG_FILE_NOTIFY, 4, aReplyParams);
                         break;
-                    case HOST_FILE_SEEK:
+                    case HOST_MSG_FILE_SEEK:
                         HGCMSvcSetU32(&aReplyParams[1], GUEST_FILE_NOTIFYTYPE_SEEK);  /* type */
                         HGCMSvcSetU32(&aReplyParams[2], rcSkip);                      /* rc */
                         HGCMSvcSetU64(&aReplyParams[3], 0);                           /* actual */
-                        hostCallback(GUEST_FILE_NOTIFY, 4, aReplyParams);
+                        hostCallback(GUEST_MSG_FILE_NOTIFY, 4, aReplyParams);
                         break;
-                    case HOST_FILE_TELL:
+                    case HOST_MSG_FILE_TELL:
                         HGCMSvcSetU32(&aReplyParams[1], GUEST_FILE_NOTIFYTYPE_TELL);  /* type */
                         HGCMSvcSetU32(&aReplyParams[2], rcSkip);                      /* rc */
                         HGCMSvcSetU64(&aReplyParams[3], 0);                           /* actual */
-                        hostCallback(GUEST_FILE_NOTIFY, 4, aReplyParams);
+                        hostCallback(GUEST_MSG_FILE_NOTIFY, 4, aReplyParams);
                         break;
 
-                    case HOST_EXEC_GET_OUTPUT: /** @todo This can't be right/work. */
-                    case HOST_EXEC_TERMINATE:  /** @todo This can't be right/work. */
-                    case HOST_EXEC_WAIT_FOR:   /** @todo This can't be right/work. */
-                    case HOST_PATH_USER_DOCUMENTS:
-                    case HOST_PATH_USER_HOME:
-                    case HOST_PATH_RENAME:
-                    case HOST_DIR_REMOVE:
+                    case HOST_MSG_EXEC_GET_OUTPUT: /** @todo This can't be right/work. */
+                    case HOST_MSG_EXEC_TERMINATE:  /** @todo This can't be right/work. */
+                    case HOST_MSG_EXEC_WAIT_FOR:   /** @todo This can't be right/work. */
+                    case HOST_MSG_PATH_USER_DOCUMENTS:
+                    case HOST_MSG_PATH_USER_HOME:
+                    case HOST_MSG_PATH_RENAME:
+                    case HOST_MSG_DIR_REMOVE:
                     default:
-                        HGCMSvcSetU32(&aReplyParams[1], pFirstCmd->mMsgType);
+                        HGCMSvcSetU32(&aReplyParams[1], pFirstMsg->mType);
                         HGCMSvcSetU32(&aReplyParams[2], (uint32_t)rcSkip);
                         HGCMSvcSetPv(&aReplyParams[3], NULL, 0);
@@ -1520 +1516 @@
 
                 /*
-                 * Free the command.
+                 * Free the message.
                  */
-                pFirstCmd->Delete();
+                pFirstMsg->Delete();
             }
             else
@@ -1528 +1524 @@
             return VINF_HGCM_ASYNC_EXECUTE; /* The caller must not complete it. */
         }
-        LogFunc(("Warning: GUEST_MSG_SKIP mismatch! Found %u, caller expected %u!\n", pFirstCmd->mMsgType, idMsg));
+        LogFunc(("Warning: GUEST_MSG_SKIP mismatch! Found %u, caller expected %u!\n", pFirstMsg->mType, idMsg));
         return VERR_MISMATCH;
     }
@@ -1596 +1592 @@
 
     /*
-     * Try complete the command.
+     * Try complete the message.
      */
     int rc = mpHelpers->pfnCallComplete(hCall, VINF_SUCCESS);
@@ -1786 +1782 @@
 
     /*
-     * Forward the command to the destiation.
+     * Forward the message to the destiation.
      * Since we modify the first parameter, we must make a copy of the parameters.
      */
@@ -1792 +1788 @@
     HGCMSvcSetU64(&aParms[0], idContext | VBOX_GUESTCTRL_DST_SESSION);
     HGCMSvcSetU32(&aParms[1], fFlags);
-    int rc = hostProcessCommand(HOST_SESSION_CLOSE, RT_ELEMENTS(aParms), aParms);
+    int rc = hostProcessMessage(HOST_MSG_SESSION_CLOSE, RT_ELEMENTS(aParms), aParms);
 
     LogFlowFunc(("Closing guest context ID=%RU32 (from client ID=%RU32) returned with rc=%Rrc\n", idContext, pClient->m_idClient, rc));
@@ -1871 +1867 @@
 
 /**
- * For compatibility with old additions only - skip the current command w/o
+ * For compatibility with old additions only - skip the current message w/o
  * calling main code.
  *
@@ -1899 +1895 @@
      *       So, we have to track whether they issued a MSG_REPLY or not.  Wonderful.
      */
-    HostCommand *pFirstCmd = RTListGetFirstCpp(&pClient->m_HostCmdList, HostCommand, m_ListEntry);
-    if (pFirstCmd)
-    {
-        uint32_t const idMsg             = pFirstCmd->mMsgType;
-        bool const     f60BetaHackInPlay = pFirstCmd->m_f60BetaHackInPlay;
+    HostMsg *pFirstMsg = RTListGetFirstCpp(&pClient->m_HostMsgList, HostMsg, m_ListEntry);
+    if (pFirstMsg)
+    {
+        uint32_t const idMsg             = pFirstMsg->mType;
+        bool const     f60BetaHackInPlay = pFirstMsg->m_f60BetaHackInPlay;
         int            rc;
         if (!f60BetaHackInPlay)
@@ -1909 +1905 @@
         else
         {
-            RTListNodeRemove(&pFirstCmd->m_ListEntry);
-            pFirstCmd->Delete();
+            RTListNodeRemove(&pFirstMsg->m_ListEntry);
+            pFirstMsg->Delete();
             rc = VINF_SUCCESS;
         }
@@ -1917 +1913 @@
         if (RT_SUCCESS(rc))
         {
-            pClient->mHostCmdRc    = VINF_SUCCESS;
-            pClient->mHostCmdTries = 0;
+            pClient->mHostMsgRc    = VINF_SUCCESS;
+            pClient->mHostMsgTries = 0;
             pClient->mPeekCount    = 0;
         }
 
         LogFlowFunc(("[Client %RU32] Legacy message skipping: Skipped %u (%s)%s!\n",
-                     pClient->m_idClient, idMsg, GstCtrlHostFnName((eHostFn)idMsg), f60BetaHackInPlay ? " hack style" : ""));
+                     pClient->m_idClient, idMsg, GstCtrlHostMsgtoStr((eHostMsg)idMsg), f60BetaHackInPlay ? " hack style" : ""));
         NOREF(idMsg);
         return rc;
@@ -1939 +1935 @@
  * @returns VBox status code.
  * @param   pClient         The client state.
- * @param   idFunction      Function (event) that occured.
+ * @param   idMsg           Message ID that occured.
  * @param   cParms          Number of parameters.
  * @param   paParms         Array of parameters.
  */
-int GstCtrlService::clientToMain(ClientState *pClient, uint32_t idFunction, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
+int GstCtrlService::clientToMain(ClientState *pClient, uint32_t idMsg, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
 {
     /*
@@ -1958 +1954 @@
                             || (   m_fLegacyMode                                /* (see bugref:9313#c16) */
                                 && pClient->m_idSession == UINT32_MAX
-                                && (   idFunction == GUEST_EXEC_STATUS
-                                    || idFunction == GUEST_SESSION_NOTIFY)),
-                            ("idSession=%u (CID=%#x) m_idSession=%u idClient=%u idFunction=%u (%s)\n", idSession, idContext,
-                             pClient->m_idSession, pClient->m_idClient, idFunction, GstCtrlGuestFnName((eGuestFn)idFunction)),
+                                && (   idMsg == GUEST_MSG_EXEC_STATUS
+                                    || idMsg == GUEST_MSG_SESSION_NOTIFY)),
+                            ("idSession=%u (CID=%#x) m_idSession=%u idClient=%u idMsg=%u (%s)\n", idSession, idContext,
+                             pClient->m_idSession, pClient->m_idClient, idMsg, GstCtrlGuestMsgToStr((eGuestMsg)idMsg)),
                             VERR_ACCESS_DENIED);
 
@@ -1967 +1963 @@
      * It seems okay, so make the call.
      */
-    return hostCallback(idFunction, cParms, paParms);
+    return hostCallback(idMsg, cParms, paParms);
 }
 
@@ -1981 +1977 @@
 /*static*/ DECLCALLBACK(void)
 GstCtrlService::svcCall(void *pvService, VBOXHGCMCALLHANDLE hCall, uint32_t idClient, void *pvClient,
-                        uint32_t idFunction, uint32_t cParms, VBOXHGCMSVCPARM paParms[], uint64_t tsArrival)
-{
-    LogFlowFunc(("[Client %RU32] idFunction=%RU32 (%s), cParms=%RU32, paParms=0x%p\n",
-                 idClient, idFunction, GstCtrlGuestFnName((eGuestFn)idFunction), cParms, paParms));
+                        uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[], uint64_t tsArrival)
+{
+    LogFlowFunc(("[Client %RU32] u32Function=%RU32 (%s), cParms=%RU32, paParms=0x%p\n",
+                 idClient, u32Function, GstCtrlGuestMsgToStr((eGuestMsg)u32Function), cParms, paParms));
     RT_NOREF(tsArrival, idClient);
 
@@ -2000 +1996 @@
      */
     int rc;
-    switch (idFunction)
-    {
-        case GUEST_MAKE_ME_MASTER:
+    switch (u32Function)
+    {
+        case GUEST_MSG_MAKE_ME_MASTER:
             LogFlowFunc(("[Client %RU32] GUEST_MAKE_ME_MASTER\n", idClient));
             rc = pThis->clientMakeMeMaster(pClient, hCall, cParms);
@@ -2026 +2022 @@
             rc = pThis->clientMsgSkip(pClient, hCall, cParms, paParms);
             break;
-        case GUEST_SESSION_PREPARE:
+        case GUEST_MSG_SESSION_PREPARE:
             LogFlowFunc(("[Client %RU32] GUEST_SESSION_PREPARE\n", idClient));
             rc = pThis->clientSessionPrepare(pClient, hCall, cParms, paParms);
             break;
-        case GUEST_SESSION_CANCEL_PREPARED:
+        case GUEST_MSG_SESSION_CANCEL_PREPARED:
             LogFlowFunc(("[Client %RU32] GUEST_SESSION_CANCEL_PREPARED\n", idClient));
             rc = pThis->clientSessionCancelPrepared(pClient, cParms, paParms);
             break;
-        case GUEST_SESSION_ACCEPT:
+        case GUEST_MSG_SESSION_ACCEPT:
             LogFlowFunc(("[Client %RU32] GUEST_SESSION_ACCEPT\n", idClient));
             rc = pThis->clientSessionAccept(pClient, hCall, cParms, paParms);
             break;
-        case GUEST_SESSION_CLOSE:
+        case GUEST_MSG_SESSION_CLOSE:
             LogFlowFunc(("[Client %RU32] GUEST_SESSION_CLOSE\n", idClient));
             rc = pThis->clientSessionCloseOther(pClient, cParms, paParms);
@@ -2049 +2045 @@
             if (cParms >= 3 && paParms[2].u.uint32 == (uint32_t)VERR_NOT_SUPPORTED)
             {
-                HostCommand *pFirstCmd = RTListGetFirstCpp(&pClient->m_HostCmdList, HostCommand, m_ListEntry);
-                if (pFirstCmd && pFirstCmd->m_idContext == paParms[0].u.uint32)
-                    pFirstCmd->m_f60BetaHackInPlay = true;
+                HostMsg *pFirstMsg = RTListGetFirstCpp(&pClient->m_HostMsgList, HostMsg, m_ListEntry);
+                if (pFirstMsg && pFirstMsg->m_idContext == paParms[0].u.uint32)
+                    pFirstMsg->m_f60BetaHackInPlay = true;
             }
             RT_FALL_THROUGH();
         case GUEST_MSG_PROGRESS_UPDATE:
-        case GUEST_SESSION_NOTIFY:
-        case GUEST_EXEC_OUTPUT:
-        case GUEST_EXEC_STATUS:
-        case GUEST_EXEC_INPUT_STATUS:
-        case GUEST_EXEC_IO_NOTIFY:
-        case GUEST_DIR_NOTIFY:
-        case GUEST_FILE_NOTIFY:
-            LogFlowFunc(("[Client %RU32] %s\n", idClient, GstCtrlGuestFnName((eGuestFn)idFunction)));
-            rc = pThis->clientToMain(pClient, idFunction, cParms, paParms);
+        case GUEST_MSG_SESSION_NOTIFY:
+        case GUEST_MSG_EXEC_OUTPUT:
+        case GUEST_MSG_EXEC_STATUS:
+        case GUEST_MSG_EXEC_INPUT_STATUS:
+        case GUEST_MSG_EXEC_IO_NOTIFY:
+        case GUEST_MSG_DIR_NOTIFY:
+        case GUEST_MSG_FILE_NOTIFY:
+            LogFlowFunc(("[Client %RU32] %s\n", idClient, GstCtrlGuestMsgToStr((eGuestMsg)u32Function)));
+            rc = pThis->clientToMain(pClient, u32Function /* Msg */, cParms, paParms);
             Assert(rc != VINF_HGCM_ASYNC_EXECUTE);
             break;
 
         /*
-         * The remaining commands are here for compatibility with older guest additions:
+         * The remaining messages are here for compatibility with older Guest Additions:
          */
         case GUEST_MSG_WAIT:
@@ -2097 +2093 @@
          */
         default:
-            ASSERT_GUEST_MSG_FAILED(("idFunction=%d (%#x)\n", idFunction, idFunction));
+            ASSERT_GUEST_MSG_FAILED(("u32Function=%RU32 (%#x)\n", u32Function, u32Function));
             rc = VERR_INVALID_FUNCTION;
             break;
@@ -2117 +2113 @@
  *
  * @returns VBox status code.
- * @param   idFunction      Function (event) that occured.
+ * @param   u32Function     Message ID that occured.
  * @param   cParms          Number of parameters.
  * @param   paParms         Array of parameters.
  */
-int GstCtrlService::hostCallback(uint32_t idFunction, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
-{
-    LogFlowFunc(("idFunction=%u (%s), cParms=%ld, paParms=%p\n", idFunction, GstCtrlGuestFnName((eGuestFn)idFunction), cParms, paParms));
+int GstCtrlService::hostCallback(uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
+{
+    LogFlowFunc(("u32Function=%RU32 (%s), cParms=%ld, paParms=%p\n",
+                 u32Function, GstCtrlGuestMsgToStr((eGuestMsg)u32Function), cParms, paParms));
 
     int rc;
@@ -2129 +2126 @@
     {
         VBOXGUESTCTRLHOSTCALLBACK data(cParms, paParms);
-        rc = mpfnHostCallback(mpvHostData, idFunction, &data, sizeof(data));
+        rc = mpfnHostCallback(mpvHostData, u32Function, &data, sizeof(data));
     }
     else
@@ -2140 +2137 @@
 
 /**
- * Processes a command received from the host side and re-routes it to
+ * Processes a message received from the host side and re-routes it to
  * a connect client on the guest.
  *
  * @returns VBox status code.
- * @param   idFunction  Function code to process.
+ * @param   idMsg   Message ID to process.
  * @param   cParms      Number of parameters.
  * @param   paParms     Array of parameters.
  */
-int GstCtrlService::hostProcessCommand(uint32_t idFunction, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
-{
-    /*
-     * If no client is connected at all we don't buffer any host commands
+int GstCtrlService::hostProcessMessage(uint32_t idMsg, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
+{
+    /*
+     * If no client is connected at all we don't buffer any host messages
      * and immediately return an error to the host.  This avoids the host
      * waiting for a response from the guest side in case VBoxService on
@@ -2158 +2155 @@
     if (m_ClientStateMap.empty())
     {
-        LogFlow(("GstCtrlService::hostProcessCommand: VERR_NOT_FOUND!\n"));
+        LogFlow(("GstCtrlService::hostProcessMessage: VERR_NOT_FOUND!\n"));
         return VERR_NOT_FOUND;
     }
 
     /*
-     * Create a host command for each destination.
+     * Create a host message for each destination.
      * Note! There is currently only one scenario in which we send a host
-     *       command to two recipients.
-     */
-    HostCommand *pHostCmd = new (std::nothrow) HostCommand();
-    AssertReturn(pHostCmd, VERR_NO_MEMORY);
-    int rc = pHostCmd->Init(idFunction, cParms, paParms);
+     *       message to two recipients.
+     */
+    HostMsg *pHostMsg = new (std::nothrow) HostMsg();
+    AssertReturn(pHostMsg, VERR_NO_MEMORY);
+    int rc = pHostMsg->Init(idMsg, cParms, paParms);
     if (RT_SUCCESS(rc))
     {
-        uint64_t const fDestinations = pHostCmd->m_idContextAndDst & VBOX_GUESTCTRL_DST_BOTH;
-        HostCommand   *pHostCmd2     = NULL;
+        uint64_t const fDestinations = pHostMsg->m_idContextAndDst & VBOX_GUESTCTRL_DST_BOTH;
+        HostMsg       *pHostMsg2     = NULL;
         if (fDestinations != VBOX_GUESTCTRL_DST_BOTH)
         { /* likely */ }
         else
         {
-            pHostCmd2 = new (std::nothrow) HostCommand();
-            if (pHostCmd2)
-                rc = pHostCmd2->Init(idFunction, cParms, paParms);
+            pHostMsg2 = new (std::nothrow) HostMsg();
+            if (pHostMsg2)
+                rc = pHostMsg2->Init(idMsg, cParms, paParms);
             else
                 rc = VERR_NO_MEMORY;
@@ -2186 +2183 @@
         if (RT_SUCCESS(rc))
         {
-            LogFlowFunc(("Handling host command m_idContextAndDst=%#RX64, idFunction=%RU32, cParms=%RU32, paParms=%p, cClients=%zu\n",
-                         pHostCmd->m_idContextAndDst, idFunction, cParms, paParms, m_ClientStateMap.size()));
+            LogFlowFunc(("Handling host message m_idContextAndDst=%#RX64, idMsg=%RU32, cParms=%RU32, paParms=%p, cClients=%zu\n",
+                         pHostMsg->m_idContextAndDst, idMsg, cParms, paParms, m_ClientStateMap.size()));
 
             /*
@@ -2198 +2195 @@
             if (fDestinations & VBOX_GUESTCTRL_DST_SESSION)
             {
-                uint32_t const idSession = VBOX_GUESTCTRL_CONTEXTID_GET_SESSION(pHostCmd->m_idContext);
+                uint32_t const idSession = VBOX_GUESTCTRL_CONTEXTID_GET_SESSION(pHostMsg->m_idContext);
                 ClientStateMap::iterator It = m_SessionIdMap.find(idSession);
                 if (It != m_SessionIdMap.end())
@@ -2204 +2201 @@
                     ClientState *pClient = It->second;
                     Assert(pClient->m_idSession == idSession);
-                    RTListAppend(&pClient->m_HostCmdList, &pHostCmd->m_ListEntry);
-                    pHostCmd  = pHostCmd2;
-                    pHostCmd2 = NULL;
+                    RTListAppend(&pClient->m_HostMsgList, &pHostMsg->m_ListEntry);
+                    pHostMsg  = pHostMsg2;
+                    pHostMsg2 = NULL;
 
                     int rc2 = pClient->Wakeup();
@@ -2215 +2212 @@
                 else
                 {
-                    LogFunc(("No client with session ID %u was found! (idFunction=%d %s)\n",
-                             idSession, idFunction, GstCtrlHostFnName((eHostFn)idFunction)));
+                    LogFunc(("No client with session ID %u was found! (idMsg=%d %s)\n",
+                             idSession, idMsg, GstCtrlHostMsgtoStr((eHostMsg)idMsg)));
                     rc = !(fDestinations & VBOX_GUESTCTRL_DST_ROOT_SVC) ? VERR_NOT_FOUND : VWRN_NOT_FOUND;
                 }
@@ -2225 +2222 @@
                 && RT_SUCCESS(rc))
             {
-                Assert(pHostCmd);
+                Assert(pHostMsg);
                 if (m_pMasterClient)
                 {
-                    RTListAppend(&m_pMasterClient->m_HostCmdList, &pHostCmd->m_ListEntry);
-                    pHostCmd = NULL;
+                    RTListAppend(&m_pMasterClient->m_HostMsgList, &pHostMsg->m_ListEntry);
+                    pHostMsg = NULL;
 
                     int rc2 = m_pMasterClient->Wakeup();
@@ -2240 +2237 @@
         }
 
-        /* Drop unset commands */
-        if (pHostCmd2)
-            pHostCmd2->Delete();
-    }
-    if (pHostCmd)
-        pHostCmd->Delete();
+        /* Drop unset messages. */
+        if (pHostMsg2)
+            pHostMsg2->Delete();
+    }
+    if (pHostMsg)
+        pHostMsg->Delete();
 
     if (RT_FAILURE(rc))
-        LogFunc(("Failed %Rrc (idFunction=%u, cParms=%u)\n", rc, idFunction, cParms));
+        LogFunc(("Failed %Rrc (idMsg=%u, cParms=%u)\n", rc, idMsg, cParms));
     return rc;
 }
@@ -2255 +2252 @@
 /**
  * @interface_method_impl{VBOXHGCMSVCFNTABLE,pfnHostCall,
- *  Wraps to the hostProcessCommand() member function.}
+ *  Wraps to the hostProcessMessage() member function.}
  */
 /*static*/ DECLCALLBACK(int)
@@ -2264 +2261 @@
     AssertPtrReturn(pThis, VERR_INVALID_POINTER);
 
-    LogFlowFunc(("fn=%RU32, cParms=%RU32, paParms=0x%p\n", u32Function, cParms, paParms));
-    AssertReturn(u32Function != HOST_CANCEL_PENDING_WAITS, VERR_INVALID_FUNCTION);
-    return pThis->hostProcessCommand(u32Function, cParms, paParms);
+    LogFlowFunc(("u32Function=%RU32, cParms=%RU32, paParms=0x%p\n", u32Function, cParms, paParms));
+    AssertReturn(u32Function != HOST_MSG_CANCEL_PENDING_WAITS, VERR_INVALID_FUNCTION);
+    return pThis->hostProcessMessage(u32Function, cParms, paParms);
 }
 

trunk/src/VBox/HostServices/GuestControl/testcase/tstGuestControlSvc.cpp

@@ -179 +179 @@
 
         /** Client connected, invalid parameters given. */
-        { HOST_EXEC_CMD, 1024, 0, true, VERR_INVALID_POINTER },
-        { HOST_EXEC_CMD, 1, 0, true, VERR_INVALID_POINTER },
-        { HOST_EXEC_CMD, -1, 0, true, VERR_INVALID_POINTER },
+        { HOST_MSG_EXEC_CMD, 1024, 0, true, VERR_INVALID_POINTER },
+        { HOST_MSG_EXEC_CMD, 1, 0, true, VERR_INVALID_POINTER },
+        { HOST_MSG_EXEC_CMD, -1, 0, true, VERR_INVALID_POINTER },
 
         /** Client connected, parameters given. */
-        { HOST_CANCEL_PENDING_WAITS, 1, &aParms[0], true, VINF_SUCCESS },
-        { HOST_EXEC_CMD, 1, &aParms[0], true, VINF_SUCCESS },
-        { HOST_EXEC_SET_INPUT, 1, &aParms[0], true, VINF_SUCCESS },
-        { HOST_EXEC_GET_OUTPUT, 1, &aParms[0], true, VINF_SUCCESS },
+        { HOST_MSG_CANCEL_PENDING_WAITS, 1, &aParms[0], true, VINF_SUCCESS },
+        { HOST_MSG_EXEC_CMD, 1, &aParms[0], true, VINF_SUCCESS },
+        { HOST_MSG_EXEC_SET_INPUT, 1, &aParms[0], true, VINF_SUCCESS },
+        { HOST_MSG_EXEC_GET_OUTPUT, 1, &aParms[0], true, VINF_SUCCESS },
 
         /** Client connected, unknown command + valid parameters given. */
@@ -221 +221 @@
         HGCMSvcSetStr(&aParmsHost[2], "baz");
 
-        rc = pTable->pfnHostCall(pTable->pvService, HOST_EXEC_CMD, 3, &aParmsHost[0]);
+        rc = pTable->pfnHostCall(pTable->pvService, HOST_MSG_EXEC_CMD, 3, &aParmsHost[0]);
         RTTEST_CHECK_RC_RET(g_hTest, rc, VINF_SUCCESS, rc);
 

@@ -8 +8 @@
 /branches/VBox-5.0/src/VBox:104938,104943,104950,104987-104988,104990,106453
 /branches/VBox-5.1/src/VBox:112367,116543,116550,116568,116573
-/branches/VBox-5.2/src/VBox:119536,120083,120099,120213,120221,120239,123597-123598,123600-123601,123755,124263,124273,124277-124279,124284-124286,124288-124290,125768,125779-125780,125812
+/branches/VBox-5.2/src/VBox:119536,120083,120099,120213,120221,120239,123597-123598,123600-123601,123755,124263,124273,124277-124279,124284-124286,124288-124290,125768,125779-125780,125812,127158-127159,127162-127167,127180
 /branches/andy/draganddrop/src/VBox:90781-91268
 /branches/andy/guestctrl20/src/VBox:78916,78930