VirtualBox

Changeset 100204 in vbox for trunk/src/VBox/Additions/common


Ignore:
Timestamp:
Jun 19, 2023 9:11:37 AM (22 months ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
157911
Message:

Shared Clipboard: Unified root list entry code to also use the generic list entry code, a lot of updates for the cross OS transfer handling code, more updates for HTTP server transfer handling.

This also changed the handling of how that transfers are being initiated, as we needed to have this for X11: Before, transfers were initiated as soon as on side announced the URI list format -- now we postpone initiating the transfer until the receiving side requests the data as URI list.

bugref:9437

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR3LibClipboard.cpp

    r100015 r100204  
    5454#include <iprt/string.h>
    5555#include <iprt/cpp/ministring.h>
     56
     57#ifdef LOG_GROUP
     58 #undef LOG_GROUP
     59#endif
     60#define LOG_GROUP LOG_GROUP_SHARED_CLIPBOARD
     61#include <VBox/log.h>
    5662
    5763#include "VBoxGuestR3LibInternal.h"
    … …  
    176182                {
    177183                    if (!(pCtx->fHostFeatures & VBOX_SHCL_HF_0_TRANSFERS))
    178                         LogRel2(("Shared Clipboard: Host does not support transfers\n"));
     184                        LogRel(("Shared Clipboard: Host does not support transfers\n"));
    179185                }
    180186#endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
    … …  
    424430 * Reads data from the host clipboard.
    425431 *
    426  * Legacy function, do not use anymore.
    427  *
    428432 * @returns VBox status code.
    429433 * @retval  VINF_BUFFER_OVERFLOW    If there is more data available than the caller provided buffer space for.
    … …  
    433437 * @param   pvData          Where to store the data.
    434438 * @param   cbData          The size of the buffer pointed to by \a pvData.
     439 *                          This also indicates the maximum size to read.
    435440 * @param   pcbRead         The actual size of the host clipboard data. May be larger than \a cbData.
    436441 */
    … …  
    438443                                        uint32_t *pcbRead)
    439444{
    440     LogFlowFuncEnter();
     445    LogFlowFunc(("fFormat=%#x, pvData=%p, cbData=%RU32\n", fFormat, pvData, cbData));
    441446
    442447    struct
    … …  
    532537
    533538/**
     539 * Peeks at the next host message, extended version.
     540 *
     541 * This glosses over the difference between new (6.1) and old (1.3.2) host
     542 * service versions, however it does so by abusing @a pcParameters, so don't use
     543 * it directly when in legacy mode, always pass it on to
     544 * VbglR3ClipboardEventGetNext() or VbglR3ClipboardEventGetNextEx().
     545 *
     546 * @returns VBox status code.
     547 * @retval  VERR_INTERRUPTED if interrupted.  Does the necessary cleanup, so
     548 *          caller just have to repeat this call.
     549 * @retval  VERR_VM_RESTORED if the VM has been restored (idRestoreCheck).
     550 * @retval  VERR_TRY_AGAIN if no new message is available.
     551 *
     552 * @param   pCtx            Shared Clipboard command context to use for the connection.
     553 * @param   fWait           Wait for new messages to arrive if \c true, return immediately if \c false.
     554 * @param   pidMsg          Where to store the message id.
     555 * @param   pcParameters    Where to store the number  of parameters which will
     556 *                          be received in a second call to the host.
     557 * @param   pidRestoreCheck Pointer to the VbglR3GetSessionId() variable to use
     558 *                          for the VM restore check.  Optional.
     559 *
     560 * @note    Restore check is only performed optimally with a 6.0 host.
     561 */
     562static int vbglR3ClipboardMsgPeekEx(PVBGLR3SHCLCMDCTX pCtx, bool fWait, uint32_t *pidMsg,
     563                                    uint32_t *pcParameters, uint64_t *pidRestoreCheck)
     564{
     565    AssertPtrReturn(pidMsg, VERR_INVALID_POINTER);
     566    AssertPtrReturn(pcParameters, VERR_INVALID_POINTER);
     567
     568    struct
     569    {
     570        VBGLIOCHGCMCALL Hdr;
     571        HGCMFunctionParameter idMsg;       /* Doubles as restore check on input. */
     572        HGCMFunctionParameter cParameters;
     573    } Msg;
     574    int rc;
     575    if (!pCtx->fUseLegacyProtocol)
     576    {
     577        VBGL_HGCM_HDR_INIT(&Msg.Hdr, pCtx->idClient,
     578                           fWait ? VBOX_SHCL_GUEST_FN_MSG_PEEK_WAIT
     579                                 : VBOX_SHCL_GUEST_FN_MSG_PEEK_NOWAIT, 2);
     580        VbglHGCMParmUInt64Set(&Msg.idMsg, pidRestoreCheck ? *pidRestoreCheck : 0);
     581        VbglHGCMParmUInt32Set(&Msg.cParameters, 0);
     582        rc = VbglR3HGCMCall(&Msg.Hdr, sizeof(Msg));
     583        Log4Func(("VbglR3HGCMCall -> %Rrc\n", rc));
     584        if (RT_SUCCESS(rc))
     585        {
     586            AssertMsgReturn(   Msg.idMsg.type       == VMMDevHGCMParmType_64bit
     587                            && Msg.cParameters.type == VMMDevHGCMParmType_32bit,
     588                            ("msg.type=%d num_parms.type=%d\n", Msg.idMsg.type, Msg.cParameters.type),
     589                            VERR_INTERNAL_ERROR_3);
     590
     591            *pidMsg       = (uint32_t)Msg.idMsg.u.value64;
     592            *pcParameters = Msg.cParameters.u.value32;
     593            return rc;
     594        }
     595
     596        /*
     597         * If restored, update pidRestoreCheck.
     598         */
     599        if (rc == VERR_VM_RESTORED && pidRestoreCheck)
     600            *pidRestoreCheck = Msg.idMsg.u.value64;
     601    }
     602    else
     603    {
     604        /*
     605         * We do some crude stuff here by putting the 2nd parameter (foramts) in the parameter count,
     606         * however it's supposed to be passed directly to VbglR3ClipboardEventGetNext or
     607         * VbglR3ClipboardEventGetNextEx, so that's fine...
     608         */
     609        rc = VbglR3ClipboardGetHostMsgOld(pCtx->idClient, pidMsg, pcParameters);
     610        if (RT_SUCCESS(rc))
     611            return rc;
     612    }
     613
     614    /*
     615     * If interrupted we must cancel the call so it doesn't prevent us from making another one.
     616     */
     617    if (rc == VERR_INTERRUPTED)
     618    {
     619        VBGL_HGCM_HDR_INIT(&Msg.Hdr, pCtx->idClient, VBOX_SHCL_GUEST_FN_MSG_CANCEL, 0);
     620        int rc2 = VbglR3HGCMCall(&Msg.Hdr, sizeof(Msg.Hdr));
     621        AssertRC(rc2);
     622    }
     623
     624    *pidMsg       = UINT32_MAX - 1;
     625    *pcParameters = UINT32_MAX - 2;
     626    return rc;
     627}
     628
     629/**
    534630 * Peeks at the next host message, waiting for one to turn up.
    535631 *
    … …  
    556652                                           uint32_t *pcParameters, uint64_t *pidRestoreCheck)
    557653{
    558     AssertPtrReturn(pidMsg, VERR_INVALID_POINTER);
    559     AssertPtrReturn(pcParameters, VERR_INVALID_POINTER);
    560 
    561     struct
    562     {
    563         VBGLIOCHGCMCALL Hdr;
    564         HGCMFunctionParameter idMsg;       /* Doubles as restore check on input. */
    565         HGCMFunctionParameter cParameters;
    566     } Msg;
    567     int rc;
    568     if (!pCtx->fUseLegacyProtocol)
    569     {
    570         VBGL_HGCM_HDR_INIT(&Msg.Hdr, pCtx->idClient, VBOX_SHCL_GUEST_FN_MSG_PEEK_WAIT, 2);
    571         VbglHGCMParmUInt64Set(&Msg.idMsg, pidRestoreCheck ? *pidRestoreCheck : 0);
    572         VbglHGCMParmUInt32Set(&Msg.cParameters, 0);
    573         rc = VbglR3HGCMCall(&Msg.Hdr, sizeof(Msg));
    574         LogFlowFunc(("VbglR3HGCMCall -> %Rrc\n", rc));
    575         if (RT_SUCCESS(rc))
    576         {
    577             AssertMsgReturn(   Msg.idMsg.type       == VMMDevHGCMParmType_64bit
    578                             && Msg.cParameters.type == VMMDevHGCMParmType_32bit,
    579                             ("msg.type=%d num_parms.type=%d\n", Msg.idMsg.type, Msg.cParameters.type),
    580                             VERR_INTERNAL_ERROR_3);
    581 
    582             *pidMsg       = (uint32_t)Msg.idMsg.u.value64;
    583             *pcParameters = Msg.cParameters.u.value32;
    584             return rc;
    585         }
    586 
    587         /*
    588          * If restored, update pidRestoreCheck.
    589          */
    590         if (rc == VERR_VM_RESTORED && pidRestoreCheck)
    591             *pidRestoreCheck = Msg.idMsg.u.value64;
    592     }
    593     else
    594     {
    595         /*
    596          * We do some crude stuff here by putting the 2nd parameter (foramts) in the parameter count,
    597          * however it's supposed to be passed directly to VbglR3ClipboardEventGetNext or
    598          * VbglR3ClipboardEventGetNextEx, so that's fine...
    599          */
    600         rc = VbglR3ClipboardGetHostMsgOld(pCtx->idClient, pidMsg, pcParameters);
    601         if (RT_SUCCESS(rc))
    602             return rc;
    603     }
    604 
    605     /*
    606      * If interrupted we must cancel the call so it doesn't prevent us from making another one.
    607      */
    608     if (rc == VERR_INTERRUPTED)
    609     {
    610         VBGL_HGCM_HDR_INIT(&Msg.Hdr, pCtx->idClient, VBOX_SHCL_GUEST_FN_MSG_CANCEL, 0);
    611         int rc2 = VbglR3HGCMCall(&Msg.Hdr, sizeof(Msg.Hdr));
    612         AssertRC(rc2);
    613     }
    614 
    615     *pidMsg       = UINT32_MAX - 1;
    616     *pcParameters = UINT32_MAX - 2;
    617     return rc;
     654    return vbglR3ClipboardMsgPeekEx(pCtx, true /* fWait */, pidMsg, pcParameters, pidRestoreCheck);
     655}
     656
     657/**
     658 * Peeks at the next host message, returning immediately.
     659 *
     660 * This glosses over the difference between new (6.1) and old (1.3.2) host
     661 * service versions, however it does so by abusing @a pcParameters, so don't use
     662 * it directly when in legacy mode, always pass it on to
     663 * VbglR3ClipboardEventGetNext() or VbglR3ClipboardEventGetNextEx().
     664 *
     665 * @returns VBox status code.
     666 * @retval  VERR_INTERRUPTED if interrupted.  Does the necessary cleanup, so
     667 *          caller just have to repeat this call.
     668 * @retval  VERR_VM_RESTORED if the VM has been restored (idRestoreCheck).
     669 * @retval  VERR_TRY_AGAIN if no new message is available.
     670 *
     671 * @param   pCtx            Shared Clipboard command context to use for the connection.
     672 * @param   pidMsg          Where to store the message id.
     673 * @param   pcParameters    Where to store the number  of parameters which will
     674 *                          be received in a second call to the host.
     675 * @param   pidRestoreCheck Pointer to the VbglR3GetSessionId() variable to use
     676 *                          for the VM restore check.  Optional.
     677 *
     678 * @note    Restore check is only performed optimally with a 6.0 host.
     679 */
     680VBGLR3DECL(int) VbglR3ClipboardMsgPeek(PVBGLR3SHCLCMDCTX pCtx, uint32_t *pidMsg,
     681                                       uint32_t *pcParameters, uint64_t *pidRestoreCheck)
     682{
     683    return vbglR3ClipboardMsgPeekEx(pCtx, false /* fWait */, pidMsg, pcParameters, pidRestoreCheck);
    618684}
    619685
    … …  
    627693 * @param   pRootListHdr        Where to store the received root list header.
    628694 */
    629 static int vbglR3ClipboardRootListHdrRead(PVBGLR3SHCLCMDCTX pCtx, PSHCLROOTLISTHDR pRootListHdr)
     695static int vbglR3ClipboardRootListHdrRead(PVBGLR3SHCLCMDCTX pCtx, PSHCLLISTHDR pRootListHdr)
    630696{
    631697    AssertPtrReturn(pCtx,         VERR_INVALID_POINTER);
    … …  
    645711    if (RT_SUCCESS(rc))
    646712    {
    647         rc = Msg.ReqParms.fRoots.GetUInt32(&pRootListHdr->fRoots); AssertRC(rc);
    648         if (RT_SUCCESS(rc))
    649         {
    650             rc = Msg.cRoots.GetUInt64(&pRootListHdr->cRoots);
     713        rc = Msg.ReqParms.fRoots.GetUInt32(&pRootListHdr->fFeatures); AssertRC(rc);
     714        if (RT_SUCCESS(rc))
     715        {
     716            rc = Msg.cRoots.GetUInt64(&pRootListHdr->cEntries);
    651717            AssertRC(rc);
     718
     719            pRootListHdr->cbTotalSize = 0; /* Unused for the root list header. */
    652720        }
    653721    }
    … …  
    665733 * @param   pRootListEntry      Where to store the root list entry read from the host.
    666734 */
    667 static int vbglR3ClipboardRootListEntryRead(PVBGLR3SHCLCMDCTX pCtx, uint32_t uIndex, PSHCLROOTLISTENTRY pRootListEntry)
     735static int vbglR3ClipboardRootListEntryRead(PVBGLR3SHCLCMDCTX pCtx, uint64_t uIndex, PSHCLLISTENTRY pRootListEntry)
    668736{
    669737    AssertPtrReturn(pCtx,           VERR_INVALID_POINTER);
    … …  
    675743                       VBOX_SHCL_GUEST_FN_ROOT_LIST_ENTRY_READ, VBOX_SHCL_CPARMS_ROOT_LIST_ENTRY_READ);
    676744
     745    uint32_t const fInfo = VBOX_SHCL_INFO_F_FSOBJINFO; /* For now the only info we have. */
     746
    677747    Msg.Parms.uContext.SetUInt64(pCtx->idContext);
    678     Msg.Parms.fInfo.SetUInt32(pRootListEntry->fInfo);
    679     Msg.Parms.uIndex.SetUInt32(uIndex);
    680 
    681     Msg.szName.SetPtr(pRootListEntry->pszName, pRootListEntry->cbName);
    682     Msg.cbInfo.SetUInt32(pRootListEntry->cbInfo);
    683     Msg.pvInfo.SetPtr(pRootListEntry->pvInfo, pRootListEntry->cbInfo);
    684 
    685     int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
    686     if (RT_SUCCESS(rc))
    687     {
    688         rc = Msg.Parms.fInfo.GetUInt32(&pRootListEntry->fInfo); AssertRC(rc);
    689         if (RT_SUCCESS(rc))
    690         {
    691             uint32_t cbInfo = 0;
    692             rc = Msg.cbInfo.GetUInt32(&cbInfo); AssertRC(rc);
    693             if (pRootListEntry->cbInfo != cbInfo)
    694                 rc = VERR_INVALID_PARAMETER;
    695         }
    696     }
     748    Msg.Parms.fInfo.SetUInt32(fInfo);
     749    Msg.Parms.uIndex.SetUInt64(uIndex);
     750
     751    char szName[SHCLLISTENTRY_MAX_NAME];
     752    Msg.szName.SetPtr(szName, sizeof(szName));
     753
     754    void    *pvInfo = NULL;
     755    uint32_t cbInfo = 0;
     756
     757    int rc = VINF_SUCCESS;
     758
     759    if ((fInfo & VBOX_SHCL_INFO_F_FSOBJINFO) == VBOX_SHCL_INFO_F_FSOBJINFO)
     760    {
     761        cbInfo = sizeof(SHCLFSOBJINFO);
     762        pvInfo = RTMemAlloc(cbInfo);
     763        if (!pvInfo)
     764            rc = VERR_NO_MEMORY;
     765    }
     766
     767    if (RT_SUCCESS(rc))
     768    {
     769        Msg.cbInfo.SetUInt32(cbInfo);
     770        Msg.pvInfo.SetPtr(pvInfo, cbInfo);
     771
     772        rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     773        if (RT_SUCCESS(rc))
     774        {
     775            uint32_t fInfoRet;
     776            rc = Msg.Parms.fInfo.GetUInt32(&fInfoRet);
     777            AssertRCReturn(rc, rc);
     778            AssertMsgStmt((fInfoRet & VBOX_SHCL_INFO_F_FSOBJINFO) == VBOX_SHCL_INFO_F_FSOBJINFO,
     779                          ("Host returned unknown entry info flags (%#x)\n", fInfoRet), rc = VERR_INVALID_PARAMETER);
     780            if (RT_SUCCESS(rc))
     781            {
     782                uint32_t cbInfoRet = 0;
     783                Msg.cbInfo.GetUInt32(&cbInfoRet);
     784
     785                AssertMsgStmt(cbInfo == cbInfoRet,
     786                              ("Host reported cbInfo %RU32, expected %RU32\n", cbInfoRet, cbInfo), rc = VERR_INVALID_PARAMETER);
     787
     788                rc = ShClTransferListEntryInitEx(pRootListEntry, fInfo, szName, pvInfo, cbInfo);
     789                if (RT_SUCCESS(rc))
     790                {
     791                    pvInfo = NULL;  /* Entry took ownership of pvInfo now. */
     792                    cbInfo = 0;
     793                }
     794            }
     795        }
     796    }
     797
     798    RTMemFree(pvInfo);
    697799
    698800    LogFlowFuncLeaveRC(rc);
    … …  
    705807 * @returns VBox status code.
    706808 * @param   pCtx                Shared Clipboard command context to use for the connection.
    707  * @param   ppRootList          Where to store the (allocated) root list. Must be free'd by the caller with
    708  *                              SharedClipboardTransferRootListFree().
    709  */
    710 VBGLR3DECL(int) VbglR3ClipboardRootListRead(PVBGLR3SHCLCMDCTX pCtx, PSHCLROOTLIST *ppRootList)
    711 {
    712     AssertPtrReturn(pCtx,       VERR_INVALID_POINTER);
    713     AssertPtrReturn(ppRootList, VERR_INVALID_POINTER);
    714 
    715     int rc;
    716 
    717     PSHCLROOTLIST pRootList = ShClTransferRootListAlloc();
    718     if (pRootList)
    719     {
    720         rc = vbglR3ClipboardRootListHdrRead(pCtx, &pRootList->Hdr);
    721         if (RT_SUCCESS(rc))
    722         {
    723             if (pRootList->Hdr.cRoots)
     809 * @param   pRootList           Where to store the read root list.
     810 *
     811 */
     812VBGLR3DECL(int) VbglR3ClipboardRootListRead(PVBGLR3SHCLCMDCTX pCtx, PSHCLTRANSFER pTransfer)
     813{
     814    AssertPtrReturn(pCtx,      VERR_INVALID_POINTER);
     815    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
     816
     817    SHCLLISTHDR Hdr;
     818    int rc = vbglR3ClipboardRootListHdrRead(pCtx, &Hdr);
     819    if (RT_SUCCESS(rc))
     820    {
     821        LogFlowFunc(("cEntries=%RU64, cTotalSize=%RU64\n", Hdr.cEntries, Hdr.cbTotalSize));
     822
     823        for (uint64_t i = 0; i < Hdr.cEntries; i++)
     824        {
     825            PSHCLLISTENTRY pEntry = NULL;
     826            rc = ShClTransferListEntryAlloc(&pEntry);
     827            if (RT_SUCCESS(rc))
    724828            {
    725                 pRootList->paEntries =
    726                     (PSHCLROOTLISTENTRY)RTMemAllocZ(pRootList->Hdr.cRoots * sizeof(SHCLROOTLISTENTRY));
    727                 if (pRootList->paEntries)
    728                 {
    729                     for (uint32_t i = 0; i < pRootList->Hdr.cRoots; i++)
    730                     {
    731                         SHCLROOTLISTENTRY *pEntry = &pRootList->paEntries[i];
    732                         AssertPtr(pEntry);
    733 
    734                         rc = ShClTransferRootListEntryInit(pEntry);
    735                         if (RT_SUCCESS(rc))
    736                             rc = vbglR3ClipboardRootListEntryRead(pCtx, i, pEntry);
    737 
    738                         if (RT_FAILURE(rc))
    739                             break;
    740                     }
    741                 }
    742                 else
    743                     rc = VERR_NO_MEMORY;
     829                rc = vbglR3ClipboardRootListEntryRead(pCtx, i, pEntry);
     830                if (RT_SUCCESS(rc))
     831                    rc = ShClTransferListAddEntry(&pTransfer->lstRoots, pEntry, true /* fAppend */);
    744832            }
    745         }
    746 
    747         if (RT_SUCCESS(rc))
    748         {
    749             *ppRootList = pRootList;
    750         }
    751         else
    752             ShClTransferRootListFree(pRootList);
    753     }
    754     else
    755         rc = VERR_NO_MEMORY;
     833
     834            if (RT_FAILURE(rc))
     835            {
     836                ShClTransferListEntryFree(pEntry);
     837                break;
     838            }
     839        }
     840    }
    756841
    757842    LogFlowFuncLeaveRC(rc);
    … …  
    891976 * @param   pRootListHdr        Root lsit header to reply to the host.
    892977 */
    893 VBGLR3DECL(int) VbglR3ClipboardRootListHdrReadReply(PVBGLR3SHCLCMDCTX pCtx, PSHCLROOTLISTHDR pRootListHdr)
     978VBGLR3DECL(int) VbglR3ClipboardRootListHdrReadReply(PVBGLR3SHCLCMDCTX pCtx, PSHCLLISTHDR pRootListHdr)
    894979{
    895980    AssertPtrReturn(pCtx,         VERR_INVALID_POINTER);
    … …  
    901986
    902987    Msg.ReqParms.uContext.SetUInt64(pCtx->idContext);
    903     Msg.ReqParms.fRoots.SetUInt32(pRootListHdr->fRoots);
    904 
    905     Msg.cRoots.SetUInt64(pRootListHdr->cRoots);
     988    Msg.ReqParms.fRoots.SetUInt32(pRootListHdr->fFeatures);
     989
     990    Msg.cRoots.SetUInt64(pRootListHdr->cEntries);
    906991
    907992    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
    … …  
    9611046 * @param   pEntry              Actual root list entry to reply.
    9621047 */
    963 VBGLR3DECL(int) VbglR3ClipboardRootListEntryReadReply(PVBGLR3SHCLCMDCTX pCtx, uint32_t uIndex, PSHCLROOTLISTENTRY pEntry)
     1048VBGLR3DECL(int) VbglR3ClipboardRootListEntryReadReply(PVBGLR3SHCLCMDCTX pCtx, uint32_t uIndex, PSHCLLISTENTRY pEntry)
    9641049{
    9651050    AssertPtrReturn(pCtx,   VERR_INVALID_POINTER);
    … …  
    12021287        rc = Msg.fFeatures.GetUInt32(&pListHdr->fFeatures);
    12031288        if (RT_SUCCESS(rc))
    1204             rc = Msg.cTotalObjects.GetUInt64(&pListHdr->cTotalObjects);
     1289            rc = Msg.cTotalObjects.GetUInt64(&pListHdr->cEntries);
    12051290        if (RT_SUCCESS(rc))
    12061291            rc = Msg.cbTotalSize.GetUInt64(&pListHdr->cbTotalSize);
    … …  
    12711356    Msg.fFeatures.SetUInt32(0);
    12721357    Msg.cbTotalSize.SetUInt32(pListHdr->fFeatures);
    1273     Msg.cTotalObjects.SetUInt64(pListHdr->cTotalObjects);
     1358    Msg.cTotalObjects.SetUInt64(pListHdr->cEntries);
    12741359    Msg.cbTotalSize.SetUInt64(pListHdr->cbTotalSize);
    12751360
    … …  
    16811766    Msg.uContext.SetUInt64(pCtx->idContext);
    16821767    Msg.uHandle.SetUInt64(hObj);
     1768    Msg.cbData.SetUInt32(cbData);
    16831769    Msg.pvData.SetPtr(pvData, cbData);
     1770    Msg.cbChecksum.SetUInt32(0);
    16841771    Msg.pvChecksum.SetPtr(NULL, 0);
    16851772
    … …  
    17021789*********************************************************************************************************************************/
    17031790
    1704 /** @copydoc SHCLTXPROVIDERIFACE::pfnRootsGet */
    1705 static DECLCALLBACK(int) vbglR3ClipboardTransferIfaceRootsGet(PSHCLTXPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList)
     1791/** @copydoc SHCLTXPROVIDERIFACE::pfnRootListRead */
     1792static DECLCALLBACK(int) vbglR3ClipboardTransferIfaceRootListRead(PSHCLTXPROVIDERCTX pCtx)
    17061793{
    17071794    LogFlowFuncEnter();
    … …  
    17101797    AssertPtr(pCmdCtx);
    17111798
    1712     int rc = VbglR3ClipboardRootListRead(pCmdCtx, ppRootList);
     1799    int rc = VbglR3ClipboardRootListRead(pCmdCtx, pCtx->pTransfer);
    17131800
    17141801    LogFlowFuncLeaveRC(rc);
    … …  
    18321919
    18331920/**
    1834  * Starts a transfer on the guest side.
     1921 * Initializes a transfer on the guest side.
    18351922 *
    18361923 * @returns VBox status code.
    18371924 * @param   pCmdCtx             Command context to use.
    1838  * @param   pTransferCtx        Transfer context to create transfer for.
    1839  * @param   uTransferID         ID to use for transfer to start.
    1840  * @param   enmDir              Direction of transfer to start.
    1841  * @param   enmSource           Source of transfer to start.
     1925 * @param   pTransferCtx        Transfer context to init transfer for.
     1926 * @param   uTransferID         ID to use for transfer to init.
     1927 * @param   enmDir              Direction of transfer to init.
     1928 * @param   enmSource           Source of transfer to init.
    18421929 * @param   ppTransfer          Where to return the transfer object on success. Optional.
    18431930 */
    1844 static int vbglR3ClipboardTransferStart(PVBGLR3SHCLCMDCTX pCmdCtx, PSHCLTRANSFERCTX pTransferCtx,
    1845                                         SHCLTRANSFERID uTransferID, SHCLTRANSFERDIR enmDir, SHCLSOURCE enmSource,
    1846                                         PSHCLTRANSFER *ppTransfer)
    1847 {
     1931static int vbglR3ClipboardTransferInit(PVBGLR3SHCLCMDCTX pCmdCtx, PSHCLTRANSFERCTX pTransferCtx,
     1932                                       SHCLTRANSFERID uTransferID, SHCLTRANSFERDIR enmDir, SHCLSOURCE enmSource,
     1933                                       PSHCLTRANSFER *ppTransfer)
     1934{
     1935    LogFlowFuncEnter();
     1936
    18481937    PSHCLTRANSFER pTransfer;
    18491938    int rc = ShClTransferCreate(&pTransfer);
    18501939    if (RT_SUCCESS(rc))
    18511940    {
     1941        /* Set the callbacks the (OS-dependent) implementation relies on. Optional. */
    18521942        ShClTransferSetCallbacks(pTransfer, &pCmdCtx->Transfers.Callbacks);
    18531943
    … …  
    18551945        if (RT_SUCCESS(rc))
    18561946        {
    1857             rc = ShClTransferCtxTransferRegisterById(pTransferCtx, pTransfer, uTransferID);
     1947            SHCLTXPROVIDER Provider;
     1948            RT_ZERO(Provider);
     1949
     1950            /* Assign local provider first and overwrite interface methods below if needed. */
     1951            VBClTransferProviderLocalQueryInterface(&Provider);
     1952
     1953            /* If this is a read transfer (reading data from host), set the interface to use
     1954             * our VbglR3 routines here. */
     1955            if (enmDir == SHCLTRANSFERDIR_FROM_REMOTE) /* Host -> Guest */
     1956            {
     1957                Provider.Interface.pfnRootListRead  = vbglR3ClipboardTransferIfaceRootListRead;
     1958
     1959                Provider.Interface.pfnListOpen      = vbglR3ClipboardTransferIfaceListOpen;
     1960                Provider.Interface.pfnListClose     = vbglR3ClipboardTransferIfaceListClose;
     1961                Provider.Interface.pfnListHdrRead   = vbglR3ClipboardTransferIfaceListHdrRead;
     1962                Provider.Interface.pfnListEntryRead = vbglR3ClipboardTransferIfaceListEntryRead;
     1963
     1964                Provider.Interface.pfnObjOpen       = vbglR3ClipboardTransferIfaceObjOpen;
     1965                Provider.Interface.pfnObjClose      = vbglR3ClipboardTransferIfaceObjClose;
     1966                Provider.Interface.pfnObjRead       = vbglR3ClipboardTransferIfaceObjRead;
     1967            }
     1968
     1969            Provider.pvUser = pCmdCtx;
     1970
     1971            rc = ShClTransferSetProvider(pTransfer, &Provider);
     1972
     1973            /* As a last step, register the transfer with our transfer context. */
    18581974            if (RT_SUCCESS(rc))
    1859             {
    1860                 SHCLTXPROVIDERCREATIONCTX creationCtx;
    1861                 RT_ZERO(creationCtx);
    1862 
    1863                 /* Assign local provider first and overwrite interface methods below if needed. */
    1864                 VBClTransferQueryIfaceLocal(&creationCtx.Interface);
    1865 
    1866                 /* If this is a read transfer (reading data from host), set the interface to use
    1867                  * our VbglR3 routines here. */
    1868                 if (enmDir == SHCLTRANSFERDIR_FROM_REMOTE)
    1869                 {
    1870                     creationCtx.Interface.pfnRootsGet      = vbglR3ClipboardTransferIfaceRootsGet;
    1871 
    1872                     creationCtx.Interface.pfnListOpen      = vbglR3ClipboardTransferIfaceListOpen;
    1873                     creationCtx.Interface.pfnListClose     = vbglR3ClipboardTransferIfaceListClose;
    1874                     creationCtx.Interface.pfnListHdrRead   = vbglR3ClipboardTransferIfaceListHdrRead;
    1875                     creationCtx.Interface.pfnListEntryRead = vbglR3ClipboardTransferIfaceListEntryRead;
    1876 
    1877                     creationCtx.Interface.pfnObjOpen       = vbglR3ClipboardTransferIfaceObjOpen;
    1878                     creationCtx.Interface.pfnObjClose      = vbglR3ClipboardTransferIfaceObjClose;
    1879                     creationCtx.Interface.pfnObjRead       = vbglR3ClipboardTransferIfaceObjRead;
    1880 
    1881                     creationCtx.pvUser = pCmdCtx;
    1882 
    1883                     rc = ShClTransferSetProviderIface(pTransfer, &creationCtx);
    1884                 }
    1885 
    1886                 if (RT_SUCCESS(rc))
    1887                     rc = ShClTransferStart(pTransfer);
    1888             }
     1975                rc = ShClTransferCtxTransferRegisterById(pTransferCtx, pTransfer, uTransferID);
    18891976
    18901977            if (RT_FAILURE(rc))
    … …  
    18981985            *ppTransfer = pTransfer;
    18991986
    1900         LogRel2(("Shared Clipboard: Transfer ID=%RU32 (%s %s) successfully started\n",
    1901                  uTransferID,
    1902                  enmDir    == SHCLTRANSFERDIR_FROM_REMOTE ? "reading from" : "writing to",
    1903                  enmSource == SHCLSOURCE_LOCAL            ? "local"        : "remote"));
     1987        LogRel(("Shared Clipboard: Transfer %RU32 (%s) successfully initialized\n",
     1988                uTransferID,
     1989                enmDir == SHCLTRANSFERDIR_FROM_REMOTE ? "host -> guest" : "guest -> host"));
    19041990    }
    19051991    else
    1906         LogRel(("Shared Clipboard: Unable to start transfer ID=%RU32, rc=%Rrc\n", uTransferID, rc));
     1992        LogRel(("Shared Clipboard: Unable to initialize transfer %RU32, rc=%Rrc\n", uTransferID, rc));
     1993
     1994    /* Send a reply in any case. */
     1995    int rc2 = VbglR3ClipboardTransferStatusReply(pCmdCtx, pTransfer,
     1996                                                   RT_SUCCESS(rc)
     1997                                                 ? SHCLTRANSFERSTATUS_INITIALIZED : SHCLTRANSFERSTATUS_ERROR, rc);
     1998    if (RT_SUCCESS(rc))
     1999        rc = rc2;
     2000
     2001    if (RT_FAILURE(rc))
     2002    {
     2003        ShClTransferDestroy(pTransfer);
     2004        pTransfer = NULL;
     2005    }
     2006
     2007    LogFlowFuncLeaveRC(rc);
     2008    return rc;
     2009}
     2010
     2011/**
     2012 * Uninitializes a transfer on the guest side.
     2013 *
     2014 * @returns VBox status code.
     2015 * @param   pCmdCtx             Command context to use.
     2016 * @param   pTransferCtx        Transfer context to uninit transfer for.
     2017 * @param   uTransferID         ID to use for transfer to uninit.
     2018 */
     2019static int vbglR3ClipboardTransferUninit(PVBGLR3SHCLCMDCTX pCmdCtx, PSHCLTRANSFERCTX pTransferCtx, SHCLTRANSFERID uTransferID)
     2020{
     2021    RT_NOREF(pCmdCtx);
     2022
     2023    LogFlowFuncEnter();
     2024
     2025    int rc;
     2026
     2027    PSHCLTRANSFER pTransfer = ShClTransferCtxGetTransferById(pTransferCtx, uTransferID);
     2028    if (pTransfer)
     2029    {
     2030        rc = ShClTransferCtxTransferUnregister(pTransferCtx, uTransferID);
     2031        if (RT_SUCCESS(rc))
     2032            rc = ShClTransferDestroy(pTransfer);
     2033
     2034        if (RT_SUCCESS(rc))
     2035        {
     2036            LogRel(("Shared Clipboard: Transfer %RU32 successfully uninitialized\n", uTransferID));
     2037        }
     2038        else
     2039            LogRel(("Shared Clipboard: Unable to uninitialized transfer %RU32, rc=%Rrc\n", uTransferID, rc));
     2040    }
     2041    else
     2042        rc = VERR_SHCLPB_TRANSFER_ID_NOT_FOUND;
     2043
     2044    /* Send a reply in any case. */
     2045    int rc2 = VbglR3ClipboardTransferStatusReply(pCmdCtx, pTransfer,
     2046                                                   RT_SUCCESS(rc)
     2047                                                 ? SHCLTRANSFERSTATUS_UNINITIALIZED : SHCLTRANSFERSTATUS_ERROR, rc);
     2048
     2049    /* The host might not have the transfer around anymore at this time, so simply ignore this error. */
     2050    if (rc2 == VERR_SHCLPB_TRANSFER_ID_NOT_FOUND)
     2051        rc2 = VINF_SUCCESS;
     2052
     2053    if (RT_SUCCESS(rc))
     2054        rc = rc2;
     2055
     2056    LogFlowFuncLeaveRC(rc);
     2057    return rc;
     2058}
     2059
     2060/**
     2061 * Starts a transfer on the guest side.
     2062 *
     2063 * @returns VBox status code.
     2064 * @param   pCmdCtx             Command context to use.
     2065 * @param   pTransferCtx        Transfer context to start transfer for.
     2066 * @param   uTransferID         ID to use for transfer to start.
     2067 */
     2068static int vbglR3ClipboardTransferStart(PVBGLR3SHCLCMDCTX pCmdCtx, PSHCLTRANSFERCTX pTransferCtx,
     2069                                        SHCLTRANSFERID uTransferID)
     2070{
     2071    RT_NOREF(pCmdCtx);
     2072
     2073    LogFlowFuncEnter();
     2074
     2075    int rc;
     2076
     2077    PSHCLTRANSFER pTransfer = ShClTransferCtxGetTransferById(pTransferCtx, uTransferID);
     2078    if (pTransfer)
     2079    {
     2080        rc = ShClTransferStart(pTransfer);
     2081        if (RT_SUCCESS(rc))
     2082        {
     2083            LogRel(("Shared Clipboard: Transfer %RU32 successfully started\n", uTransferID));
     2084        }
     2085        else
     2086            LogRel(("Shared Clipboard: Unable to start transfer %RU32, rc=%Rrc\n", uTransferID, rc));
     2087    }
     2088    else
     2089        rc = VERR_SHCLPB_TRANSFER_ID_NOT_FOUND;
    19072090
    19082091    /* Send a reply in any case. */
    … …  
    19132096        rc = rc2;
    19142097
    1915     if (RT_FAILURE(rc))
    1916     {
    1917         ShClTransferDestroy(pTransfer);
    1918         pTransfer = NULL;
    1919     }
    1920 
    19212098    LogFlowFuncLeaveRC(rc);
    19222099    return rc;
    … …  
    19342111                                       SHCLTRANSFERID uTransferID)
    19352112{
     2113    LogFlowFuncEnter();
     2114
    19362115    int rc;
    19372116
    … …  
    19422121        if (RT_SUCCESS(rc))
    19432122        {
    1944             LogRel2(("Shared Clipboard: Transfer ID=%RU32 successfully stopped\n", uTransferID));
     2123            LogRel(("Shared Clipboard: Transfer %RU32 successfully stopped\n", uTransferID));
    19452124        }
    19462125        else
    1947             LogRel(("Shared Clipboard: Unable to stop transfer ID=%RU32, rc=%Rrc\n", uTransferID, rc));
    1948 
    1949         /* Send a reply in any case. */
    1950         int rc2 = VbglR3ClipboardTransferStatusReply(pCmdCtx, pTransfer,
    1951                                                        RT_SUCCESS(rc)
    1952                                                      ? SHCLTRANSFERSTATUS_STOPPED : SHCLTRANSFERSTATUS_ERROR, rc);
    1953         AssertRC(rc2);
     2126            LogRel(("Shared Clipboard: Unable to stop transfer %RU32, rc=%Rrc\n", uTransferID, rc));
    19542127    }
    19552128    else
    1956         rc = VERR_NOT_FOUND;
     2129        rc = VERR_SHCLPB_TRANSFER_ID_NOT_FOUND;
     2130
     2131    /* Send a reply in any case. */
     2132    int rc2 = VbglR3ClipboardTransferStatusReply(pCmdCtx, pTransfer,
     2133                                                   RT_SUCCESS(rc)
     2134                                                 ? SHCLTRANSFERSTATUS_STOPPED : SHCLTRANSFERSTATUS_ERROR, rc);
     2135    if (RT_SUCCESS(rc))
     2136        rc = rc2;
    19572137
    19582138    LogFlowFuncLeaveRC(rc);
    … …  
    19662146 * @param   pCallbacks          Pointer to callback table to set.
    19672147 */
    1968 VBGLR3DECL(void) VbglR3ClipboardTransferSetCallbacks(PVBGLR3SHCLCMDCTX pCmdCtx,  PSHCLTRANSFERCALLBACKTABLE pCallbacks)
     2148VBGLR3DECL(void) VbglR3ClipboardTransferSetCallbacks(PVBGLR3SHCLCMDCTX pCmdCtx,  PSHCLTRANSFERCALLBACKS pCallbacks)
    19692149{
    19702150    AssertPtrReturnVoid(pCmdCtx);
    … …  
    20002180                    const SHCLTRANSFERID uTransferID = VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->idContext);
    20012181
    2002                     LogFlowFunc(("[Transfer %RU32] enmDir=%RU32, status=%s\n",
    2003                                  uTransferID, enmDir, ShClTransferStatusToStr(transferReport.uStatus)));
     2182                    LogRel(("Shared Clipboard: Received status %s (%Rrc) for transfer %RU32\n",
     2183                            ShClTransferStatusToStr(transferReport.uStatus), transferReport.rc, uTransferID));
    20042184
    20052185                    switch (transferReport.uStatus)
    20062186                    {
     2187                        case SHCLTRANSFERSTATUS_NONE:
     2188                            AssertFailed(); /* Should never happen. */
     2189                            break;
     2190
    20072191                        case SHCLTRANSFERSTATUS_INITIALIZED:
    2008                             RT_FALL_THROUGH();
    2009                         case SHCLTRANSFERSTATUS_STARTED:
    20102192                        {
    20112193                            SHCLSOURCE enmSource = SHCLSOURCE_INVALID;
    20122194
    20132195                            /* The host announces the transfer direction from its point of view, so inverse the direction here. */
    2014                             if (enmDir == SHCLTRANSFERDIR_TO_REMOTE)
     2196                            if (enmDir == SHCLTRANSFERDIR_TO_REMOTE) /* Host -> Guest */
    20152197                            {
    20162198                                enmDir = SHCLTRANSFERDIR_FROM_REMOTE;
    20172199                                enmSource = SHCLSOURCE_REMOTE;
     2200
     2201                                rc = vbglR3ClipboardTransferInit(pCmdCtx, pTransferCtx, uTransferID,
     2202                                                                 enmDir, enmSource, NULL /* ppTransfer */);
    20182203                            }
    2019                             else if (enmDir == SHCLTRANSFERDIR_FROM_REMOTE)
     2204                            else if (enmDir == SHCLTRANSFERDIR_FROM_REMOTE) /* Guest -> Host */
    20202205                            {
     2206                                /* Already initialized when remote (host) was reading the URI data. */
    20212207                                enmDir = SHCLTRANSFERDIR_TO_REMOTE;
    20222208                                enmSource = SHCLSOURCE_LOCAL;
     2209
     2210                                rc = vbglR3ClipboardTransferInit(pCmdCtx, pTransferCtx, uTransferID,
     2211                                                                 enmDir, enmSource, NULL /* ppTransfer */);
    20232212                            }
    20242213                            else
    20252214                                AssertFailedBreakStmt(rc = VERR_INVALID_PARAMETER);
    20262215
    2027                             rc = vbglR3ClipboardTransferStart(pCmdCtx, pTransferCtx, uTransferID,
    2028                                                               enmDir, enmSource, NULL /* ppTransfer */);
     2216                            break;
     2217                        }
     2218
     2219                        case SHCLTRANSFERSTATUS_UNINITIALIZED:
     2220                        {
     2221                            rc = vbglR3ClipboardTransferUninit(pCmdCtx, pTransferCtx, uTransferID);
     2222                            break;
     2223                        }
     2224
     2225                        case SHCLTRANSFERSTATUS_STARTED:
     2226                        {
     2227                            rc = vbglR3ClipboardTransferStart(pCmdCtx, pTransferCtx, uTransferID);
    20292228                            break;
    20302229                        }
    … …  
    20442243
    20452244                        default:
     2245                            LogRel(("Shared Clipboard: Received unknown status %#x (%Rrc) for transfer %RU32\n",
     2246                                    pEvent->u.TransferStatus.Report.uStatus, pEvent->u.TransferStatus.Report.rc,
     2247                                    pEvent->u.TransferStatus.uID));
    20462248                            rc = VERR_NOT_SUPPORTED;
    20472249                            break;
    … …  
    20552257
    20562258                        pEvent->enmType = VBGLR3CLIPBOARDEVENTTYPE_TRANSFER_STATUS;
    2057 
    2058                         LogRel2(("Shared Clipboard: Received status %s (rc=%Rrc) for transfer ID=%RU32\n",
    2059                                  ShClTransferStatusToStr(pEvent->u.TransferStatus.Report.uStatus), pEvent->u.TransferStatus.Report.rc,
    2060                                  pEvent->u.TransferStatus.uID));
    20612259                    }
    20622260                }
    … …  
    20772275                    AssertPtrBreakStmt(pTransfer, rc = VERR_NOT_FOUND);
    20782276
    2079                     SHCLROOTLISTHDR rootListHdr;
    2080                     RT_ZERO(rootListHdr);
    2081 
    2082                     rootListHdr.cRoots = ShClTransferRootsCount(pTransfer);
    2083 
    2084                     LogFlowFunc(("cRoots=%RU32\n", rootListHdr.cRoots));
     2277                    SHCLLISTHDR rootListHdr;
     2278                    ShClTransferListHdrInit(&rootListHdr);
     2279
     2280                    rootListHdr.cEntries = ShClTransferRootsCount(pTransfer);
     2281
     2282                    LogFlowFunc(("cRoots=%RU32\n", rootListHdr.cEntries));
    20852283
    20862284                    rc = VbglR3ClipboardRootListHdrReadReply(pCmdCtx, &rootListHdr);
    … …  
    21002298                    AssertPtrBreakStmt(pTransfer, rc = VERR_NOT_FOUND);
    21012299
    2102                     SHCLROOTLISTENTRY rootListEntry;
    2103                     rc = ShClTransferRootsEntry(pTransfer, uIndex, &rootListEntry);
    2104                     if (RT_SUCCESS(rc))
    2105                         rc = VbglR3ClipboardRootListEntryReadReply(pCmdCtx, uIndex, &rootListEntry);
     2300                    PCSHCLLISTENTRY pEntry = ShClTransferRootsEntryGet(pTransfer, uIndex);
     2301                    if (pEntry)
     2302                    {
     2303                        rc = VbglR3ClipboardRootListEntryReadReply(pCmdCtx, uIndex, pEntry);
     2304                    }
     2305                    else
     2306                        rc = VERR_NOT_FOUND;
    21062307                }
    21072308                break;
    … …  
    25532754VBGLR3DECL(int) VbglR3ClipboardWriteDataEx(PVBGLR3SHCLCMDCTX pCtx, SHCLFORMAT fFormat, void *pvData, uint32_t cbData)
    25542755{
    2555     LogFlowFunc(("ENTER: fFormat=%#x pvData=%p cbData=%#x\n", fFormat, pvData, cbData));
    25562756    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
    2557     if (cbData > 0)
    2558         AssertPtrReturn(pvData, VERR_INVALID_POINTER);
     2757    AssertReturn(cbData == 0 || RT_VALID_PTR(pvData), VERR_INVALID_PARAMETER);
     2758
     2759    LogFlowFunc(("fFormat=%#x pvData=%p cbData=%#x\n", fFormat, pvData, cbData));
    25592760
    25602761    int rc;
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