Index: trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-darwin.cpp
===================================================================
--- trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-darwin.cpp	(revision 80990)
+++ trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-darwin.cpp	(revision 80995)
@@ -54,5 +54,5 @@
 
 /**
- * Checks if something is present on the clipboard and calls sharedClipboardSvcReportMsg.
+ * Checks if something is present on the clipboard and calls shclSvcReportMsg.
  *
  * @returns IPRT status code (ignored).
@@ -76,5 +76,5 @@
         formatData.uFormats = fFormats;
 
-        rc = sharedClipboardSvcFormatsReport(pCtx->pClient, &formatData);
+        rc = shclSvcFormatsReport(pCtx->pClient, &formatData);
     }
 
@@ -117,5 +117,5 @@
 
 
-int SharedClipboardSvcImplInit(void)
+int ShClSvcImplInit(void)
 {
     Log(("vboxClipboardInit\n"));
@@ -137,5 +137,5 @@
 }
 
-void SharedClipboardSvcImplDestroy(void)
+void ShClSvcImplDestroy(void)
 {
     /*
@@ -156,5 +156,5 @@
 }
 
-int SharedClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless)
+int ShClSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless)
 {
     RT_NOREF(fHeadless);
@@ -172,11 +172,11 @@
 
     /* Initially sync the host clipboard content with the client. */
-    int rc = SharedClipboardSvcImplSync(pClient);
-
-    VBoxSvcClipboardUnlock();
-    return rc;
-}
-
-int SharedClipboardSvcImplSync(PSHCLCLIENT pClient)
+    int rc = ShClSvcImplSync(pClient);
+
+    VBoxSvcClipboardUnlock();
+    return rc;
+}
+
+int ShClSvcImplSync(PSHCLCLIENT pClient)
 {
     /* Sync the host clipboard content with the client. */
@@ -190,5 +190,5 @@
 }
 
-int SharedClipboardSvcImplDisconnect(PSHCLCLIENT pClient)
+int ShClSvcImplDisconnect(PSHCLCLIENT pClient)
 {
     VBoxSvcClipboardLock();
@@ -201,6 +201,6 @@
 }
 
-int SharedClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient,
-                                       PSHCLCLIENTCMDCTX pCmdCtx, PSHCLFORMATDATA pFormats)
+int ShClSvcImplFormatAnnounce(PSHCLCLIENT pClient,
+                              PSHCLCLIENTCMDCTX pCmdCtx, PSHCLFORMATDATA pFormats)
 {
     RT_NOREF(pCmdCtx);
@@ -225,5 +225,5 @@
     dataReq.cbSize = _64K; /** @todo Make this more dynamic. */
 
-    return sharedClipboardSvcDataReadRequest(pClient, &dataReq, NULL /* puEvent */);
+    return shclSvcDataReadRequest(pClient, &dataReq, NULL /* puEvent */);
 }
 
@@ -236,6 +236,6 @@
  * @param pcbActual             Where to write the actual size of the written data.
  */
-int SharedClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
-                                 PSHCLDATABLOCK pData, uint32_t *pcbActual)
+int ShClSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
+                        PSHCLDATABLOCK pData, uint32_t *pcbActual)
 {
     RT_NOREF(pCmdCtx);
@@ -262,6 +262,6 @@
  * @param pData                 Data block to write to clipboard.
  */
-int SharedClipboardSvcImplWriteData(PSHCLCLIENT pClient,
-                                  PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData)
+int ShClSvcImplWriteData(PSHCLCLIENT pClient,
+                         PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData)
 {
     RT_NOREF(pCmdCtx);
@@ -277,5 +277,5 @@
 
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
-int SharedClipboardSvcImplTransferReadDir(PSHCLCLIENT pClient, PSHCLDIRDATA pDirData)
+int ShClSvcImplTransferReadDir(PSHCLCLIENT pClient, PSHCLDIRDATA pDirData)
 {
     RT_NOREF(pClient, pDirData);
@@ -283,5 +283,5 @@
 }
 
-int SharedClipboardSvcImplTransferWriteDir(PSHCLCLIENT pClient, PSHCLDIRDATA pDirData)
+int ShClSvcImplTransferWriteDir(PSHCLCLIENT pClient, PSHCLDIRDATA pDirData)
 {
     RT_NOREF(pClient, pDirData);
@@ -289,5 +289,5 @@
 }
 
-int SharedClipboardSvcImplTransferReadFileHdr(PSHCLCLIENT pClient, PSHCLFILEHDR pFileHdr)
+int ShClSvcImplTransferReadFileHdr(PSHCLCLIENT pClient, PSHCLFILEHDR pFileHdr)
 {
     RT_NOREF(pClient, pFileHdr);
@@ -295,5 +295,5 @@
 }
 
-int SharedClipboardSvcImplTransferWriteFileHdr(PSHCLCLIENT pClient, PSHCLFILEHDR pFileHdr)
+int ShClSvcImplTransferWriteFileHdr(PSHCLCLIENT pClient, PSHCLFILEHDR pFileHdr)
 {
     RT_NOREF(pClient, pFileHdr);
@@ -301,5 +301,5 @@
 }
 
-int SharedClipboardSvcImplTransferReadFileData(PSHCLCLIENT pClient, PSHCLFILEDATA pFileData)
+int ShClSvcImplTransferReadFileData(PSHCLCLIENT pClient, PSHCLFILEDATA pFileData)
 {
     RT_NOREF(pClient, pFileData);
@@ -307,5 +307,5 @@
 }
 
-int SharedClipboardSvcImplTransferWriteFileData(PSHCLCLIENT pClient, PSHCLFILEDATA pFileData)
+int ShClSvcImplTransferWriteFileData(PSHCLCLIENT pClient, PSHCLFILEDATA pFileData)
 {
     RT_NOREF(pClient, pFileData);
Index: trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-internal.h
===================================================================
--- trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-internal.h	(revision 80990)
+++ trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-internal.h	(revision 80995)
@@ -179,27 +179,27 @@
  * The service functions. Locking is between the service thread and the platform-dependent (window) thread.
  */
-int sharedClipboardSvcDataReadRequest(PSHCLCLIENT pClient, PSHCLDATAREQ pDataReq, PSHCLEVENTID puEvent);
-int sharedClipboardSvcDataReadSignal(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData);
-int sharedClipboardSvcFormatsReport(PSHCLCLIENT pClient, PSHCLFORMATDATA pFormats);
-
-uint32_t sharedClipboardSvcGetMode(void);
-int sharedClipboardSvcSetSource(PSHCLCLIENT pClient, SHCLSOURCE enmSource);
-
-void sharedClipboardSvcMsgQueueReset(PSHCLCLIENT pClient);
-PSHCLCLIENTMSG sharedClipboardSvcMsgAlloc(uint32_t uMsg, uint32_t cParms);
-void sharedClipboardSvcMsgFree(PSHCLCLIENTMSG pMsg);
-void sharedClipboardSvcMsgSetPeekReturn(PSHCLCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms);
-int sharedClipboardSvcMsgAdd(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg, bool fAppend);
-int sharedClipboardSvcMsgPeek(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[], bool fWait);
-int sharedClipboardSvcMsgGet(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
-
-int sharedClipboardSvcClientWakeup(PSHCLCLIENT pClient);
+int shclSvcDataReadRequest(PSHCLCLIENT pClient, PSHCLDATAREQ pDataReq, PSHCLEVENTID puEvent);
+int shclSvcDataReadSignal(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData);
+int shclSvcFormatsReport(PSHCLCLIENT pClient, PSHCLFORMATDATA pFormats);
+
+uint32_t shclSvcGetMode(void);
+int shclSvcSetSource(PSHCLCLIENT pClient, SHCLSOURCE enmSource);
+
+void shclSvcMsgQueueReset(PSHCLCLIENT pClient);
+PSHCLCLIENTMSG shclSvcMsgAlloc(uint32_t uMsg, uint32_t cParms);
+void shclSvcMsgFree(PSHCLCLIENTMSG pMsg);
+void shclSvcMsgSetPeekReturn(PSHCLCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms);
+int shclSvcMsgAdd(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg, bool fAppend);
+int shclSvcMsgPeek(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[], bool fWait);
+int shclSvcMsgGet(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
+
+int shclSvcClientWakeup(PSHCLCLIENT pClient);
 
 # ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
-int sharedClipboardSvcTransferStart(PSHCLCLIENT pClient,
-                                    SHCLTRANSFERDIR enmDir, SHCLSOURCE enmSource,
-                                    PSHCLTRANSFER *ppTransfer);
-int sharedClipboardSvcTransferStop(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer);
-bool sharedClipboardSvcTransferMsgIsAllowed(uint32_t uMode, uint32_t uMsg);
+int shclSvcTransferStart(PSHCLCLIENT pClient,
+                         SHCLTRANSFERDIR enmDir, SHCLSOURCE enmSource,
+                         PSHCLTRANSFER *ppTransfer);
+int shclSvcTransferStop(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer);
+bool shclSvcTransferMsgIsAllowed(uint32_t uMode, uint32_t uMsg);
 # endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
 
@@ -207,39 +207,44 @@
  * Platform-dependent implementations.
  */
-int SharedClipboardSvcImplInit(void);
-void SharedClipboardSvcImplDestroy(void);
-
-int SharedClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless);
-int SharedClipboardSvcImplDisconnect(PSHCLCLIENT pClient);
-int SharedClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLFORMATDATA pFormats);
+int ShClSvcImplInit(void);
+void ShClSvcImplDestroy(void);
+
+int ShClSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless);
+int ShClSvcImplDisconnect(PSHCLCLIENT pClient);
+int ShClSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLFORMATDATA pFormats);
 /** @todo Document: Can return VINF_HGCM_ASYNC_EXECUTE to defer returning read data.*/
-int SharedClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData, uint32_t *pcbActual);
-int SharedClipboardSvcImplWriteData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData);
+int ShClSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData, uint32_t *pcbActual);
+int ShClSvcImplWriteData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData);
 /**
  * Synchronise the contents of the host clipboard with the guest, called by the HGCM layer
  * after a save and restore of the guest.
  */
