VirtualBox

Ignore:
Timestamp:
Jun 26, 2019 3:59:30 PM (6 years ago)
Author:
vboxsync
Message:

Shared Clipboard/URI: Update.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r79347 r79366  
    4343
    4444
    45 static DECLCALLBACK(int) vboxSvcClipboardURIProviderImplReadDataHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx,
    46                                                                     PVBOXCLIPBOARDDATAHDR *ppDataHdr)
    47 {
    48     RT_NOREF(pCtx, ppDataHdr);
     45/*********************************************************************************************************************************
     46*   Provider implementation                                                                                                                    *
     47*********************************************************************************************************************************/
     48
     49int VBoxSvcClipboardProviderImplURIReadDataHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDDATAHDR *ppDataHdr)
     50{
     51    LogFlowFuncEnter();
     52
     53    PVBOXCLIPBOARDCLIENTDATA pClientData = (PVBOXCLIPBOARDCLIENTDATA)pCtx->pvUser;
     54    AssertPtr(pClientData);
     55
     56    PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
     57    int rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_METADATA_HDR,
     58                                                 30 * 1000 /* Timeout in ms */, &pPayload);
     59    if (RT_SUCCESS(rc))
     60    {
     61        Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDDATAHDR));
     62        *ppDataHdr = (PVBOXCLIPBOARDDATAHDR)pPayload->pvData;
     63
     64        RTMemFree(pPayload);
     65    }
     66
     67    LogFlowFuncLeaveRC(rc);
     68    return rc;
     69}
     70
     71int VBoxSvcClipboardProviderImplURIWriteDataHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDATAHDR pDataHdr)
     72{
     73    RT_NOREF(pCtx, pDataHdr);
     74
     75    LogFlowFuncEnter();
     76
    4977    return VERR_NOT_IMPLEMENTED;
    5078}
    5179
    52 static DECLCALLBACK(int) vboxSvcClipboardURIProviderImplReadObjHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx,
    53                                                                    PVBOXCLIPBOARDDATAHDR *ppDataHdr)
    54 {
    55     RT_NOREF(pCtx, ppDataHdr);
     80int VBoxSvcClipboardProviderImplURIReadDataChunk(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDATAHDR pDataHdr,
     81                                                 void *pvChunk, uint32_t cbChunk, uint32_t fFlags, uint32_t *pcbRead)
     82{
     83    RT_NOREF(pDataHdr, fFlags);
     84
     85    LogFlowFuncEnter();
     86
     87    PVBOXCLIPBOARDCLIENTDATA pClientData = (PVBOXCLIPBOARDCLIENTDATA)pCtx->pvUser;
     88    AssertPtr(pClientData);
     89
     90    PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
     91    int rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_METADATA_CHUNK,
     92                                                 30 * 1000 /* Timeout in ms */, &pPayload);
     93    if (RT_SUCCESS(rc))
     94    {
     95        Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDDATACHUNK));
     96
     97        const uint32_t cbToRead = RT_MIN(cbChunk, pPayload->cbData);
     98
     99        memcpy(pvChunk, pPayload->pvData, cbToRead);
     100
     101        SharedClipboardURITransferPayloadFree(pPayload);
     102
     103        if (pcbRead)
     104            *pcbRead = cbToRead;
     105    }
     106
     107    LogFlowFuncLeaveRC(rc);
     108    return rc;
     109}
     110
     111int VBoxSvcClipboardProviderImplURIWriteDataChunk(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDATAHDR pDataHdr,
     112                                                  const void *pvChunk, uint32_t cbChunk, uint32_t fFlags, uint32_t *pcbWritten)
     113{
     114    RT_NOREF(pCtx, pDataHdr, pvChunk, cbChunk, fFlags, pcbWritten);
     115
     116    LogFlowFuncEnter();
     117
    56118    return VERR_NOT_IMPLEMENTED;
    57119}
    58120
    59 static DECLCALLBACK(int) vboxSvcClipboardURIProviderImplReadDir(PSHAREDCLIPBOARDPROVIDERCTX pCtx,
    60                                                                 PVBOXCLIPBOARDDIRDATA *ppDirData)
     121int VBoxSvcClipboardProviderImplURIReadDir(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDDIRDATA *ppDirData)
    61122{
    62123    RT_NOREF(pCtx, ppDirData);
     124
     125    LogFlowFuncEnter();
     126
    63127    return VERR_NOT_IMPLEMENTED;
    64128}
    65129
    66 static DECLCALLBACK(int) vboxSvcClipboardURIProviderImplReadFileHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx,
    67                                                                     PVBOXCLIPBOARDFILEHDR *ppFileHdr)
     130int VBoxSvcClipboardProviderImplURIWriteDir(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDIRDATA pDirData)
     131{
     132    RT_NOREF(pCtx, pDirData);
     133
     134    LogFlowFuncEnter();
     135
     136    return VERR_NOT_IMPLEMENTED;
     137}
     138
     139int VBoxSvcClipboardProviderImplURIReadFileHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDFILEHDR *ppFileHdr)
    68140{
    69141    RT_NOREF(pCtx, ppFileHdr);
     142
     143    LogFlowFuncEnter();
     144
    70145    return VERR_NOT_IMPLEMENTED;
    71146}
    72147
    73 static DECLCALLBACK(int) vboxSvcClipboardURIProviderImplReadFileData(PSHAREDCLIPBOARDPROVIDERCTX pCtX,
    74                                                                      void *pvData, uint32_t cbData, uint32_t fFlags,
    75                                                                      uint32_t *pcbRead)
    76 {
    77 #if 0
    78     const PVBOXCLIPBOARDCLIENTDATA pClientData = (PVBOXCLIPBOARDCLIENTDATA)pCtx->pvUser;
    79 
    80     return pObjCtx->pObj->Read(pvBuf, cbBuf, pcbWritten);
    81 #endif
    82 
    83     RT_NOREF(pCtX, pvData, cbData, fFlags, pcbRead);
     148int VBoxSvcClipboardProviderImplURIWriteFileHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDFILEHDR pFileHdr)
     149{
     150    RT_NOREF(pCtx, pFileHdr);
     151
     152    LogFlowFuncEnter();
     153
    84154    return VERR_NOT_IMPLEMENTED;
    85155}
    86156
    87 #if 0
    88 int vboxSvcClipboardURIAnnounce(uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    89 {
    90     Provider.pfnReadDataHdr    = vboxSvcClipboardURIProviderImplReadDataHdr;
    91     Provider.pfnReadDataChunk  = vboxSvcClipboardURIProviderImplReadDataChunk;
    92     Provider.pfnReadDir        = vboxSvcClipboardURIProviderImplReadDir;
    93     Provider.pfnReadFileHdr    = vboxSvcClipboardURIProviderImplReadFileHdr;
    94     Provider.pfnReadFileData   = vboxSvcClipboardURIProviderImplReadFileData;
    95 
    96     Provider.pvUser =
    97 
    98     SharedClipboardURITransferSetProvider(&Provider);
    99 
    100     return rc;
    101 }
    102 #endif
     157int VBoxSvcClipboardProviderImplURIReadFileData(PSHAREDCLIPBOARDPROVIDERCTX pCtx, void *pvData, uint32_t cbData, uint32_t fFlags,
     158                                                uint32_t *pcbRead)
     159{
     160    RT_NOREF(pCtx, pvData, cbData, fFlags, pcbRead);
     161
     162    LogFlowFuncEnter();
     163
     164    return VERR_NOT_IMPLEMENTED;
     165}
     166
     167int VBoxSvcClipboardProviderImplURIWriteFileData(PSHAREDCLIPBOARDPROVIDERCTX pCtx, void *pvData, uint32_t cbData, uint32_t fFlags,
     168                                                 uint32_t *pcbWritten)
     169{
     170    RT_NOREF(pCtx, pvData, cbData, fFlags, pcbWritten);
     171
     172    LogFlowFuncEnter();
     173
     174    return VERR_NOT_IMPLEMENTED;
     175}
     176
     177/*********************************************************************************************************************************
     178*   URI callbacks                                                                                                                    *
     179*********************************************************************************************************************************/
     180
     181DECLCALLBACK(void) VBoxSvcClipboardURITransferPrepareCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData)
     182{
     183    LogFlowFuncEnter();
     184
     185    LogFlowFuncEnter();
     186
     187    AssertPtrReturnVoid(pData);
     188
     189    PVBOXCLIPBOARDCLIENTDATA pClientData = (PVBOXCLIPBOARDCLIENTDATA)pData->pvUser;
     190    AssertPtrReturnVoid(pClientData);
     191
     192    /* Tell the guest that it can start sending URI data. */
     193    int rc2 = vboxSvcClipboardReportMsg(pClientData, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
     194                                        VBOX_SHARED_CLIPBOARD_FMT_URI_LIST);
     195    AssertRC(rc2);
     196
     197    rc2 = SharedClipboardURITransferEventRegister(pData->pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_METADATA_HDR);
     198    AssertRC(rc2);
     199    rc2 = SharedClipboardURITransferEventRegister(pData->pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_METADATA_CHUNK);
     200    AssertRC(rc2);
     201}
     202
     203DECLCALLBACK(void) VBoxSvcClipboardURIDataHeaderCompleteCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData)
     204{
     205    LogFlowFuncEnter();
     206
     207    RT_NOREF(pData);
     208}
     209
     210DECLCALLBACK(void) VBoxSvcClipboardURIDataCompleteCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData)
     211{
     212    LogFlowFuncEnter();
     213
     214    VBoxClipboardSvcImplURIOnDataHeaderComplete(pData);
     215}
     216
     217DECLCALLBACK(void) VBoxSvcClipboardURITransferCompleteCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, int rc)
     218{
     219    LogFlowFuncEnter();
     220
     221    RT_NOREF(pData, rc);
     222
     223    LogRel2(("Shared Clipboard: Transfer complete\n"));
     224}
     225
     226DECLCALLBACK(void) VBoxSvcClipboardURITransferCanceledCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData)
     227{
     228    LogFlowFuncEnter();
     229
     230    RT_NOREF(pData);
     231
     232    LogRel2(("Shared Clipboard: Transfer canceled\n"));
     233}
     234
     235DECLCALLBACK(void) VBoxSvcClipboardURITransferErrorCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, int rc)
     236{
     237    LogFlowFuncEnter();
     238
     239    RT_NOREF(pData, rc);
     240
     241    LogRel(("Shared Clipboard: Transfer failed with %Rrc\n", rc));
     242}
    103243
    104244/**
    … …  
    497637    }
    498638
    499     if (!SharedClipboardURICtxGetRunningTransfers(&pClientData->URI))
    500     {
    501         LogFunc(("No running transfers found\n"));
     639    if (!SharedClipboardURICtxGetTotalTransfers(&pClientData->URI))
     640    {
     641        LogFunc(("No transfers found\n"));
    502642        return VERR_WRONG_ORDER;
    503643    }
    … …  
    534674            rc = SharedClipboardURIDataHdrInit(&dataHdr);
    535675            if (RT_SUCCESS(rc))
     676            {
    536677                rc = VBoxSvcClipboardURIGetDataHdr(cParms, paParms, &dataHdr);
    537             /*if (RT_SUCCESS(rc))
    538                 rc = SharedClipboardURITransferSetDataHeader(&dataHdr);*/
     678                if (RT_SUCCESS(rc))
     679                {
     680                    void    *pvData = SharedClipboardURIDataHdrDup(&dataHdr);
     681                    uint32_t cbData = sizeof(VBOXCLIPBOARDDATAHDR);
     682
     683                    PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
     684                    rc = SharedClipboardURITransferPayloadAlloc(SHAREDCLIPBOARDURITRANSFEREVENTTYPE_METADATA_HDR,
     685                                                                pvData, cbData, &pPayload);
     686                    if (RT_SUCCESS(rc))
     687                    {
     688                        rc = SharedClipboardURITransferEventSignal(pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_METADATA_HDR,
     689                                                                   pPayload);
     690                    }
     691                }
     692            }
    539693            break;
    540694        }
    … …  
    553707            rc = SharedClipboardURIDataChunkInit(&dataChunk);
    554708            if (RT_SUCCESS(rc))
     709            {
    555710                rc = VBoxSvcClipboardURIGetDataChunk(cParms, paParms, &dataChunk);
    556     #if 0
    557             if (RT_SUCCESS(rc))
    558             {
    559                 VBOXCLIPBOARDTRANSFEREVENT Event = { &dataChunk, sizeof(dataChunk) };
    560                 rc = SharedClipboardURITransferSendEvent(WRITE_DATA_CHUNK, &Event);
     711                if (RT_SUCCESS(rc))
     712                {
     713                    void    *pvData = SharedClipboardURIDataChunkDup(&dataChunk);
     714                    uint32_t cbData = sizeof(VBOXCLIPBOARDDATACHUNK);
     715
     716                    PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
     717                    rc = SharedClipboardURITransferPayloadAlloc(SHAREDCLIPBOARDURITRANSFEREVENTTYPE_METADATA_CHUNK,
     718                                                                pvData, cbData, &pPayload);
     719                    if (RT_SUCCESS(rc))
     720                    {
     721                        rc = SharedClipboardURITransferEventSignal(pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_METADATA_CHUNK,
     722                                                                   pPayload);
     723                    }
     724
     725                }
    561726            }
    562         #endif
    563727            break;
    564728        }
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