VirtualBox

Changeset 80995 in vbox for trunk/src/VBox/HostServices


Ignore:
Timestamp:
Sep 25, 2019 7:07:18 AM (5 years ago)
Author:
vboxsync
Message:

Shared Clipboard/HostService: More renaming.

Location:
trunk/src/VBox/HostServices/SharedClipboard
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-darwin.cpp

    r80858 r80995  
    5454
    5555/**
    56  * Checks if something is present on the clipboard and calls sharedClipboardSvcReportMsg.
     56 * Checks if something is present on the clipboard and calls shclSvcReportMsg.
    5757 *
    5858 * @returns IPRT status code (ignored).
    … …  
    7676        formatData.uFormats = fFormats;
    7777
    78         rc = sharedClipboardSvcFormatsReport(pCtx->pClient, &formatData);
     78        rc = shclSvcFormatsReport(pCtx->pClient, &formatData);
    7979    }
    8080
    … …  
    117117
    118118
    119 int SharedClipboardSvcImplInit(void)
     119int ShClSvcImplInit(void)
    120120{
    121121    Log(("vboxClipboardInit\n"));
    … …  
    137137}
    138138
    139 void SharedClipboardSvcImplDestroy(void)
     139void ShClSvcImplDestroy(void)
    140140{
    141141    /*
    … …  
    156156}
    157157
    158 int SharedClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless)
     158int ShClSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless)
    159159{
    160160    RT_NOREF(fHeadless);
    … …  
    172172
    173173    /* Initially sync the host clipboard content with the client. */
    174     int rc = SharedClipboardSvcImplSync(pClient);
    175 
    176     VBoxSvcClipboardUnlock();
    177     return rc;
    178 }
    179 
    180 int SharedClipboardSvcImplSync(PSHCLCLIENT pClient)
     174    int rc = ShClSvcImplSync(pClient);
     175
     176    VBoxSvcClipboardUnlock();
     177    return rc;
     178}
     179
     180int ShClSvcImplSync(PSHCLCLIENT pClient)
    181181{
    182182    /* Sync the host clipboard content with the client. */
    … …  
    190190}
    191191
    192 int SharedClipboardSvcImplDisconnect(PSHCLCLIENT pClient)
     192int ShClSvcImplDisconnect(PSHCLCLIENT pClient)
    193193{
    194194    VBoxSvcClipboardLock();
    … …  
    201201}
    202202
    203 int SharedClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient,
    204                                        PSHCLCLIENTCMDCTX pCmdCtx, PSHCLFORMATDATA pFormats)
     203int ShClSvcImplFormatAnnounce(PSHCLCLIENT pClient,
     204                              PSHCLCLIENTCMDCTX pCmdCtx, PSHCLFORMATDATA pFormats)
    205205{
    206206    RT_NOREF(pCmdCtx);
    … …  
    225225    dataReq.cbSize = _64K; /** @todo Make this more dynamic. */
    226226
    227     return sharedClipboardSvcDataReadRequest(pClient, &dataReq, NULL /* puEvent */);
     227    return shclSvcDataReadRequest(pClient, &dataReq, NULL /* puEvent */);
    228228}
    229229
    … …  
    236236 * @param pcbActual             Where to write the actual size of the written data.
    237237 */
    238 int SharedClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
    239                                  PSHCLDATABLOCK pData, uint32_t *pcbActual)
     238int ShClSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
     239                        PSHCLDATABLOCK pData, uint32_t *pcbActual)
    240240{
    241241    RT_NOREF(pCmdCtx);
    … …  
    262262 * @param pData                 Data block to write to clipboard.
    263263 */
    264 int SharedClipboardSvcImplWriteData(PSHCLCLIENT pClient,
    265                                   PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData)
     264int ShClSvcImplWriteData(PSHCLCLIENT pClient,
     265                         PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData)
    266266{
    267267    RT_NOREF(pCmdCtx);
    … …  
    277277
    278278#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    279 int SharedClipboardSvcImplTransferReadDir(PSHCLCLIENT pClient, PSHCLDIRDATA pDirData)
     279int ShClSvcImplTransferReadDir(PSHCLCLIENT pClient, PSHCLDIRDATA pDirData)
    280280{
    281281    RT_NOREF(pClient, pDirData);
    … …  
    283283}
    284284
    285 int SharedClipboardSvcImplTransferWriteDir(PSHCLCLIENT pClient, PSHCLDIRDATA pDirData)
     285int ShClSvcImplTransferWriteDir(PSHCLCLIENT pClient, PSHCLDIRDATA pDirData)
    286286{
    287287    RT_NOREF(pClient, pDirData);
    … …  
    289289}
    290290
    291 int SharedClipboardSvcImplTransferReadFileHdr(PSHCLCLIENT pClient, PSHCLFILEHDR pFileHdr)
     291int ShClSvcImplTransferReadFileHdr(PSHCLCLIENT pClient, PSHCLFILEHDR pFileHdr)
    292292{
    293293    RT_NOREF(pClient, pFileHdr);
    … …  
    295295}
    296296
    297 int SharedClipboardSvcImplTransferWriteFileHdr(PSHCLCLIENT pClient, PSHCLFILEHDR pFileHdr)
     297int ShClSvcImplTransferWriteFileHdr(PSHCLCLIENT pClient, PSHCLFILEHDR pFileHdr)
    298298{
    299299    RT_NOREF(pClient, pFileHdr);
    … …  
    301301}
    302302
    303 int SharedClipboardSvcImplTransferReadFileData(PSHCLCLIENT pClient, PSHCLFILEDATA pFileData)
     303int ShClSvcImplTransferReadFileData(PSHCLCLIENT pClient, PSHCLFILEDATA pFileData)
    304304{
    305305    RT_NOREF(pClient, pFileData);
    … …  
    307307}
    308308
    309 int SharedClipboardSvcImplTransferWriteFileData(PSHCLCLIENT pClient, PSHCLFILEDATA pFileData)
     309int ShClSvcImplTransferWriteFileData(PSHCLCLIENT pClient, PSHCLFILEDATA pFileData)
    310310{
    311311    RT_NOREF(pClient, pFileData);

  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-internal.h

    r80990 r80995  
    179179 * The service functions. Locking is between the service thread and the platform-dependent (window) thread.
    180180 */
    181 int sharedClipboardSvcDataReadRequest(PSHCLCLIENT pClient, PSHCLDATAREQ pDataReq, PSHCLEVENTID puEvent);
    182 int sharedClipboardSvcDataReadSignal(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData);
    183 int sharedClipboardSvcFormatsReport(PSHCLCLIENT pClient, PSHCLFORMATDATA pFormats);
    184 
    185 uint32_t sharedClipboardSvcGetMode(void);
    186 int sharedClipboardSvcSetSource(PSHCLCLIENT pClient, SHCLSOURCE enmSource);
    187 
    188 void sharedClipboardSvcMsgQueueReset(PSHCLCLIENT pClient);
    189 PSHCLCLIENTMSG sharedClipboardSvcMsgAlloc(uint32_t uMsg, uint32_t cParms);
    190 void sharedClipboardSvcMsgFree(PSHCLCLIENTMSG pMsg);
    191 void sharedClipboardSvcMsgSetPeekReturn(PSHCLCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms);
    192 int sharedClipboardSvcMsgAdd(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg, bool fAppend);
    193 int sharedClipboardSvcMsgPeek(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[], bool fWait);
    194 int sharedClipboardSvcMsgGet(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
    195 
    196 int sharedClipboardSvcClientWakeup(PSHCLCLIENT pClient);
     181int shclSvcDataReadRequest(PSHCLCLIENT pClient, PSHCLDATAREQ pDataReq, PSHCLEVENTID puEvent);
     182int shclSvcDataReadSignal(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData);
     183int shclSvcFormatsReport(PSHCLCLIENT pClient, PSHCLFORMATDATA pFormats);
     184
     185uint32_t shclSvcGetMode(void);
     186int shclSvcSetSource(PSHCLCLIENT pClient, SHCLSOURCE enmSource);
     187
     188void shclSvcMsgQueueReset(PSHCLCLIENT pClient);
     189PSHCLCLIENTMSG shclSvcMsgAlloc(uint32_t uMsg, uint32_t cParms);
     190void shclSvcMsgFree(PSHCLCLIENTMSG pMsg);
     191void shclSvcMsgSetPeekReturn(PSHCLCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms);
     192int shclSvcMsgAdd(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg, bool fAppend);
     193int shclSvcMsgPeek(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[], bool fWait);
     194int shclSvcMsgGet(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
     195
     196int shclSvcClientWakeup(PSHCLCLIENT pClient);
    197197
    198198# ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    199 int sharedClipboardSvcTransferStart(PSHCLCLIENT pClient,
    200                                     SHCLTRANSFERDIR enmDir, SHCLSOURCE enmSource,
    201                                     PSHCLTRANSFER *ppTransfer);
    202 int sharedClipboardSvcTransferStop(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer);
    203 bool sharedClipboardSvcTransferMsgIsAllowed(uint32_t uMode, uint32_t uMsg);
     199int shclSvcTransferStart(PSHCLCLIENT pClient,
     200                         SHCLTRANSFERDIR enmDir, SHCLSOURCE enmSource,
     201                         PSHCLTRANSFER *ppTransfer);
     202int shclSvcTransferStop(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer);
     203bool shclSvcTransferMsgIsAllowed(uint32_t uMode, uint32_t uMsg);
    204204# endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
    205205
    … …  
    207207 * Platform-dependent implementations.
    208208 */
    209 int SharedClipboardSvcImplInit(void);
    210 void SharedClipboardSvcImplDestroy(void);
    211 
    212 int SharedClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless);
    213 int SharedClipboardSvcImplDisconnect(PSHCLCLIENT pClient);
    214 int SharedClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLFORMATDATA pFormats);
     209int ShClSvcImplInit(void);
     210void ShClSvcImplDestroy(void);
     211
     212int ShClSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless);
     213int ShClSvcImplDisconnect(PSHCLCLIENT pClient);
     214int ShClSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLFORMATDATA pFormats);
    215215/** @todo Document: Can return VINF_HGCM_ASYNC_EXECUTE to defer returning read data.*/
    216 int SharedClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData, uint32_t *pcbActual);
    217 int SharedClipboardSvcImplWriteData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData);
     216int ShClSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData, uint32_t *pcbActual);
     217int ShClSvcImplWriteData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData);
    218218/**
    219219 * Synchronise the contents of the host clipboard with the guest, called by the HGCM layer
    220220 * after a save and restore of the guest.
    221221 */
    222 int SharedClipboardSvcImplSync(PSHCLCLIENT pClient);
     222int ShClSvcImplSync(PSHCLCLIENT pClient);
    223223
    224224#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    225 int sharedClipboardSvcTransferIfaceOpen(PSHCLPROVIDERCTX pCtx);
    226 int sharedClipboardSvcTransferIfaceClose(PSHCLPROVIDERCTX pCtx);
    227 
    228 int sharedClipboardSvcTransferIfaceGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList);
    229 
    230 int sharedClipboardSvcTransferIfaceListOpen(PSHCLPROVIDERCTX pCtx, PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList);
    231 int sharedClipboardSvcTransferIfaceListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList);
    232 int sharedClipboardSvcTransferIfaceListHdrRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr);
    233 int sharedClipboardSvcTransferIfaceListHdrWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr);
    234 int sharedClipboardSvcTransferIfaceListEntryRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry);
    235 int sharedClipboardSvcTransferIfaceListEntryWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry);
    236 
    237 int sharedClipboardSvcTransferIfaceObjOpen(PSHCLPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms,
    238                                            PSHCLOBJHANDLE phObj);
    239 int sharedClipboardSvcTransferIfaceObjClose(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj);
    240 int sharedClipboardSvcTransferIfaceObjRead(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
    241                                            void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead);
    242 int sharedClipboardSvcTransferIfaceObjWrite(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
    243                                             void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten);
     225int shclSvcTransferAreaDetach(PSHCLCLIENTSTATE pClientState, PSHCLTRANSFER pTransfer);
     226int shclSvcTransferHandler(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE callHandle, uint32_t u32Function,
     227                           uint32_t cParms, VBOXHGCMSVCPARM paParms[], uint64_t tsArrival);
     228int shclSvcTransferHostHandler(uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
     229
     230int shclSvcTransferIfaceOpen(PSHCLPROVIDERCTX pCtx);
     231int shclSvcTransferIfaceClose(PSHCLPROVIDERCTX pCtx);
     232
     233int shclSvcTransferIfaceGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList);
     234
     235int shclSvcTransferIfaceListOpen(PSHCLPROVIDERCTX pCtx, PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList);
     236int shclSvcTransferIfaceListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList);
     237int shclSvcTransferIfaceListHdrRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr);
     238int shclSvcTransferIfaceListHdrWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr);
     239int shclSvcTransferIfaceListEntryRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry);
     240int shclSvcTransferIfaceListEntryWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry);
     241
     242int shclSvcTransferIfaceObjOpen(PSHCLPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms,
     243                                PSHCLOBJHANDLE phObj);
     244int shclSvcTransferIfaceObjClose(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj);
     245int shclSvcTransferIfaceObjRead(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
     246                                void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead);
     247int shclSvcTransferIfaceObjWrite(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
     248                                 void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten);
    244249
    245250DECLCALLBACK(void) VBoxSvcClipboardTransferPrepareCallback(PSHCLTRANSFERCALLBACKDATA pData);
    … …  
    250255DECLCALLBACK(void) VBoxSvcClipboardTransferErrorCallback(PSHCLTRANSFERCALLBACKDATA pData, int rc);
    251256
    252 int SharedClipboardSvcImplTransferCreate(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer);
    253 int SharedClipboardSvcImplTransferDestroy(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer);
     257int ShClSvcImplTransferCreate(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer);
     258int ShClSvcImplTransferDestroy(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer);
    254259#endif /*VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
    255260

  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-transfers.cpp

    r80990 r80995  
    4848*   Prototypes                                                                                                                   *
    4949*********************************************************************************************************************************/
    50 static int sharedClipboardSvcTransferSetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    51                                                  PSHCLMSGCTX pMsgCtx, PSHCLLISTOPENPARMS pOpenParms);
    52 static int sharedClipboardSvcTransferSetListClose(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    53                                                   PSHCLMSGCTX pMsgCtx, SHCLLISTHANDLE hList);
     50static int shclSvcTransferSetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     51                                      PSHCLMSGCTX pMsgCtx, PSHCLLISTOPENPARMS pOpenParms);
     52static int shclSvcTransferSetListClose(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     53                                       PSHCLMSGCTX pMsgCtx, SHCLLISTHANDLE hList);
    5454
    5555
    … …  
    5858*********************************************************************************************************************************/
    5959
    60 DECLCALLBACK(int) sharedClipboardSvcTransferIfaceOpen(PSHCLPROVIDERCTX pCtx)
     60DECLCALLBACK(int) shclSvcTransferIfaceOpen(PSHCLPROVIDERCTX pCtx)
    6161{
    6262    RT_NOREF(pCtx);
    … …  
    6666}
    6767
    68 DECLCALLBACK(int) sharedClipboardSvcTransferIfaceClose(PSHCLPROVIDERCTX pCtx)
     68DECLCALLBACK(int) shclSvcTransferIfaceClose(PSHCLPROVIDERCTX pCtx)
    6969{
    7070    RT_NOREF(pCtx);
    … …  
    7474}
    7575
    76 DECLCALLBACK(int) sharedClipboardSvcTransferIfaceGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList)
     76DECLCALLBACK(int) shclSvcTransferIfaceGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList)
    7777{
    7878    LogFlowFuncEnter();
    … …  
    8383    int rc;
    8484
    85     PSHCLCLIENTMSG pMsgHdr = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_ROOT_LIST_HDR_READ,
    86                                                         VBOX_SHCL_CPARMS_ROOT_LIST_HDR_READ);
     85    PSHCLCLIENTMSG pMsgHdr = shclSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_ROOT_LIST_HDR_READ,
     86                                             VBOX_SHCL_CPARMS_ROOT_LIST_HDR_READ);
    8787    if (pMsgHdr)
    8888    {
    … …  
    9393        HGCMSvcSetU32(&pMsgHdr->paParms[1], 0 /* fRoots */);
    9494
    95         rc = sharedClipboardSvcMsgAdd(pClient, pMsgHdr, true /* fAppend */);
     95        rc = shclSvcMsgAdd(pClient, pMsgHdr, true /* fAppend */);
    9696        if (RT_SUCCESS(rc))
    9797        {
    … …  
    9999            AssertRC(rc2);
    100100
    101             rc = sharedClipboardSvcClientWakeup(pClient);
     101            rc = shclSvcClientWakeup(pClient);
    102102            if (RT_SUCCESS(rc))
    103103            {
    … …  
    124124                                for (uint32_t i = 0; i < pSrcRootListHdr->cRoots; i++)
    125125                                {
    126                                     PSHCLCLIENTMSG pMsgEntry = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_ROOT_LIST_ENTRY_READ,
    127                                                                                           VBOX_SHCL_CPARMS_ROOT_LIST_ENTRY_READ_REQ);
     126                                    PSHCLCLIENTMSG pMsgEntry = shclSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_ROOT_LIST_ENTRY_READ,
     127                                                                               VBOX_SHCL_CPARMS_ROOT_LIST_ENTRY_READ_REQ);
    128128
    129129                                    uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
    … …  
    138138                                    AssertRC(rc2);
    139139
    140                                     rc = sharedClipboardSvcMsgAdd(pClient, pMsgEntry, true /* fAppend */);
     140                                    rc = shclSvcMsgAdd(pClient, pMsgEntry, true /* fAppend */);
    141141                                    if (RT_FAILURE(rc))
    142142                                        break;
    … …  
    192192}
    193193
    194 DECLCALLBACK(int) sharedClipboardSvcTransferIfaceListOpen(PSHCLPROVIDERCTX pCtx,
    195                                                           PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList)
     194DECLCALLBACK(int) shclSvcTransferIfaceListOpen(PSHCLPROVIDERCTX pCtx,
     195                                               PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList)
    196196{
    197197    LogFlowFuncEnter();
    … …  
    202202    int rc;
    203203
    204     PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_OPEN,
    205                                                      VBOX_SHCL_CPARMS_LIST_OPEN);
     204    PSHCLCLIENTMSG pMsg = shclSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_OPEN,
     205                                          VBOX_SHCL_CPARMS_LIST_OPEN);
    206206    if (pMsg)
    207207    {
    … …  
    209209
    210210        pMsg->Ctx.uContextID = VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,  pCtx->pTransfer->State.uID,
    211                                                                       uEvent);
    212 
    213         rc = sharedClipboardSvcTransferSetListOpen(pMsg->cParms, pMsg->paParms, &pMsg->Ctx, pOpenParms);
    214         if (RT_SUCCESS(rc))
    215         {
    216             rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
     211                                                        uEvent);
     212
     213        rc = shclSvcTransferSetListOpen(pMsg->cParms, pMsg->paParms, &pMsg->Ctx, pOpenParms);
     214        if (RT_SUCCESS(rc))
     215        {
     216            rc = shclSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    217217            if (RT_SUCCESS(rc))
    218218            {
    … …  
    220220                AssertRC(rc2);
    221221
    222                 rc = sharedClipboardSvcClientWakeup(pClient);
     222                rc = shclSvcClientWakeup(pClient);
    223223                if (RT_SUCCESS(rc))
    224224                {
    … …  
    251251}
    252252
    253 DECLCALLBACK(int) sharedClipboardSvcTransferIfaceListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList)
     253DECLCALLBACK(int) shclSvcTransferIfaceListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList)
    254254{
    255255    LogFlowFuncEnter();
    … …  
    260260    int rc;
    261261
    262     PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_CLOSE,
    263                                                      VBOX_SHCL_CPARMS_LIST_CLOSE);
     262    PSHCLCLIENTMSG pMsg = shclSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_CLOSE,
     263                                          VBOX_SHCL_CPARMS_LIST_CLOSE);
    264264    if (pMsg)
    265265    {
    … …  
    267267
    268268        pMsg->Ctx.uContextID = VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID, pCtx->pTransfer->State.uID,
    269                                                                     uEvent);
    270 
    271         rc = sharedClipboardSvcTransferSetListClose(pMsg->cParms, pMsg->paParms, &pMsg->Ctx, hList);
    272         if (RT_SUCCESS(rc))
    273         {
    274             rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
     269                                                        uEvent);
     270
     271        rc = shclSvcTransferSetListClose(pMsg->cParms, pMsg->paParms, &pMsg->Ctx, hList);
     272        if (RT_SUCCESS(rc))
     273        {
     274            rc = shclSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    275275            if (RT_SUCCESS(rc))
    276276            {
    … …  
    278278                AssertRC(rc2);
    279279
    280                 rc = sharedClipboardSvcClientWakeup(pClient);
     280                rc = shclSvcClientWakeup(pClient);
    281281                if (RT_SUCCESS(rc))
    282282                {
    … …  
    298298}
    299299
    300 DECLCALLBACK(int) sharedClipboardSvcTransferIfaceListHdrRead(PSHCLPROVIDERCTX pCtx,
    301                                                              SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr)
     300DECLCALLBACK(int) shclSvcTransferIfaceListHdrRead(PSHCLPROVIDERCTX pCtx,
     301                                                  SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr)
    302302{
    303303    LogFlowFuncEnter();
    … …  
    308308    int rc;
    309309
    310     PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_HDR_READ,
    311                                                      VBOX_SHCL_CPARMS_LIST_HDR_READ_REQ);
     310    PSHCLCLIENTMSG pMsg = shclSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_HDR_READ,
     311                                          VBOX_SHCL_CPARMS_LIST_HDR_READ_REQ);
    312312    if (pMsg)
    313313    {
    … …  
    319319        HGCMSvcSetU32(&pMsg->paParms[2], 0 /* fFlags */);
    320320
    321         rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
     321        rc = shclSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    322322        if (RT_SUCCESS(rc))
    323323        {
    … …  
    325325            AssertRC(rc2);
    326326
    327             rc = sharedClipboardSvcClientWakeup(pClient);
     327            rc = shclSvcClientWakeup(pClient);
    328328            if (RT_SUCCESS(rc))
    329329            {
    330330                PSHCLEVENTPAYLOAD pPayload;
    331331                rc = SharedClipboardEventWait(&pCtx->pTransfer->Events, uEvent,
    332                                                          pCtx->pTransfer->uTimeoutMs, &pPayload);
     332                                             pCtx->pTransfer->uTimeoutMs, &pPayload);
    333333                if (RT_SUCCESS(rc))
    334334                {
    … …  
    349349}
    350350
    351 DECLCALLBACK(int) sharedClipboardSvcTransferIfaceListHdrWrite(PSHCLPROVIDERCTX pCtx,
    352                                                               SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr)
     351DECLCALLBACK(int) shclSvcTransferIfaceListHdrWrite(PSHCLPROVIDERCTX pCtx,
     352                                                   SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr)
    353353{
    354354    RT_NOREF(pCtx, hList, pListHdr);
    … …  
    359359}
    360360
    361 DECLCALLBACK(int) sharedClipboardSvcTransferIfaceListEntryRead(PSHCLPROVIDERCTX pCtx,
    362                                                                SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry)
     361DECLCALLBACK(int) shclSvcTransferIfaceListEntryRead(PSHCLPROVIDERCTX pCtx,
     362                                                    SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry)
    363363{
    364364    LogFlowFuncEnter();
    … …  
    369369    int rc;
    370370
    371     PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_ENTRY_READ,
    372                                                      VBOX_SHCL_CPARMS_LIST_ENTRY_READ);
     371    PSHCLCLIENTMSG pMsg = shclSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_ENTRY_READ,
     372                                          VBOX_SHCL_CPARMS_LIST_ENTRY_READ);
    373373    if (pMsg)
    374374    {
    … …  
    376376
    377377        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
    378                                                                               pCtx->pTransfer->State.uID, uEvent));
     378                                                                  pCtx->pTransfer->State.uID, uEvent));
    379379        HGCMSvcSetU64(&pMsg->paParms[1], hList);
    380380        HGCMSvcSetU32(&pMsg->paParms[2], 0 /* fInfo */);
    381381
    382         rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
     382        rc = shclSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    383383        if (RT_SUCCESS(rc))
    384384        {
    … …  
    386386            AssertRC(rc2);
    387387
    388             rc = sharedClipboardSvcClientWakeup(pClient);
     388            rc = shclSvcClientWakeup(pClient);
    389389            if (RT_SUCCESS(rc))
    390390            {
    … …  
    409409}
    410410
    411 DECLCALLBACK(int) sharedClipboardSvcTransferIfaceListEntryWrite(PSHCLPROVIDERCTX pCtx,
    412                                                                 SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry)
     411DECLCALLBACK(int) shclSvcTransferIfaceListEntryWrite(PSHCLPROVIDERCTX pCtx,
     412                                                     SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry)
    413413{
    414414    RT_NOREF(pCtx, hList, pListEntry);
    … …  
    419419}
    420420
    421 int sharedClipboardSvcTransferIfaceObjOpen(PSHCLPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms,
    422                                            PSHCLOBJHANDLE phObj)
     421int shclSvcTransferIfaceObjOpen(PSHCLPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms,
     422                                PSHCLOBJHANDLE phObj)
    423423{
    424424    LogFlowFuncEnter();
    … …  
    429429    int rc;
    430430
    431     PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_OPEN,
    432                                                      VBOX_SHCL_CPARMS_OBJ_OPEN);
     431    PSHCLCLIENTMSG pMsg = shclSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_OPEN,
     432                                          VBOX_SHCL_CPARMS_OBJ_OPEN);
    433433    if (pMsg)
    434434    {
    … …  
    446446        HGCMSvcSetU32(&pMsg->paParms[4], pCreateParms->fCreate);
    447447
    448         rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
     448        rc = shclSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    449449        if (RT_SUCCESS(rc))
    450450        {
    … …  
    452452            AssertRC(rc2);
    453453
    454             rc = sharedClipboardSvcClientWakeup(pClient);
     454            rc = shclSvcClientWakeup(pClient);
    455455            if (RT_SUCCESS(rc))
    456456            {
    … …  
    480480}
    481481
    482 int sharedClipboardSvcTransferIfaceObjClose(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj)
     482int shclSvcTransferIfaceObjClose(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj)
    483483{
    484484    LogFlowFuncEnter();
    … …  
    489489    int rc;
    490490
    491     PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_CLOSE,
    492                                                      VBOX_SHCL_CPARMS_OBJ_CLOSE);
     491    PSHCLCLIENTMSG pMsg = shclSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_CLOSE,
     492                                          VBOX_SHCL_CPARMS_OBJ_CLOSE);
    493493    if (pMsg)
    494494    {
    … …  
    499499        HGCMSvcSetU64(&pMsg->paParms[1], hObj);
    500500
    501         rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
     501        rc = shclSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    502502        if (RT_SUCCESS(rc))
    503503        {
    … …  
    505505            AssertRC(rc2);
    506506
    507             rc = sharedClipboardSvcClientWakeup(pClient);
     507            rc = shclSvcClientWakeup(pClient);
    508508            if (RT_SUCCESS(rc))
    509509            {
    … …  
    533533}
    534534
    535 int sharedClipboardSvcTransferIfaceObjRead(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
    536                                            void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead)
     535int shclSvcTransferIfaceObjRead(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
     536                                void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead)
    537537{
    538538    LogFlowFuncEnter();
    … …  
    543543    int rc;
    544544
    545     PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_READ,
    546                                                      VBOX_SHCL_CPARMS_OBJ_READ_REQ);
     545    PSHCLCLIENTMSG pMsg = shclSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_READ,
     546                                          VBOX_SHCL_CPARMS_OBJ_READ_REQ);
    547547    if (pMsg)
    548548    {
    … …  
    555555        HGCMSvcSetU32(&pMsg->paParms[3], fFlags);
    556556
    557         rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
     557        rc = shclSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    558558        if (RT_SUCCESS(rc))
    559559        {
    … …  
    561561            AssertRC(rc2);
    562562
    563             rc = sharedClipboardSvcClientWakeup(pClient);
     563            rc = shclSvcClientWakeup(pClient);
    564564            if (RT_SUCCESS(rc))
    565565            {
    … …  
    592592}
    593593
    594 int sharedClipboardSvcTransferIfaceObjWrite(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
    595                                             void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten)
     594int shclSvcTransferIfaceObjWrite(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
     595                                 void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten)
    596596{
    597597    LogFlowFuncEnter();
    … …  
    602602    int rc;
    603603
    604     PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_WRITE,
    605                                                      VBOX_SHCL_CPARMS_OBJ_WRITE);
     604    PSHCLCLIENTMSG pMsg = shclSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_WRITE,
     605                                          VBOX_SHCL_CPARMS_OBJ_WRITE);
    606606    if (pMsg)
    607607    {
    … …  
    614614        HGCMSvcSetU64(&pMsg->paParms[3], fFlags);
    615615
    616         rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
     616        rc = shclSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    617617        if (RT_SUCCESS(rc))
    618618        {
    … …  
    620620            AssertRC(rc2);
    621621
    622             rc = sharedClipboardSvcClientWakeup(pClient);
     622            rc = shclSvcClientWakeup(pClient);
    623623            if (RT_SUCCESS(rc))
    624624            {
    … …  
    659659 * @param   pReply              Where to store the reply.
    660660 */
    661 static int sharedClipboardSvcTransferGetReply(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    662                                               PSHCLREPLY pReply)
     661static int shclSvcTransferGetReply(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     662                                   PSHCLREPLY pReply)
    663663{
    664664    int rc;
    … …  
    735735 * @param   pRootLstHdr         Where to store the transfer root list header on success.
    736736 */
    737 static int sharedClipboardSvcTransferGetRootListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    738                                                     PSHCLROOTLISTHDR pRootLstHdr)
     737static int shclSvcTransferGetRootListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     738                                         PSHCLROOTLISTHDR pRootLstHdr)
    739739{
    740740    int rc;
    … …  
    761761 * @param   pListEntry          Where to store the root list entry.
    762762 */
    763 static int sharedClipboardSvcTransferGetRootListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    764                                                       PSHCLROOTLISTENTRY pListEntry)
     763static int shclSvcTransferGetRootListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     764                                           PSHCLROOTLISTENTRY pListEntry)
    765765{
    766766    int rc;
    … …  
    798798 * @param   pOpenParms          Where to store the open parameters of the request.
    799799 */
    800 static int sharedClipboardSvcTransferGetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    801                                                  PSHCLLISTOPENPARMS pOpenParms)
     800static int shclSvcTransferGetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     801                                      PSHCLLISTOPENPARMS pOpenParms)
    802802{
    803803    int rc;
    … …  
    845845 * @param   pOpenParms          List open parameters to set.
    846846 */
    847 static int sharedClipboardSvcTransferSetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    848                                                  PSHCLMSGCTX pMsgCtx, PSHCLLISTOPENPARMS pOpenParms)
     847static int shclSvcTransferSetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     848                                      PSHCLMSGCTX pMsgCtx, PSHCLLISTOPENPARMS pOpenParms)
    849849{
    850850    int rc;
    … …  
    878878 * @param   hList               Handle of list to close.
    879879 */
    880 static int sharedClipboardSvcTransferSetListClose(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    881                                                   PSHCLMSGCTX pMsgCtx, SHCLLISTHANDLE hList)
     880static int shclSvcTransferSetListClose(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     881                                       PSHCLMSGCTX pMsgCtx, SHCLLISTHANDLE hList)
    882882{
    883883    int rc;
    … …  
    906906 * @param   pListHdr            Where to store the list header.
    907907 */
    908 static int sharedClipboardSvcTransferGetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    909                                                 PSHCLLISTHANDLE phList, PSHCLLISTHDR pListHdr)
     908static int shclSvcTransferGetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     909                                     PSHCLLISTHANDLE phList, PSHCLLISTHDR pListHdr)
    910910{
    911911    int rc;
    … …  
    945945 * @param   pListHdr            Pointer to data to set to the HGCM parameters.
    946946 */
    947 static int sharedClipboardSvcTransferSetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    948                                                 PVBOXSHCLMSGCTX pMsgCtx, PSHCLLISTHDR pListHdr)
     947static int shclSvcTransferSetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     948                                     PVBOXSHCLMSGCTX pMsgCtx, PSHCLLISTHDR pListHdr)
    949949{
    950950    int rc;
    … …  
    980980 * @param   pListEntry          Where to store the list entry.
    981981 */
    982 static int sharedClipboardSvcTransferGetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    983                                                   PSHCLLISTHANDLE phList, PSHCLLISTENTRY pListEntry)
     982static int shclSvcTransferGetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     983                                       PSHCLLISTHANDLE phList, PSHCLLISTENTRY pListEntry)
    984984{
    985985    int rc;
    … …  
    10261026 * @param   pListEntry          Pointer to data to set to the HGCM parameters.
    10271027 */
    1028 static int sharedClipboardSvcTransferSetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    1029                                                   PVBOXSHCLMSGCTX pMsgCtx, PSHCLLISTENTRY pListEntry)
     1028static int shclSvcTransferSetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     1029                                       PVBOXSHCLMSGCTX pMsgCtx, PSHCLLISTENTRY pListEntry)
    10301030{
    10311031    int rc;
    … …  
    10581058 * @param   pDataChunk          Where to store the object data chunk data.
    10591059 */
    1060 static int sharedClipboardSvcTransferGetObjDataChunk(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PSHCLOBJDATACHUNK pDataChunk)
     1060static int shclSvcTransferGetObjDataChunk(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PSHCLOBJDATACHUNK pDataChunk)
    10611061{
    10621062    AssertPtrReturn(paParms,    VERR_INVALID_PARAMETER);
    … …  
    10961096 * @param   pRc                 Where to store the received error code.
    10971097 */
    1098 static int sharedClipboardSvcTransferGetError(uint32_t cParms, VBOXHGCMSVCPARM paParms[], int *pRc)
     1098static int shclSvcTransferGetError(uint32_t cParms, VBOXHGCMSVCPARM paParms[], int *pRc)
    10991099{
    11001100    AssertPtrReturn(paParms, VERR_INVALID_PARAMETER);
    … …  
    11231123 * @param   paParms             Array function parameters supplied.
    11241124 */
    1125 static int sharedClipboardSvcTransferHandleReply(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer,
    1126                                                  uint32_t cParms, VBOXHGCMSVCPARM paParms[])
     1125static int shclSvcTransferHandleReply(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer,
     1126                                      uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    11271127{
    11281128    RT_NOREF(pClient);
    … …  
    11341134    if (pReply)
    11351135    {
    1136         rc = sharedClipboardSvcTransferGetReply(cParms, paParms, pReply);
     1136        rc = shclSvcTransferGetReply(cParms, paParms, pReply);
    11371137        if (RT_SUCCESS(rc))
    11381138        {
    … …  
    12081208 * @param   tsArrival           Timestamp of arrival.
    12091209 */
    1210 int sharedClipboardSvcTransferHandler(PSHCLCLIENT pClient,
    1211                                       VBOXHGCMCALLHANDLE callHandle,
    1212                                       uint32_t u32Function,
    1213                                       uint32_t cParms,
    1214                                       VBOXHGCMSVCPARM paParms[],
    1215                                       uint64_t tsArrival)
     1210int shclSvcTransferHandler(PSHCLCLIENT pClient,
     1211                           VBOXHGCMCALLHANDLE callHandle,
     1212                           uint32_t u32Function,
     1213                           uint32_t cParms,
     1214                           VBOXHGCMSVCPARM paParms[],
     1215                           uint64_t tsArrival)
    12161216{
    12171217    RT_NOREF(callHandle, paParms, tsArrival);
    … …  
    12221222#if 0
    12231223    /* Check if we've the right mode set. */
    1224     if (!sharedClipboardSvcTransferMsgIsAllowed(sharedClipboardSvcGetMode(), u32Function))
     1224    if (!shclSvcTransferMsgIsAllowed(shclSvcGetMode(), u32Function))
    12251225    {
    12261226        LogFunc(("Wrong clipboard mode, denying access\n"));
    … …  
    13171317                if (RT_SUCCESS(rc))
    13181318                {
    1319                     rc = sharedClipboardSvcTransferAreaRegister(&pClient->State, pTransfer);
     1319                    rc = shclSvcTransferAreaRegister(&pClient->State, pTransfer);
    13201320                    if (RT_SUCCESS(rc))
    13211321                    {
    … …  
    13251325                        creationCtx.enmSource = pClient->State.enmSource;
    13261326
    1327                         creationCtx.Interface.pfnTransferOpen  = sharedClipboardSvcTransferOpen;
    1328                         creationCtx.Interface.pfnTransferClose = sharedClipboardSvcTransferClose;
    1329                         creationCtx.Interface.pfnListOpen      = sharedClipboardSvcTransferListOpen;
    1330                         creationCtx.Interface.pfnListClose     = sharedClipboardSvcTransferListClose;
    1331                         creationCtx.Interface.pfnObjOpen       = sharedClipboardSvcTransferObjOpen;
    1332                         creationCtx.Interface.pfnObjClose      = sharedClipboardSvcTransferObjClose;
     1327                        creationCtx.Interface.pfnTransferOpen  = shclSvcTransferOpen;
     1328                        creationCtx.Interface.pfnTransferClose = shclSvcTransferClose;
     1329                        creationCtx.Interface.pfnListOpen      = shclSvcTransferListOpen;
     1330                        creationCtx.Interface.pfnListClose     = shclSvcTransferListClose;
     1331                        creationCtx.Interface.pfnObjOpen       = shclSvcTransferObjOpen;
     1332                        creationCtx.Interface.pfnObjClose      = shclSvcTransferObjClose;
    13331333
    13341334                        if (enmDir == SHCLTRANSFERDIR_READ)
    13351335                        {
    1336                             creationCtx.Interface.pfnRootsGet        = sharedClipboardSvcTransferGetRoots;
    1337                             creationCtx.Interface.pfnListHdrRead     = sharedClipboardSvcTransferListHdrRead;
    1338                             creationCtx.Interface.pfnListEntryRead   = sharedClipboardSvcTransferListEntryRead;
    1339                             creationCtx.Interface.pfnObjRead         = sharedClipboardSvcTransferObjRead;
     1336                            creationCtx.Interface.pfnRootsGet        = shclSvcTransferGetRoots;
     1337                            creationCtx.Interface.pfnListHdrRead     = shclSvcTransferListHdrRead;
     1338                            creationCtx.Interface.pfnListEntryRead   = shclSvcTransferListEntryRead;
     1339                            creationCtx.Interface.pfnObjRead         = shclSvcTransferObjRead;
    13401340                        }
    13411341                        else
    … …  
    13661366                    if (RT_SUCCESS(rc))
    13671367                    {
    1368                         rc = SharedClipboardSvcImplTransferCreate(pClient, pTransfer);
     1368                        rc = ShClSvcImplTransferCreate(pClient, pTransfer);
    13691369                        if (RT_SUCCESS(rc))
    1370                             rc = SharedClipboardSvcImplFormatAnnounce(pClient, VBOX_SHCL_FMT_URI_LIST);
     1370                            rc = ShClSvcImplFormatAnnounce(pClient, VBOX_SHCL_FMT_URI_LIST);
    13711371                    }
    13721372
    13731373                    if (RT_FAILURE(rc))
    13741374                    {
    1375                         SharedClipboardSvcImplTransferDestroy(pClient, pTransfer);
     1375                        ShClSvcImplTransferDestroy(pClient, pTransfer);
    13761376                        SharedClipboardTransferDestroy(pTransfer);
    13771377                    }
    … …  
    13901390        case VBOX_SHCL_GUEST_FN_REPLY:
    13911391        {
    1392             rc = sharedClipboardSvcTransferHandleReply(pClient, pTransfer, cParms, paParms);
     1392            rc = shclSvcTransferHandleReply(pClient, pTransfer, cParms, paParms);
    13931393            break;
    13941394        }
    … …  
    14021402        {
    14031403            SHCLROOTLISTHDR lstHdr;
    1404             rc = sharedClipboardSvcTransferGetRootListHdr(cParms, paParms, &lstHdr);
     1404            rc = shclSvcTransferGetRootListHdr(cParms, paParms, &lstHdr);
    14051405            if (RT_SUCCESS(rc))
    14061406            {
    … …  
    14461446        {
    14471447            SHCLROOTLISTENTRY lstEntry;
    1448             rc = sharedClipboardSvcTransferGetRootListEntry(cParms, paParms, &lstEntry);
     1448            rc = shclSvcTransferGetRootListEntry(cParms, paParms, &lstEntry);
    14491449            if (RT_SUCCESS(rc))
    14501450            {
    … …  
    14691469        {
    14701470            SHCLLISTOPENPARMS listOpenParms;
    1471             rc = sharedClipboardSvcTransferGetListOpen(cParms, paParms, &listOpenParms);
     1471            rc = shclSvcTransferGetListOpen(cParms, paParms, &listOpenParms);
    14721472            if (RT_SUCCESS(rc))
    14731473            {
    … …  
    15091509                rc = SharedClipboardTransferListGetHeader(pTransfer, hList, &hdrList);
    15101510                /*if (RT_SUCCESS(rc))
    1511                     rc = sharedClipboardSvcTransferSetListHdr(cParms, paParms, &hdrList);*/
     1511                    rc = shclSvcTransferSetListHdr(cParms, paParms, &hdrList);*/
    15121512            }
    15131513            break;
    … …  
    15211521            {
    15221522                SHCLLISTHANDLE hList;
    1523                 rc = sharedClipboardSvcTransferGetListHdr(cParms, paParms, &hList, &hdrList);
     1523                rc = shclSvcTransferGetListHdr(cParms, paParms, &hList, &hdrList);
    15241524                if (RT_SUCCESS(rc))
    15251525                {
    … …  
    15641564            {
    15651565                SHCLLISTHANDLE hList;
    1566                 rc = sharedClipboardSvcTransferGetListEntry(cParms, paParms, &hList, &entryList);
     1566                rc = shclSvcTransferGetListEntry(cParms, paParms, &hList, &entryList);
    15671567                if (RT_SUCCESS(rc))
    15681568                {
    … …  
    16051605        {
    16061606            SHCLOBJDATACHUNK dataChunk;
    1607             rc = sharedClipboardSvcTransferGetObjDataChunk(cParms, paParms, &dataChunk);
     1607            rc = shclSvcTransferGetObjDataChunk(cParms, paParms, &dataChunk);
    16081608            if (RT_SUCCESS(rc))
    16091609            {
    … …  
    18051805        {
    18061806            int rcGuest;
    1807             rc = sharedClipboardSvcTransferGetError(cParms,paParms, &rcGuest);
     1807            rc = shclSvcTransferGetError(cParms,paParms, &rcGuest);
    18081808            if (RT_SUCCESS(rc))
    18091809                LogRel(("Shared Clipboard: Transfer error: %Rrc\n", rcGuest));
    … …  
    18211821
    18221822/**
    1823  * transfer host handler for the Shared Clipboard host service.
     1823 * Transfer host handler for the Shared Clipboard host service.
    18241824 *
    18251825 * @returns VBox status code.
    … …  
    18281828 * @param   paParms             Array function parameters  supplied.
    18291829 */
    1830 int sharedClipboardSvcTransferHostHandler(uint32_t u32Function,
    1831                                           uint32_t cParms,
    1832                                           VBOXHGCMSVCPARM paParms[])
     1830int shclSvcTransferHostHandler(uint32_t u32Function,
     1831                               uint32_t cParms,
     1832                               VBOXHGCMSVCPARM paParms[])
    18331833{
    18341834    RT_NOREF(cParms, paParms);
    … …  
    18601860 * @param   pTransfer           Shared Clipboard transfer to register a clipboard area for.
    18611861 */
    1862 int sharedClipboardSvcTransferAreaRegister(PSHCLCLIENTSTATE pClientState, PSHCLTRANSFER pTransfer)
     1862int shclSvcTransferAreaRegister(PSHCLCLIENTSTATE pClientState, PSHCLTRANSFER pTransfer)
    18631863{
    18641864    RT_NOREF(pClientState);
    … …  
    19091909 * @param   pTransfer           Shared Clipboard transfer to unregister a clipboard area from.
    19101910 */
    1911 int sharedClipboardSvcTransferAreaUnregister(PSHCLCLIENTSTATE pClientState, PSHCLTRANSFER pTransfer)
     1911int shclSvcTransferAreaUnregister(PSHCLCLIENTSTATE pClientState, PSHCLTRANSFER pTransfer)
    19121912{
    19131913    RT_NOREF(pClientState);
    … …  
    19571957 * @param   uID                 ID of clipboard area to to attach to. Specify 0 to attach to the most recent one.
    19581958 */
    1959 int sharedClipboardSvcTransferAreaAttach(PSHCLCLIENTSTATE pClientState, PSHCLTRANSFER pTransfer,
    1960                                          SHCLAREAID uID)
     1959int shclSvcTransferAreaAttach(PSHCLCLIENTSTATE pClientState, PSHCLTRANSFER pTransfer,
     1960                              SHCLAREAID uID)
    19611961{
    19621962    RT_NOREF(pClientState);
    … …  
    20052005 * @param   pTransfer           Shared Clipboard transfer to detach a clipboard area from.
    20062006 */
    2007 int sharedClipboardSvcTransferAreaDetach(PSHCLCLIENTSTATE pClientState, PSHCLTRANSFER pTransfer)
     2007int shclSvcTransferAreaDetach(PSHCLCLIENTSTATE pClientState, PSHCLTRANSFER pTransfer)
    20082008{
    20092009    RT_NOREF(pClientState);
    … …  
    20472047 * @param   puEvent             Where to store the created wait event. Optional.
    20482048 */
    2049 int sharedClipboardSvcTransferSendStatus(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer, SHCLTRANSFERSTATUS uStatus,
    2050                                          int rcTransfer, PSHCLEVENTID puEvent)
     2049int shclSvcTransferSendStatus(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer, SHCLTRANSFERSTATUS uStatus,
     2050                              int rcTransfer, PSHCLEVENTID puEvent)
    20512051{
    20522052    AssertPtrReturn(pClient,   VERR_INVALID_POINTER);
    … …  
    20542054    /* puEvent is optional. */
    20552055
    2056     PSHCLCLIENTMSG pMsgReadData = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_STATUS,
    2057                                                              VBOX_SHCL_CPARMS_TRANSFER_STATUS);
     2056    PSHCLCLIENTMSG pMsgReadData = shclSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_STATUS,
     2057                                                  VBOX_SHCL_CPARMS_TRANSFER_STATUS);
    20582058    if (!pMsgReadData)
    20592059        return VERR_NO_MEMORY;
    … …  
    20682068    HGCMSvcSetU32(&pMsgReadData->paParms[4], 0 /* fFlags, unused */);
    20692069
    2070     int rc = sharedClipboardSvcMsgAdd(pClient, pMsgReadData, true /* fAppend */);
     2070    int rc = shclSvcMsgAdd(pClient, pMsgReadData, true /* fAppend */);
    20712071    if (RT_SUCCESS(rc))
    20722072    {
    … …  
    20742074        if (RT_SUCCESS(rc))
    20752075        {
    2076             rc = sharedClipboardSvcClientWakeup(pClient);
     2076            rc = shclSvcClientWakeup(pClient);
    20772077            if (RT_SUCCESS(rc))
    20782078            {
    … …  
    21012101 * @param   ppTransfer          Where to return the created transfer on success. Optional.
    21022102 */
    2103 int sharedClipboardSvcTransferStart(PSHCLCLIENT pClient,
    2104                                     SHCLTRANSFERDIR enmDir, SHCLSOURCE enmSource,
    2105                                     PSHCLTRANSFER *ppTransfer)
     2103int shclSvcTransferStart(PSHCLCLIENT pClient,
     2104                         SHCLTRANSFERDIR enmDir, SHCLSOURCE enmSource,
     2105                         PSHCLTRANSFER *ppTransfer)
    21062106{
    21072107    AssertPtrReturn(pClient, VERR_INVALID_POINTER);
    … …  
    21272127            if (enmDir == SHCLTRANSFERDIR_READ)
    21282128            {
    2129                 rc = sharedClipboardSvcTransferAreaRegister(&pClient->State, pTransfer);
     2129                rc = shclSvcTransferAreaRegister(&pClient->State, pTransfer);
    21302130                if (RT_SUCCESS(rc))
    21312131                {
    2132                     creationCtx.Interface.pfnTransferOpen  = sharedClipboardSvcTransferIfaceOpen;
    2133                     creationCtx.Interface.pfnTransferClose = sharedClipboardSvcTransferIfaceClose;
    2134 
    2135                     creationCtx.Interface.pfnRootsGet      = sharedClipboardSvcTransferIfaceGetRoots;
    2136 
    2137                     creationCtx.Interface.pfnListOpen      = sharedClipboardSvcTransferIfaceListOpen;
    2138                     creationCtx.Interface.pfnListClose     = sharedClipboardSvcTransferIfaceListClose;
    2139                     creationCtx.Interface.pfnListHdrRead   = sharedClipboardSvcTransferIfaceListHdrRead;
    2140                     creationCtx.Interface.pfnListEntryRead = sharedClipboardSvcTransferIfaceListEntryRead;
    2141 
    2142                     creationCtx.Interface.pfnObjOpen       = sharedClipboardSvcTransferIfaceObjOpen;
    2143                     creationCtx.Interface.pfnObjClose      = sharedClipboardSvcTransferIfaceObjClose;
    2144                     creationCtx.Interface.pfnObjRead       = sharedClipboardSvcTransferIfaceObjRead;
     2132                    creationCtx.Interface.pfnTransferOpen  = shclSvcTransferIfaceOpen;
     2133                    creationCtx.Interface.pfnTransferClose = shclSvcTransferIfaceClose;
     2134
     2135                    creationCtx.Interface.pfnRootsGet      = shclSvcTransferIfaceGetRoots;
     2136
     2137                    creationCtx.Interface.pfnListOpen      = shclSvcTransferIfaceListOpen;
     2138                    creationCtx.Interface.pfnListClose     = shclSvcTransferIfaceListClose;
     2139                    creationCtx.Interface.pfnListHdrRead   = shclSvcTransferIfaceListHdrRead;
     2140                    creationCtx.Interface.pfnListEntryRead = shclSvcTransferIfaceListEntryRead;
     2141
     2142                    creationCtx.Interface.pfnObjOpen       = shclSvcTransferIfaceObjOpen;
     2143                    creationCtx.Interface.pfnObjClose      = shclSvcTransferIfaceObjClose;
     2144                    creationCtx.Interface.pfnObjRead       = shclSvcTransferIfaceObjRead;
    21452145                }
    21462146            }
    21472147            else if (enmDir == SHCLTRANSFERDIR_WRITE)
    21482148            {
    2149                 creationCtx.Interface.pfnListHdrWrite   = sharedClipboardSvcTransferIfaceListHdrWrite;
    2150                 creationCtx.Interface.pfnListEntryWrite = sharedClipboardSvcTransferIfaceListEntryWrite;
    2151                 creationCtx.Interface.pfnObjWrite       = sharedClipboardSvcTransferIfaceObjWrite;
     2149                creationCtx.Interface.pfnListHdrWrite   = shclSvcTransferIfaceListHdrWrite;
     2150                creationCtx.Interface.pfnListEntryWrite = shclSvcTransferIfaceListEntryWrite;
     2151                creationCtx.Interface.pfnObjWrite       = shclSvcTransferIfaceObjWrite;
    21522152            }
    21532153            else
    … …  
    21622162            if (RT_SUCCESS(rc))
    21632163            {
    2164                 rc = SharedClipboardSvcImplTransferCreate(pClient, pTransfer);
     2164                rc = ShClSvcImplTransferCreate(pClient, pTransfer);
    21652165                if (RT_SUCCESS(rc))
    21662166                {
    … …  
    21722172                        {
    21732173                            SHCLEVENTID uEvent;
    2174                             rc = sharedClipboardSvcTransferSendStatus(pClient, pTransfer,
    2175                                                                       SHCLTRANSFERSTATUS_INITIALIZED, VINF_SUCCESS,
    2176                                                                       &uEvent);
     2174                            rc = shclSvcTransferSendStatus(pClient, pTransfer,
     2175                                                           SHCLTRANSFERSTATUS_INITIALIZED, VINF_SUCCESS,
     2176                                                           &uEvent);
    21772177                            if (RT_SUCCESS(rc))
    21782178                            {
    … …  
    22412241 * @param   pTransfer           Transfer to stop.
    22422242 */
    2243 int sharedClipboardSvcTransferStop(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer)
     2243int shclSvcTransferStop(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer)
    22442244{
    22452245    int rc = SharedClipboardTransferClose(pTransfer);
    … …  
    22472247    {
    22482248        SHCLEVENTID uEvent;
    2249         rc = sharedClipboardSvcTransferSendStatus(pClient, pTransfer,
    2250                                                   SHCLTRANSFERSTATUS_STOPPED, VINF_SUCCESS,
    2251                                                   &uEvent);
     2249        rc = shclSvcTransferSendStatus(pClient, pTransfer,
     2250                                       SHCLTRANSFERSTATUS_STOPPED, VINF_SUCCESS,
     2251                                       &uEvent);
    22522252        if (RT_SUCCESS(rc))
    22532253        {

  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-utils.cpp

    r80858 r80995  
    107107            LogFlowFunc(("VBOX_SHCL_HOST_MSG_TRANSFER_TRANSFER_START\n"));
    108108
    109             if (   sharedClipboardSvcGetMode() != VBOX_SHCL_MODE_HOST_TO_GUEST
    110                 && sharedClipboardSvcGetMode() != VBOX_SHCL_MODE_BIDIRECTIONAL)
     109            if (   shclSvcGetMode() != VBOX_SHCL_MODE_HOST_TO_GUEST
     110                && shclSvcGetMode() != VBOX_SHCL_MODE_BIDIRECTIONAL)
    111111            {
    112112                LogFlowFunc(("Wrong clipboard mode, skipping\n"));
    … …  
    130130}
    131131
    132 bool sharedClipboardSvcTransferReturnMsg(PSHCLCLIENT pClient, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
     132bool shclSvcTransferReturnMsg(PSHCLCLIENT pClient, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    133133{
    134134    RT_NOREF(pClient, cParms, paParms);

  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-win.cpp

    r80990 r80995  
    179179
    180180    SHCLEVENTID uEvent = 0;
    181     int rc = sharedClipboardSvcDataReadRequest(pCtx->pClient, &dataReq, &uEvent);
     181    int rc = shclSvcDataReadRequest(pCtx->pClient, &dataReq, &uEvent);
    182182    if (RT_SUCCESS(rc))
    183183    {
    … …  
    231231                    rc = vboxClipboardSvcWinSyncInternal(pCtx);
    232232                    if (RT_SUCCESS(rc))
    233                         rc = sharedClipboardSvcSetSource(pCtx->pClient, SHCLSOURCE_LOCAL);
     233                        rc = shclSvcSetSource(pCtx->pClient, SHCLSOURCE_LOCAL);
    234234                }
    235235                else
    … …  
    273273                    rc = vboxClipboardSvcWinSyncInternal(pCtx);
    274274                    if (RT_SUCCESS(rc))
    275                         sharedClipboardSvcSetSource(pCtx->pClient, SHCLSOURCE_LOCAL);
     275                        shclSvcSetSource(pCtx->pClient, SHCLSOURCE_LOCAL);
    276276                }
    277277                else
    … …  
    357357            {
    358358                PSHCLTRANSFER pTransfer;
    359                 int rc = sharedClipboardSvcTransferStart(pCtx->pClient,
    360                                                          SHCLTRANSFERDIR_READ, SHCLSOURCE_REMOTE,
    361                                                          &pTransfer);
     359                int rc = shclSvcTransferStart(pCtx->pClient,
     360                                              SHCLTRANSFERDIR_READ, SHCLSOURCE_REMOTE,
     361                                              &pTransfer);
    362362                if (RT_SUCCESS(rc))
    363363                {
    … …  
    591591            && Formats.uFormats != VBOX_SHCL_FMT_NONE)
    592592        {
    593             rc = sharedClipboardSvcFormatsReport(pCtx->pClient, &Formats);
     593            rc = shclSvcFormatsReport(pCtx->pClient, &Formats);
    594594        }
    595595    }
    … …  
    605605 */
    606606
    607 int SharedClipboardSvcImplInit(void)
     607int ShClSvcImplInit(void)
    608608{
    609609#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    … …  
    621621}
    622622
    623 void SharedClipboardSvcImplDestroy(void)
     623void ShClSvcImplDestroy(void)
    624624{
    625625#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    … …  
    629629}
    630630
    631 int SharedClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless)
     631int ShClSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless)
    632632{
    633633    RT_NOREF(fHeadless);
    … …  
    656656
    657657        /* Sync the host clipboard content with the client. */
    658         rc = SharedClipboardSvcImplSync(pClient);
     658        rc = ShClSvcImplSync(pClient);
    659659    }
    660660    else
    … …  
    665665}
    666666
    667 int SharedClipboardSvcImplSync(PSHCLCLIENT pClient)
     667int ShClSvcImplSync(PSHCLCLIENT pClient)
    668668{
    669669    /* Sync the host clipboard content with the client. */
    … …  
    671671}
    672672
    673 int SharedClipboardSvcImplDisconnect(PSHCLCLIENT pClient)
     673int ShClSvcImplDisconnect(PSHCLCLIENT pClient)
    674674{
    675675    AssertPtrReturn(pClient, VERR_INVALID_POINTER);
    … …  
    712712}
    713713
    714 int SharedClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
    715                                          PSHCLFORMATDATA pFormats)
     714int ShClSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
     715                              PSHCLFORMATDATA pFormats)
    716716{
    717717    AssertPtrReturn(pClient, VERR_INVALID_POINTER);
    … …  
    737737}
    738738
    739 int SharedClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
    740                                    PSHCLDATABLOCK pData, uint32_t *pcbActual)
     739int ShClSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
     740                        PSHCLDATABLOCK pData, uint32_t *pcbActual)
    741741{
    742742    AssertPtrReturn(pClient,             VERR_INVALID_POINTER);
    … …  
    848848}
    849849
    850 int SharedClipboardSvcImplWriteData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
    851                                     PSHCLDATABLOCK pData)
     850int ShClSvcImplWriteData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
     851                         PSHCLDATABLOCK pData)
    852852{
    853853    LogFlowFuncEnter();
    854854
    855     int rc = sharedClipboardSvcDataReadSignal(pClient, pCmdCtx, pData);
     855    int rc = shclSvcDataReadSignal(pClient, pCmdCtx, pData);
    856856
    857857    LogFlowFuncLeaveRC(rc);
    … …  
    860860
    861861#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    862 int SharedClipboardSvcImplTransferCreate(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer)
     862int ShClSvcImplTransferCreate(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer)
    863863{
    864864    RT_NOREF(pClient, pTransfer);
    … …  
    869869}
    870870
    871 int SharedClipboardSvcImplTransferDestroy(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer)
     871int ShClSvcImplTransferDestroy(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer)
    872872{
    873873    LogFlowFuncEnter();

  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11.cpp

    r80990 r80995  
    7474    formatData.uFormats = u32Formats;
    7575
    76     int rc2 = sharedClipboardSvcFormatsReport(pCtx->pClient, &formatData);
     76    int rc2 = shclSvcFormatsReport(pCtx->pClient, &formatData);
    7777    AssertRC(rc2);
    7878}
    … …  
    8282 * @note  Host glue code
    8383 */
    84 int SharedClipboardSvcImplInit(void)
     84int ShClSvcImplInit(void)
    8585{
    8686    LogFlowFuncEnter();
    … …  
    9292 * @note  host glue code
    9393 */
    94 void SharedClipboardSvcImplDestroy(void)
     94void ShClSvcImplDestroy(void)
    9595{
    9696    LogFlowFuncEnter();
    … …  
    102102 *        the clipboard and leave ownership to X11.
    103103 */
    104 int SharedClipboardSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless)
     104int ShClSvcImplConnect(PSHCLCLIENT pClient, bool fHeadless)
    105105{
    106106    int rc = VINF_SUCCESS;
    … …  
    144144 * @note  Host glue code
    145145 */
    146 int SharedClipboardSvcImplSync(PSHCLCLIENT pClient)
     146int ShClSvcImplSync(PSHCLCLIENT pClient)
    147147{
    148148    LogFlowFuncEnter();
    … …  
    156156    formatData.uFormats = VBOX_SHCL_FMT_NONE;
    157157
    158     return sharedClipboardSvcFormatsReport(pClient, &formatData);
     158    return shclSvcFormatsReport(pClient, &formatData);
    159159}
    160160
    … …  
    163163 * @note  Host glue code
    164164 */
    165 int SharedClipboardSvcImplDisconnect(PSHCLCLIENT pClient)
     165int ShClSvcImplDisconnect(PSHCLCLIENT pClient)
    166166{
    167167    LogFlowFuncEnter();
    … …  
    176176    /* If there is a currently pending request, release it immediately. */
    177177    SHCLDATABLOCK dataBlock = { 0, NULL, 0 };
    178     SharedClipboardSvcImplWriteData(pClient, NULL, &dataBlock);
     178    ShClSvcImplWriteData(pClient, NULL, &dataBlock);
    179179
    180180    int rc = ClipStopX11(pCtx->pBackend);
    … …  
    201201 * @param pFormats              Clipboard formats the guest is offering.
    202202 */
    203 int SharedClipboardSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
    204                                          PSHCLFORMATDATA pFormats)
     203int ShClSvcImplFormatAnnounce(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
     204                              PSHCLFORMATDATA pFormats)
    205205{
    206206    RT_NOREF(pCmdCtx);
    … …  
    247247 *
    248248 */
    249 int SharedClipboardSvcImplReadData(PSHCLCLIENT pClient,
    250                                    PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData, uint32_t *pcbActual)
     249int ShClSvcImplReadData(PSHCLCLIENT pClient,
     250                        PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData, uint32_t *pcbActual)
    251251{
    252252    RT_NOREF(pCmdCtx);
    … …  
    301301 * @param  pData                Data block to write to clipboard.
    302302 */
    303 int SharedClipboardSvcImplWriteData(PSHCLCLIENT pClient,
    304                                     PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData)
     303int ShClSvcImplWriteData(PSHCLCLIENT pClient,
     304                         PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData)
    305305{
    306306    LogFlowFunc(("pClient=%p, pv=%p, cb=%RU32, uFormat=%02X\n",
    307307                 pClient, pData->pvData, pData->cbData, pData->uFormat));
    308308
    309     int rc = sharedClipboardSvcDataReadSignal(pClient, pCmdCtx, pData);
     309    int rc = shclSvcDataReadSignal(pClient, pCmdCtx, pData);
    310310
    311311    LogFlowFuncLeaveRC(rc);
    … …  
    370370
    371371    SHCLEVENTID uEvent;
    372     int rc = sharedClipboardSvcDataReadRequest(pCtx->pClient, &dataReq, &uEvent);
     372    int rc = shclSvcDataReadRequest(pCtx->pClient, &dataReq, &uEvent);
    373373    if (RT_SUCCESS(rc))
    374374    {
    … …  
    392392
    393393#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    394 int SharedClipboardSvcImplTransferCreate(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer)
     394int ShClSvcImplTransferCreate(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer)
    395395{
    396396    RT_NOREF(pClient, pTransfer);
    … …  
    398398}
    399399
    400 int SharedClipboardSvcImplTransferDestroy(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer)
     400int ShClSvcImplTransferDestroy(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer)
    401401{
    402402    RT_NOREF(pClient, pTransfer);

  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp

    r80990 r80995  
    224224*   Prototypes                                                                                                                   *
    225225*********************************************************************************************************************************/
    226 static int sharedClipboardSvcClientStateInit(PSHCLCLIENTSTATE pClientState, uint32_t uClientID);
    227 static int sharedClipboardSvcClientStateDestroy(PSHCLCLIENTSTATE pClientState);
    228 static void sharedClipboardSvcClientStateReset(PSHCLCLIENTSTATE pClientState);
     226static int shclSvcClientStateInit(PSHCLCLIENTSTATE pClientState, uint32_t uClientID);
     227static int shclSvcClientStateDestroy(PSHCLCLIENTSTATE pClientState);
     228static void shclSvcClientStateReset(PSHCLCLIENTSTATE pClientState);
    229229
    230230
    … …  
    251251
    252252
    253 uint32_t sharedClipboardSvcGetMode(void)
     253uint32_t shclSvcGetMode(void)
    254254{
    255255    return g_uMode;
    … …  
    260260uint32_t TestClipSvcGetMode(void)
    261261{
    262     return sharedClipboardSvcGetMode();
     262    return shclSvcGetMode();
    263263}
    264264#endif
    … …  
    270270}
    271271
    272 static int sharedClipboardSvcModeSet(uint32_t uMode)
     272static int shclSvcModeSet(uint32_t uMode)
    273273{
    274274    int rc = VERR_NOT_SUPPORTED;
    … …  
    317317 * @param   pClient             Pointer to the client data structure to reset message queue for.
    318318 */
    319 void sharedClipboardSvcMsgQueueReset(PSHCLCLIENT pClient)
     319void shclSvcMsgQueueReset(PSHCLCLIENT pClient)
    320320{
    321321    LogFlowFuncEnter();
    … …  
    335335 * @param   cParms              Number of HGCM parameters to allocate.
    336336 */
    337 PSHCLCLIENTMSG sharedClipboardSvcMsgAlloc(uint32_t uMsg, uint32_t cParms)
     337PSHCLCLIENTMSG shclSvcMsgAlloc(uint32_t uMsg, uint32_t cParms)
    338338{
    339339    PSHCLCLIENTMSG pMsg = (PSHCLCLIENTMSG)RTMemAlloc(sizeof(SHCLCLIENTMSG));
    … …  
    360360 *                              The pointer will be invalid after calling this function.
    361361 */
    362 void sharedClipboardSvcMsgFree(PSHCLCLIENTMSG pMsg)
     362void shclSvcMsgFree(PSHCLCLIENTMSG pMsg)
    363363{
    364364    if (!pMsg)
    … …  
    381381 * @remarks ASSUMES the parameters has been cleared by clientMsgPeek.
    382382 */
    383 void sharedClipboardSvcMsgSetPeekReturn(PSHCLCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms)
     383void shclSvcMsgSetPeekReturn(PSHCLCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms)
    384384{
    385385    Assert(cDstParms >= 2);
    … …  
    411411 * @param   cDstParms   The number of peek parameters (at least two).
    412412 */
    413 int sharedClipboardSvcMsgSetGetHostMsgOldReturn(PSHCLCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms)
     413int shclSvcMsgSetGetHostMsgOldReturn(PSHCLCLIENTMSG pMsg, PVBOXHGCMSVCPARM paDstParms, uint32_t cDstParms)
    414414{
    415415    AssertPtrReturn(pMsg,           VERR_INVALID_POINTER);
    … …  
    468468 * @param   fAppend             Whether to append or prepend the message to the queue.
    469469 */
    470 int sharedClipboardSvcMsgAdd(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg, bool fAppend)
     470int shclSvcMsgAdd(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg, bool fAppend)
    471471{
    472472    AssertPtrReturn(pMsg, VERR_INVALID_POINTER);
    … …  
    501501 *                      immediately.
    502502 */
    503 int sharedClipboardSvcMsgPeek(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[],
    504                               bool fWait)
     503int shclSvcMsgPeek(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[],
     504                   bool fWait)
    505505{
    506506    /*
    … …  
    548548        if (pFirstMsg)
    549549        {
    550             sharedClipboardSvcMsgSetPeekReturn(pFirstMsg, paParms, cParms);
     550            shclSvcMsgSetPeekReturn(pFirstMsg, paParms, cParms);
    551551            LogFlowFunc(("[Client %RU32] VBOX_SHCL_GUEST_FN_MSG_PEEK_XXX -> VINF_SUCCESS (idMsg=%u (%s), cParms=%u)\n",
    552552                         pClient->State.uClientID, pFirstMsg->uMsg, VBoxShClHostMsgToStr(pFirstMsg->uMsg),
    … …  
    590590 * @param   paParms     Array of parameters.
    591591 */
    592 int sharedClipboardSvcMsgGetOld(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
     592int shclSvcMsgGetOld(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    593593{
    594594    int rc;
    … …  
    614614                         pFirstMsg->cParms));
    615615
    616             rc = sharedClipboardSvcMsgSetGetHostMsgOldReturn(pFirstMsg, paParms, cParms);
     616            rc = shclSvcMsgSetGetHostMsgOldReturn(pFirstMsg, paParms, cParms);
    617617            if (RT_SUCCESS(rc))
    618618            {
    … …  
    622622                {
    623623                    pClient->queueMsg.removeFirst();
    624                     sharedClipboardSvcMsgFree(pFirstMsg);
     624                    shclSvcMsgFree(pFirstMsg);
    625625
    626626                    rc = VINF_HGCM_ASYNC_EXECUTE; /* The caller must not complete it. */
    … …  
    666666 * @param   paParms      Array of parameters.
    667667 */
    668 int sharedClipboardSvcMsgGet(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
     668int shclSvcMsgGet(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE hCall, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    669669{
    670670    /*
    … …  
    756756                {
    757757                    pClient->queueMsg.removeFirst();
    758                     sharedClipboardSvcMsgFree(pFirstMsg);
     758                    shclSvcMsgFree(pFirstMsg);
    759759                }
    760760
    … …  
    781781 * @param   pClient             Client to wake up.
    782782 */
    783 int sharedClipboardSvcClientWakeup(PSHCLCLIENT pClient)
     783int shclSvcClientWakeup(PSHCLCLIENT pClient)
    784784{
    785785    int rc = VINF_NO_CHANGE;
    … …  
    804804                if (pClient->Pending.uType == VBOX_SHCL_GUEST_FN_MSG_PEEK_WAIT)
    805805                {
    806                     sharedClipboardSvcMsgSetPeekReturn(pFirstMsg, pClient->Pending.paParms, pClient->Pending.cParms);
     806                    shclSvcMsgSetPeekReturn(pFirstMsg, pClient->Pending.paParms, pClient->Pending.cParms);
    807807                    fDonePending = true;
    808808                }
    809809                else if (pClient->Pending.uType == VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD) /* Legacy */
    810810                {
    811                     rc = sharedClipboardSvcMsgSetGetHostMsgOldReturn(pFirstMsg, pClient->Pending.paParms, pClient->Pending.cParms);
     811                    rc = shclSvcMsgSetGetHostMsgOldReturn(pFirstMsg, pClient->Pending.paParms, pClient->Pending.cParms);
    812812                    if (RT_SUCCESS(rc))
    813813                    {
    … …  
    815815                         * remove the actual message from our queue right now. */
    816816                        pClient->queueMsg.removeFirst();
    817                         sharedClipboardSvcMsgFree(pFirstMsg);
     817                        shclSvcMsgFree(pFirstMsg);
    818818
    819819                        fDonePending = true;
    … …  
    853853 * @param   puEvent             Event ID for waiting for new data. Optional.
    854854 */
    855 int sharedClipboardSvcDataReadRequest(PSHCLCLIENT pClient, PSHCLDATAREQ pDataReq,
    856                                       PSHCLEVENTID puEvent)
     855int shclSvcDataReadRequest(PSHCLCLIENT pClient, PSHCLDATAREQ pDataReq,
     856                           PSHCLEVENTID puEvent)
    857857{
    858858    AssertPtrReturn(pClient,  VERR_INVALID_POINTER);
    … …  
    862862    int rc;
    863863
    864     PSHCLCLIENTMSG pMsgReadData = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_READ_DATA,
    865                                                              VBOX_SHCL_CPARMS_READ_DATA);
     864    PSHCLCLIENTMSG pMsgReadData = shclSvcMsgAlloc(VBOX_SHCL_HOST_MSG_READ_DATA,
     865                                                  VBOX_SHCL_CPARMS_READ_DATA);
    866866    if (pMsgReadData)
    867867    {
    … …  
    873873        HGCMSvcSetU32(&pMsgReadData->paParms[2], pClient->State.cbChunkSize);
    874874
    875         rc = sharedClipboardSvcMsgAdd(pClient, pMsgReadData, true /* fAppend */);
     875        rc = shclSvcMsgAdd(pClient, pMsgReadData, true /* fAppend */);
    876876        if (RT_SUCCESS(rc))
    877877        {
    … …  
    879879            if (RT_SUCCESS(rc))
    880880            {
    881                 rc = sharedClipboardSvcClientWakeup(pClient);
     881                rc = shclSvcClientWakeup(pClient);
    882882                if (RT_SUCCESS(rc))
    883883                {
    … …  
    897897}
    898898
    899 int sharedClipboardSvcDataReadSignal(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
    900                                      PSHCLDATABLOCK pData)
     899int shclSvcDataReadSignal(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
     900                          PSHCLDATABLOCK pData)
    901901{
    902902    SHCLEVENTID uEvent;
    … …  
    927927}
    928928
    929 int sharedClipboardSvcFormatsReport(PSHCLCLIENT pClient, PSHCLFORMATDATA pFormats)
     929int shclSvcFormatsReport(PSHCLCLIENT pClient, PSHCLFORMATDATA pFormats)
    930930{
    931931    AssertPtrReturn(pClient,  VERR_INVALID_POINTER);
    … …  
    934934    int rc;
    935935
    936     PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHCL_HOST_MSG_FORMATS_REPORT, 3);
     936    PSHCLCLIENTMSG pMsg = shclSvcMsgAlloc(VBOX_SHCL_HOST_MSG_FORMATS_REPORT, 3);
    937937    if (pMsg)
    938938    {
    … …  
    944944        HGCMSvcSetU32(&pMsg->paParms[2], 0 /* fFlags */);
    945945
    946         rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
     946        rc = shclSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    947947        if (RT_SUCCESS(rc))
    948948        {
    … …  
    952952            if (pFormats->uFormats & VBOX_SHCL_FMT_URI_LIST)
    953953            {
    954                 rc = sharedClipboardSvcTransferStart(pClient, SHCLTRANSFERDIR_WRITE, SHCLSOURCE_LOCAL,
    955                                                      NULL /* pTransfer */);
     954                rc = shclSvcTransferStart(pClient, SHCLTRANSFERDIR_WRITE, SHCLSOURCE_LOCAL,
     955                                          NULL /* pTransfer */);
    956956                if (RT_FAILURE(rc))
    957957                    LogRel(("Shared Clipboard: Initializing host write transfer failed with %Rrc\n", rc));
    … …  
    960960            {
    961961#endif
    962                 rc = sharedClipboardSvcClientWakeup(pClient);
     962                rc = shclSvcClientWakeup(pClient);
    963963
    964964#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    … …  
    974974}
    975975
    976 int sharedClipboardSvcGetDataWrite(PSHCLCLIENT pClient, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
     976int shclSvcGetDataWrite(PSHCLCLIENT pClient, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    977977{
    978978    LogFlowFuncEnter();
    979979
    980     if (   sharedClipboardSvcGetMode() != VBOX_SHCL_MODE_GUEST_TO_HOST
    981         && sharedClipboardSvcGetMode() != VBOX_SHCL_MODE_BIDIRECTIONAL)
     980    if (   shclSvcGetMode() != VBOX_SHCL_MODE_GUEST_TO_HOST
     981        && shclSvcGetMode() != VBOX_SHCL_MODE_BIDIRECTIONAL)
    982982    {
    983983        return VERR_NOT_SUPPORTED;
    … …  
    10491049        }
    10501050
    1051         rc = SharedClipboardSvcImplWriteData(pClient, &cmdCtx, &dataBlock);
     1051        rc = ShClSvcImplWriteData(pClient, &cmdCtx, &dataBlock);
    10521052    }
    10531053
    … …  
    10561056}
    10571057
    1058 int sharedClipboardSvcSetSource(PSHCLCLIENT pClient, SHCLSOURCE enmSource)
     1058int shclSvcSetSource(PSHCLCLIENT pClient, SHCLSOURCE enmSource)
    10591059{
    10601060    if (!pClient) /* If no client connected (anymore), bail out. */
    … …  
    10821082    if (RT_SUCCESS(rc))
    10831083    {
    1084         sharedClipboardSvcModeSet(VBOX_SHCL_MODE_OFF);
    1085 
    1086         rc = SharedClipboardSvcImplInit();
     1084        shclSvcModeSet(VBOX_SHCL_MODE_OFF);
     1085
     1086        rc = ShClSvcImplInit();
    10871087
    10881088        /* Clean up on failure, because 'svnUnload' will not be called
    … …  
    11021102    LogFlowFuncEnter();
    11031103
    1104     SharedClipboardSvcImplDestroy();
     1104    ShClSvcImplDestroy();
    11051105
    11061106    RTCritSectDelete(&g_CritSect);
    … …  
    11211121    PSHCLTRANSFER pTransfer = SharedClipboardTransferCtxGetTransfer(&pClient->TransferCtx, 0 /* Index*/);
    11221122    if (pTransfer)
    1123         sharedClipboardSvcTransferAreaDetach(&pClient->State, pTransfer);
     1123        shclSvcTransferAreaDetach(&pClient->State, pTransfer);
    11241124
    11251125    SharedClipboardTransferCtxDestroy(&pClient->TransferCtx);
    11261126#endif
    11271127
    1128     SharedClipboardSvcImplDisconnect(pClient);
    1129 
    1130     sharedClipboardSvcClientStateReset(&pClient->State);
    1131     sharedClipboardSvcClientStateDestroy(&pClient->State);
     1128    ShClSvcImplDisconnect(pClient);
     1129
     1130    shclSvcClientStateReset(&pClient->State);
     1131    shclSvcClientStateDestroy(&pClient->State);
    11321132
    11331133    SharedClipboardEventSourceDestroy(&pClient->Events);
    … …  
    11611161
    11621162        /* Reset the client state. */
    1163         sharedClipboardSvcClientStateReset(&pClient->State);
     1163        shclSvcClientStateReset(&pClient->State);
    11641164
    11651165        /* (Re-)initialize the client state. */
    1166         rc = sharedClipboardSvcClientStateInit(&pClient->State, u32ClientID);
     1166        rc = shclSvcClientStateInit(&pClient->State, u32ClientID);
    11671167        if (RT_SUCCESS(rc))
    11681168        {
    1169             rc = SharedClipboardSvcImplConnect(pClient, VBoxSvcClipboardGetHeadless());
     1169            rc = ShClSvcImplConnect(pClient, VBoxSvcClipboardGetHeadless());
    11701170#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    11711171            if (RT_SUCCESS(rc))
    … …  
    12241224        case VBOX_SHCL_GUEST_FN_GET_HOST_MSG_OLD:
    12251225        {
    1226             rc = sharedClipboardSvcMsgGetOld(pClient, callHandle, cParms, paParms);
     1226            rc = shclSvcMsgGetOld(pClient, callHandle, cParms, paParms);
    12271227            break;
    12281228        }
    … …  
    12421242                rc = VERR_INVALID_PARAMETER;
    12431243            }
    1244             else if (sharedClipboardSvcGetMode() == VBOX_SHCL_MODE_OFF)
     1244            else if (shclSvcGetMode() == VBOX_SHCL_MODE_OFF)
    12451245            {
    12461246                rc = VERR_ACCESS_DENIED;
    … …  
    12671267        case VBOX_SHCL_GUEST_FN_MSG_PEEK_NOWAIT:
    12681268        {
    1269             rc = sharedClipboardSvcMsgPeek(pClient, callHandle, cParms, paParms, false /*fWait*/);
     1269            rc = shclSvcMsgPeek(pClient, callHandle, cParms, paParms, false /*fWait*/);
    12701270            break;
    12711271        }
    … …  
    12731273        case VBOX_SHCL_GUEST_FN_MSG_PEEK_WAIT:
    12741274        {
    1275             rc = sharedClipboardSvcMsgPeek(pClient, callHandle, cParms, paParms, true /*fWait*/);
     1275            rc = shclSvcMsgPeek(pClient, callHandle, cParms, paParms, true /*fWait*/);
    12761276            break;
    12771277        }
    … …  
    12791279        case VBOX_SHCL_GUEST_FN_MSG_GET:
    12801280        {
    1281             rc = sharedClipboardSvcMsgGet(pClient, callHandle, cParms, paParms);
     1281            rc = shclSvcMsgGet(pClient, callHandle, cParms, paParms);
    12821282            break;
    12831283        }
    … …  
    13241324            if (RT_SUCCESS(rc))
    13251325            {
    1326                 if (   sharedClipboardSvcGetMode() != VBOX_SHCL_MODE_GUEST_TO_HOST
    1327                     && sharedClipboardSvcGetMode() != VBOX_SHCL_MODE_BIDIRECTIONAL)
     1326                if (   shclSvcGetMode() != VBOX_SHCL_MODE_GUEST_TO_HOST
     1327                    && shclSvcGetMode() != VBOX_SHCL_MODE_BIDIRECTIONAL)
    13281328                {
    13291329                    rc = VERR_ACCESS_DENIED;
    … …  
    13311331                else if (uFormats != VBOX_SHCL_FMT_NONE) /* Only announce formats if we actually *have* formats to announce! */
    13321332                {
    1333                     rc = sharedClipboardSvcSetSource(pClient, SHCLSOURCE_REMOTE);
     1333                    rc = shclSvcSetSource(pClient, SHCLSOURCE_REMOTE);
    13341334                    if (RT_SUCCESS(rc))
    13351335                    {
    … …  
    13541354                        Assert(formatData.uFormats != VBOX_SHCL_FMT_NONE); /* Sanity. */
    13551355
    1356                         rc = SharedClipboardSvcImplFormatAnnounce(pClient, &cmdCtx, &formatData);
     1356                        rc = ShClSvcImplFormatAnnounce(pClient, &cmdCtx, &formatData);
    13571357                    }
    13581358                }
    … …  
    13771377            else
    13781378            {
    1379                 if (   sharedClipboardSvcGetMode() != VBOX_SHCL_MODE_HOST_TO_GUEST
    1380                     && sharedClipboardSvcGetMode() != VBOX_SHCL_MODE_BIDIRECTIONAL)
     1379                if (   shclSvcGetMode() != VBOX_SHCL_MODE_HOST_TO_GUEST
     1380                    && shclSvcGetMode() != VBOX_SHCL_MODE_BIDIRECTIONAL)
    13811381                {
    13821382                    rc = VERR_ACCESS_DENIED;
    … …  
    14241424                                Assert(formatData.uFormats != VBOX_SHCL_FMT_NONE); /* There better is *any* format here now. */
    14251425
    1426                                 int rc2 = sharedClipboardSvcFormatsReport(pClient, &formatData);
     1426                                int rc2 = shclSvcFormatsReport(pClient, &formatData);
    14271427                                AssertRC(rc2);
    14281428
    … …  
    14561456                            dataBlock.uFormat = uFormat;
    14571457
    1458                             rc = SharedClipboardSvcImplReadData(pClient, &cmdCtx, &dataBlock, &cbActual);
     1458                            rc = ShClSvcImplReadData(pClient, &cmdCtx, &dataBlock, &cbActual);
    14591459                            if (RT_SUCCESS(rc))
    14601460                                HGCMSvcSetU32(&paParms[2], cbActual);
    … …  
    14691469        case VBOX_SHCL_GUEST_FN_DATA_WRITE:
    14701470        {
    1471             rc = sharedClipboardSvcGetDataWrite(pClient, cParms, paParms);
     1471            rc = shclSvcGetDataWrite(pClient, cParms, paParms);
    14721472            break;
    14731473        }
    … …  
    14761476        {
    14771477#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    1478             rc = sharedClipboardSvcTransferHandler(pClient, callHandle, u32Function, cParms, paParms, tsArrival);
     1478            rc = shclSvcTransferHandler(pClient, callHandle, u32Function, cParms, paParms, tsArrival);
    14791479#else
    14801480            rc = VERR_NOT_IMPLEMENTED;
    … …  
    14971497 * @param   uClientID           Client ID (HGCM) to use for this client state.
    14981498 */
    1499 static int sharedClipboardSvcClientStateInit(PSHCLCLIENTSTATE pClientState, uint32_t uClientID)
     1499static int shclSvcClientStateInit(PSHCLCLIENTSTATE pClientState, uint32_t uClientID)
    15001500{
    15011501    LogFlowFuncEnter();
    15021502
    1503     sharedClipboardSvcClientStateReset(pClientState);
     1503    shclSvcClientStateReset(pClientState);
    15041504
    15051505    /* Register the client. */
    … …  
    15151515 * @param   pClientState        Client state to destroy.
    15161516 */
    1517 static int sharedClipboardSvcClientStateDestroy(PSHCLCLIENTSTATE pClientState)
     1517static int shclSvcClientStateDestroy(PSHCLCLIENTSTATE pClientState)
    15181518{
    15191519    RT_NOREF(pClientState);
    … …  
    15291529 * @param   pClientState    Client state to reset.
    15301530 */
    1531 static void sharedClipboardSvcClientStateReset(PSHCLCLIENTSTATE pClientState)
     1531static void shclSvcClientStateReset(PSHCLCLIENTSTATE pClientState)
    15321532{
    15331533    LogFlowFuncEnter();
    … …  
    15701570                rc = HGCMSvcGetU32(&paParms[0], &u32Mode);
    15711571                if (RT_SUCCESS(rc))
    1572                     rc = sharedClipboardSvcModeSet(u32Mode);
     1572                    rc = shclSvcModeSet(u32Mode);
    15731573            }
    15741574
    … …  
    15981598        {
    15991599#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    1600             rc = sharedClipboardSvcTransferHostHandler(u32Function, cParms, paParms);
     1600            rc = shclSvcTransferHostHandler(u32Function, cParms, paParms);
    16011601#else
    16021602            rc = VERR_NOT_IMPLEMENTED;
    … …  
    17911791            }
    17921792
    1793             rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
     1793            rc = shclSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    17941794            AssertRCReturn(rc, rc);
    17951795        }
    … …  
    18021802
    18031803    /* Actual host data are to be reported to guest (SYNC). */
    1804     SharedClipboardSvcImplSync(pClient);
     1804    ShClSvcImplSync(pClient);
    18051805
    18061806#else  /* UNIT_TEST */
    … …  
    18431843                    formatData.uFormats = u32Format;
    18441844
    1845                     rc = sharedClipboardSvcFormatsReport(pClient, &formatData);
     1845                    rc = shclSvcFormatsReport(pClient, &formatData);
    18461846                }
    18471847
    … …  
    18581858                dataReq.cbSize = _64K; /** @todo Make this more dynamic. */
    18591859
    1860                 rc = sharedClipboardSvcDataReadRequest(pClient, &dataReq, NULL /* puEvent */);
     1860                rc = shclSvcDataReadRequest(pClient, &dataReq, NULL /* puEvent */);
    18611861                break;
    18621862            }
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette