VirtualBox

Changeset 82880 in vbox for trunk/src/VBox/HostServices


Ignore:
Timestamp:
Jan 27, 2020 5:52:41 PM (5 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
135860
Message:

Shared Clipboard: Ditched SHCLDATABLOCK.

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

Legend:

Unmodified
Added
Removed

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

    r82846 r82880  
    212212
    213213int ShClSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
    214                         PSHCLDATABLOCK pData, uint32_t *pcbActual)
     214                        SHCLFORMAT uFormat, uint32_t cbData, void *pvData, uint32_t *pcbActual)
    215215{
    216216    RT_NOREF(pCmdCtx);
    … …  
    222222
    223223    int rc = readFromPasteboard(pClient->State.pCtx->pasteboard,
    224                                 pData->uFormat, pData->pvData, pData->cbData, pcbActual);
     224                                uFormat, pvData, cbData, pcbActual);
    225225
    226226    ShClSvcUnlock();
    … …  
    230230
    231231int ShClSvcImplWriteData(PSHCLCLIENT pClient,
    232                          PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData)
     232                         PSHCLCLIENTCMDCTX pCmdCtx, SHCLFORMAT uFormat, uint32_t cbData, void *pvData)
    233233{
    234234    RT_NOREF(pCmdCtx);
    … …  
    236236    ShClSvcLock();
    237237
    238     writeToPasteboard(pClient->State.pCtx->pasteboard, pData->pvData, pData->cbData, pData->uFormat);
     238    writeToPasteboard(pClient->State.pCtx->pasteboard, pvData, cbData, uFormat);
    239239
    240240    ShClSvcUnlock();

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

    r82872 r82880  
    242242 */
    243243int ShClSvcDataReadRequest(PSHCLCLIENT pClient, SHCLFORMAT fFormat, PSHCLEVENTID pidEvent);
    244 int ShClSvcDataReadSignal(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData);
     244int ShClSvcDataReadSignal(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, SHCLFORMAT uFormat, void *pvData, uint32_t cbData);
    245245int ShClSvcHostReportFormats(PSHCLCLIENT pClient, SHCLFORMATS fFormats);
    246246uint32_t ShClSvcGetMode(void);
    … …  
    293293 * @param   pClient             Shared Clipboard client context.
    294294 * @param   pCmdCtx             Shared Clipboard command context.
    295  * @param   pData               Where to return the read clipboard data.
     295 * @param   uFormat             Clipboard format to read.
     296 * @param   pvData              Where to return the read clipboard data.
     297 * @param   cbData              Size (in bytes) of buffer where to return the clipboard data.
    296298 * @param   pcbActual           Where to return the amount of bytes read.
    297299 */
    298 int ShClSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData, uint32_t *pcbActual);
     300int ShClSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, SHCLFORMAT uFormat, void *pvData, uint32_t cbData, uint32_t *pcbActual);
    299301/**
    300302 * Called when the guest writes clipboard data to the host.
    … …  
    303305 * @param   pClient             Shared Clipboard client context.
    304306 * @param   pCmdCtx             Shared Clipboard command context.
    305  * @param   pData               Clipboard data from the guest.
    306  */
    307 int ShClSvcImplWriteData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData);
     307 * @param   uFormat             Clipboard format to write.
     308 * @param   pvData              Clipboard data to write.
     309 * @param   cbData              Size (in bytes) of buffer clipboard data to write.
     310 */
     311int ShClSvcImplWriteData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, SHCLFORMAT uFormat, void *pvData, uint32_t cbData);
    308312/**
    309313 * Called when synchronization of the clipboard contents of the host clipboard with the guest is needed.

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

    r82851 r82880  
    729729
    730730int ShClSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
    731                         PSHCLDATABLOCK pData, uint32_t *pcbActual)
     731                        SHCLFORMAT uFormat, uint32_t cbData, void *pvData, uint32_t *pcbActual)
    732732{
    733733    AssertPtrReturn(pClient,             VERR_INVALID_POINTER);
    734734    RT_NOREF(pCmdCtx);
     735    AssertPtrReturn(pvData,              VERR_INVALID_POINTER);
    735736    AssertPtrReturn(pClient->State.pCtx, VERR_INVALID_POINTER);
    736737
    737     LogFlowFunc(("uFormat=%02X\n", pData->uFormat));
     738    LogFlowFunc(("uFormat=%02X\n", uFormat));
    738739
    739740    HANDLE hClip = NULL;
    … …  
    749750        LogFunc(("Clipboard opened\n"));
    750751
    751         if (pData->uFormat & VBOX_SHCL_FMT_BITMAP)
     752        if (uFormat & VBOX_SHCL_FMT_BITMAP)
    752753        {
    753754            hClip = GetClipboardData(CF_DIB);
    … …  
    761762
    762763                    vboxClipboardSvcWinGetData(VBOX_SHCL_FMT_BITMAP, lp, GlobalSize(hClip),
    763                                                pData->pvData, pData->cbData, pcbActual);
     764                                               pvData, cbData, pcbActual);
    764765
    765766                    GlobalUnlock(hClip);
    … …  
    771772            }
    772773        }
    773         else if (pData->uFormat & VBOX_SHCL_FMT_UNICODETEXT)
     774        else if (uFormat & VBOX_SHCL_FMT_UNICODETEXT)
    774775        {
    775776            hClip = GetClipboardData(CF_UNICODETEXT);
    … …  
    783784
    784785                    vboxClipboardSvcWinGetData(VBOX_SHCL_FMT_UNICODETEXT, uniString, (lstrlenW(uniString) + 1) * 2,
    785                                                pData->pvData, pData->cbData, pcbActual);
     786                                               pvData, cbData, pcbActual);
    786787
    787788                    GlobalUnlock(hClip);
    … …  
    793794            }
    794795        }
    795         else if (pData->uFormat & VBOX_SHCL_FMT_HTML)
     796        else if (uFormat & VBOX_SHCL_FMT_HTML)
    796797        {
    797798            UINT format = RegisterClipboardFormat(SHCL_WIN_REGFMT_HTML);
    … …  
    806807                        /** @todo r=andy Add data overflow handling. */
    807808                        vboxClipboardSvcWinGetData(VBOX_SHCL_FMT_HTML, lp, GlobalSize(hClip),
    808                                                    pData->pvData, pData->cbData, pcbActual);
     809                                                   pvData, cbData, pcbActual);
    809810#ifdef VBOX_STRICT
    810811                        LogFlowFunc(("Raw HTML clipboard data from host:"));
    811                         ShClDbgDumpHtml((char *)pData->pvData, pData->cbData);
     812                        ShClDbgDumpHtml((char *)pvData, cbData);
    812813#endif
    813814                        GlobalUnlock(hClip);
    … …  
    821822        }
    822823#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    823         else if (pData->uFormat & VBOX_SHCL_FMT_URI_LIST)
     824        else if (uFormat & VBOX_SHCL_FMT_URI_LIST)
    824825        {
    825826            AssertFailed(); /** @todo */
    … …  
    832833    {
    833834        /* Reply with empty data. */
    834         vboxClipboardSvcWinGetData(0, NULL, 0, pData->pvData, pData->cbData, pcbActual);
     835        vboxClipboardSvcWinGetData(0, NULL, 0, pvData, cbData, pcbActual);
    835836    }
    836837
    … …  
    840841
    841842int ShClSvcImplWriteData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
    842                          PSHCLDATABLOCK pData)
     843                         SHCLFORMAT uFormat, uint32_t cbData, void *pvData)
    843844{
    844845    LogFlowFuncEnter();
    845846
    846     int rc = ShClSvcDataReadSignal(pClient, pCmdCtx, pData);
     847    int rc = ShClSvcDataReadSignal(pClient, pCmdCtx, uFormat, cbData, pvData);
    847848
    848849    LogFlowFuncLeaveRC(rc);

  • trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11-stubs.cpp

    r81820 r82880  
    107107 * @param pClient       Context information about the guest VM
    108108 * @param pCmdCtx       Command context to use.
    109  * @param pData         Data block to put read data into.
     109 * @param uFormat       Clipboard format to read.
     110 * @param pvData        Where to return the read clipboard data.
     111 * @param cbData        Size (in bytes) of buffer where to return the clipboard data.
    110112 * @param pcbActual     Where to store the actual amount of data available.
    111113 */
    112114int SharedClipboardSvcImplReadData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
    113                                    PSHCLDATABLOCK pData, uint32_t *pcbActual)
     115                                   SHCLFORMAT uFormat, void *pvData, uint32_t cbData, uint32_t *pcbActual)
    114116{
    115     RT_NOREF(pClient, pCmdCtx, pData);
     117    RT_NOREF(pClient, pCmdCtx, uFormat, pvData, cbData);
    116118
    117119    /* No data available. */
    … …  
    122124
    123125int SharedClipboardSvcImplWriteData(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
    124                                     PSHCLDATABLOCK pData)
     126                                    SHCLFORMAT uFormat, void *pvData, uint32_t cbData)
    125127{
    126     RT_NOREF(pClient, pCmdCtx, pData);
     128    RT_NOREF(pClient, pCmdCtx, uFormat, pvData, cbData);
    127129    return VERR_NOT_IMPLEMENTED;
    128130}

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

    r82875 r82880  
    177177 */
    178178int ShClSvcImplReadData(PSHCLCLIENT pClient,
    179                         PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData, uint32_t *pcbActual)
    180 {
     179                        PSHCLCLIENTCMDCTX pCmdCtx, SHCLFORMAT uFormat, void *pvData, uint32_t cbData, uint32_t *pcbActual)
     180{
     181    AssertPtrReturn(pClient, VERR_INVALID_POINTER);
     182    AssertPtrReturn(pCmdCtx, VERR_INVALID_POINTER);
     183    AssertPtrReturn(pvData,  VERR_INVALID_POINTER);
     184
    181185    RT_NOREF(pCmdCtx);
    182186
    183187    LogFlowFunc(("pClient=%p, uFormat=%02X, pv=%p, cb=%u, pcbActual=%p\n",
    184                  pClient, pData->uFormat, pData->pvData, pData->cbData, pcbActual));
     188                 pClient, uFormat, pvData, cbData, pcbActual));
    185189
    186190    int rc = VINF_SUCCESS;
    … …  
    189193    if (pReq)
    190194    {
    191         pReq->pv        = pData->pvData;
    192         pReq->cb        = pData->cbData;
     195        pReq->pv        = pvData;
     196        pReq->cb        = cbData;
    193197        pReq->pcbActual = pcbActual;
    194198        const SHCLEVENTID idEvent = ShClEventIdGenerateAndRegister(&pClient->EventSrc);
    … …  
    196200        if (idEvent != NIL_SHCLEVENTID)
    197201        {
    198             rc = ShClX11ReadDataFromX11(&pClient->State.pCtx->X11, pData->uFormat, pReq);
     202            rc = ShClX11ReadDataFromX11(&pClient->State.pCtx->X11, uFormat, pReq);
    199203            if (RT_SUCCESS(rc))
    200204            {
    … …  
    203207                if (RT_SUCCESS(rc))
    204208                {
    205                     memcpy(pData->pvData, pPayload->pvData, RT_MIN(pData->cbData, pPayload->cbData));
    206                     pData->cbData = (uint32_t)pPayload->cbData; /** @todo r=bird: Just ditch this data block wrapper, it made you forget to set pcbActual! */
     209                    memcpy(pvData, pPayload->pvData, RT_MIN(cbData, pPayload->cbData));
     210
    207211                    *pcbActual = (uint32_t)pPayload->cbData;
    208212
    … …  
    227231
    228232int ShClSvcImplWriteData(PSHCLCLIENT pClient,
    229                          PSHCLCLIENTCMDCTX pCmdCtx, PSHCLDATABLOCK pData)
     233                         PSHCLCLIENTCMDCTX pCmdCtx, SHCLFORMAT uFormat, void *pvData, uint32_t cbData)
    230234{
    231235    AssertPtrReturn(pClient, VERR_INVALID_POINTER);
    232236    AssertPtrReturn(pCmdCtx, VERR_INVALID_POINTER);
    233     AssertPtrReturn(pData,   VERR_INVALID_POINTER);
     237    AssertPtrReturn(pvData,  VERR_INVALID_POINTER);
    234238
    235239    LogFlowFunc(("pClient=%p, pv=%p, cb=%RU32, uFormat=%02X\n",
    236                  pClient, pData->pvData, pData->cbData, pData->uFormat));
    237 
    238     int rc = ShClSvcDataReadSignal(pClient, pCmdCtx, pData);
     240                 pClient, pvData, cbData, uFormat));
     241
     242    int rc = ShClSvcDataReadSignal(pClient, pCmdCtx, uFormat, pvData, cbData);
    239243
    240244    LogFlowFuncLeaveRC(rc);

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

    r82875 r82880  
    12501250
    12511251int ShClSvcDataReadSignal(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx,
    1252                           PSHCLDATABLOCK pData)
     1252                          SHCLFORMAT uFormat, void *pvData, uint32_t cbData)
    12531253{
    12541254    AssertPtrReturn(pClient, VERR_INVALID_POINTER);
    12551255    AssertPtrReturn(pCmdCtx, VERR_INVALID_POINTER);
    1256     AssertPtrReturn(pData,   VERR_INVALID_POINTER);
     1256    AssertPtrReturn(pvData,  VERR_INVALID_POINTER);
     1257
     1258    RT_NOREF(uFormat);
    12571259
    12581260    LogFlowFuncEnter();
    … …  
    12711273
    12721274    PSHCLEVENTPAYLOAD pPayload = NULL;
    1273     if (pData->cbData)
    1274         rc = ShClPayloadAlloc(idEvent, pData->pvData, pData->cbData, &pPayload);
     1275    if (cbData)
     1276        rc = ShClPayloadAlloc(idEvent, pvData, cbData, &pPayload);
    12751277
    12761278    if (RT_SUCCESS(rc))
    … …  
    14791481    }
    14801482
    1481     SHCLDATABLOCK dataBlock;
     1483    SHCLFORMAT  uFormat = VBOX_SHCL_FMT_NONE;
     1484    uint32_t    cbData  = 0;
     1485    void       *pvData  = NULL;
     1486
    14821487    ASSERT_GUEST_RETURN(paParms[iParm].type == VBOX_HGCM_SVC_PARM_32BIT, VERR_WRONG_PARAMETER_TYPE);
    1483     dataBlock.uFormat = paParms[iParm].u.uint32;
     1488    uFormat = paParms[iParm].u.uint32;
    14841489    iParm++;
    14851490    if (cParms != VBOX_SHCL_CPARMS_DATA_READ_61B)
    14861491    {
    14871492        ASSERT_GUEST_RETURN(paParms[iParm].type == VBOX_HGCM_SVC_PARM_PTR, VERR_WRONG_PARAMETER_TYPE); /* Data buffer */
    1488         dataBlock.pvData = paParms[iParm].u.pointer.addr;
    1489         dataBlock.cbData = paParms[iParm].u.pointer.size;
     1493        pvData = paParms[iParm].u.pointer.addr;
     1494        cbData = paParms[iParm].u.pointer.size;
    14901495        iParm++;
    14911496        ASSERT_GUEST_RETURN(paParms[iParm].type == VBOX_HGCM_SVC_PARM_32BIT, VERR_WRONG_PARAMETER_TYPE); /*cbDataReturned*/
    … …  
    14971502        iParm++;
    14981503        ASSERT_GUEST_RETURN(paParms[iParm].type == VBOX_HGCM_SVC_PARM_PTR, VERR_WRONG_PARAMETER_TYPE); /* Data buffer */
    1499         dataBlock.pvData = paParms[iParm].u.pointer.addr;
    1500         dataBlock.cbData = paParms[iParm].u.pointer.size;
     1504        pvData = paParms[iParm].u.pointer.addr;
     1505        cbData = paParms[iParm].u.pointer.size;
    15011506        iParm++;
    15021507    }
    … …  
    15111516    {
    15121517        if (pClient->State.POD.uFormat == VBOX_SHCL_FMT_NONE)
    1513             pClient->State.POD.uFormat = dataBlock.uFormat;
     1518            pClient->State.POD.uFormat = uFormat;
    15141519    }
    15151520
    … …  
    15261531        RT_ZERO(parms);
    15271532
    1528         parms.uFormat  = dataBlock.uFormat;
    1529         parms.u.pvData = dataBlock.pvData;
    1530         parms.cbData   = dataBlock.cbData;
     1533        parms.uFormat  = uFormat;
     1534        parms.u.pvData = pvData;
     1535        parms.cbData   = cbData;
    15311536
    15321537        g_ExtState.fReadingData = true;
    … …  
    15351540        rc = g_ExtState.pfnExtension(g_ExtState.pvExtension, VBOX_CLIPBOARD_EXT_FN_DATA_READ, &parms, sizeof(parms));
    15361541        LogRelFlowFunc(("Shared Clipboard: DATA/Ext: fDelayedAnnouncement=%RTbool fDelayedFormats=%#x cbData=%RU32->%RU32 rc=%Rrc\n",
    1537                         g_ExtState.fDelayedAnnouncement, g_ExtState.fDelayedFormats, dataBlock.cbData, parms.cbData, rc));
     1542                        g_ExtState.fDelayedAnnouncement, g_ExtState.fDelayedFormats, cbData, parms.cbData, rc));
    15381543
    15391544        /* Did the extension send the clipboard formats yet?
    … …  
    15551560    else
    15561561    {
    1557         rc = ShClSvcImplReadData(pClient, &cmdCtx, &dataBlock, &cbActual);
    1558         LogRelFlowFunc(("Shared Clipboard: DATA/Host: cbData=%RU32->%RU32 rc=%Rrc\n", dataBlock.cbData, cbActual, rc));
     1562        rc = ShClSvcImplReadData(pClient, &cmdCtx, uFormat, pvData, cbData, &cbActual);
     1563        LogRelFlowFunc(("Shared Clipboard: DATA/Host: cbData=%RU32->%RU32 rc=%Rrc\n", cbData, cbActual, rc));
    15591564    }
    15601565
    … …  
    15681573
    15691574        /* If the data to return exceeds the buffer the guest supplies, tell it (and let it try again). */
    1570         if (cbActual >= dataBlock.cbData)
     1575        if (cbActual >= cbData)
    15711576            rc = VINF_BUFFER_OVERFLOW;
    15721577    }
    … …  
    16261631        iParm++;
    16271632    }
    1628     SHCLDATABLOCK dataBlock;
     1633
     1634    SHCLFORMAT  uFormat = VBOX_SHCL_FMT_NONE;
     1635    uint32_t    cbData  = 0;
     1636    void       *pvData  = NULL;
     1637
    16291638    ASSERT_GUEST_RETURN(paParms[iParm].type == VBOX_HGCM_SVC_PARM_32BIT, VERR_WRONG_PARAMETER_TYPE); /* Format bit. */
    1630     dataBlock.uFormat = paParms[iParm].u.uint32;
     1639    uFormat = paParms[iParm].u.uint32;
    16311640    iParm++;
    16321641    if (cParms == VBOX_SHCL_CPARMS_DATA_WRITE_61B)
    … …  
    16361645    }
    16371646    ASSERT_GUEST_RETURN(paParms[iParm].type == VBOX_HGCM_SVC_PARM_PTR, VERR_WRONG_PARAMETER_TYPE); /* Data buffer */
    1638     dataBlock.pvData = paParms[iParm].u.pointer.addr;
    1639     dataBlock.cbData = paParms[iParm].u.pointer.size;
     1647    pvData = paParms[iParm].u.pointer.addr;
     1648    cbData = paParms[iParm].u.pointer.size;
    16401649    iParm++;
    16411650    Assert(iParm == cParms);
    … …  
    16491658    {
    16501659        if (pClient->State.POD.uFormat == VBOX_SHCL_FMT_NONE)
    1651             pClient->State.POD.uFormat = dataBlock.uFormat;
     1660            pClient->State.POD.uFormat = uFormat;
    16521661    }
    16531662
    … …  
    16601669        SHCLEXTPARMS parms;
    16611670        RT_ZERO(parms);
    1662         parms.uFormat   = dataBlock.uFormat;
    1663         parms.u.pvData  = dataBlock.pvData;
    1664         parms.cbData    = dataBlock.cbData;
     1671        parms.uFormat   = uFormat;
     1672        parms.u.pvData  = pvData;
     1673        parms.cbData    = cbData;
    16651674
    16661675        g_ExtState.pfnExtension(g_ExtState.pvExtension, VBOX_CLIPBOARD_EXT_FN_DATA_WRITE, &parms, sizeof(parms));
    … …  
    16681677    }
    16691678    else
    1670         rc = ShClSvcImplWriteData(pClient, &cmdCtx, &dataBlock);
     1679        rc = ShClSvcImplWriteData(pClient, &cmdCtx, uFormat, pvData, cbData);
    16711680
    16721681    LogFlowFuncLeaveRC(rc);

  • trunk/src/VBox/HostServices/SharedClipboard/testcase/tstClipboardServiceHost.cpp

    r82846 r82880  
    307307int ShClSvcImplConnect(PSHCLCLIENT, bool) { return VINF_SUCCESS; }
    308308int ShClSvcImplFormatAnnounce(PSHCLCLIENT, PSHCLCLIENTCMDCTX, PSHCLFORMATDATA) { AssertFailed(); return VINF_SUCCESS; }
    309 int ShClSvcImplReadData(PSHCLCLIENT, PSHCLCLIENTCMDCTX, PSHCLDATABLOCK, unsigned int *) { AssertFailed(); return VERR_WRONG_ORDER; }
    310 int ShClSvcImplWriteData(PSHCLCLIENT, PSHCLCLIENTCMDCTX, PSHCLDATABLOCK) { AssertFailed(); return VINF_SUCCESS; }
     309int ShClSvcImplReadData(PSHCLCLIENT, PSHCLCLIENTCMDCTX, SHCLFORMAT uFormat, uint32_t cbData, void *pvData, unsigned int *) { AssertFailed(); return VERR_WRONG_ORDER; }
     310int ShClSvcImplWriteData(PSHCLCLIENT, PSHCLCLIENTCMDCTX, SHCLFORMAT uFormat, uint32_t cbData, void *pvData) { AssertFailed(); return VINF_SUCCESS; }
    311311int ShClSvcImplSync(PSHCLCLIENT) { return VINF_SUCCESS; }
    312312
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