VirtualBox

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


Ignore:
Timestamp:
Jul 3, 2019 1:28:33 PM (6 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
131761
Message:

Shared Clipboard/URI: Update.

Location:
trunk/src/VBox/Additions/common
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/common/VBoxGuest/lib/Makefile.kmk

    r78897 r79497  
    152152 ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    153153 VBoxGuestR3Lib_SOURCES   += \
    154         $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardMetaData.cpp \
    155154        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardMIME.cpp
    156155 endif

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

    r79267 r79497  
    5050*   Prototypes                                                                                                                   *
    5151*********************************************************************************************************************************/
    52 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    53 static int vbglR3ClipboardWriteErrorInternal(HGCMCLIENTID idClient, int rcErr);
    54 #endif
    5552
    5653
    … …  
    6764    if (rc == VERR_HGCM_SERVICE_NOT_FOUND)
    6865        rc = VINF_PERMISSION_DENIED;
     66
     67    LogFlowFuncLeaveRC(rc);
    6968    return rc;
    7069}
    … …  
    8483
    8584/**
    86  * Get a host message.
     85 * Get a host message, old version.
     86 *
     87 * Note: This is the old message which still is being used for the non-URI Shared Clipboard transfers,
     88 *       to not break compatibility with older additions / VBox versions.
    8789 *
    8890 * This will block until a message becomes available.
    … …  
    9395 * @param   pfFormats       Where to store the format(s) the message applies to.
    9496 */
    95 VBGLR3DECL(int) VbglR3ClipboardGetHostMsg(HGCMCLIENTID idClient, uint32_t *pidMsg, uint32_t *pfFormats)
    96 {
    97     VBoxClipboardGetHostMsg Msg;
    98 
    99     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG, VBOX_SHARED_CLIPBOARD_CPARMS_GET_HOST_MSG);
     97VBGLR3DECL(int) VbglR3ClipboardGetHostMsgOld(HGCMCLIENTID idClient, uint32_t *pidMsg, uint32_t *pfFormats)
     98{
     99    VBoxClipboardGetHostMsgOld Msg;
     100
     101    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
     102                       VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG_OLD, VBOX_SHARED_CLIPBOARD_CPARMS_GET_HOST_MSG_OLD);
     103
    100104    VbglHGCMParmUInt32Set(&Msg.msg, 0);
    101105    VbglHGCMParmUInt32Set(&Msg.formats, 0);
    … …  
    157161}
    158162
    159 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    160 /**
    161  * Reads a (meta) data header from the host.
    162  *
    163  * @returns IPRT status code.
    164  * @param   idClient            The client id returned by VbglR3ClipboardConnect().
    165  * @param   pDataHdr            Where to store the read meta data header.
    166  */
    167 VBGLR3DECL(int) VbglR3ClipboardReadDataHdr(HGCMCLIENTID idClient, PVBOXCLIPBOARDDATAHDR pDataHdr)
    168 {
    169     AssertPtrReturn(pDataHdr, VERR_INVALID_POINTER);
    170 
    171     VBoxClipboardReadDataHdrMsg Msg;
    172     RT_ZERO(Msg);
    173     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
    174                        VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_DATA_HDR, VBOX_SHARED_CLIPBOARD_CPARMS_READ_DATA_HDR);
    175     Msg.uContext.SetUInt32(0);
    176     Msg.uFlags.SetUInt32(0);
    177     Msg.uScreenId.SetUInt32(0);
    178     Msg.cbTotal.SetUInt64(0);
    179     Msg.cbMeta.SetUInt32(0);
    180     Msg.cbMetaFmt.SetUInt32(0);
    181     Msg.pvMetaFmt.SetPtr(pDataHdr->pvMetaFmt, pDataHdr->cbMetaFmt);
    182     Msg.cObjects.SetUInt64(0);
     163static int vbglR3ClipboardGetNextMsgType(HGCMCLIENTID idClient, uint32_t *puMsg, uint32_t *pcParms, bool fWait)
     164{
     165    AssertPtrReturn(puMsg,   VERR_INVALID_POINTER);
     166    AssertPtrReturn(pcParms, VERR_INVALID_POINTER);
     167
     168    VBoxClipboardGetHostMsg Msg;
     169    RT_ZERO(Msg);
     170
     171    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
     172                       VBOX_SHARED_CLIPBOARD_GUEST_FN_GET_HOST_MSG, VBOX_SHARED_CLIPBOARD_CPARMS_GET_HOST_MSG);
     173
     174    Msg.uMsg.SetUInt32(0);
     175    Msg.cParms.SetUInt32(0);
     176    Msg.fBlock.SetUInt32(fWait ? 1 : 0);
     177
     178    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     179    if (RT_SUCCESS(rc))
     180    {
     181        rc = Msg.uMsg.GetUInt32(puMsg);
     182        if (RT_SUCCESS(rc))
     183            rc = Msg.cParms.GetUInt32(pcParms);
     184    }
     185
     186    LogFlowFuncLeaveRC(rc);
     187    return rc;
     188}
     189
     190static int vbglR3ClipboardRecvListOpen(HGCMCLIENTID idClient, PVBOXCLIPBOARDLISTHDR pListHdr)
     191{
     192    AssertPtrReturn(pListHdr, VERR_INVALID_POINTER);
     193
     194    VBoxClipboardListOpenMsg Msg;
     195    RT_ZERO(Msg);
     196
     197    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
     198                       VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_OPEN);
     199
     200    Msg.uContext.SetUInt32(0); /** @todo Context ID not used yet. */
     201    Msg.uHandle.SetUInt64(0);
     202    Msg.fList.SetUInt32(0);
     203    Msg.fFeatures.SetUInt32(0);
     204    Msg.cbFilter.SetUInt32(0);
     205    Msg.pvFilter.SetPtr(pListHdr->pszFilter, pListHdr->cbFilter);
     206
     207    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     208    if (RT_SUCCESS(rc))
     209    {
     210        rc = Msg.fList.GetUInt32(&pListHdr->fList);         AssertRC(rc);
     211        rc = Msg.fFeatures.GetUInt32(&pListHdr->fFeatures); AssertRC(rc);
     212    }
     213
     214    LogFlowFuncLeaveRC(rc);
     215    return rc;
     216}
     217
     218static int vbglR3ClipboardRecvListClose(HGCMCLIENTID idClient, PVBOXCLIPBOARDLISTHANDLE phList)
     219{
     220    AssertPtrReturn(phList, VERR_INVALID_POINTER);
     221
     222    VBoxClipboardListCloseMsg Msg;
     223    RT_ZERO(Msg);
     224
     225    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
     226                       VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_CLOSE);
     227
     228    Msg.uContext.SetUInt32(0); /** @todo Context ID not used yet. */
     229    Msg.uHandle.SetUInt64(0);
     230
     231    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     232    if (RT_SUCCESS(rc))
     233    {
     234        rc = Msg.uHandle.GetUInt64(phList); AssertRC(rc);
     235    }
     236
     237    LogFlowFuncLeaveRC(rc);
     238    return rc;
     239}
     240
     241static int vbglR3ClipboardRecvListHdrRead(HGCMCLIENTID idClient, PVBOXCLIPBOARDLISTHANDLE phList, PVBOXCLIPBOARDLISTHDR pListHdr)
     242{
     243    AssertPtrReturn(pListHdr, VERR_INVALID_POINTER);
     244    AssertPtrReturn(phList,   VERR_INVALID_POINTER);
     245
     246    VBoxClipboardListHdrReadMsg Msg;
     247    RT_ZERO(Msg);
     248
     249    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
     250                       VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_READ, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR_READ);
     251
     252    Msg.uContext.SetUInt32(0); /** @todo Context ID not used yet. */
     253    Msg.uHandle.SetUInt64(0);
     254    Msg.cTotalObjects.SetUInt64(0);
     255    Msg.cbTotalSize.SetUInt64(0);
    183256    Msg.enmCompression.SetUInt32(0);
    184257    Msg.enmChecksumType.SetUInt32(0);
    185     Msg.pvChecksum.SetPtr(pDataHdr->pvChecksum, pDataHdr->cbChecksum);
    186     Msg.cbChecksum.SetUInt32(0);
    187 
    188     int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
    189     if (RT_SUCCESS(rc))
    190     {
    191         /* Msg.uContext not needed here. */
    192         Msg.uFlags.GetUInt32(&pDataHdr->uFlags);
    193         Msg.uScreenId.GetUInt32(&pDataHdr->uScreenId);
    194         Msg.cbTotal.GetUInt64(&pDataHdr->cbTotal);
    195         Msg.cbMeta.GetUInt32(&pDataHdr->cbMeta);
    196         Msg.cbMetaFmt.GetUInt32(&pDataHdr->cbMetaFmt);
    197         Msg.cObjects.GetUInt64(&pDataHdr->cObjects);
    198         Msg.enmCompression.GetUInt32(&pDataHdr->enmCompression);
    199         Msg.enmChecksumType.GetUInt32((uint32_t *)&pDataHdr->enmChecksumType);
    200         Msg.cbChecksum.GetUInt32(&pDataHdr->cbChecksum);
    201 
    202         AssertReturn(SharedClipboardURIDataHdrIsValid(pDataHdr), VERR_INVALID_PARAMETER);
    203     }
    204 
    205     LogFlowFuncLeaveRC(rc);
    206     return rc;
    207 }
    208 
    209 /**
    210  * Sends a guest clipboard data header to the host.
    211  *
    212  * This is usually called in reply to a VBOX_SHARED_CLIPBOARD_HOST_READ_DATA message from the host
    213  * (if URI format is specified).
     258
     259    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     260    if (RT_SUCCESS(rc))
     261    {
     262        rc = Msg.uHandle.GetUInt64(phList); AssertRC(rc);
     263    }
     264
     265    LogFlowFuncLeaveRC(rc);
     266    return rc;
     267}
     268
     269static int vbglR3ClipboardRecvListEntryRead(HGCMCLIENTID idClient, PVBOXCLIPBOARDLISTHANDLE phList,
     270                                            PVBOXCLIPBOARDLISTENTRY pListEntry)
     271{
     272    AssertPtrReturn(pListEntry, VERR_INVALID_POINTER);
     273    AssertPtrReturn(phList,     VERR_INVALID_POINTER);
     274
     275    VBoxClipboardListEntryReadMsg Msg;
     276    RT_ZERO(Msg);
     277
     278    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
     279                       VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY_READ);
     280
     281    Msg.uContext.SetUInt32(0); /** @todo Context ID not used yet. */
     282    Msg.uHandle.SetUInt64(0);
     283    Msg.fInfo.SetUInt32(0);
     284    Msg.cbInfo.SetUInt32(0);
     285    Msg.pvInfo.SetPtr(pListEntry->pvInfo, pListEntry->cbInfo);
     286
     287    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     288    if (RT_SUCCESS(rc))
     289    {
     290        rc = Msg.uHandle.GetUInt64(phList);             AssertRC(rc);
     291        rc = Msg.fInfo.GetUInt32(&pListEntry->fInfo);   AssertRC(rc);
     292        rc = Msg.cbInfo.GetUInt32(&pListEntry->cbInfo); AssertRC(rc);
     293    }
     294
     295    LogFlowFuncLeaveRC(rc);
     296    return rc;
     297}
     298
     299VBGLR3DECL(int) VbglR3ClipboardEventGetNext(HGCMCLIENTID idClient, PSHAREDCLIPBOARDURITRANSFER pTransfer,
     300                                            PVBGLR3CLIPBOARDEVENT *ppEvent)
     301{
     302    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
     303    AssertPtrReturn(ppEvent,   VERR_INVALID_POINTER);
     304
     305    PVBGLR3CLIPBOARDEVENT pEvent = (PVBGLR3CLIPBOARDEVENT)RTMemAllocZ(sizeof(VBGLR3CLIPBOARDEVENT));
     306    if (!pEvent)
     307        return VERR_NO_MEMORY;
     308
     309    uint32_t uMsg   = 0;
     310    uint32_t cParms = 0;
     311    int rc = vbglR3ClipboardGetNextMsgType(idClient, &uMsg, &cParms, true /* fWait */);
     312    if (RT_SUCCESS(rc))
     313    {
     314        /** @todo Check for VM session change. */
     315    }
     316
     317#if 0
     318    typedef struct _
     319    {
     320        union
     321        {
     322            struct Dir
     323            {
     324                RTDIR hDir;
     325            };
     326        } u;
     327    };
     328#endif
     329
     330    if (RT_SUCCESS(rc))
     331    {
     332        LogFunc(("Handling uMsg=%RU32\n", uMsg));
     333
     334        switch (uMsg)
     335        {
     336#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
     337            case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN:
     338            {
     339                LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN\n"));
     340
     341                VBOXCLIPBOARDLISTHDR listHdr;
     342                rc = SharedClipboardURIListHdrInit(&listHdr);
     343                if (RT_SUCCESS(rc))
     344                {
     345                    rc = vbglR3ClipboardRecvListOpen(idClient, &listHdr);
     346                    if (RT_SUCCESS(rc))
     347                    {
     348                        rc = SharedClipboardURITransferListOpen(pTransfer, &listHdr, NULL /* phList */);
     349                    }
     350
     351                    SharedClipboardURIListHdrDestroy(&listHdr);
     352                }
     353
     354                break;
     355            }
     356
     357            case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE:
     358            {
     359                LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE\n"));
     360
     361                VBOXCLIPBOARDLISTHANDLE hList;
     362                rc = vbglR3ClipboardRecvListClose(idClient, &hList);
     363                if (RT_SUCCESS(rc))
     364                {
     365                    rc = SharedClipboardURITransferListClose(pTransfer, hList);
     366                }
     367
     368                break;
     369            }
     370
     371            case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_READ:
     372            {
     373                LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_READ\n"));
     374
     375                /** @todo Handle filter + list features. */
     376
     377                VBOXCLIPBOARDLISTHDR listHdr;
     378                rc = SharedClipboardURIListHdrInit(&listHdr);
     379                if (RT_SUCCESS(rc))
     380                {
     381                    VBOXCLIPBOARDLISTHANDLE hList;
     382                    rc = vbglR3ClipboardRecvListHdrRead(idClient, &hList, &listHdr);
     383                    if (RT_SUCCESS(rc))
     384                    {
     385                        if (SharedClipboardURITransferListHandleIsValid(pTransfer, hList))
     386                        {
     387                            rc = VbglR3ClipboardSendListHdrWrite(idClient, hList, &listHdr);
     388                        }
     389                        else
     390                            rc = VERR_INVALID_HANDLE;
     391                    }
     392
     393                    SharedClipboardURIListHdrDestroy(&listHdr);
     394                }
     395
     396                break;
     397            }
     398
     399            case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_WRITE:
     400            {
     401                LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_WRITE\n"));
     402                pEvent->enmType = VBGLR3CLIPBOARDEVENTTYPE_URI_LIST_HDR_WRITE;
     403                break;
     404            }
     405
     406            case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ:
     407            {
     408                LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ\n"));
     409
     410                VBOXCLIPBOARDLISTENTRY listEntry;
     411                rc = SharedClipboardURIListEntryInit(&listEntry);
     412                if (RT_SUCCESS(rc))
     413                {
     414                    VBOXCLIPBOARDLISTHANDLE hList;
     415                    rc = vbglR3ClipboardRecvListEntryRead(idClient, &hList, &listEntry);
     416                    if (RT_SUCCESS(rc))
     417                    {
     418                        if (SharedClipboardURITransferListHandleIsValid(pTransfer, hList))
     419                        {
     420                            rc = VbglR3ClipboardSendListEntryWrite(idClient, hList, &listEntry);
     421                        }
     422                        else
     423                            rc = VERR_INVALID_HANDLE;
     424                    }
     425
     426                    SharedClipboardURIListEntryDestroy(&listEntry);
     427                }
     428                break;
     429            }
     430
     431            case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_WRITE:
     432            {
     433                LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_WRITE\n"));
     434                pEvent->enmType = VBGLR3CLIPBOARDEVENTTYPE_URI_LIST_ENTRY_WRITE;
     435                break;
     436            }
     437
     438            case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN:
     439            {
     440                LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN\n"));
     441                pEvent->enmType = VBGLR3CLIPBOARDEVENTTYPE_URI_OBJ_OPEN;
     442                break;
     443            }
     444
     445            case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE:
     446            {
     447                LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE\n"));
     448                pEvent->enmType = VBGLR3CLIPBOARDEVENTTYPE_URI_OBJ_CLOSE;
     449                break;
     450            }
     451
     452            case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ:
     453            {
     454                LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ\n"));
     455                pEvent->enmType = VBGLR3CLIPBOARDEVENTTYPE_URI_OBJ_READ;
     456                break;
     457            }
     458
     459            case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_WRITE:
     460            {
     461                LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_WRITE\n"));
     462                pEvent->enmType = VBGLR3CLIPBOARDEVENTTYPE_URI_OBJ_WRITE;
     463                break;
     464            }
     465#endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
     466
     467            default:
     468                rc = VERR_NOT_SUPPORTED;
     469                break;
     470        }
     471    }
     472
     473
     474    if (RT_SUCCESS(rc))
     475    {
     476        if (pEvent->enmType != VBGLR3CLIPBOARDEVENTTYPE_INVALID)
     477        {
     478            *ppEvent = pEvent;
     479        }
     480        else
     481            VbglR3ClipboardEventFree(pEvent);
     482    }
     483    else
     484    {
     485        /* Report error back to the host. */
     486        VbglR3ClipboardWriteError(idClient, rc);
     487
     488        VbglR3ClipboardEventFree(pEvent);
     489    }
     490
     491    LogFlowFuncLeaveRC(rc);
     492    return rc;
     493}
     494
     495/**
     496 * Frees (destroys) a formerly allocated Shared Clipboard event.
     497 *
     498 * @returns IPRT status code.
     499 * @param   pEvent              Event to free (destroy).
     500 */
     501VBGLR3DECL(void) VbglR3ClipboardEventFree(PVBGLR3CLIPBOARDEVENT pEvent)
     502{
     503    if (!pEvent)
     504        return;
     505
     506    /* Some messages require additional cleanup. */
     507    switch (pEvent->enmType)
     508    {
     509        default:
     510            break;
     511    }
     512
     513    RTMemFree(pEvent);
     514    pEvent = NULL;
     515}
     516
     517#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
     518/**
     519 * Sends a list header to the host.
    214520 *
    215521 * @returns VBox status code.
    216522 * @param   idClient        The client id returned by VbglR3ClipboardConnect().
    217  * @param   pDataHdr        Pointer to data header to send.
    218  */
    219 VBGLR3DECL(int) VbglR3ClipboardWriteDataHdr(HGCMCLIENTID idClient, const PVBOXCLIPBOARDDATAHDR pDataHdr)
    220 {
    221     VBoxClipboardWriteDataHdrMsg Msg;
    222     RT_ZERO(Msg);
    223 
    224     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DATA_HDR, VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_DATA_HDR);
    225 
    226     AssertReturn(SharedClipboardURIDataHdrIsValid(pDataHdr), VERR_INVALID_PARAMETER);
    227 
    228     Msg.uContext.SetUInt32(0);                                          /** @todo Not used yet. */
    229     Msg.uFlags.SetUInt32(pDataHdr->uFlags);                             /** @todo Not used yet. */
    230     Msg.uScreenId.SetUInt32(pDataHdr->uScreenId);                       /** @todo Not used yet. */
    231     Msg.cbTotal.SetUInt64(pDataHdr->cbTotal);
    232     Msg.cbMeta.SetUInt32(pDataHdr->cbMeta);
    233     Msg.cbMetaFmt.SetUInt32(pDataHdr->cbMetaFmt);
    234     Msg.pvMetaFmt.SetPtr(pDataHdr->pvMetaFmt, pDataHdr->cbMetaFmt);
    235     Msg.cObjects.SetUInt64(pDataHdr->cObjects);
    236     Msg.enmCompression.SetUInt32(pDataHdr->enmCompression);             /** @todo Not used yet. */
    237     Msg.enmChecksumType.SetUInt32(RTDIGESTTYPE_INVALID);                /** @todo Not used yet. */
    238     Msg.cbChecksum.SetUInt32(0);                                        /** @todo Not used yet. */
    239     Msg.pvChecksum.SetPtr(NULL, 0);                                     /** @todo Not used yet. */
    240 
    241     int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
    242 
    243     LogFlowFunc(("cbTotal=%RU64, cbMeta=%RU32, pvMetaFmt=%p (%RU32), cObjects=%RU64, rc=%Rrc\n",
    244                  pDataHdr->cbTotal, pDataHdr->cbMeta, pDataHdr->pvMetaFmt, pDataHdr->cbMetaFmt, pDataHdr->cObjects, rc));
    245 
    246     LogFlowFuncLeaveRC(rc);
    247     return rc;
    248 }
    249 
    250 /**
    251  * Reads a (meta) data chunk from the host.
     523 * @param   hList           List handle to send header for.
     524 * @param   pListHdr        List header to send.
     525 */
     526VBGLR3DECL(int) VbglR3ClipboardSendListHdrWrite(HGCMCLIENTID idClient,
     527                                                VBOXCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTHDR pListHdr)
     528{
     529    VBoxClipboardListHdrWriteMsg Msg;
     530    RT_ZERO(Msg);
     531
     532    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
     533                       VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_WRITE, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR_WRITE);
     534
     535    Msg.uContext.SetUInt32(0); /** @todo Not used yet. */
     536    Msg.uHandle.SetUInt64(hList);
     537    Msg.cTotalObjects.SetUInt64(pListHdr->cTotalObjects);
     538    Msg.cbTotalSize.SetUInt64(pListHdr->cbTotalSize);
     539    Msg.enmCompression.SetUInt32(pListHdr->enmCompression);
     540    Msg.enmChecksumType.SetUInt32(RTDIGESTTYPE_INVALID);
     541
     542    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     543
     544    LogFlowFuncLeaveRC(rc);
     545    return rc;
     546}
     547
     548/**
     549 * Sends a list entry to the host.
    252550 *
    253551 * @returns IPRT status code.
    254  * @param   idClient            The client id returned by VbglR3ClipboardConnect().
    255  * @param   pDataHdr            Data header to use. Need for accounting and stuff.
    256  * @param   pvData              Where to store the received data from the host.
    257  * @param   cbData              Size (in bytes) of where to store the received data.
    258  * @param   pcbDataRecv         Where to store the received amount of data (in bytes).
    259  */
    260 static int vbglR3ClipboardReadDataChunk(HGCMCLIENTID idClient, PVBOXCLIPBOARDDATAHDR pDataHdr,
    261                                         void *pvData, uint32_t cbData, uint32_t *pcbDataRecv)
    262 {
    263     AssertPtrReturn(pDataHdr,        VERR_INVALID_POINTER);
    264     AssertPtrReturn(pvData,          VERR_INVALID_POINTER);
    265     AssertReturn(cbData,             VERR_INVALID_PARAMETER);
    266     AssertPtrNullReturn(pcbDataRecv, VERR_INVALID_POINTER);
    267 
    268     LogFlowFunc(("pvDate=%p, cbData=%RU32\n", pvData, cbData));
    269 
    270     VBoxClipboardReadDataChunkMsg Msg;
    271     RT_ZERO(Msg);
    272 
    273     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
    274                        VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_DATA_CHUNK, VBOX_SHARED_CLIPBOARD_CPARMS_READ_DATA_CHUNK);
     552 * @param   idClient            The client id returned by VbglR3ClipboardConnect()
     553 * @param   hList               List handle to send entry for.
     554 * @param   pListEntry          List entry to send.
     555 */
     556VBGLR3DECL(int) VbglR3ClipboardSendListEntryWrite(HGCMCLIENTID idClient,
     557                                                  VBOXCLIPBOARDLISTHANDLE hList, PVBOXCLIPBOARDLISTENTRY pListEntry)
     558{
     559    AssertPtrReturn(pListEntry, VERR_INVALID_POINTER);
     560
     561    VBoxClipboardListEntryWriteMsg Msg;
     562    RT_ZERO(Msg);
     563
     564    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
     565                       VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_WRITE, VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY_WRITE);
     566
     567    Msg.uContext.SetUInt32(0); /** @todo Not used yet. */
     568    Msg.uHandle.SetUInt64(hList);
     569    Msg.fInfo.SetUInt32(pListEntry->fInfo);
     570    Msg.cbInfo.SetUInt32(pListEntry->cbInfo);
     571    Msg.pvInfo.SetPtr(pListEntry->pvInfo, pListEntry->cbInfo);
     572
     573    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     574
     575    LogFlowFuncLeaveRC(rc);
     576    return rc;
     577}
     578
     579VBGLR3DECL(int) VbglR3ClipboardObjOpen(HGCMCLIENTID idClient,
     580                                       const char *pszPath, PVBOXCLIPBOARDCREATEPARMS pCreateParms,
     581                                       PSHAREDCLIPBOARDOBJHANDLE phObj)
     582{
     583    AssertPtrReturn(pszPath, VERR_INVALID_POINTER);
     584    AssertPtrReturn(pCreateParms, VERR_INVALID_POINTER);
     585    AssertPtrReturn(phObj, VERR_INVALID_POINTER);
     586
     587    VBoxClipboardObjOpenMsg Msg;
     588    RT_ZERO(Msg);
     589
     590    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
     591                       VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_OPEN, VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_OPEN);
     592
     593    int rc;
     594
     595    char *pszPathTmp = RTStrDup(pszPath);
     596    if (pszPathTmp)
     597    {
     598        Msg.szPath.SetPtr((void *)pszPathTmp, (uint32_t)strlen(pszPathTmp) + 1 /* Include terminating zero */);
     599        Msg.parms.SetPtr(pCreateParms, sizeof(VBOXCLIPBOARDCREATEPARMS));
     600
     601        rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     602        if (RT_SUCCESS(rc))
     603        {
     604            *phObj = pCreateParms->uHandle;
     605        }
     606
     607        RTStrFree(pszPathTmp);
     608    }
     609    else
     610        rc = VERR_NO_MEMORY;
     611
     612    LogFlowFuncLeaveRC(rc);
     613    return rc;
     614}
     615
     616VBGLR3DECL(int) VbglR3ClipboardObjClose(HGCMCLIENTID idClient, SHAREDCLIPBOARDOBJHANDLE hObj)
     617{
     618    VBoxClipboardObjCloseMsg Msg;
     619    RT_ZERO(Msg);
     620
     621    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
     622                       VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_CLOSE, VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_CLOSE);
     623
     624    Msg.uHandle.SetUInt64(hObj);
     625
     626    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     627
     628    LogFlowFuncLeaveRC(rc);
     629    return rc;
     630}
     631
     632VBGLR3DECL(int) VbglR3ClipboardObjRead(HGCMCLIENTID idClient, SHAREDCLIPBOARDOBJHANDLE hObj,
     633                                       void *pvData, uint32_t cbData, uint32_t *pcbRead)
     634{
     635    AssertPtrReturn(pvData,  VERR_INVALID_POINTER);
     636    AssertReturn(cbData,     VERR_INVALID_PARAMETER);
     637    /* pcbRead is optional. */
     638
     639    VBoxClipboardObjReadWriteMsg Msg;
     640    RT_ZERO(Msg);
     641
     642    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_READ, VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_READ);
     643
     644    Msg.uContext.SetUInt32(0);
     645    Msg.uHandle.SetUInt64(hObj);
    275646    Msg.pvData.SetPtr(pvData, cbData);
    276647    Msg.cbData.SetUInt32(0);
    … …  
    281652    if (RT_SUCCESS(rc))
    282653    {
    283         uint32_t cbDataRecv;
    284         rc = Msg.cbData.GetUInt32(&cbDataRecv);
    285         AssertRC(rc);
    286         if (RT_SUCCESS(rc))
     654        /** @todo Context ID not used yet. */
     655        /** @todo Add checksum support. */
     656
     657        if (pcbRead)
    287658        {
    288             /** @todo Use checksum for validating the received data. */
    289             if (pcbDataRecv)
    290                 *pcbDataRecv = cbDataRecv;
    291             LogFlowFuncLeaveRC(rc);
    292             return rc;
     659            rc = Msg.cbData.GetUInt32(pcbRead); AssertRC(rc);
     660            AssertReturn(cbData >= *pcbRead, VERR_TOO_MUCH_DATA);
    293661        }
    294662    }
    295663
    296     /* failure */
    297     LogFlowFuncLeaveRC(rc);
    298     return rc;
    299 }
    300 
    301 /**
    302  * Helper function for reading the actual clipboard (meta) data from the host. Do not call directly.
    303  *
    304  * @returns IPRT status code.
    305  * @param   idClient            The client id returned by VbglR3ClipboardConnect().
    306  * @param   pDataHdr            Pointer to data header to use.
    307  * @param   pvMeta              Where to store the received meta data.
    308  * @param   cbMeta              Size (in bytes) of meta data buffer.
    309  * @param   pcbRead             How much bytes were read on success. Optional.
    310  */
    311 static int vbglR3ClipboardReadMetaDataLoop(HGCMCLIENTID idClient, PVBOXCLIPBOARDDATAHDR pDataHdr,
    312                                            void *pvMeta, uint32_t cbMeta, uint32_t *pcbRead)
    313 {
    314     AssertPtrReturn(pDataHdr, VERR_INVALID_POINTER);
    315     AssertPtrReturn(pvMeta,   VERR_INVALID_POINTER);
    316 
    317     LogFlowFuncEnter();
    318 
    319     int rc = VINF_SUCCESS;
    320 
    321     uint32_t cbReadTotal = 0;
    322 
    323     LogFlowFunc(("cbTotal=%RU64, cbMeta=%RU32, cObjects=%RU32\n", pDataHdr->cbTotal, pDataHdr->cbMeta, pDataHdr->cObjects));
    324     if (pDataHdr->cbMeta)
    325     {
    326         uint32_t cbToRead = RT_MIN(cbMeta, pDataHdr->cbMeta);
    327         while (cbToRead)
    328         {
    329             uint32_t cbRead;
    330             rc = vbglR3ClipboardReadDataChunk(idClient, pDataHdr,
    331                                               (uint8_t *)pvMeta + cbReadTotal, cbToRead, &cbRead);
    332             if (RT_FAILURE(rc))
    333                 break;
    334 
    335             Assert(cbToRead >= cbRead);
    336             cbToRead -= cbRead;
    337 
    338             cbReadTotal += cbRead;
    339         }
    340     }
    341 
    342     if (RT_SUCCESS(rc))
    343     {
    344         if (pcbRead)
    345             *pcbRead = cbReadTotal;
    346     }
    347 
    348     LogFlowFuncLeaveRC(rc);
    349     return rc;
    350 }
    351 
    352 /**
    353  * Reads the actual meta data from the host, internal version.
    354  *
    355  * @returns IPRT status code.
    356  * @param   idClient            The client id returned by VbglR3ClipboardConnect().
    357  * @param   pDataHdr            Pointer to data header to use.
    358  * @param   pvMeta              Where to store the received meta data.
    359  * @param   cbMeta              Size (in bytes) of meta data buffer.
    360  * @param   pcbRead             How much bytes were read on success. Optional.
    361  */
    362 static int vbglR3ClipboardReadMetaDataInternal(HGCMCLIENTID idClient, PVBOXCLIPBOARDDATAHDR pDataHdr,
    363                                                void *pvMeta, uint32_t cbMeta, uint32_t *pcbRead)
    364 {
    365    LogFlowFuncEnter();
    366 
    367     int rc = vbglR3ClipboardReadMetaDataLoop(idClient, pDataHdr, pvMeta, cbMeta, pcbRead);
    368 
    369     LogFlowFuncLeaveRC(rc);
    370     return rc;
    371 }
    372 
    373 /**
    374  * Reads the actual meta data from the host, extended version.
    375  *
    376  * @returns IPRT status code.
    377  * @param   idClient            The client id returned by VbglR3ClipboardConnect().
    378  * @param   pvMeta              Where to store the received meta data.
    379  * @param   cbMeta              Size (in bytes) of meta data buffer.
    380  * @param   pcbRead             How much bytes were read on success. Optional.
    381  */
    382 VBGLR3DECL(int) VbglR3ClipboardReadMetaDataEx(HGCMCLIENTID idClient, PVBOXCLIPBOARDDATAHDR pDataHdr,
    383                                               void *pvMeta, uint32_t cbMeta, uint32_t *pcbRead)
    384 {
    385     return vbglR3ClipboardReadMetaDataInternal(idClient, pDataHdr, pvMeta, cbMeta, pcbRead);
    386 }
    387 
    388 /**
    389  * Reads the actual meta data from the host.
    390  *
    391  * @returns IPRT status code.
    392  * @param   idClient            The client id returned by VbglR3ClipboardConnect().
    393  * @param   pvMeta              Where to store the received meta data.
    394  * @param   cbMeta              Size (in bytes) of meta data buffer.
    395  * @param   pcbRead             How much bytes were read on success. Optional.
    396  */
    397 VBGLR3DECL(int) VbglR3ClipboardReadMetaData(HGCMCLIENTID idClient, PVBOXCLIPBOARDDATAHDR pDataHdr,
    398                                             void *pvMeta, uint32_t cbMeta, uint32_t *pcbRead)
    399 {
    400     return VbglR3ClipboardReadMetaDataEx(idClient, pDataHdr, pvMeta, cbMeta, pcbRead);
    401 }
    402 
    403 /**
    404  * Writes a (meta) data chunk to the host.
    405  *
    406  * @returns IPRT status code.
    407  * @param   idClient            The client id returned by VbglR3ClipboardConnect().
    408  * @param   pDataHdr            Data header to use. Need for accounting and stuff.
    409  * @param   pvData              Where to store the received data from the host.
    410  * @param   cbData              Size (in bytes) of where to store the received data.
    411  * @param   pcbDataWritten      Where to store the written amount of data (in bytes).
    412  */
    413 static int vbglR3ClipboardWriteDataChunk(HGCMCLIENTID idClient, PVBOXCLIPBOARDDATAHDR pDataHdr,
    414                                          void *pvData, uint32_t cbData, uint32_t *pcbDataWritten)
    415 {
    416     AssertPtrReturn(pDataHdr,        VERR_INVALID_POINTER);
    417     AssertPtrReturn(pvData,          VERR_INVALID_POINTER);
    418     AssertReturn(cbData,             VERR_INVALID_PARAMETER);
    419     AssertPtrNullReturn(pcbDataWritten, VERR_INVALID_POINTER);
    420 
    421     LogFlowFunc(("pvDate=%p, cbData=%RU32\n", pvData, cbData));
    422 
    423     VBoxClipboardReadDataChunkMsg Msg;
    424     RT_ZERO(Msg);
    425 
    426     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
    427                        VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DATA_CHUNK, VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_DATA_CHUNK);
    428 
    429     Msg.uContext.SetUInt32(0);                                          /** @todo Not used yet. */
     664    LogFlowFuncLeaveRC(rc);
     665    return rc;
     666}
     667
     668VBGLR3DECL(int) VbglR3ClipboardObjWrite(HGCMCLIENTID idClient,
     669                                        SHAREDCLIPBOARDOBJHANDLE hObj,
     670                                        void *pvData, uint32_t cbData, uint32_t *pcbWritten)
     671{
     672    AssertPtrReturn(pvData, VERR_INVALID_POINTER);
     673    AssertReturn(cbData, VERR_INVALID_PARAMETER);
     674    /* pcbWritten is optional. */
     675
     676    VBoxClipboardObjReadWriteMsg Msg;
     677    RT_ZERO(Msg);
     678
     679    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_WRITE, VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_WRITE);
     680
     681    Msg.uContext.SetUInt32(0);
     682    Msg.uHandle.SetUInt64(hObj);
     683    Msg.pvData.SetPtr(pvData, cbData);
    430684    Msg.cbData.SetUInt32(cbData);
    431     Msg.pvData.SetPtr(pvData, cbData);
    432     Msg.cbChecksum.SetUInt32(0);
    433     Msg.pvChecksum.SetPtr(NULL, 0);
    434 
    435     int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
    436     if (RT_SUCCESS(rc))
    437     {
    438         if (pcbDataWritten)
    439             *pcbDataWritten = cbData;
    440     }
    441 
    442     /* failure */
    443     LogFlowFuncLeaveRC(rc);
    444     return rc;
    445 }
    446 
    447 /**
    448  * Writes the actual meta data to the host, internal version.
    449  *
    450  * @returns IPRT status code.
    451  * @param   idClient            The client id returned by VbglR3ClipboardConnect().
    452  * @param   pDataHdr            Pointer to data header to use.
    453  * @param   pvMeta              Meta data buffer to write.
    454  * @param   cbMeta              Size (in bytes) of meta data buffer.
    455  * @param   pcbWritten          How much bytes were written on success. Optional.
    456  */
    457 static int vbglR3ClipboardWriteMetaDataInternal(HGCMCLIENTID idClient, PVBOXCLIPBOARDDATAHDR pDataHdr,
    458                                                 const void *pvMeta, uint32_t cbMeta, uint32_t *pcbWritten)
    459 {
    460     AssertPtrReturn(pDataHdr, VERR_INVALID_POINTER);
    461     AssertPtrReturn(pvMeta,   VERR_INVALID_POINTER);
    462 
    463     LogFlowFuncEnter();
    464 
    465     int rc = VINF_SUCCESS;
    466 
    467     uint32_t cbWrittenTotal = 0;
    468 
    469     LogFlowFunc(("cbTotal=%RU64, cbMeta=%RU32, cObjects=%RU32\n", pDataHdr->cbTotal, pDataHdr->cbMeta, pDataHdr->cObjects));
    470     if (pDataHdr->cbMeta)
    471     {
    472         uint32_t cbToWrite = RT_MIN(cbMeta, pDataHdr->cbMeta);
    473         while (cbToWrite)
    474         {
    475             uint32_t cbWritten;
    476             rc = vbglR3ClipboardWriteDataChunk(idClient, pDataHdr,
    477                                                (uint8_t *)pvMeta + cbWrittenTotal, cbToWrite, &cbWritten);
    478             if (RT_FAILURE(rc))
    479                 break;
    480 
    481             Assert(cbToWrite >= cbWritten);
    482             cbToWrite -= cbWritten;
    483 
    484             cbWrittenTotal += cbWritten;
    485         }
    486     }
    487 
    488     if (RT_SUCCESS(rc))
    489     {
    490         if (pcbWritten)
    491             *pcbWritten = cbWrittenTotal;
    492     }
    493 
    494     LogFlowFunc(("cbWrittenTotal=%RU32, rc=%Rrc\n", cbWrittenTotal, rc));
    495     return rc;
    496 }
    497 
    498 /**
    499  * Writes the actual meta data to the host, extended version.
    500  *
    501  * @returns IPRT status code.
    502  * @param   idClient            The client id returned by VbglR3ClipboardConnect().
    503  * @param   pDataHdr            Pointer to data header to use.
    504  * @param   pvMeta              Pointer to meta data buffer.
    505  * @param   cbMeta              Size (in bytes) of meta data buffer.
    506  * @param   pcbWritten          How much bytes were written on success. Optional.
    507  */
    508 VBGLR3DECL(int) VbglR3ClipboardWriteMetaDataEx(HGCMCLIENTID idClient, PVBOXCLIPBOARDDATAHDR pDataHdr,
    509                                                const void *pvMeta, uint32_t cbMeta, uint32_t *pcbWritten)
    510 {
    511     int rc = vbglR3ClipboardWriteMetaDataInternal(idClient, pDataHdr, pvMeta, cbMeta, pcbWritten);
    512 
    513     LogFlowFuncLeaveRC(rc);
    514     return rc;
    515 }
    516 
    517 /**
    518  * Writes the actual meta data to the host.
    519  *
    520  * @returns IPRT status code.
    521  * @param   idClient            The client id returned by VbglR3ClipboardConnect().
    522  * @param   pDataHdr            Pointer to data header to use.
    523  * @param   pvMeta              Pointer to meta data buffer.
    524  * @param   cbMeta              Size (in bytes) of meta data buffer.
    525  * @param   pcbWritten          How much bytes were written on success. Optional.
    526  */
    527 VBGLR3DECL(int) VbglR3ClipboardWriteMetaData(HGCMCLIENTID idClient, PVBOXCLIPBOARDDATAHDR pDataHdr,
    528                                              const void *pvMeta, uint32_t cbMeta, uint32_t *pcbWritten)
    529 {
    530     return VbglR3ClipboardWriteMetaDataEx(idClient, pDataHdr, pvMeta, cbMeta, pcbWritten);
    531 }
    532 
    533 /**
    534  * Reads a directory entry from the host.
    535  *
    536  * @returns IPRT status code.
    537  * @param   idClient            The client id returned by VbglR3ClipboardConnect().
    538  * @param   pszDirname          Where to store the directory name of the directory being created.
    539  * @param   cbDirname           Size (in bytes) of where to store the directory name of the directory being created.
    540  * @param   pcbDirnameRecv      Size (in bytes) of the actual directory name received.
    541  * @param   pfMode              Where to store the directory creation mode.
    542  */
    543 VBGLR3DECL(int) VbglR3ClipboardReadDir(HGCMCLIENTID idClient,
    544                                        char     *pszDirname,
    545                                        uint32_t  cbDirname,
    546                                        uint32_t *pcbDirnameRecv,
    547                                        uint32_t *pfMode)
    548 {
    549     AssertPtrReturn(pszDirname,     VERR_INVALID_POINTER);
    550     AssertReturn(cbDirname,         VERR_INVALID_PARAMETER);
    551     AssertPtrReturn(pcbDirnameRecv, VERR_INVALID_POINTER);
    552     AssertPtrReturn(pfMode,         VERR_INVALID_POINTER);
    553 
    554     VBoxClipboardReadDirMsg Msg;
    555     RT_ZERO(Msg);
    556 
    557     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_DIR, VBOX_SHARED_CLIPBOARD_CPARMS_READ_DIR);
    558     /** @todo Context ID not used yet. */
    559     Msg.uContext.SetUInt32(0);
    560     Msg.pvName.SetPtr(pszDirname, cbDirname);
    561     Msg.cbName.SetUInt32(cbDirname);
    562     Msg.fMode.SetUInt32(0);
    563 
    564     int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
    565     if (RT_SUCCESS(rc))
    566     {
    567         /** @todo Context ID not used yet. */
    568         rc = Msg.cbName.GetUInt32(pcbDirnameRecv); AssertRC(rc);
    569         rc = Msg.fMode.GetUInt32(pfMode);          AssertRC(rc);
    570 
    571         AssertReturn(cbDirname >= *pcbDirnameRecv, VERR_TOO_MUCH_DATA);
    572     }
    573 
    574     return rc;
    575 }
    576 
    577 /**
    578  * Writes a guest directory to the host.
    579  *
    580  * @returns IPRT status code.
    581  * @param   idClient        The client id returned by VbglR3ClipboardConnect().
    582  * @param   pszPath         Directory path.
    583  * @param   cbPath          Size (in bytes) of directory path.
    584  * @param   fMode           File mode for directory (IPRT-style).
    585  */
    586 VBGLR3DECL(int) VbglR3ClipboardWriteDir(HGCMCLIENTID idClient,
    587                                         const char  *pszPath,
    588                                         uint32_t     cbPath,
    589                                         uint32_t     fMode)
    590 {
    591     const size_t cchDir = strlen(pszPath);
    592 
    593     if (   !cchDir
    594         ||  cchDir >  RTPATH_MAX
    595         ||  cchDir != cbPath) /* UTF-8 */
    596         return VERR_INVALID_PARAMETER;
    597 
    598     const uint32_t cbPathSz = (uint32_t)cchDir + 1; /* Include termination. */
    599 
    600     VBoxClipboardWriteDirMsg Msg;
    601     RT_ZERO(Msg);
    602 
    603     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DIR, VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_DIR);
    604     /** @todo Context ID not used yet. */
    605     Msg.pvName.SetPtr((void *)pszPath, (uint32_t)cbPathSz);
    606     Msg.cbName.SetUInt32(cbPathSz);
    607     Msg.fMode.SetUInt32(fMode);
    608 
    609     return VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
    610 }
    611 
    612 /**
    613  * Receives a file header from the host.
    614  *
    615  * @returns IPRT status code.
    616  * @param   idClient            The client id returned by VbglR3ClipboardConnect().
    617  * @param   pszFilename         Where to store the file name of the file being transferred.
    618  * @param   cbFilename          Size (in bytes) of where to store the file name of the file being transferred.
    619  * @param   puFlags             File transfer flags. Currently not being used.
    620  * @param   pfMode              Where to store the file creation mode.
    621  * @param   pcbTotal            Where to store the file size (in bytes).
    622  */
    623 VBGLR3DECL(int) VbglR3ClipboardReadFileHdr(HGCMCLIENTID  idClient,
    624                                            char         *pszFilename,
    625                                            uint32_t      cbFilename,
    626                                            uint32_t     *puFlags,
    627                                            uint32_t     *pfMode,
    628                                            uint64_t     *pcbTotal)
    629 {
    630     AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
    631     AssertReturn(cbFilename,     VERR_INVALID_PARAMETER);
    632     AssertPtrReturn(puFlags,     VERR_INVALID_POINTER);
    633     AssertPtrReturn(pfMode,      VERR_INVALID_POINTER);
    634     AssertReturn(pcbTotal,       VERR_INVALID_POINTER);
    635 
    636     VBoxClipboardReadFileHdrMsg Msg;
    637     RT_ZERO(Msg);
    638 
    639     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
    640                        VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_FILE_HDR, VBOX_SHARED_CLIPBOARD_CPARMS_READ_FILE_HDR);
    641     Msg.uContext.SetUInt32(0); /** @todo Not used yet. */
    642     Msg.pvName.SetPtr(pszFilename, cbFilename);
    643     Msg.cbName.SetUInt32(cbFilename);
    644     Msg.uFlags.SetUInt32(0);
    645     Msg.fMode.SetUInt32(0);
    646     Msg.cbTotal.SetUInt64(0);
    647 
    648     int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
    649     if (RT_SUCCESS(rc))
    650     {
    651         /** @todo Get context ID. */
    652         rc = Msg.uFlags.GetUInt32(puFlags);   AssertRC(rc);
    653         rc = Msg.fMode.GetUInt32(pfMode);     AssertRC(rc);
    654         rc = Msg.cbTotal.GetUInt64(pcbTotal); AssertRC(rc);
    655     }
    656 
    657     return rc;
    658 }
    659 
    660 /**
    661  * Writes a file header from the guest to the host.
    662  *
    663  * @returns VBox status code.
    664  * @param   idClient            The client id returned by VbglR3ClipboardConnect().
    665  * @param   pszFilename         File name this header belong to.
    666  * @param   cbFilename          Size (in bytes) of file name.
    667  * @param   fFlags              Transfer flags; not being used and will be ignored.
    668  * @param   fMode               File mode.
    669  * @param   cbTotal             File size (in bytes).
    670  */
    671 VBGLR3DECL(int) VbglR3ClipboardWriteFileHdr(HGCMCLIENTID idClient, const char *pszFilename, uint32_t cbFilename,
    672                                             uint32_t fFlags, uint32_t fMode, uint64_t cbTotal)
    673 {
    674     RT_NOREF(fFlags);
    675 
    676     const size_t cchFile = strlen(pszFilename);
    677 
    678     if (   !cchFile
    679         ||  cchFile >  RTPATH_MAX
    680         ||  cchFile != cbFilename)
    681         return VERR_INVALID_PARAMETER;
    682 
    683     const uint32_t cbFileSz = (uint32_t)cchFile + 1; /* Include termination. */
    684 
    685     VBoxClipboardWriteFileHdrMsg MsgHdr;
    686     RT_ZERO(MsgHdr);
    687 
    688     VBGL_HGCM_HDR_INIT(&MsgHdr.hdr, idClient, VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_FILE_HDR, VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_FILE_HDR);
    689     MsgHdr.uContext.SetUInt32(0);                                                    /* Context ID; unused at the moment. */
    690     MsgHdr.cbName.SetUInt32(cbFileSz);
    691     MsgHdr.pvName.SetPtr((void *)pszFilename, (uint32_t)(cbFileSz));
    692     MsgHdr.uFlags.SetUInt32(0);                                                      /* Flags; unused at the moment. */
    693     MsgHdr.fMode.SetUInt32(fMode);                                                   /* File mode */
    694     MsgHdr.cbTotal.SetUInt64(cbTotal);                                               /* File size (in bytes). */
    695 
    696     return VbglR3HGCMCall(&MsgHdr.hdr, sizeof(MsgHdr));
    697 }
    698 
    699 /**
    700  * Reads a file data chunk from the host.
    701  *
    702  * @returns IPRT status code.
    703  * @param   idClient            The client id returned by VbglR3ClipboardConnect().
    704  * @param   pvData              Where to store the file data chunk.
    705  * @param   cbData              Size (in bytes) of where to store the data chunk.
    706  * @param   pcbRead             Size (in bytes) of the actual data chunk size read.
    707  */
    708 VBGLR3DECL(int) VbglR3ClipboardReadFileData(HGCMCLIENTID          idClient,
    709                                             void                 *pvData,
    710                                             uint32_t              cbData,
    711                                             uint32_t             *pcbRead)
    712 {
    713     AssertPtrReturn(pvData,  VERR_INVALID_POINTER);
    714     AssertReturn(cbData,     VERR_INVALID_PARAMETER);
    715     AssertPtrReturn(pcbRead, VERR_INVALID_POINTER);
    716 
    717     VBoxClipboardReadFileDataMsg Msg;
    718     RT_ZERO(Msg);
    719 
    720     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
    721                        VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_FILE_DATA, VBOX_SHARED_CLIPBOARD_CPARMS_READ_FILE_DATA);
    722     Msg.uContext.SetUInt32(0);
    723     Msg.pvData.SetPtr(pvData, cbData);
    724     Msg.cbData.SetUInt32(0);
    725685    Msg.pvChecksum.SetPtr(NULL, 0);
    726686    Msg.cbChecksum.SetUInt32(0);
    … …  
    729689    if (RT_SUCCESS(rc))
    730690    {
    731         /** @todo Context ID not used yet. */
    732         rc = Msg.cbData.GetUInt32(pcbRead); AssertRC(rc);
    733         AssertReturn(cbData >= *pcbRead, VERR_TOO_MUCH_DATA);
    734         /** @todo Add checksum support. */
    735     }
    736 
    737     return rc;
    738 }
    739 
    740 /**
    741  * Writes a file data chunk to the host.
    742  *
    743  * @returns VBox status code.
    744  * @param   idClient            The client id returned by VbglR3ClipboardConnect().
    745  * @param   pvData              Data chunk to write.
    746  * @param   cbData              Size (in bytes) of data chunk to write.
    747  * @param   pcbWritten          Returns how many bytes written.
    748  */
    749 VBGLR3DECL(int) VbglR3ClipboardWriteFileData(HGCMCLIENTID idClient, void *pvData, uint32_t cbData, uint32_t *pcbWritten)
    750 {
    751     AssertPtrReturn(pvData,     VERR_INVALID_POINTER);
    752     AssertReturn(cbData,        VERR_INVALID_PARAMETER);
    753     AssertPtrReturn(pcbWritten, VERR_INVALID_POINTER);
    754 
    755     VBoxClipboardWriteFileDataMsg MsgData;
    756     RT_ZERO(MsgData);
    757 
    758     VBGL_HGCM_HDR_INIT(&MsgData.hdr, idClient, VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_FILE_DATA, VBOX_SHARED_CLIPBOARD_CPARMS_READ_FILE_DATA);
    759     MsgData.uContext.SetUInt32(0);                                                    /* Context ID; unused at the moment. */
    760     MsgData.pvData.SetPtr(pvData, cbData);
    761     MsgData.cbData.SetUInt32(cbData);
    762     MsgData.pvChecksum.SetPtr(NULL, 0);
    763     MsgData.cbChecksum.SetUInt32(0);
    764 
    765     int rc = VbglR3HGCMCall(&MsgData.hdr, sizeof(MsgData));
    766     if (RT_SUCCESS(rc))
    767     {
    768         *pcbWritten = cbData;
    769     }
    770 
     691        if (pcbWritten)
     692            *pcbWritten = cbData;
     693    }
     694
     695    LogFlowFuncLeaveRC(rc);
    771696    return rc;
    772697}
    … …  
    827752{
    828753    int rc  = vbglR3ClipboardWriteDataRaw(idClient, fFormat, pv, cb);
    829 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
    830     if (RT_FAILURE(rc))
    831     {
    832         int rc2 = vbglR3ClipboardWriteErrorInternal(idClient, rc);
    833         if (RT_FAILURE(rc2))
    834             LogFlowFunc(("Unable to send error (%Rrc) to host, rc=%Rrc\n", rc, rc2));
    835     }
    836 #endif
    837754
    838755    return rc;
    … …  
    847764 * @param   rcErr               Error (IPRT-style) to send.
    848765 */
    849 static int vbglR3ClipboardWriteErrorInternal(HGCMCLIENTID idClient, int rcErr)
     766VBGLR3DECL(int) VbglR3ClipboardWriteError(HGCMCLIENTID idClient, int rcErr)
    850767{
    851768    VBoxClipboardWriteErrorMsg Msg;
    852769    RT_ZERO(Msg);
    853770
    854     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_ERROR, 2);
     771    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, VBOX_SHARED_CLIPBOARD_GUEST_FN_ERROR, VBOX_SHARED_CLIPBOARD_CPARMS_ERROR);
     772
    855773    /** @todo Context ID not used yet. */
    856774    Msg.uContext.SetUInt32(0);
    … …  
    859777    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
    860778
    861     /*
    862      * Never return an error if the host did not accept the error at the current
    863      * time.  This can be due to the host not having any appropriate callbacks
    864      * set which would handle that error.
    865      *
    866      * bird: Looks like VERR_NOT_SUPPORTED is what the host will return if it
    867      *       doesn't an appropriate callback.  The code used to ignore ALL errors
    868      *       the host would return, also relevant ones.
    869      */
    870779    if (RT_FAILURE(rc))
    871780        LogFlowFunc(("Sending error %Rrc failed with rc=%Rrc\n", rcErr, rc));
    … …  
    873782        rc = VINF_SUCCESS;
    874783
    875     return rc;
    876 }
    877 
    878 /**
    879  * Writes an error back to the host.
    880  *
    881  * @returns IPRT status code.
    882  * @param   idClient            The client id returned by VbglR3ClipboardConnect().
    883  * @param   rcErr               Error (IPRT-style) to send.
    884  */
    885 VBGLR3DECL(int) vbglR3ClipboardWriteError(HGCMCLIENTID idClient, int rcErr)
    886 {
    887     return vbglR3ClipboardWriteErrorInternal(idClient, rcErr);
     784    if (RT_FAILURE(rc))
     785        LogRel(("Shared Clipboard: Reporting error %Rrc to the host failed with %Rrc\n", rcErr, rc));
     786
     787    LogFlowFuncLeaveRC(rc);
     788    return rc;
    888789}
    889790#endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */

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

    r78080 r79497  
    359359 * @returns IPRT status code.
    360360 * @param   pCtx                DnD context to use.
    361  * @param   pDataHdr            DnD data header to use. Needed for accounting.
     361 * @param   pListHdr            DnD data header to use. Needed for accounting.
    362362 * @param   pDroppedFiles       Dropped files object to use for maintaining the file creation / locking.
    363363 */
    364 static int vbglR3DnDHGRecvURIData(PVBGLR3GUESTDNDCMDCTX pCtx, PVBOXDNDSNDDATAHDR pDataHdr, DnDDroppedFiles *pDroppedFiles)
     364static int vbglR3DnDHGRecvURIData(PVBGLR3GUESTDNDCMDCTX pCtx, PVBOXDNDSNDListHdr pListHdr, DnDDroppedFiles *pDroppedFiles)
    365365{
    366366    AssertPtrReturn(pCtx,          VERR_INVALID_POINTER);
    367     AssertPtrReturn(pDataHdr,      VERR_INVALID_POINTER);
     367    AssertPtrReturn(pListHdr,      VERR_INVALID_POINTER);
    368368    AssertPtrReturn(pDroppedFiles, VERR_INVALID_POINTER);
    369369
    370370    /* Only count the raw data minus the already received meta data. */
    371     Assert(pDataHdr->cbTotal >= pDataHdr->cbMeta);
    372     uint64_t cbToRecvBytes = pDataHdr->cbTotal - pDataHdr->cbMeta;
    373     uint64_t cToRecvObjs   = pDataHdr->cObjects;
     371    Assert(pListHdr->cbTotal >= pListHdr->cbMeta);
     372    uint64_t cbToRecvBytes = pListHdr->cbTotal - pListHdr->cbMeta;
     373    uint64_t cToRecvObjs   = pListHdr->cObjects;
    374374
    375375    LogFlowFunc(("cbToRecvBytes=%RU64, cToRecvObjs=%RU64, (cbTotal=%RU64, cbMeta=%RU32)\n",
    376                  cbToRecvBytes, cToRecvObjs, pDataHdr->cbTotal, pDataHdr->cbMeta));
     376                 cbToRecvBytes, cToRecvObjs, pListHdr->cbTotal, pListHdr->cbMeta));
    377377
    378378    /* Anything to do at all? */
    … …  
    641641 * @returns IPRT status code.
    642642 * @param   pCtx                DnD context to use.
    643  * @param   pDataHdr            DnD data header to use. Need for accounting and stuff.
     643 * @param   pListHdr            DnD data header to use. Need for accounting and stuff.
    644644 * @param   pvData              Where to store the received data from the host.
    645645 * @param   cbData              Size (in bytes) of where to store the received data.
    646646 * @param   pcbDataRecv         Where to store the received amount of data (in bytes).
    647647 */
    648 static int vbglR3DnDHGRecvDataRaw(PVBGLR3GUESTDNDCMDCTX pCtx, PVBOXDNDSNDDATAHDR pDataHdr,
     648static int vbglR3DnDHGRecvDataRaw(PVBGLR3GUESTDNDCMDCTX pCtx, PVBOXDNDSNDListHdr pListHdr,
    649649                                  void *pvData, uint32_t cbData, uint32_t *pcbDataRecv)
    650650{
    651651    AssertPtrReturn(pCtx,            VERR_INVALID_POINTER);
    652     AssertPtrReturn(pDataHdr,        VERR_INVALID_POINTER);
     652    AssertPtrReturn(pListHdr,        VERR_INVALID_POINTER);
    653653    AssertPtrReturn(pvData,          VERR_INVALID_POINTER);
    654654    AssertReturn(cbData,             VERR_INVALID_PARAMETER);
    … …  
    694694 * @returns IPRT status code.
    695695 * @param   pCtx                DnD context to use.
    696  * @param   pDataHdr            Where to store the receivd DnD data header.
    697  */
    698 static int vbglR3DnDHGRecvDataHdr(PVBGLR3GUESTDNDCMDCTX pCtx, PVBOXDNDSNDDATAHDR pDataHdr)
     696 * @param   pListHdr            Where to store the receivd DnD data header.
     697 */
     698static int vbglR3DnDHGRecvListHdr(PVBGLR3GUESTDNDCMDCTX pCtx, PVBOXDNDSNDListHdr pListHdr)
    699699{
    700700    AssertPtrReturn(pCtx,     VERR_INVALID_POINTER);
    701     AssertPtrReturn(pDataHdr, VERR_INVALID_POINTER);
     701    AssertPtrReturn(pListHdr, VERR_INVALID_POINTER);
    702702
    703703    Assert(pCtx->uProtocol >= 3); /* Only for protocol v3 and up. */
    704704
    705     VBOXDNDHGSENDDATAHDRMSG Msg;
     705    VBOXDNDHGSENDListHdrMSG Msg;
    706706    RT_ZERO(Msg);
    707707    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, HOST_DND_HG_SND_DATA_HDR, 12);
    … …  
    711711    Msg.cbTotal.SetUInt64(0);
    712712    Msg.cbMeta.SetUInt32(0);
    713     Msg.pvMetaFmt.SetPtr(pDataHdr->pvMetaFmt, pDataHdr->cbMetaFmt);
     713    Msg.pvMetaFmt.SetPtr(pListHdr->pvMetaFmt, pListHdr->cbMetaFmt);
    714714    Msg.cbMetaFmt.SetUInt32(0);
    715715    Msg.cObjects.SetUInt64(0);
    716716    Msg.enmCompression.SetUInt32(0);
    717717    Msg.enmChecksumType.SetUInt32(0);
    718     Msg.pvChecksum.SetPtr(pDataHdr->pvChecksum, pDataHdr->cbChecksum);
     718    Msg.pvChecksum.SetPtr(pListHdr->pvChecksum, pListHdr->cbChecksum);
    719719    Msg.cbChecksum.SetUInt32(0);
    720720
    … …  
    723723    {
    724724        /* Msg.uContext not needed here. */
    725         Msg.uFlags.GetUInt32(&pDataHdr->uFlags);
    726         Msg.uScreenId.GetUInt32(&pDataHdr->uScreenId);
    727         Msg.cbTotal.GetUInt64(&pDataHdr->cbTotal);
    728         Msg.cbMeta.GetUInt32(&pDataHdr->cbMeta);
    729         Msg.cbMetaFmt.GetUInt32(&pDataHdr->cbMetaFmt);
    730         Msg.cObjects.GetUInt64(&pDataHdr->cObjects);
    731         Msg.enmCompression.GetUInt32(&pDataHdr->enmCompression);
    732         Msg.enmChecksumType.GetUInt32((uint32_t *)&pDataHdr->enmChecksumType);
    733         Msg.cbChecksum.GetUInt32(&pDataHdr->cbChecksum);
     725        Msg.uFlags.GetUInt32(&pListHdr->uFlags);
     726        Msg.uScreenId.GetUInt32(&pListHdr->uScreenId);
     727        Msg.cbTotal.GetUInt64(&pListHdr->cbTotal);
     728        Msg.cbMeta.GetUInt32(&pListHdr->cbMeta);
     729        Msg.cbMetaFmt.GetUInt32(&pListHdr->cbMetaFmt);
     730        Msg.cObjects.GetUInt64(&pListHdr->cObjects);
     731        Msg.enmCompression.GetUInt32(&pListHdr->enmCompression);
     732        Msg.enmChecksumType.GetUInt32((uint32_t *)&pListHdr->enmChecksumType);
     733        Msg.cbChecksum.GetUInt32(&pListHdr->cbChecksum);
    734734    }
    735735
    … …  
    744744 * @returns IPRT status code.
    745745 * @param   pCtx                DnD context to use.
    746  * @param   pDataHdr            Where to store the data header data.
     746 * @param   pListHdr            Where to store the data header data.
    747747 * @param   ppvData             Returns the received meta data. Needs to be free'd by the caller.
    748748 * @param   pcbData             Where to store the size (in bytes) of the received meta data.
    749749 */
    750 static int vbglR3DnDHGRecvDataLoop(PVBGLR3GUESTDNDCMDCTX pCtx, PVBOXDNDSNDDATAHDR pDataHdr,
     750static int vbglR3DnDHGRecvDataLoop(PVBGLR3GUESTDNDCMDCTX pCtx, PVBOXDNDSNDListHdr pListHdr,
    751751                                   void **ppvData, uint64_t *pcbData)
    752752{
    753753    AssertPtrReturn(pCtx,     VERR_INVALID_POINTER);
    754     AssertPtrReturn(pDataHdr, VERR_INVALID_POINTER);
     754    AssertPtrReturn(pListHdr, VERR_INVALID_POINTER);
    755755    AssertPtrReturn(ppvData,  VERR_INVALID_POINTER);
    756756    AssertPtrReturn(pcbData,  VERR_INVALID_POINTER);
    … …  
    761761    LogFlowFuncEnter();
    762762
    763     rc = vbglR3DnDHGRecvDataHdr(pCtx, pDataHdr);
     763    rc = vbglR3DnDHGRecvListHdr(pCtx, pListHdr);
    764764    if (RT_FAILURE(rc))
    765765        return rc;
    766766
    767     LogFlowFunc(("cbTotal=%RU64, cbMeta=%RU32, cObjects=%RU32\n", pDataHdr->cbTotal, pDataHdr->cbMeta, pDataHdr->cObjects));
    768     if (pDataHdr->cbMeta)
     767    LogFlowFunc(("cbTotal=%RU64, cbMeta=%RU32, cObjects=%RU32\n", pListHdr->cbTotal, pListHdr->cbMeta, pListHdr->cObjects));
     768    if (pListHdr->cbMeta)
    769769    {
    770770        uint64_t cbDataTmp = 0;
    771         void    *pvDataTmp = RTMemAlloc(pDataHdr->cbMeta);
     771        void    *pvDataTmp = RTMemAlloc(pListHdr->cbMeta);
    772772        if (!pvDataTmp)
    773773            rc = VERR_NO_MEMORY;
    … …  
    776776        {
    777777            uint8_t *pvDataOff = (uint8_t *)pvDataTmp;
    778             while (cbDataTmp < pDataHdr->cbMeta)
     778            while (cbDataTmp < pListHdr->cbMeta)
    779779            {
    780                 rc = vbglR3DnDHGRecvDataRaw(pCtx, pDataHdr,
    781                                             pvDataOff, RT_MIN(pDataHdr->cbMeta - cbDataTmp, pCtx->cbMaxChunkSize),
     780                rc = vbglR3DnDHGRecvDataRaw(pCtx, pListHdr,
     781                                            pvDataOff, RT_MIN(pListHdr->cbMeta - cbDataTmp, pCtx->cbMaxChunkSize),
    782782                                            &cbDataRecv);
    783783                if (RT_SUCCESS(rc))
    784784                {
    785785                    LogFlowFunc(("cbDataRecv=%RU32, cbDataTmp=%RU64\n", cbDataRecv, cbDataTmp));
    786                     Assert(cbDataTmp + cbDataRecv <= pDataHdr->cbMeta);
     786                    Assert(cbDataTmp + cbDataRecv <= pListHdr->cbMeta);
    787787                    cbDataTmp += cbDataRecv;
    788788                    pvDataOff += cbDataRecv;
    … …  
    794794            if (RT_SUCCESS(rc))
    795795            {
    796                 Assert(cbDataTmp == pDataHdr->cbMeta);
     796                Assert(cbDataTmp == pListHdr->cbMeta);
    797797
    798798                LogFlowFunc(("Received %RU64 bytes of data\n", cbDataTmp));
    … …  
    833833    /* The rest is optional. */
    834834
    835     VBOXDNDDATAHDR dataHdr;
    836     RT_ZERO(dataHdr);
     835    VBOXDNDListHdr ListHdr;
     836    RT_ZERO(ListHdr);
    837837
    838838    AssertMsg(pCtx->cbMaxChunkSize, ("Maximum chunk size must not be 0\n"));
    839839
    840     dataHdr.cbMetaFmt = pCtx->cbMaxChunkSize;
    841     dataHdr.pvMetaFmt = RTMemAlloc(dataHdr.cbMetaFmt);
    842     if (!dataHdr.pvMetaFmt)
     840    ListHdr.cbMetaFmt = pCtx->cbMaxChunkSize;
     841    ListHdr.pvMetaFmt = RTMemAlloc(ListHdr.cbMetaFmt);
     842    if (!ListHdr.pvMetaFmt)
    843843        return VERR_NO_MEMORY;
    844844
    … …  
    849849    uint64_t cbData = 0;
    850850
    851     int rc = vbglR3DnDHGRecvDataLoop(pCtx, &dataHdr, &pvData, &cbData);
     851    int rc = vbglR3DnDHGRecvDataLoop(pCtx, &ListHdr, &pvData, &cbData);
    852852    if (RT_SUCCESS(rc))
    853853    {
    … …  
    860860         * VBoxTray) small by not having too much redundant code.
    861861         */
    862         Assert(dataHdr.cbMetaFmt);
    863         AssertPtr(dataHdr.pvMetaFmt);
    864         if (DnDMIMEHasFileURLs((char *)dataHdr.pvMetaFmt, dataHdr.cbMetaFmt)) /* URI data. */
     862        Assert(ListHdr.cbMetaFmt);
     863        AssertPtr(ListHdr.pvMetaFmt);
     864        if (DnDMIMEHasFileURLs((char *)ListHdr.pvMetaFmt, ListHdr.cbMetaFmt)) /* URI data. */
    865865        {
    866866            AssertPtr(pvData);
    … …  
    869869            rc = lstURI.SetFromURIData(pvData, cbData, 0 /* fFlags */);
    870870            if (RT_SUCCESS(rc))
    871                 rc = vbglR3DnDHGRecvURIData(pCtx, &dataHdr, &droppedFiles);
     871                rc = vbglR3DnDHGRecvURIData(pCtx, &ListHdr, &droppedFiles);
    872872
    873873            if (RT_SUCCESS(rc)) /** @todo Remove this block as soon as we hand in DnDURIList. */
    … …  
    905905    }
    906906
    907     if (dataHdr.pvMetaFmt)
    908         RTMemFree(dataHdr.pvMetaFmt);
     907    if (ListHdr.pvMetaFmt)
     908        RTMemFree(ListHdr.pvMetaFmt);
    909909
    910910    if (RT_SUCCESS(rc))
    … …  
    14801480 * @param   pvData              Data block to send.
    14811481 * @param   cbData              Size (in bytes) of data block to send.
    1482  * @param   pDataHdr            Data header to use -- needed for accounting.
     1482 * @param   pListHdr            Data header to use -- needed for accounting.
    14831483 */
    14841484static int vbglR3DnDGHSendDataInternal(PVBGLR3GUESTDNDCMDCTX pCtx,
    1485                                        void *pvData, uint64_t cbData, PVBOXDNDSNDDATAHDR pDataHdr)
     1485                                       void *pvData, uint64_t cbData, PVBOXDNDSNDListHdr pListHdr)
    14861486{
    14871487    AssertPtrReturn(pCtx,     VERR_INVALID_POINTER);
    14881488    AssertPtrReturn(pvData,   VERR_INVALID_POINTER);
    14891489    AssertReturn(cbData,      VERR_INVALID_PARAMETER);
    1490     AssertPtrReturn(pDataHdr, VERR_INVALID_POINTER);
    1491 
    1492     VBOXDNDGHSENDDATAHDRMSG MsgHdr;
     1490    AssertPtrReturn(pListHdr, VERR_INVALID_POINTER);
     1491
     1492    VBOXDNDGHSENDListHdrMSG MsgHdr;
    14931493    RT_ZERO(MsgHdr);
    14941494
    … …  
    14971497    MsgHdr.uFlags.SetUInt32(0);                             /** @todo Not used yet. */
    14981498    MsgHdr.uScreenId.SetUInt32(0);                          /** @todo Not used for guest->host (yet). */
    1499     MsgHdr.cbTotal.SetUInt64(pDataHdr->cbTotal);
    1500     MsgHdr.cbMeta.SetUInt32(pDataHdr->cbMeta);
    1501     MsgHdr.pvMetaFmt.SetPtr(pDataHdr->pvMetaFmt, pDataHdr->cbMetaFmt);
    1502     MsgHdr.cbMetaFmt.SetUInt32(pDataHdr->cbMetaFmt);
    1503     MsgHdr.cObjects.SetUInt64(pDataHdr->cObjects);
     1499    MsgHdr.cbTotal.SetUInt64(pListHdr->cbTotal);
     1500    MsgHdr.cbMeta.SetUInt32(pListHdr->cbMeta);
     1501    MsgHdr.pvMetaFmt.SetPtr(pListHdr->pvMetaFmt, pListHdr->cbMetaFmt);
     1502    MsgHdr.cbMetaFmt.SetUInt32(pListHdr->cbMetaFmt);
     1503    MsgHdr.cObjects.SetUInt64(pListHdr->cObjects);
    15041504    MsgHdr.enmCompression.SetUInt32(0);                     /** @todo Not used yet. */
    15051505    MsgHdr.enmChecksumType.SetUInt32(RTDIGESTTYPE_INVALID); /** @todo Not used yet. */
    … …  
    15101510
    15111511    LogFlowFunc(("cbTotal=%RU64, cbMeta=%RU32, cObjects=%RU64, rc=%Rrc\n",
    1512                  pDataHdr->cbTotal, pDataHdr->cbMeta, pDataHdr->cObjects, rc));
     1512                 pListHdr->cbTotal, pListHdr->cbMeta, pListHdr->cObjects, rc));
    15131513
    15141514    if (RT_SUCCESS(rc))
    … …  
    17331733    /* cbData can be 0. */
    17341734
    1735     VBOXDNDDATAHDR dataHdr;
    1736     RT_ZERO(dataHdr);
     1735    VBOXDNDListHdr ListHdr;
     1736    RT_ZERO(ListHdr);
    17371737
    17381738    /* For raw data only the total size is required to be specified. */
    1739     dataHdr.cbTotal = cbData;
    1740 
    1741     return vbglR3DnDGHSendDataInternal(pCtx, pvData, cbData, &dataHdr);
     1739    ListHdr.cbTotal = cbData;
     1740
     1741    return vbglR3DnDGHSendDataInternal(pCtx, pvData, cbData, &ListHdr);
    17421742}
    17431743
    … …  
    17861786            const uint32_t cbMetaFmt   = (uint32_t)strlen(szMetaFmt) + 1; /* Include termination. */
    17871787
    1788             VBOXDNDDATAHDR dataHdr;
    1789             dataHdr.uFlags    = 0; /* Flags not used yet. */
    1790             dataHdr.cbTotal   = cbTotal;
    1791             dataHdr.cbMeta    = cbURLIist;
    1792             dataHdr.pvMetaFmt = (void *)szMetaFmt;
    1793             dataHdr.cbMetaFmt = cbMetaFmt;
    1794             dataHdr.cObjects  = lstURI.GetTotalCount();
     1788            VBOXDNDListHdr ListHdr;
     1789            ListHdr.uFlags    = 0; /* Flags not used yet. */
     1790            ListHdr.cbTotal   = cbTotal;
     1791            ListHdr.cbMeta    = cbURLIist;
     1792            ListHdr.pvMetaFmt = (void *)szMetaFmt;
     1793            ListHdr.cbMetaFmt = cbMetaFmt;
     1794            ListHdr.cObjects  = lstURI.GetTotalCount();
    17951795
    17961796            rc = vbglR3DnDGHSendDataInternal(pCtx,
    1797                                              pvURIList, cbURLIist, &dataHdr);
     1797                                             pvURIList, cbURLIist, &ListHdr);
    17981798        }
    17991799        else

  • trunk/src/VBox/Additions/common/VBoxService/VBoxServiceClipboard-os2.cpp

    r78346 r79497  
    884884                uint32_t Msg;
    885885                uint32_t fFormats;
    886                 rc = VbglR3ClipboardGetHostMsg(g_u32ClientId, &Msg, &fFormats);
     886                rc = VbglR3ClipboardGetHostMsgOld(g_u32ClientId, &Msg, &fFormats);
    887887                if (RT_SUCCESS(rc))
    888888                {
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