VirtualBox

Changeset 80990 in vbox


Ignore:
Timestamp:
Sep 25, 2019 6:20:09 AM (5 years ago)
Author:
vboxsync
Message:

Shared Clipboard/Transfers: Update.

Location:
trunk
Files:
18 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/GuestHost/SharedClipboard-transfers.h

    r80918 r80990  
    6666    SHCLTRANSFERSTATUS_KILLED,
    6767    /** The transfer ran into an unrecoverable error. */
    68     SHCLTRANSFERSTATUS_ERROR
     68    SHCLTRANSFERSTATUS_ERROR,
     69    /** The usual 32-bit hack. */
     70    SHCLTRANSFERSTATUS_32BIT_SIZE_HACK = 0x7fffffff
    6971} SHCLTRANSFERSTATUSENUM;
    7072
    … …  
    213215     * SHCLFSOBJATTRADD_LAST. */
    214216    SHCLFSOBJATTRADD_LAST = SHCLFSOBJATTRADD_EASIZE,
    215 
    216217    /** The usual 32-bit hack. */
    217218    SHCLFSOBJATTRADD_32BIT_SIZE_HACK = 0x7fffffff

  • trunk/include/VBox/GuestHost/SharedClipboard-win.h

    r80863 r80990  
    6767#define SHCL_WIN_WM_READ_DATA               WM_USER + 1
    6868#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    69 /** Reports a transfer status to the guest. */
    70 # define SHCL_WIN_WM_URI_TRANSFER_STATUS    WM_USER + 2
     69/** Starts a transfer on the guest.
     70 *  This creates the necessary IDataObject in the matching window thread. */
     71# define SHCL_WIN_WM_URI_TRANSFER_START    WM_USER + 2
    7172#endif
    7273

  • trunk/include/VBox/GuestHost/clipboard-helper.h

    r80847 r80990  
    193193
    194194/**
     195 * Translates a Shared Clipboard host function number to a string.
     196 *
     197 * @returns Function ID string name.
     198 * @param   uFn                 The function to translate.
     199 */
     200const char *VBoxShClHostFunctionToStr(uint32_t uFn);
     201
     202/**
    195203 * Translates a Shared Clipboard host message enum to a string.
    196204 *

  • trunk/include/VBox/HostServices/VBoxClipboardSvc.h

    r80970 r80990  
    274274#define VBOX_SHCL_CPARMS_CONNECT 5
    275275
     276/**
     277 * Reports available formats.
     278 */
    276279typedef struct _VBoxShClFormatsMsg
    277280{
    … …  
    298301} VBoxShClFormatsMsg;
    299302
     303/**
     304 * Requests to read clipboard data.
     305 */
    300306typedef struct _VBoxShClReadDataReqMsg
    301307{
    … …  
    312318#define VBOX_SHCL_CPARMS_READ_DATA_REQ 2
    313319
     320/**
     321 * Reads clipboard data.
     322 */
    314323typedef struct _VBoxShClReadDataMsg
    315324{
    … …  
    329338#define VBOX_SHCL_CPARMS_READ_DATA 3
    330339
     340/**
     341 * Writes clipboard data.
     342 */
    331343typedef struct _VBoxShClWriteDataMsg
    332344{
    … …  
    401413#define VBOX_SHCL_CPARMS_GET_HOST_MSG 3
    402414
    403 /** @todo might be necessary for future. */
     415/** No listing flags specified. */
    404416#define VBOX_SHCL_LIST_FLAG_NONE          0
     417/** Only returns one entry per read. */
    405418#define VBOX_SHCL_LIST_FLAG_RETURN_ONE    RT_BIT(0)
     419/** Restarts reading a list from the beginning. */
    406420#define VBOX_SHCL_LIST_FLAG_RESTART       RT_BIT(1)
    407421
    … …  
    486500#define VBOX_SHCL_CPARMS_REPLY_MIN 5
    487501
     502/**
     503 * Structure for keeping root list message parameters.
     504 */
    488505typedef struct _VBoxShClRootListParms
    489506{
    … …  
    520537#define VBOX_SHCL_CPARMS_ROOT_LIST_HDR 3
    521538
     539/**
     540 * Structure for keeping list entry message parameters.
     541 */
    522542typedef struct _VBoxShClRootListEntryParms
    523543{
    … …  
    553573    VBoxShClRootListEntryParms Parms;
    554574    /** pointer, in/out: Entry name. */
    555     HGCMFunctionParameter           szName;
     575    HGCMFunctionParameter      szName;
    556576    /** uint32_t, out: Bytes to be used for information/How many bytes were used.  */
    557     HGCMFunctionParameter           cbInfo;
     577    HGCMFunctionParameter      cbInfo;
    558578    /** pointer, in/out: Information to be set/get (SHCLFSOBJINFO only currently).
    559579     *  Do not forget to set the SHCLFSOBJINFO::Attr::enmAdditional for Get operation as well.  */
    560     HGCMFunctionParameter           pvInfo;
     580    HGCMFunctionParameter      pvInfo;
    561581} VBoxShClRootListEntryMsg;
    562582
    … …  
    634654    VBoxShClListHdrReqParms ReqParms;
    635655    /** uint32_t, in/out: Feature flags (see VBOX_SHCL_FEATURE_FLAG_XXX). */
    636     HGCMFunctionParameter        fFeatures;
     656    HGCMFunctionParameter   fFeatures;
    637657    /** uint64_t, in/out:  Number of total objects to transfer. */
    638     HGCMFunctionParameter        cTotalObjects;
     658    HGCMFunctionParameter   cTotalObjects;
    639659    /** uint64_t, in/out:  Number of total bytes to transfer. */
    640     HGCMFunctionParameter        cbTotalSize;
     660    HGCMFunctionParameter   cbTotalSize;
    641661} VBoxShClListHdrMsg;
    642662
    … …  
    685705#define VBOX_SHCL_CPARMS_LIST_ENTRY 6
    686706
     707/**
     708 * Opens a Shared Clipboard object.
     709 */
    687710typedef struct _VBoxShClObjOpenMsg
    688711{
    … …  
    703726#define VBOX_SHCL_CPARMS_OBJ_OPEN 5
    704727
     728/**
     729 * Closes a Shared Clipboard object.
     730 */
    705731typedef struct _VBoxShClObjCloseMsg
    706732{
    … …  
    715741#define VBOX_SHCL_CPARMS_OBJ_CLOSE 2
    716742
     743/**
     744 * Structure for keeping read parameters of a Shared Clipboard object.
     745 */
    717746typedef struct _VBoxShClObjReadReqParms
    718747{
    … …  
    727756} VBoxShClObjReadReqParms;
    728757
     758/**
     759 * Reads from a Shared Clipboard object.
     760 */
    729761typedef struct _VBoxShClObjReadReqMsg
    730762{
    … …  
    785817#pragma pack()
    786818
     819/**
     820 * Structure for keeping a Shared Clipboard file data chunk.
     821 *
     822 * @returns VBox status code.
     823 */
    787824typedef struct _SHCLFILEDATA
    788825{
    … …  
    797834} SHCLFILEDATA, *PSHCLFILEDATA;
    798835
     836/**
     837 * Structure for keeping Shared Clipboard error data.
     838 */
    799839typedef struct _SHCLERRORDATA
    800840{

  • trunk/include/VBox/VBoxGuestLib.h

    r80905 r80990  
    672672VBGLR3DECL(int)     VbglR3ClipboardWriteData(HGCMCLIENTID idClient, uint32_t fFormat, void *pv, uint32_t cb);
    673673VBGLR3DECL(int)     VbglR3ClipboardWriteDataEx(PVBGLR3SHCLCMDCTX pCtx, PSHCLDATABLOCK pData);
    674 VBGLR3DECL(int)     VbglR3ClipboardFormatsSend(PVBGLR3SHCLCMDCTX pCtx, PSHCLFORMATDATA pFormats);
    675 VBGLR3DECL(int)     VbglR3ClipboardReportFormats(HGCMCLIENTID idClient, uint32_t fFormats);
     674VBGLR3DECL(int)     VbglR3ClipboardFormatsReportEx(PVBGLR3SHCLCMDCTX pCtx, PSHCLFORMATDATA pFormats);
     675VBGLR3DECL(int)     VbglR3ClipboardFormatsReport(HGCMCLIENTID idClient, uint32_t fFormats);
    676676
    677677VBGLR3DECL(int)     VbglR3ClipboardConnectEx(PVBGLR3SHCLCMDCTX pCtx);
    … …  
    716716VBGLR3DECL(int)     VbglR3ClipboardObjReadRecv(PVBGLR3SHCLCMDCTX pCtx, PSHCLOBJHANDLE phObj, uint32_t pcbToRead,
    717717                                               uint32_t *pfFlags);
    718 VBGLR3DECL(int)     VbglR3ClipboardObjRead(PVBGLR3SHCLCMDCTX pCtx, SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf,
     718VBGLR3DECL(int)     VbglR3ClipboardObjReadSend(PVBGLR3SHCLCMDCTX pCtx, SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf,
    719719                                               uint32_t *pcbRead);
    720 VBGLR3DECL(int)     VbglR3ClipboardObjWrite(PVBGLR3SHCLCMDCTX pCtx, SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf,
    721                                             uint32_t *pcbWritten);
     720VBGLR3DECL(int)     VbglR3ClipboardObjWriteSend(PVBGLR3SHCLCMDCTX pCtx, SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf,
     721                                                uint32_t *pcbWritten);
    722722#  endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
    723723/** @} */

  • trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxClipboard.cpp

    r80967 r80990  
    9494*********************************************************************************************************************************/
    9595#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
     96static DECLCALLBACK(int)  vboxClipboardOnTransferInitCallback(PSHCLTRANSFERCALLBACKDATA pData);
    9697static DECLCALLBACK(int)  vboxClipboardOnTransferStartCallback(PSHCLTRANSFERCALLBACKDATA pData);
    9798static DECLCALLBACK(void) vboxClipboardOnTransferCompleteCallback(PSHCLTRANSFERCALLBACKDATA pData, int rc);
    … …  
    127128    RTMemFree(pTransfer);
    128129    pTransfer = NULL;
     130}
     131
     132static DECLCALLBACK(int)  vboxClipboardOnTransferInitCallback(PSHCLTRANSFERCALLBACKDATA pData)
     133{
     134    PSHCLCONTEXT pCtx = (PSHCLCONTEXT)pData->pvUser;
     135    AssertPtr(pCtx);
     136
     137    LogFlowFunc(("pCtx=%p\n", pCtx));
     138
     139    RT_NOREF(pData, pCtx);
     140
     141    return VINF_SUCCESS;
    129142}
    130143
    … …  
    183196    else if (SharedClipboardTransferGetDir(pTransfer) == SHCLTRANSFERDIR_READ)
    184197    {
    185         Assert(SharedClipboardTransferGetSource(pTransfer) == SHCLSOURCE_REMOTE); /* Sanity. */
    186 
    187         rc = SharedClipboardWinTransferCreate(&pCtx->Win, pTransfer);
     198        /* The IDataObject must be created in our window thread, so post a message to it, which
     199         * then in turn takes care of the creation. */
     200        ::PostMessage(pCtx->Win.hWnd, SHCL_WIN_WM_URI_TRANSFER_START,
     201                      0 /* wParm */, (LPARAM)pTransfer /* lParm */);
     202
     203        rc = VINF_SUCCESS;
    188204    }
    189205    else
    … …  
    221237    vboxClipboardTransferCallbackCleanup(pData);
    222238}
    223 
    224 static int vboxClipboardTransferOpen(PSHCLPROVIDERCTX pCtx)
    225 {
    226     RT_NOREF(pCtx);
    227 
    228     LogFlowFuncLeave();
    229     return VINF_SUCCESS;
    230 }
    231 
    232 static int vboxClipboardTransferClose(PSHCLPROVIDERCTX pCtx)
    233 {
    234     RT_NOREF(pCtx);
    235 
    236     LogFlowFuncLeave();
    237     return VINF_SUCCESS;
    238 }
    239 
    240 static int vboxClipboardTransferListOpen(PSHCLPROVIDERCTX pCtx, PSHCLLISTOPENPARMS pOpenParms,
    241                                          PSHCLLISTHANDLE phList)
    242 {
    243     RT_NOREF(pCtx, pOpenParms, phList);
    244 
    245     LogFlowFuncEnter();
    246 
    247     PSHCLCONTEXT pThisCtx = (PSHCLCONTEXT)pCtx->pvUser;
    248     AssertPtr(pThisCtx);
    249 
    250     RT_NOREF(pThisCtx);
    251 
    252     int rc = 0; // VbglR3ClipboardRecvListOpen(pThisCtx->u32ClientID, pListHdr, phList);
    253 
    254     LogFlowFuncLeaveRC(rc);
    255     return rc;
    256 }
    257 
    258 static int vboxClipboardTransferListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList)
    259 {
    260     RT_NOREF(pCtx, hList);
    261 
    262     LogFlowFuncEnter();
    263 
    264     PSHCLCONTEXT pThisCtx = (PSHCLCONTEXT)pCtx->pvUser;
    265     AssertPtr(pThisCtx);
    266 
    267     RT_NOREF(pThisCtx);
    268 
    269     int rc = 0; // VbglR3ClipboardRecvListOpen(pThisCtx->u32ClientID, pListHdr, phList);
    270 
    271     LogFlowFuncLeaveRC(rc);
    272     return rc;
    273 }
    274 
    275 static int vboxClipboardTransferGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList)
    276 {
    277     LogFlowFuncEnter();
    278 
    279     PSHCLCONTEXT pThisCtx = (PSHCLCONTEXT)pCtx->pvUser;
    280     AssertPtr(pThisCtx);
    281 
    282     int rc = VbglR3ClipboardRootListRead(&pThisCtx->CmdCtx, ppRootList);
    283 
    284     LogFlowFuncLeaveRC(rc);
    285     return rc;
    286 }
    287 
    288 static int vboxClipboardTransferListHdrRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList,
    289                                             PSHCLLISTHDR pListHdr)
    290 {
    291     RT_NOREF(hList);
    292 
    293     LogFlowFuncEnter();
    294 
    295     PSHCLCONTEXT pThisCtx = (PSHCLCONTEXT)pCtx->pvUser;
    296     AssertPtr(pThisCtx);
    297 
    298     RT_NOREF(pThisCtx);
    299 
    300     int rc = SharedClipboardTransferListHdrInit(pListHdr);
    301     if (RT_SUCCESS(rc))
    302     {
    303         if (RT_SUCCESS(rc))
    304         {
    305             //rc = VbglR3ClipboardListHdrReadRecv(pThisCtx->u32ClientID, hList, pListHdr);
    306         }
    307         else
    308             SharedClipboardTransferListHdrDestroy(pListHdr);
    309     }
    310 
    311     LogFlowFuncLeaveRC(rc);
    312     return rc;
    313 }
    314 
    315 /*
    316 static int vboxClipboardTransferListHdrWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList,
    317                                              PSHCLLISTHDR pListHdr)
    318 {
    319     LogFlowFuncEnter();
    320 
    321     PSHCLCONTEXT pThisCtx = (PSHCLCONTEXT)pCtx->pvUser;
    322     AssertPtr(pThisCtx);
    323 
    324     int rc = VbglR3ClipboardListHdrWrite(pThisCtx->u32ClientID, hList, pListHdr);
    325 
    326     LogFlowFuncLeaveRC(rc);
    327     return rc;
    328 }*/
    329 
    330 static int vboxClipboardTransferListEntryRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList,
    331                                               PSHCLLISTENTRY pListEntry)
    332 {
    333     RT_NOREF(hList);
    334 
    335     LogFlowFuncEnter();
    336 
    337     PSHCLCONTEXT pThisCtx = (PSHCLCONTEXT)pCtx->pvUser;
    338     AssertPtr(pThisCtx);
    339 
    340     RT_NOREF(pThisCtx);
    341 
    342     RT_NOREF(pListEntry);
    343     int rc = 0; // VbglR3ClipboardListEntryRead(pThisCtx->u32ClientID, pListEntry);
    344 
    345     LogFlowFuncLeaveRC(rc);
    346     return rc;
    347 }
    348 
    349 /*
    350 static int vboxClipboardTransferListEntryWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList,
    351                                                PSHCLLISTENTRY pListEntry)
    352 {
    353     LogFlowFuncEnter();
    354 
    355     PSHCLCONTEXT pThisCtx = (PSHCLCONTEXT)pCtx->pvUser;
    356     AssertPtr(pThisCtx);
    357 
    358     int rc = VbglR3ClipboardListEntryWrite(pThisCtx->u32ClientID, hList, pListEntry);
    359 
    360     LogFlowFuncLeaveRC(rc);
    361     return rc;
    362 }
    363 */
    364 
    365 static int vboxClipboardTransferObjOpen(PSHCLPROVIDERCTX pCtx,
    366                                         PSHCLOBJOPENCREATEPARMS pCreateParms, PSHCLOBJHANDLE phObj)
    367 {
    368     LogFlowFuncEnter();
    369 
    370     PSHCLCONTEXT pThisCtx = (PSHCLCONTEXT)pCtx->pvUser;
    371     AssertPtr(pThisCtx);
    372 
    373     int rc = VbglR3ClipboardObjOpenSend(&pThisCtx->CmdCtx, pCreateParms, phObj);
    374 
    375     LogFlowFuncLeaveRC(rc);
    376     return rc;
    377 }
    378 
    379 static int vboxClipboardTransferObjClose(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj)
    380 {
    381     LogFlowFuncEnter();
    382 
    383     PSHCLCONTEXT pThisCtx = (PSHCLCONTEXT)pCtx->pvUser;
    384     AssertPtr(pThisCtx);
    385 
    386     int rc = VbglR3ClipboardObjCloseSend(&pThisCtx->CmdCtx, hObj);
    387 
    388     LogFlowFuncLeaveRC(rc);
    389     return rc;
    390 }
    391 
    392 static int vboxClipboardTransferObjRead(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
    393                                         void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead)
    394 {
    395     RT_NOREF(fFlags);
    396 
    397     LogFlowFuncEnter();
    398 
    399     PSHCLCONTEXT pThisCtx = (PSHCLCONTEXT)pCtx->pvUser;
    400     AssertPtr(pThisCtx);
    401 
    402     int rc = VbglR3ClipboardObjRead(&pThisCtx->CmdCtx, hObj, pvData, cbData, pcbRead);
    403 
    404     LogFlowFuncLeaveRC(rc);
    405     return rc;
    406 }
    407 
    408 static int vboxClipboardTransferObjWrite(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
    409                                          void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten)
    410 {
    411     RT_NOREF(fFlags);
    412 
    413     LogFlowFuncEnter();
    414 
    415     PSHCLCONTEXT pThisCtx = (PSHCLCONTEXT)pCtx->pvUser;
    416     AssertPtr(pThisCtx);
    417 
    418     int rc = VbglR3ClipboardObjWrite(&pThisCtx->CmdCtx, hObj, pvData, cbData, pcbWritten);
    419 
    420     LogFlowFuncLeaveRC(rc);
    421     return rc;
    422 }
    423239#endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
    424240
    … …  
    435251        case WM_CLIPBOARDUPDATE:
    436252        {
    437             LogFunc(("WM_CLIPBOARDUPDATE: Waiting ...\n"));
     253            LogFunc(("WM_CLIPBOARDUPDATE\n"));
    438254
    439255            int rc = RTCritSectEnter(&pWinCtx->CritSect);
    … …  
    457273                    {
    458274                        LogFunc(("WM_CLIPBOARDUPDATE: Reporting formats 0x%x\n", Formats.uFormats));
    459                         rc = VbglR3ClipboardFormatsSend(&pCtx->CmdCtx, &Formats);
     275                        rc = VbglR3ClipboardFormatsReportEx(&pCtx->CmdCtx, &Formats);
    460276                    }
    461277                }
    … …  
    480296       }
    481297
    482        case WM_DRAWCLIPBOARD:
    483        {
    484            LogFlowFunc(("WM_DRAWCLIPBOARD: hwnd %p\n", pWinCtx->hWnd));
    485 
    486            if (GetClipboardOwner() != hwnd)
    487            {
    488                /* Clipboard was updated by another application. */
    489                /* WM_DRAWCLIPBOARD always expects a return code of 0, so don't change "rc" here. */
    490                SHCLFORMATDATA Formats;
    491                int rc = SharedClipboardWinGetFormats(pWinCtx, &Formats);
    492                if (   RT_SUCCESS(rc)
    493                    && Formats.uFormats != VBOX_SHCL_FMT_NONE)
    494                {
    495                    rc = VbglR3ClipboardFormatsSend(&pCtx->CmdCtx, &Formats);
    496                }
    497            }
    498 
    499            lresultRc = SharedClipboardWinChainPassToNext(pWinCtx, msg, wParam, lParam);
    500            break;
    501        }
     298        case WM_DRAWCLIPBOARD:
     299        {
     300            LogFlowFunc(("WM_DRAWCLIPBOARD\n"));
     301
     302            int rc = RTCritSectEnter(&pWinCtx->CritSect);
     303            if (RT_SUCCESS(rc))
     304            {
     305                const HWND hWndClipboardOwner = GetClipboardOwner();
     306
     307                LogFunc(("WM_DRAWCLIPBOARD: hWndClipboardOwnerUs=%p, hWndNewClipboardOwner=%p\n",
     308                         pWinCtx->hWndClipboardOwnerUs, hWndClipboardOwner));
     309
     310                if (pWinCtx->hWndClipboardOwnerUs != hWndClipboardOwner)
     311                {
     312                    int rc2 = RTCritSectLeave(&pWinCtx->CritSect);
     313                    AssertRC(rc2);
     314
     315                    /* Clipboard was updated by another application. */
     316                    /* WM_DRAWCLIPBOARD always expects a return code of 0, so don't change "rc" here. */
     317                    SHCLFORMATDATA Formats;
     318                    rc = SharedClipboardWinGetFormats(pWinCtx, &Formats);
     319                    if (RT_SUCCESS(rc)
     320                        && Formats.uFormats != VBOX_SHCL_FMT_NONE)
     321                    {
     322                        rc = VbglR3ClipboardFormatsReportEx(&pCtx->CmdCtx, &Formats);
     323                    }
     324                }
     325                else
     326                {
     327                    int rc2 = RTCritSectLeave(&pWinCtx->CritSect);
     328                    AssertRC(rc2);
     329                }
     330            }
     331
     332            lresultRc = SharedClipboardWinChainPassToNext(pWinCtx, msg, wParam, lParam);
     333            break;
     334        }
    502335
    503336       case WM_TIMER:
    … …  
    819652
    820653#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    821        case SHCL_WIN_WM_URI_TRANSFER_STATUS:
     654       case SHCL_WIN_WM_URI_TRANSFER_START:
    822655       {
    823            LogFunc(("SHCL_WIN_WM_URI_TRANSFER_STATUS\n"));
    824 
     656           LogFunc(("SHCL_WIN_WM_URI_TRANSFER_CREATE\n"));
     657
     658           PSHCLTRANSFER pTransfer = (PSHCLTRANSFER)lParam;
     659           AssertPtr(pTransfer);
     660
     661           Assert(SharedClipboardTransferGetSource(pTransfer) == SHCLSOURCE_REMOTE); /* Sanity. */
     662
     663           int rc2 = SharedClipboardWinTransferCreate(&pCtx->Win, pTransfer);
     664           AssertRC(rc2);
    825665           break;
    826666       }
    827667#endif
    828 
    829 #if 0
    830        /* The host wants to write transfer data. */
    831        case VBOX_CLIPBOARD_WM_URI_START_WRITE:
    832        {
    833            LogFunc(("VBOX_CLIPBOARD_WM_URI_START_WRITE: cTransfersRunning=%RU32\n",
    834                     SharedClipboardTransferCtxGetRunningTransfers(&pCtx->URI)));
    835 
    836            PSHCLTRANSFER pTransfer;
    837            int rc = SharedClipboardTransferCreate(SHCLTRANSFERDIR_READ,
    838                                                   SHCLSOURCE_LOCAL,
    839                                                   &pTransfer);
    840            if (RT_SUCCESS(rc))
    841            {
    842                SHCLTRANSFERCALLBACKS TransferCallbacks;
    843                RT_ZERO(TransferCallbacks);
    844 
    845                TransferCallbacks.pvUser              = &pCtx->URI;
    846                TransferCallbacks.pfnTransferComplete = vboxClipboardTransferCompleteCallback;
    847                TransferCallbacks.pfnTransferError    = vboxClipboardTransferErrorCallback;
    848 
    849                SharedClipboardTransferSetCallbacks(pTransfer, &TransferCallbacks);
    850 
    851                SHCLPROVIDERCREATIONCTX creationCtx;
    852                RT_ZERO(creationCtx);
    853 
    854                creationCtx.enmSource = SHCLSOURCE_REMOTE;
    855 
    856                creationCtx.Interface.pfnRootsGet      = vboxClipboardTransferGetRoots;
    857                creationCtx.Interface.pfnListOpen      = vboxClipboardTransferListOpen;
    858                creationCtx.Interface.pfnListClose     = vboxClipboardTransferListClose;
    859                creationCtx.Interface.pfnListHdrRead   = vboxClipboardTransferListHdrRead;
    860                creationCtx.Interface.pfnListEntryRead = vboxClipboardTransferListEntryRead;
    861                creationCtx.Interface.pfnObjOpen       = vboxClipboardTransferObjOpen;
    862                creationCtx.Interface.pfnObjClose      = vboxClipboardTransferObjClose;
    863                creationCtx.Interface.pfnObjRead       = vboxClipboardTransferObjRead;
    864 
    865                creationCtx.pvUser = pCtx;
    866 
    867                rc = SharedClipboardTransferSetInterface(pTransfer, &creationCtx);
    868                if (RT_SUCCESS(rc))
    869                {
    870                    rc = SharedClipboardTransferCtxTransferAdd(&pCtx->URI, pTransfer);
    871                    if (RT_SUCCESS(rc))
    872                    {
    873                        rc = SharedClipboardTransferPrepare(pTransfer);
    874                        if (RT_SUCCESS(rc))
    875                        {
    876                            rc = SharedClipboardWinTransferCreate(pWinCtx, pTransfer);
    877                        }
    878                    }
    879                }
    880            }
    881 
    882            break;
    883        }
    884 #endif /* 0 */
    885668
    886669       case WM_DESTROY:
    … …  
    1034817        pCtx->CmdCtx.Transfers.Callbacks.pvUser = pCtx; /* Assign context as user-provided callback data. */
    1035818
    1036         pCtx->CmdCtx.Transfers.Callbacks.pfnTransferStart    = vboxClipboardOnTransferStartCallback;
    1037         pCtx->CmdCtx.Transfers.Callbacks.pfnTransferComplete = vboxClipboardOnTransferCompleteCallback;
    1038         pCtx->CmdCtx.Transfers.Callbacks.pfnTransferError    = vboxClipboardOnTransferErrorCallback;
     819        pCtx->CmdCtx.Transfers.Callbacks.pfnTransferInitialize = vboxClipboardOnTransferInitCallback;
     820        pCtx->CmdCtx.Transfers.Callbacks.pfnTransferStart      = vboxClipboardOnTransferStartCallback;
     821        pCtx->CmdCtx.Transfers.Callbacks.pfnTransferComplete   = vboxClipboardOnTransferCompleteCallback;
     822        pCtx->CmdCtx.Transfers.Callbacks.pfnTransferError      = vboxClipboardOnTransferErrorCallback;
    1039823    }
    1040824#endif
    … …  
    1186970                   ::PostMessage(pWinCtx->hWnd, SHCL_WIN_WM_REPORT_FORMATS,
    1187971                                 0 /* wParam */, (LPARAM)pEvent /* lParam */);
     972
     973                   pEvent = NULL; /* Consume pointer. */
    1188974                   break;
    1189975               }
    … …  
    1194980                   ::PostMessage(pWinCtx->hWnd, SHCL_WIN_WM_READ_DATA,
    1195981                                 0 /* wParam */, (LPARAM)pEvent /* lParam */);
     982
     983                   pEvent = NULL; /* Consume pointer. */
    1196984                   break;
    1197985               }
    1198986
    1199 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    1200                case VBGLR3CLIPBOARDEVENTTYPE_URI_TRANSFER_STATUS:
    1201                {
    1202                    ::PostMessage(pWinCtx->hWnd, SHCL_WIN_WM_URI_TRANSFER_STATUS,
    1203                                  0 /* wParm */, (LPARAM)pEvent /* lParm */);
    1204                    break;
    1205                }
    1206 #endif
    1207987               case VBGLR3CLIPBOARDEVENTTYPE_QUIT:
    1208988               {
    … …  
    1213993               }
    1214994
     995               case VBGLR3CLIPBOARDEVENTTYPE_URI_TRANSFER_STATUS:
     996               {
     997                   /* Nothing to do here. */
     998                   break;
     999               }
     1000
     1001               case VBGLR3CLIPBOARDEVENTTYPE_INVALID:
    12151002               default:
    12161003               {
    12171004                   /* Wait a bit before retrying. */
    12181005                   RTThreadSleep(1000);
     1006
     1007                   rc = VERR_NOT_SUPPORTED;
    12191008                   break;
    12201009               }
    12211010            }
    12221011
    1223             if (RT_FAILURE(rc))
     1012            if (pEvent)
     1013            {
    12241014                VbglR3ClipboardEventFree(pEvent);
     1015                pEvent = NULL;
     1016            }
    12251017        }
    12261018

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

    r80968 r80990  
    4848
    4949
     50/**
     51 * Function naming convention:
     52 *
     53 * FunctionNameRecv  = Receives a host message (request).
     54 * FunctionNameReply = Replies to a host message (request).
     55 * FunctionNameSend  = Sends a guest message to the host.
     56 */
     57
     58
    5059/*********************************************************************************************************************************
    5160*   Prototypes                                                                                                                   *
    … …  
    11771186}
    11781187
    1179 VBGLR3DECL(int) VbglR3ClipboardObjRead(PVBGLR3SHCLCMDCTX pCtx, SHCLOBJHANDLE hObj,
    1180                                        void *pvData, uint32_t cbData, uint32_t *pcbRead)
     1188VBGLR3DECL(int) VbglR3ClipboardObjReadSend(PVBGLR3SHCLCMDCTX pCtx, SHCLOBJHANDLE hObj,
     1189                                           void *pvData, uint32_t cbData, uint32_t *pcbRead)
    11811190{
    11821191    AssertPtrReturn(pCtx,   VERR_INVALID_POINTER);
    … …  
    12141223}
    12151224
    1216 VBGLR3DECL(int) VbglR3ClipboardObjWrite(PVBGLR3SHCLCMDCTX pCtx, SHCLOBJHANDLE hObj,
    1217                                         void *pvData, uint32_t cbData, uint32_t *pcbWritten)
     1225VBGLR3DECL(int) VbglR3ClipboardObjWriteSend(PVBGLR3SHCLCMDCTX pCtx, SHCLOBJHANDLE hObj,
     1226                                            void *pvData, uint32_t cbData, uint32_t *pcbWritten)
    12181227{
    12191228    AssertPtrReturn(pCtx,   VERR_INVALID_POINTER);
    … …  
    12431252            *pcbWritten = cbData; /** @todo For now return all as being written. */
    12441253    }
     1254
     1255    LogFlowFuncLeaveRC(rc);
     1256    return rc;
     1257}
     1258
     1259/*********************************************************************************************************************************
     1260*   Transfer interface implementations                                                                                           *
     1261*********************************************************************************************************************************/
     1262
     1263static int vbglR3ClipboardTransferIfaceGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList)
     1264{
     1265    LogFlowFuncEnter();
     1266
     1267    PVBGLR3SHCLCMDCTX pCmdCtx = (PVBGLR3SHCLCMDCTX)pCtx->pvUser;
     1268    AssertPtr(pCmdCtx);
     1269
     1270    int rc = VbglR3ClipboardRootListRead(pCmdCtx, ppRootList);
     1271
     1272    LogFlowFuncLeaveRC(rc);
     1273    return rc;
     1274}
     1275
     1276static int vbglR3ClipboardTransferIfaceListOpen(PSHCLPROVIDERCTX pCtx, PSHCLLISTOPENPARMS pOpenParms,
     1277                                                PSHCLLISTHANDLE phList)
     1278{
     1279    LogFlowFuncEnter();
     1280
     1281    PVBGLR3SHCLCMDCTX pCmdCtx = (PVBGLR3SHCLCMDCTX)pCtx->pvUser;
     1282    AssertPtr(pCmdCtx);
     1283
     1284    int rc = VbglR3ClipboardListOpenSend(pCmdCtx, pOpenParms, phList);
     1285
     1286    LogFlowFuncLeaveRC(rc);
     1287    return rc;
     1288}
     1289
     1290static int vbglR3ClipboardTransferIfaceListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList)
     1291{
     1292    LogFlowFuncEnter();
     1293
     1294    PVBGLR3SHCLCMDCTX pCmdCtx = (PVBGLR3SHCLCMDCTX)pCtx->pvUser;
     1295    AssertPtr(pCmdCtx);
     1296
     1297    int rc = VbglR3ClipboardListCloseSend(pCmdCtx, hList);
     1298
     1299    LogFlowFuncLeaveRC(rc);
     1300    return rc;
     1301}
     1302
     1303static int vbglR3ClipboardTransferIfaceListHdrRead(PSHCLPROVIDERCTX pCtx,
     1304                                                   SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr)
     1305{
     1306    LogFlowFuncEnter();
     1307
     1308    PVBGLR3SHCLCMDCTX pCmdCtx = (PVBGLR3SHCLCMDCTX)pCtx->pvUser;
     1309    AssertPtr(pCmdCtx);
     1310
     1311    int rc = SharedClipboardTransferListHdrInit(pListHdr);
     1312    if (RT_SUCCESS(rc))
     1313    {
     1314        if (RT_SUCCESS(rc))
     1315        {
     1316            rc = VbglR3ClipboardListHdrRead(pCmdCtx, hList, 0 /* fFlags */, pListHdr);
     1317        }
     1318        else
     1319            SharedClipboardTransferListHdrDestroy(pListHdr);
     1320    }
     1321
     1322    LogFlowFuncLeaveRC(rc);
     1323    return rc;
     1324}
     1325
     1326static int vbglR3ClipboardTransferIfaceListEntryRead(PSHCLPROVIDERCTX pCtx,
     1327                                                     SHCLLISTHANDLE hList, PSHCLLISTENTRY pEntry)
     1328{
     1329    LogFlowFuncEnter();
     1330
     1331    PVBGLR3SHCLCMDCTX pCmdCtx = (PVBGLR3SHCLCMDCTX)pCtx->pvUser;
     1332    AssertPtr(pCmdCtx);
     1333
     1334    int rc = VbglR3ClipboardListEntryRead(pCmdCtx, hList, pEntry);
     1335
     1336    LogFlowFuncLeaveRC(rc);
     1337    return rc;
     1338}
     1339
     1340static int vbglR3ClipboardTransferIfaceObjOpen(PSHCLPROVIDERCTX pCtx,
     1341                                               PSHCLOBJOPENCREATEPARMS pCreateParms, PSHCLOBJHANDLE phObj)
     1342{
     1343    LogFlowFuncEnter();
     1344
     1345    PVBGLR3SHCLCMDCTX pCmdCtx = (PVBGLR3SHCLCMDCTX)pCtx->pvUser;
     1346    AssertPtr(pCmdCtx);
     1347
     1348    int rc = VbglR3ClipboardObjOpenSend(pCmdCtx, pCreateParms, phObj);
     1349
     1350    LogFlowFuncLeaveRC(rc);
     1351    return rc;
     1352}
     1353
     1354static int vbglR3ClipboardTransferIfaceObjClose(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj)
     1355{
     1356    LogFlowFuncEnter();
     1357
     1358    PVBGLR3SHCLCMDCTX pCmdCtx = (PVBGLR3SHCLCMDCTX)pCtx->pvUser;
     1359    AssertPtr(pCmdCtx);
     1360
     1361    int rc = VbglR3ClipboardObjCloseSend(pCmdCtx, hObj);
     1362
     1363    LogFlowFuncLeaveRC(rc);
     1364    return rc;
     1365}
     1366
     1367static int vbglR3ClipboardTransferIfaceObjRead(PSHCLPROVIDERCTX pCtx,
     1368                                               SHCLOBJHANDLE hObj, void *pvData, uint32_t cbData,
     1369                                               uint32_t fFlags, uint32_t *pcbRead)
     1370{
     1371    LogFlowFuncEnter();
     1372
     1373    PVBGLR3SHCLCMDCTX pCmdCtx = (PVBGLR3SHCLCMDCTX)pCtx->pvUser;
     1374    AssertPtr(pCmdCtx);
     1375
     1376    RT_NOREF(fFlags); /* Not used yet. */
     1377
     1378    int rc = VbglR3ClipboardObjReadSend(pCmdCtx, hObj, pvData, cbData, pcbRead);
    12451379
    12461380    LogFlowFuncLeaveRC(rc);
    … …  
    12751409            if (RT_SUCCESS(rc))
    12761410            {
    1277                 rc = SharedClipboardTransferStart(pTransfer);
     1411                /* If this is a read transfer (reading data from host), set the interface to use
     1412                 * our VbglR3 routines here. */
     1413                if (enmDir == SHCLTRANSFERDIR_READ)
     1414                {
     1415                    SHCLPROVIDERCREATIONCTX creationCtx;
     1416                    RT_ZERO(creationCtx);
     1417
     1418                    creationCtx.Interface.pfnRootsGet      = vbglR3ClipboardTransferIfaceGetRoots;
     1419
     1420                    creationCtx.Interface.pfnListOpen      = vbglR3ClipboardTransferIfaceListOpen;
     1421                    creationCtx.Interface.pfnListClose     = vbglR3ClipboardTransferIfaceListClose;
     1422                    creationCtx.Interface.pfnListHdrRead   = vbglR3ClipboardTransferIfaceListHdrRead;
     1423                    creationCtx.Interface.pfnListEntryRead = vbglR3ClipboardTransferIfaceListEntryRead;
     1424
     1425                    creationCtx.Interface.pfnObjOpen       = vbglR3ClipboardTransferIfaceObjOpen;
     1426                    creationCtx.Interface.pfnObjClose      = vbglR3ClipboardTransferIfaceObjClose;
     1427                    creationCtx.Interface.pfnObjRead       = vbglR3ClipboardTransferIfaceObjRead;
     1428
     1429                    rc = SharedClipboardTransferSetInterface(pTransfer, &creationCtx);
     1430                }
     1431
     1432                if (RT_SUCCESS(rc))
     1433                    rc = SharedClipboardTransferStart(pTransfer);
    12781434            }
    1279             else
     1435
     1436            if (RT_FAILURE(rc))
    12801437                SharedClipboardTransferCtxTransferUnregister(pTransferCtx, uTransferID);
    12811438        }
    … …  
    13001457                                                 ? SHCLTRANSFERSTATUS_STARTED : SHCLTRANSFERSTATUS_ERROR, rc);
    13011458    AssertRC(rc2);
     1459
     1460    if (RT_FAILURE(rc))
     1461    {
     1462        SharedClipboardTransferDestroy(pTransfer);
     1463        pTransfer = NULL;
     1464    }
    13021465
    13031466    LogFlowFuncLeaveRC(rc);
    … …  
    14241587                    pEvent->enmType = VBGLR3CLIPBOARDEVENTTYPE_URI_TRANSFER_STATUS;
    14251588
    1426                     LogRel2(("Shared Clipboard: Received status %RU32 (%Rrc) for transfer ID=%RU16\n",
    1427                              pEvent->u.TransferStatus.Report.uStatus, pEvent->u.TransferStatus.Report.rc,
     1589                    LogRel2(("Shared Clipboard: Received status %s (rc=%Rrc) for transfer ID=%RU16\n",
     1590                             VBoxShClTransferStatusToStr(pEvent->u.TransferStatus.Report.uStatus), pEvent->u.TransferStatus.Report.rc,
    14281591                             pEvent->u.TransferStatus.uID));
    14291592                }
    … …  
    15501713            break;
    15511714        }
    1552 
    1553     #if 0
    1554         case VBOX_SHCL_HOST_MSG_TRANSFER_LIST_HDR_WRITE:
    1555         {
    1556             LogFlowFunc(("VBOX_SHCL_HOST_MSG_TRANSFER_LIST_HDR_WRITE\n"));
    1557 
    1558             SHCLLISTHDR hdrList;
    1559             rc = SharedClipboardTransferListHdrInit(&hdrList);
    1560             if (RT_SUCCESS(rc))
    1561             {
    1562                 rc = VBglR3ClipboardListHdrRecv(pCtx, )
    1563             }
    1564             break;
    1565         }
    1566     #endif
    15671715
    15681716        case VBOX_SHCL_HOST_MSG_TRANSFER_LIST_ENTRY_READ:
    … …  
    16031751        }
    16041752
    1605     #if 0
    1606         case VBOX_SHCL_HOST_MSG_TRANSFER_LIST_ENTRY_WRITE:
    1607         {
    1608             LogFlowFunc(("VBOX_SHCL_HOST_MSG_TRANSFER_LIST_ENTRY_WRITE\n"));
    1609             pEvent->enmType = VBGLR3CLIPBOARDEVENTTYPE_URI_LIST_ENTRY_WRITE;
    1610             break;
    1611         }
    1612     #endif
    1613 
    16141753        case VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_OPEN:
    16151754        {
    … …  
    16841823                    rc = SharedClipboardTransferObjectRead(pTransfer, hObj, pvBuf, cbToRead, &cbRead, fFlags);
    16851824                    if (RT_SUCCESS(rc))
    1686                         rc = VbglR3ClipboardObjWrite(pCmdCtx, hObj, pvBuf, cbRead, NULL /* pcbWritten */);
     1825                        rc = VbglR3ClipboardObjWriteSend(pCmdCtx, hObj, pvBuf, cbRead, NULL /* pcbWritten */);
    16871826
    16881827                    RTMemFree(pvBuf);
    … …  
    16951834        }
    16961835
    1697     #if 0
    1698         case VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_WRITE:
    1699         {
    1700             LogFlowFunc(("VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_WRITE\n"));
    1701             break;
    1702         }
    1703     #endif
    1704 
    17051836        default:
    17061837        {
    … …  
    17921923}
    17931924
    1794 #if 0
    1795 VBGLR3DECL(int) VbglR3ClipboardListHdrReadRecv(HGCMCLIENTID idClient, PSHCLLISTHANDLE phList)
    1796 {
    1797     AssertPtrReturn(phList, VERR_INVALID_POINTER);
    1798 
    1799     VBoxShClListHdrReadMsg Msg;
    1800     RT_ZERO(Msg);
    1801 
    1802     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
    1803                        VBOX_SHCL_GUEST_FN_LIST_HDR_READ, VBOX_SHCL_CPARMS_LIST_HDR_READ);
    1804 
    1805     Msg.uContext.SetUInt32(0); /** @todo Not used yet. */
    1806     Msg.uHandle.SetUInt64(0);
    1807 
    1808     int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
    1809     if (RT_SUCCESS(rc))
    1810     {
    1811         Msg.uHandle.GetUInt32(phList);
    1812     }
    1813 
    1814     LogFlowFuncLeaveRC(rc);
    1815     return rc;
    1816 }
    1817 
    18181925/**
    1819  * Sends a list header to the host.
     1926 * Reports (advertises) guest clipboard formats to the host.
    18201927 *
    18211928 * @returns VBox status code.
    1822  * @param   idClient        The client id returned by VbglR3ClipboardConnect().
    1823  * @param   hList           List handle to send header for.
    1824  * @param   pListHdr        List header to send.
     1929 * @param   pCtx                The command context returned by VbglR3ClipboardConnectEx().
     1930 * @param   pFormats            The formats to report.
    18251931 */
    1826 VBGLR3DECL(int) VbglR3ClipboardListHdrSend(HGCMCLIENTID idClient,
    1827                                            SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr)
    1828 {
    1829     AssertPtrReturn(pListHdr, VERR_INVALID_POINTER);
    1830 
    1831     VBoxShClListHdrMsg Msg;
    1832     RT_ZERO(Msg);
    1833 
    1834     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
    1835                        VBOX_SHCL_GUEST_FN_LIST_HDR_WRITE, VBOX_SHCL_CPARMS_LIST_HDR);
    1836 
    1837     Msg.uContext.SetUInt32(0); /** @todo Not used yet. */
    1838     Msg.fFeatures.SetUInt32(pListHdr->fFeatures);
    1839     Msg.cTotalObjects.SetUInt64(pListHdr->cTotalObjects);
    1840     Msg.cbTotalSize.SetUInt64(pListHdr->cbTotalSize);
    1841     Msg.enmCompression.SetUInt32(pListHdr->enmCompression);
    1842     Msg.enmChecksumType.SetUInt32(RTDIGESTTYPE_INVALID);
    1843 
    1844     int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
    1845 
    1846     LogFlowFuncLeaveRC(rc);
    1847     return rc;
    1848 }
    1849 
    1850 /**
    1851  * Sends a list entry to the host.
    1852  *
    1853  * @returns IPRT status code.
    1854  * @param   idClient            The client id returned by VbglR3ClipboardConnect()
    1855  * @param   hList               List handle to send entry for.
    1856  * @param   pListEntry          List entry to send.
    1857  */
    1858 VBGLR3DECL(int) VbglR3ClipboardSendListEntryWrite(HGCMCLIENTID idClient,
    1859                                                   SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry)
    1860 {
    1861     AssertPtrReturn(pListEntry, VERR_INVALID_POINTER);
    1862 
    1863     VBoxShClListEntryWriteMsg Msg;
    1864     RT_ZERO(Msg);
    1865 
    1866     VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient,
    1867                        VBOX_SHCL_GUEST_FN_LIST_ENTRY_WRITE, VBOX_SHCL_CPARMS_LIST_ENTRY_WRITE);
    1868 
    1869     Msg.uContext.SetUInt32(0); /** @todo Not used yet. */
    1870     Msg.uHandle.SetUInt64(hList);
    1871     Msg.fInfo.SetUInt32(pListEntry->fInfo);
    1872     Msg.cbInfo.SetUInt32(pListEntry->cbInfo);
    1873     Msg.pvInfo.SetPtr(pListEntry->pvInfo, pListEntry->cbInfo);
    1874 
    1875     int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
    1876 
    1877     LogFlowFuncLeaveRC(rc);
    1878     return rc;
    1879 }
    1880 #endif
    1881 
    1882 /**
    1883  * Sends (reports) guest clipboard formats to the host.
    1884  *
    1885  * @returns VBox status code.
    1886  * @param   pCtx                The command context returned by VbglR3ClipboardConnect().
    1887  * @param   pFormats            The formats to send (report).
    1888  */
    1889 VBGLR3DECL(int) VbglR3ClipboardFormatsSend(PVBGLR3SHCLCMDCTX pCtx, PSHCLFORMATDATA pFormats)
    1890 {
     1932VBGLR3DECL(int) VbglR3ClipboardFormatsReportEx(PVBGLR3SHCLCMDCTX pCtx, PSHCLFORMATDATA pFormats)
     1933{
     1934    AssertPtrReturn(pCtx,     VERR_INVALID_POINTER);
     1935    AssertPtrReturn(pFormats, VERR_INVALID_POINTER);
     1936
    18911937    VBoxShClFormatsMsg Msg;
    18921938
    18931939    int rc;
     1940
     1941    LogFlowFunc(("uFormats=0x%x\n", pFormats->uFormats));
    18941942
    18951943    if (pCtx->uProtocolVer == 0)
    … …  
    19221970 * @returns VBox status code.
    19231971 * @param   idClient        The client id returned by VbglR3ClipboardConnect().
    1924  * @param   fFormats        The formats to advertise.
     1972 * @param   fFormats        The formats to report.
    19251973 */
    1926 VBGLR3DECL(int) VbglR3ClipboardReportFormats(HGCMCLIENTID idClient, uint32_t fFormats)
    1927 {
     1974VBGLR3DECL(int) VbglR3ClipboardFormatsReport(HGCMCLIENTID idClient, uint32_t fFormats)
     1975{
     1976    AssertReturn(idClient, VERR_INVALID_PARAMETER);
     1977    AssertReturn(fFormats, VERR_INVALID_PARAMETER);
     1978
    19281979    VBoxShClFormatsMsg Msg;
    19291980
    … …  
    19481999VBGLR3DECL(int) VbglR3ClipboardWriteData(HGCMCLIENTID idClient, uint32_t fFormat, void *pv, uint32_t cb)
    19492000{
     2001    AssertReturn   (idClient, VERR_INVALID_PARAMETER);
     2002    AssertPtrReturn(pv,       VERR_INVALID_POINTER);
     2003    AssertReturn   (cb,       VERR_INVALID_PARAMETER);
     2004
    19502005    VBoxShClWriteDataMsg Msg;
    19512006    RT_ZERO(Msg);
    … …  
    19702025 *
    19712026 * @returns VBox status code.
    1972  * @param   pCtx                The command context returned by VbglR3ClipboardConnect().
     2027 * @param   pCtx                The command context returned by VbglR3ClipboardConnectEx().
    19732028 * @param   pData               Clipboard data to send.
    19742029 */
    19752030VBGLR3DECL(int) VbglR3ClipboardWriteDataEx(PVBGLR3SHCLCMDCTX pCtx, PSHCLDATABLOCK pData)
    19762031{
     2032    AssertPtrReturn(pCtx,  VERR_INVALID_POINTER);
     2033    AssertPtrReturn(pData, VERR_INVALID_POINTER);
     2034
    19772035    int rc;
    19782036
    … …  
    20122070VBGLR3DECL(int) VbglR3ClipboardWriteError(HGCMCLIENTID idClient, int rcErr)
    20132071{
     2072    AssertReturn(idClient, VERR_INVALID_PARAMETER);
     2073
    20142074    VBoxShClWriteErrorMsg Msg;
    20152075    RT_ZERO(Msg);

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

    r80847 r80990  
    611611    }
    612612    VGSvcVerbose(4, "clipboard: reporting fFormats=%#x\n", fFormats);
    613     VbglR3ClipboardReportFormats(g_u32ClientId, fFormats);
     613    VbglR3ClipboardFormatsReport(g_u32ClientId, fFormats);
    614614}
    615615
    … …  
    658658                g_fEmptyClipboard = true;
    659659                VGSvcVerbose(3, "Reporting empty clipboard\n");
    660                 VbglR3ClipboardReportFormats(g_u32ClientId, 0);
     660                VbglR3ClipboardFormatsReport(g_u32ClientId, 0);
    661661            }
    662662        }
    … …  
    681681    g_fEmptyClipboard = true;
    682682    VGSvcVerbose(3, "Reporting empty clipboard\n");
    683     VbglR3ClipboardReportFormats(g_u32ClientId, 0);
     683    VbglR3ClipboardFormatsReport(g_u32ClientId, 0);
    684684
    685685    vgsvcClipboardOs2PollViewer();

  • trunk/src/VBox/Additions/darwin/VBoxClient/VBoxClientClipboard.cpp

    r80847 r80990  
    177177        {
    178178            fFormats = vbclClipboardGetAvailableFormats(g_PasteboardRef);
    179             rc = VbglR3ClipboardReportFormats(g_u32ClientId, fFormats);
     179            rc = VbglR3ClipboardFormatsReport(g_u32ClientId, fFormats);
    180180            if (RT_FAILURE(rc))
    181181            {
    … …  
    287287    AssertReturn(g_u32ClientId != 0, VERR_GENERAL_FAILURE);
    288288
    289     VbglR3ClipboardReportFormats(g_u32ClientId, 0);
     289    VbglR3ClipboardFormatsReport(g_u32ClientId, 0);
    290290
    291291    rc = VbglR3ClipboardDisconnect(g_u32ClientId);

  • trunk/src/VBox/Additions/haiku/VBoxTray/VBoxClipboard.cpp

    r80847 r80990  
    345345            be_clipboard->Unlock();
    346346
    347             VbglR3ClipboardReportFormats(fClientId, formats);
     347            VbglR3ClipboardFormatsReport(fClientId, formats);
    348348            break;
    349349        }

  • trunk/src/VBox/Additions/x11/VBoxClient/clipboard.cpp

    r80847 r80990  
    152152    RT_NOREF1(pCtx);
    153153    LogRelFlowFunc(("u32Formats=%d\n", u32Formats));
    154     int rc = VbglR3ClipboardReportFormats(g_ctx.client, u32Formats);
     154    int rc = VbglR3ClipboardFormatsReport(g_ctx.client, u32Formats);
    155155    LogRelFlowFunc(("rc=%Rrc\n", rc));
    156156}

  • trunk/src/VBox/GuestHost/SharedClipboard/clipboard-common.cpp

    r80907 r80990  
    815815}
    816816#endif /* LOG_ENABLED */
     817
     818/**
     819 * Translates a Shared Clipboard host function number to a string.
     820 *
     821 * @returns Function ID string name.
     822 * @param   uFn                 The function to translate.
     823 */
     824const char *VBoxShClHostFunctionToStr(uint32_t uFn)
     825{
     826    switch (uFn)
     827    {
     828        RT_CASE_RET_STR(VBOX_SHCL_HOST_FN_SET_MODE);
     829        RT_CASE_RET_STR(VBOX_SHCL_HOST_FN_SET_HEADLESS);
     830        RT_CASE_RET_STR(VBOX_SHCL_HOST_FN_CANCEL);
     831        RT_CASE_RET_STR(VBOX_SHCL_HOST_FN_ERROR);
     832        RT_CASE_RET_STR(VBOX_SHCL_HOST_FN_AREA_REGISTER);
     833        RT_CASE_RET_STR(VBOX_SHCL_HOST_FN_AREA_UNREGISTER);
     834        RT_CASE_RET_STR(VBOX_SHCL_HOST_FN_AREA_ATTACH);
     835        RT_CASE_RET_STR(VBOX_SHCL_HOST_FN_AREA_DETACH);
     836    }
     837    return "Unknown";
     838}
    817839
    818840/**
    … …  
    889911    return "Unknown";
    890912}
    891 

  • trunk/src/VBox/GuestHost/SharedClipboard/clipboard-transfers.cpp

    r80918 r80990  
    10641064    pTransfer->State.enmDir    = SHCLTRANSFERDIR_UNKNOWN;
    10651065    pTransfer->State.enmSource = SHCLSOURCE_INVALID;
    1066 
    1067     LogFlowFunc(("enmDir=%RU32, enmSource=%RU32\n", pTransfer->State.enmDir, pTransfer->State.enmSource));
    10681066
    10691067    pTransfer->pArea = NULL; /* Will be created later if needed. */

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

    r80866 r80990  
    223223
    224224#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    225 int sharedClipboardSvcTransferOpen(PSHCLPROVIDERCTX pCtx);
    226 DECLCALLBACK(int) sharedClipboardSvcTransferClose(PSHCLPROVIDERCTX pCtx);
    227 
    228 int sharedClipboardSvcTransferGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList);
    229 
    230 int sharedClipboardSvcTransferListOpen(PSHCLPROVIDERCTX pCtx, PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList);
    231 int sharedClipboardSvcTransferListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList);
    232 int sharedClipboardSvcTransferListHdrRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr);
    233 int sharedClipboardSvcTransferListHdrWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr);
    234 int sharedClipboardSvcTransferListEntryRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry);
    235 int sharedClipboardSvcTransferListEntryWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry);
    236 
    237 int sharedClipboardSvcTransferObjOpen(PSHCLPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms,
    238                                  PSHCLOBJHANDLE phObj);
    239 int sharedClipboardSvcTransferObjClose(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj);
    240 int sharedClipboardSvcTransferObjRead(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
    241                                  void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead);
    242 int sharedClipboardSvcTransferObjWrite(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
    243                                   void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten);
     225int sharedClipboardSvcTransferIfaceOpen(PSHCLPROVIDERCTX pCtx);
     226int sharedClipboardSvcTransferIfaceClose(PSHCLPROVIDERCTX pCtx);
     227
     228int sharedClipboardSvcTransferIfaceGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList);
     229
     230int sharedClipboardSvcTransferIfaceListOpen(PSHCLPROVIDERCTX pCtx, PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList);
     231int sharedClipboardSvcTransferIfaceListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList);
     232int sharedClipboardSvcTransferIfaceListHdrRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr);
     233int sharedClipboardSvcTransferIfaceListHdrWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr);
     234int sharedClipboardSvcTransferIfaceListEntryRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry);
     235int sharedClipboardSvcTransferIfaceListEntryWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry);
     236
     237int sharedClipboardSvcTransferIfaceObjOpen(PSHCLPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms,
     238                                           PSHCLOBJHANDLE phObj);
     239int sharedClipboardSvcTransferIfaceObjClose(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj);
     240int sharedClipboardSvcTransferIfaceObjRead(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
     241                                           void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead);
     242int sharedClipboardSvcTransferIfaceObjWrite(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
     243                                            void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten);
    244244
    245245DECLCALLBACK(void) VBoxSvcClipboardTransferPrepareCallback(PSHCLTRANSFERCALLBACKDATA pData);

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

    r80918 r80990  
    5858*********************************************************************************************************************************/
    5959
    60 DECLCALLBACK(int) sharedClipboardSvcTransferOpen(PSHCLPROVIDERCTX pCtx)
     60DECLCALLBACK(int) sharedClipboardSvcTransferIfaceOpen(PSHCLPROVIDERCTX pCtx)
    6161{
    6262    RT_NOREF(pCtx);
    … …  
    6666}
    6767
    68 DECLCALLBACK(int) sharedClipboardSvcTransferClose(PSHCLPROVIDERCTX pCtx)
     68DECLCALLBACK(int) sharedClipboardSvcTransferIfaceClose(PSHCLPROVIDERCTX pCtx)
    6969{
    7070    RT_NOREF(pCtx);
    … …  
    7474}
    7575
    76 DECLCALLBACK(int) sharedClipboardSvcTransferGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList)
     76DECLCALLBACK(int) sharedClipboardSvcTransferIfaceGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList)
    7777{
    7878    LogFlowFuncEnter();
    … …  
    192192}
    193193
    194 DECLCALLBACK(int) sharedClipboardSvcTransferListOpen(PSHCLPROVIDERCTX pCtx,
    195                                                      PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList)
     194DECLCALLBACK(int) sharedClipboardSvcTransferIfaceListOpen(PSHCLPROVIDERCTX pCtx,
     195                                                          PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList)
    196196{
    197197    LogFlowFuncEnter();
    … …  
    251251}
    252252
    253 DECLCALLBACK(int) sharedClipboardSvcTransferListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList)
     253DECLCALLBACK(int) sharedClipboardSvcTransferIfaceListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList)
    254254{
    255255    LogFlowFuncEnter();
    … …  
    298298}
    299299
    300 DECLCALLBACK(int) sharedClipboardSvcTransferListHdrRead(PSHCLPROVIDERCTX pCtx,
    301                                                         SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr)
     300DECLCALLBACK(int) sharedClipboardSvcTransferIfaceListHdrRead(PSHCLPROVIDERCTX pCtx,
     301                                                             SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr)
    302302{
    303303    LogFlowFuncEnter();
    … …  
    315315
    316316        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
    317                                                                               pCtx->pTransfer->State.uID, uEvent));
     317                                                                  pCtx->pTransfer->State.uID, uEvent));
    318318        HGCMSvcSetU64(&pMsg->paParms[1], hList);
    319319        HGCMSvcSetU32(&pMsg->paParms[2], 0 /* fFlags */);
    … …  
    349349}
    350350
    351 DECLCALLBACK(int) sharedClipboardSvcTransferListHdrWrite(PSHCLPROVIDERCTX pCtx,
    352                                                          SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr)
     351DECLCALLBACK(int) sharedClipboardSvcTransferIfaceListHdrWrite(PSHCLPROVIDERCTX pCtx,
     352                                                              SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr)
    353353{
    354354    RT_NOREF(pCtx, hList, pListHdr);
    … …  
    359359}
    360360
    361 DECLCALLBACK(int) sharedClipboardSvcTransferListEntryRead(PSHCLPROVIDERCTX pCtx,
    362                                                           SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry)
     361DECLCALLBACK(int) sharedClipboardSvcTransferIfaceListEntryRead(PSHCLPROVIDERCTX pCtx,
     362                                                               SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry)
    363363{
    364364    LogFlowFuncEnter();
    … …  
    409409}
    410410
    411 DECLCALLBACK(int) sharedClipboardSvcTransferListEntryWrite(PSHCLPROVIDERCTX pCtx,
    412                                                            SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry)
     411DECLCALLBACK(int) sharedClipboardSvcTransferIfaceListEntryWrite(PSHCLPROVIDERCTX pCtx,
     412                                                                SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry)
    413413{
    414414    RT_NOREF(pCtx, hList, pListEntry);
    … …  
    419419}
    420420
    421 int sharedClipboardSvcTransferObjOpen(PSHCLPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms,
    422                                       PSHCLOBJHANDLE phObj)
     421int sharedClipboardSvcTransferIfaceObjOpen(PSHCLPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms,
     422                                           PSHCLOBJHANDLE phObj)
    423423{
    424424    LogFlowFuncEnter();
    … …  
    440440
    441441        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
    442                                                                               pCtx->pTransfer->State.uID, uEvent));
     442                                                                  pCtx->pTransfer->State.uID, uEvent));
    443443        HGCMSvcSetU64(&pMsg->paParms[1], 0); /* uHandle */
    444444        HGCMSvcSetU32(&pMsg->paParms[2], cbPath);
    … …  
    480480}
    481481
    482 int sharedClipboardSvcTransferObjClose(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj)
     482int sharedClipboardSvcTransferIfaceObjClose(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj)
    483483{
    484484    LogFlowFuncEnter();
    … …  
    496496
    497497        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
    498                                                                               pCtx->pTransfer->State.uID, uEvent));
     498                                                                  pCtx->pTransfer->State.uID, uEvent));
    499499        HGCMSvcSetU64(&pMsg->paParms[1], hObj);
    500500
    … …  
    533533}
    534534
    535 int sharedClipboardSvcTransferObjRead(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
    536                                       void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead)
     535int sharedClipboardSvcTransferIfaceObjRead(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
     536                                           void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead)
    537537{
    538538    LogFlowFuncEnter();
    … …  
    550550
    551551        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
    552                                                                               pCtx->pTransfer->State.uID, uEvent));
     552                                                                  pCtx->pTransfer->State.uID, uEvent));
    553553        HGCMSvcSetU64(&pMsg->paParms[1], hObj);
    554554        HGCMSvcSetU32(&pMsg->paParms[2], cbData);
    … …  
    592592}
    593593
    594 int sharedClipboardSvcTransferObjWrite(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
    595                                        void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten)
     594int sharedClipboardSvcTransferIfaceObjWrite(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
     595                                            void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten)
    596596{
    597597    LogFlowFuncEnter();
    … …  
    609609
    610610        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
    611                                                                               pCtx->pTransfer->State.uID, uEvent));
     611                                                                  pCtx->pTransfer->State.uID, uEvent));
    612612        HGCMSvcSetU64(&pMsg->paParms[1], hObj);
    613613        HGCMSvcSetU64(&pMsg->paParms[2], cbData);
    … …  
    21302130                if (RT_SUCCESS(rc))
    21312131                {
    2132                     creationCtx.Interface.pfnTransferOpen    = sharedClipboardSvcTransferOpen;
    2133                     creationCtx.Interface.pfnTransferClose   = sharedClipboardSvcTransferClose;
    2134                     creationCtx.Interface.pfnListOpen        = sharedClipboardSvcTransferListOpen;
    2135                     creationCtx.Interface.pfnListClose       = sharedClipboardSvcTransferListClose;
    2136                     creationCtx.Interface.pfnObjOpen         = sharedClipboardSvcTransferObjOpen;
    2137                     creationCtx.Interface.pfnObjClose        = sharedClipboardSvcTransferObjClose;
    2138 
    2139                     creationCtx.Interface.pfnRootsGet        = sharedClipboardSvcTransferGetRoots;
    2140                     creationCtx.Interface.pfnListHdrRead     = sharedClipboardSvcTransferListHdrRead;
    2141                     creationCtx.Interface.pfnListEntryRead   = sharedClipboardSvcTransferListEntryRead;
    2142                     creationCtx.Interface.pfnObjRead         = sharedClipboardSvcTransferObjRead;
     2132                    creationCtx.Interface.pfnTransferOpen  = sharedClipboardSvcTransferIfaceOpen;
     2133                    creationCtx.Interface.pfnTransferClose = sharedClipboardSvcTransferIfaceClose;
     2134
     2135                    creationCtx.Interface.pfnRootsGet      = sharedClipboardSvcTransferIfaceGetRoots;
     2136
     2137                    creationCtx.Interface.pfnListOpen      = sharedClipboardSvcTransferIfaceListOpen;
     2138                    creationCtx.Interface.pfnListClose     = sharedClipboardSvcTransferIfaceListClose;
     2139                    creationCtx.Interface.pfnListHdrRead   = sharedClipboardSvcTransferIfaceListHdrRead;
     2140                    creationCtx.Interface.pfnListEntryRead = sharedClipboardSvcTransferIfaceListEntryRead;
     2141
     2142                    creationCtx.Interface.pfnObjOpen       = sharedClipboardSvcTransferIfaceObjOpen;
     2143                    creationCtx.Interface.pfnObjClose      = sharedClipboardSvcTransferIfaceObjClose;
     2144                    creationCtx.Interface.pfnObjRead       = sharedClipboardSvcTransferIfaceObjRead;
    21432145                }
    21442146            }
    21452147            else if (enmDir == SHCLTRANSFERDIR_WRITE)
    21462148            {
    2147                 creationCtx.Interface.pfnListHdrWrite   = sharedClipboardSvcTransferListHdrWrite;
    2148                 creationCtx.Interface.pfnListEntryWrite = sharedClipboardSvcTransferListEntryWrite;
    2149                 creationCtx.Interface.pfnObjWrite       = sharedClipboardSvcTransferObjWrite;
     2149                creationCtx.Interface.pfnListHdrWrite   = sharedClipboardSvcTransferIfaceListHdrWrite;
     2150                creationCtx.Interface.pfnListEntryWrite = sharedClipboardSvcTransferIfaceListEntryWrite;
     2151                creationCtx.Interface.pfnObjWrite       = sharedClipboardSvcTransferIfaceObjWrite;
    21502152            }
    21512153            else

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

    r80866 r80990  
    213213        case WM_CLIPBOARDUPDATE:
    214214        {
    215             LogFunc(("WM_CLIPBOARDUPDATE: Waiting ...\n"));
     215            LogFunc(("WM_CLIPBOARDUPDATE\n"));
    216216
    217217            int rc = RTCritSectEnter(&pWinCtx->CritSect);
    … …  
    257257            LogFunc(("WM_DRAWCLIPBOARD\n"));
    258258
    259             if (GetClipboardOwner() != hWnd)
    260             {
    261                 /* Clipboard was updated by another application, retrieve formats and report back. */
    262                 int rc = vboxClipboardSvcWinSyncInternal(pCtx);
    263                 if (RT_SUCCESS(rc))
    264                     sharedClipboardSvcSetSource(pCtx->pClient, SHCLSOURCE_LOCAL);
     259            int rc = RTCritSectEnter(&pWinCtx->CritSect);
     260            if (RT_SUCCESS(rc))
     261            {
     262                const HWND hWndClipboardOwner = GetClipboardOwner();
     263
     264                LogFunc(("WM_DRAWCLIPBOARD: hWndClipboardOwnerUs=%p, hWndNewClipboardOwner=%p\n",
     265                         pWinCtx->hWndClipboardOwnerUs, hWndClipboardOwner));
     266
     267                if (pWinCtx->hWndClipboardOwnerUs != hWndClipboardOwner)
     268                {
     269                    int rc2 = RTCritSectLeave(&pWinCtx->CritSect);
     270                    AssertRC(rc2);
     271
     272                    /* Clipboard was updated by another application, retrieve formats and report back. */
     273                    rc = vboxClipboardSvcWinSyncInternal(pCtx);
     274                    if (RT_SUCCESS(rc))
     275                        sharedClipboardSvcSetSource(pCtx->pClient, SHCLSOURCE_LOCAL);
     276                }
     277                else
     278                {
     279                    int rc2 = RTCritSectLeave(&pWinCtx->CritSect);
     280                    AssertRC(rc2);
     281                }
    265282            }
    266283
    … …  
    389406    }
    390407
    391     LogFlowFunc(("hWnd=%p, WM_ %u\n", hWnd, uMsg));
     408    LogFlowFunc(("LEAVE hWnd=%p, WM_ %u\n", hWnd, uMsg));
    392409    return DefWindowProc(hWnd, uMsg, wParam, lParam);
    393410}

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

    r80858 r80990  
    5959/**
    6060 * Report formats available in the X11 clipboard to VBox.
    61  * @param  pCtx        Opaque context pointer for the glue code
    62  * @param  u32Formats  The formats available
    63  * @note  Host glue code
     61 * @param  pCtx                 Opaque context pointer for the glue code.
     62 * @param  u32Formats           The formats available.
    6463 */
    6564void ClipReportX11Formats(SHCLCONTEXT *pCtx, uint32_t u32Formats)
    6665{
    6766    LogFlowFunc(("pCtx=%p, u32Formats=%02X\n", pCtx, u32Formats));
     67
     68    if (u32Formats == VBOX_SHCL_FMT_NONE) /* No formats to report? Bail out early. */
     69        return;
    6870
    6971    SHCLFORMATDATA formatData;

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

    r80918 r80990  
    937937    if (pMsg)
    938938    {
    939         SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pClient->Events);
     939        const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pClient->Events);
    940940
    941941        HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
    … …  
    948948        {
    949949#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
     950            /* If this is an URI list, create a transfer locally and also tell the guest to create
     951             * a transfer on the guest side. */
    950952            if (pFormats->uFormats & VBOX_SHCL_FMT_URI_LIST)
    951953            {
    … …  
    955957                    LogRel(("Shared Clipboard: Initializing host write transfer failed with %Rrc\n", rc));
    956958            }
     959            else
     960            {
    957961#endif
    958             if (RT_SUCCESS(rc))
    959962                rc = sharedClipboardSvcClientWakeup(pClient);
     963
     964#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
     965            }
     966#endif
    960967        }
    961968    }
    … …  
    13221329                    rc = VERR_ACCESS_DENIED;
    13231330                }
    1324                 else
     1331                else if (uFormats != VBOX_SHCL_FMT_NONE) /* Only announce formats if we actually *have* formats to announce! */
    13251332                {
    13261333                    rc = sharedClipboardSvcSetSource(pClient, SHCLSOURCE_REMOTE);
    … …  
    13341341                            parms.uFormat = uFormats;
    13351342
    1336                             g_ExtState.pfnExtension(g_ExtState.pvExtension, VBOX_CLIPBOARD_EXT_FN_FORMAT_ANNOUNCE, &parms, sizeof(parms));
     1343                            g_ExtState.pfnExtension(g_ExtState.pvExtension, VBOX_CLIPBOARD_EXT_FN_FORMAT_ANNOUNCE,
     1344                                                    &parms, sizeof(parms));
    13371345                        }
    13381346
    … …  
    13441352
    13451353                        formatData.uFormats = uFormats;
     1354                        Assert(formatData.uFormats != VBOX_SHCL_FMT_NONE); /* Sanity. */
    13461355
    13471356                        rc = SharedClipboardSvcImplFormatAnnounce(pClient, &cmdCtx, &formatData);
    … …  
    14131422
    14141423                                formatData.uFormats = g_ExtState.uDelayedFormats;
     1424                                Assert(formatData.uFormats != VBOX_SHCL_FMT_NONE); /* There better is *any* format here now. */
    14151425
    14161426                                int rc2 = sharedClipboardSvcFormatsReport(pClient, &formatData);
    … …  
    15441554
    15451555    LogFlowFunc(("u32Function=%RU32 (%s), cParms=%RU32, paParms=%p\n",
    1546                  u32Function, VBoxShClHostMsgToStr(u32Function), cParms, paParms));
     1556                 u32Function, VBoxShClHostFunctionToStr(u32Function), cParms, paParms));
    15471557
    15481558    switch (u32Function)
    … …  
    18261836                    g_ExtState.uDelayedFormats = u32Format;
    18271837                }
    1828                 else
     1838                else if (u32Format != VBOX_SHCL_FMT_NONE)
    18291839                {
    18301840                    SHCLFORMATDATA formatData;
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