-int SharedClipboardSvcImplSync(PSHCLCLIENT pClient);
+int ShClSvcImplSync(PSHCLCLIENT pClient);
 
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
-int sharedClipboardSvcTransferIfaceOpen(PSHCLPROVIDERCTX pCtx);
-int sharedClipboardSvcTransferIfaceClose(PSHCLPROVIDERCTX pCtx);
-
-int sharedClipboardSvcTransferIfaceGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList);
-
-int sharedClipboardSvcTransferIfaceListOpen(PSHCLPROVIDERCTX pCtx, PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList);
-int sharedClipboardSvcTransferIfaceListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList);
-int sharedClipboardSvcTransferIfaceListHdrRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr);
-int sharedClipboardSvcTransferIfaceListHdrWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr);
-int sharedClipboardSvcTransferIfaceListEntryRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry);
-int sharedClipboardSvcTransferIfaceListEntryWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry);
-
-int sharedClipboardSvcTransferIfaceObjOpen(PSHCLPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms,
-                                           PSHCLOBJHANDLE phObj);
-int sharedClipboardSvcTransferIfaceObjClose(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj);
-int sharedClipboardSvcTransferIfaceObjRead(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
-                                           void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead);
-int sharedClipboardSvcTransferIfaceObjWrite(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
-                                            void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten);
+int shclSvcTransferAreaDetach(PSHCLCLIENTSTATE pClientState, PSHCLTRANSFER pTransfer);
+int shclSvcTransferHandler(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE callHandle, uint32_t u32Function,
+                           uint32_t cParms, VBOXHGCMSVCPARM paParms[], uint64_t tsArrival);
+int shclSvcTransferHostHandler(uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
+
+int shclSvcTransferIfaceOpen(PSHCLPROVIDERCTX pCtx);
+int shclSvcTransferIfaceClose(PSHCLPROVIDERCTX pCtx);
+
+int shclSvcTransferIfaceGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList);
+
+int shclSvcTransferIfaceListOpen(PSHCLPROVIDERCTX pCtx, PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList);
+int shclSvcTransferIfaceListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList);
+int shclSvcTransferIfaceListHdrRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr);
+int shclSvcTransferIfaceListHdrWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr);
+int shclSvcTransferIfaceListEntryRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry);
+int shclSvcTransferIfaceListEntryWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry);
+
+int shclSvcTransferIfaceObjOpen(PSHCLPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms,
+                                PSHCLOBJHANDLE phObj);
+int shclSvcTransferIfaceObjClose(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj);
+int shclSvcTransferIfaceObjRead(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
+                                void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead);
+int shclSvcTransferIfaceObjWrite(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
+                                 void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten);
 
 DECLCALLBACK(void) VBoxSvcClipboardTransferPrepareCallback(PSHCLTRANSFERCALLBACKDATA pData);
@@ -250,6 +255,6 @@
 DECLCALLBACK(void) VBoxSvcClipboardTransferErrorCallback(PSHCLTRANSFERCALLBACKDATA pData, int rc);
 
-int SharedClipboardSvcImplTransferCreate(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer);
-int SharedClipboardSvcImplTransferDestroy(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer);
+int ShClSvcImplTransferCreate(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer);
+int ShClSvcImplTransferDestroy(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer);
 #endif /*VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
 
Index: trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-transfers.cpp
===================================================================
--- trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-transfers.cpp	(revision 80990)
+++ trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-transfers.cpp	(revision 80995)
@@ -48,8 +48,8 @@
 *   Prototypes                                                                                                                   *
 *********************************************************************************************************************************/
-static int sharedClipboardSvcTransferSetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
-                                                 PSHCLMSGCTX pMsgCtx, PSHCLLISTOPENPARMS pOpenParms);
-static int sharedClipboardSvcTransferSetListClose(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
-                                                  PSHCLMSGCTX pMsgCtx, SHCLLISTHANDLE hList);
+static int shclSvcTransferSetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
+                                      PSHCLMSGCTX pMsgCtx, PSHCLLISTOPENPARMS pOpenParms);
+static int shclSvcTransferSetListClose(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
+                                       PSHCLMSGCTX pMsgCtx, SHCLLISTHANDLE hList);
 
 
@@ -58,5 +58,5 @@
 *********************************************************************************************************************************/
 
-DECLCALLBACK(int) sharedClipboardSvcTransferIfaceOpen(PSHCLPROVIDERCTX pCtx)
+DECLCALLBACK(int) shclSvcTransferIfaceOpen(PSHCLPROVIDERCTX pCtx)
 {
     RT_NOREF(pCtx);
@@ -66,5 +66,5 @@
 }
 
-DECLCALLBACK(int) sharedClipboardSvcTransferIfaceClose(PSHCLPROVIDERCTX pCtx)
+DECLCALLBACK(int) shclSvcTransferIfaceClose(PSHCLPROVIDERCTX pCtx)
 {
     RT_NOREF(pCtx);
@@ -74,5 +74,5 @@
 }
 
-DECLCALLBACK(int) sharedClipboardSvcTransferIfaceGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList)
+DECLCALLBACK(int) shclSvcTransferIfaceGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList)
 {
     LogFlowFuncEnter();
@@ -83,6 +83,6 @@
     int rc;
 
-    PSHCLCLIENTMSG pMsgHdr = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_ROOT_LIST_HDR_READ,
-                                                        VBOX_SHCL_CPARMS_ROOT_LIST_HDR_READ);
+    PSHCLCLIENTMSG pMsgHdr = shclSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_ROOT_LIST_HDR_READ,
+                                             VBOX_SHCL_CPARMS_ROOT_LIST_HDR_READ);
     if (pMsgHdr)
     {
@@ -93,5 +93,5 @@
         HGCMSvcSetU32(&pMsgHdr->paParms[1], 0 /* fRoots */);
 
-        rc = sharedClipboardSvcMsgAdd(pClient, pMsgHdr, true /* fAppend */);
+        rc = shclSvcMsgAdd(pClient, pMsgHdr, true /* fAppend */);
         if (RT_SUCCESS(rc))
         {
@@ -99,5 +99,5 @@
             AssertRC(rc2);
 
-            rc = sharedClipboardSvcClientWakeup(pClient);
+            rc = shclSvcClientWakeup(pClient);
             if (RT_SUCCESS(rc))
             {
@@ -124,6 +124,6 @@
                                 for (uint32_t i = 0; i < pSrcRootListHdr->cRoots; i++)
                                 {
-                                    PSHCLCLIENTMSG pMsgEntry = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_ROOT_LIST_ENTRY_READ,
-                                                                                          VBOX_SHCL_CPARMS_ROOT_LIST_ENTRY_READ_REQ);
+                                    PSHCLCLIENTMSG pMsgEntry = shclSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_ROOT_LIST_ENTRY_READ,
+                                                                               VBOX_SHCL_CPARMS_ROOT_LIST_ENTRY_READ_REQ);
 
                                     uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
@@ -138,5 +138,5 @@
                                     AssertRC(rc2);
 
-                                    rc = sharedClipboardSvcMsgAdd(pClient, pMsgEntry, true /* fAppend */);
+                                    rc = shclSvcMsgAdd(pClient, pMsgEntry, true /* fAppend */);
                                     if (RT_FAILURE(rc))
                                         break;
@@ -192,6 +192,6 @@
 }
 
-DECLCALLBACK(int) sharedClipboardSvcTransferIfaceListOpen(PSHCLPROVIDERCTX pCtx,
-                                                          PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList)
+DECLCALLBACK(int) shclSvcTransferIfaceListOpen(PSHCLPROVIDERCTX pCtx,
+                                               PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList)
 {
     LogFlowFuncEnter();
@@ -202,6 +202,6 @@
     int rc;
 
-    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_OPEN,
-                                                     VBOX_SHCL_CPARMS_LIST_OPEN);
+    PSHCLCLIENTMSG pMsg = shclSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_OPEN,
+                                          VBOX_SHCL_CPARMS_LIST_OPEN);
     if (pMsg)
     {
@@ -209,10 +209,10 @@
 
         pMsg->Ctx.uContextID = VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,  pCtx->pTransfer->State.uID,
-                                                                      uEvent);
-
-        rc = sharedClipboardSvcTransferSetListOpen(pMsg->cParms, pMsg->paParms, &pMsg->Ctx, pOpenParms);
-        if (RT_SUCCESS(rc))
-        {
-            rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
+                                                        uEvent);
+
+        rc = shclSvcTransferSetListOpen(pMsg->cParms, pMsg->paParms, &pMsg->Ctx, pOpenParms);
+        if (RT_SUCCESS(rc))
+        {
+            rc = shclSvcMsgAdd(pClient, pMsg, true /* fAppend */);
             if (RT_SUCCESS(rc))
             {
@@ -220,5 +220,5 @@
                 AssertRC(rc2);
 
-                rc = sharedClipboardSvcClientWakeup(pClient);
+                rc = shclSvcClientWakeup(pClient);
                 if (RT_SUCCESS(rc))
                 {
@@ -251,5 +251,5 @@
 }
 
-DECLCALLBACK(int) sharedClipboardSvcTransferIfaceListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList)
+DECLCALLBACK(int) shclSvcTransferIfaceListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList)
 {
     LogFlowFuncEnter();
@@ -260,6 +260,6 @@
     int rc;
 
-    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_CLOSE,
-                                                     VBOX_SHCL_CPARMS_LIST_CLOSE);
+    PSHCLCLIENTMSG pMsg = shclSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_CLOSE,
+                                          VBOX_SHCL_CPARMS_LIST_CLOSE);
     if (pMsg)
     {
@@ -267,10 +267,10 @@
 
         pMsg->Ctx.uContextID = VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID, pCtx->pTransfer->State.uID,
-                                                                    uEvent);
-
-        rc = sharedClipboardSvcTransferSetListClose(pMsg->cParms, pMsg->paParms, &pMsg->Ctx, hList);
-        if (RT_SUCCESS(rc))
-        {
-            rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
+                                                        uEvent);
+
+        rc = shclSvcTransferSetListClose(pMsg->cParms, pMsg->paParms, &pMsg->Ctx, hList);
+        if (RT_SUCCESS(rc))
+        {
+            rc = shclSvcMsgAdd(pClient, pMsg, true /* fAppend */);
             if (RT_SUCCESS(rc))
             {
@@ -278,5 +278,5 @@
                 AssertRC(rc2);
 
-                rc = sharedClipboardSvcClientWakeup(pClient);
+                rc = shclSvcClientWakeup(pClient);
                 if (RT_SUCCESS(rc))
                 {
@@ -298,6 +298,6 @@
 }
 
-DECLCALLBACK(int) sharedClipboardSvcTransferIfaceListHdrRead(PSHCLPROVIDERCTX pCtx,
-                                                             SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr)
+DECLCALLBACK(int) shclSvcTransferIfaceListHdrRead(PSHCLPROVIDERCTX pCtx,
+                                                  SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr)
 {
     LogFlowFuncEnter();
@@ -308,6 +308,6 @@
     int rc;
 
-    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_HDR_READ,
-                                                     VBOX_SHCL_CPARMS_LIST_HDR_READ_REQ);
+    PSHCLCLIENTMSG pMsg = shclSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_HDR_READ,
+                                          VBOX_SHCL_CPARMS_LIST_HDR_READ_REQ);
     if (pMsg)
     {
@@ -319,5 +319,5 @@
         HGCMSvcSetU32(&pMsg->paParms[2], 0 /* fFlags */);
 
-        rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
+        rc = shclSvcMsgAdd(pClient, pMsg, true /* fAppend */);
         if (RT_SUCCESS(rc))
         {
@@ -325,10 +325,10 @@
             AssertRC(rc2);
 
-            rc = sharedClipboardSvcClientWakeup(pClient);
+            rc = shclSvcClientWakeup(pClient);
             if (RT_SUCCESS(rc))
             {
                 PSHCLEVENTPAYLOAD pPayload;
                 rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent,
-                                                         pCtx->pTransfer->uTimeoutMs, &pPayload);
+                                             pCtx->pTransfer->uTimeoutMs, &pPayload);
                 if (RT_SUCCESS(rc))
                 {
@@ -349,6 +349,6 @@
 }
 
-DECLCALLBACK(int) sharedClipboardSvcTransferIfaceListHdrWrite(PSHCLPROVIDERCTX pCtx,
-                                                              SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr)
+DECLCALLBACK(int) shclSvcTransferIfaceListHdrWrite(PSHCLPROVIDERCTX pCtx,
+                                                   SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr)
 {
     RT_NOREF(pCtx, hList, pListHdr);
@@ -359,6 +359,6 @@
 }
 
-DECLCALLBACK(int) sharedClipboardSvcTransferIfaceListEntryRead(PSHCLPROVIDERCTX pCtx,
-                                                               SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry)
+DECLCALLBACK(int) shclSvcTransferIfaceListEntryRead(PSHCLPROVIDERCTX pCtx,
+                                                    SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry)
 {
     LogFlowFuncEnter();
@@ -369,6 +369,6 @@
     int rc;
 
-    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_ENTRY_READ,
-                                                     VBOX_SHCL_CPARMS_LIST_ENTRY_READ);
+    PSHCLCLIENTMSG pMsg = shclSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_ENTRY_READ,
+                                          VBOX_SHCL_CPARMS_LIST_ENTRY_READ);
     if (pMsg)
     {
@@ -376,9 +376,9 @@
 
         HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
-                                                                              pCtx->pTransfer->State.uID, uEvent));
+                                                                  pCtx->pTransfer->State.uID, uEvent));
         HGCMSvcSetU64(&pMsg->paParms[1], hList);
         HGCMSvcSetU32(&pMsg->paParms[2], 0 /* fInfo */);
 
