VirtualBox

Changeset 79366 in vbox for trunk/src/VBox


Ignore:
Timestamp:
Jun 26, 2019 3:59:30 PM (6 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
131600
Message:

Shared Clipboard/URI: Update.

Location:
trunk/src/VBox
Files:
9 edited

Legend:

Unmodified
Added
Removed

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

    r79347 r79366  
    596596
    597597                        PSHAREDCLIPBOARDURITRANSFER pTransfer;
    598                         rc = SharedClipboardURITransferCreate(SHAREDCLIPBOARDURITRANSFERDIR_READ, &pTransfer);
     598                        rc = SharedClipboardURITransferCreate(SHAREDCLIPBOARDURITRANSFERDIR_READ,
     599                                                              SHAREDCLIPBOARDSOURCE_REMOTE,
     600                                                              &pTransfer);
    599601                        if (RT_SUCCESS(rc))
    600602                        {
    … …  
    620622
    621623                            creationCtx.pvUser = pCtx;
    622 
    623                             creationCtx.u.VbglR3.uClientID = pCtx->u32ClientID;
    624624
    625625                            rc = SharedClipboardURITransferProviderCreate(pTransfer, &creationCtx);
    … …  
    728728
    729729                    PSHAREDCLIPBOARDURITRANSFER pTransfer;
    730                     rc = SharedClipboardURITransferCreate(SHAREDCLIPBOARDURITRANSFERDIR_WRITE, &pTransfer);
     730                    rc = SharedClipboardURITransferCreate(SHAREDCLIPBOARDURITRANSFERDIR_WRITE,
     731                                                          SHAREDCLIPBOARDSOURCE_LOCAL,
     732                                                          &pTransfer);
    731733                    if (RT_SUCCESS(rc))
    732734                    {
    … …  
    743745                        RT_ZERO(creationCtx);
    744746                        creationCtx.enmSource          = SHAREDCLIPBOARDSOURCE_LOCAL;
    745                         creationCtx.u.VbglR3.uClientID = pCtx->u32ClientID;
     747
     748                        RT_ZERO(creationCtx.Interface);
     749                        creationCtx.Interface.pfnWriteDataHdr   = vboxClipboardURIWriteDataHdr;
     750                        creationCtx.Interface.pfnWriteDataChunk = vboxClipboardURIWriteDataChunk;
     751                        creationCtx.Interface.pfnWriteDirectory = vboxClipboardURIWriteDir;
     752                        creationCtx.Interface.pfnWriteFileHdr   = vboxClipboardURIWriteFileHdr;
     753                        creationCtx.Interface.pfnWriteFileData  = vboxClipboardURIWriteFileData;
     754
     755                        creationCtx.pvUser = pCtx;
    746756
    747757                        rc = SharedClipboardURITransferProviderCreate(pTransfer, &creationCtx);

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

    r79347 r79366  
    421421                    }
    422422                }
     423
     424                if (RT_FAILURE(rc))
     425                    LogRel(("Shared Clipboard: Data object unable to receive meta data, rc=%Rrc\n", rc));
    423426            }
    424427            break;

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

    r79276 r79366  
    487487    AssertReturn(!(fFlags & ~SHAREDCLIPBOARDURILIST_FLAGS_VALID_MASK), VERR_INVALID_FLAGS);
    488488
    489     if (!RTStrIsValidEncoding(static_cast<const char *>(pvData)))
    490         return VERR_INVALID_PARAMETER;
    491 
    492489    RTCList<RTCString> lstURI =
    493490        RTCString(static_cast<const char *>(pvData), cbData - 1).split("\r\n");

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

    r79347 r79366  
    2020
    2121#include <iprt/path.h>
     22#include <iprt/semaphore.h>
    2223
    2324#include <VBox/err.h>
    … …  
    3637
    3738
     39/**
     40 * Allocates a VBOXCLIPBOARDDATAHDR structure.
     41 *
     42 * @returns VBox status code.
     43 * @param   ppDataChunk         Where to store the allocated VBOXCLIPBOARDDATAHDR structure on success.
     44 */
    3845int SharedClipboardURIDataHdrAlloc(PVBOXCLIPBOARDDATAHDR *ppDataHdr)
    3946{
    … …  
    4855        {
    4956            char *pszFmt = NULL;
    50             rc = RTStrAAppend(&pszFmt, "VBoxShClURIList");
     57            rc = RTStrAAppend(&pszFmt, "VBoxShClURIList"); /** @todo Make this more flexible. Later. */
    5158            if (RT_SUCCESS(rc))
    5259            {
    … …  
    245252
    246253/**
     254 * Duplicates (allocates) a VBOXCLIPBOARDDATACHUNK structure.
     255 *
     256 * @returns Duplicated VBOXCLIPBOARDDATACHUNK structure on success.
     257 * @param   pDataChunk          VBOXCLIPBOARDDATACHUNK to duplicate.
     258 */
     259PVBOXCLIPBOARDDATACHUNK SharedClipboardURIDataChunkDup(PVBOXCLIPBOARDDATACHUNK pDataChunk)
     260{
     261    AssertPtrReturn(pDataChunk, NULL);
     262
     263    PVBOXCLIPBOARDDATACHUNK pDataChunkDup = (PVBOXCLIPBOARDDATACHUNK)RTMemAlloc(sizeof(VBOXCLIPBOARDDATACHUNK));
     264    if (pDataChunkDup)
     265    {
     266        *pDataChunkDup = *pDataChunk;
     267
     268        if (pDataChunk->pvData)
     269        {
     270            pDataChunkDup->pvData = RTMemDup(pDataChunk->pvData, pDataChunk->cbData);
     271            pDataChunkDup->cbData = pDataChunk->cbData;
     272        }
     273
     274        if (pDataChunk->pvChecksum)
     275        {
     276            pDataChunkDup->pvChecksum = RTMemDup(pDataChunk->pvChecksum, pDataChunk->cbChecksum);
     277            pDataChunkDup->cbChecksum = pDataChunk->cbChecksum;
     278        }
     279    }
     280
     281    return pDataChunkDup;
     282}
     283
     284/**
    247285 * Initializes a VBOXCLIPBOARDDATACHUNK structure.
    248286 *
    … …  
    662700
    663701    pTransfer->pURIList = new SharedClipboardURIList();
    664     if (!pTransfer->pURIList)
     702    if (pTransfer->pURIList)
     703    {
     704        pTransfer->Events.pMap = new SharedClipboardURITransferEventMap();
     705        if (pTransfer->Events.pMap)
     706        {
     707            rc = SharedClipboardURIObjCtxInit(&pTransfer->State.ObjCtx);
     708            if (RT_SUCCESS(rc))
     709            {
     710                *ppTransfer = pTransfer;
     711            }
     712        }
     713        else
     714            rc = VERR_NO_MEMORY;
     715    }
     716    else
     717        rc = VERR_NO_MEMORY;
     718
     719    if (RT_FAILURE(rc))
    665720    {
    666721        RTMemFree(pTransfer);
    667         return VERR_NO_MEMORY;
    668     }
    669 
    670     rc = SharedClipboardURIObjCtxInit(&pTransfer->State.ObjCtx);
    671     if (RT_SUCCESS(rc))
    672     {
    673         *ppTransfer = pTransfer;
    674722    }
    675723
    … …  
    704752    }
    705753
     754    if (pTransfer->Events.pMap)
     755    {
     756        delete pTransfer->Events.pMap;
     757        pTransfer->Events.pMap = NULL;
     758    }
     759
    706760    SharedClipboardURIObjCtxDestroy(&pTransfer->State.ObjCtx);
    707761
    … …  
    727781
    728782    int rc = VINF_SUCCESS;
     783
     784    AssertMsgReturn(pTransfer->State.enmStatus == SHAREDCLIPBOARDURITRANSFERSTATUS_NONE,
     785                    ("Transfer has wrong state (%RU32)\n", pTransfer->State.enmStatus), VERR_WRONG_ORDER);
    729786
    730787    LogFlowFunc(("pTransfer=%p, enmDir=%RU32\n", pTransfer, pTransfer->State.enmDir));
    … …  
    798855    if (RT_SUCCESS(rc))
    799856    {
     857        pTransfer->State.enmStatus = SHAREDCLIPBOARDURITRANSFERSTATUS_READY;
     858
    800859        /** @todo Add checksum support. */
    801860    }
    … …  
    10051064}
    10061065
    1007 int SharedClipboardURITransferSetDataHeader(PSHAREDCLIPBOARDURITRANSFER pTransfer, PVBOXCLIPBOARDDATAHDR pDataHdr)
    1008 {
    1009     AssertReturn(pTransfer->State.pHeader == NULL, VERR_WRONG_ORDER);
    1010 
    1011     LogFlowFuncEnter();
    1012 
     1066int SharedClipboardURITransferPayloadAlloc(uint32_t uID, const void *pvData, uint32_t cbData,
     1067                                           PSHAREDCLIPBOARDURITRANSFERPAYLOAD *ppPayload)
     1068{
     1069    PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload =
     1070        (PSHAREDCLIPBOARDURITRANSFERPAYLOAD)RTMemAlloc(sizeof(SHAREDCLIPBOARDURITRANSFERPAYLOAD));
     1071    if (!pPayload)
     1072        return VERR_NO_MEMORY;
     1073
     1074    pPayload->pvData = RTMemAlloc(cbData);
     1075    if (pPayload->pvData)
     1076    {
     1077        memcpy(pPayload->pvData, pvData, cbData);
     1078
     1079        pPayload->cbData = cbData;
     1080        pPayload->uID    = uID;
     1081
     1082        *ppPayload = pPayload;
     1083
     1084        return VINF_SUCCESS;
     1085    }
     1086
     1087    RTMemFree(pPayload);
     1088    return VERR_NO_MEMORY;
     1089}
     1090
     1091void SharedClipboardURITransferPayloadFree(PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload)
     1092{
     1093    if (!pPayload)
     1094        return;
     1095
     1096    if (pPayload->pvData)
     1097    {
     1098        Assert(pPayload->cbData);
     1099        RTMemFree(pPayload->pvData);
     1100        pPayload->pvData = NULL;
     1101    }
     1102
     1103    pPayload->cbData = 0;
     1104
     1105    RTMemFree(pPayload);
     1106    pPayload = NULL;
     1107}
     1108
     1109int SharedClipboardURITransferEventRegister(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint32_t uID)
     1110{
    10131111    int rc;
    10141112
    1015     pTransfer->State.pHeader = SharedClipboardURIDataHdrDup(pDataHdr);
    1016     if (pTransfer->State.pHeader)
    1017     {
    1018         LogFlowFunc(("Meta data size is %RU32, total size is %RU64, %RU64 objects\n",
    1019                      pTransfer->State.pHeader->cbMeta, pTransfer->State.pHeader->cbTotal,
    1020                      pTransfer->State.pHeader->cObjects));
     1113    SharedClipboardURITransferEventMap::iterator itEvent = pTransfer->Events.pMap->find(uID);
     1114    if (itEvent == pTransfer->Events.pMap->end())
     1115    {
     1116        PSHAREDCLIPBOARDURITRANSFEREVENT pEvent
     1117            = (PSHAREDCLIPBOARDURITRANSFEREVENT)RTMemAllocZ(sizeof(SHAREDCLIPBOARDURITRANSFEREVENT));
     1118        if (pEvent)
     1119        {
     1120            rc = RTSemEventCreate(&pEvent->hEventSem);
     1121            if (RT_SUCCESS(rc))
     1122            {
     1123                pTransfer->Events.pMap->insert(std::pair<uint32_t, PSHAREDCLIPBOARDURITRANSFEREVENT>(uID, pEvent)); /** @todo Can this throw? */
     1124            }
     1125        }
     1126        else
     1127            rc = VERR_NO_MEMORY;
     1128    }
     1129    else
     1130        rc = VERR_ALREADY_EXISTS;
     1131
     1132    LogFlowFuncLeaveRC(rc);
     1133    return rc;
     1134}
     1135
     1136int SharedClipboardURITransferEventUnregister(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint32_t uID)
     1137{
     1138    int rc;
     1139
     1140    SharedClipboardURITransferEventMap::const_iterator itEvent = pTransfer->Events.pMap->find(uID);
     1141    if (itEvent != pTransfer->Events.pMap->end())
     1142    {
     1143        SharedClipboardURITransferPayloadFree(itEvent->second->pPayload);
     1144
     1145        RTSemEventDestroy(itEvent->second->hEventSem);
     1146
     1147        RTMemFree(itEvent->second);
     1148
     1149        pTransfer->Events.pMap->erase(itEvent);
    10211150
    10221151        rc = VINF_SUCCESS;
    1023 
    1024         if (pTransfer->Callbacks.pfnDataHeaderComplete)
    1025         {
    1026             SHAREDCLIPBOARDURITRANSFERCALLBACKDATA callbackData = { pTransfer, pTransfer->Callbacks.pvUser };
    1027             pTransfer->Callbacks.pfnDataHeaderComplete(&callbackData);
    1028         }
    10291152    }
    10301153    else
    1031         rc = VERR_NO_MEMORY;
    1032 
    1033     LogFlowFuncLeaveRC(rc);
    1034     return rc;
    1035 }
    1036 
    1037 int SharedClipboardURITransferSetDataChunk(PSHAREDCLIPBOARDURITRANSFER pTransfer, PVBOXCLIPBOARDDATACHUNK pDataChunk)
    1038 {
    1039     LogFlowFuncEnter();
    1040 
    1041     AssertPtrReturn(pTransfer->State.pHeader, VERR_WRONG_ORDER);
    1042 
    1043     int rc = SharedClipboardURITransferMetaDataAdd(pTransfer, pDataChunk->pvData, pDataChunk->cbData);
     1154        rc = VERR_NOT_FOUND;
     1155
     1156    LogFlowFuncLeaveRC(rc);
     1157    return rc;
     1158}
     1159
     1160int SharedClipboardURITransferEventWait(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint32_t uID, RTMSINTERVAL uTimeoutMs,
     1161                                        PSHAREDCLIPBOARDURITRANSFERPAYLOAD *ppPayload)
     1162{
     1163    LogFlowFuncEnter();
     1164
     1165    int rc;
     1166
     1167    SharedClipboardURITransferEventMap::const_iterator itEvent = pTransfer->Events.pMap->find(uID);
     1168    if (itEvent != pTransfer->Events.pMap->end())
     1169    {
     1170        rc = RTSemEventWait(itEvent->second->hEventSem, uTimeoutMs);
     1171        if (RT_SUCCESS(rc))
     1172        {
     1173            *ppPayload = itEvent->second->pPayload;
     1174
     1175            itEvent->second->pPayload = NULL;
     1176        }
     1177    }
     1178    else
     1179        rc = VERR_NOT_FOUND;
     1180
     1181    LogFlowFuncLeaveRC(rc);
     1182    return rc;
     1183}
     1184
     1185int SharedClipboardURITransferEventSignal(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint32_t uID,
     1186                                          PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload)
     1187{
     1188    int rc;
     1189
     1190    SharedClipboardURITransferEventMap::const_iterator itEvent = pTransfer->Events.pMap->find(uID);
     1191    if (itEvent != pTransfer->Events.pMap->end())
     1192    {
     1193        Assert(itEvent->second->pPayload == NULL);
     1194
     1195        itEvent->second->pPayload = pPayload;
     1196
     1197        rc = RTSemEventSignal(itEvent->second->hEventSem);
     1198    }
     1199    else
     1200        rc = VERR_NOT_FOUND;
    10441201
    10451202    LogFlowFuncLeaveRC(rc);
    … …  
    11171274    LogFlowFuncEnter();
    11181275
    1119     AssertMsgReturn(pTransfer->State.enmStatus == SHAREDCLIPBOARDURITRANSFERSTATUS_RUNNING,
    1120                     ("Transfer already is running\n"), VERR_WRONG_ORDER);
     1276    AssertMsgReturn(pTransfer->State.enmStatus == SHAREDCLIPBOARDURITRANSFERSTATUS_READY,
     1277                    ("Read transfer has wrong state (%RU32)\n", pTransfer->State.enmStatus), VERR_WRONG_ORDER);
    11211278
    11221279    pTransfer->State.enmStatus = SHAREDCLIPBOARDURITRANSFERSTATUS_RUNNING;
    … …  
    11661323
    11671324    PVBOXCLIPBOARDDIRDATA pDirData;
     1325    AssertPtr(pTransfer->ProviderIface.pfnReadDirectory);
    11681326    int rc = pTransfer->ProviderIface.pfnReadDirectory(&pTransfer->ProviderCtx, &pDirData);
    11691327    if (RT_SUCCESS(rc))
    … …  
    11851343
    11861344    PVBOXCLIPBOARDFILEHDR pFileHdr;
     1345    AssertPtr(pTransfer->ProviderIface.pfnReadFileHdr);
    11871346    int rc = pTransfer->ProviderIface.pfnReadFileHdr(&pTransfer->ProviderCtx, &pFileHdr);
    11881347    if (RT_SUCCESS(rc))
    … …  
    11961355        while (cbToRead)
    11971356        {
     1357            AssertPtr(pTransfer->ProviderIface.pfnReadFileData);
    11981358            rc = pTransfer->ProviderIface.pfnReadFileData(&pTransfer->ProviderCtx,
    11991359                                                          pvBuf, cbBuf, 0 /* fFlags */, &cbRead);
    … …  
    12231383
    12241384    PVBOXCLIPBOARDOBJHDR pObjHdr;
     1385    AssertPtr(pTransfer->ProviderIface.pfnReadObjHdr);
    12251386    int rc = pTransfer->ProviderIface.pfnReadObjHdr(&pTransfer->ProviderCtx, &pObjHdr);
    12261387    if (RT_SUCCESS(rc))
    … …  
    13851546    LogFlowFunc(("pvMeta=%p, cbMeta=%RU32\n", pvMeta, cbMeta));
    13861547
     1548    AssertPtrReturn(pTransfer->State.pHeader, VERR_WRONG_ORDER); /* Header must be present. */
     1549    AssertReturn(SharedClipboardMetaDataGetUsed(pTransfer->State.pMeta) + cbMeta <= pTransfer->State.pHeader->cbMeta,
     1550                 VERR_BUFFER_OVERFLOW);
     1551
    13871552    int rc = SharedClipboardMetaDataAdd(pTransfer->State.pMeta, pvMeta, cbMeta);
    13881553
    … …  
    14461611    uint32_t cbReadTotal = 0;
    14471612
     1613    AssertPtr(pTransfer->ProviderIface.pfnReadDataHdr);
    14481614    int rc = pTransfer->ProviderIface.pfnReadDataHdr(&pTransfer->ProviderCtx, &pTransfer->State.pHeader);
    14491615    if (RT_SUCCESS(rc))
    14501616    {
    1451         uint32_t cbMeta = _4K; /** @todo Improve. */
    1452         void    *pvMeta = RTMemAlloc(cbMeta);
     1617        if (pTransfer->Callbacks.pfnDataHeaderComplete)
     1618        {
     1619            SHAREDCLIPBOARDURITRANSFERCALLBACKDATA callbackData = { pTransfer, pTransfer->Callbacks.pvUser };
     1620            pTransfer->Callbacks.pfnDataHeaderComplete(&callbackData);
     1621        }
     1622
     1623        uint32_t cbMetaToRead = pTransfer->State.pHeader->cbMeta;
     1624
     1625        uint32_t cbMeta = cbMetaToRead;
     1626        void    *pvMeta = RTMemAlloc(cbMetaToRead);
    14531627
    14541628        if (pvMeta)
    14551629        {
    14561630            AssertPtr(pTransfer->State.pHeader);
    1457             uint32_t cbMetaToRead = pTransfer->State.pHeader->cbMeta;
    14581631            while (cbMetaToRead)
    14591632            {
     1633                const uint32_t cbToRead = RT_MIN(cbMetaToRead, cbMeta);
     1634
    14601635                uint32_t cbMetaRead;
     1636                AssertPtr(pTransfer->ProviderIface.pfnReadDataChunk);
    14611637                rc = pTransfer->ProviderIface.pfnReadDataChunk(&pTransfer->ProviderCtx,
    1462                                                                pTransfer->State.pHeader, pvMeta, cbMeta, 0 /* fFlags */,
    1463                                                                &cbMetaRead);
     1638                                                               pTransfer->State.pHeader, pvMeta, cbToRead,
     1639                                                               0 /* fFlags */, &cbMetaRead);
    14641640                if (RT_SUCCESS(rc))
    1465                     rc = sharedClipboardURITransferMetaDataAddInternal(pTransfer, pvMeta, cbMeta);
     1641                    rc = SharedClipboardURITransferMetaDataAdd(pTransfer, pvMeta, cbMetaRead);
    14661642
    14671643                if (RT_FAILURE(rc))
    … …  
    14711647                cbMetaToRead -= cbMetaRead;
    14721648
    1473                 cbReadTotal += cbReadTotal;
     1649                cbReadTotal += cbMetaRead;
    14741650            }
    14751651
    … …  
    14781654            if (RT_SUCCESS(rc))
    14791655            {
     1656                rc = pTransfer->pURIList->SetFromURIData(SharedClipboardMetaDataMutableRaw(pTransfer->State.pMeta),
     1657                                                         SharedClipboardMetaDataGetUsed(pTransfer->State.pMeta),
     1658                                                         SHAREDCLIPBOARDURILIST_FLAGS_NONE);
     1659                if (   RT_SUCCESS(rc)
     1660                    && pTransfer->Callbacks.pfnDataComplete)
     1661                {
     1662                    SHAREDCLIPBOARDURITRANSFERCALLBACKDATA callbackData = { pTransfer, pTransfer->Callbacks.pvUser };
     1663                    pTransfer->Callbacks.pfnDataComplete(&callbackData);
     1664                }
     1665
    14801666                if (pcbRead)
    14811667                    *pcbRead = cbReadTotal;
    … …  
    15091695    uint32_t cbWrittenTotal = 0;
    15101696
     1697    AssertPtr(pTransfer->ProviderIface.pfnWriteDataHdr);
    15111698    int rc = pTransfer->ProviderIface.pfnWriteDataHdr(&pTransfer->ProviderCtx, pTransfer->State.pHeader);
    15121699    if (RT_SUCCESS(rc))
    … …  
    15191706        {
    15201707            uint32_t cbMetaWritten;
     1708            AssertPtr(pTransfer->ProviderIface.pfnWriteDataChunk);
    15211709            rc = pTransfer->ProviderIface.pfnWriteDataChunk(&pTransfer->ProviderCtx, pTransfer->State.pHeader,
    15221710                                                            (uint8_t *)pTransfer->State.pMeta->pvMeta + cbWrittenTotal,
    … …  
    15841772                dirData.cbPath  = (uint32_t)strlen(dirData.pszPath);
    15851773
     1774                AssertPtr(pTransfer->ProviderIface.pfnWriteDirectory);
    15861775                rc = pTransfer->ProviderIface.pfnWriteDirectory(&pTransfer->ProviderCtx, &dirData);
    15871776
    … …  
    16081797                fileHdr.fMode       = pObj->GetMode();
    16091798
     1799                AssertPtr(pTransfer->ProviderIface.pfnWriteFileHdr);
    16101800                rc = pTransfer->ProviderIface.pfnWriteFileHdr(&pTransfer->ProviderCtx, &fileHdr);
    16111801                SharedClipboardURIFileHdrDestroy(&fileHdr);
    … …  
    16261816                    {
    16271817                        uint32_t cbToRead = cbRead;
     1818                        AssertPtr(pTransfer->ProviderIface.pfnWriteFileData);
    16281819                        rc = pTransfer->ProviderIface.pfnWriteFileData(&pTransfer->ProviderCtx,
    16291820                                                                       pvData, cbToRead, 0 /* fFlags */, &cbRead);
    … …  
    17051896    LogFlowFuncEnter();
    17061897
    1707     AssertMsgReturn(pTransfer->State.enmStatus == SHAREDCLIPBOARDURITRANSFERSTATUS_RUNNING,
    1708                     ("Transfer already is running\n"), VERR_WRONG_ORDER);
     1898    AssertMsgReturn(pTransfer->State.enmStatus == SHAREDCLIPBOARDURITRANSFERSTATUS_READY,
     1899                    ("Write transfer has wrong state (%RU32)\n", pTransfer->State.enmStatus), VERR_WRONG_ORDER);
    17091900
    17101901    pTransfer->State.enmStatus = SHAREDCLIPBOARDURITRANSFERSTATUS_RUNNING;
    … …  
    17941985    }
    17951986
    1796     pURI->cRunning  = 0;
    1797 #ifdef DEBUG
    1798     pURI->cTransfer = 0;
    1799 #endif
     1987    pURI->cRunning   = 0;
     1988    pURI->cTransfers = 0;
    18001989}
    18011990
    … …  
    18352024    RTListAppend(&pURI->List, &pTransfer->Node);
    18362025
    1837 #ifdef DEBUG
    1838     pURI->cTransfer++;
    1839     LogFlowFunc(("cTransfers=%RU32, cRunning=%RU32\n", pURI->cTransfer, pURI->cRunning));
    1840 #endif
     2026    pURI->cTransfers++;
     2027    LogFlowFunc(("cTransfers=%RU32, cRunning=%RU32\n", pURI->cTransfers, pURI->cRunning));
    18412028
    18422029    return VINF_SUCCESS;
    … …  
    18962083 * Returns the number of running URI transfers.
    18972084 *
    1898  * @returns VBox status code.
     2085 * @returns Number of running transfers.
    18992086 * @param   pURI                URI clipboard context to return number for.
    19002087 */
    … …  
    19032090    AssertPtrReturn(pURI, 0);
    19042091    return pURI->cRunning;
     2092}
     2093
     2094/**
     2095 * Returns the number of total URI transfers.
     2096 *
     2097 * @returns Number of total transfers.
     2098 * @param   pURI                URI clipboard context to return number for.
     2099 */
     2100uint32_t SharedClipboardURICtxGetTotalTransfers(PSHAREDCLIPBOARDURICTX pURI)
     2101{
     2102    AssertPtrReturn(pURI, 0);
     2103    return pURI->cTransfers;
    19052104}
    19062105
    … …  
    19262125            RTListNodeRemove(&pTransfer->Node);
    19272126
    1928 #ifdef DEBUG
    1929             Assert(pURI->cTransfer);
    1930             pURI->cTransfer--;
    1931 
    1932             LogFlowFunc(("cTransfers=%RU32\n", pURI->cTransfer));
    1933 #endif
     2127            Assert(pURI->cTransfers);
     2128            pURI->cTransfers--;
     2129
     2130            LogFlowFunc(("cTransfers=%RU32\n", pURI->cTransfers));
    19342131        }
    19352132    }

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

    r79351 r79366  
    852852    int rc;
    853853
    854     if (pTransfer->pvUser)
    855     {
    856         Assert(pTransfer->cbUser == sizeof(SharedClipboardWinURITransferCtx));
    857         SharedClipboardWinURITransferCtx *pWinURITransferCtx = (SharedClipboardWinURITransferCtx *)pTransfer->pvUser;
    858         Assert(pWinURITransferCtx);
    859 
    860         if (pWinURITransferCtx->pDataObj)
    861             delete pWinURITransferCtx->pDataObj;
    862     }
     854    AssertReturn(pTransfer->pvUser == NULL, VERR_WRONG_ORDER);
    863855
    864856    SharedClipboardWinURITransferCtx *pWinURITransferCtx = new SharedClipboardWinURITransferCtx();

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

    r79347 r79366  
    2929#include <VBox/GuestHost/SharedClipboard.h>
    3030#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
     31# include <iprt/semaphore.h>
    3132# include <VBox/GuestHost/SharedClipboard-uri.h>
    3233#endif
    … …  
    4344
    4445struct VBOXCLIPBOARDCLIENTSTATE;
    45 
    46 /**
    47  * Structure for maintaining a single URI transfer.
    48  * A transfer can contain one or multiple files / directories.
    49  */
    50 typedef struct _VBOXCLIPBOARDCLIENTURITRANSFER
    51 {
    52     /** Node for keeping this transfer in a RTList. */
    53     RTLISTNODE                     Node;
    54     /** Pointer to the client state (parent). */
    55     VBOXCLIPBOARDCLIENTSTATE      *pState;
    56     /** The transfer's own (local) area.
    57      *  The area itself has a clipboard area ID assigned, which gets shared (maintained / locked) across all
    58      *  VMs via VBoxSVC. */
    59     SharedClipboardArea            Area;
    60     /** The transfer's URI list, containing the fs object root entries. */
    61     SharedClipboardURIList         List;
    62     /** Current object being handled. */
    63     VBOXCLIPBOARDCLIENTURIOBJCTX   ObjCtx;
    64     /** The transfer header, needed for verification and accounting. */
    65     VBOXCLIPBOARDDATAHDR           Hdr;
    66     /** Intermediate meta data object. */
    67     SHAREDCLIPBOARDMETADATA        Meta;
    68 } VBOXCLIPBOARDCLIENTURITRANSFER, *PVBOXCLIPBOARDCLIENTURITRANSFER;
    6946#endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
    7047
    … …  
    162139
    163140#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
     141int VBoxSvcClipboardProviderImplURIReadDataHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDDATAHDR *ppDataHdr);
     142int VBoxSvcClipboardProviderImplURIWriteDataHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDATAHDR pDataHdr);
     143int VBoxSvcClipboardProviderImplURIReadDataChunk(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDATAHDR pDataHdr, void *pvChunk, uint32_t cbChunk, uint32_t fFlags, uint32_t *pcbRead);
     144int VBoxSvcClipboardProviderImplURIWriteDataChunk(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDATAHDR pDataHdr, const void *pvChunk, uint32_t cbChunk, uint32_t fFlags, uint32_t *pcbWritten);
     145int VBoxSvcClipboardProviderImplURIReadDir(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDDIRDATA *ppDirData);
     146int VBoxSvcClipboardProviderImplURIWriteDir(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDIRDATA pDirData);
     147int VBoxSvcClipboardProviderImplURIReadFileHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDFILEHDR *ppFileHdr);
     148int VBoxSvcClipboardProviderImplURIWriteFileHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDFILEHDR pFileHdr);
     149int VBoxSvcClipboardProviderImplURIReadFileData(PSHAREDCLIPBOARDPROVIDERCTX pCtx, void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead);
     150int VBoxSvcClipboardProviderImplURIWriteFileData(PSHAREDCLIPBOARDPROVIDERCTX pCtx, void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten);
     151
     152DECLCALLBACK(void) VBoxSvcClipboardURITransferPrepareCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData);
     153DECLCALLBACK(void) VBoxSvcClipboardURIDataHeaderCompleteCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData);
     154DECLCALLBACK(void) VBoxSvcClipboardURIDataCompleteCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData);
     155DECLCALLBACK(void) VBoxSvcClipboardURITransferCompleteCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, int rc);
     156DECLCALLBACK(void) VBoxSvcClipboardURITransferCanceledCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData);
     157DECLCALLBACK(void) VBoxSvcClipboardURITransferErrorCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData, int rc);
     158
    164159int VBoxClipboardSvcImplURITransferCreate(PVBOXCLIPBOARDCLIENTDATA pClientData, PSHAREDCLIPBOARDURITRANSFER pTransfer);
    165160int VBoxClipboardSvcImplURITransferDestroy(PVBOXCLIPBOARDCLIENTDATA pClientData, PSHAREDCLIPBOARDURITRANSFER pTransfer);
    166161
    167 int VBoxClipboardSvcImplURIReadDataHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDDATAHDR *ppDataHdr);
    168 int VBoxClipboardSvcImplURIWriteDataHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDATAHDR pDataHdr);
    169 int VBoxClipboardSvcImplURIReadDataChunk(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDATAHDR pDataHdr, void *pvChunk, uint32_t cbChunk, uint32_t fFlags, uint32_t *pcbRead);
    170 int VBoxClipboardSvcImplURIWriteDataChunk(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDATAHDR pDataHdr, const void *pvChunk, uint32_t cbChunk, uint32_t fFlags, uint32_t *pcbWritten);
    171 
    172 int VBoxClipboardSvcImplURIReadDir(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDDIRDATA *ppDirData);
    173 int VBoxClipboardSvcImplURIWriteDir(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDIRDATA pDirData);
    174 
    175 int VBoxClipboardSvcImplURIReadFileHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDFILEHDR *ppFileHdr);
    176 int VBoxClipboardSvcImplURIWriteFileHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDFILEHDR pFileHdr);
    177 int VBoxClipboardSvcImplURIReadFileData(PSHAREDCLIPBOARDPROVIDERCTX pCtx, void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead);
    178 int VBoxClipboardSvcImplURIWriteFileData(PSHAREDCLIPBOARDPROVIDERCTX pCtx, void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten);
     162void VBoxClipboardSvcImplURIOnDataHeaderComplete(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData);
    179163#endif
    180164

  • 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        }

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

    r79347 r79366  
    138138    Assert(pCtx->pClientData->State.data.pv == NULL && pCtx->pClientData->State.data.cb == 0 && pCtx->pClientData->State.data.u32Format == 0);
    139139
    140     LogFlowFunc(("fFormat=%02X\n", fFormat));
     140    LogFlowFunc(("fFormat=%02X, uTimeoutMs=%RU32\n", fFormat, uTimeoutMs));
    141141
    142142    int rc = vboxSvcClipboardReportMsg(pCtx->pClientData, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, fFormat);
    … …  
    770770
    771771#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    772 DECLCALLBACK(void) vboxClipboardSvcWinURITransferPrepareCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData)
    773 {
    774     LogFlowFuncEnter();
    775 
    776     AssertPtrReturnVoid(pData);
    777 
    778     PVBOXCLIPBOARDCLIENTDATA pClientData = (PVBOXCLIPBOARDCLIENTDATA)pData->pvUser;
    779     AssertPtrReturnVoid(pClientData);
    780 
    781     /* Tell the guest that it can start sending URI data. */
    782     int rc2 = vboxSvcClipboardReportMsg(pClientData, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
    783                                         VBOX_SHARED_CLIPBOARD_FMT_URI_LIST);
    784     AssertRC(rc2);
    785 }
    786 
    787 DECLCALLBACK(void) vboxClipboardSvcWinURIDataCompleteCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData)
     772void VBoxClipboardSvcImplURIOnDataHeaderComplete(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData)
    788773{
    789774    LogFlowFuncEnter();
    … …  
    804789int VBoxClipboardSvcImplURITransferCreate(PVBOXCLIPBOARDCLIENTDATA pClientData, PSHAREDCLIPBOARDURITRANSFER pTransfer)
    805790{
     791    RT_NOREF(pClientData, pTransfer);
     792
    806793    LogFlowFuncEnter();
    807794
    808     /* Register needed callbacks so that we can wait for the meta data to arrive here. */
    809     SHAREDCLIPBOARDURITRANSFERCALLBACKS Callbacks;
    810     RT_ZERO(Callbacks);
    811 
    812     Callbacks.pvUser              = pClientData;
    813     Callbacks.pfnTransferPrepare  = vboxClipboardSvcWinURITransferPrepareCallback;
    814 
    815     SharedClipboardURITransferSetCallbacks(pTransfer, &Callbacks);
    816 
    817795    return VINF_SUCCESS;
    818796}
    … …  
    826804    return VINF_SUCCESS;
    827805}
    828 
    829 int VBoxClipboardSvcImplURIReadDataHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDDATAHDR *ppDataHdr)
    830 {
    831     RT_NOREF(ppDataHdr);
    832 
    833     LogFlowFuncEnter();
    834 
    835     PVBOXCLIPBOARDCLIENTDATA pClientData = (PVBOXCLIPBOARDCLIENTDATA)pCtx->pvUser;
    836     AssertPtr(pClientData);
    837 
    838 
    839     return VERR_NOT_IMPLEMENTED;
    840 }
    841 
    842 int VBoxClipboardSvcImplURIWriteDataHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDATAHDR pDataHdr)
    843 {
    844     RT_NOREF(pCtx, pDataHdr);
    845     return VERR_NOT_IMPLEMENTED;
    846 }
    847 
    848 int VBoxClipboardSvcImplURIReadDataChunk(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDATAHDR pDataHdr,
    849                                          void *pvChunk, uint32_t cbChunk, uint32_t fFlags, uint32_t *pcbRead)
    850 {
    851     RT_NOREF(pCtx, pDataHdr, pvChunk, cbChunk, fFlags, pcbRead);
    852     return VERR_NOT_IMPLEMENTED;
    853 }
    854 
    855 int VBoxClipboardSvcImplURIWriteDataChunk(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDATAHDR pDataHdr,
    856                                           const void *pvChunk, uint32_t cbChunk, uint32_t fFlags, uint32_t *pcbWritten)
    857 {
    858     RT_NOREF(pCtx, pDataHdr, pvChunk, cbChunk, fFlags, pcbWritten);
    859     return VERR_NOT_IMPLEMENTED;
    860 }
    861 
    862 int VBoxClipboardSvcImplURIReadDir(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDDIRDATA *ppDirData)
    863 {
    864     RT_NOREF(pCtx, ppDirData);
    865     return VERR_NOT_IMPLEMENTED;
    866 }
    867 
    868 int VBoxClipboardSvcImplURIWriteDir(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDIRDATA pDirData)
    869 {
    870     RT_NOREF(pCtx, pDirData);
    871     return VERR_NOT_IMPLEMENTED;
    872 }
    873 
    874 int VBoxClipboardSvcImplURIReadFileHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDFILEHDR *ppFileHdr)
    875 {
    876     RT_NOREF(pCtx, ppFileHdr);
    877     return VERR_NOT_IMPLEMENTED;
    878 }
    879 
    880 int VBoxClipboardSvcImplURIWriteFileHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDFILEHDR pFileHdr)
    881 {
    882     RT_NOREF(pCtx, pFileHdr);
    883     return VERR_NOT_IMPLEMENTED;
    884 }
    885 
    886 int VBoxClipboardSvcImplURIReadFileData(PSHAREDCLIPBOARDPROVIDERCTX pCtx, void *pvData, uint32_t cbData, uint32_t fFlags,
    887                                         uint32_t *pcbRead)
    888 {
    889     RT_NOREF(pCtx, pvData, cbData, fFlags, pcbRead);
    890     return VERR_NOT_IMPLEMENTED;
    891 }
    892 
    893 int VBoxClipboardSvcImplURIWriteFileData(PSHAREDCLIPBOARDPROVIDERCTX pCtx, void *pvData, uint32_t cbData, uint32_t fFlags,
    894                                          uint32_t *pcbWritten)
    895 {
    896     RT_NOREF(pCtx, pvData, cbData, fFlags, pcbWritten);
    897     return VERR_NOT_IMPLEMENTED;
    898 }
    899806#endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
    900807

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

    r79347 r79366  
    677677
    678678                                        RT_ZERO(creationCtx.Interface);
    679                                         creationCtx.Interface.pfnReadDataHdr    = VBoxClipboardSvcImplURIReadDataHdr;
    680                                         creationCtx.Interface.pfnReadDataChunk  = VBoxClipboardSvcImplURIReadDataChunk;
    681                                         creationCtx.Interface.pfnReadDirectory  = VBoxClipboardSvcImplURIReadDir;
    682                                         creationCtx.Interface.pfnReadFileHdr    = VBoxClipboardSvcImplURIReadFileHdr;
    683                                         creationCtx.Interface.pfnReadFileData   = VBoxClipboardSvcImplURIReadFileData;
    684 
    685                                         creationCtx.Interface.pfnWriteDataHdr    = VBoxClipboardSvcImplURIWriteDataHdr;
    686                                         creationCtx.Interface.pfnWriteDataChunk  = VBoxClipboardSvcImplURIWriteDataChunk;
    687                                         creationCtx.Interface.pfnWriteDirectory  = VBoxClipboardSvcImplURIWriteDir;
    688                                         creationCtx.Interface.pfnWriteFileHdr    = VBoxClipboardSvcImplURIWriteFileHdr;
    689                                         creationCtx.Interface.pfnWriteFileData   = VBoxClipboardSvcImplURIWriteFileData;
     679                                        creationCtx.Interface.pfnReadDataHdr    = VBoxSvcClipboardProviderImplURIReadDataHdr;
     680                                        creationCtx.Interface.pfnReadDataChunk  = VBoxSvcClipboardProviderImplURIReadDataChunk;
     681                                        creationCtx.Interface.pfnReadDirectory  = VBoxSvcClipboardProviderImplURIReadDir;
     682                                        creationCtx.Interface.pfnReadFileHdr    = VBoxSvcClipboardProviderImplURIReadFileHdr;
     683                                        creationCtx.Interface.pfnReadFileData   = VBoxSvcClipboardProviderImplURIReadFileData;
    690684
    691685                                        creationCtx.pvUser = pClientData;
    692686
    693                                         creationCtx.u.HostService.pArea = pTransfer->pArea;
     687                                        /* Register needed callbacks so that we can wait for the meta data to arrive here. */
     688                                        SHAREDCLIPBOARDURITRANSFERCALLBACKS Callbacks;
     689                                        RT_ZERO(Callbacks);
     690
     691                                        Callbacks.pvUser                = pClientData;
     692
     693                                        Callbacks.pfnTransferPrepare    = VBoxSvcClipboardURITransferPrepareCallback;
     694                                        Callbacks.pfnDataHeaderComplete = VBoxSvcClipboardURIDataHeaderCompleteCallback;
     695                                        Callbacks.pfnDataComplete       = VBoxSvcClipboardURIDataCompleteCallback;
     696                                        Callbacks.pfnTransferComplete   = VBoxSvcClipboardURITransferCompleteCallback;
     697                                        Callbacks.pfnTransferCanceled   = VBoxSvcClipboardURITransferCanceledCallback;
     698                                        Callbacks.pfnTransferError      = VBoxSvcClipboardURITransferErrorCallback;
     699
     700                                        SharedClipboardURITransferSetCallbacks(pTransfer, &Callbacks);
    694701
    695702                                        rc = SharedClipboardURITransferProviderCreate(pTransfer, &creationCtx);
    … …  
    790797                                    RT_ZERO(creationCtx.Interface);
    791798
    792                                     creationCtx.Interface.pfnReadDataHdr    = VBoxClipboardSvcImplURIReadDataHdr;
    793                                     creationCtx.Interface.pfnReadDataChunk  = VBoxClipboardSvcImplURIReadDataChunk;
    794                                     creationCtx.Interface.pfnReadDirectory  = VBoxClipboardSvcImplURIReadDir;
    795                                     creationCtx.Interface.pfnReadFileHdr    = VBoxClipboardSvcImplURIReadFileHdr;
    796                                     creationCtx.Interface.pfnReadFileData   = VBoxClipboardSvcImplURIReadFileData;
    797 
    798                                     creationCtx.Interface.pfnWriteDataHdr    = VBoxClipboardSvcImplURIWriteDataHdr;
    799                                     creationCtx.Interface.pfnWriteDataChunk  = VBoxClipboardSvcImplURIWriteDataChunk;
    800                                     creationCtx.Interface.pfnWriteDirectory  = VBoxClipboardSvcImplURIWriteDir;
    801                                     creationCtx.Interface.pfnWriteFileHdr    = VBoxClipboardSvcImplURIWriteFileHdr;
    802                                     creationCtx.Interface.pfnWriteFileData   = VBoxClipboardSvcImplURIWriteFileData;
     799                                    creationCtx.Interface.pfnWriteDataHdr    = VBoxSvcClipboardProviderImplURIWriteDataHdr;
     800                                    creationCtx.Interface.pfnWriteDataChunk  = VBoxSvcClipboardProviderImplURIWriteDataChunk;
     801                                    creationCtx.Interface.pfnWriteDirectory  = VBoxSvcClipboardProviderImplURIWriteDir;
     802                                    creationCtx.Interface.pfnWriteFileHdr    = VBoxSvcClipboardProviderImplURIWriteFileHdr;
     803                                    creationCtx.Interface.pfnWriteFileData   = VBoxSvcClipboardProviderImplURIWriteFileData;
    803804
    804805                                    creationCtx.pvUser = pClientData;
    805 
    806                                     creationCtx.u.HostService.pArea = pTransfer->pArea;
    807806
    808807                                    rc = SharedClipboardURITransferProviderCreate(pTransfer, &creationCtx);
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