VirtualBox

Ignore:
Timestamp:
Sep 17, 2019 9:05:21 AM (5 years ago)
Author:
vboxsync
Message:

Shared Clipboard/URI: More code for transfer channel handling.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r80664 r80845  
    8484
    8585    PSHCLCLIENTMSG pMsgHdr = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_HDR_READ,
    86                                                                VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_HDR_READ);
     86                                                        VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_HDR_READ);
    8787    if (pMsgHdr)
    8888    {
    8989        SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
    9090
    91         HGCMSvcSetU32(&pMsgHdr->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent));
    92         HGCMSvcSetU32(&pMsgHdr->m_paParms[1], 0 /* fRoots */);
     91        HGCMSvcSetU32(&pMsgHdr->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID,
     92                                                                                   pCtx->pTransfer->State.uID, uEvent));
     93        HGCMSvcSetU32(&pMsgHdr->paParms[1], 0 /* fRoots */);
    9394
    9495        rc = sharedClipboardSvcMsgAdd(pClient, pMsgHdr, true /* fAppend */);
    … …  
    124125                                {
    125126                                    PSHCLCLIENTMSG pMsgEntry = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_ENTRY_READ,
    126                                                                                                  VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_ENTRY_READ_REQ);
     127                                                                                          VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_ENTRY_READ_REQ);
    127128
    128129                                    uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
    129130
    130                                     HGCMSvcSetU32(&pMsgEntry->m_paParms[0],
    131                                                   VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent));
    132                                     HGCMSvcSetU32(&pMsgEntry->m_paParms[1], 0 /* fRoots */);
    133                                     HGCMSvcSetU32(&pMsgEntry->m_paParms[2], i /* uIndex */);
     131                                    HGCMSvcSetU32(&pMsgEntry->paParms[0],
     132                                                  VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uClientID,
     133                                                                                       pCtx->pTransfer->State.uID, uEvent));
     134                                    HGCMSvcSetU32(&pMsgEntry->paParms[1], 0 /* fRoots */);
     135                                    HGCMSvcSetU32(&pMsgEntry->paParms[2], i /* uIndex */);
    134136
    135137                                    rc2 = SharedClipboardEventRegister(&pCtx->pTransfer->Events, uEvent);
    … …  
    206208        const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
    207209
    208         pMsg->m_Ctx.uContextID = VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent);
    209 
    210         rc = sharedClipboardSvcURISetListOpen(pMsg->m_cParms, pMsg->m_paParms, &pMsg->m_Ctx, pOpenParms);
     210        pMsg->Ctx.uContextID = VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID,  pCtx->pTransfer->State.uID,
     211                                                                      uEvent);
     212
     213        rc = sharedClipboardSvcURISetListOpen(pMsg->cParms, pMsg->paParms, &pMsg->Ctx, pOpenParms);
    211214        if (RT_SUCCESS(rc))
    212215        {
    … …  
    258261
    259262    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE,
    260                                                             VBOX_SHARED_CLIPBOARD_CPARMS_LIST_CLOSE);
     263                                                     VBOX_SHARED_CLIPBOARD_CPARMS_LIST_CLOSE);
    261264    if (pMsg)
    262265    {
    263266        const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
    264267
    265         pMsg->m_Ctx.uContextID = VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent);
    266 
    267         rc = sharedClipboardSvcURISetListClose(pMsg->m_cParms, pMsg->m_paParms, &pMsg->m_Ctx, hList);
     268        pMsg->Ctx.uContextID = VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID, pCtx->pTransfer->State.uID,
     269                                                                    uEvent);
     270
     271        rc = sharedClipboardSvcURISetListClose(pMsg->cParms, pMsg->paParms, &pMsg->Ctx, hList);
    268272        if (RT_SUCCESS(rc))
    269273        {
    … …  
    310314        const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
    311315
    312         HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent));
    313         HGCMSvcSetU64(&pMsg->m_paParms[1], hList);
    314         HGCMSvcSetU32(&pMsg->m_paParms[2], 0 /* fFlags */);
     316        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID,
     317                                                                              pCtx->pTransfer->State.uID, uEvent));
     318        HGCMSvcSetU64(&pMsg->paParms[1], hList);
     319        HGCMSvcSetU32(&pMsg->paParms[2], 0 /* fFlags */);
    315320
    316321        rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    … …  
    370375        const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
    371376
    372         HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent));
    373         HGCMSvcSetU64(&pMsg->m_paParms[1], hList);
    374         HGCMSvcSetU32(&pMsg->m_paParms[2], 0 /* fInfo */);
     377        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID,
     378                                                                              pCtx->pTransfer->State.uID, uEvent));
     379        HGCMSvcSetU64(&pMsg->paParms[1], hList);
     380        HGCMSvcSetU32(&pMsg->paParms[2], 0 /* fInfo */);
    375381
    376382        rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    … …  
    433439        const uint32_t cbPath = (uint32_t)strlen(pCreateParms->pszPath) + 1; /* Include terminating zero */
    434440
    435         HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent));
    436         HGCMSvcSetU64(&pMsg->m_paParms[1], 0); /* uHandle */
    437         HGCMSvcSetU32(&pMsg->m_paParms[2], cbPath);
    438         HGCMSvcSetPv (&pMsg->m_paParms[3], pCreateParms->pszPath, cbPath);
    439         HGCMSvcSetU32(&pMsg->m_paParms[4], pCreateParms->fCreate);
     441        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID,
     442                                                                              pCtx->pTransfer->State.uID, uEvent));
     443        HGCMSvcSetU64(&pMsg->paParms[1], 0); /* uHandle */
     444        HGCMSvcSetU32(&pMsg->paParms[2], cbPath);
     445        HGCMSvcSetPv (&pMsg->paParms[3], pCreateParms->pszPath, cbPath);
     446        HGCMSvcSetU32(&pMsg->paParms[4], pCreateParms->fCreate);
    440447
    441448        rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    … …  
    483490
    484491    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE,
    485                                                             VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_CLOSE);
     492                                                     VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_CLOSE);
    486493    if (pMsg)
    487494    {
    488495        const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
    489496
    490         HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent));
    491         HGCMSvcSetU64(&pMsg->m_paParms[1], hObj);
     497        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID,
     498                                                                              pCtx->pTransfer->State.uID, uEvent));
     499        HGCMSvcSetU64(&pMsg->paParms[1], hObj);
    492500
    493501        rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    … …  
    536544
    537545    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ,
    538                                                             VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_READ_REQ);
     546                                                     VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_READ_REQ);
    539547    if (pMsg)
    540548    {
    541549        const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
    542550
    543         HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent));
    544         HGCMSvcSetU64(&pMsg->m_paParms[1], hObj);
    545         HGCMSvcSetU32(&pMsg->m_paParms[2], cbData);
    546         HGCMSvcSetU32(&pMsg->m_paParms[3], fFlags);
     551        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID,
     552                                                                              pCtx->pTransfer->State.uID, uEvent));
     553        HGCMSvcSetU64(&pMsg->paParms[1], hObj);
     554        HGCMSvcSetU32(&pMsg->paParms[2], cbData);
     555        HGCMSvcSetU32(&pMsg->paParms[3], fFlags);
    547556
    548557        rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    … …  
    594603
    595604    PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_WRITE,
    596                                                             VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_WRITE);
     605                                                     VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_WRITE);
    597606    if (pMsg)
    598607    {
    599608        const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events);
    600609
    601         HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent));
    602         HGCMSvcSetU64(&pMsg->m_paParms[1], hObj);
    603         HGCMSvcSetU64(&pMsg->m_paParms[2], cbData);
    604         HGCMSvcSetU64(&pMsg->m_paParms[3], fFlags);
     610        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID,
     611                                                                              pCtx->pTransfer->State.uID, uEvent));
     612        HGCMSvcSetU64(&pMsg->paParms[1], hObj);
     613        HGCMSvcSetU64(&pMsg->paParms[2], cbData);
     614        HGCMSvcSetU64(&pMsg->paParms[3], fFlags);
    605615
    606616        rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */);
    … …  
    697707        uint32_t cbPayload = 0;
    698708
     709        /* paParms[0] has the context ID. */
    699710        rc = HGCMSvcGetU32(&paParms[1], &pReply->uType);
    700711        if (RT_SUCCESS(rc))
    … …  
    714725            switch (pReply->uType)
    715726            {
     727                case VBOX_SHCL_REPLYMSGTYPE_TRANSFER_STATUS:
     728                {
     729                    if (cParms >= 6)
     730                        rc = HGCMSvcGetU32(&paParms[5], &pReply->u.TransferStatus.uStatus);
     731                    break;
     732                }
     733
    716734                case VBOX_SHCL_REPLYMSGTYPE_LIST_OPEN:
    717735                {
    … …  
    11511169    int rc;
    11521170
    1153     uint32_t            cbReply = sizeof(SHCLREPLY);
     1171    uint32_t   cbReply = sizeof(SHCLREPLY);
    11541172    PSHCLREPLY pReply  = (PSHCLREPLY)RTMemAlloc(cbReply);
    11551173    if (pReply)
    … …  
    11671185                switch (pReply->uType)
    11681186                {
     1187                    case VBOX_SHCL_REPLYMSGTYPE_TRANSFER_STATUS:
     1188                        RT_FALL_THROUGH();
    11691189                    case VBOX_SHCL_REPLYMSGTYPE_LIST_OPEN:
    11701190                        RT_FALL_THROUGH();
    … …  
    12371257
    12381258    LogFlowFunc(("uClient=%RU32, u32Function=%RU32 (%s), cParms=%RU32, g_ExtState.pfnExtension=%p\n",
    1239                  pClient->uClientID, u32Function, VBoxClipboardGuestMsgToStr(u32Function), cParms, g_ExtState.pfnExtension));
    1240 
     1259                 pClient->State.uClientID, u32Function, VBoxClipboardGuestMsgToStr(u32Function), cParms, g_ExtState.pfnExtension));
     1260
     1261#if 0
    12411262    /* Check if we've the right mode set. */
    12421263    if (!sharedClipboardSvcURIMsgIsAllowed(sharedClipboardSvcGetMode(), u32Function))
    … …  
    12451266        return VERR_ACCESS_DENIED;
    12461267    }
     1268#endif
    12471269
    12481270    /* A (valid) service extension is needed because VBoxSVC needs to keep track of the
    … …  
    12571279    }
    12581280
    1259     int rc = VINF_SUCCESS;
     1281    int rc = VERR_INVALID_PARAMETER; /* Play safe by default. */
    12601282
    12611283    /*
    12621284     * Pre-check: For certain messages we need to make sure that a (right) transfer is present.
    12631285     */
     1286    uint32_t         uCID      = 0; /* Context ID */
    12641287    PSHCLURITRANSFER pTransfer = NULL;
     1288
    12651289    switch (u32Function)
    12661290    {
    … …  
    12721296            {
    12731297                LogFunc(("No transfers found\n"));
    1274                 rc = VERR_WRONG_ORDER;
     1298                rc = VERR_SHCLPB_TRANSFER_ID_NOT_FOUND;
    12751299                break;
    12761300            }
    12771301
    1278             const uint32_t uTransferID = 0; /* Only one transfer per client is supported at the moment. */
     1302            if (cParms < 1)
     1303                break;
     1304
     1305            rc = HGCMSvcGetU32(&paParms[0], &uCID);
     1306            if (RT_FAILURE(rc))
     1307                break;
     1308
     1309            const SHCLURITRANSFERID uTransferID = VBO_SHARED_CLIPBOARD_CONTEXTID_GET_TRANSFER(uCID);
    12791310
    12801311            pTransfer = SharedClipboardURICtxGetTransfer(&pClient->URI, uTransferID);
    … …  
    12821313            {
    12831314                LogFunc(("Transfer with ID %RU32 not found\n", uTransferID));
    1284                 rc = VERR_WRONG_ORDER;
     1315                rc = VERR_SHCLPB_TRANSFER_ID_NOT_FOUND;
    12851316            }
    12861317            break;
    … …  
    12921323
    12931324    rc = VERR_INVALID_PARAMETER; /* Play safe. */
     1325
     1326    bool fDoCallComplete = true;
    12941327
    12951328    switch (u32Function)
    … …  
    13991432        {
    14001433            rc = sharedClipboardSvcURITransferHandleReply(pClient, pTransfer, cParms, paParms);
     1434
     1435            /* This message does not need any completion, as it can happen at any time from the guest side. */
     1436            fDoCallComplete = false;
    14011437            break;
    14021438        }
    … …  
    14161452                uint32_t cbData = sizeof(SHCLROOTLISTHDR);
    14171453
    1418                 uint32_t uCID;
    1419                 rc = HGCMSvcGetU32(&paParms[0], &uCID);
     1454                const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
     1455
     1456                PSHCLEVENTPAYLOAD pPayload;
     1457                rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload);
    14201458                if (RT_SUCCESS(rc))
    14211459                {
     1460                    rc = SharedClipboardEventSignal(&pTransfer->Events, uEvent, pPayload);
     1461                    if (RT_FAILURE(rc))
     1462                        SharedClipboardPayloadFree(pPayload);
     1463                }
     1464            }
     1465            break;
     1466        }
     1467
     1468        case VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_ENTRY_READ:
     1469        {
     1470    #if 0
     1471            SHCLROOTLISTENTRY lstEntry;
     1472            rc = VBoxSvcClipboardURIGetRootListEntry(cParms, paParms, &lstEntry);
     1473            if (RT_SUCCESS(rc))
     1474            {
     1475                void    *pvData = SharedClipboardURIRootListEntryDup(&lstEntry);
     1476                uint32_t cbData = sizeof(SHCLROOTLISTENTRY);
     1477
     1478                PSHCLURITRANSFERPAYLOAD pPayload;
     1479                rc = SharedClipboardURITransferPayloadAlloc(SHCLURITRANSFEREVENTTYPE_ROOT_LIST_HDR_READ,
     1480                                                            pvData, cbData, &pPayload);
     1481                if (RT_SUCCESS(rc))
     1482                    rc = SharedClipboardURITransferEventSignal(pTransfer, SHCLURITRANSFEREVENTTYPE_ROOT_LIST_HDR_READ,
     1483                                                               pPayload);
     1484            }
     1485            break;
     1486    #endif
     1487        }
     1488
     1489        case VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_ENTRY_WRITE:
     1490        {
     1491            SHCLROOTLISTENTRY lstEntry;
     1492            rc = sharedClipboardSvcURIGetRootListEntry(cParms, paParms, &lstEntry);
     1493            if (RT_SUCCESS(rc))
     1494            {
     1495                void    *pvData = SharedClipboardURIRootListEntryDup(&lstEntry);
     1496                uint32_t cbData = sizeof(SHCLROOTLISTENTRY);
     1497
     1498                const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
     1499
     1500                PSHCLEVENTPAYLOAD pPayload;
     1501                rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload);
     1502                if (RT_SUCCESS(rc))
     1503                {
     1504                    rc = SharedClipboardEventSignal(&pTransfer->Events, uEvent, pPayload);
     1505                    if (RT_FAILURE(rc))
     1506                        SharedClipboardPayloadFree(pPayload);
     1507                }
     1508            }
     1509            break;
     1510        }
     1511
     1512        case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_OPEN:
     1513        {
     1514            SHCLLISTOPENPARMS listOpenParms;
     1515            rc = sharedClipboardSvcURIGetListOpen(cParms, paParms, &listOpenParms);
     1516            if (RT_SUCCESS(rc))
     1517            {
     1518                SHCLLISTHANDLE hList;
     1519                rc = SharedClipboardURITransferListOpen(pTransfer, &listOpenParms, &hList);
     1520                if (RT_SUCCESS(rc))
     1521                {
     1522                    /* Return list handle. */
     1523                    HGCMSvcSetU32(&paParms[1], hList);
     1524                }
     1525            }
     1526            break;
     1527        }
     1528
     1529        case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_CLOSE:
     1530        {
     1531            if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_LIST_CLOSE)
     1532                break;
     1533
     1534            SHCLLISTHANDLE hList;
     1535            rc = HGCMSvcGetU64(&paParms[1], &hList);
     1536            if (RT_SUCCESS(rc))
     1537            {
     1538                rc = SharedClipboardURITransferListClose(pTransfer, hList);
     1539            }
     1540            break;
     1541        }
     1542
     1543        case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_READ:
     1544        {
     1545            if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR)
     1546                break;
     1547
     1548            SHCLLISTHANDLE hList;
     1549            rc = HGCMSvcGetU64(&paParms[1], &hList); /* Get list handle. */
     1550            if (RT_SUCCESS(rc))
     1551            {
     1552                SHCLLISTHDR hdrList;
     1553                rc = SharedClipboardURITransferListGetHeader(pTransfer, hList, &hdrList);
     1554                /*if (RT_SUCCESS(rc))
     1555                    rc = sharedClipboardSvcURISetListHdr(cParms, paParms, &hdrList);*/
     1556            }
     1557            break;
     1558        }
     1559
     1560        case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_WRITE:
     1561        {
     1562            SHCLLISTHDR hdrList;
     1563            rc = SharedClipboardURIListHdrInit(&hdrList);
     1564            if (RT_SUCCESS(rc))
     1565            {
     1566                SHCLLISTHANDLE hList;
     1567                rc = sharedClipboardSvcURIGetListHdr(cParms, paParms, &hList, &hdrList);
     1568                if (RT_SUCCESS(rc))
     1569                {
     1570                    void    *pvData = SharedClipboardURIListHdrDup(&hdrList);
     1571                    uint32_t cbData = sizeof(SHCLLISTHDR);
     1572
    14221573                    const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
    14231574
    … …  
    14351586        }
    14361587
    1437         case VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_ENTRY_READ:
    1438         {
    1439     #if 0
    1440             SHCLROOTLISTENTRY lstEntry;
    1441             rc = VBoxSvcClipboardURIGetRootListEntry(cParms, paParms, &lstEntry);
    1442             if (RT_SUCCESS(rc))
    1443             {
    1444                 void    *pvData = SharedClipboardURIRootListEntryDup(&lstEntry);
    1445                 uint32_t cbData = sizeof(SHCLROOTLISTENTRY);
    1446 
    1447                 PSHCLURITRANSFERPAYLOAD pPayload;
    1448                 rc = SharedClipboardURITransferPayloadAlloc(SHCLURITRANSFEREVENTTYPE_ROOT_LIST_HDR_READ,
    1449                                                             pvData, cbData, &pPayload);
     1588        case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_READ:
     1589        {
     1590            if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY)
     1591                break;
     1592
     1593            SHCLLISTHANDLE hList;
     1594            rc = HGCMSvcGetU64(&paParms[1], &hList); /* Get list handle. */
     1595            if (RT_SUCCESS(rc))
     1596            {
     1597                SHCLLISTENTRY entryList;
     1598                rc = SharedClipboardURITransferListRead(pTransfer, hList, &entryList);
     1599            }
     1600            break;
     1601        }
     1602
     1603        case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_WRITE:
     1604        {
     1605            SHCLLISTENTRY entryList;
     1606            rc = SharedClipboardURIListEntryInit(&entryList);
     1607            if (RT_SUCCESS(rc))
     1608            {
     1609                SHCLLISTHANDLE hList;
     1610                rc = sharedClipboardSvcURIGetListEntry(cParms, paParms, &hList, &entryList);
    14501611                if (RT_SUCCESS(rc))
    1451                     rc = SharedClipboardURITransferEventSignal(pTransfer, SHCLURITRANSFEREVENTTYPE_ROOT_LIST_HDR_READ,
    1452                                                                pPayload);
    1453             }
    1454             break;
    1455     #endif
    1456         }
    1457 
    1458         case VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_ENTRY_WRITE:
    1459         {
    1460             SHCLROOTLISTENTRY lstEntry;
    1461             rc = sharedClipboardSvcURIGetRootListEntry(cParms, paParms, &lstEntry);
    1462             if (RT_SUCCESS(rc))
    1463             {
    1464                 void    *pvData = SharedClipboardURIRootListEntryDup(&lstEntry);
    1465                 uint32_t cbData = sizeof(SHCLROOTLISTENTRY);
    1466 
    1467                 uint32_t uCID;
    1468                 rc = HGCMSvcGetU32(&paParms[0], &uCID);
    1469                 if (RT_SUCCESS(rc))
    1470                 {
     1612                {
     1613                    void    *pvData = SharedClipboardURIListEntryDup(&entryList);
     1614                    uint32_t cbData = sizeof(SHCLLISTENTRY);
     1615
    14711616                    const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
    14721617
    … …  
    14841629        }
    14851630
    1486         case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_OPEN:
    1487         {
    1488             SHCLLISTOPENPARMS listOpenParms;
    1489             rc = sharedClipboardSvcURIGetListOpen(cParms, paParms, &listOpenParms);
    1490             if (RT_SUCCESS(rc))
    1491             {
    1492                 SHCLLISTHANDLE hList;
    1493                 rc = SharedClipboardURITransferListOpen(pTransfer, &listOpenParms, &hList);
    1494                 if (RT_SUCCESS(rc))
    1495                 {
    1496                     /* Return list handle. */
    1497                     HGCMSvcSetU32(&paParms[1], hList);
    1498                 }
    1499             }
    1500             break;
    1501         }
    1502 
    1503         case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_CLOSE:
    1504         {
    1505             if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_LIST_CLOSE)
    1506                 break;
    1507 
    1508             SHCLLISTHANDLE hList;
    1509             rc = HGCMSvcGetU64(&paParms[1], &hList);
    1510             if (RT_SUCCESS(rc))
    1511             {
    1512                 rc = SharedClipboardURITransferListClose(pTransfer, hList);
    1513             }
    1514             break;
    1515         }
    1516 
    1517         case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_READ:
    1518         {
    1519             if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR)
    1520                 break;
    1521 
    1522             SHCLLISTHANDLE hList;
    1523             rc = HGCMSvcGetU64(&paParms[1], &hList); /* Get list handle. */
    1524             if (RT_SUCCESS(rc))
    1525             {
    1526                 SHCLLISTHDR hdrList;
    1527                 rc = SharedClipboardURITransferListGetHeader(pTransfer, hList, &hdrList);
    1528                 /*if (RT_SUCCESS(rc))
    1529                     rc = sharedClipboardSvcURISetListHdr(cParms, paParms, &hdrList);*/
    1530             }
    1531             break;
    1532         }
    1533 
    1534         case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_WRITE:
    1535         {
    1536             SHCLLISTHDR hdrList;
    1537             rc = SharedClipboardURIListHdrInit(&hdrList);
    1538             if (RT_SUCCESS(rc))
    1539             {
    1540                 SHCLLISTHANDLE hList;
    1541                 rc = sharedClipboardSvcURIGetListHdr(cParms, paParms, &hList, &hdrList);
    1542                 if (RT_SUCCESS(rc))
    1543                 {
    1544                     void    *pvData = SharedClipboardURIListHdrDup(&hdrList);
    1545                     uint32_t cbData = sizeof(SHCLLISTHDR);
    1546 
    1547                     uint32_t uCID;
    1548                     rc = HGCMSvcGetU32(&paParms[0], &uCID);
    1549                     if (RT_SUCCESS(rc))
    1550                     {
    1551                         const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
    1552 
    1553                         PSHCLEVENTPAYLOAD pPayload;
    1554                         rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload);
    1555                         if (RT_SUCCESS(rc))
    1556                         {
    1557                             rc = SharedClipboardEventSignal(&pTransfer->Events, uEvent, pPayload);
    1558                             if (RT_FAILURE(rc))
    1559                                 SharedClipboardPayloadFree(pPayload);
    1560                         }
    1561                     }
    1562                 }
    1563             }
    1564             break;
    1565         }
    1566 
    1567         case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_READ:
    1568         {
    1569             if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY)
    1570                 break;
    1571 
    1572             SHCLLISTHANDLE hList;
    1573             rc = HGCMSvcGetU64(&paParms[1], &hList); /* Get list handle. */
    1574             if (RT_SUCCESS(rc))
    1575             {
    1576                 SHCLLISTENTRY entryList;
    1577                 rc = SharedClipboardURITransferListRead(pTransfer, hList, &entryList);
    1578             }
    1579             break;
    1580         }
    1581 
    1582         case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_WRITE:
    1583         {
    1584             SHCLLISTENTRY entryList;
    1585             rc = SharedClipboardURIListEntryInit(&entryList);
    1586             if (RT_SUCCESS(rc))
    1587             {
    1588                 SHCLLISTHANDLE hList;
    1589                 rc = sharedClipboardSvcURIGetListEntry(cParms, paParms, &hList, &entryList);
    1590                 if (RT_SUCCESS(rc))
    1591                 {
    1592                     void    *pvData = SharedClipboardURIListEntryDup(&entryList);
    1593                     uint32_t cbData = sizeof(SHCLLISTENTRY);
    1594 
    1595                     uint32_t uCID;
    1596                     rc = HGCMSvcGetU32(&paParms[0], &uCID);
    1597                     if (RT_SUCCESS(rc))
    1598                     {
    1599                         const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
    1600 
    1601                         PSHCLEVENTPAYLOAD pPayload;
    1602                         rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload);
    1603                         if (RT_SUCCESS(rc))
    1604                         {
    1605                             rc = SharedClipboardEventSignal(&pTransfer->Events, uEvent, pPayload);
    1606                             if (RT_FAILURE(rc))
    1607                                 SharedClipboardPayloadFree(pPayload);
    1608                         }
    1609                     }
    1610                 }
    1611             }
    1612             break;
    1613         }
    1614 
    16151631    #if 0
    16161632        case VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_OPEN:
    … …  
    16391655                uint32_t cbData = sizeof(SHCLOBJDATACHUNK);
    16401656
    1641                 uint32_t uCID;
    1642                 rc = HGCMSvcGetU32(&paParms[0], &uCID);
     1657                const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
     1658
     1659                PSHCLEVENTPAYLOAD pPayload;
     1660                rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload);
    16431661                if (RT_SUCCESS(rc))
    16441662                {
    1645                     const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
    1646 
    1647                     PSHCLEVENTPAYLOAD pPayload;
    1648                     rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload);
    1649                     if (RT_SUCCESS(rc))
    1650                     {
    1651                         rc = SharedClipboardEventSignal(&pTransfer->Events, uEvent, pPayload);
    1652                         if (RT_FAILURE(rc))
    1653                             SharedClipboardPayloadFree(pPayload);
    1654                     }
     1663                    rc = SharedClipboardEventSignal(&pTransfer->Events, uEvent, pPayload);
     1664                    if (RT_FAILURE(rc))
     1665                        SharedClipboardPayloadFree(pPayload);
    16551666                }
    16561667            }
    … …  
    18491860    }
    18501861
    1851     if (rc != VINF_HGCM_ASYNC_EXECUTE)
     1862    if (fDoCallComplete)
    18521863    {
    18531864        /* Tell the client that the call is complete (unblocks waiting). */
    1854         LogFlowFunc(("[Client %RU32] Calling pfnCallComplete w/ rc=%Rrc\n", pClient->uClientID, rc));
     1865        LogFlowFunc(("[Client %RU32] Calling pfnCallComplete w/ rc=%Rrc\n", pClient->State.uClientID, rc));
    18551866        AssertPtr(g_pHelpers);
    18561867        g_pHelpers->pfnCallComplete(callHandle, rc);
    18571868    }
    18581869
    1859     LogFlowFunc(("[Client %RU32] Returning rc=%Rrc\n", pClient->uClientID, rc));
     1870    LogFlowFunc(("[Client %RU32] Returning rc=%Rrc\n", pClient->State.uClientID, rc));
    18601871    return rc;
    18611872}
    … …  
    19341945
    19351946        LogFlowFunc(("Registered new clipboard area (%RU32) by client %RU32 with rc=%Rrc\n",
    1936                      parms.uID, pClientState->u32ClientID, rc));
     1947                     parms.uID, pClientState->uClientID, rc));
    19371948    }
    19381949    else
    … …  
    19801991
    19811992        LogFlowFunc(("Unregistered clipboard area (%RU32) by client %RU32 with rc=%Rrc\n",
    1982                      parms.uID, pClientState->u32ClientID, rc));
     1993                     parms.uID, pClientState->uClientID, rc));
    19831994    }
    19841995
    … …  
    20302041
    20312042        LogFlowFunc(("Attached client %RU32 to clipboard area %RU32 with rc=%Rrc\n",
    2032                      pClientState->u32ClientID, parms.uID, rc));
     2043                     pClientState->uClientID, parms.uID, rc));
    20332044    }
    20342045    else
    … …  
    20682079
    20692080        LogFlowFunc(("Detached client %RU32 from clipboard area %RU32 with rc=%Rrc\n",
    2070                      pClientState->u32ClientID, uAreaID, rc));
     2081                     pClientState->uClientID, uAreaID, rc));
    20712082    }
    20722083
    … …  
    20782089}
    20792090
     2091/**
     2092 * Reports a transfer status to the guest.
     2093 *
     2094 * @returns VBox status code.
     2095 * @param   pClient             Client that owns the transfer.
     2096 * @param   pTransfer           Transfer to report status for.
     2097 * @param   uStatus             Status to report.
     2098 * @param   rcTransfer          Result code to report. Optional and depending on status.
     2099 * @param   puEvent             Where to store the created wait event. Optional.
     2100 */
     2101int sharedClipboardSvcURITransferSendStatus(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer, SHCLURITRANSFERSTATUS uStatus,
     2102                                            int rcTransfer, PSHCLEVENTID puEvent)
     2103{
     2104    AssertPtrReturn(pClient,   VERR_INVALID_POINTER);
     2105    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
     2106    /* puEvent is optional. */
     2107
     2108    PSHCLCLIENTMSG pMsgReadData = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_STATUS,
     2109                                                             VBOX_SHARED_CLIPBOARD_CPARMS_TRANSFER_STATUS);
     2110    if (!pMsgReadData)
     2111        return VERR_NO_MEMORY;
     2112
     2113    const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pTransfer->Events);
     2114
     2115    HGCMSvcSetU32(&pMsgReadData->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID,
     2116                                                                                  pTransfer->State.uID, uEvent));
     2117    HGCMSvcSetU32(&pMsgReadData->paParms[1], pTransfer->State.enmDir);
     2118    HGCMSvcSetU32(&pMsgReadData->paParms[2], uStatus);
     2119    HGCMSvcSetU32(&pMsgReadData->paParms[3], (uint32_t)rcTransfer); /** @todo uint32_t vs. int. */
     2120    HGCMSvcSetU32(&pMsgReadData->paParms[4], 0 /* fFlags, unused */);
     2121
     2122    int rc = sharedClipboardSvcMsgAdd(pClient, pMsgReadData, true /* fAppend */);
     2123    if (RT_SUCCESS(rc))
     2124    {
     2125        rc = SharedClipboardEventRegister(&pTransfer->Events, uEvent);
     2126        if (RT_SUCCESS(rc))
     2127        {
     2128            rc = sharedClipboardSvcClientWakeup(pClient);
     2129            if (RT_SUCCESS(rc))
     2130            {
     2131                LogRel2(("Shared Clipboard: Reported status %s (rc=%Rrc) of transfer %RU32 to guest\n",
     2132                         VBoxClipboardTransferStatusToStr(uStatus), rcTransfer, pTransfer->State.uID));
     2133
     2134                if (puEvent)
     2135                    *puEvent = uEvent;
     2136            }
     2137            else
     2138                SharedClipboardEventUnregister(&pTransfer->Events, uEvent);
     2139        }
     2140    }
     2141
     2142    LogFlowFuncLeaveRC(rc);
     2143    return rc;
     2144}
     2145
     2146/**
     2147 * Starts a new transfer, waiting for acknowledgement by the guest side.
     2148 *
     2149 * @returns VBox status code.
     2150 * @param   pClient             Client that owns the transfer.
     2151 * @param   enmDir              Transfer direction to start.
     2152 * @param   enmSource           Transfer source to start.
     2153 * @param   ppTransfer          Where to return the created transfer on success. Optional.
     2154 */
     2155int sharedClipboardSvcURITransferStart(PSHCLCLIENT pClient,
     2156                                       SHCLURITRANSFERDIR enmDir, SHCLSOURCE enmSource,
     2157                                       PSHCLURITRANSFER *ppTransfer)
     2158{
     2159    AssertPtrReturn(pClient, VERR_INVALID_POINTER);
     2160    /* ppTransfer is optional. */
     2161
     2162    LogFlowFuncEnter();
     2163
     2164    SharedClipboardURICtxTransfersCleanup(&pClient->URI);
     2165
     2166    int rc;
     2167
     2168    if (!SharedClipboardURICtxTransfersMaximumReached(&pClient->URI))
     2169    {
     2170        LogRel2(("Shared Clipboard: Starting %s transfer ...\n", enmDir == SHCLURITRANSFERDIR_READ ? "read" : "write"));
     2171
     2172        PSHCLURITRANSFER pTransfer;
     2173        rc = SharedClipboardURITransferCreate(&pTransfer);
     2174        if (RT_SUCCESS(rc))
     2175        {
     2176            SHCLPROVIDERCREATIONCTX creationCtx;
     2177            RT_ZERO(creationCtx);
     2178
     2179            if (enmDir == SHCLURITRANSFERDIR_READ)
     2180            {
     2181                rc = sharedClipboardSvcURIAreaRegister(&pClient->State, pTransfer);
     2182                if (RT_SUCCESS(rc))
     2183                {
     2184                    creationCtx.Interface.pfnTransferOpen    = sharedClipboardSvcURITransferOpen;
     2185                    creationCtx.Interface.pfnTransferClose   = sharedClipboardSvcURITransferClose;
     2186                    creationCtx.Interface.pfnListOpen        = sharedClipboardSvcURIListOpen;
     2187                    creationCtx.Interface.pfnListClose       = sharedClipboardSvcURIListClose;
     2188                    creationCtx.Interface.pfnObjOpen         = sharedClipboardSvcURIObjOpen;
     2189                    creationCtx.Interface.pfnObjClose        = sharedClipboardSvcURIObjClose;
     2190
     2191                    creationCtx.Interface.pfnGetRoots        = sharedClipboardSvcURIGetRoots;
     2192                    creationCtx.Interface.pfnListHdrRead     = sharedClipboardSvcURIListHdrRead;
     2193                    creationCtx.Interface.pfnListEntryRead   = sharedClipboardSvcURIListEntryRead;
     2194                    creationCtx.Interface.pfnObjRead         = sharedClipboardSvcURIObjRead;
     2195                }
     2196            }
     2197            else if (enmDir == SHCLURITRANSFERDIR_WRITE)
     2198            {
     2199                creationCtx.Interface.pfnListHdrWrite   = sharedClipboardSvcURIListHdrWrite;
     2200                creationCtx.Interface.pfnListEntryWrite = sharedClipboardSvcURIListEntryWrite;
     2201                creationCtx.Interface.pfnObjWrite       = sharedClipboardSvcURIObjWrite;
     2202            }
     2203            else
     2204                AssertFailed();
     2205
     2206            creationCtx.enmSource = pClient->State.enmSource;
     2207            creationCtx.pvUser    = pClient;
     2208
     2209            /* Register needed callbacks so that we can wait for the meta data to arrive here. */
     2210            SHCLURITRANSFERCALLBACKS Callbacks;
     2211            RT_ZERO(Callbacks);
     2212
     2213            Callbacks.pvUser                = pClient;
     2214
     2215            Callbacks.pfnTransferPrepare    = VBoxSvcClipboardURITransferPrepareCallback;
     2216            Callbacks.pfnTransferComplete   = VBoxSvcClipboardURITransferCompleteCallback;
     2217            Callbacks.pfnTransferCanceled   = VBoxSvcClipboardURITransferCanceledCallback;
     2218            Callbacks.pfnTransferError      = VBoxSvcClipboardURITransferErrorCallback;
     2219
     2220            SharedClipboardURITransferSetCallbacks(pTransfer, &Callbacks);
     2221
     2222            uint32_t uTransferID = 0;
     2223
     2224            rc = SharedClipboardURITransferSetInterface(pTransfer, &creationCtx);
     2225            if (RT_SUCCESS(rc))
     2226            {
     2227                rc = SharedClipboardSvcImplURITransferCreate(pClient, pTransfer);
     2228                if (RT_SUCCESS(rc))
     2229                {
     2230                    rc = SharedClipboardURICtxTransferRegister(&pClient->URI, pTransfer, &uTransferID);
     2231                    if (RT_SUCCESS(rc))
     2232                    {
     2233                        rc = SharedClipboardURITransferInit(pTransfer, uTransferID, enmDir, enmSource);
     2234                        if (RT_SUCCESS(rc))
     2235                        {
     2236                            SHCLEVENTID uEvent;
     2237                            rc = sharedClipboardSvcURITransferSendStatus(pClient, pTransfer,
     2238                                                                         SHCLURITRANSFERSTATUS_READY, VINF_SUCCESS,
     2239                                                                         &uEvent);
     2240                            if (RT_SUCCESS(rc))
     2241                            {
     2242                                LogRel2(("Shared Clipboard: Waiting for start of transfer %RU32 on guest ...\n",
     2243                                         pTransfer->State.uID));
     2244
     2245                                PSHCLEVENTPAYLOAD pPayload;
     2246                                rc = SharedClipboardEventWait(&pTransfer->Events, uEvent, pTransfer->uTimeoutMs, &pPayload);
     2247                                if (RT_SUCCESS(rc))
     2248                                {
     2249                                    Assert(pPayload->cbData == sizeof(SHCLREPLY));
     2250                                    PSHCLREPLY pReply = (PSHCLREPLY)pPayload->pvData;
     2251                                    AssertPtr(pReply);
     2252
     2253                                    Assert(pReply->uType == VBOX_SHCL_REPLYMSGTYPE_TRANSFER_STATUS);
     2254
     2255                                    if (pReply->u.TransferStatus.uStatus)
     2256                                    {
     2257                                        LogRel2(("Shared Clipboard: Started transfer %RU32 on guest\n", pTransfer->State.uID));
     2258                                    }
     2259                                    else
     2260                                        LogRel(("Shared Clipboard: Guest reported status %s (error %Rrc) while starting transfer %RU32\n",
     2261                                                VBoxClipboardTransferStatusToStr(pReply->u.TransferStatus.uStatus),
     2262                                                pReply->rc, pTransfer->State.uID));
     2263                                }
     2264                                else
     2265                                   LogRel(("Shared Clipboard: Unable to start transfer %RU32 on guest, rc=%Rrc\n",
     2266                                           pTransfer->State.uID, rc));
     2267                            }
     2268                        }
     2269                    }
     2270                }
     2271            }
     2272
     2273            if (RT_FAILURE(rc))
     2274            {
     2275                SharedClipboardURICtxTransferUnregister(&pClient->URI, uTransferID);
     2276
     2277                SharedClipboardURITransferDestroy(pTransfer);
     2278
     2279                RTMemFree(pTransfer);
     2280                pTransfer = NULL;
     2281            }
     2282            else
     2283            {
     2284                if (ppTransfer)
     2285                    *ppTransfer = pTransfer;
     2286            }
     2287        }
     2288
     2289        if (RT_FAILURE(rc))
     2290            LogRel(("Shared Clipboard: Starting transfer failed with %Rrc\n", rc));
     2291    }
     2292    else
     2293        rc = VERR_SHCLPB_MAX_TRANSFERS_REACHED;
     2294
     2295    LogFlowFuncLeaveRC(rc);
     2296    return rc;
     2297}
     2298
     2299/**
     2300 * Stops a transfer, communicating the status to the guest side.
     2301 *
     2302 * @returns VBox status code.
     2303 * @param   pClient             Client that owns the transfer.
     2304 * @param   pTransfer           Transfer to stop.
     2305 */
     2306int sharedClipboardSvcURITransferStop(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer)
     2307{
     2308    int rc = SharedClipboardURITransferClose(pTransfer);
     2309    if (RT_SUCCESS(rc))
     2310    {
     2311        SHCLEVENTID uEvent;
     2312        rc = sharedClipboardSvcURITransferSendStatus(pClient, pTransfer,
     2313                                                     SHCLURITRANSFERSTATUS_STOPPED, VINF_SUCCESS,
     2314                                                     &uEvent);
     2315        if (RT_SUCCESS(rc))
     2316        {
     2317            LogRel2(("Shared Clipboard: Waiting for stop of transfer %RU32 on guest ...\n", pTransfer->State.uID));
     2318
     2319            rc = SharedClipboardEventWait(&pTransfer->Events, uEvent, pTransfer->uTimeoutMs, NULL);
     2320            if (RT_SUCCESS(rc))
     2321            {
     2322                rc = SharedClipboardURICtxTransferUnregister(&pClient->URI, SharedClipboardURITransferGetID(pTransfer));
     2323
     2324                LogRel2(("Shared Clipboard: Stopped transfer %RU32 on guest\n", pTransfer->State.uID));
     2325            }
     2326            else
     2327               LogRel(("Shared Clipboard: Unable to stop transfer %RU32 on guest, rc=%Rrc\n",
     2328                       pTransfer->State.uID, rc));
     2329        }
     2330    }
     2331
     2332    LogFlowFuncLeaveRC(rc);
     2333    return rc;
     2334}
     2335
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