-        rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
+        rc = shclSvcMsgAdd(pClient, pMsg, true /* fAppend */);
         if (RT_SUCCESS(rc))
         {
@@ -386,5 +386,5 @@
             AssertRC(rc2);
 
-            rc = sharedClipboardSvcClientWakeup(pClient);
+            rc = shclSvcClientWakeup(pClient);
             if (RT_SUCCESS(rc))
             {
@@ -409,6 +409,6 @@
 }
 
-DECLCALLBACK(int) sharedClipboardSvcTransferIfaceListEntryWrite(PSHCLPROVIDERCTX pCtx,
-                                                                SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry)
+DECLCALLBACK(int) shclSvcTransferIfaceListEntryWrite(PSHCLPROVIDERCTX pCtx,
+                                                     SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry)
 {
     RT_NOREF(pCtx, hList, pListEntry);
@@ -419,6 +419,6 @@
 }
 
-int sharedClipboardSvcTransferIfaceObjOpen(PSHCLPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms,
-                                           PSHCLOBJHANDLE phObj)
+int shclSvcTransferIfaceObjOpen(PSHCLPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms,
+                                PSHCLOBJHANDLE phObj)
 {
     LogFlowFuncEnter();
@@ -429,6 +429,6 @@
     int rc;
 
-    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_OPEN,
-                                                     VBOX_SHCL_CPARMS_OBJ_OPEN);
+    PSHCLCLIENTMSG pMsg = shclSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_OPEN,
+                                          VBOX_SHCL_CPARMS_OBJ_OPEN);
     if (pMsg)
     {
@@ -446,5 +446,5 @@
         HGCMSvcSetU32(&pMsg->paParms[4], pCreateParms->fCreate);
 
-        rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
+        rc = shclSvcMsgAdd(pClient, pMsg, true /* fAppend */);
         if (RT_SUCCESS(rc))
         {
@@ -452,5 +452,5 @@
             AssertRC(rc2);
 
-            rc = sharedClipboardSvcClientWakeup(pClient);
+            rc = shclSvcClientWakeup(pClient);
             if (RT_SUCCESS(rc))
             {
@@ -480,5 +480,5 @@
 }
 
-int sharedClipboardSvcTransferIfaceObjClose(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj)
+int shclSvcTransferIfaceObjClose(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj)
 {
     LogFlowFuncEnter();
@@ -489,6 +489,6 @@
     int rc;
 
-    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_CLOSE,
-                                                     VBOX_SHCL_CPARMS_OBJ_CLOSE);
+    PSHCLCLIENTMSG pMsg = shclSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_CLOSE,
+                                          VBOX_SHCL_CPARMS_OBJ_CLOSE);
     if (pMsg)
     {
@@ -499,5 +499,5 @@
         HGCMSvcSetU64(&pMsg->paParms[1], hObj);
 
-        rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
+        rc = shclSvcMsgAdd(pClient, pMsg, true /* fAppend */);
         if (RT_SUCCESS(rc))
         {
@@ -505,5 +505,5 @@
             AssertRC(rc2);
 
-            rc = sharedClipboardSvcClientWakeup(pClient);
+            rc = shclSvcClientWakeup(pClient);
             if (RT_SUCCESS(rc))
             {
@@ -533,6 +533,6 @@
 }
 
-int sharedClipboardSvcTransferIfaceObjRead(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
-                                           void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead)
+int shclSvcTransferIfaceObjRead(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
+                                void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead)
 {
     LogFlowFuncEnter();
@@ -543,6 +543,6 @@
     int rc;
 
-    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_READ,
-                                                     VBOX_SHCL_CPARMS_OBJ_READ_REQ);
+    PSHCLCLIENTMSG pMsg = shclSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_READ,
+                                          VBOX_SHCL_CPARMS_OBJ_READ_REQ);
     if (pMsg)
     {
@@ -555,5 +555,5 @@
         HGCMSvcSetU32(&pMsg->paParms[3], fFlags);
 
-        rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
+        rc = shclSvcMsgAdd(pClient, pMsg, true /* fAppend */);
         if (RT_SUCCESS(rc))
         {
@@ -561,5 +561,5 @@
             AssertRC(rc2);
 
-            rc = sharedClipboardSvcClientWakeup(pClient);
+            rc = shclSvcClientWakeup(pClient);
             if (RT_SUCCESS(rc))
             {
@@ -592,6 +592,6 @@
 }
 
-int sharedClipboardSvcTransferIfaceObjWrite(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
-                                            void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten)
+int shclSvcTransferIfaceObjWrite(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
+                                 void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten)
 {
     LogFlowFuncEnter();
@@ -602,6 +602,6 @@
     int rc;
 
-    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_WRITE,
-                                                     VBOX_SHCL_CPARMS_OBJ_WRITE);
+    PSHCLCLIENTMSG pMsg = shclSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_WRITE,
+                                          VBOX_SHCL_CPARMS_OBJ_WRITE);
     if (pMsg)
     {
@@ -614,5 +614,5 @@
         HGCMSvcSetU64(&pMsg->paParms[3], fFlags);
 
-        rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
+        rc = shclSvcMsgAdd(pClient, pMsg, true /* fAppend */);
         if (RT_SUCCESS(rc))
         {
@@ -620,5 +620,5 @@
             AssertRC(rc2);
 
-            rc = sharedClipboardSvcClientWakeup(pClient);
+            rc = shclSvcClientWakeup(pClient);
             if (RT_SUCCESS(rc))
             {
@@ -659,6 +659,6 @@
  * @param   pReply              Where to store the reply.
  */
-static int sharedClipboardSvcTransferGetReply(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
-                                              PSHCLREPLY pReply)
+static int shclSvcTransferGetReply(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
+                                   PSHCLREPLY pReply)
 {
     int rc;
@@ -735,6 +735,6 @@
  * @param   pRootLstHdr         Where to store the transfer root list header on success.
  */
-static int sharedClipboardSvcTransferGetRootListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
-                                                    PSHCLROOTLISTHDR pRootLstHdr)
+static int shclSvcTransferGetRootListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
+                                         PSHCLROOTLISTHDR pRootLstHdr)
 {
     int rc;
@@ -761,6 +761,6 @@
  * @param   pListEntry          Where to store the root list entry.
  */
-static int sharedClipboardSvcTransferGetRootListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
-                                                      PSHCLROOTLISTENTRY pListEntry)
+static int shclSvcTransferGetRootListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
+                                           PSHCLROOTLISTENTRY pListEntry)
 {
     int rc;
@@ -798,6 +798,6 @@
  * @param   pOpenParms          Where to store the open parameters of the request.
  */
-static int sharedClipboardSvcTransferGetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
-                                                 PSHCLLISTOPENPARMS pOpenParms)
+static int shclSvcTransferGetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
+                                      PSHCLLISTOPENPARMS pOpenParms)
 {
     int rc;
@@ -845,6 +845,6 @@
  * @param   pOpenParms          List open parameters to set.
  */
-static int sharedClipboardSvcTransferSetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
-                                                 PSHCLMSGCTX pMsgCtx, PSHCLLISTOPENPARMS pOpenParms)
+static int shclSvcTransferSetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
+                                      PSHCLMSGCTX pMsgCtx, PSHCLLISTOPENPARMS pOpenParms)
 {
     int rc;
@@ -878,6 +878,6 @@
  * @param   hList               Handle of list to close.
  */
-static int sharedClipboardSvcTransferSetListClose(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
-                                                  PSHCLMSGCTX pMsgCtx, SHCLLISTHANDLE hList)
+static int shclSvcTransferSetListClose(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
+                                       PSHCLMSGCTX pMsgCtx, SHCLLISTHANDLE hList)
 {
     int rc;
@@ -906,6 +906,6 @@
  * @param   pListHdr            Where to store the list header.
  */
-static int sharedClipboardSvcTransferGetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
-                                                PSHCLLISTHANDLE phList, PSHCLLISTHDR pListHdr)
+static int shclSvcTransferGetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
+                                     PSHCLLISTHANDLE phList, PSHCLLISTHDR pListHdr)
 {
     int rc;
@@ -945,6 +945,6 @@
  * @param   pListHdr            Pointer to data to set to the HGCM parameters.
  */
-static int sharedClipboardSvcTransferSetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
-                                                PVBOXSHCLMSGCTX pMsgCtx, PSHCLLISTHDR pListHdr)
+static int shclSvcTransferSetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
+                                     PVBOXSHCLMSGCTX pMsgCtx, PSHCLLISTHDR pListHdr)
 {
     int rc;
@@ -980,6 +980,6 @@
  * @param   pListEntry          Where to store the list entry.
  */
-static int sharedClipboardSvcTransferGetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
-                                                  PSHCLLISTHANDLE phList, PSHCLLISTENTRY pListEntry)
+static int shclSvcTransferGetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
+                                       PSHCLLISTHANDLE phList, PSHCLLISTENTRY pListEntry)
 {
     int rc;
@@ -1026,6 +1026,6 @@
  * @param   pListEntry          Pointer to data to set to the HGCM parameters.
  */
-static int sharedClipboardSvcTransferSetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
-                                                  PVBOXSHCLMSGCTX pMsgCtx, PSHCLLISTENTRY pListEntry)
+static int shclSvcTransferSetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
+                                       PVBOXSHCLMSGCTX pMsgCtx, PSHCLLISTENTRY pListEntry)
 {
     int rc;
@@ -1058,5 +1058,5 @@
  * @param   pDataChunk          Where to store the object data chunk data.
  */
-static int sharedClipboardSvcTransferGetObjDataChunk(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PSHCLOBJDATACHUNK pDataChunk)
+static int shclSvcTransferGetObjDataChunk(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PSHCLOBJDATACHUNK pDataChunk)
 {
     AssertPtrReturn(paParms,    VERR_INVALID_PARAMETER);
@@ -1096,5 +1096,5 @@
  * @param   pRc                 Where to store the received error code.
  */
-static int sharedClipboardSvcTransferGetError(uint32_t cParms, VBOXHGCMSVCPARM paParms[], int *pRc)
+static int shclSvcTransferGetError(uint32_t cParms, VBOXHGCMSVCPARM paParms[], int *pRc)
 {
     AssertPtrReturn(paParms, VERR_INVALID_PARAMETER);
@@ -1123,6 +1123,6 @@
  * @param   paParms             Array function parameters supplied.
  */
-static int sharedClipboardSvcTransferHandleReply(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer,
-                                                 uint32_t cParms, VBOXHGCMSVCPARM paParms[])
+static int shclSvcTransferHandleReply(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer,
+                                      uint32_t cParms, VBOXHGCMSVCPARM paParms[])
 {
     RT_NOREF(pClient);
@@ -1134,5 +1134,5 @@
     if (pReply)
     {
-        rc = sharedClipboardSvcTransferGetReply(cParms, paParms, pReply);
+        rc = shclSvcTransferGetReply(cParms, paParms, pReply);
         if (RT_SUCCESS(rc))
         {
@@ -1208,10 +1208,10 @@
  * @param   tsArrival           Timestamp of arrival.
  */
-int sharedClipboardSvcTransferHandler(PSHCLCLIENT pClient,
-                                      VBOXHGCMCALLHANDLE callHandle,
-                                      uint32_t u32Function,
-                                      uint32_t cParms,
-                                      VBOXHGCMSVCPARM paParms[],
-                                      uint64_t tsArrival)
+int shclSvcTransferHandler(PSHCLCLIENT pClient,
+                           VBOXHGCMCALLHANDLE callHandle,
+                           uint32_t u32Function,
+                           uint32_t cParms,
+                           VBOXHGCMSVCPARM paParms[],
+                           uint64_t tsArrival)
 {
     RT_NOREF(callHandle, paParms, tsArrival);
@@ -1222,5 +1222,5 @@
 #if 0
     /* Check if we've the right mode set. */
-    if (!sharedClipboardSvcTransferMsgIsAllowed(sharedClipboardSvcGetMode(), u32Function))
+    if (!shclSvcTransferMsgIsAllowed(shclSvcGetMode(), u32Function))
     {
         LogFunc(("Wrong clipboard mode, denying access\n"));
@@ -1317,5 +1317,5 @@
                 if (RT_SUCCESS(rc))
                 {
-                    rc = sharedClipboardSvcTransferAreaRegister(&pClient->State, pTransfer);
+                    rc = shclSvcTransferAreaRegister(&pClient->State, pTransfer);
                     if (RT_SUCCESS(rc))
                     {
@@ -1325,17 +1325,17 @@
                         creationCtx.enmSource = pClient->State.enmSource;
 
-                        creationCtx.Interface.pfnTransferOpen  = sharedClipboardSvcTransferOpen;
-                        creationCtx.Interface.pfnTransferClose = sharedClipboardSvcTransferClose;
-                        creationCtx.Interface.pfnListOpen      = sharedClipboardSvcTransferListOpen;
-                        creationCtx.Interface.pfnListClose     = sharedClipboardSvcTransferListClose;
-                        creationCtx.Interface.pfnObjOpen       = sharedClipboardSvcTransferObjOpen;
-                        creationCtx.Interface.pfnObjClose      = sharedClipboardSvcTransferObjClose;
+                        creationCtx.Interface.pfnTransferOpen  = shclSvcTransferOpen;
+                        creationCtx.Interface.pfnTransferClose = shclSvcTransferClose;
+                        creationCtx.Interface.pfnListOpen      = shclSvcTransferListOpen;
+                        creationCtx.Interface.pfnListClose     = shclSvcTransferListClose;
+                        creationCtx.Interface.pfnObjOpen       = shclSvcTransferObjOpen;
+                        creationCtx.Interface.pfnObjClose      = shclSvcTransferObjClose;
 
                         if (enmDir == SHCLTRANSFERDIR_READ)
                         {
-                            creationCtx.Interface.pfnRootsGet        = sharedClipboardSvcTransferGetRoots;
-                            creationCtx.Interface.pfnListHdrRead     = sharedClipboardSvcTransferListHdrRead;
-                            creationCtx.Interface.pfnListEntryRead   = sharedClipboardSvcTransferListEntryRead;
-                            creationCtx.Interface.pfnObjRead         = sharedClipboardSvcTransferObjRead;
+                            creationCtx.Interface.pfnRootsGet        = shclSvcTransferGetRoots;
+                            creationCtx.Interface.pfnListHdrRead     = shclSvcTransferListHdrRead;
+                            creationCtx.Interface.pfnListEntryRead   = shclSvcTransferListEntryRead;
+                            creationCtx.Interface.pfnObjRead         = shclSvcTransferObjRead;
                         }
                         else
@@ -1366,12 +1366,12 @@
                     if (RT_SUCCESS(rc))
                     {
-                        rc = SharedClipboardSvcImplTransferCreate(pClient, pTransfer);
+                        rc = ShClSvcImplTransferCreate(pClient, pTransfer);
                         if (RT_SUCCESS(rc))
-                            rc = SharedClipboardSvcImplFormatAnnounce(pClient, VBOX_SHCL_FMT_URI_LIST);
+                            rc = ShClSvcImplFormatAnnounce(pClient, VBOX_SHCL_FMT_URI_LIST);
                     }
 
                     if (RT_FAILURE(rc))
                     {
-                        SharedClipboardSvcImplTransferDestroy(pClient, pTransfer);
+                        ShClSvcImplTransferDestroy(pClient, pTransfer);
                         SharedClipboardTransferDestroy(pTransfer);
                     }
@@ -1390,5 +1390,5 @@
         case VBOX_SHCL_GUEST_FN_REPLY:
         {
-            rc = sharedClipboardSvcTransferHandleReply(pClient, pTransfer, cParms, paParms);
+            rc = shclSvcTransferHandleReply(pClient, pTransfer, cParms, paParms);
             break;
         }
@@ -1402,5 +1402,5 @@
         {
             SHCLROOTLISTHDR lstHdr;
-            rc = sharedClipboardSvcTransferGetRootListHdr(cParms, paParms, &lstHdr);
+            rc = shclSvcTransferGetRootListHdr(cParms, paParms, &lstHdr);
             if (RT_SUCCESS(rc))
             {
@@ -1446,5 +1446,5 @@
         {
             SHCLROOTLISTENTRY lstEntry;
-            rc = sharedClipboardSvcTransferGetRootListEntry(cParms, paParms, &lstEntry);
+            rc = shclSvcTransferGetRootListEntry(cParms, paParms, &lstEntry);
             if (RT_SUCCESS(rc))
             {
@@ -1469,5 +1469,5 @@
         {
             SHCLLISTOPENPARMS listOpenParms;
-            rc = sharedClipboardSvcTransferGetListOpen(cParms, paParms, &listOpenParms);
+            rc = shclSvcTransferGetListOpen(cParms, paParms, &listOpenParms);
             if (RT_SUCCESS(rc))
             {
@@ -1509,5 +1509,5 @@
                 rc = SharedClipboardTransferListGetHeader(pTransfer, hList, &hdrList);
                 /*if (RT_SUCCESS(rc))
-                    rc = sharedClipboardSvcTransferSetListHdr(cParms, paParms, &hdrList);*/
+                    rc = shclSvcTransferSetListHdr(cParms, paParms, &hdrList);*/
             }
             break;
@@ -1521,5 +1521,5 @@
             {
                 SHCLLISTHANDLE hList;
-                rc = sharedClipboardSvcTransferGetListHdr(cParms, paParms, &hList, &hdrList);
+                rc = shclSvcTransferGetListHdr(cParms, paParms, &hList, &hdrList);
                 if (RT_SUCCESS(rc))
                 {
@@ -1564,5 +1564,5 @@
             {
                 SHCLLISTHANDLE hList;
-                rc = sharedClipboardSvcTransferGetListEntry(cParms, paParms, &hList, &entryList);
+                rc = shclSvcTransferGetListEntry(cParms, paParms, &hList, &entryList);
                 if (RT_SUCCESS(rc))
                 {
@@ -1605,5 +1605,5 @@
         {
             SHCLOBJDATACHUNK dataChunk;
-            rc = sharedClipboardSvcTransferGetObjDataChunk(cParms, paParms, &dataChunk);
+            rc = shclSvcTransferGetObjDataChunk(cParms, paParms, &dataChunk);
             if (RT_SUCCESS(rc))
             {
@@ -1805,5 +1805,5 @@
         {
             int rcGuest;
-            rc = sharedClipboardSvcTransferGetError(cParms,paParms, &rcGuest);
+            rc = shclSvcTransferGetError(cParms,paParms, &rcGuest);
             if (RT_SUCCESS(rc))
                 LogRel(("Shared Clipboard: Transfer error: %Rrc\n", rcGuest));
@@ -1821,5 +1821,5 @@
 
 /**
- * transfer host handler for the Shared Clipboard host service.
+ * Transfer host handler for the Shared Clipboard host service.
  *
  * @returns VBox status code.
@@ -1828,7 +1828,7 @@
  * @param   paParms             Array function parameters  supplied.
  */
-int sharedClipboardSvcTransferHostHandler(uint32_t u32Function,
-                                          uint32_t cParms,
-                                          VBOXHGCMSVCPARM paParms[])
+int shclSvcTransferHostHandler(uint32_t u32Function,
+                               uint32_t cParms,
+                               VBOXHGCMSVCPARM paParms[])
 {
     RT_NOREF(cParms, paParms);
@@ -1860,5 +1860,5 @@
  * @param   pTransfer           Shared Clipboard transfer to register a clipboard area for.
  */
-int sharedClipboardSvcTransferAreaRegister(PSHCLCLIENTSTATE pClientState, PSHCLTRANSFER pTransfer)
+int shclSvcTransferAreaRegister(PSHCLCLIENTSTATE pClientState, PSHCLTRANSFER pTransfer)
 {
     RT_NOREF(pClientState);
@@ -1909,5 +1909,5 @@
  * @param   pTransfer           Shared Clipboard transfer to unregister a clipboard area from.
  */
-int sharedClipboardSvcTransferAreaUnregister(PSHCLCLIENTSTATE pClientState, PSHCLTRANSFER pTransfer)
+int shclSvcTransferAreaUnregister(PSHCLCLIENTSTATE pClientState, PSHCLTRANSFER pTransfer)
 {
     RT_NOREF(pClientState);
@@ -1957,6 +1957,6 @@
  * @param   uID                 ID of clipboard area to to attach to. Specify 0 to attach to the most recent one.
  */
-int sharedClipboardSvcTransferAreaAttach(PSHCLCLIENTSTATE pClientState, PSHCLTRANSFER pTransfer,
-                                         SHCLAREAID uID)
+int shclSvcTransferAreaAttach(PSHCLCLIENTSTATE pClientState, PSHCLTRANSFER pTransfer,
+                              SHCLAREAID uID)
 {
     RT_NOREF(pClientState);
@@ -2005,5 +2005,5 @@
  * @param   pTransfer           Shared Clipboard transfer to detach a clipboard area from.
  */
-int sharedClipboardSvcTransferAreaDetach(PSHCLCLIENTSTATE pClientState, PSHCLTRANSFER pTransfer)
+int shclSvcTransferAreaDetach(PSHCLCLIENTSTATE pClientState, PSHCLTRANSFER pTransfer)
 {
     RT_NOREF(pClientState);
@@ -2047,6 +2047,6 @@
  * @param   puEvent             Where to store the created wait event. Optional.
  */
-int sharedClipboardSvcTransferSendStatus(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer, SHCLTRANSFERSTATUS uStatus,
-                                         int rcTransfer, PSHCLEVENTID puEvent)
+int shclSvcTransferSendStatus(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer, SHCLTRANSFERSTATUS uStatus,
+                              int rcTransfer, PSHCLEVENTID puEvent)
 {
     AssertPtrReturn(pClient,   VERR_INVALID_POINTER);
@@ -2054,6 +2054,6 @@
     /* puEvent is optional. */
 
-    PSHCLCLIENTMSG pMsgReadData = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_STATUS,
-                                                             VBOX_SHCL_CPARMS_TRANSFER_STATUS);
+    PSHCLCLIENTMSG pMsgReadData = shclSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_STATUS,
+                                                  VBOX_SHCL_CPARMS_TRANSFER_STATUS);
     if (!pMsgReadData)
         return VERR_NO_MEMORY;
@@ -2068,5 +2068,5 @@
     HGCMSvcSetU32(&pMsgReadData->paParms[4], 0 /* fFlags, unused */);
 
-    int rc = sharedClipboardSvcMsgAdd(pClient, pMsgReadData, true /* fAppend */);
+    int rc = shclSvcMsgAdd(pClient, pMsgReadData, true /* fAppend */);
     if (RT_SUCCESS(rc))
     {
@@ -2074,5 +2074,5 @@
         if (RT_SUCCESS(rc))
         {
-            rc = sharedClipboardSvcClientWakeup(pClient);
+            rc = shclSvcClientWakeup(pClient);
             if (RT_SUCCESS(rc))
             {
@@ -2101,7 +2101,7 @@
  * @param   ppTransfer          Where to return the created transfer on success. Optional.
  */
-int sharedClipboardSvcTransferStart(PSHCLCLIENT pClient,
-                                    SHCLTRANSFERDIR enmDir, SHCLSOURCE enmSource,
-                                    PSHCLTRANSFER *ppTransfer)
+int shclSvcTransferStart(PSHCLCLIENT pClient,
+                         SHCLTRANSFERDIR enmDir, SHCLSOURCE enmSource,
+                         PSHCLTRANSFER *ppTransfer)
 {
     AssertPtrReturn(pClient, VERR_INVALID_POINTER);
@@ -2127,27 +2127,27 @@
             if (enmDir == SHCLTRANSFERDIR_READ)
             {
-                rc = sharedClipboardSvcTransferAreaRegister(&pClient->State, pTransfer);
+                rc = shclSvcTransferAreaRegister(&pClient->State, pTransfer);
                 if (RT_SUCCESS(rc))
                 {
-                    creationCtx.Interface.pfnTransferOpen  = sharedClipboardSvcTransferIfaceOpen;
-                    creationCtx.Interface.pfnTransferClose = sharedClipboardSvcTransferIfaceClose;
-
-                    creationCtx.Interface.pfnRootsGet      = sharedClipboardSvcTransferIfaceGetRoots;
-
-                    creationCtx.Interface.pfnListOpen      = sharedClipboardSvcTransferIfaceListOpen;
-                    creationCtx.Interface.pfnListClose     = sharedClipboardSvcTransferIfaceListClose;
-                    creationCtx.Interface.pfnListHdrRead   = sharedClipboardSvcTransferIfaceListHdrRead;
-                    creationCtx.Interface.pfnListEntryRead = sharedClipboardSvcTransferIfaceListEntryRead;
-
-                    creationCtx.Interface.pfnObjOpen       = sharedClipboardSvcTransferIfaceObjOpen;
-                    creationCtx.Interface.pfnObjClose      = sharedClipboardSvcTransferIfaceObjClose;
-                    creationCtx.Interface.pfnObjRead       = sharedClipboardSvcTransferIfaceObjRead;
+                    creationCtx.Interface.pfnTransferOpen  = shclSvcTransferIfaceOpen;
+                    creationCtx.Interface.pfnTransferClose = shclSvcTransferIfaceClose;
+
+                    creationCtx.Interface.pfnRootsGet      = shclSvcTransferIfaceGetRoots;
+
+                    creationCtx.Interface.pfnListOpen      = shclSvcTransferIfaceListOpen;
+                    creationCtx.Interface.pfnListClose     = shclSvcTransferIfaceListClose;
+                    creationCtx.Interface.pfnListHdrRead   = shclSvcTransferIfaceListHdrRead;
+                    creationCtx.Interface.pfnListEntryRead = shclSvcTransferIfaceListEntryRead;
+
+                    creationCtx.Interface.pfnObjOpen       = shclSvcTransferIfaceObjOpen;
+                    creationCtx.Interface.pfnObjClose      = shclSvcTransferIfaceObjClose;
+                    creationCtx.Interface.pfnObjRead       = shclSvcTransferIfaceObjRead;
                 }
             }
             else if (enmDir == SHCLTRANSFERDIR_WRITE)
             {
-                creationCtx.Interface.pfnListHdrWrite   = sharedClipboardSvcTransferIfaceListHdrWrite;
-                creationCtx.Interface.pfnListEntryWrite = sharedClipboardSvcTransferIfaceListEntryWrite;
-                creationCtx.Interface.pfnObjWrite       = sharedClipboardSvcTransferIfaceObjWrite;
+                creationCtx.Interface.pfnListHdrWrite   = shclSvcTransferIfaceListHdrWrite;
+                creationCtx.Interface.pfnListEntryWrite = shclSvcTransferIfaceListEntryWrite;
+                creationCtx.Interface.pfnObjWrite       = shclSvcTransferIfaceObjWrite;
             }
             else
@@ -2162,5 +2162,5 @@
             if (RT_SUCCESS(rc))
             {
-                rc = SharedClipboardSvcImplTransferCreate(pClient, pTransfer);
+                rc = ShClSvcImplTransferCreate(pClient, pTransfer);
                 if (RT_SUCCESS(rc))
                 {
@@ -2172,7 +2172,7 @@
                         {
                             SHCLEVENTID uEvent;
-                            rc = sharedClipboardSvcTransferSendStatus(pClient, pTransfer,
-                                                                      SHCLTRANSFERSTATUS_INITIALIZED, VINF_SUCCESS,
-                                                                      &uEvent);
+                            rc = shclSvcTransferSendStatus(pClient, pTransfer,
+                                                           SHCLTRANSFERSTATUS_INITIALIZED, VINF_SUCCESS,
+                                                           &uEvent);
                             if (RT_SUCCESS(rc))
                             {
@@ -2241,5 +2241,5 @@
  * @param   pTransfer           Transfer to stop.
  */
-int sharedClipboardSvcTransferStop(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer)
+int shclSvcTransferStop(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer)
 {
     int rc = SharedClipboardTransferClose(pTransfer);
@@ -2247,7 +2247,7 @@
     {
         SHCLEVENTID uEvent;
-        rc = sharedClipboardSvcTransferSendStatus(pClient, pTransfer,
-                                                  SHCLTRANSFERSTATUS_STOPPED, VINF_SUCCESS,
-                                                  &uEvent);
+        rc = shclSvcTransferSendStatus(pClient, pTransfer,
+                                       SHCLTRANSFERSTATUS_STOPPED, VINF_SUCCESS,
+                                       &uEvent);
         if (RT_SUCCESS(rc))
         {
Index: trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-utils.cpp
===================================================================
--- trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-utils.cpp	(revision 80990)
+++ trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-utils.cpp	(revision 80995)
@@ -107,6 +107,6 @@
             LogFlowFunc(("VBOX_SHCL_HOST_MSG_TRANSFER_TRANSFER_START\n"));
 
-            if (   sharedClipboardSvcGetMode() != VBOX_SHCL_MODE_HOST_TO_GUEST
-                && sharedClipboardSvcGetMode() != VBOX_SHCL_MODE_BIDIRECTIONAL)
+            if (   shclSvcGetMode() != VBOX_SHCL_MODE_HOST_TO_GUEST
+                && shclSvcGetMode() != VBOX_SHCL_MODE_BIDIRECTIONAL)
             {
                 LogFlowFunc(("Wrong clipboard mode, skipping\n"));
@@ -130,5 +130,5 @@
 }
 
-bool sharedClipboardSvcTransferReturnMsg(PSHCLCLIENT pClient, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
+bool shclSvcTransferReturnMsg(PSHCLCLIENT pClient, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
 {
     RT_NOREF(pClient, cParms, paParms);
Index: trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-win.cpp
===================================================================
--- trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-win.cpp	(revision 80990)
+++ trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-win.cpp	(revision 80995)
@@ -179,5 +179,5 @@
 
     SHCLEVENTID uEvent = 0;
-    int rc = sharedClipboardSvcDataReadRequest(pCtx->pClient, &dataReq, &uEvent);
+    int rc = shclSvcDataReadRequest(pCtx->pClient, &dataReq, &uEvent);
     if (RT_SUCCESS(rc))
     {
@@ -231,5 +231,5 @@
                     rc = vboxClipboardSvcWinSyncInternal(pCtx);
                     if (RT_SUCCESS(rc))
-                        rc = sharedClipboardSvcSetSource(pCtx->pClient, SHCLSOURCE_LOCAL);
+                        rc = shclSvcSetSource(pCtx->pClient, SHCLSOURCE_LOCAL);
                 }
                 else
@@ -273,5 +273,5 @@
                     rc = vboxClipboardSvcWinSyncInternal(pCtx);
                     if (RT_SUCCESS(rc))
-                        sharedClipboardSvcSetSource(pCtx->pClient, SHCLSOURCE_LOCAL);
+                        shclSvcSetSource(pCtx->pClient, SHCLSOURCE_LOCAL);
                 }
                 else
@@ -357,7 +357,7 @@
             {
                 PSHCLTRANSFER pTransfer;
-                int rc = sharedClipboardSvcTransferStart(pCtx->pClient,
-                                                         SHCLTRANSFERDIR_READ, SHCLSOURCE_REMOTE,
-                                                         &pTransfer);
+                int rc = shclSvcTransferStart(pCtx->pClient,
+                                              SHCLTRANSFERDIR_READ, SHCLSOURCE_REMOTE,
+                                              &pTransfer);
                 if (RT_SUCCESS(rc))
                 {
@@ -591,5 +591,5 @@
             && Formats.uFormats != VBOX_SHCL_FMT_NONE)
         {
-            rc = sharedClipboardSvcFormatsReport(pCtx->pClient, &Formats);
+            rc = shclSvcFormatsReport(pCtx->pClient, &Formats);
         }
     }
@@ -605,5 +605,5 @@
  */
 
-int SharedClipboardSvcImplInit(void)
+int ShClSvcImplInit(void)
 {
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
@@ -621,5 +621,5 @@
 }
 
-void SharedClipboardSvcImplDestroy(void)
+void ShClSvcImplDestroy(void)
 {
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
@@ -629,5 +629,5 @@
 }
 
-int SharedClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless)
+int ShClSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless)
 {
     RT_NOREF(fHeadless);
@@ -656,5 +656,5 @@
 
         /* Sync the host clipboard content with the client. */
-        rc = SharedClipboardSvcImplSync(pClient);
+        rc = ShClSvcImplSync(pClient);
     }
     else
@@ -665,5 +665,5 @@
 }
 
-int SharedClipboardSvcImplSync(PSHCLCLIENT pClient)
+int ShClSvcImplSync(PSHCLCLIENT pClient)
 {
     /* Sync the host clipboard content with the client. */
@@ -671,5 +671,5 @@
 }
 
-int SharedClipboardSvcImplDisconnect(PSHCLCLIENT pClient)
+int ShClSvcImplDisconnect(PSHCLCLIENT pClient)
 {
     AssertPtrReturn(pClient, VERR_INVALID_POINTER);
@@ -712,6 +712,6 @@
 }
 
-int SharedClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
-                                         PSHCLFORMATDATA pFormats)
+int ShClSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
+                              PSHCLFORMATDATA pFormats)
 {
     AssertPtrReturn(pClient, VERR_INVALID_POINTER);
@@ -737,6 +737,6 @@
 }
 
-int SharedClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
-                                   PSHCLDATABLOCK pData, uint32_t *pcbActual)
+int ShClSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
+                        PSHCLDATABLOCK pData, uint32_t *pcbActual)
 {
     AssertPtrReturn(pClient,             VERR_INVALID_POINTER);
@@ -848,10 +848,10 @@
 }
 
-int SharedClipboardSvcImplWriteData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
-                                    PSHCLDATABLOCK pData)
+int ShClSvcImplWriteData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
+                         PSHCLDATABLOCK pData)
 {
     LogFlowFuncEnter();
 
-    int rc = sharedClipboardSvcDataReadSignal(pClient, pCmdCtx, pData);
+    int rc = shclSvcDataReadSignal(pClient, pCmdCtx, pData);
 
     LogFlowFuncLeaveRC(rc);
@@ -860,5 +860,5 @@
 
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
-int SharedClipboardSvcImplTransferCreate(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer)
+int ShClSvcImplTransferCreate(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer)
 {
     RT_NOREF(pClient, pTransfer);
@@ -869,5 +869,5 @@
 }
 
-int SharedClipboardSvcImplTransferDestroy(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer)
+int ShClSvcImplTransferDestroy(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer)
 {
     LogFlowFuncEnter();
Index: trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11.cpp
===================================================================
--- trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11.cpp	(revision 80990)
+++ trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11.cpp	(revision 80995)
@@ -74,5 +74,5 @@
     formatData.uFormats = u32Formats;
 
-    int rc2 = sharedClipboardSvcFormatsReport(pCtx->pClient, &formatData);
+    int rc2 = shclSvcFormatsReport(pCtx->pClient, &formatData);
     AssertRC(rc2);
 }
@@ -82,5 +82,5 @@
  * @note  Host glue code
  */
-int SharedClipboardSvcImplInit(void)
+int ShClSvcImplInit(void)
 {
     LogFlowFuncEnter();
@@ -92,5 +92,5 @@
  * @note  host glue code
  */
-void SharedClipboardSvcImplDestroy(void)
+void ShClSvcImplDestroy(void)
 {
     LogFlowFuncEnter();
@@ -102,5 +102,5 @@
  *        the clipboard and leave ownership to X11.
  */
-int SharedClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless)
+int ShClSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless)
 {
     int rc = VINF_SUCCESS;
@@ -144,5 +144,5 @@
  * @note  Host glue code
  */
-int SharedClipboardSvcImplSync(PSHCLCLIENT pClient)
+int ShClSvcImplSync(PSHCLCLIENT pClient)
 {
     LogFlowFuncEnter();
@@ -156,5 +156,5 @@
     formatData.uFormats = VBOX_SHCL_FMT_NONE;
 
-    return sharedClipboardSvcFormatsReport(pClient, &formatData);
+    return shclSvcFormatsReport(pClient, &formatData);
 }
 
@@ -163,5 +163,5 @@
  * @note  Host glue code
  */
-int SharedClipboardSvcImplDisconnect(PSHCLCLIENT pClient)
+int ShClSvcImplDisconnect(PSHCLCLIENT pClient)
 {
     LogFlowFuncEnter();
@@ -176,5 +176,5 @@
     /* If there is a currently pending request, release it immediately. */
     SHCLDATABLOCK dataBlock = { 0, NULL, 0 };
-    SharedClipboardSvcImplWriteData(pClient, NULL, &dataBlock);
+    ShClSvcImplWriteData(pClient, NULL, &dataBlock);
 
     int rc = ClipStopX11(pCtx->pBackend);
@@ -201,6 +201,6 @@
  * @param pFormats              Clipboard formats the guest is offering.
  */
-int SharedClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
-                                         PSHCLFORMATDATA pFormats)
+int ShClSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
+                              PSHCLFORMATDATA pFormats)
 {
     RT_NOREF(pCmdCtx);
@@ -247,6 +247,6 @@
  *
  */
-int SharedClipboardSvcImplReadData(PSHCLCLIENT pClient,
-                                   PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData, uint32_t *pcbActual)
+int ShClSvcImplReadData(PSHCLCLIENT pClient,
+                        PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData, uint32_t *pcbActual)
 {
     RT_NOREF(pCmdCtx);
@@ -301,11 +301,11 @@
  * @param  pData                Data block to write to clipboard.
  */
-int SharedClipboardSvcImplWriteData(PSHCLCLIENT pClient,
-                                    PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData)
+int ShClSvcImplWriteData(PSHCLCLIENT pClient,
+                         PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData)
 {
     LogFlowFunc(("pClient=%p, pv=%p, cb=%RU32, uFormat=%02X\n",
                  pClient, pData->pvData, pData->cbData, pData->uFormat));
 
-    int rc = sharedClipboardSvcDataReadSignal(pClient, pCmdCtx, pData);
+    int rc = shclSvcDataReadSignal(pClient, pCmdCtx, pData);
 
     LogFlowFuncLeaveRC(rc);
@@ -370,5 +370,5 @@
 
     SHCLEVENTID uEvent;
-    int rc = sharedClipboardSvcDataReadRequest(pCtx->pClient, &dataReq, &uEvent);
+    int rc = shclSvcDataReadRequest(pCtx->pClient, &dataReq, &uEvent);
     if (RT_SUCCESS(rc))
     {
@@ -392,5 +392,5 @@
 
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
-int SharedClipboardSvcImplTransferCreate(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer)
+int ShClSvcImplTransferCreate(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer)
 {
     RT_NOREF(pClient, pTransfer);
@@ -398,5 +398,5 @@
 }
 
-int SharedClipboardSvcImplTransferDestroy(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer)
+int ShClSvcImplTransferDestroy(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer)
 {
     RT_NOREF(pClient, pTransfer);
Index: trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp
===================================================================
--- trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp	(revision 80990)
+++ trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp	(revision 80995)
@@ -224,7 +224,7 @@
 *   Prototypes                                                                                                                   *
 *********************************************************************************************************************************/
-static int sharedClipboardSvcClientStateInit(PSHCLCLIENTSTATE pClientState, uint32_t uClientID);
-static int sharedClipboardSvcClientStateDestroy(PSHCLCLIENTSTATE pClientState);
-static void sharedClipboardSvcClientStateReset(PSHCLCLIENTSTATE pClientState);
+static int shclSvcClientStateInit(PSHCLCLIENTSTATE pClientState, uint32_t uClientID);
+static int shclSvcClientStateDestroy(PSHCLCLIENTSTATE pClientState);
+static void shclSvcClientStateReset(PSHCLCLIENTSTATE pClientState);
 
 
@@ -251,5 +251,5 @@
 
 
-uint32_t sharedClipboardSvcGetMode(void)
+uint32_t shclSvcGetMode(void)
 {
     return g_uMode;
@@ -260,5 +260,5 @@
 uint32_t TestClipSvcGetMode(void)
 {
-    return sharedClipboardSvcGetMode();
+    return shclSvcGetMode();
 }
 #endif
@@ -270,5 +270,5 @@
 }
 
-static int sharedClipboardSvcModeSet(uint32_t uMode)
+static int shclSvcModeSet(uint32_t uMode)
 {
     int rc = VERR_NOT_SUPPORTED;
@@ -317,5 +317,5 @@
  * @param   pClient             Pointer to the client data structure to reset message queue for.
  */
-void sharedClipboardSvcMsgQueueReset(PSHCLCLIENT pClient)
+void shclSvcMsgQueueReset(PSHCLCLIENT pClient)
 {
     LogFlowFuncEnter();
@@ -335,5 +335,5 @@
  * @param   cParms              Number of HGCM parameters to allocate.
  */
-PSHCLCLIENTMSG sharedClipboardSvcMsgAlloc(uint32_t uMsg, uint32_t cParms)
+PSHCLCLIENTMSG shclSvcMsgAlloc(uint32_t uMsg, uint32_t cParms)
 {
     PSHCLCLIENTMSG pMsg = (PSHCLCLIENTMSG)RTMemAlloc(sizeof(SHCLCLIENTMSG));
@@ -360,5 +360,5 @@
  *                              The pointer will be invalid after calling this function.
  */
-void sharedClipboardSvcMsgFree(PSHCLCLIENTMSG pMsg)
+void shclSvcMsgFree(PSHCLCLIENTMSG pMsg)
 {
     if (!pMsg)
@@ -381,5 +381,5 @@
  * @remarks ASSUMES the parameters has been cleared by clientMsgPeek.
  */
-void sharedClipboardSvcMsgSetPeekReturn(PSHCLCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms)
+void shclSvcMsgSetPeekReturn(PSHCLCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms)
 {
     Assert(cDstParms >= 2);
@@ -411,5 +411,5 @@
  * @param   cDstParms   The number of peek parameters (at least two).
  */
-int sharedClipboardSvcMsgSetGetHostMsgOldReturn(PSHCLCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms)
+int shclSvcMsgSetGetHostMsgOldReturn(PSHCLCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms)
 {
     AssertPtrReturn(pMsg,           VERR_INVALID_POINTER);
@@ -468,5 +468,5 @@
  * @param   fAppend             Whether to append or prepend the message to the queue.
  */
-int sharedClipboardSvcMsgAdd(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg, bool fAppend)
+int shclSvcMsgAdd(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg, bool fAppend)
 {
     AssertPtrReturn(pMsg, VERR_INVALID_POINTER);
@@ -501,6 +501,6 @@
  *                      immediately.
  */
-int sharedClipboardSvcMsgPeek(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[],
-                              bool fWait)
+int shclSvcMsgPeek(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[],
+                   bool fWait)
 {
     /*
@@ -548,5 +548,5 @@
         if (pFirstMsg)
         {
-            sharedClipboardSvcMsgSetPeekReturn(pFirstMsg, paParms, cParms);
+            shclSvcMsgSetPeekReturn(pFirstMsg, paParms, cParms);
             LogFlowFunc(("[Client %RU32] VBOX_SHCL_GUEST_FN_MSG_PEEK_XXX -> VINF_SUCCESS (idMsg=%u (%s), cParms=%u)\n",
                          pClient->State.uClientID, pFirstMsg->uMsg, VBoxShClHostMsgToStr(pFirstMsg->uMsg),
@@ -590,5 +590,5 @@
  * @param   paParms     Array of parameters.
  */
-int sharedClipboardSvcMsgGetOld(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
+int shclSvcMsgGetOld(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
 {
     int rc;
@@ -614,5 +614,5 @@
                          pFirstMsg->cParms));
 
-            rc = sharedClipboardSvcMsgSetGetHostMsgOldReturn(pFirstMsg, paParms, cParms);
+            rc = shclSvcMsgSetGetHostMsgOldReturn(pFirstMsg, paParms, cParms);
             if (RT_SUCCESS(rc))
             {
@@ -622,5 +622,5 @@
                 {
                     pClient->queueMsg.removeFirst();
-                    sharedClipboardSvcMsgFree(pFirstMsg);
+                    shclSvcMsgFree(pFirstMsg);
 
                     rc = VINF_HGCM_ASYNC_EXECUTE; /* The caller must not complete it. */
@@ -666,5 +666,5 @@
  * @param   paParms      Array of parameters.
  */
-int sharedClipboardSvcMsgGet(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
+int shclSvcMsgGet(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
 {
     /*
@@ -756,5 +756,5 @@
                 {
                     pClient->queueMsg.removeFirst();
-                    sharedClipboardSvcMsgFree(pFirstMsg);
+                    shclSvcMsgFree(pFirstMsg);
                 }
 
@@ -781,5 +781,5 @@
  * @param   pClient             Client to wake up.
  */
-int sharedClipboardSvcClientWakeup(PSHCLCLIENT pClient)
+int shclSvcClientWakeup(PSHCLCLIENT pClient)
 {
     int rc = VINF_NO_CHANGE;
@@ -804,10 +804,10 @@
                 if (pClient->Pending.uType == VBOX_SHCL_GUEST_FN_MSG_PEEK_WAIT)
                 {
-                    sharedClipboardSvcMsgSetPeekReturn(pFirstMsg, pClient->Pending.paParms, pClient->Pending.cParms);
+                    shclSvcMsgSetPeekReturn(pFirstMsg, pClient->Pending.paParms, pClient->Pending.cParms);
                     fDonePending = true;
                 }
                 else if (pClient->Pending.uType == VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD) /* Legacy */
                 {
-                    rc = sharedClipboardSvcMsgSetGetHostMsgOldReturn(pFirstMsg, pClient->Pending.paParms, pClient->Pending.cParms);
+                    rc = shclSvcMsgSetGetHostMsgOldReturn(pFirstMsg, pClient->Pending.paParms, pClient->Pending.cParms);
                     if (RT_SUCCESS(rc))
                     {
@@ -815,5 +815,5 @@
                          * remove the actual message from our queue right now. */
                         pClient->queueMsg.removeFirst();
-                        sharedClipboardSvcMsgFree(pFirstMsg);
+                        shclSvcMsgFree(pFirstMsg);
 
                         fDonePending = true;
@@ -853,6 +853,6 @@
  * @param   puEvent             Event ID for waiting for new data. Optional.
  */
-int sharedClipboardSvcDataReadRequest(PSHCLCLIENT pClient, PSHCLDATAREQ pDataReq,
-                                      PSHCLEVENTID puEvent)
+int shclSvcDataReadRequest(PSHCLCLIENT pClient, PSHCLDATAREQ pDataReq,
+                           PSHCLEVENTID puEvent)
 {
     AssertPtrReturn(pClient,  VERR_INVALID_POINTER);
@@ -862,6 +862,6 @@
     int rc;
 
-    PSHCLCLIENTMSG pMsgReadData = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_READ_DATA,
-                                                             VBOX_SHCL_CPARMS_READ_DATA);
+    PSHCLCLIENTMSG pMsgReadData = shclSvcMsgAlloc(VBOX_SHCL_HOST_MSG_READ_DATA,
+                                                  VBOX_SHCL_CPARMS_READ_DATA);
     if (pMsgReadData)
     {
@@ -873,5 +873,5 @@
         HGCMSvcSetU32(&pMsgReadData->paParms[2], pClient->State.cbChunkSize);
 
-        rc = sharedClipboardSvcMsgAdd(pClient, pMsgReadData, true /* fAppend */);
+        rc = shclSvcMsgAdd(pClient, pMsgReadData, true /* fAppend */);
         if (RT_SUCCESS(rc))
         {
@@ -879,5 +879,5 @@
             if (RT_SUCCESS(rc))
             {
-                rc = sharedClipboardSvcClientWakeup(pClient);
+                rc = shclSvcClientWakeup(pClient);
                 if (RT_SUCCESS(rc))
                 {
@@ -897,6 +897,6 @@
 }
 
-int sharedClipboardSvcDataReadSignal(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
-                                     PSHCLDATABLOCK pData)
+int shclSvcDataReadSignal(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
+                          PSHCLDATABLOCK pData)
 {
     SHCLEVENTID uEvent;
@@ -927,5 +927,5 @@
 }
 
-int sharedClipboardSvcFormatsReport(PSHCLCLIENT pClient, PSHCLFORMATDATA pFormats)
+int shclSvcFormatsReport(PSHCLCLIENT pClient, PSHCLFORMATDATA pFormats)
 {
     AssertPtrReturn(pClient,  VERR_INVALID_POINTER);
@@ -934,5 +934,5 @@
     int rc;
 
-    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_FORMATS_REPORT, 3);
+    PSHCLCLIENTMSG pMsg = shclSvcMsgAlloc(VBOX_SHCL_HOST_MSG_FORMATS_REPORT, 3);
     if (pMsg)
     {
@@ -944,5 +944,5 @@
         HGCMSvcSetU32(&pMsg->paParms[2], 0 /* fFlags */);
 
-        rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
+        rc = shclSvcMsgAdd(pClient, pMsg, true /* fAppend */);
         if (RT_SUCCESS(rc))
         {
@@ -952,6 +952,6 @@
             if (pFormats->uFormats & VBOX_SHCL_FMT_URI_LIST)
             {
-                rc = sharedClipboardSvcTransferStart(pClient, SHCLTRANSFERDIR_WRITE, SHCLSOURCE_LOCAL,
-                                                     NULL /* pTransfer */);
+                rc = shclSvcTransferStart(pClient, SHCLTRANSFERDIR_WRITE, SHCLSOURCE_LOCAL,
+                                          NULL /* pTransfer */);
                 if (RT_FAILURE(rc))
                     LogRel(("Shared Clipboard: Initializing host write transfer failed with %Rrc\n", rc));
@@ -960,5 +960,5 @@
             {
 #endif
-                rc = sharedClipboardSvcClientWakeup(pClient);
+                rc = shclSvcClientWakeup(pClient);
 
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
@@ -974,10 +974,10 @@
 }
 
-int sharedClipboardSvcGetDataWrite(PSHCLCLIENT pClient, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
+int shclSvcGetDataWrite(PSHCLCLIENT pClient, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
 {
     LogFlowFuncEnter();
 
-    if (   sharedClipboardSvcGetMode() != VBOX_SHCL_MODE_GUEST_TO_HOST
-        && sharedClipboardSvcGetMode() != VBOX_SHCL_MODE_BIDIRECTIONAL)
+    if (   shclSvcGetMode() != VBOX_SHCL_MODE_GUEST_TO_HOST
+        && shclSvcGetMode() != VBOX_SHCL_MODE_BIDIRECTIONAL)
     {
         return VERR_NOT_SUPPORTED;
@@ -1049,5 +1049,5 @@
         }
 
-        rc = SharedClipboardSvcImplWriteData(pClient, &cmdCtx, &dataBlock);
+        rc = ShClSvcImplWriteData(pClient, &cmdCtx, &dataBlock);
     }
 
@@ -1056,5 +1056,5 @@
 }
 
-int sharedClipboardSvcSetSource(PSHCLCLIENT pClient, SHCLSOURCE enmSource)
+int shclSvcSetSource(PSHCLCLIENT pClient, SHCLSOURCE enmSource)
 {
     if (!pClient) /* If no client connected (anymore), bail out. */
@@ -1082,7 +1082,7 @@
     if (RT_SUCCESS(rc))
     {
-        sharedClipboardSvcModeSet(VBOX_SHCL_MODE_OFF);
-
-        rc = SharedClipboardSvcImplInit();
+        shclSvcModeSet(VBOX_SHCL_MODE_OFF);
+
+        rc = ShClSvcImplInit();
 
         /* Clean up on failure, because 'svnUnload' will not be called
@@ -1102,5 +1102,5 @@
     LogFlowFuncEnter();
 
-    SharedClipboardSvcImplDestroy();
+    ShClSvcImplDestroy();
 
     RTCritSectDelete(&g_CritSect);
@@ -1121,13 +1121,13 @@
     PSHCLTRANSFER pTransfer = SharedClipboardTransferCtxGetTransfer(&pClient->TransferCtx, 0 /* Index*/);
     if (pTransfer)
-        sharedClipboardSvcTransferAreaDetach(&pClient->State, pTransfer);
+        shclSvcTransferAreaDetach(&pClient->State, pTransfer);
 
     SharedClipboardTransferCtxDestroy(&pClient->TransferCtx);
 #endif
 
-    SharedClipboardSvcImplDisconnect(pClient);
-
-    sharedClipboardSvcClientStateReset(&pClient->State);
-    sharedClipboardSvcClientStateDestroy(&pClient->State);
+    ShClSvcImplDisconnect(pClient);
+
+    shclSvcClientStateReset(&pClient->State);
+    shclSvcClientStateDestroy(&pClient->State);
 
     SharedClipboardEventSourceDestroy(&pClient->Events);
@@ -1161,11 +1161,11 @@
 
         /* Reset the client state. */
-        sharedClipboardSvcClientStateReset(&pClient->State);
+        shclSvcClientStateReset(&pClient->State);
 
         /* (Re-)initialize the client state. */
-        rc = sharedClipboardSvcClientStateInit(&pClient->State, u32ClientID);
+        rc = shclSvcClientStateInit(&pClient->State, u32ClientID);
         if (RT_SUCCESS(rc))
         {
-            rc = SharedClipboardSvcImplConnect(pClient, VBoxSvcClipboardGetHeadless());
+            rc = ShClSvcImplConnect(pClient, VBoxSvcClipboardGetHeadless());
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
             if (RT_SUCCESS(rc))
@@ -1224,5 +1224,5 @@
         case VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD:
         {
-            rc = sharedClipboardSvcMsgGetOld(pClient, callHandle, cParms, paParms);
+            rc = shclSvcMsgGetOld(pClient, callHandle, cParms, paParms);
             break;
         }
@@ -1242,5 +1242,5 @@
                 rc = VERR_INVALID_PARAMETER;
             }
-            else if (sharedClipboardSvcGetMode() == VBOX_SHCL_MODE_OFF)
+            else if (shclSvcGetMode() == VBOX_SHCL_MODE_OFF)
             {
                 rc = VERR_ACCESS_DENIED;
@@ -1267,5 +1267,5 @@
         case VBOX_SHCL_GUEST_FN_MSG_PEEK_NOWAIT:
         {
-            rc = sharedClipboardSvcMsgPeek(pClient, callHandle, cParms, paParms, false /*fWait*/);
+            rc = shclSvcMsgPeek(pClient, callHandle, cParms, paParms, false /*fWait*/);
             break;
         }
@@ -1273,5 +1273,5 @@
         case VBOX_SHCL_GUEST_FN_MSG_PEEK_WAIT:
         {
-            rc = sharedClipboardSvcMsgPeek(pClient, callHandle, cParms, paParms, true /*fWait*/);
+            rc = shclSvcMsgPeek(pClient, callHandle, cParms, paParms, true /*fWait*/);
             break;
         }
@@ -1279,5 +1279,5 @@
         case VBOX_SHCL_GUEST_FN_MSG_GET:
         {
-            rc = sharedClipboardSvcMsgGet(pClient, callHandle, cParms, paParms);
+            rc = shclSvcMsgGet(pClient, callHandle, cParms, paParms);
             break;
         }
@@ -1324,6 +1324,6 @@
             if (RT_SUCCESS(rc))
             {
-                if (   sharedClipboardSvcGetMode() != VBOX_SHCL_MODE_GUEST_TO_HOST
-                    && sharedClipboardSvcGetMode() != VBOX_SHCL_MODE_BIDIRECTIONAL)
+                if (   shclSvcGetMode() != VBOX_SHCL_MODE_GUEST_TO_HOST
+                    && shclSvcGetMode() != VBOX_SHCL_MODE_BIDIRECTIONAL)
                 {
                     rc = VERR_ACCESS_DENIED;
@@ -1331,5 +1331,5 @@
                 else if (uFormats != VBOX_SHCL_FMT_NONE) /* Only announce formats if we actually *have* formats to announce! */
                 {
-                    rc = sharedClipboardSvcSetSource(pClient, SHCLSOURCE_REMOTE);
+                    rc = shclSvcSetSource(pClient, SHCLSOURCE_REMOTE);
                     if (RT_SUCCESS(rc))
                     {
@@ -1354,5 +1354,5 @@
                         Assert(formatData.uFormats != VBOX_SHCL_FMT_NONE); /* Sanity. */
 
-                        rc = SharedClipboardSvcImplFormatAnnounce(pClient, &cmdCtx, &formatData);
+                        rc = ShClSvcImplFormatAnnounce(pClient, &cmdCtx, &formatData);
                     }
                 }
@@ -1377,6 +1377,6 @@
             else
             {
-                if (   sharedClipboardSvcGetMode() != VBOX_SHCL_MODE_HOST_TO_GUEST
-                    && sharedClipboardSvcGetMode() != VBOX_SHCL_MODE_BIDIRECTIONAL)
+                if (   shclSvcGetMode() != VBOX_SHCL_MODE_HOST_TO_GUEST
+                    && shclSvcGetMode() != VBOX_SHCL_MODE_BIDIRECTIONAL)
                 {
                     rc = VERR_ACCESS_DENIED;
@@ -1424,5 +1424,5 @@
                                 Assert(formatData.uFormats != VBOX_SHCL_FMT_NONE); /* There better is *any* format here now. */
 
-                                int rc2 = sharedClipboardSvcFormatsReport(pClient, &formatData);
+                                int rc2 = shclSvcFormatsReport(pClient, &formatData);
                                 AssertRC(rc2);
 
@@ -1456,5 +1456,5 @@
                             dataBlock.uFormat = uFormat;
 
-                            rc = SharedClipboardSvcImplReadData(pClient, &cmdCtx, &dataBlock, &cbActual);
+                            rc = ShClSvcImplReadData(pClient, &cmdCtx, &dataBlock, &cbActual);
                             if (RT_SUCCESS(rc))
                                 HGCMSvcSetU32(&paParms[2], cbActual);
@@ -1469,5 +1469,5 @@
         case VBOX_SHCL_GUEST_FN_DATA_WRITE:
         {
-            rc = sharedClipboardSvcGetDataWrite(pClient, cParms, paParms);
+            rc = shclSvcGetDataWrite(pClient, cParms, paParms);
             break;
         }
@@ -1476,5 +1476,5 @@
         {
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
-            rc = sharedClipboardSvcTransferHandler(pClient, callHandle, u32Function, cParms, paParms, tsArrival);
+            rc = shclSvcTransferHandler(pClient, callHandle, u32Function, cParms, paParms, tsArrival);
 #else
             rc = VERR_NOT_IMPLEMENTED;
@@ -1497,9 +1497,9 @@
  * @param   uClientID           Client ID (HGCM) to use for this client state.
  */
-static int sharedClipboardSvcClientStateInit(PSHCLCLIENTSTATE pClientState, uint32_t uClientID)
+static int shclSvcClientStateInit(PSHCLCLIENTSTATE pClientState, uint32_t uClientID)
 {
     LogFlowFuncEnter();
 
-    sharedClipboardSvcClientStateReset(pClientState);
+    shclSvcClientStateReset(pClientState);
 
     /* Register the client. */
@@ -1515,5 +1515,5 @@
  * @param   pClientState        Client state to destroy.
  */
-static int sharedClipboardSvcClientStateDestroy(PSHCLCLIENTSTATE pClientState)
+static int shclSvcClientStateDestroy(PSHCLCLIENTSTATE pClientState)
 {
     RT_NOREF(pClientState);
@@ -1529,5 +1529,5 @@
  * @param   pClientState    Client state to reset.
  */
-static void sharedClipboardSvcClientStateReset(PSHCLCLIENTSTATE pClientState)
+static void shclSvcClientStateReset(PSHCLCLIENTSTATE pClientState)
 {
     LogFlowFuncEnter();
@@ -1570,5 +1570,5 @@
                 rc = HGCMSvcGetU32(&paParms[0], &u32Mode);
                 if (RT_SUCCESS(rc))
-                    rc = sharedClipboardSvcModeSet(u32Mode);
+                    rc = shclSvcModeSet(u32Mode);
             }
 
@@ -1598,5 +1598,5 @@
         {
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
-            rc = sharedClipboardSvcTransferHostHandler(u32Function, cParms, paParms);
+            rc = shclSvcTransferHostHandler(u32Function, cParms, paParms);
 #else
             rc = VERR_NOT_IMPLEMENTED;
@@ -1791,5 +1791,5 @@
             }
 
-            rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
+            rc = shclSvcMsgAdd(pClient, pMsg, true /* fAppend */);
             AssertRCReturn(rc, rc);
         }
@@ -1802,5 +1802,5 @@
 
     /* Actual host data are to be reported to guest (SYNC). */
-    SharedClipboardSvcImplSync(pClient);
+    ShClSvcImplSync(pClient);
 
 #else  /* UNIT_TEST */
@@ -1843,5 +1843,5 @@
                     formatData.uFormats = u32Format;
 
-                    rc = sharedClipboardSvcFormatsReport(pClient, &formatData);
+                    rc = shclSvcFormatsReport(pClient, &formatData);
                 }
 
@@ -1858,5 +1858,5 @@
                 dataReq.cbSize = _64K; /** @todo Make this more dynamic. */
 
-                rc = sharedClipboardSvcDataReadRequest(pClient, &dataReq, NULL /* puEvent */);
+                rc = shclSvcDataReadRequest(pClient, &dataReq, NULL /* puEvent */);
                 break;
             }
