Index: /trunk/include/VBox/HostServices/GuestControlSvc.h =================================================================== --- /trunk/include/VBox/HostServices/GuestControlSvc.h (revision 76957) +++ /trunk/include/VBox/HostServices/GuestControlSvc.h (revision 76958) @@ -87,6 +87,6 @@ typedef struct VBoxGuestCtrlHostCbCtx { - /** HGCM Function number. */ - uint32_t uFunction; + /** HGCM message number. */ + uint32_t uMessage; /** The context ID. */ uint32_t uContextID; @@ -126,128 +126,129 @@ /** - * The service functions which are callable by host. - */ -enum eHostFn + * The service messages which are callable by host. + */ +enum eHostMsg { /** * The host asks the client to cancel all pending waits and exit. */ - HOST_CANCEL_PENDING_WAITS = 0, + HOST_MSG_CANCEL_PENDING_WAITS = 0, /** * The host wants to create a guest session. */ - HOST_SESSION_CREATE = 20, + HOST_MSG_SESSION_CREATE = 20, /** * The host wants to close a guest session. */ - HOST_SESSION_CLOSE = 21, + HOST_MSG_SESSION_CLOSE = 21, /** * The host wants to execute something in the guest. This can be a command line * or starting a program. - ** Note: Legacy (VBox < 4.3) command. - */ - HOST_EXEC_CMD = 100, + ** Note: Legacy (VBox < 4.3) message. + */ + HOST_MSG_EXEC_CMD = 100, /** * Sends input data for stdin to a running process executed by HOST_EXEC_CMD. - ** Note: Legacy (VBox < 4.3) command. - */ - HOST_EXEC_SET_INPUT = 101, + ** Note: Legacy (VBox < 4.3) message. + */ + HOST_MSG_EXEC_SET_INPUT = 101, /** * Gets the current status of a running process, e.g. * new data on stdout/stderr, process terminated etc. - * @note Legacy (VBox < 4.3) command. - */ - HOST_EXEC_GET_OUTPUT = 102, + * @note Legacy (VBox < 4.3) message. + */ + HOST_MSG_EXEC_GET_OUTPUT = 102, /** * Terminates a running guest process. */ - HOST_EXEC_TERMINATE = 110, + HOST_MSG_EXEC_TERMINATE = 110, /** * Waits for a certain event to happen. This can be an input, output * or status event. */ - HOST_EXEC_WAIT_FOR = 120, + HOST_MSG_EXEC_WAIT_FOR = 120, /** * Opens a guest file. */ - HOST_FILE_OPEN = 240, + HOST_MSG_FILE_OPEN = 240, /** * Closes a guest file. */ - HOST_FILE_CLOSE = 241, + HOST_MSG_FILE_CLOSE = 241, /** * Reads from an opened guest file. */ - HOST_FILE_READ = 250, + HOST_MSG_FILE_READ = 250, /** * Reads from an opened guest file at * a specified offset. */ - HOST_FILE_READ_AT = 251, + HOST_MSG_FILE_READ_AT = 251, /** * Write to an opened guest file. */ - HOST_FILE_WRITE = 260, + HOST_MSG_FILE_WRITE = 260, /** * Write to an opened guest file at * a specified offset. */ - HOST_FILE_WRITE_AT = 261, + HOST_MSG_FILE_WRITE_AT = 261, /** * Changes the read & write position of an opened guest file. */ - HOST_FILE_SEEK = 270, + HOST_MSG_FILE_SEEK = 270, /** * Gets the current file position of an opened guest file. */ - HOST_FILE_TELL = 271, + HOST_MSG_FILE_TELL = 271, /** * Removes a directory on the guest. */ - HOST_DIR_REMOVE = 320, + HOST_MSG_DIR_REMOVE = 320, /** * Renames a path on the guest. */ - HOST_PATH_RENAME = 330, + HOST_MSG_PATH_RENAME = 330, /** * Retrieves the user's documents directory. */ - HOST_PATH_USER_DOCUMENTS = 331, + HOST_MSG_PATH_USER_DOCUMENTS = 331, /** * Retrieves the user's home directory. */ - HOST_PATH_USER_HOME = 332 + HOST_MSG_PATH_USER_HOME = 332 }; /** - * Translates a guest control host function function enum to at string. + * Translates a guest control host message enum to a string. + * * @returns Enum string name. - * @param enmFunction The function name to translate. - */ -DECLINLINE(const char *) GstCtrlHostFnName(enum eHostFn enmFunction) -{ - switch (enmFunction) + * @param enmMsg The message to translate. + */ +DECLINLINE(const char *) GstCtrlHostMsgtoStr(enum eHostMsg enmMsg) +{ + switch (enmMsg) { - RT_CASE_RET_STR(HOST_CANCEL_PENDING_WAITS); - RT_CASE_RET_STR(HOST_SESSION_CREATE); - RT_CASE_RET_STR(HOST_SESSION_CLOSE); - RT_CASE_RET_STR(HOST_EXEC_CMD); - RT_CASE_RET_STR(HOST_EXEC_SET_INPUT); - RT_CASE_RET_STR(HOST_EXEC_GET_OUTPUT); - RT_CASE_RET_STR(HOST_EXEC_TERMINATE); - RT_CASE_RET_STR(HOST_EXEC_WAIT_FOR); - RT_CASE_RET_STR(HOST_FILE_OPEN); - RT_CASE_RET_STR(HOST_FILE_CLOSE); - RT_CASE_RET_STR(HOST_FILE_READ); - RT_CASE_RET_STR(HOST_FILE_READ_AT); - RT_CASE_RET_STR(HOST_FILE_WRITE); - RT_CASE_RET_STR(HOST_FILE_WRITE_AT); - RT_CASE_RET_STR(HOST_FILE_SEEK); - RT_CASE_RET_STR(HOST_FILE_TELL); - RT_CASE_RET_STR(HOST_DIR_REMOVE); - RT_CASE_RET_STR(HOST_PATH_RENAME); - RT_CASE_RET_STR(HOST_PATH_USER_DOCUMENTS); - RT_CASE_RET_STR(HOST_PATH_USER_HOME); + RT_CASE_RET_STR(HOST_MSG_CANCEL_PENDING_WAITS); + RT_CASE_RET_STR(HOST_MSG_SESSION_CREATE); + RT_CASE_RET_STR(HOST_MSG_SESSION_CLOSE); + RT_CASE_RET_STR(HOST_MSG_EXEC_CMD); + RT_CASE_RET_STR(HOST_MSG_EXEC_SET_INPUT); + RT_CASE_RET_STR(HOST_MSG_EXEC_GET_OUTPUT); + RT_CASE_RET_STR(HOST_MSG_EXEC_TERMINATE); + RT_CASE_RET_STR(HOST_MSG_EXEC_WAIT_FOR); + RT_CASE_RET_STR(HOST_MSG_FILE_OPEN); + RT_CASE_RET_STR(HOST_MSG_FILE_CLOSE); + RT_CASE_RET_STR(HOST_MSG_FILE_READ); + RT_CASE_RET_STR(HOST_MSG_FILE_READ_AT); + RT_CASE_RET_STR(HOST_MSG_FILE_WRITE); + RT_CASE_RET_STR(HOST_MSG_FILE_WRITE_AT); + RT_CASE_RET_STR(HOST_MSG_FILE_SEEK); + RT_CASE_RET_STR(HOST_MSG_FILE_TELL); + RT_CASE_RET_STR(HOST_MSG_DIR_REMOVE); + RT_CASE_RET_STR(HOST_MSG_PATH_RENAME); + RT_CASE_RET_STR(HOST_MSG_PATH_USER_DOCUMENTS); + RT_CASE_RET_STR(HOST_MSG_PATH_USER_HOME); } return "Unknown"; @@ -256,18 +257,18 @@ /** - * The service functions which are called by guest. + * The service messages which are callable by the guest. * - * @note The function numbers cannot be changed. Please use the first non-zero - * number that's not in use when adding new functions. + * @note The message numbers cannot be changed. Please use the first non-zero + * number that's not in use when adding new messages. * - * @note Remember to update service.cpp when adding new functions/events for - * Main, as it validates all incoming commands before passing them on. - */ -enum eGuestFn + * @note Remember to update service.cpp when adding new messages for Main, + * as it validates all incoming messages before passing them on. + */ +enum eGuestMsg { /** Guest waits for a new message the host wants to process on the guest side. * This is a blocking call and can be deferred. * - * @note This command is rather odd. The above description isn't really + * @note This message is rather odd. The above description isn't really * correct. Yes, it (1) waits for a new message and will return the * mesage number and parameter count when one is available. However, it @@ -303,7 +304,7 @@ * * @note This is a host side notification message that has no business in this - * enum. The guest cannot use this function number, host will reject it. - */ - GUEST_DISCONNECTED = 3, + * enum. The guest cannot use this message number, host will reject it. + */ + GUEST_MSG_DISCONNECTED = 3, /** Sets a message filter to only get messages which have a certain * context ID scheme (that is, a specific session, object etc). @@ -391,7 +392,7 @@ * This skips the current message, replying to the main backend as best it can. * Takes between zero and two parameters. The first parameter is the 32-bit - * VBox status code to pass onto Main when skipping the command, defaults to + * VBox status code to pass onto Main when skipping the message, defaults to * VERR_NOT_SUPPORTED. The second parameter is the 32-bit message ID of the - * command to skip, by default whatever is first in the queue is removed. This + * message to skip, by default whatever is first in the queue is removed. This * is also the case if UINT32_MAX is specified. * @@ -407,5 +408,5 @@ * Skips the current assigned message returned by GUEST_MSG_WAIT. * Needed for telling the host service to not keep stale - * host commands in the queue. + * host messages in the queue. * @deprecated Replaced by GUEST_MSG_SKIP. */ @@ -433,5 +434,5 @@ * @since 6.0 */ - GUEST_MAKE_ME_MASTER = 13, + GUEST_MSG_MAKE_ME_MASTER = 13, /** Prepares the starting of a session. * @@ -455,5 +456,5 @@ * @since 6.0 */ - GUEST_SESSION_PREPARE = 14, + GUEST_MSG_SESSION_PREPARE = 14, /** Cancels a prepared session. * @@ -470,5 +471,5 @@ * @since 6.0 */ - GUEST_SESSION_CANCEL_PREPARED = 15, + GUEST_MSG_SESSION_CANCEL_PREPARED = 15, /** Accepts a prepared session. * @@ -490,15 +491,15 @@ * @since 6.0 */ - GUEST_SESSION_ACCEPT = 16, + GUEST_MSG_SESSION_ACCEPT = 16, /** * Guest reports back a guest session status. * @todo proper docs. */ - GUEST_SESSION_NOTIFY = 20, + GUEST_MSG_SESSION_NOTIFY = 20, /** * Guest wants to close a specific guest session. * @todo proper docs. */ - GUEST_SESSION_CLOSE = 21, + GUEST_MSG_SESSION_CLOSE = 21, /** @@ -506,15 +507,15 @@ * @todo proper docs. */ - GUEST_EXEC_OUTPUT = 100, + GUEST_MSG_EXEC_OUTPUT = 100, /** * Guest sends a status update of an executed process to the host. * @todo proper docs. */ - GUEST_EXEC_STATUS = 101, + GUEST_MSG_EXEC_STATUS = 101, /** * Guests sends an input status notification to the host. * @todo proper docs. */ - GUEST_EXEC_INPUT_STATUS = 102, + GUEST_MSG_EXEC_INPUT_STATUS = 102, /** * Guest notifies the host about some I/O event. This can be @@ -524,29 +525,30 @@ * @todo proper docs. */ - GUEST_EXEC_IO_NOTIFY = 210, + GUEST_MSG_EXEC_IO_NOTIFY = 210, /** * Guest notifies the host about some directory event. * @todo proper docs. */ - GUEST_DIR_NOTIFY = 230, + GUEST_MSG_DIR_NOTIFY = 230, /** * Guest notifies the host about some file event. * @todo proper docs. */ - GUEST_FILE_NOTIFY = 240 + GUEST_MSG_FILE_NOTIFY = 240 }; /** - * Translates a guest control host function function enum to at string. + * Translates a guest control guest message enum to a string. + * * @returns Enum string name. - * @param enmFunction The function name to translate. - */ -DECLINLINE(const char *) GstCtrlGuestFnName(enum eGuestFn enmFunction) -{ - switch (enmFunction) + * @param enmMsg The message to translate. + */ +DECLINLINE(const char *) GstCtrlGuestMsgToStr(enum eGuestMsg enmMsg) +{ + switch (enmMsg) { RT_CASE_RET_STR(GUEST_MSG_WAIT); RT_CASE_RET_STR(GUEST_MSG_CANCEL); - RT_CASE_RET_STR(GUEST_DISCONNECTED); + RT_CASE_RET_STR(GUEST_MSG_DISCONNECTED); RT_CASE_RET_STR(GUEST_MSG_FILTER_SET); RT_CASE_RET_STR(GUEST_MSG_FILTER_UNSET); @@ -558,16 +560,16 @@ RT_CASE_RET_STR(GUEST_MSG_PROGRESS_UPDATE); RT_CASE_RET_STR(GUEST_MSG_SKIP); - RT_CASE_RET_STR(GUEST_MAKE_ME_MASTER); - RT_CASE_RET_STR(GUEST_SESSION_PREPARE); - RT_CASE_RET_STR(GUEST_SESSION_CANCEL_PREPARED); - RT_CASE_RET_STR(GUEST_SESSION_ACCEPT); - RT_CASE_RET_STR(GUEST_SESSION_NOTIFY); - RT_CASE_RET_STR(GUEST_SESSION_CLOSE); - RT_CASE_RET_STR(GUEST_EXEC_OUTPUT); - RT_CASE_RET_STR(GUEST_EXEC_STATUS); - RT_CASE_RET_STR(GUEST_EXEC_INPUT_STATUS); - RT_CASE_RET_STR(GUEST_EXEC_IO_NOTIFY); - RT_CASE_RET_STR(GUEST_DIR_NOTIFY); - RT_CASE_RET_STR(GUEST_FILE_NOTIFY); + RT_CASE_RET_STR(GUEST_MSG_MAKE_ME_MASTER); + RT_CASE_RET_STR(GUEST_MSG_SESSION_PREPARE); + RT_CASE_RET_STR(GUEST_MSG_SESSION_CANCEL_PREPARED); + RT_CASE_RET_STR(GUEST_MSG_SESSION_ACCEPT); + RT_CASE_RET_STR(GUEST_MSG_SESSION_NOTIFY); + RT_CASE_RET_STR(GUEST_MSG_SESSION_CLOSE); + RT_CASE_RET_STR(GUEST_MSG_EXEC_OUTPUT); + RT_CASE_RET_STR(GUEST_MSG_EXEC_STATUS); + RT_CASE_RET_STR(GUEST_MSG_EXEC_INPUT_STATUS); + RT_CASE_RET_STR(GUEST_MSG_EXEC_IO_NOTIFY); + RT_CASE_RET_STR(GUEST_MSG_DIR_NOTIFY); + RT_CASE_RET_STR(GUEST_MSG_FILE_NOTIFY); } return "Unknown"; @@ -655,31 +657,27 @@ /** - * Waits for a host command to arrive. The structure then contains the + * Waits for a host message to arrive. The structure then contains the * actual message type + required number of parameters needed to successfully - * retrieve that host command (in a next round). - */ -typedef struct HGCMMsgCmdWaitFor -{ - VBGLIOCHGCMCALL hdr; - /** - * The returned command the host wants to - * run on the guest. - */ + * retrieve that host message (in a next round). + */ +typedef struct HGCMMsgWaitFor +{ + VBGLIOCHGCMCALL hdr; + /** The returned message the host wants to run on the guest. */ HGCMFunctionParameter msg; /* OUT uint32_t */ /** Number of parameters the message needs. */ HGCMFunctionParameter num_parms; /* OUT uint32_t */ -} HGCMMsgCmdWaitFor; - -/** - * Asks the guest control host service to set a command +} HGCMMsgWaitFor; + +/** + * Asks the guest control host service to set a message * filter for this client. This filter will then only * deliver messages to the client which match the * wanted context ID (ranges). */ -typedef struct HGCMMsgCmdFilterSet -{ - VBGLIOCHGCMCALL hdr; - /** Value to filter for after filter mask - * was applied. */ +typedef struct HGCMMsgFilterSet +{ + VBGLIOCHGCMCALL hdr; + /** Value to filter for after filter mask was applied. */ HGCMFunctionParameter value; /* IN uint32_t */ /** Mask to add to the current set filter. */ @@ -689,5 +687,5 @@ /** Filter flags; currently unused. */ HGCMFunctionParameter flags; /* IN uint32_t */ -} HGCMMsgCmdFilterSet; +} HGCMMsgFilterSet; /** @@ -695,22 +693,22 @@ * a previously set message filter again. */ -typedef struct HGCMMsgCmdFilterUnset +typedef struct HGCMMsgFilterUnset { VBGLIOCHGCMCALL hdr; /** Unset flags; currently unused. */ HGCMFunctionParameter flags; /* IN uint32_t */ -} HGCMMsgCmdFilterUnset; +} HGCMMsgFilterUnset; /** * Asks the guest control host service to skip the - * currently assigned host command returned by + * currently assigned host message returned by * VbglR3GuestCtrlMsgWaitFor(). */ -typedef struct HGCMMsgCmdSkip +typedef struct HGCMMsgSkip { VBGLIOCHGCMCALL hdr; /** Skip flags; currently unused. */ HGCMFunctionParameter flags; /* IN uint32_t */ -} HGCMMsgCmdSkip; +} HGCMMsgSkip; /** @@ -723,5 +721,5 @@ } HGCMMsgCancelPendingWaits; -typedef struct HGCMMsgCmdReply +typedef struct HGCMMsgReply { VBGLIOCHGCMCALL hdr; @@ -734,5 +732,5 @@ /** Optional payload to this reply. */ HGCMFunctionParameter payload; -} HGCMMsgCmdReply; +} HGCMMsgReply; /** Index: /trunk/src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR3LibGuestCtrl.cpp =================================================================== --- /trunk/src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR3LibGuestCtrl.cpp (revision 76957) +++ /trunk/src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR3LibGuestCtrl.cpp (revision 76958) @@ -94,7 +94,7 @@ AssertPtrReturn(pcParameters, VERR_INVALID_POINTER); - HGCMMsgCmdWaitFor Msg; + HGCMMsgWaitFor Msg; VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, - GUEST_MSG_WAIT, /* Tell the host we want our next command. */ + GUEST_MSG_WAIT, /* Tell the host we want our next message. */ 2); /* Just peek for the next message! */ VbglHGCMParmUInt32Set(&Msg.msg, 0); @@ -103,5 +103,5 @@ /* * We should always get a VERR_TOO_MUCH_DATA response here, see - * guestControl::HostCommand::Peek() and its caller ClientState::SendReply(). + * guestControl::HostMessage::Peek() and its caller ClientState::SendReply(). * We accept success too here, in case someone decide to make the protocol * slightly more sane. @@ -166,5 +166,5 @@ /* * Seems we get VINF_SUCCESS back from the host if we try unsupported - * guest control functions, so we need to supply some random message + * guest control messages, so we need to supply some random message * parameters and check that they change. */ @@ -301,5 +301,5 @@ { VBGLIOCHGCMCALL Hdr; - VBGL_HGCM_HDR_INIT(&Hdr, idClient, GUEST_MAKE_ME_MASTER, 0); + VBGL_HGCM_HDR_INIT(&Hdr, idClient, GUEST_MSG_MAKE_ME_MASTER, 0); rc = VbglR3HGCMCall(&Hdr, sizeof(Hdr)); } while (rc == VERR_INTERRUPTED); @@ -403,6 +403,6 @@ /** - * Asks the host guest control service to set a command filter to this - * client so that it only will receive certain commands in the future. + * Asks the host guest control service to set a message filter to this + * client so that it only will receive certain messages in the future. * The filter(s) are a bitmask for the context IDs, served from the host. * @@ -415,5 +415,5 @@ VBGLR3DECL(int) VbglR3GuestCtrlMsgFilterSet(uint32_t idClient, uint32_t uValue, uint32_t uMaskAdd, uint32_t uMaskRemove) { - HGCMMsgCmdFilterSet Msg; + HGCMMsgFilterSet Msg; /* Tell the host we want to set a filter. */ @@ -443,5 +443,5 @@ /* Everything else is optional. */ - HGCMMsgCmdReply Msg; + HGCMMsgReply Msg; VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, GUEST_MSG_REPLY, 4); VbglHGCMParmUInt32Set(&Msg.context, pCtx->uContextID); @@ -491,7 +491,7 @@ VBGLR3DECL(int) VbglR3GuestCtrlMsgSkipOld(uint32_t idClient) { - HGCMMsgCmdSkip Msg; - - /* Tell the host we want to skip the current assigned command. */ + HGCMMsgSkip Msg; + + /* Tell the host we want to skip the current assigned message. */ VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, GUEST_MSG_SKIP_OLD, 1); VbglHGCMParmUInt32Set(&Msg.flags, 0 /* Flags, unused */); @@ -530,5 +530,5 @@ HGCMFunctionParameter pKey; } Msg; - VBGL_HGCM_HDR_INIT(&Msg.Hdr, idClient, GUEST_SESSION_PREPARE, 2); + VBGL_HGCM_HDR_INIT(&Msg.Hdr, idClient, GUEST_MSG_SESSION_PREPARE, 2); VbglHGCMParmUInt32Set(&Msg.idSession, idSession); VbglHGCMParmPtrSet(&Msg.pKey, (void *)pvKey, cbKey); @@ -555,5 +555,5 @@ HGCMFunctionParameter pKey; } Msg; - VBGL_HGCM_HDR_INIT(&Msg.Hdr, idClient, GUEST_SESSION_ACCEPT, 2); + VBGL_HGCM_HDR_INIT(&Msg.Hdr, idClient, GUEST_MSG_SESSION_ACCEPT, 2); VbglHGCMParmUInt32Set(&Msg.idSession, idSession); VbglHGCMParmPtrSet(&Msg.pKey, (void *)pvKey, cbKey); @@ -579,5 +579,5 @@ HGCMFunctionParameter idSession; } Msg; - VBGL_HGCM_HDR_INIT(&Msg.Hdr, idClient, GUEST_SESSION_CANCEL_PREPARED, 1); + VBGL_HGCM_HDR_INIT(&Msg.Hdr, idClient, GUEST_MSG_SESSION_CANCEL_PREPARED, 1); VbglHGCMParmUInt32Set(&Msg.idSession, idSession); rc = VbglR3HGCMCall(&Msg.Hdr, sizeof(Msg)); @@ -601,5 +601,5 @@ HGCMMsgSessionClose Msg; - VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, GUEST_SESSION_CLOSE, pCtx->uNumParms); + VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, GUEST_MSG_SESSION_CLOSE, pCtx->uNumParms); VbglHGCMParmUInt32Set(&Msg.context, pCtx->uContextID); VbglHGCMParmUInt32Set(&Msg.flags, fFlags); @@ -614,5 +614,5 @@ HGCMMsgSessionNotify Msg; - VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, GUEST_SESSION_NOTIFY, 3); + VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, GUEST_MSG_SESSION_NOTIFY, 3); VbglHGCMParmUInt32Set(&Msg.context, pCtx->uContextID); VbglHGCMParmUInt32Set(&Msg.type, uType); @@ -647,5 +647,5 @@ HGCMMsgSessionOpen Msg; VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, vbglR3GuestCtrlGetMsgFunctionNo(pCtx->uClientID), pCtx->uNumParms); - VbglHGCMParmUInt32Set(&Msg.context, HOST_SESSION_CREATE); + VbglHGCMParmUInt32Set(&Msg.context, HOST_MSG_SESSION_CREATE); VbglHGCMParmUInt32Set(&Msg.protocol, 0); VbglHGCMParmPtrSet(&Msg.username, pszUser, cbUser); @@ -685,5 +685,5 @@ HGCMMsgSessionClose Msg; VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, vbglR3GuestCtrlGetMsgFunctionNo(pCtx->uClientID), pCtx->uNumParms); - VbglHGCMParmUInt32Set(&Msg.context, HOST_SESSION_CLOSE); + VbglHGCMParmUInt32Set(&Msg.context, HOST_MSG_SESSION_CLOSE); VbglHGCMParmUInt32Set(&Msg.flags, 0); @@ -724,5 +724,5 @@ HGCMMsgPathRename Msg; VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, vbglR3GuestCtrlGetMsgFunctionNo(pCtx->uClientID), pCtx->uNumParms); - VbglHGCMParmUInt32Set(&Msg.context, HOST_PATH_RENAME); + VbglHGCMParmUInt32Set(&Msg.context, HOST_MSG_PATH_RENAME); VbglHGCMParmPtrSet(&Msg.source, pszSource, cbSource); VbglHGCMParmPtrSet(&Msg.dest, pszDest, cbDest); @@ -754,5 +754,5 @@ HGCMMsgPathUserDocuments Msg; VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, vbglR3GuestCtrlGetMsgFunctionNo(pCtx->uClientID), pCtx->uNumParms); - VbglHGCMParmUInt32Set(&Msg.context, HOST_PATH_USER_DOCUMENTS); + VbglHGCMParmUInt32Set(&Msg.context, HOST_MSG_PATH_USER_DOCUMENTS); rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg)); @@ -777,5 +777,5 @@ HGCMMsgPathUserHome Msg; VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, vbglR3GuestCtrlGetMsgFunctionNo(pCtx->uClientID), pCtx->uNumParms); - VbglHGCMParmUInt32Set(&Msg.context, HOST_PATH_USER_HOME); + VbglHGCMParmUInt32Set(&Msg.context, HOST_MSG_PATH_USER_HOME); rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg)); @@ -819,5 +819,5 @@ HGCMMsgProcExec Msg; VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, vbglR3GuestCtrlGetMsgFunctionNo(pCtx->uClientID), pCtx->uNumParms); - VbglHGCMParmUInt32Set(&Msg.context, HOST_EXEC_CMD); + VbglHGCMParmUInt32Set(&Msg.context, HOST_MSG_EXEC_CMD); VbglHGCMParmPtrSet(&Msg.cmd, pszCmd, cbCmd); VbglHGCMParmUInt32Set(&Msg.flags, 0); @@ -894,5 +894,5 @@ HGCMMsgProcOutput Msg; VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, vbglR3GuestCtrlGetMsgFunctionNo(pCtx->uClientID), pCtx->uNumParms); - VbglHGCMParmUInt32Set(&Msg.context, HOST_EXEC_GET_OUTPUT); + VbglHGCMParmUInt32Set(&Msg.context, HOST_MSG_EXEC_GET_OUTPUT); VbglHGCMParmUInt32Set(&Msg.pid, 0); VbglHGCMParmUInt32Set(&Msg.handle, 0); @@ -936,5 +936,5 @@ HGCMMsgProcInput Msg; VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, vbglR3GuestCtrlGetMsgFunctionNo(pCtx->uClientID), pCtx->uNumParms); - VbglHGCMParmUInt32Set(&Msg.context, HOST_EXEC_SET_INPUT); + VbglHGCMParmUInt32Set(&Msg.context, HOST_MSG_EXEC_SET_INPUT); VbglHGCMParmUInt32Set(&Msg.pid, 0); VbglHGCMParmUInt32Set(&Msg.flags, 0); @@ -978,5 +978,5 @@ HGCMMsgDirRemove Msg; VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, vbglR3GuestCtrlGetMsgFunctionNo(pCtx->uClientID), pCtx->uNumParms); - VbglHGCMParmUInt32Set(&Msg.context, HOST_DIR_REMOVE); + VbglHGCMParmUInt32Set(&Msg.context, HOST_MSG_DIR_REMOVE); VbglHGCMParmPtrSet(&Msg.path, pszPath, cbPath); VbglHGCMParmUInt32Set(&Msg.flags, 0); @@ -1023,5 +1023,5 @@ HGCMMsgFileOpen Msg; VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, vbglR3GuestCtrlGetMsgFunctionNo(pCtx->uClientID), pCtx->uNumParms); - VbglHGCMParmUInt32Set(&Msg.context, HOST_FILE_OPEN); + VbglHGCMParmUInt32Set(&Msg.context, HOST_MSG_FILE_OPEN); VbglHGCMParmPtrSet(&Msg.filename, pszFileName, cbFileName); VbglHGCMParmPtrSet(&Msg.openmode, pszAccess, cbAccess); @@ -1058,5 +1058,5 @@ HGCMMsgFileClose Msg; VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, vbglR3GuestCtrlGetMsgFunctionNo(pCtx->uClientID), pCtx->uNumParms); - VbglHGCMParmUInt32Set(&Msg.context, HOST_FILE_CLOSE); + VbglHGCMParmUInt32Set(&Msg.context, HOST_MSG_FILE_CLOSE); VbglHGCMParmUInt32Set(&Msg.handle, 0); @@ -1088,5 +1088,5 @@ HGCMMsgFileRead Msg; VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, vbglR3GuestCtrlGetMsgFunctionNo(pCtx->uClientID), pCtx->uNumParms); - VbglHGCMParmUInt32Set(&Msg.context, HOST_FILE_READ); + VbglHGCMParmUInt32Set(&Msg.context, HOST_MSG_FILE_READ); VbglHGCMParmUInt32Set(&Msg.handle, 0); VbglHGCMParmUInt32Set(&Msg.size, 0); @@ -1121,5 +1121,5 @@ HGCMMsgFileReadAt Msg; VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, vbglR3GuestCtrlGetMsgFunctionNo(pCtx->uClientID), pCtx->uNumParms); - VbglHGCMParmUInt32Set(&Msg.context, HOST_FILE_READ_AT); + VbglHGCMParmUInt32Set(&Msg.context, HOST_MSG_FILE_READ_AT); VbglHGCMParmUInt32Set(&Msg.handle, 0); VbglHGCMParmUInt32Set(&Msg.offset, 0); @@ -1158,5 +1158,5 @@ HGCMMsgFileWrite Msg; VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, vbglR3GuestCtrlGetMsgFunctionNo(pCtx->uClientID), pCtx->uNumParms); - VbglHGCMParmUInt32Set(&Msg.context, HOST_FILE_WRITE); + VbglHGCMParmUInt32Set(&Msg.context, HOST_MSG_FILE_WRITE); VbglHGCMParmUInt32Set(&Msg.handle, 0); VbglHGCMParmPtrSet(&Msg.data, pvData, cbData); @@ -1198,5 +1198,5 @@ HGCMMsgFileWriteAt Msg; VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, vbglR3GuestCtrlGetMsgFunctionNo(pCtx->uClientID), pCtx->uNumParms); - VbglHGCMParmUInt32Set(&Msg.context, HOST_FILE_WRITE_AT); + VbglHGCMParmUInt32Set(&Msg.context, HOST_MSG_FILE_WRITE_AT); VbglHGCMParmUInt32Set(&Msg.handle, 0); VbglHGCMParmPtrSet(&Msg.data, pvData, cbData); @@ -1239,5 +1239,5 @@ HGCMMsgFileSeek Msg; VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, vbglR3GuestCtrlGetMsgFunctionNo(pCtx->uClientID), pCtx->uNumParms); - VbglHGCMParmUInt32Set(&Msg.context, HOST_FILE_SEEK); + VbglHGCMParmUInt32Set(&Msg.context, HOST_MSG_FILE_SEEK); VbglHGCMParmUInt32Set(&Msg.handle, 0); VbglHGCMParmUInt32Set(&Msg.method, 0); @@ -1272,5 +1272,5 @@ HGCMMsgFileTell Msg; VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, vbglR3GuestCtrlGetMsgFunctionNo(pCtx->uClientID), pCtx->uNumParms); - VbglHGCMParmUInt32Set(&Msg.context, HOST_FILE_TELL); + VbglHGCMParmUInt32Set(&Msg.context, HOST_MSG_FILE_TELL); VbglHGCMParmUInt32Set(&Msg.handle, 0); @@ -1301,5 +1301,5 @@ HGCMMsgProcTerminate Msg; VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, vbglR3GuestCtrlGetMsgFunctionNo(pCtx->uClientID), pCtx->uNumParms); - VbglHGCMParmUInt32Set(&Msg.context, HOST_EXEC_TERMINATE); + VbglHGCMParmUInt32Set(&Msg.context, HOST_MSG_EXEC_TERMINATE); VbglHGCMParmUInt32Set(&Msg.pid, 0); @@ -1331,5 +1331,5 @@ HGCMMsgProcWaitFor Msg; VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, vbglR3GuestCtrlGetMsgFunctionNo(pCtx->uClientID), pCtx->uNumParms); - VbglHGCMParmUInt32Set(&Msg.context, HOST_EXEC_WAIT_FOR); + VbglHGCMParmUInt32Set(&Msg.context, HOST_MSG_EXEC_WAIT_FOR); VbglHGCMParmUInt32Set(&Msg.pid, 0); VbglHGCMParmUInt32Set(&Msg.flags, 0); @@ -1355,5 +1355,5 @@ HGCMReplyFileNotify Msg; - VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, GUEST_FILE_NOTIFY, 4); + VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, GUEST_MSG_FILE_NOTIFY, 4); VbglHGCMParmUInt32Set(&Msg.context, pCtx->uContextID); VbglHGCMParmUInt32Set(&Msg.type, GUEST_FILE_NOTIFYTYPE_OPEN); @@ -1371,5 +1371,5 @@ HGCMReplyFileNotify Msg; - VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, GUEST_FILE_NOTIFY, 3); + VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, GUEST_MSG_FILE_NOTIFY, 3); VbglHGCMParmUInt32Set(&Msg.context, pCtx->uContextID); VbglHGCMParmUInt32Set(&Msg.type, GUEST_FILE_NOTIFYTYPE_CLOSE); @@ -1385,5 +1385,5 @@ HGCMReplyFileNotify Msg; - VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, GUEST_FILE_NOTIFY, 3); + VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, GUEST_MSG_FILE_NOTIFY, 3); VbglHGCMParmUInt32Set(&Msg.context, pCtx->uContextID); VbglHGCMParmUInt32Set(&Msg.type, GUEST_FILE_NOTIFYTYPE_ERROR); @@ -1401,5 +1401,5 @@ HGCMReplyFileNotify Msg; - VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, GUEST_FILE_NOTIFY, 4); + VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, GUEST_MSG_FILE_NOTIFY, 4); VbglHGCMParmUInt32Set(&Msg.context, pCtx->uContextID); VbglHGCMParmUInt32Set(&Msg.type, GUEST_FILE_NOTIFYTYPE_READ); @@ -1417,5 +1417,5 @@ HGCMReplyFileNotify Msg; - VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, GUEST_FILE_NOTIFY, 4); + VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, GUEST_MSG_FILE_NOTIFY, 4); VbglHGCMParmUInt32Set(&Msg.context, pCtx->uContextID); VbglHGCMParmUInt32Set(&Msg.type, GUEST_FILE_NOTIFYTYPE_WRITE); @@ -1433,5 +1433,5 @@ HGCMReplyFileNotify Msg; - VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, GUEST_FILE_NOTIFY, 4); + VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, GUEST_MSG_FILE_NOTIFY, 4); VbglHGCMParmUInt32Set(&Msg.context, pCtx->uContextID); VbglHGCMParmUInt32Set(&Msg.type, GUEST_FILE_NOTIFYTYPE_SEEK); @@ -1449,5 +1449,5 @@ HGCMReplyFileNotify Msg; - VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, GUEST_FILE_NOTIFY, 4); + VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, GUEST_MSG_FILE_NOTIFY, 4); VbglHGCMParmUInt32Set(&Msg.context, pCtx->uContextID); VbglHGCMParmUInt32Set(&Msg.type, GUEST_FILE_NOTIFYTYPE_TELL); @@ -1472,5 +1472,5 @@ HGCMMsgProcStatus Msg; - VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, GUEST_EXEC_STATUS, 5); + VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, GUEST_MSG_EXEC_STATUS, 5); VbglHGCMParmUInt32Set(&Msg.context, pCtx->uContextID); VbglHGCMParmUInt32Set(&Msg.pid, uPID); @@ -1496,5 +1496,5 @@ HGCMMsgProcOutput Msg; - VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, GUEST_EXEC_OUTPUT, 5); + VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, GUEST_MSG_EXEC_OUTPUT, 5); VbglHGCMParmUInt32Set(&Msg.context, pCtx->uContextID); VbglHGCMParmUInt32Set(&Msg.pid, uPID); @@ -1520,5 +1520,5 @@ HGCMMsgProcStatusInput Msg; - VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, GUEST_EXEC_INPUT_STATUS, 5); + VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, GUEST_MSG_EXEC_INPUT_STATUS, 5); VbglHGCMParmUInt32Set(&Msg.context, pCtx->uContextID); VbglHGCMParmUInt32Set(&Msg.pid, uPID); Index: /trunk/src/VBox/Additions/common/VBoxService/VBoxServiceControl.cpp =================================================================== --- /trunk/src/VBox/Additions/common/VBoxService/VBoxServiceControl.cpp (revision 76957) +++ /trunk/src/VBox/Additions/common/VBoxService/VBoxServiceControl.cpp (revision 76958) @@ -245,5 +245,5 @@ Assert(g_idControlSvcClient > 0); - /* Allocate a scratch buffer for commands which also send + /* Allocate a scratch buffer for messages which also send * payload data with them. */ uint32_t cbScratchBuf = _64K; /** @todo Make buffer size configurable via guest properties/argv! */ @@ -264,5 +264,5 @@ cRetrievalFailed = 0; /* Reset failed retrieval count. */ VGSvcVerbose(4, "idMsg=%RU32 (%s) (%RU32 parms) retrieved\n", - idMsg, GstCtrlHostFnName((eHostFn)idMsg), ctxHost.uNumParms); + idMsg, GstCtrlHostMsgtoStr((eHostMsg)idMsg), ctxHost.uNumParms); /* @@ -271,14 +271,14 @@ switch (idMsg) { - case HOST_CANCEL_PENDING_WAITS: + case HOST_MSG_CANCEL_PENDING_WAITS: VGSvcVerbose(1, "We were asked to quit ...\n"); break; - case HOST_SESSION_CREATE: + case HOST_MSG_SESSION_CREATE: rc = vgsvcGstCtrlHandleSessionOpen(&ctxHost); break; /* This message is also sent to the child session process (by the host). */ - case HOST_SESSION_CLOSE: + case HOST_MSG_SESSION_CLOSE: rc = vgsvcGstCtrlHandleSessionClose(&ctxHost); break; @@ -289,5 +289,5 @@ rc = VbglR3GuestCtrlMsgSkip(g_idControlSvcClient, VERR_NOT_SUPPORTED, idMsg); VGSvcVerbose(1, "Skipped unexpected message idMsg=%RU32 (%s), cParms=%RU32 (rc=%Rrc)\n", - idMsg, GstCtrlHostFnName((eHostFn)idMsg), ctxHost.uNumParms, rc); + idMsg, GstCtrlHostMsgtoStr((eHostMsg)idMsg), ctxHost.uNumParms, rc); } else @@ -300,5 +300,5 @@ /* Do we need to shutdown? */ - if (idMsg == HOST_CANCEL_PENDING_WAITS) + if (idMsg == HOST_MSG_CANCEL_PENDING_WAITS) break; @@ -561,5 +561,5 @@ #endif " --control-interval Specifies the interval at which to check for\n" - " new control commands. The default is 1000 ms.\n" + " new control messages. The default is 1000 ms.\n" , /* methods */ Index: /trunk/src/VBox/Additions/common/VBoxService/VBoxServiceControlSession.cpp =================================================================== --- /trunk/src/VBox/Additions/common/VBoxService/VBoxServiceControlSession.cpp (revision 76957) +++ /trunk/src/VBox/Additions/common/VBoxService/VBoxServiceControlSession.cpp (revision 76958) @@ -939,5 +939,5 @@ *ppvScratchBuf, RT_MIN(cbInput, *pcbScratchBuf)); if (RT_FAILURE(rc)) - VGSvcError("Error handling input command for PID=%RU32, rc=%Rrc\n", uPID, rc); + VGSvcError("Error handling input message for PID=%RU32, rc=%Rrc\n", uPID, rc); VGSvcGstCtrlProcessRelease(pProcess); } @@ -1129,5 +1129,5 @@ switch (uMsg) { - case HOST_SESSION_CLOSE: + case HOST_MSG_SESSION_CLOSE: /* Shutdown (this spawn). */ rc = VGSvcGstCtrlSessionClose(pSession); @@ -1135,80 +1135,80 @@ break; - case HOST_DIR_REMOVE: + case HOST_MSG_DIR_REMOVE: if (fImpersonated) rc = vgsvcGstCtrlSessionHandleDirRemove(pSession, pHostCtx); break; - case HOST_EXEC_CMD: + case HOST_MSG_EXEC_CMD: rc = vgsvcGstCtrlSessionHandleProcExec(pSession, pHostCtx); break; - case HOST_EXEC_SET_INPUT: + case HOST_MSG_EXEC_SET_INPUT: rc = vgsvcGstCtrlSessionHandleProcInput(pSession, pHostCtx, ppvScratchBuf, pcbScratchBuf); break; - case HOST_EXEC_GET_OUTPUT: + case HOST_MSG_EXEC_GET_OUTPUT: rc = vgsvcGstCtrlSessionHandleProcOutput(pSession, pHostCtx); break; - case HOST_EXEC_TERMINATE: + case HOST_MSG_EXEC_TERMINATE: rc = vgsvcGstCtrlSessionHandleProcTerminate(pSession, pHostCtx); break; - case HOST_EXEC_WAIT_FOR: + case HOST_MSG_EXEC_WAIT_FOR: rc = vgsvcGstCtrlSessionHandleProcWaitFor(pSession, pHostCtx); break; - case HOST_FILE_OPEN: + case HOST_MSG_FILE_OPEN: if (fImpersonated) rc = vgsvcGstCtrlSessionHandleFileOpen(pSession, pHostCtx); break; - case HOST_FILE_CLOSE: + case HOST_MSG_FILE_CLOSE: if (fImpersonated) rc = vgsvcGstCtrlSessionHandleFileClose(pSession, pHostCtx); break; - case HOST_FILE_READ: + case HOST_MSG_FILE_READ: if (fImpersonated) rc = vgsvcGstCtrlSessionHandleFileRead(pSession, pHostCtx, ppvScratchBuf, pcbScratchBuf); break; - case HOST_FILE_READ_AT: + case HOST_MSG_FILE_READ_AT: if (fImpersonated) rc = vgsvcGstCtrlSessionHandleFileReadAt(pSession, pHostCtx, ppvScratchBuf, pcbScratchBuf); break; - case HOST_FILE_WRITE: + case HOST_MSG_FILE_WRITE: if (fImpersonated) rc = vgsvcGstCtrlSessionHandleFileWrite(pSession, pHostCtx, ppvScratchBuf, pcbScratchBuf); break; - case HOST_FILE_WRITE_AT: + case HOST_MSG_FILE_WRITE_AT: if (fImpersonated) rc = vgsvcGstCtrlSessionHandleFileWriteAt(pSession, pHostCtx, ppvScratchBuf, pcbScratchBuf); break; - case HOST_FILE_SEEK: + case HOST_MSG_FILE_SEEK: if (fImpersonated) rc = vgsvcGstCtrlSessionHandleFileSeek(pSession, pHostCtx); break; - case HOST_FILE_TELL: + case HOST_MSG_FILE_TELL: if (fImpersonated) rc = vgsvcGstCtrlSessionHandleFileTell(pSession, pHostCtx); break; - case HOST_PATH_RENAME: + case HOST_MSG_PATH_RENAME: if (fImpersonated) rc = vgsvcGstCtrlSessionHandlePathRename(pSession, pHostCtx); break; - case HOST_PATH_USER_DOCUMENTS: + case HOST_MSG_PATH_USER_DOCUMENTS: if (fImpersonated) rc = vgsvcGstCtrlSessionHandlePathUserDocuments(pSession, pHostCtx); break; - case HOST_PATH_USER_HOME: + case HOST_MSG_PATH_USER_HOME: if (fImpersonated) rc = vgsvcGstCtrlSessionHandlePathUserHome(pSession, pHostCtx); @@ -1529,5 +1529,5 @@ { /* - * Allocate a scratch buffer for commands which also send payload data with them. + * Allocate a scratch buffer for messages which also send payload data with them. * This buffer may grow if the host sends us larger chunks of data. */ Index: /trunk/src/VBox/HostServices/GuestControl/service.cpp =================================================================== --- /trunk/src/VBox/HostServices/GuestControl/service.cpp (revision 76957) +++ /trunk/src/VBox/HostServices/GuestControl/service.cpp (revision 76958) @@ -18,5 +18,5 @@ /** @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,5 +26,5 @@ * 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,12 +33,12 @@ * 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,19 +104,14 @@ /** - * 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,9 +120,9 @@ * 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,7 +132,7 @@ bool m_f60BetaHackInPlay; - HostCommand() + HostMsg() : m_idContextAndDst(0) - , mMsgType(UINT32_MAX) + , mType(UINT32_MAX) , mParmCount(0) , mpParms(NULL) @@ -148,9 +143,9 @@ /** - * 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,5 +166,5 @@ /** - * Initializes the command. + * Initializes the message. * * The specified parameters are copied and any buffers referenced by it @@ -177,12 +172,12 @@ * * @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,5 +192,5 @@ /* - * 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,5 +201,5 @@ 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,5 +210,5 @@ * Just make a copy of the parameters and any buffers. */ - mMsgType = idFunction; + mType = idMsg; mParmCount = cParms; mpParms = (VBOXHGCMSVCPARM *)RTMemAllocZ(sizeof(VBOXHGCMSVCPARM) * mParmCount); @@ -244,6 +239,6 @@ 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,7 +266,7 @@ 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,6 +296,6 @@ 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,16 +381,16 @@ 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,9 +419,9 @@ 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,5 +433,5 @@ * 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,18 +439,18 @@ /** @} */ -} 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,6 +462,6 @@ { 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,7 +477,7 @@ /** 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,10 +491,10 @@ , 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,23 +506,23 @@ , 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,5 +532,5 @@ int rc = VINF_NO_CHANGE; - if (m_enmIsPending != 0) + if (m_enmPendingMsg != 0) { LogFlowFunc(("[Client %RU32] Waking up ...\n", m_idClient)); @@ -543,13 +538,13 @@ 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,13 +552,13 @@ 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,5 +576,5 @@ { 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,7 +582,7 @@ */ 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,9 +592,9 @@ * 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,5 +615,5 @@ 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,15 +628,15 @@ */ - /** 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,18 +645,18 @@ /** - * 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,21 +667,22 @@ * @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,22 +691,22 @@ * * 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,11 +714,11 @@ 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,15 +735,15 @@ /* - * 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,5 +753,5 @@ 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,7 +760,7 @@ /* - * Return first host command. + * Return first host message. */ - return OldRun(pReq, pFirstCmd); + return OldRun(pReq, pFirstMsg); } @@ -774,8 +770,8 @@ */ 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,8 +781,8 @@ /* 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,19 +790,19 @@ { /* 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,5 +813,5 @@ /* Reset pending status. */ - m_enmIsPending = (guestControl::eGuestFn)0; + m_enmPendingMsg = (guestControl::eGuestMsg)0; /* In any case the client did something, so complete @@ -831,6 +827,6 @@ } - 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,23 +863,23 @@ 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,5 +917,5 @@ 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,6 +923,6 @@ 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,19 +1021,19 @@ /* - * 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,5 +1075,5 @@ * 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,12 +1202,12 @@ /* - * 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,10 +1225,10 @@ * 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,26 +1266,26 @@ /* - * 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,22 +1298,22 @@ 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,5 +1322,5 @@ 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,5 +1329,5 @@ { /* - * 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,6 +1336,6 @@ if (rc != VERR_CANCELLED) { - RTListNodeRemove(&pFirstCmd->m_ListEntry); - pFirstCmd->Delete(); + RTListNodeRemove(&pFirstMsg->m_ListEntry); + pFirstMsg->Delete(); } else @@ -1377,5 +1373,5 @@ * Execute. */ - if (pClient->m_enmIsPending != 0) + if (pClient->m_enmPendingMsg != 0) { pClient->CancelWaiting(); @@ -1422,8 +1418,8 @@ * 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,8 +1428,8 @@ { /* - * 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,76 +1437,76 @@ */ 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,7 +1516,7 @@ /* - * Free the command. + * Free the message. */ - pFirstCmd->Delete(); + pFirstMsg->Delete(); } else @@ -1528,5 +1524,5 @@ 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,5 +1592,5 @@ /* - * Try complete the command. + * Try complete the message. */ int rc = mpHelpers->pfnCallComplete(hCall, VINF_SUCCESS); @@ -1786,5 +1782,5 @@ /* - * 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,5 +1788,5 @@ 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,5 +1867,5 @@ /** - * 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,9 +1895,9 @@ * 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,6 +1905,6 @@ else { - RTListNodeRemove(&pFirstCmd->m_ListEntry); - pFirstCmd->Delete(); + RTListNodeRemove(&pFirstMsg->m_ListEntry); + pFirstMsg->Delete(); rc = VINF_SUCCESS; } @@ -1917,11 +1913,11 @@ 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,9 +1935,9 @@ * @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,8 +1954,8 @@ || ( 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,5 +1963,5 @@ * It seems okay, so make the call. */ - return hostCallback(idFunction, cParms, paParms); + return hostCallback(idMsg, cParms, paParms); } @@ -1981,8 +1977,8 @@ /*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,7 +1996,7 @@ */ 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,17 +2022,17 @@ 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,24 +2045,24 @@ 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,5 +2093,5 @@ */ 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,11 +2113,12 @@ * * @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,5 +2126,5 @@ { VBOXGUESTCTRLHOSTCALLBACK data(cParms, paParms); - rc = mpfnHostCallback(mpvHostData, idFunction, &data, sizeof(data)); + rc = mpfnHostCallback(mpvHostData, u32Function, &data, sizeof(data)); } else @@ -2140,16 +2137,16 @@ /** - * 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,27 +2155,27 @@ 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,6 +2183,6 @@ 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,5 +2195,5 @@ 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,7 +2201,7 @@ 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,6 +2212,6 @@ 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,9 +2222,9 @@ && 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,13 +2237,13 @@ } - /* 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,5 +2252,5 @@ /** * @interface_method_impl{VBOXHGCMSVCFNTABLE,pfnHostCall, - * Wraps to the hostProcessCommand() member function.} + * Wraps to the hostProcessMessage() member function.} */ /*static*/ DECLCALLBACK(int) @@ -2264,7 +2261,7 @@ 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); } Index: /trunk/src/VBox/HostServices/GuestControl/testcase/tstGuestControlSvc.cpp =================================================================== --- /trunk/src/VBox/HostServices/GuestControl/testcase/tstGuestControlSvc.cpp (revision 76957) +++ /trunk/src/VBox/HostServices/GuestControl/testcase/tstGuestControlSvc.cpp (revision 76958) @@ -179,13 +179,13 @@ /** 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,5 +221,5 @@ 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); Index: /trunk/src/VBox/Main/include/GuestCtrlImplPrivate.h =================================================================== --- /trunk/src/VBox/Main/include/GuestCtrlImplPrivate.h (revision 76957) +++ /trunk/src/VBox/Main/include/GuestCtrlImplPrivate.h (revision 76958) @@ -1179,5 +1179,5 @@ int bindToSession(Console *pConsole, GuestSession *pSession, uint32_t uObjectID); int registerWaitEvent(const GuestEventTypes &lstEvents, GuestWaitEvent **ppEvent); - int sendCommand(uint32_t uFunction, uint32_t cParms, PVBOXHGCMSVCPARM paParms); + int sendMessage(uint32_t uFunction, uint32_t cParms, PVBOXHGCMSVCPARM paParms); protected: Index: /trunk/src/VBox/Main/include/GuestSessionImpl.h =================================================================== --- /trunk/src/VBox/Main/include/GuestSessionImpl.h (revision 76957) +++ /trunk/src/VBox/Main/include/GuestSessionImpl.h (revision 76958) @@ -325,5 +325,5 @@ inline bool i_processExists(uint32_t uProcessID, ComObjPtr *pProcess); inline int i_processGetByPID(ULONG uPID, ComObjPtr *pProcess); - int i_sendCommand(uint32_t uFunction, uint32_t uParms, PVBOXHGCMSVCPARM paParms, + int i_sendMessage(uint32_t uFunction, uint32_t uParms, PVBOXHGCMSVCPARM paParms, uint64_t fDst = VBOX_GUESTCTRL_DST_SESSION); static HRESULT i_setErrorExternal(VirtualBoxBase *pInterface, int guestRc); Index: /trunk/src/VBox/Main/src-client/GuestCtrlImpl.cpp =================================================================== --- /trunk/src/VBox/Main/src-client/GuestCtrlImpl.cpp (revision 76957) +++ /trunk/src/VBox/Main/src-client/GuestCtrlImpl.cpp (revision 76958) @@ -61,5 +61,5 @@ /** - * Static callback function for receiving updates on guest control commands + * Static callback function for receiving updates on guest control messages * from the guest. Acts as a dispatcher for the actual class instance. * @@ -72,6 +72,6 @@ * return locations. However, there is no explaination for this attitude * thowards error handling. Further, it creates a slight problem since - * the service would route all function calls it didn't recognize here, - * thereby making any undefined functions confusingly return VINF_SUCCESS. + * the service would route all message calls it didn't recognize here, + * thereby making any undefined messages confusingly return VINF_SUCCESS. * * In my humble opinion, if the guest gives us incorrect input it should @@ -85,5 +85,5 @@ /* static */ DECLCALLBACK(int) Guest::i_notifyCtrlDispatcher(void *pvExtension, - uint32_t idFunction, + uint32_t idMessage, void *pvData, uint32_t cbData) @@ -95,5 +95,5 @@ * changes to the object state. */ - Log2Func(("pvExtension=%p, idFunction=%RU32, pvParms=%p, cbParms=%RU32\n", pvExtension, idFunction, pvData, cbData)); + Log2Func(("pvExtension=%p, idMessage=%RU32, pvParms=%p, cbParms=%RU32\n", pvExtension, idMessage, pvData, cbData)); ComObjPtr pGuest = reinterpret_cast(pvExtension); @@ -110,5 +110,5 @@ /* - * For guest control 2.0 using the legacy commands we need to do the following here: + * For guest control 2.0 using the legacy messages we need to do the following here: * - Get the callback header to access the context ID * - Get the context ID of the callback @@ -123,5 +123,5 @@ uint32_t const idContext = pSvcCb->mpaParms[0].u.uint32; - VBOXGUESTCTRLHOSTCBCTX CtxCb = { idFunction, idContext }; + VBOXGUESTCTRLHOSTCBCTX CtxCb = { idMessage, idContext }; int rc = pGuest->i_dispatchToSession(&CtxCb, pSvcCb); @@ -142,5 +142,5 @@ AssertPtrReturn(pSvcCb, VERR_INVALID_POINTER); - Log2Func(("uFunction=%RU32, uContextID=%RU32, uProtocol=%RU32\n", pCtxCb->uFunction, pCtxCb->uContextID, pCtxCb->uProtocol)); + Log2Func(("uMessage=%RU32, uContextID=%RU32, uProtocol=%RU32\n", pCtxCb->uMessage, pCtxCb->uContextID, pCtxCb->uProtocol)); AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); @@ -170,5 +170,5 @@ bool fDispatch = true; rc = VERR_INVALID_FUNCTION; - if ( pCtxCb->uFunction == GUEST_EXEC_STATUS + if ( pCtxCb->uMessage == GUEST_MSG_EXEC_STATUS && pSvcCb->mParms >= 5) { @@ -183,5 +183,5 @@ && (int32_t)dataCb.uFlags == VERR_TOO_MUCH_DATA) { - LogFlowFunc(("Requested command with too much data, skipping dispatching ...\n")); + LogFlowFunc(("Requested message with too much data, skipping dispatching ...\n")); Assert(dataCb.uPID == 0); fDispatch = false; @@ -191,25 +191,25 @@ #endif { - switch (pCtxCb->uFunction) + switch (pCtxCb->uMessage) { - case GUEST_DISCONNECTED: + case GUEST_MSG_DISCONNECTED: rc = pSession->i_dispatchToThis(pCtxCb, pSvcCb); break; /* Process stuff. */ - case GUEST_EXEC_STATUS: - case GUEST_EXEC_OUTPUT: - case GUEST_EXEC_INPUT_STATUS: - case GUEST_EXEC_IO_NOTIFY: + case GUEST_MSG_EXEC_STATUS: + case GUEST_MSG_EXEC_OUTPUT: + case GUEST_MSG_EXEC_INPUT_STATUS: + case GUEST_MSG_EXEC_IO_NOTIFY: rc = pSession->i_dispatchToObject(pCtxCb, pSvcCb); break; /* File stuff. */ - case GUEST_FILE_NOTIFY: + case GUEST_MSG_FILE_NOTIFY: rc = pSession->i_dispatchToObject(pCtxCb, pSvcCb); break; /* Session stuff. */ - case GUEST_SESSION_NOTIFY: + case GUEST_MSG_SESSION_NOTIFY: rc = pSession->i_dispatchToThis(pCtxCb, pSvcCb); break; Index: /trunk/src/VBox/Main/src-client/GuestCtrlPrivate.cpp =================================================================== --- /trunk/src/VBox/Main/src-client/GuestCtrlPrivate.cpp (revision 76957) +++ /trunk/src/VBox/Main/src-client/GuestCtrlPrivate.cpp (revision 76958) @@ -813,7 +813,7 @@ try { - Log2Func(("uFunc=%RU32, cParms=%RU32\n", pCtxCb->uFunction, pSvcCb->mParms)); - - switch (pCtxCb->uFunction) + Log2Func(("uFunc=%RU32, cParms=%RU32\n", pCtxCb->uMessage, pSvcCb->mParms)); + + switch (pCtxCb->uMessage) { case GUEST_MSG_PROGRESS_UPDATE: @@ -1413,5 +1413,5 @@ } -int GuestObject::sendCommand(uint32_t uFunction, uint32_t cParms, PVBOXHGCMSVCPARM paParms) +int GuestObject::sendMessage(uint32_t uMessage, uint32_t cParms, PVBOXHGCMSVCPARM paParms) { #ifndef VBOX_GUESTCTRL_TEST_CASE @@ -1432,6 +1432,6 @@ /* Make the call. */ - LogFlowThisFunc(("uFunction=%RU32, cParms=%RU32\n", uFunction, cParms)); - vrc = pVMMDev->hgcmHostCall(HGCMSERVICE_NAME, uFunction, cParms, paParms); + LogFlowThisFunc(("uMessage=%RU32, cParms=%RU32\n", uMessage, cParms)); + vrc = pVMMDev->hgcmHostCall(HGCMSERVICE_NAME, uMessage, cParms, paParms); if (RT_FAILURE(vrc)) { @@ -1443,5 +1443,5 @@ /* Not needed within testcases. */ - RT_NOREF(uFunction, cParms, paParms); + RT_NOREF(uMessage, cParms, paParms); int vrc = VINF_SUCCESS; #endif Index: /trunk/src/VBox/Main/src-client/GuestDirectoryImpl.cpp =================================================================== --- /trunk/src/VBox/Main/src-client/GuestDirectoryImpl.cpp (revision 76957) +++ /trunk/src/VBox/Main/src-client/GuestDirectoryImpl.cpp (revision 76958) @@ -170,10 +170,10 @@ LogFlowThisFunc(("strPath=%s, uContextID=%RU32, uFunction=%RU32, pSvcCb=%p\n", - mData.mOpenInfo.mPath.c_str(), pCbCtx->uContextID, pCbCtx->uFunction, pSvcCb)); + mData.mOpenInfo.mPath.c_str(), pCbCtx->uContextID, pCbCtx->uMessage, pSvcCb)); int vrc; - switch (pCbCtx->uFunction) - { - case GUEST_DIR_NOTIFY: + switch (pCbCtx->uMessage) + { + case GUEST_MSG_DIR_NOTIFY: { int idx = 1; /* Current parameter index. */ Index: /trunk/src/VBox/Main/src-client/GuestFileImpl.cpp =================================================================== --- /trunk/src/VBox/Main/src-client/GuestFileImpl.cpp (revision 76957) +++ /trunk/src/VBox/Main/src-client/GuestFileImpl.cpp (revision 76958) @@ -333,14 +333,14 @@ LogFlowThisFunc(("strName=%s, uContextID=%RU32, uFunction=%RU32, pSvcCb=%p\n", - mData.mOpenInfo.mFilename.c_str(), pCbCtx->uContextID, pCbCtx->uFunction, pSvcCb)); + mData.mOpenInfo.mFilename.c_str(), pCbCtx->uContextID, pCbCtx->uMessage, pSvcCb)); int vrc; - switch (pCbCtx->uFunction) - { - case GUEST_DISCONNECTED: + switch (pCbCtx->uMessage) + { + case GUEST_MSG_DISCONNECTED: vrc = i_onGuestDisconnected(pCbCtx, pSvcCb); break; - case GUEST_FILE_NOTIFY: + case GUEST_MSG_FILE_NOTIFY: vrc = i_onFileNotify(pCbCtx, pSvcCb); break; @@ -386,5 +386,5 @@ HGCMSvcSetU32(&paParms[i++], mObjectID /* Guest file ID */); - vrc = sendCommand(HOST_FILE_CLOSE, i, paParms); + vrc = sendMessage(HOST_MSG_FILE_CLOSE, i, paParms); if (RT_SUCCESS(vrc)) vrc = i_waitForStatusChange(pEvent, 30 * 1000 /* Timeout in ms */, @@ -730,5 +730,5 @@ alock.release(); /* Drop write lock before sending. */ - vrc = sendCommand(HOST_FILE_OPEN, i, paParms); + vrc = sendMessage(HOST_MSG_FILE_OPEN, i, paParms); if (RT_SUCCESS(vrc)) vrc = i_waitForStatusChange(pEvent, uTimeoutMS, NULL /* FileStatus */, prcGuest); @@ -785,5 +785,5 @@ alock.release(); /* Drop write lock before sending. */ - vrc = sendCommand(HOST_FILE_READ, i, paParms); + vrc = sendMessage(HOST_MSG_FILE_READ, i, paParms); if (RT_SUCCESS(vrc)) { @@ -845,5 +845,5 @@ alock.release(); /* Drop write lock before sending. */ - vrc = sendCommand(HOST_FILE_READ_AT, i, paParms); + vrc = sendMessage(HOST_MSG_FILE_READ_AT, i, paParms); if (RT_SUCCESS(vrc)) { @@ -907,5 +907,5 @@ alock.release(); /* Drop write lock before sending. */ - vrc = sendCommand(HOST_FILE_SEEK, i, paParms); + vrc = sendMessage(HOST_MSG_FILE_SEEK, i, paParms); if (RT_SUCCESS(vrc)) { @@ -1171,5 +1171,5 @@ alock.release(); /* Drop write lock before sending. */ - vrc = sendCommand(HOST_FILE_WRITE, i, paParms); + vrc = sendMessage(HOST_MSG_FILE_WRITE, i, paParms); if (RT_SUCCESS(vrc)) { @@ -1235,5 +1235,5 @@ alock.release(); /* Drop write lock before sending. */ - vrc = sendCommand(HOST_FILE_WRITE_AT, i, paParms); + vrc = sendMessage(HOST_MSG_FILE_WRITE_AT, i, paParms); if (RT_SUCCESS(vrc)) { Index: /trunk/src/VBox/Main/src-client/GuestProcessImpl.cpp =================================================================== --- /trunk/src/VBox/Main/src-client/GuestProcessImpl.cpp (revision 76957) +++ /trunk/src/VBox/Main/src-client/GuestProcessImpl.cpp (revision 76958) @@ -416,12 +416,12 @@ AssertPtrReturn(pSvcCb, VERR_INVALID_POINTER); #ifdef DEBUG - LogFlowThisFunc(("uPID=%RU32, uContextID=%RU32, uFunction=%RU32, pSvcCb=%p\n", - mData.mPID, pCbCtx->uContextID, pCbCtx->uFunction, pSvcCb)); + LogFlowThisFunc(("uPID=%RU32, uContextID=%RU32, uMessage=%RU32, pSvcCb=%p\n", + mData.mPID, pCbCtx->uContextID, pCbCtx->uMessage, pSvcCb)); #endif int vrc; - switch (pCbCtx->uFunction) - { - case GUEST_DISCONNECTED: + switch (pCbCtx->uMessage) + { + case GUEST_MSG_DISCONNECTED: { vrc = i_onGuestDisconnected(pCbCtx, pSvcCb); @@ -429,5 +429,5 @@ } - case GUEST_EXEC_STATUS: + case GUEST_MSG_EXEC_STATUS: { vrc = i_onProcessStatusChange(pCbCtx, pSvcCb); @@ -435,5 +435,5 @@ } - case GUEST_EXEC_OUTPUT: + case GUEST_MSG_EXEC_OUTPUT: { vrc = i_onProcessOutput(pCbCtx, pSvcCb); @@ -441,5 +441,5 @@ } - case GUEST_EXEC_INPUT_STATUS: + case GUEST_MSG_EXEC_INPUT_STATUS: { vrc = i_onProcessInputStatus(pCbCtx, pSvcCb); @@ -916,5 +916,5 @@ alock.release(); /* Drop the write lock before sending. */ - vrc = sendCommand(HOST_EXEC_GET_OUTPUT, i, paParms); + vrc = sendMessage(HOST_MSG_EXEC_GET_OUTPUT, i, paParms); } @@ -1132,5 +1132,5 @@ rLock.release(); /* Drop the write lock before sending. */ - vrc = sendCommand(HOST_EXEC_CMD, i, paParms); + vrc = sendMessage(HOST_MSG_EXEC_CMD, i, paParms); if (RT_FAILURE(vrc)) { @@ -1251,5 +1251,5 @@ alock.release(); /* Drop the write lock before sending. */ - vrc = sendCommand(HOST_EXEC_TERMINATE, i, paParms); + vrc = sendMessage(HOST_MSG_EXEC_TERMINATE, i, paParms); if (RT_SUCCESS(vrc)) vrc = i_waitForStatusChange(pEvent, uTimeoutMS, @@ -1733,5 +1733,5 @@ uint32_t cbProcessed = 0; - vrc = sendCommand(HOST_EXEC_SET_INPUT, i, paParms); + vrc = sendMessage(HOST_MSG_EXEC_SET_INPUT, i, paParms); if (RT_SUCCESS(vrc)) { Index: /trunk/src/VBox/Main/src-client/GuestSessionImpl.cpp =================================================================== --- /trunk/src/VBox/Main/src-client/GuestSessionImpl.cpp (revision 76957) +++ /trunk/src/VBox/Main/src-client/GuestSessionImpl.cpp (revision 76958) @@ -718,5 +718,5 @@ alock.release(); /* Drop the write lock before waiting. */ - vrc = i_sendCommand(HOST_SESSION_CLOSE, i, paParms, VBOX_GUESTCTRL_DST_BOTH); + vrc = i_sendMessage(HOST_MSG_SESSION_CLOSE, i, paParms, VBOX_GUESTCTRL_DST_BOTH); if (RT_SUCCESS(vrc)) vrc = i_waitForStatusChange(pEvent, GuestSessionWaitForFlag_Terminate, uTimeoutMS, @@ -1073,5 +1073,5 @@ alock.release(); /* Drop write lock before sending. */ - vrc = i_sendCommand(HOST_DIR_REMOVE, i, paParms); + vrc = i_sendMessage(HOST_MSG_DIR_REMOVE, i, paParms); if (RT_SUCCESS(vrc)) { @@ -1314,15 +1314,15 @@ AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); - LogFlowThisFunc(("sessionID=%RU32, CID=%RU32, uFunction=%RU32, pSvcCb=%p\n", - mData.mSession.mID, pCbCtx->uContextID, pCbCtx->uFunction, pSvcCb)); + LogFlowThisFunc(("sessionID=%RU32, CID=%RU32, uMessage=%RU32, pSvcCb=%p\n", + mData.mSession.mID, pCbCtx->uContextID, pCbCtx->uMessage, pSvcCb)); int rc; - switch (pCbCtx->uFunction) - { - case GUEST_DISCONNECTED: + switch (pCbCtx->uMessage) + { + case GUEST_MSG_DISCONNECTED: /** @todo Handle closing all guest objects. */ rc = VERR_INTERNAL_ERROR; break; - case GUEST_SESSION_NOTIFY: /* Guest Additions >= 4.3.0. */ + case GUEST_MSG_SESSION_NOTIFY: /* Guest Additions >= 4.3.0. */ { rc = i_onSessionStatusChange(pCbCtx, pSvcCb); @@ -1947,5 +1947,5 @@ alock.release(); /* Drop write lock before sending. */ - vrc = i_sendCommand(HOST_SESSION_CREATE, i, paParms, VBOX_GUESTCTRL_DST_ROOT_SVC); + vrc = i_sendMessage(HOST_MSG_SESSION_CREATE, i, paParms, VBOX_GUESTCTRL_DST_ROOT_SVC); if (RT_SUCCESS(vrc)) { @@ -2136,5 +2136,5 @@ alock.release(); /* Drop write lock before sending. */ - vrc = i_sendCommand(HOST_PATH_RENAME, i, paParms); + vrc = i_sendMessage(HOST_MSG_PATH_RENAME, i, paParms); if (RT_SUCCESS(vrc)) { @@ -2177,5 +2177,5 @@ alock.release(); /* Drop write lock before sending. */ - vrc = i_sendCommand(HOST_PATH_USER_DOCUMENTS, i, paParms); + vrc = i_sendMessage(HOST_MSG_PATH_USER_DOCUMENTS, i, paParms); if (RT_SUCCESS(vrc)) { @@ -2227,5 +2227,5 @@ alock.release(); /* Drop write lock before sending. */ - vrc = i_sendCommand(HOST_PATH_USER_HOME, i, paParms); + vrc = i_sendMessage(HOST_MSG_PATH_USER_HOME, i, paParms); if (RT_SUCCESS(vrc)) { @@ -2437,5 +2437,5 @@ } -int GuestSession::i_sendCommand(uint32_t uFunction, uint32_t uParms, PVBOXHGCMSVCPARM paParms, +int GuestSession::i_sendMessage(uint32_t uMessage, uint32_t uParms, PVBOXHGCMSVCPARM paParms, uint64_t fDst /*= VBOX_GUESTCTRL_DST_SESSION*/) { @@ -2450,5 +2450,5 @@ AssertPtr(pVMMDev); - LogFlowThisFunc(("uFunction=%RU32 (%s), uParms=%RU32\n", uFunction, GstCtrlHostFnName((guestControl::eHostFn)uFunction), uParms)); + LogFlowThisFunc(("uMessage=%RU32 (%s), uParms=%RU32\n", uMessage, GstCtrlHostMsgtoStr((guestControl::eHostMsg)uMessage), uParms)); /* HACK ALERT! We extend the first parameter to 64-bit and use the @@ -2460,5 +2460,5 @@ /* Make the call. */ - int vrc = pVMMDev->hgcmHostCall(HGCMSERVICE_NAME, uFunction, uParms, paParms); + int vrc = pVMMDev->hgcmHostCall(HGCMSERVICE_NAME, uMessage, uParms, paParms); if (RT_FAILURE(vrc)) {