VirtualBox

Changeset 79299 in vbox for trunk/src/VBox


Ignore:
Timestamp:
Jun 24, 2019 10:18:19 AM (6 years ago)
Author:
vboxsync
Message:

Shared Clipboard/URI: Update.

Location:
trunk/src/VBox
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxClipboard.cpp

    r79271 r79299  
    347347                            SHAREDCLIPBOARDPROVIDERCREATIONCTX creationCtx;
    348348                            RT_ZERO(creationCtx);
    349                             creationCtx.enmSource = SHAREDCLIPBOARDPROVIDERSOURCE_VBGLR3;
     349                            creationCtx.enmSource = SHAREDCLIPBOARDURIPROVIDERSOURCE_VBGLR3;
     350                            creationCtx.enmDir    = SHAREDCLIPBOARDURITRANSFERDIR_READ;
    350351                            creationCtx.u.VbglR3.uClientID = pCtx->u32ClientID;
    351352
    … …  
    469470                        SHAREDCLIPBOARDPROVIDERCREATIONCTX creationCtx;
    470471                        RT_ZERO(creationCtx);
    471                         creationCtx.enmSource = SHAREDCLIPBOARDPROVIDERSOURCE_VBGLR3;
     472                        creationCtx.enmSource = SHAREDCLIPBOARDURIPROVIDERSOURCE_VBGLR3;
     473                        creationCtx.enmDir    = SHAREDCLIPBOARDURITRANSFERDIR_WRITE;
    472474                        creationCtx.u.VbglR3.uClientID = pCtx->u32ClientID;
    473475

  • trunk/src/VBox/GuestHost/SharedClipboard/ClipboardDataObjectImpl-win.cpp

    r79267 r79299  
    121121        m_enmStatus = Initialized;
    122122
     123        int rc2 = RTSemEventCreate(&m_EventMetaDataComplete);
     124        AssertRC(rc2);
     125
    123126        AssertPtr(m_pTransfer->pProvider);
    124127        m_pTransfer->pProvider->AddRef();
    … …  
    130133VBoxClipboardWinDataObject::~VBoxClipboardWinDataObject(void)
    131134{
     135    RTSemEventDestroy(m_EventMetaDataComplete);
     136
    132137    if (m_pTransfer->pProvider)
    133138        m_pTransfer->pProvider->Release();
    … …  
    218223
    219224/**
    220  * Creates a FILEGROUPDESCRIPTOR object from a given Shared Clipboard URI list and stores
    221  * the result into an HGLOBAL object.
     225 * Creates a FILEGROUPDESCRIPTOR object from a given URI transfer and stores the result into an HGLOBAL object.
    222226 *
    223227 * @returns VBox status code.
    224  * @param   URIList             URI list to create object for.
     228 * @param   pTransfer           URI transfer to create file grou desciprtor for.
    225229 * @param   fUnicode            Whether the FILEGROUPDESCRIPTOR object shall contain Unicode data or not.
    226230 * @param   phGlobal            Where to store the allocated HGLOBAL object on success.
    227231 */
    228 int VBoxClipboardWinDataObject::createFileGroupDescriptorFromURIList(const SharedClipboardURIList &URIList,
    229                                                                      bool fUnicode, HGLOBAL *phGlobal)
    230 {
    231     AssertReturn(URIList.GetRootCount(), VERR_INVALID_PARAMETER);
    232     AssertPtrReturn(phGlobal,            VERR_INVALID_POINTER);
     232int VBoxClipboardWinDataObject::createFileGroupDescriptorFromTransfer(PSHAREDCLIPBOARDURITRANSFER pTransfer,
     233                                                                      bool fUnicode, HGLOBAL *phGlobal)
     234{
     235    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
     236    AssertPtrReturn(phGlobal,  VERR_INVALID_POINTER);
    233237
    234238    LogFlowFuncEnter();
     239
     240    SharedClipboardURIList *pURIList = SharedClipboardURITransferGetList(pTransfer);
     241    if (!pURIList)
     242        return VERR_WRONG_ORDER;
    235243
    236244    const size_t cbFileGroupDescriptor = fUnicode ? sizeof(FILEGROUPDESCRIPTORW) : sizeof(FILEGROUPDESCRIPTORA);
    237245    const size_t cbFileDescriptor = fUnicode ? sizeof(FILEDESCRIPTORW) : sizeof(FILEDESCRIPTORA);
    238246
    239     const UINT   cItems = (UINT)URIList.GetRootCount(); /** @todo UINT vs. uint64_t */
     247    const UINT   cItems = (UINT)pURIList->GetRootCount(); /** @todo UINT vs. uint64_t */
    240248    const size_t cbFGD  = cbFileGroupDescriptor + (cbFileDescriptor * (cItems - 1));
    241249
    … …  
    258266        RT_BZERO(pFD, cbFileDescriptor);
    259267
    260         const SharedClipboardURIObject *pObj = URIList.At(i);
     268        const SharedClipboardURIObject *pObj = pURIList->At(i);
    261269        AssertPtr(pObj);
    262270        const char *pszFile = pObj->GetSourcePathAbs().c_str();
    … …  
    373381    HRESULT hr = DV_E_FORMATETC; /* Play safe. */
    374382
    375     LogRel2(("Clipboard: cfFormat=%RI16, sFormat=%s, tyMed=%RU32, dwAspect=%RU32 -> lIndex=%u\n",
     383    LogRel2(("Shared Clipboard: cfFormat=%RI16, sFormat=%s, tyMed=%RU32, dwAspect=%RU32 -> lIndex=%u\n",
    376384             pThisFormat->cfFormat, VBoxClipboardWinDataObject::ClipboardFormatToString(pFormatEtc->cfFormat),
    377385             pThisFormat->tymed, pThisFormat->dwAspect, lIndex));
    … …  
    391399#endif
    392400        {
    393             break;
    394 #if 0
    395             const bool fUnicode = lIndex == FormatIndex_FileDescriptorW;
    396 
    397             LogFlowFunc(("FormatIndex_FileDescriptor%s\n", fUnicode ? "W" : "A"));
    398 
    399             int rc = SharedClipboardURITransferMetaDataRead(m_pTransfer, NULL /* cbRead */);
     401            int rc = SharedClipboardURITransferPrepare(m_pTransfer);
    400402            if (RT_SUCCESS(rc))
    401403            {
    402                 const SharedClipboardURIList *pURIList = SharedClipboardURITransferGetList(m_pTransfer);
    403                 if (    pURIList
    404                     && !pURIList->IsEmpty())
     404                const bool fUnicode = lIndex == FormatIndex_FileDescriptorW;
     405
     406                LogFlowFunc(("FormatIndex_FileDescriptor%s\n", fUnicode ? "W" : "A"));
     407
     408                /* Register needed callbacks so that we can wait for the meta data to arrive here. */
     409                SHAREDCLIPBOARDURITRANSFERCALLBACKS Callbacks;
     410                RT_ZERO(Callbacks);
     411                Callbacks.pfnMetaDataComplete = VBoxClipboardWinDataObject::onMetaDataCompleteCallback;
     412
     413                SharedClipboardURITransferSetCallbacks(m_pTransfer, &Callbacks);
     414
     415                /* Start the transfer asynchronously in a separate thread. */
     416                rc = SharedClipboardURITransferRun(m_pTransfer, true /* fAsync */);
     417                if (RT_SUCCESS(rc))
    405418                {
    406                     HGLOBAL hGlobal;
    407                     rc = createFileGroupDescriptorFromURIList(*pURIList, fUnicode, &hGlobal);
     419                    /* Wait for the meta data to arrive. */
     420                    LogFlowFunc(("Waiting for meta data to arrive ...\n"));
     421                    rc = RTSemEventWait(m_EventMetaDataComplete, 30 * 1000 /* 30s timeout */);
    408422                    if (RT_SUCCESS(rc))
    409423                    {
    410                         pMedium->tymed   = TYMED_HGLOBAL;
    411                         pMedium->hGlobal = hGlobal;
    412                         /* Note: hGlobal now is being owned by pMedium / the caller. */
    413 
    414                         hr = S_OK;
     424                        const SharedClipboardURIList *pURIList = SharedClipboardURITransferGetList(m_pTransfer);
     425                        if (    pURIList
     426                            && !pURIList->IsEmpty())
     427                        {
     428                            HGLOBAL hGlobal;
     429                            rc = createFileGroupDescriptorFromTransfer(m_pTransfer, fUnicode, &hGlobal);
     430                            if (RT_SUCCESS(rc))
     431                            {
     432                                pMedium->tymed   = TYMED_HGLOBAL;
     433                                pMedium->hGlobal = hGlobal;
     434                                /* Note: hGlobal now is being owned by pMedium / the caller. */
     435
     436                                hr = S_OK;
     437                            }
     438                        }
    415439                    }
    416440                }
    417441            }
    418 #endif
    419442            break;
    420443        }
    … …  
    452475
    453476    if (hr == DV_E_FORMATETC)
    454         LogRel(("Clipboard: Error handling format\n"));
     477        LogRel(("Shared Clipboard: Error handling format\n"));
    455478
    456479    LogFlowFunc(("hr=%Rhrc\n", hr));
    … …  
    689712            //&& pFormatEtc->dwAspect == m_pFormatEtc[i].dwAspect)
    690713        {
    691             LogRel3(("Clipboard: Format found: tyMed=%RI32, cfFormat=%RI16, sFormats=%s, dwAspect=%RI32, ulIndex=%RU32\n",
     714            LogRel3(("Shared Clipboard: Format found: tyMed=%RI32, cfFormat=%RI16, sFormats=%s, dwAspect=%RI32, ulIndex=%RU32\n",
    692715                      pFormatEtc->tymed, pFormatEtc->cfFormat, VBoxClipboardWinDataObject::ClipboardFormatToString(m_pFormatEtc[i].cfFormat),
    693716                      pFormatEtc->dwAspect, i));
    … …  
    698721    }
    699722
    700     LogRel3(("Clipboard: Format NOT found: tyMed=%RI32, cfFormat=%RI16, sFormats=%s, dwAspect=%RI32\n",
     723    LogRel3(("Shared Clipboard: Format NOT found: tyMed=%RI32, cfFormat=%RI16, sFormats=%s, dwAspect=%RI32\n",
    701724             pFormatEtc->tymed, pFormatEtc->cfFormat, VBoxClipboardWinDataObject::ClipboardFormatToString(pFormatEtc->cfFormat),
    702725             pFormatEtc->dwAspect));
    … …  
    721744}
    722745
     746/* static */
     747DECLCALLBACK(void) VBoxClipboardWinDataObject::onMetaDataCompleteCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData)
     748{
     749    VBoxClipboardWinDataObject *pThis = (VBoxClipboardWinDataObject *)pData->pvUser;
     750
     751    LogFlowFunc(("pThis=%p\n", pThis));
     752
     753    int rc2 = RTSemEventSignal(pThis->m_EventMetaDataComplete);
     754    AssertRC(rc2);
     755}
     756

  • trunk/src/VBox/GuestHost/SharedClipboard/ClipboardProvider-HostService.cpp

    r79267 r79299  
    5151}
    5252
     53int SharedClipboardProviderHostService::Prepare(void)
     54{
     55    LogFlowFuncEnter();
     56
     57    /*return vboxSvcClipboardReportMsg(,
     58                                     VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, );*/
     59    return 0;
     60}
     61
    5362int SharedClipboardProviderHostService::ReadDataHdr(PVBOXCLIPBOARDDATAHDR *ppDataHdr)
    5463{
    55     RT_NOREF(ppDataHdr);
     64    AssertPtrReturn(ppDataHdr, VERR_INVALID_POINTER);
     65
     66    LogFlowFuncEnter();
     67
    5668    /*return eventWait(VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DATA_HDR, m_Callbacks.pfnReadDataHdr, m_uTimeoutMs,
    5769                     (void **)ppDataHdr);*/
    … …  
    6173int SharedClipboardProviderHostService::WriteDataHdr(const PVBOXCLIPBOARDDATAHDR pDataHdr)
    6274{
    63     RT_NOREF(pDataHdr);
     75    AssertPtrReturn(pDataHdr, VERR_INVALID_POINTER);
    6476
    6577    LogFlowFuncEnter();

  • trunk/src/VBox/GuestHost/SharedClipboard/ClipboardProvider.cpp

    r79267 r79299  
    148148SharedClipboardProvider::SharedClipboardProvider(void)
    149149    : m_cRefs(0)
     150    , m_enmDir(SHAREDCLIPBOARDURITRANSFERDIR_UNKNOWN)
    150151    , m_uTimeoutMs(30 * 1000 /* 30s timeout by default */)
    151152{
    … …  
    178179    {
    179180#ifdef VBOX_WITH_SHARED_CLIPBOARD_GUEST
    180         case SHAREDCLIPBOARDPROVIDERSOURCE_VBGLR3:
     181        case SHAREDCLIPBOARDURIPROVIDERSOURCE_VBGLR3:
    181182            pProvider = new SharedClipboardProviderVbglR3(pCtx->u.VbglR3.uClientID);
    182183            break;
    … …  
    184185
    185186#ifdef VBOX_WITH_SHARED_CLIPBOARD_HOST
    186         case SHAREDCLIPBOARDPROVIDERSOURCE_HOSTSERVICE:
     187        case SHAREDCLIPBOARDURIPROVIDERSOURCE_HOSTSERVICE:
    187188            pProvider = new SharedClipboardProviderHostService(pCtx->u.HostService.pArea);
    188189            break;
    … …  
    245246 * Stubs.
    246247 */
     248
     249int SharedClipboardProvider::Prepare(void)
     250{
     251    return VINF_SUCCESS;
     252}
    247253
    248254int SharedClipboardProvider::ReadDataHdr(PVBOXCLIPBOARDDATAHDR *ppDataHdr)

  • trunk/src/VBox/GuestHost/SharedClipboard/clipboard-uri.cpp

    r79276 r79299  
    637637    pTransfer->cbUser = 0;
    638638
     639    RT_ZERO(pTransfer->Callbacks);
     640
    639641    pTransfer->pURIList = new SharedClipboardURIList();
    640642    if (!pTransfer->pURIList)
    … …  
    708710    LogFlowFuncEnter();
    709711
    710     AssertPtrReturn(pTransfer->State.pMeta, VERR_WRONG_ORDER);
    711     AssertPtrReturn(pTransfer->pURIList,    VERR_WRONG_ORDER);
    712 
    713     PSHAREDCLIPBOARDMETADATA pMeta = pTransfer->State.pMeta;
    714     AssertPtrReturn(pMeta, VERR_WRONG_ORDER);
    715 
    716712    int rc;
    717713
    718714    LogFlowFunc(("enmDir=%RU32\n", pTransfer->State.enmDir));
    719715
     716    if (pTransfer->Callbacks.pfnTransferPrepare)
     717    {
     718        SHAREDCLIPBOARDURITRANSFERCALLBACKDATA callbackData = { pTransfer, pTransfer->Callbacks.pvUser };
     719        pTransfer->Callbacks.pfnTransferPrepare(&callbackData);
     720    }
     721
    720722    if (pTransfer->State.enmDir == SHAREDCLIPBOARDURITRANSFERDIR_READ)
    721723    {
     724        rc = pTransfer->pProvider->Prepare();
     725    #if 0
    722726        rc = pTransfer->pURIList->SetFromURIData(SharedClipboardMetaDataRaw(pMeta),
    723727                                                 SharedClipboardMetaDataGetUsed(pMeta),
    724728                                                 SHAREDCLIPBOARDURILIST_FLAGS_NONE);
    725729        /** @todo Verify pvMetaFmt. */
     730    #endif
    726731
    727732        sharedClipboardURITransferMetaDataDestroyInternal(pTransfer);
    … …  
    729734    else if (pTransfer->State.enmDir == SHAREDCLIPBOARDURITRANSFERDIR_WRITE)
    730735    {
     736        AssertPtrReturn(pTransfer->State.pMeta, VERR_WRONG_ORDER);
     737        AssertPtrReturn(pTransfer->pURIList,    VERR_WRONG_ORDER);
     738
     739        const PSHAREDCLIPBOARDMETADATA pMeta = pTransfer->State.pMeta;
     740
    731741        rc = pTransfer->pURIList->AppendURIPathsFromList((char *)SharedClipboardMetaDataRaw(pMeta),
    732742                                                         SharedClipboardMetaDataGetUsed(pMeta),
    … …  
    947957 * @returns VBox status code.
    948958 * @param   pTransfer           URI clipboard transfer to set callbacks for.
    949  * @param   pCallbacks          Pointer to callback table to set. Specify NULL to unset existing callbacks.
    950  */
    951 void SharedClipboardURITransferSetCallbacks(PSHAREDCLIPBOARDURITRANSFER pTransfer, PSHAREDCLIPBOARDURITRANSFERCALLBACKS pCallbacks)
     959 * @param   pCallbacks          Pointer to callback table to set.
     960 */
     961void SharedClipboardURITransferSetCallbacks(PSHAREDCLIPBOARDURITRANSFER pTransfer,
     962                                            PSHAREDCLIPBOARDURITRANSFERCALLBACKS pCallbacks)
    952963{
    953964    AssertPtrReturnVoid(pTransfer);
    954     /* pCallbacks might be NULL to unset callbacks. */
     965    AssertPtrReturnVoid(pCallbacks);
    955966
    956967    LogFlowFunc(("pCallbacks=%p\n", pCallbacks));
    957968
    958     if (pCallbacks)
    959     {
    960         pTransfer->Callbacks = *pCallbacks;
    961     }
    962     else
    963         RT_ZERO(pTransfer->Callbacks);
     969#define SET_CALLBACK(a_pfnCallback)             \
     970    if (pCallbacks->a_pfnCallback)              \
     971        pTransfer->Callbacks.a_pfnCallback = pCallbacks->a_pfnCallback
     972
     973    SET_CALLBACK(pfnTransferPrepare);
     974    SET_CALLBACK(pfnTransferStarted);
     975    SET_CALLBACK(pfnMetaDataComplete);
     976    SET_CALLBACK(pfnTransferCanceled);
     977    SET_CALLBACK(pfnTransferError);
     978    SET_CALLBACK(pfnTransferStarted);
     979
     980#undef SET_CALLBACK
    964981}
    965982
    … …  
    10331050
    10341051    LogFlowFuncEnter();
     1052
     1053    if (pTransfer->Callbacks.pfnTransferStarted)
     1054    {
     1055        SHAREDCLIPBOARDURITRANSFERCALLBACKDATA callbackData = { pTransfer, pTransfer->Callbacks.pvUser };
     1056        pTransfer->Callbacks.pfnTransferStarted(&callbackData);
     1057    }
    10351058
    10361059    int rc = SharedClipboardURITransferMetaDataRead(pTransfer, NULL /* pcbRead */);
    … …  
    12341257{
    12351258    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
     1259    /* pcbRead is optional. */
    12361260
    12371261    LogFlowFuncEnter();
    … …  
    12501274        if (pvMeta)
    12511275        {
     1276            AssertPtr(pTransfer->State.pHeader);
    12521277            uint32_t cbMetaToRead = pTransfer->State.pHeader->cbMeta;
    12531278            while (cbMetaToRead)
    … …  
    12731298                if (pcbRead)
    12741299                    *pcbRead = cbReadTotal;
     1300
     1301                if (pTransfer->Callbacks.pfnMetaDataComplete)
     1302                {
     1303                    SHAREDCLIPBOARDURITRANSFERCALLBACKDATA callbackData = { pTransfer, pTransfer->Callbacks.pvUser };
     1304                    pTransfer->Callbacks.pfnMetaDataComplete(&callbackData);
     1305                }
    12751306            }
    12761307        }
    … …  
    12931324{
    12941325    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
     1326    /* pcbWritten is optional. */
    12951327
    12961328    AssertPtr(pTransfer->pProvider);
    … …  
    13291361            if (pcbWritten)
    13301362                *pcbWritten = cbWrittenTotal;
     1363
     1364            if (pTransfer->Callbacks.pfnMetaDataComplete)
     1365            {
     1366                SHAREDCLIPBOARDURITRANSFERCALLBACKDATA callbackData = { pTransfer, pTransfer->Callbacks.pvUser };
     1367                pTransfer->Callbacks.pfnMetaDataComplete(&callbackData);
     1368            }
    13311369        }
    13321370    }
    … …  
    14931531    LogFlowFuncEnter();
    14941532
     1533    if (pTransfer->Callbacks.pfnTransferStarted)
     1534    {
     1535        SHAREDCLIPBOARDURITRANSFERCALLBACKDATA callbackData = { pTransfer, pTransfer->Callbacks.pvUser };
     1536        pTransfer->Callbacks.pfnTransferStarted(&callbackData);
     1537    }
     1538
    14951539    int rc = SharedClipboardURITransferMetaDataWrite(pTransfer, NULL /* pcbWritten */);
    14961540    if (RT_SUCCESS(rc))

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

    r79276 r79299  
    9797
    9898/**
     99 * Reads an URI data header from HGCM service parameters.
     100 *
     101 * @returns VBox status code.
     102 * @param   cParms              Number of HGCM parameters supplied in \a paParms.
     103 * @param   paParms             Array of HGCM parameters.
     104 * @param   pDataHdr            Pointer to data to write the the HGCM parameters.
     105 */
     106int VBoxSvcClipboardURIWriteDataHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDATAHDR pDataHdr)
     107{
     108    int rc;
     109
     110    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_READ_DATA_HDR)
     111    {
     112        /** @todo Set pvMetaFmt + cbMetaFmt. */
     113        /** @todo Calculate header checksum. */
     114
     115        /* Note: Context ID (paParms[0]) not used yet. */
     116        HGCMSvcSetU32(&paParms[1],  pDataHdr->uFlags);
     117        HGCMSvcSetU32(&paParms[2],  pDataHdr->uScreenId);
     118        HGCMSvcSetU64(&paParms[3],  pDataHdr->cbTotal);
     119        HGCMSvcSetU32(&paParms[4],  pDataHdr->cbMeta);
     120        HGCMSvcSetU32(&paParms[5],  pDataHdr->cbMetaFmt);
     121        HGCMSvcSetPv (&paParms[6],  pDataHdr->pvMetaFmt, pDataHdr->cbMetaFmt);
     122        HGCMSvcSetU64(&paParms[7],  pDataHdr->cObjects);
     123        HGCMSvcSetU32(&paParms[8],  pDataHdr->enmCompression);
     124        HGCMSvcSetU32(&paParms[9],  (uint32_t)pDataHdr->enmChecksumType);
     125        HGCMSvcSetU32(&paParms[10], pDataHdr->cbChecksum);
     126        HGCMSvcSetPv (&paParms[11], pDataHdr->pvChecksum, pDataHdr->cbChecksum);
     127
     128        LogFlowFunc(("fFlags=0x%x, cbMeta=%RU32, cbTotalSize=%RU64, cObj=%RU64\n",
     129                     pDataHdr->uFlags, pDataHdr->cbMeta, pDataHdr->cbTotal, pDataHdr->cObjects));
     130
     131        rc = VINF_SUCCESS;
     132    }
     133    else
     134        rc = VERR_INVALID_PARAMETER;
     135
     136    LogFlowFuncLeaveRC(rc);
     137    return rc;
     138}
     139
     140/**
    99141 * Reads an URI data chunk from HGCM service parameters.
    100142 *
    … …  
    133175
    134176/**
     177 * Writes an URI data chunk to HGCM service parameters.
     178 *
     179 * @returns VBox status code.
     180 * @param   cParms              Number of HGCM parameters supplied in \a paParms.
     181 * @param   paParms             Array of HGCM parameters.
     182 * @param   pDataChunk          Pointer to data to write the the HGCM parameters.
     183 */
     184int VBoxSvcClipboardURIWriteDataChunk(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDATACHUNK pDataChunk)
     185{
     186    int rc;
     187
     188    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_READ_DATA_CHUNK)
     189    {
     190        /** @todo Calculate chunk checksum. */
     191
     192        /* Note: Context ID (paParms[0]) not used yet. */
     193        HGCMSvcSetU32(&paParms[1], pDataChunk->cbData);
     194        HGCMSvcSetPv (&paParms[2], pDataChunk->pvData, pDataChunk->cbData);
     195        HGCMSvcSetU32(&paParms[3], pDataChunk->cbChecksum);
     196        HGCMSvcSetPv (&paParms[4], pDataChunk->pvChecksum, pDataChunk->cbChecksum);
     197
     198        rc = VINF_SUCCESS;
     199    }
     200    else
     201        rc = VERR_INVALID_PARAMETER;
     202
     203    LogFlowFuncLeaveRC(rc);
     204    return rc;
     205}
     206
     207/**
    135208 * Reads an URI directory entry from HGCM service parameters.
    136209 *
    … …  
    169242
    170243/**
     244 * Writes an URI directory entry to HGCM service parameters.
     245 *
     246 * @returns VBox status code.
     247 * @param   cParms              Number of HGCM parameters supplied in \a paParms.
     248 * @param   paParms             Array of HGCM parameters.
     249 * @param   pDirData            Pointer to data to write the the HGCM parameters.
     250 */
     251int VBoxSvcClipboardURIWriteDir(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDIRDATA pDirData)
     252{
     253    int rc;
     254
     255    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_READ_DIR)
     256    {
     257        /* Note: Context ID (paParms[0]) not used yet. */
     258        HGCMSvcSetU32(&paParms[1], pDirData->cbPath);
     259        HGCMSvcSetPv (&paParms[2], pDirData->pszPath, pDirData->cbPath);
     260        HGCMSvcSetU32(&paParms[3], pDirData->fMode);
     261
     262        rc = VINF_SUCCESS;
     263    }
     264    else
     265        rc = VERR_INVALID_PARAMETER;
     266
     267    LogFlowFuncLeaveRC(rc);
     268    return rc;
     269}
     270
     271/**
    171272 * Reads an URI file header from HGCM service parameters.
    172273 *
    … …  
    204305
    205306/**
     307 * Writes an URI file header to HGCM service parameters.
     308 *
     309 * @returns VBox status code.
     310 * @param   cParms              Number of HGCM parameters supplied in \a paParms.
     311 * @param   paParms             Array of HGCM parameters.
     312 * @param   pFileHdr            Pointer to data to write the the HGCM parameters.
     313 */
     314int VBoxSvcClipboardURIWriteFileHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEHDR pFileHdr)
     315{
     316    int rc;
     317
     318    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_READ_FILE_HDR)
     319    {
     320        /* Note: Context ID (paParms[0]) not used yet. */
     321        HGCMSvcSetU32(&paParms[1], pFileHdr->cbFilePath);
     322        HGCMSvcSetPv (&paParms[2], pFileHdr->pszFilePath, pFileHdr->cbFilePath);
     323        HGCMSvcSetU32(&paParms[3], pFileHdr->fFlags);
     324        HGCMSvcSetU32(&paParms[4], pFileHdr->fMode);
     325        HGCMSvcSetU64(&paParms[5], pFileHdr->cbSize);
     326
     327        rc = VINF_SUCCESS;
     328    }
     329    else
     330        rc = VERR_INVALID_PARAMETER;
     331
     332    LogFlowFuncLeaveRC(rc);
     333    return rc;
     334}
     335
     336/**
    206337 * Reads an URI file data chunk from HGCM service parameters.
    207338 *
    … …  
    227358
    228359        LogFlowFunc(("pvData=0x%p, cbData=%RU32\n", pFileData->pvData, pFileData->cbData));
     360    }
     361    else
     362        rc = VERR_INVALID_PARAMETER;
     363
     364    LogFlowFuncLeaveRC(rc);
     365    return rc;
     366}
     367
     368/**
     369 * Writes an URI file data chunk to HGCM service parameters.
     370 *
     371 * @returns VBox status code.
     372 * @param   cParms              Number of HGCM parameters supplied in \a paParms.
     373 * @param   paParms             Array of HGCM parameters.
     374 * @param   pFileData           Pointer to data to write the the HGCM parameters.
     375 */
     376int VBoxSvcClipboardURIWriteFileData(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEDATA pFileData)
     377{
     378    int rc;
     379
     380    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_READ_FILE_DATA)
     381    {
     382        /* Note: Context ID (paParms[0]) not used yet. */
     383        HGCMSvcSetU32(&paParms[1], pFileData->cbData);
     384        HGCMSvcSetPv (&paParms[2], pFileData->pvData, pFileData->cbData);
     385        HGCMSvcSetU32(&paParms[3], pFileData->cbChecksum);
     386        HGCMSvcSetPv (&paParms[4], pFileData->pvChecksum, pFileData->cbChecksum);
     387
     388        rc = VINF_SUCCESS;
    229389    }
    230390    else
    … …  
    293453    }
    294454
    295     bool fDispatchToProvider = false; /* Whether to (also) dispatch the HGCM data to the transfer provider. */
     455    bool fWriteToProvider = false; /* Whether to (also) dispatch the HGCM data to the transfer provider. */
    296456
    297457    int rc = VERR_INVALID_PARAMETER; /* Play safe. */
    … …  
    597757    }
    598758
    599     if (fDispatchToProvider)
     759    if (fWriteToProvider)
    600760        rc = VINF_SUCCESS;
    601761
    602762    if (RT_SUCCESS(rc))
    603763    {
    604         if (fDispatchToProvider)
     764        if (fWriteToProvider)
    605765        {
    606766            SHAREDCLIPBOARDPROVIDERWRITEPARMS writeParms;

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

    r79269 r79299  
    128128 * @param   pCtx                Clipboard context to use.
    129129 * @param   fFormat             Format to receive data in.
    130  * @param   uTimeoutMs          Timeout (in ms). Specify 0 if no waiting is required.
     130 * @param   uTimeoutMs          Timeout (in ms) to wait until the render event has been triggered.
     131 *                              Specify 0 if no waiting is required.
    131132 */
    132133static int vboxClipboardWinRequestData(PVBOXCLIPBOARDCONTEXT pCtx, VBOXCLIPBOARDFORMAT fFormat,
    … …  
    328329                        {
    329330                            rc = VBoxClipboardWinURIAnnounce(pWinCtx, &pCtx->pClientData->URI, pTransfer);
    330                             if (RT_SUCCESS(rc))
    331                             {
    332                                 rc = vboxClipboardWinRequestData(pCtx, fFormats, 0 /* Waiting not required */); /** FIX !!!!!!!!!!!! NEEDS TO GO INTO IDATAOBJECT GetData() !!!! */
    333                             }
     331
     332                            /* Note: The actual requesting + retrieving of data will be done in the IDataObject implementation
     333                                     (ClipboardDataObjectImpl::GetData()). */
    334334                        }
    335335                        else

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

    r79275 r79299  
    638638                                        SHAREDCLIPBOARDPROVIDERCREATIONCTX creationCtx;
    639639                                        RT_ZERO(creationCtx);
    640                                         creationCtx.enmSource = SHAREDCLIPBOARDPROVIDERSOURCE_HOSTSERVICE;
     640                                        creationCtx.enmSource = SHAREDCLIPBOARDURIPROVIDERSOURCE_HOSTSERVICE;
     641                                        creationCtx.enmDir    = SHAREDCLIPBOARDURITRANSFERDIR_READ;
    641642                                        creationCtx.u.HostService.pArea = pTransfer->pArea;
    642643
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