VirtualBox

Ignore:
Timestamp:
Jan 27, 2021 5:11:25 PM (4 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
142470
Message:

Shared Clipboard/Transfers: More code for HTTP transfers. bugref:9437

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

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/HostServices/SharedClipboard/Makefile.kmk

    r87059 r87452  
    4545        darwin-pasteboard.cpp
    4646ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
     47 if1of ($(KBUILD_TARGET), linux)
     48  VBoxSharedClipboard_DEFS    += VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS_HTTP
     49  VBoxSharedClipboard_SOURCES += \
     50        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/clipboard-transfers-http.cpp
     51 endif
    4752 VBoxSharedClipboard_DEFS    += VBOX_WITH_SHARED_CLIPBOARD_HOST
    4853 VBoxSharedClipboard_SOURCES += \
    … …  
    5560        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardEnumFormatEtcImpl-win.cpp \
    5661        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardStreamImpl-win.cpp
    57  if1of ($(KBUILD_TARGET), linux)
    58   VBoxSharedClipboard_DEFS    += VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS_HTTP
    59   VBoxSharedClipboard_SOURCES += \
    60         $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/clipboard-transfers-http.cpp
    61  endif
    6262endif
    6363if1of ($(KBUILD_TARGET), linux solaris freebsd) ## @todo X11

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

    r86908 r87452  
    166166} SHCLCLIENTCMDCTX, *PSHCLCLIENTCMDCTX;
    167167
     168#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
     169/**
     170 * Structure for keeping transfer-related data per HGCM client.
     171 */
     172typedef struct _SHCLIENTTRANSFERS
     173{
     174    /** Transfer context. */
     175    SHCLTRANSFERCTX             Ctx;
     176} SHCLIENTTRANSFERS, *PSHCLIENTTRANSFERS;
     177#endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
     178
     179/**
     180 * Structure for keeping data per (connected) HGCM client.
     181 */
    168182typedef struct _SHCLCLIENT
    169183{
    … …  
    182196    SHCLEVENTSOURCE             EventSrc;
    183197#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    184     /** Transfer contextdata. */
    185     SHCLTRANSFERCTX             TransferCtx;
     198    SHCLIENTTRANSFERS           Transfers;
    186199#endif
    187200    /** Structure for keeping the client's pending (deferred return) state.
    … …  
    256269int shClSvcClientInit(PSHCLCLIENT pClient, uint32_t uClientID);
    257270void shClSvcClientDestroy(PSHCLCLIENT pClient);
     271void shClSvcClientLock(PSHCLCLIENT pClient);
     272void shClSvcClientUnlock(PSHCLCLIENT pClient);
    258273void shClSvcClientReset(PSHCLCLIENT pClient);
    259274
    … …  
    359374 */
    360375/**
    361  * Called when a transfer gets created.
     376 * Called after a transfer got created.
    362377 *
    363378 * @returns VBox status code.
    … …  
    367382int ShClBackendTransferCreate(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer);
    368383/**
    369  * Called when a transfer gets destroyed.
     384 * Called before a transfer gets destroyed.
    370385 *
    371386 * @returns VBox status code.
    … …  
    397412 * @{
    398413 */
    399 int shClSvcTransferIfaceOpen(PSHCLPROVIDERCTX pCtx);
    400 int shClSvcTransferIfaceClose(PSHCLPROVIDERCTX pCtx);
    401 
    402 int shClSvcTransferIfaceGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList);
    403 
    404 int shClSvcTransferIfaceListOpen(PSHCLPROVIDERCTX pCtx, PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList);
    405 int shClSvcTransferIfaceListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList);
    406 int shClSvcTransferIfaceListHdrRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr);
    407 int shClSvcTransferIfaceListHdrWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr);
    408 int shClSvcTransferIfaceListEntryRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry);
    409 int shClSvcTransferIfaceListEntryWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry);
    410 
    411 int shClSvcTransferIfaceObjOpen(PSHCLPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms,
     414#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS_HTTP
     415
     416#endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS_HTTP */
     417
     418int shClSvcTransferIfaceGetRoots(PSHCLTXPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList);
     419
     420int shClSvcTransferIfaceListOpen(PSHCLTXPROVIDERCTX pCtx, PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList);
     421int shClSvcTransferIfaceListClose(PSHCLTXPROVIDERCTX pCtx, SHCLLISTHANDLE hList);
     422int shClSvcTransferIfaceListHdrRead(PSHCLTXPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr);
     423int shClSvcTransferIfaceListHdrWrite(PSHCLTXPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr);
     424int shClSvcTransferIfaceListEntryRead(PSHCLTXPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry);
     425int shClSvcTransferIfaceListEntryWrite(PSHCLTXPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry);
     426
     427int shClSvcTransferIfaceObjOpen(PSHCLTXPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms,
    412428                                PSHCLOBJHANDLE phObj);
    413 int shClSvcTransferIfaceObjClose(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj);
    414 int shClSvcTransferIfaceObjRead(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
     429int shClSvcTransferIfaceObjClose(PSHCLTXPROVIDERCTX pCtx, SHCLOBJHANDLE hObj);
     430int shClSvcTransferIfaceObjRead(PSHCLTXPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
    415431                                void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead);
    416 int shClSvcTransferIfaceObjWrite(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
     432int shClSvcTransferIfaceObjWrite(PSHCLTXPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
    417433                                 void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten);
    418434/** @} */
    … …  
    421437 * @{
    422438 */
    423 DECLCALLBACK(void) VBoxSvcClipboardTransferPrepareCallback(PSHCLTRANSFERCALLBACKDATA pData);
    424 DECLCALLBACK(void) VBoxSvcClipboardDataHeaderCompleteCallback(PSHCLTRANSFERCALLBACKDATA pData);
    425 DECLCALLBACK(void) VBoxSvcClipboardDataCompleteCallback(PSHCLTRANSFERCALLBACKDATA pData);
    426 DECLCALLBACK(void) VBoxSvcClipboardTransferCompleteCallback(PSHCLTRANSFERCALLBACKDATA pData, int rc);
    427 DECLCALLBACK(void) VBoxSvcClipboardTransferCanceledCallback(PSHCLTRANSFERCALLBACKDATA pData);
    428 DECLCALLBACK(void) VBoxSvcClipboardTransferErrorCallback(PSHCLTRANSFERCALLBACKDATA pData, int rc);
     439DECLCALLBACK(void) VBoxSvcClipboardTransferPrepareCallback(PSHCLTXPROVIDERCTX pCtx);
     440DECLCALLBACK(void) VBoxSvcClipboardDataHeaderCompleteCallback(PSHCLTXPROVIDERCTX pCtx);
     441DECLCALLBACK(void) VBoxSvcClipboardDataCompleteCallback(PSHCLTXPROVIDERCTX pCtx);
     442DECLCALLBACK(void) VBoxSvcClipboardTransferCompleteCallback(PSHCLTXPROVIDERCTX pCtx, int rc);
     443DECLCALLBACK(void) VBoxSvcClipboardTransferCanceledCallback(PSHCLTXPROVIDERCTX pCtx);
     444DECLCALLBACK(void) VBoxSvcClipboardTransferErrorCallback(PSHCLTXPROVIDERCTX pCtx, int rc);
    429445/** @} */
    430446#endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */

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

    r86949 r87452  
    7373    LogFlowFuncEnter();
    7474
    75     ShClTransferCtxDestroy(&pClient->TransferCtx);
     75    /* Make sure to let the backend know that all transfers are getting destroyed. */
     76    uint32_t      uIdx = 0;
     77    PSHCLTRANSFER pTransfer;
     78    while ((pTransfer = ShClTransferCtxGetTransferByIndex(&pClient->Transfers.Ctx, uIdx++)))
     79        ShClBackendTransferDestroy(pClient, pTransfer);
     80
     81    ShClTransferCtxDestroy(&pClient->Transfers.Ctx);
    7682}
    7783
    7884
    7985/*********************************************************************************************************************************
    80 *   Provider implementation                                                                                                      *
     86*   Provider interface implementation                                                                                            *
    8187*********************************************************************************************************************************/
    8288
    83 DECLCALLBACK(int) shClSvcTransferIfaceOpen(PSHCLPROVIDERCTX pCtx)
    84 {
    85     LogFlowFuncEnter();
    86 
    87     RT_NOREF(pCtx);
    88 
    89     LogFlowFuncLeave();
    90     return VINF_SUCCESS;
    91 }
    92 
    93 DECLCALLBACK(int) shClSvcTransferIfaceClose(PSHCLPROVIDERCTX pCtx)
    94 {
    95     LogFlowFuncEnter();
    96 
    97     PSHCLCLIENT pClient = (PSHCLCLIENT)pCtx->pvUser;
    98     AssertPtr(pClient);
    99 
    100     int rc = shClSvcTransferStop(pClient, pCtx->pTransfer);
    101 
    102     LogFlowFuncLeaveRC(rc);
    103     return rc;
    104 }
    105 
    106 DECLCALLBACK(int) shClSvcTransferIfaceGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList)
     89DECLCALLBACK(int) shClSvcTransferIfaceGetRoots(PSHCLTXPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList)
    10790{
    10891    LogFlowFuncEnter();
    … …  
    124107            HGCMSvcSetU32(&pMsgHdr->aParms[1], 0 /* fRoots */);
    125108
     109            shClSvcClientLock(pClient);
     110
    126111            shClSvcMsgAdd(pClient, pMsgHdr, true /* fAppend */);
    127 
    128112            rc = shClSvcClientWakeup(pClient);
     113
     114            shClSvcClientUnlock(pClient);
     115
    129116            if (RT_SUCCESS(rc))
    130117            {
    … …  
    163150                                        HGCMSvcSetU32(&pMsgEntry->aParms[2], i /* uIndex */);
    164151
     152                                        shClSvcClientLock(pClient);
    165153                                        shClSvcMsgAdd(pClient, pMsgEntry, true /* fAppend */);
     154                                        shClSvcClientUnlock(pClient);
    166155
    167156                                        PSHCLEVENTPAYLOAD pPayloadEntry;
    … …  
    220209}
    221210
    222 DECLCALLBACK(int) shClSvcTransferIfaceListOpen(PSHCLPROVIDERCTX pCtx,
     211DECLCALLBACK(int) shClSvcTransferIfaceListOpen(PSHCLTXPROVIDERCTX pCtx,
    223212                                               PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList)
    224213{
    … …  
    280269}
    281270
    282 DECLCALLBACK(int) shClSvcTransferIfaceListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList)
     271DECLCALLBACK(int) shClSvcTransferIfaceListClose(PSHCLTXPROVIDERCTX pCtx, SHCLLISTHANDLE hList)
    283272{
    284273    LogFlowFuncEnter();
    … …  
    326315}
    327316
    328 DECLCALLBACK(int) shClSvcTransferIfaceListHdrRead(PSHCLPROVIDERCTX pCtx,
     317DECLCALLBACK(int) shClSvcTransferIfaceListHdrRead(PSHCLTXPROVIDERCTX pCtx,
    329318                                                  SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr)
    330319{
    … …  
    378367}
    379368
    380 DECLCALLBACK(int) shClSvcTransferIfaceListHdrWrite(PSHCLPROVIDERCTX pCtx,
     369DECLCALLBACK(int) shClSvcTransferIfaceListHdrWrite(PSHCLTXPROVIDERCTX pCtx,
    381370                                                   SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr)
    382371{
    … …  
    388377}
    389378
    390 DECLCALLBACK(int) shClSvcTransferIfaceListEntryRead(PSHCLPROVIDERCTX pCtx,
     379DECLCALLBACK(int) shClSvcTransferIfaceListEntryRead(PSHCLTXPROVIDERCTX pCtx,
    391380                                                    SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry)
    392381{
    … …  
    439428}
    440429
    441 DECLCALLBACK(int) shClSvcTransferIfaceListEntryWrite(PSHCLPROVIDERCTX pCtx,
     430DECLCALLBACK(int) shClSvcTransferIfaceListEntryWrite(PSHCLTXPROVIDERCTX pCtx,
    442431                                                     SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry)
    443432{
    … …  
    449438}
    450439
    451 int shClSvcTransferIfaceObjOpen(PSHCLPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms,
     440int shClSvcTransferIfaceObjOpen(PSHCLTXPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms,
    452441                                PSHCLOBJHANDLE phObj)
    453442{
    … …  
    513502}
    514503
    515 int shClSvcTransferIfaceObjClose(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj)
     504int shClSvcTransferIfaceObjClose(PSHCLTXPROVIDERCTX pCtx, SHCLOBJHANDLE hObj)
    516505{
    517506    LogFlowFuncEnter();
    … …  
    567556}
    568557
    569 int shClSvcTransferIfaceObjRead(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
     558int shClSvcTransferIfaceObjRead(PSHCLTXPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
    570559                                void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead)
    571560{
    … …  
    627616}
    628617
    629 int shClSvcTransferIfaceObjWrite(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
     618int shClSvcTransferIfaceObjWrite(PSHCLTXPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
    630619                                 void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten)
    631620{
    … …  
    13151304        default:
    13161305        {
    1317             if (!ShClTransferCtxGetTotalTransfers(&pClient->TransferCtx))
     1306            if (!ShClTransferCtxGetTotalTransfers(&pClient->Transfers.Ctx))
    13181307            {
    13191308                LogFunc(("No transfers found\n"));
    … …  
    13311320            const SHCLTRANSFERID uTransferID = VBOX_SHCL_CONTEXTID_GET_TRANSFER(uCID);
    13321321
    1333             pTransfer = ShClTransferCtxGetTransfer(&pClient->TransferCtx, uTransferID);
     1322            pTransfer = ShClTransferCtxGetTransferById(&pClient->Transfers.Ctx, uTransferID);
    13341323            if (!pTransfer)
    13351324            {
    … …  
    18031792 * Starts a new transfer, waiting for acknowledgement by the guest side.
    18041793 *
     1794 * @note Assumes that the client's critical section is taken.
     1795 *
    18051796 * @returns VBox status code.
    18061797 * @param   pClient             Client that owns the transfer.
    … …  
    18181809    LogFlowFuncEnter();
    18191810
    1820     ShClTransferCtxCleanup(&pClient->TransferCtx);
    1821 
    1822     int rc;
    1823 
    1824     if (!ShClTransferCtxTransfersMaximumReached(&pClient->TransferCtx))
     1811    PSHCLTRANSFERCTX pTxCtx = &pClient->Transfers.Ctx;
     1812
     1813    ShClTransferCtxCleanup(pTxCtx);
     1814
     1815    int rc;
     1816
     1817    if (!ShClTransferCtxTransfersMaximumReached(pTxCtx))
    18251818    {
    18261819        LogRel2(("Shared Clipboard: Starting %s transfer ...\n", enmDir == SHCLTRANSFERDIR_FROM_REMOTE ? "read" : "write"));
    … …  
    18301823        if (RT_SUCCESS(rc))
    18311824        {
    1832             rc = ShClBackendTransferCreate(pClient, pTransfer);
    1833             if (RT_SUCCESS(rc))
    1834             {
    1835                 SHCLPROVIDERCREATIONCTX creationCtx;
    1836                 RT_ZERO(creationCtx);
    1837 
    1838                 if (enmDir == SHCLTRANSFERDIR_FROM_REMOTE)
    1839                 {
    1840                     creationCtx.Interface.pfnTransferOpen  = shClSvcTransferIfaceOpen;
    1841                     creationCtx.Interface.pfnTransferClose = shClSvcTransferIfaceClose;
    1842 
    1843                     creationCtx.Interface.pfnRootsGet      = shClSvcTransferIfaceGetRoots;
    1844 
    1845                     creationCtx.Interface.pfnListOpen      = shClSvcTransferIfaceListOpen;
    1846                     creationCtx.Interface.pfnListClose     = shClSvcTransferIfaceListClose;
    1847                     creationCtx.Interface.pfnListHdrRead   = shClSvcTransferIfaceListHdrRead;
    1848                     creationCtx.Interface.pfnListEntryRead = shClSvcTransferIfaceListEntryRead;
    1849 
    1850                     creationCtx.Interface.pfnObjOpen       = shClSvcTransferIfaceObjOpen;
    1851                     creationCtx.Interface.pfnObjClose      = shClSvcTransferIfaceObjClose;
    1852                     creationCtx.Interface.pfnObjRead       = shClSvcTransferIfaceObjRead;
    1853                 }
    1854                 else if (enmDir == SHCLTRANSFERDIR_TO_REMOTE)
    1855                 {
    1856                     creationCtx.Interface.pfnListHdrWrite   = shClSvcTransferIfaceListHdrWrite;
    1857                     creationCtx.Interface.pfnListEntryWrite = shClSvcTransferIfaceListEntryWrite;
    1858                     creationCtx.Interface.pfnObjWrite       = shClSvcTransferIfaceObjWrite;
    1859                 }
    1860                 else
    1861                     AssertFailed();
    1862 
    1863                 creationCtx.enmSource = pClient->State.enmSource;
    1864                 creationCtx.pvUser    = pClient;
    1865 
    1866                 SHCLTRANSFERID uTransferID = 0;
    1867 
    1868                 rc = ShClTransferSetInterface(pTransfer, &creationCtx);
     1825            SHCLTXPROVIDERCREATIONCTX creationCtx;
     1826            RT_ZERO(creationCtx);
     1827
     1828            if (enmDir == SHCLTRANSFERDIR_FROM_REMOTE)
     1829            {
     1830                creationCtx.Interface.pfnRootsGet      = shClSvcTransferIfaceGetRoots;
     1831
     1832                creationCtx.Interface.pfnListOpen      = shClSvcTransferIfaceListOpen;
     1833                creationCtx.Interface.pfnListClose     = shClSvcTransferIfaceListClose;
     1834                creationCtx.Interface.pfnListHdrRead   = shClSvcTransferIfaceListHdrRead;
     1835                creationCtx.Interface.pfnListEntryRead = shClSvcTransferIfaceListEntryRead;
     1836
     1837                creationCtx.Interface.pfnObjOpen       = shClSvcTransferIfaceObjOpen;
     1838                creationCtx.Interface.pfnObjClose      = shClSvcTransferIfaceObjClose;
     1839                creationCtx.Interface.pfnObjRead       = shClSvcTransferIfaceObjRead;
     1840            }
     1841            else if (enmDir == SHCLTRANSFERDIR_TO_REMOTE)
     1842            {
     1843                creationCtx.Interface.pfnListHdrWrite   = shClSvcTransferIfaceListHdrWrite;
     1844                creationCtx.Interface.pfnListEntryWrite = shClSvcTransferIfaceListEntryWrite;
     1845                creationCtx.Interface.pfnObjWrite       = shClSvcTransferIfaceObjWrite;
     1846            }
     1847            else
     1848                AssertFailed();
     1849
     1850            creationCtx.enmSource = pClient->State.enmSource;
     1851            creationCtx.pvUser    = pClient;
     1852
     1853            rc = ShClTransferSetProviderIface(pTransfer, &creationCtx);
     1854            if (RT_SUCCESS(rc))
     1855            {
     1856                rc = ShClTransferInit(pTransfer, enmDir, enmSource);
    18691857                if (RT_SUCCESS(rc))
    18701858                {
    1871                     rc = ShClTransferCtxTransferRegister(&pClient->TransferCtx, pTransfer, &uTransferID);
     1859                    SHCLTRANSFERID uTransferID = 0;
     1860                    rc = ShClTransferCtxTransferRegister(pTxCtx, pTransfer, &uTransferID);
    18721861                    if (RT_SUCCESS(rc))
    18731862                    {
    1874                         rc = ShClTransferInit(pTransfer, uTransferID, enmDir, enmSource);
     1863                        rc = ShClBackendTransferCreate(pClient, pTransfer);
    18751864                        if (RT_SUCCESS(rc))
    18761865                        {
    … …  
    18891878                                             pTransfer->State.uID));
    18901879
    1891                                     PSHCLEVENTPAYLOAD pPayload;
     1880                                    /* Leave the client's critical section before waiting. */
     1881                                    RTCritSectLeave(&pClient->CritSect);
     1882
     1883                                    PSHCLEVENTPAYLOAD pPayload = NULL;
    18921884                                    rc = ShClEventWait(&pTransfer->Events, idEvent, pTransfer->uTimeoutMs, &pPayload);
    18931885                                    if (RT_SUCCESS(rc))
    … …  
    19071899                                                    ShClTransferStatusToStr(pReply->u.TransferStatus.uStatus),
    19081900                                                    pReply->rc, pTransfer->State.uID));
     1901
     1902                                        rc = pReply->rc; /* Set guest rc. */
    19091903                                    }
    19101904                                    else
    19111905                                       LogRel(("Shared Clipboard: Unable to start transfer %RU32 on guest, rc=%Rrc\n",
    19121906                                               pTransfer->State.uID, rc));
     1907
     1908                                    ShClPayloadFree(pPayload);
     1909
     1910                                    /* Re-enter the client's critical section again. */
     1911                                    RTCritSectEnter(&pClient->CritSect);
    19131912                                }
    19141913                            }
    19151914                        }
    1916 
    1917                         if (RT_FAILURE(rc))
    1918                             ShClTransferCtxTransferUnregister(&pClient->TransferCtx, uTransferID);
    19191915                    }
     1916
     1917                    if (RT_FAILURE(rc))
     1918                        ShClTransferCtxTransferUnregister(pTxCtx, uTransferID);
    19201919                }
    19211920            }
    … …  
    19741973    /* Regardless of whether the guest was able to report back and/or stop the transfer, remove the transfer on the host
    19751974     * so that we don't risk of having stale transfers here. */
    1976     int rc2 = ShClTransferCtxTransferUnregister(&pClient->TransferCtx, ShClTransferGetID(pTransfer));
     1975    int rc2 = ShClTransferCtxTransferUnregister(&pClient->Transfers.Ctx, ShClTransferGetID(pTransfer));
    19771976    if (RT_SUCCESS(rc2))
    19781977    {
     1978        ShClBackendTransferDestroy(pClient, pTransfer);
    19791979        ShClTransferDestroy(pTransfer);
    19801980        pTransfer = NULL;
    … …  
    19981998    g_fTransferMode = fMode;
    19991999
     2000#ifdef DEBUG_andy
     2001g_fTransferMode = VBOX_SHCL_TRANSFER_MODE_ENABLED;
     2002#endif
     2003
    20002004    LogRel2(("Shared Clipboard: File transfers are now %s\n",
    20012005             g_fTransferMode != VBOX_SHCL_TRANSFER_MODE_DISABLED ? "enabled" : "disabled"));

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

    r87082 r87452  
    250250}
    251251
    252 /**
    253  * Reports formats available in the X11 clipboard to VBox.
    254  *
    255  * @note   Runs in Xt event thread.
    256  *
    257  * @param  pCtx                 Opaque context pointer for the glue code.
    258  * @param  fFormats             The formats available.
    259  */
     252/** @copydoc ShClX11ReportFormatsCallback */
    260253DECLCALLBACK(void) ShClX11ReportFormatsCallback(PSHCLCONTEXT pCtx, uint32_t fFormats)
    261254{
    262255    LogFlowFunc(("pCtx=%p, fFormats=%#x\n", pCtx, fFormats));
     256
     257    PSHCLCLIENT pClient = pCtx->pClient;
     258    AssertPtr(pClient);
     259
     260    RTCritSectEnter(&pClient->CritSect);
    263261
    264262    /** @todo r=bird: BUGBUG: Revisit this   */
    … …  
    269267    RT_NOREF(rc);
    270268
    271     LogFlowFuncLeaveRC(rc);
    272 }
    273 
    274 /**
    275  * Completes a request from the host service for reading the X11 clipboard data.
    276  * The data should be written to the buffer provided in the initial request.
    277  *
    278  * @note   Runs in Xt event thread.
    279  *
    280  * @param  pCtx                 Request context information.
    281  * @param  rcCompletion         The completion status of the request.
    282  * @param  pReq                 Request to complete. Will be free'd by the callback.
    283  * @param  pv                   Address of data from completed request. Optional.
    284  * @param  cb                   Size (in bytes) of data from completed request. Optional.
    285  *
    286  * @todo   Change this to deal with the buffer issues rather than offloading them onto the caller.
    287  */
     269    RTCritSectLeave(&pClient->CritSect);
     270
     271    LogFlowFuncLeaveRC(rc);
     272}
     273
     274/** @copydoc ShClX11RequestFromX11CompleteCallback */
    288275DECLCALLBACK(void) ShClX11RequestFromX11CompleteCallback(PSHCLCONTEXT pCtx, int rcCompletion,
    289276                                                         CLIPREADCBREQ *pReq, void *pv, uint32_t cb)
    … …  
    322309}
    323310
    324 /**
    325  * Callback implementation for reading clipboard data from the guest.
    326  *
    327  * @note Runs in Xt event thread.
    328  *
    329  * @returns VBox status code. VERR_NO_DATA if no data available.
    330  * @param   pCtx                Pointer to the host clipboard structure.
    331  * @param   uFmt                The format in which the data should be transferred
    332  *                              (VBOX_SHCL_FMT_XXX).
    333  * @param   ppv                 Returns an allocated buffer with data read from the guest on success.
    334  *                              Needs to be free'd with RTMemFree() by the caller.
    335  * @param   pcb                 Returns the amount of data read (in bytes) on success.
    336  */
     311/** @copydoc ShClX11RequestDataForX11Callback */
    337312DECLCALLBACK(int) ShClX11RequestDataForX11Callback(PSHCLCONTEXT pCtx, SHCLFORMAT uFmt, void **ppv, uint32_t *pcb)
    338313{
    … …  
    346321    }
    347322
    348     int rc;
     323    PSHCLCLIENT pClient = pCtx->pClient;
     324    AssertPtr(pClient);
     325
     326    RTCritSectEnter(&pClient->CritSect);
     327
     328    int rc = VINF_SUCCESS;
    349329
    350330#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
     331    /*
     332     * Note: We always return a generic URI list here.
     333     *       As we don't know which Atom target format was requested by the caller, the X11 clipboard codes needs
     334     *       to decide & transform the list into the actual clipboard Atom target format the caller wanted.
     335     */
    351336    if (uFmt == VBOX_SHCL_FMT_URI_LIST)
    352337    {
     338        PSHCLTRANSFER pTransfer;
     339        rc = shClSvcTransferStart(pCtx->pClient,
     340                                  SHCLTRANSFERDIR_FROM_REMOTE, SHCLSOURCE_REMOTE,
     341                                  &pTransfer);
     342        if (RT_SUCCESS(rc))
     343        {
     344
     345        }
     346        else
     347            LogRel(("Shared Clipboard: Initializing read transfer from guest failed with %Rrc\n", rc));
     348
    353349        *ppv = NULL;
    354350        *pcb = 0;
    … …  
    356352        rc = VERR_NO_DATA;
    357353    }
    358     else
    359354#endif
     355
     356    if (RT_SUCCESS(rc))
    360357    {
    361358        /* Request data from the guest. */
    … …  
    364361        if (RT_SUCCESS(rc))
    365362        {
     363            RTCritSectLeave(&pClient->CritSect);
     364
    366365            PSHCLEVENTPAYLOAD pPayload;
    367366            rc = ShClEventWait(&pCtx->pClient->EventSrc, idEvent, 30 * 1000, &pPayload);
    … …  
    380379            }
    381380
     381            RTCritSectEnter(&pClient->CritSect);
     382
    382383            ShClEventRelease(&pCtx->pClient->EventSrc, idEvent);
    383384            ShClEventUnregister(&pCtx->pClient->EventSrc, idEvent);
    … …  
    385386    }
    386387
     388    RTCritSectLeave(&pClient->CritSect);
     389
    387390    if (RT_FAILURE(rc))
    388391        LogRel(("Shared Clipboard: Requesting data in format %#x for X11 host failed with %Rrc\n", uFmt, rc));
    … …  
    396399int ShClBackendTransferCreate(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer)
    397400{
     401#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS_HTTP
     402    return ShClHttpTransferCreate(&pClient->State.pCtx->X11.HttpCtx, pTransfer);
     403#else
    398404    RT_NOREF(pClient, pTransfer);
    399 
    400     int rc = VINF_SUCCESS;
    401 
    402     LogFlowFuncLeaveRC(rc);
    403     return rc;
     405#endif
     406    return VERR_NOT_IMPLEMENTED;
    404407}
    405408
    406409int ShClBackendTransferDestroy(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer)
    407410{
     411#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS_HTTP
     412    return ShClHttpTransferDestroy(&pClient->State.pCtx->X11.HttpCtx, pTransfer);
     413#else
    408414    RT_NOREF(pClient, pTransfer);
    409 
    410     int rc = VINF_SUCCESS;
    411 
    412     LogFlowFuncLeaveRC(rc);
    413     return rc;
     415#endif
     416
     417    return VINF_SUCCESS;
    414418}
    415419
    … …  
    452456    return rc;
    453457}
    454 
    455458#endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
     459

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

    r86959 r87452  
    243243PVBOXHGCMSVCHELPERS g_pHelpers;
    244244
    245 static RTCRITSECT g_CritSect;
     245static RTCRITSECT g_CritSect;               /** @todo r=andy Put this into some instance struct, avoid globals. */
    246246/** Global Shared Clipboard mode. */
    247247static uint32_t g_uMode  = VBOX_SHCL_MODE_OFF;
    … …  
    324324}
    325325
     326/**
     327 * Takes the global Shared Clipboard service lock.
     328 *
     329 * @returns \c true if locking was successful, or \c false if not.
     330 */
    326331bool ShClSvcLock(void)
    327332{
    … …  
    329334}
    330335
     336/**
     337 * Unlocks the formerly locked global Shared Clipboard service lock.
     338 */
    331339void ShClSvcUnlock(void)
    332340{
    … …  
    561569#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    562570            if (RT_SUCCESS(rc))
    563                 rc = ShClTransferCtxInit(&pClient->TransferCtx);
     571                rc = ShClTransferCtxInit(&pClient->Transfers.Ctx);
    564572#endif
    565573        }
    … …  
    617625
    618626    LogFlowFuncLeave();
     627}
     628
     629void shClSvcClientLock(PSHCLCLIENT pClient)
     630{
     631    int rc2 = RTCritSectEnter(&pClient->CritSect);
     632    AssertRC(rc2);
     633}
     634
     635void shClSvcClientUnlock(PSHCLCLIENT pClient)
     636{
     637    int rc2 = RTCritSectLeave(&pClient->CritSect);
     638    AssertRC(rc2);
    619639}
    620640
    … …  
    13961416    {
    13971417        fFormats &= ~VBOX_SHCL_FMT_URI_LIST;
    1398     }
    1399     else
    1400         LogRel2(("Shared Clipboard: Warning: File transfers are disabled, ignoring\n"));
     1418        LogRel2(("Shared Clipboard: File transfers are disabled, skipping reporting those to the guest\n"));
     1419    }
    14011420#endif
    14021421
    … …  
    20262045
    20272046#ifdef LOG_ENABLED
    2028     LogFunc(("u32ClientID=%RU32, fn=%RU32 (%s), cParms=%RU32, paParms=%p\n",
    2029              u32ClientID, u32Function, ShClGuestMsgToStr(u32Function), cParms, paParms));
     2047    Log2Func(("u32ClientID=%RU32, fn=%RU32 (%s), cParms=%RU32, paParms=%p\n",
     2048              u32ClientID, u32Function, ShClGuestMsgToStr(u32Function), cParms, paParms));
    20302049    for (uint32_t i = 0; i < cParms; i++)
    20312050    {
    … …  
    20332052        {
    20342053            case VBOX_HGCM_SVC_PARM_32BIT:
    2035                 LogFunc(("    paParms[%RU32]: type uint32_t - value %RU32\n", i, paParms[i].u.uint32));
     2054                Log3Func(("    paParms[%RU32]: type uint32_t - value %RU32\n", i, paParms[i].u.uint32));
    20362055                break;
    20372056            case VBOX_HGCM_SVC_PARM_64BIT:
    2038                 LogFunc(("    paParms[%RU32]: type uint64_t - value %RU64\n", i, paParms[i].u.uint64));
     2057                Log3Func(("    paParms[%RU32]: type uint64_t - value %RU64\n", i, paParms[i].u.uint64));
    20392058                break;
    20402059            case VBOX_HGCM_SVC_PARM_PTR:
    2041                 LogFunc(("    paParms[%RU32]: type ptr - value 0x%p (%RU32 bytes)\n",
    2042                          i, paParms[i].u.pointer.addr, paParms[i].u.pointer.size));
     2060                Log3Func(("    paParms[%RU32]: type ptr - value 0x%p (%RU32 bytes)\n",
     2061                          i, paParms[i].u.pointer.addr, paParms[i].u.pointer.size));
    20432062                break;
    20442063            case VBOX_HGCM_SVC_PARM_PAGES:
    2045                 LogFunc(("    paParms[%RU32]: type pages - cb=%RU32, cPages=%RU16\n",
    2046                          i, paParms[i].u.Pages.cb, paParms[i].u.Pages.cPages));
     2064                Log3Func(("    paParms[%RU32]: type pages - cb=%RU32, cPages=%RU16\n",
     2065                          i, paParms[i].u.Pages.cb, paParms[i].u.Pages.cPages));
    20472066                break;
    20482067            default:
    … …  
    20502069        }
    20512070    }
    2052     LogFunc(("Client state: fFlags=0x%x, fGuestFeatures0=0x%x, fGuestFeatures1=0x%x\n",
    2053              pClient->State.fFlags, pClient->State.fGuestFeatures0, pClient->State.fGuestFeatures1));
     2071    Log2Func(("Client state: fFlags=0x%x, fGuestFeatures0=0x%x, fGuestFeatures1=0x%x\n",
     2072              pClient->State.fFlags, pClient->State.fGuestFeatures0, pClient->State.fGuestFeatures1));
    20542073#endif
    20552074
    … …  
    21222141            if (RT_SUCCESS(rc))
    21232142            {
    2124                 LogRel(("Shared Clipboard: Error from guest side: %Rrc\n", rcGuest));
    2125 
    2126                 /* Reset client state and start over. */
    2127                 shclSvcClientStateReset(&pClient->State);
     2143                LogRel(("Shared Clipboard: Error reported from guest side: %Rrc\n", rcGuest));
     2144
     2145                shClSvcClientLock(pClient);
     2146
    21282147#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    21292148                shClSvcClientTransfersReset(pClient);
    21302149#endif
     2150                shClSvcClientUnlock(pClient);
    21312151            }
    21322152            break;

  • trunk/src/VBox/HostServices/SharedClipboard/testcase/tstClipboardTransfers.cpp

    r82968 r87452  
    235235    RTTESTI_CHECK_RC_OK(rc);
    236236
    237     rc = ShClTransferInit(pTransfer, 0 /* ID */, SHCLTRANSFERDIR_FROM_REMOTE, SHCLSOURCE_LOCAL);
     237    rc = ShClTransferInit(pTransfer, SHCLTRANSFERDIR_FROM_REMOTE, SHCLSOURCE_LOCAL);
    238238    RTTESTI_CHECK_RC_OK(rc);
    239239
Note: See TracChangeset for help on using the changeset viewer.

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