VirtualBox

Ignore:
Timestamp:
Aug 21, 2019 8:37:54 AM (6 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
132824
Message:

Shared Clipboard/URI: Update.

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

Legend:

Unmodified
Added
Removed

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

    r80318 r80359  
    418418                               PSHAREDCLIPBOARDOBJHANDLE phObj)
    419419{
    420     RT_NOREF(pCtx, pCreateParms, phObj);
    421 
    422420    LogFlowFuncEnter();
    423421
    424     int rc = VINF_SUCCESS;
    425 
    426     PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser;
    427     AssertPtr(pThisCtx);
    428 
    429     RT_NOREF(pThisCtx);
     422    PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pCtx->pvUser;
     423    AssertPtr(pClient);
     424
     425    int rc;
     426
     427    PVBOXCLIPBOARDCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN,
     428                                                            VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_OPEN);
     429    if (pMsg)
     430    {
     431        const uint16_t uEvent = SharedClipboardURITransferEventIDGenerate(pCtx->pTransfer);
     432
     433        LogFlowFunc(("pszPath=%s, fCreate=0x%x\n", pCreateParms->pszPath, pCreateParms->fCreate));
     434
     435        const uint32_t cbPath = (uint32_t)strlen(pCreateParms->pszPath) + 1; /* Include terminating zero */
     436
     437        HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent));
     438        HGCMSvcSetU64(&pMsg->m_paParms[1], 0); /* uHandle */
     439        HGCMSvcSetU32(&pMsg->m_paParms[2], cbPath);
     440        HGCMSvcSetPv (&pMsg->m_paParms[3], pCreateParms->pszPath, cbPath);
     441        HGCMSvcSetU32(&pMsg->m_paParms[4], pCreateParms->fCreate);
     442
     443        rc = vboxSvcClipboardMsgAdd(pClient->pData, pMsg, true /* fAppend */);
     444        if (RT_SUCCESS(rc))
     445        {
     446            int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, uEvent);
     447            AssertRC(rc2);
     448
     449            rc = vboxSvcClipboardClientWakeup(pClient);
     450            if (RT_SUCCESS(rc))
     451            {
     452                PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
     453                rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
     454                if (RT_SUCCESS(rc))
     455                {
     456                    Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDREPLY));
     457
     458                    PVBOXCLIPBOARDREPLY pReply = (PVBOXCLIPBOARDREPLY)pPayload->pvData;
     459                    AssertPtr(pReply);
     460
     461                    Assert(pReply->uType == VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_OBJ_OPEN);
     462
     463                    *phObj = pReply->u.ObjOpen.uHandle;
     464
     465                    SharedClipboardURITransferPayloadFree(pPayload);
     466                }
     467            }
     468        }
     469    }
     470    else
     471        rc = VERR_NO_MEMORY;
    430472
    431473    LogFlowFuncLeaveRC(rc);
    … …  
    435477int vboxSvcClipboardURIObjClose(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj)
    436478{
    437     RT_NOREF(pCtx, hObj);
    438 
    439479    LogFlowFuncEnter();
    440480
    441     int rc = VINF_SUCCESS;
    442 
    443     PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser;
    444     AssertPtr(pThisCtx);
    445 
    446     RT_NOREF(pThisCtx);
     481    PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pCtx->pvUser;
     482    AssertPtr(pClient);
     483
     484    int rc;
     485
     486    PVBOXCLIPBOARDCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE,
     487                                                            VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_CLOSE);
     488    if (pMsg)
     489    {
     490        const uint16_t uEvent = SharedClipboardURITransferEventIDGenerate(pCtx->pTransfer);
     491
     492        HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent));
     493        HGCMSvcSetU64(&pMsg->m_paParms[1], hObj);
     494
     495        rc = vboxSvcClipboardMsgAdd(pClient->pData, pMsg, true /* fAppend */);
     496        if (RT_SUCCESS(rc))
     497        {
     498            int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, uEvent);
     499            AssertRC(rc2);
     500
     501            rc = vboxSvcClipboardClientWakeup(pClient);
     502            if (RT_SUCCESS(rc))
     503            {
     504                PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
     505                rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
     506                if (RT_SUCCESS(rc))
     507                {
     508                    Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDREPLY));
     509
     510                    PVBOXCLIPBOARDREPLY pReply = (PVBOXCLIPBOARDREPLY)pPayload->pvData;
     511                    AssertPtr(pReply);
     512
     513                    Assert(pReply->uType == VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_OBJ_CLOSE);
     514
     515                    SharedClipboardURITransferPayloadFree(pPayload);
     516                }
     517            }
     518        }
     519    }
     520    else
     521        rc = VERR_NO_MEMORY;
    447522
    448523    LogFlowFuncLeaveRC(rc);
    … …  
    453528                               void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead)
    454529{
    455     RT_NOREF(pCtx, hObj, pvData, cbData, fFlags, pcbRead);
    456 
    457530    LogFlowFuncEnter();
    458531
    459     int rc = VINF_SUCCESS;
    460 
    461     *pcbRead = cbData;
     532    PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pCtx->pvUser;
     533    AssertPtr(pClient);
     534
     535    int rc;
     536
     537    PVBOXCLIPBOARDCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ,
     538                                                            VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_READ_REQ);
     539    if (pMsg)
     540    {
     541        const uint16_t uEvent = SharedClipboardURITransferEventIDGenerate(pCtx->pTransfer);
     542
     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);
     547
     548        rc = vboxSvcClipboardMsgAdd(pClient->pData, pMsg, true /* fAppend */);
     549        if (RT_SUCCESS(rc))
     550        {
     551            int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, uEvent);
     552            AssertRC(rc2);
     553
     554            rc = vboxSvcClipboardClientWakeup(pClient);
     555            if (RT_SUCCESS(rc))
     556            {
     557                PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
     558                rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
     559                if (RT_SUCCESS(rc))
     560                {
     561                    Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDOBJDATACHUNK));
     562
     563                    PVBOXCLIPBOARDOBJDATACHUNK pDataChunk = (PVBOXCLIPBOARDOBJDATACHUNK)pPayload->pvData;
     564                    AssertPtr(pDataChunk);
     565
     566                    const uint32_t cbRead = RT_MIN(cbData, pDataChunk->cbData);
     567
     568                    memcpy(pvData, pDataChunk->pvData, cbRead);
     569
     570                    if (pcbRead)
     571                        *pcbRead = cbRead;
     572
     573                    SharedClipboardURITransferPayloadFree(pPayload);
     574                }
     575            }
     576        }
     577    }
     578    else
     579        rc = VERR_NO_MEMORY;
    462580
    463581    LogFlowFuncLeaveRC(rc);
    … …  
    468586                                void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten)
    469587{
    470     RT_NOREF(pCtx, pCtx, hObj, pvData, cbData, fFlags, pcbWritten);
    471 
    472588    LogFlowFuncEnter();
    473589
    474     return VERR_NOT_IMPLEMENTED;
    475 }
    476 
     590    PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pCtx->pvUser;
     591    AssertPtr(pClient);
     592
     593    int rc;
     594
     595    PVBOXCLIPBOARDCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_WRITE,
     596                                                            VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_WRITE);
     597    if (pMsg)
     598    {
     599        const uint16_t uEvent = SharedClipboardURITransferEventIDGenerate(pCtx->pTransfer);
     600
     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);
     605
     606        rc = vboxSvcClipboardMsgAdd(pClient->pData, pMsg, true /* fAppend */);
     607        if (RT_SUCCESS(rc))
     608        {
     609            int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, uEvent);
     610            AssertRC(rc2);
     611
     612            rc = vboxSvcClipboardClientWakeup(pClient);
     613            if (RT_SUCCESS(rc))
     614            {
     615                PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
     616                rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
     617                if (RT_SUCCESS(rc))
     618                {
     619                    const uint32_t cbRead = RT_MIN(cbData, pPayload->cbData);
     620
     621                    memcpy(pvData, pPayload->pvData, cbRead);
     622
     623                    if (pcbWritten)
     624                        *pcbWritten = cbRead;
     625
     626                    SharedClipboardURITransferPayloadFree(pPayload);
     627                }
     628            }
     629        }
     630    }
     631    else
     632        rc = VERR_NO_MEMORY;
     633
     634    LogFlowFuncLeaveRC(rc);
     635    return rc;
     636}
    477637
    478638/*********************************************************************************************************************************
    … …  
    549709        if (RT_SUCCESS(rc))
    550710        {
     711            rc = VERR_INVALID_PARAMETER; /* Play safe. */
     712
    551713            switch (pReply->uType)
    552714            {
    … …  
    554716                {
    555717                    if (cParms >= 6)
    556                     {
    557718                        rc = HGCMSvcGetU64(&paParms[5], &pReply->u.ListOpen.uHandle);
    558                     }
    559                     else
    560                         rc = VERR_INVALID_PARAMETER;
    561719                    break;
    562720                }
    … …  
    565723                {
    566724                    if (cParms >= 6)
    567                     {
    568725                        rc = HGCMSvcGetU64(&paParms[5], &pReply->u.ObjOpen.uHandle);
    569                     }
    570                     else
    571                         rc = VERR_INVALID_PARAMETER;
    572726                    break;
    573727                }
    574728
     729                case VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_OBJ_CLOSE:
     730                {
     731                    if (cParms >= 6)
     732                        rc = HGCMSvcGetU64(&paParms[5], &pReply->u.ObjClose.uHandle);
     733                    break;
     734                }
     735
    575736                default:
     737                    rc = VERR_NOT_SUPPORTED;
    576738                    break;
    577739            }
    … …  
    9031065
    9041066        rc = VINF_SUCCESS;
     1067    }
     1068    else
     1069        rc = VERR_INVALID_PARAMETER;
     1070
     1071    LogFlowFuncLeaveRC(rc);
     1072    return rc;
     1073}
     1074
     1075/**
     1076 * Gets an URI object data chunk from HGCM service parameters.
     1077 *
     1078 * @returns VBox status code.
     1079 * @param   cParms              Number of HGCM parameters supplied in \a paParms.
     1080 * @param   paParms             Array of HGCM parameters.
     1081 * @param   pDataChunk          Where to store the object data chunk data.
     1082 */
     1083static int vboxSvcClipboardURIGetObjDataChunk(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDOBJDATACHUNK pDataChunk)
     1084{
     1085    AssertPtrReturn(paParms,    VERR_INVALID_PARAMETER);
     1086    AssertPtrReturn(pDataChunk, VERR_INVALID_PARAMETER);
     1087
     1088    int rc;
     1089
     1090    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_WRITE)
     1091    {
     1092        rc = HGCMSvcGetU64(&paParms[1], &pDataChunk->uHandle);
     1093        if (RT_SUCCESS(rc))
     1094        {
     1095            uint32_t cbData;
     1096            rc = HGCMSvcGetU32(&paParms[2], &cbData);
     1097            if (RT_SUCCESS(rc))
     1098            {
     1099                rc = HGCMSvcGetPv(&paParms[3], &pDataChunk->pvData, &pDataChunk->cbData);
     1100                AssertReturn(cbData == pDataChunk->cbData, VERR_INVALID_PARAMETER);
     1101
     1102                /** @todo Implement checksum handling. */
     1103            }
     1104        }
    9051105    }
    9061106    else
    … …  
    12521452                    rc = SharedClipboardURITransferPayloadAlloc(uEvent, pvData, cbData, &pPayload);
    12531453                    if (RT_SUCCESS(rc))
     1454                    {
    12541455                        rc = SharedClipboardURITransferEventSignal(pTransfer, uEvent, pPayload);
     1456                        if (RT_FAILURE(rc))
     1457                            SharedClipboardURITransferPayloadFree(pPayload);
     1458                    }
    12551459                }
    12561460            }
    … …  
    12971501                    rc = SharedClipboardURITransferPayloadAlloc(uEvent, pvData, cbData, &pPayload);
    12981502                    if (RT_SUCCESS(rc))
     1503                    {
    12991504                        rc = SharedClipboardURITransferEventSignal(pTransfer, uEvent, pPayload);
     1505                        if (RT_FAILURE(rc))
     1506                            SharedClipboardURITransferPayloadFree(pPayload);
     1507                    }
    13001508                }
    13011509            }
    … …  
    13731581                        rc = SharedClipboardURITransferPayloadAlloc(uEvent, pvData, cbData, &pPayload);
    13741582                        if (RT_SUCCESS(rc))
     1583                        {
    13751584                            rc = SharedClipboardURITransferEventSignal(pTransfer, uEvent, pPayload);
     1585                            if (RT_FAILURE(rc))
     1586                                SharedClipboardURITransferPayloadFree(pPayload);
     1587                        }
    13761588                    }
    13771589                }
    … …  
    14171629                        rc = SharedClipboardURITransferPayloadAlloc(uEvent, pvData, cbData, &pPayload);
    14181630                        if (RT_SUCCESS(rc))
     1631                        {
    14191632                            rc = SharedClipboardURITransferEventSignal(pTransfer, uEvent, pPayload);
     1633                            if (RT_FAILURE(rc))
     1634                                SharedClipboardURITransferPayloadFree(pPayload);
     1635                        }
    14201636                    }
    14211637                }
    14221638            }
     1639            break;
     1640        }
     1641
     1642    #if 0
     1643        case VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_OPEN:
     1644        {
     1645            break;
     1646        }
     1647
     1648        case VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_CLOSE:
     1649        {
     1650            break;
     1651        }
     1652
     1653        case VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_READ:
     1654        {
     1655            break;
     1656        }
     1657    #endif
     1658
     1659        case VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_WRITE:
     1660        {
     1661            VBOXCLIPBOARDOBJDATACHUNK dataChunk;
     1662            rc = vboxSvcClipboardURIGetObjDataChunk(cParms, paParms, &dataChunk);
     1663            if (RT_SUCCESS(rc))
     1664            {
     1665                void    *pvData = SharedClipboardURIObjectDataChunkDup(&dataChunk);
     1666                uint32_t cbData = sizeof(VBOXCLIPBOARDOBJDATACHUNK);
     1667
     1668                uint32_t uCID;
     1669                rc = HGCMSvcGetU32(&paParms[0], &uCID);
     1670                if (RT_SUCCESS(rc))
     1671                {
     1672                    const uint16_t uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
     1673
     1674                    PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
     1675                    rc = SharedClipboardURITransferPayloadAlloc(uEvent, pvData, cbData, &pPayload);
     1676                    if (RT_SUCCESS(rc))
     1677                    {
     1678                        rc = SharedClipboardURITransferEventSignal(pTransfer, uEvent, pPayload);
     1679                        if (RT_FAILURE(rc))
     1680                            SharedClipboardURITransferPayloadFree(pPayload);
     1681                    }
     1682                }
     1683            }
     1684
    14231685            break;
    14241686        }

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

    r80283 r80359  
    640640            if (pFirstMsg)
    641641            {
    642                 LogFlowFunc(("[Client %RU32] Current host message is %RU32 (cParms=%RU32)\n",
    643                              pClient->uClientID, pFirstMsg->m_uMsg, pFirstMsg->m_cParms));
     642                LogFlowFunc(("[Client %RU32] Current host message is %RU32 (%s), cParms=%RU32\n",
     643                             pClient->uClientID, pFirstMsg->m_uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->m_uMsg),
     644                             pFirstMsg->m_cParms));
    644645
    645646                if (pClient->Pending.uType == VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT)
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