VirtualBox

Changeset 81025 in vbox


Ignore:
Timestamp:
Sep 26, 2019 4:13:25 PM (5 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
133628
Message:

Shared Clipboard/Transfers: Update.

Location:
trunk
Files:
12 edited

Legend:

Unmodified
Added
Removed

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

    r80990 r81025  
    918918    /** Saved user pointer. */
    919919    void         *pvUser;
     920    /** Size (in bytes) of data at user pointer. */
     921    size_t        cbUser;
    920922} SHCLTRANSFERCALLBACKDATA, *PSHCLTRANSFERCALLBACKDATA;
    921923
    … …  
    948950typedef struct _SHCLTRANSFERCALLBACKS
    949951{
    950     /** Saved user pointer. Optional and can be NULL. */
    951     void *pvUser;
     952    /** User pointer to data. Optional and can be NULL. */
     953    void  *pvUser;
     954    /** Size (in bytes) of user data pointing at. Optional and can be 0. */
     955    size_t cbUser;
    952956    /** Function pointer, called after the transfer has been initialized. */
    953957    SHCLTRANSFERCALLBACKMEMBER(TRANSFERINITIALIZE, pfnTransferInitialize)

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

    r80990 r81025  
    6969/** Starts a transfer on the guest.
    7070 *  This creates the necessary IDataObject in the matching window thread. */
    71 # define SHCL_WIN_WM_URI_TRANSFER_START    WM_USER + 2
     71# define SHCL_WIN_WM_TRANSFER_START         WM_USER + 2
    7272#endif
    7373

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

    r80996 r81025  
    178178 *  New since protocol v1. */
    179179#define VBOX_SHCL_GUEST_FN_MSG_GET                8
    180 /** Sends a transfer status to the host.
    181  *  New since protocol v1. */
    182 #define VBOX_SHCL_GUEST_FN_STATUS                 9
    183180/** Replies to a function from the host.
    184181 *  New since protocol v1. */
    … …  
    512509
    513510/**
    514  * Requests to read the root list.
     511 * Requests to read the root list header.
    515512 */
    516513typedef struct _VBoxShClRootListReadReqMsg
    … …  
    521518} VBoxShClRootListReadReqMsg;
    522519
    523 #define VBOX_SHCL_CPARMS_ROOT_LIST_HDR_READ 2
     520#define VBOX_SHCL_CPARMS_ROOT_LIST_HDR_READ_REQ 2
    524521
    525522/**
    … …  
    535532} VBoxShClRootListHdrMsg;
    536533
    537 #define VBOX_SHCL_CPARMS_ROOT_LIST_HDR 3
     534#define VBOX_SHCL_CPARMS_ROOT_LIST_HDR_READ  3
     535#define VBOX_SHCL_CPARMS_ROOT_LIST_HDR_WRITE 3
    538536
    539537/**
    … …  
    581579} VBoxShClRootListEntryMsg;
    582580
    583 #define VBOX_SHCL_CPARMS_ROOT_LIST_ENTRY 6
     581#define VBOX_SHCL_CPARMS_ROOT_LIST_ENTRY_READ  6
     582#define VBOX_SHCL_CPARMS_ROOT_LIST_ENTRY_WRITE 6
    584583
    585584/**

  • trunk/include/VBox/VBoxGuestLib.h

    r80990 r81025  
    623623typedef enum _VBGLR3CLIPBOARDEVENTTYPE
    624624{
    625     VBGLR3CLIPBOARDEVENTTYPE_INVALID = 0,
     625    /** No event needed / defined. */
     626    VBGLR3CLIPBOARDEVENTTYPE_NONE = 0,
     627    /** Host reports available clipboard formats to the guest. */
    626628    VBGLR3CLIPBOARDEVENTTYPE_REPORT_FORMATS,
     629    /** Host wants to read Shared Clipboard data from the guest. */
    627630    VBGLR3CLIPBOARDEVENTTYPE_READ_DATA,
     631    /** Terminates the Shared Clipboard service. */
    628632    VBGLR3CLIPBOARDEVENTTYPE_QUIT,
    629633#  ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    630634    /** Reports a transfer status to the guest. */
    631     VBGLR3CLIPBOARDEVENTTYPE_URI_TRANSFER_STATUS,
     635    VBGLR3CLIPBOARDEVENTTYPE_TRANSFER_STATUS,
    632636#  endif
    633637    /** Blow the type up to 32-bit. */

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

    r80993 r81025  
    6060    /** Windows-specific context data. */
    6161    SHCLWINCTX            Win;
     62    /** Thread handle for window thread. */
     63    RTTHREAD              hThread;
     64    /** Start indicator flag. */
     65    bool                  fStarted;
     66    /** Shutdown indicator flag. */
     67    bool                  fShutdown;
    6268#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    6369    /** Associated transfer data. */
    … …  
    6571#endif
    6672} SHCLCONTEXT, *PSHCLCONTEXT;
    67 
    68 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    69 typedef struct _SHCLREADTHREADCTX
    70 {
    71     PSHCLCONTEXT     pClipboardCtx;
    72     PSHCLTRANSFER pTransfer;
    73 } SHCLREADTHREADCTX, *PSHCLREADTHREADCTX;
    74 
    75 typedef struct _SHCLWRITETHREADCTX
    76 {
    77     PSHCLCONTEXT     pClipboardCtx;
    78     PSHCLTRANSFER pTransfer;
    79 } SHCLWRITETHREADCTX, *PSHCLWRITETHREADCTX;
    80 #endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
    8173
    8274
    … …  
    109101static void vboxClipboardTransferCallbackCleanup(PSHCLTRANSFERCALLBACKDATA pData)
    110102{
     103    LogFlowFuncEnter();
     104
    111105    PSHCLTRANSFERCTX pCtx = (PSHCLTRANSFERCTX)pData->pvUser;
    112106    AssertPtr(pCtx);
    … …  
    146140    PSHCLCONTEXT pCtx = (PSHCLCONTEXT)pData->pvUser;
    147141    AssertPtr(pCtx);
    148 
    149     LogFlowFunc(("pCtx=%p\n", pCtx));
     142    Assert(pData->cbUser == sizeof(SHCLCONTEXT));
    150143
    151144    PSHCLTRANSFER pTransfer = pData->pTransfer;
    152145    AssertPtr(pTransfer);
    153146
     147    const SHCLTRANSFERDIR enmDir = SharedClipboardTransferGetDir(pTransfer);
     148
     149    LogFlowFunc(("pCtx=%p, idTransfer=%RU16, enmDir=%RU32\n", pCtx, SharedClipboardTransferGetID(pTransfer), enmDir));
     150
    154151    int rc;
    155152
    156153    /* The guest wants to write local data to the host? */
    157     if (SharedClipboardTransferGetDir(pTransfer) == SHCLTRANSFERDIR_WRITE)
     154    if (enmDir == SHCLTRANSFERDIR_WRITE)
    158155    {
    159156        Assert(SharedClipboardTransferGetSource(pTransfer) == SHCLSOURCE_LOCAL); /* Sanity. */
    … …  
    194191    }
    195192    /* The guest wants to read data from a remote source. */
    196     else if (SharedClipboardTransferGetDir(pTransfer) == SHCLTRANSFERDIR_READ)
    197     {
    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;
     193    else if (enmDir == SHCLTRANSFERDIR_READ)
     194    {
     195        Assert(SharedClipboardTransferGetSource(pTransfer) == SHCLSOURCE_REMOTE); /* Sanity. */
     196
     197        rc = SharedClipboardWinTransferCreate(&pCtx->Win, pTransfer);
    204198    }
    205199    else
    206200        AssertFailedStmt(rc = VERR_NOT_SUPPORTED);
    207201
    208     LogFlowFuncLeaveRC(rc);
     202    LogFlowFunc(("LEAVE: idTransfer=%RU16, rc=%Rrc\n", SharedClipboardTransferGetID(pTransfer), rc));
    209203    return rc;
    210204}
    … …  
    251245        case WM_CLIPBOARDUPDATE:
    252246        {
    253             LogFunc(("WM_CLIPBOARDUPDATE\n"));
     247            LogFunc(("WM_CLIPBOARDUPDATE: pWinCtx=%p\n", pWinCtx));
    254248
    255249            int rc = RTCritSectEnter(&pWinCtx->CritSect);
    … …  
    269263                     * Report available formats to the host. */
    270264                    SHCLFORMATDATA Formats;
    271                     int rc = SharedClipboardWinGetFormats(&pCtx->Win, &Formats);
     265                    int rc = SharedClipboardWinGetFormats(pWinCtx, &Formats);
    272266                    if (RT_SUCCESS(rc))
    273267                    {
    … …  
    298292        case WM_DRAWCLIPBOARD:
    299293        {
    300             LogFlowFunc(("WM_DRAWCLIPBOARD\n"));
     294            LogFlowFunc(("WM_DRAWCLIPBOARD: pWinCtx=%p\n", pWinCtx));
    301295
    302296            int rc = RTCritSectEnter(&pWinCtx->CritSect);
    … …  
    517511            Assert(pEvent->enmType == VBGLR3CLIPBOARDEVENTTYPE_REPORT_FORMATS);
    518512
    519             const SHCLFORMATS fFormats =  pEvent->u.ReportedFormats.uFormats;
     513            const SHCLFORMATS fFormats = pEvent->u.ReportedFormats.uFormats;
    520514
    521515            if (fFormats != VBOX_SHCL_FMT_NONE) /* Could arrive with some older GA versions. */
    522516            {
    523                 int rc = SharedClipboardWinOpen(hwnd);
    524                 if (RT_SUCCESS(rc))
    525                 {
    526                     SharedClipboardWinClear();
    527 
    528 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    529                     if (fFormats & VBOX_SHCL_FMT_URI_LIST)
     517#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
     518                if (fFormats & VBOX_SHCL_FMT_URI_LIST)
     519                {
     520                    LogFunc(("VBOX_SHCL_FMT_URI_LIST\n"));
     521
     522                    /*
     523                     * Creating and starting the actual transfer will be done in vbglR3ClipboardTransferStart() as soon
     524                     * as the host announces the start of the transfer via a VBOX_SHCL_HOST_MSG_TRANSFER_STATUS message.
     525                     * Transfers always are controlled and initiated on the host side!
     526                     *
     527                     * So don't announce the transfer to the OS here yet. Don't touch the clipboard in any here; otherwise
     528                     * this will trigger a WM_DRAWCLIPBOARD or friends, which will result in fun bugs coming up.
     529                     */
     530                }
     531                else
     532                {
     533#endif
     534                    int rc = SharedClipboardWinOpen(hwnd);
     535                    if (RT_SUCCESS(rc))
    530536                    {
    531                         LogFunc(("VBOX_SHCL_FMT_URI_LIST\n"));
    532 
    533                         /*
    534                          * Creating and starting the actual transfer will be done in vbglR3ClipboardTransferStart() as soon
    535                          * as the host announces the start of the transfer via a VBOX_SHCL_HOST_MSG_TRANSFER_STATUS message.
    536                          * Transfers always are controlled and initiated on the host side!
    537                          *
    538                          * So don't announce the transfer to the OS here yet.
    539                          */
     537                        SharedClipboardWinClear();
     538
     539                        rc = SharedClipboardWinAnnounceFormats(pWinCtx, fFormats);
    540540                    }
    541                     else
    542                     {
    543 #endif
    544                         rc = SharedClipboardWinAnnounceFormats(pWinCtx, fFormats);
    545 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    546                     }
    547 #endif
     541
    548542                    SharedClipboardWinClose();
    549                 }
     543
     544#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
     545                }
     546#endif
    550547            }
    551548
    … …  
    651648        }
    652649
    653 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    654         case SHCL_WIN_WM_URI_TRANSFER_START:
    655         {
    656             LogFunc(("SHCL_WIN_WM_URI_TRANSFER_CREATE\n"));
     650#if 0
     651        case SHCL_WIN_WM_TRANSFER_START:
     652        {
     653            LogFunc(("SHCL_WIN_WM_TRANSFER_START\n"));
    657654
    658655            PSHCLTRANSFER pTransfer = (PSHCLTRANSFER)lParam;
    … …  
    661658            Assert(SharedClipboardTransferGetSource(pTransfer) == SHCLSOURCE_REMOTE); /* Sanity. */
    662659
    663             int rc2 = SharedClipboardWinTransferCreate(&pCtx->Win, pTransfer);
     660            int rc2 = SharedClipboardWinTransferCreate(pWinCtx, pTransfer);
    664661            AssertRC(rc2);
    665662            break;
    … …  
    707704
    708705    /* Register the Window Class. */
    709     WNDCLASSEX wc = { 0 };
    710     wc.cbSize     = sizeof(WNDCLASSEX);
     706    WNDCLASSEX wc;
     707    RT_ZERO(wc);
     708
     709    wc.cbSize = sizeof(WNDCLASSEX);
    711710
    712711    if (!GetClassInfoEx(hInstance, s_szClipWndClassName, &wc))
    … …  
    741740                         SWP_NOACTIVATE | SWP_HIDEWINDOW | SWP_NOCOPYBITS | SWP_NOREDRAW | SWP_NOSIZE);
    742741
    743             SharedClipboardWinChainAdd(pWinCtx);
    744             if (!SharedClipboardWinIsNewAPI(&pWinCtx->newAPI))
    745                 pWinCtx->oldAPI.timerRefresh = SetTimer(pWinCtx->hWnd, 0, 10 * 1000 /* 10s */, NULL);
     742            rc = SharedClipboardWinChainAdd(pWinCtx);
     743            if (RT_SUCCESS(rc))
     744            {
     745                if (!SharedClipboardWinIsNewAPI(&pWinCtx->newAPI))
     746                    pWinCtx->oldAPI.timerRefresh = SetTimer(pWinCtx->hWnd, 0, 10 * 1000 /* 10s */, NULL);
     747            }
    746748        }
    747749    }
    … …  
    751753}
    752754
     755static int vboxClipboardWindowThread(RTTHREAD hThread, void *pvUser)
     756{
     757    PSHCLCONTEXT pCtx = (PSHCLCONTEXT)pvUser;
     758    AssertPtr(pCtx);
     759
     760    HRESULT hr;
     761
     762#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
     763    hr = OleInitialize(NULL);
     764    if (FAILED(hr))
     765    {
     766        LogRel(("Shared Clipboard: Initializing OLE in window thread failed (%Rhrc) -- file transfers unavailable\n", hr));
     767        /* Not critical, the rest of the clipboard might work. */
     768    }
     769    else
     770        LogRel(("Shared Clipboard: Initialized OLE in window thread\n"));
     771#endif
     772
     773    int rc = vboxClipboardCreateWindow(pCtx);
     774    if (RT_FAILURE(rc))
     775    {
     776        LogRel(("Shared Clipboard: Unable to create window, rc=%Rrc\n", rc));
     777        return rc;
     778    }
     779
     780    pCtx->fStarted = true; /* Set started indicator. */
     781
     782    int rc2 = RTThreadUserSignal(hThread);
     783    bool fSignalled = RT_SUCCESS(rc2);
     784
     785    LogRel2(("Shared Clipboard: Window thread running\n"));
     786
     787    if (RT_SUCCESS(rc))
     788    {
     789        for (;;)
     790        {
     791            MSG uMsg;
     792            BOOL fRet;
     793            while ((fRet = GetMessage(&uMsg, 0, 0, 0)) > 0)
     794            {
     795                TranslateMessage(&uMsg);
     796                DispatchMessage(&uMsg);
     797            }
     798            Assert(fRet >= 0);
     799
     800            if (ASMAtomicReadBool(&pCtx->fShutdown))
     801                break;
     802
     803            /** @todo Immediately drop on failure? */
     804        }
     805    }
     806
     807    if (!fSignalled)
     808    {
     809        rc2 = RTThreadUserSignal(hThread);
     810        AssertRC(rc2);
     811    }
     812
     813#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
     814    OleSetClipboard(NULL); /* Make sure to flush the clipboard on destruction. */
     815    OleUninitialize();
     816#endif
     817
     818    LogRel(("Shared Clipboard: Window thread ended\n"));
     819
     820    LogFlowFuncLeaveRC(rc);
     821    return rc;
     822}
     823
    753824static void vboxClipboardDestroy(PSHCLCONTEXT pCtx)
    754825{
    755826    AssertPtrReturnVoid(pCtx);
     827
     828    LogFlowFunc(("pCtx=%p\n", pCtx));
     829
     830    LogRel2(("Shared Clipboard: Destroying ...\n"));
     831
     832    pCtx->fShutdown = true;
    756833
    757834    const PSHCLWINCTX pWinCtx = &pCtx->Win;
    … …  
    763840    }
    764841
     842    if (pCtx->hThread != NIL_RTTHREAD)
     843    {
     844        int rcThread = VERR_WRONG_ORDER;
     845        int rc = RTThreadWait(pCtx->hThread, 60 * 1000 /* Timeout in ms */, &rcThread);
     846        LogFlowFunc(("Waiting for thread resulted in %Rrc (thread exited with %Rrc)\n",
     847                     rc, rcThread));
     848        RT_NOREF(rc);
     849    }
     850
    765851    UnregisterClass(s_szClipWndClassName, pCtx->pEnv->hInstance);
    766852
    767853    SharedClipboardWinCtxDestroy(&pCtx->Win);
     854
     855    LogRel2(("Shared Clipboard: Destroyed\n"));
    768856}
    769857
    … …  
    797885    }
    798886
    799     pCtx->pEnv = pEnv;
     887    pCtx->pEnv      = pEnv;
     888    pCtx->hThread   = NIL_RTTHREAD;
     889    pCtx->fStarted  = false;
     890    pCtx->fShutdown = false;
    800891
    801892    int rc = VINF_SUCCESS;
    802893
    803894#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    804     HRESULT hr = OleInitialize(NULL);
    805     if (FAILED(hr))
    806     {
    807         LogRel(("Shared Clipboard: Initializing OLE failed (%Rhrc) -- file transfers unavailable\n", hr));
    808         /* Not critical, the rest of the clipboard might work. */
    809     }
    810     else
    811     {
    812         LogRel(("Shared Clipboard: Initialized OLE\n"));
    813 
    814         /* Install callbacks. */
    815         RT_ZERO(pCtx->CmdCtx.Transfers.Callbacks);
    816 
    817         pCtx->CmdCtx.Transfers.Callbacks.pvUser = pCtx; /* Assign context as user-provided callback data. */
    818 
    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;
    823     }
     895    /* Install callbacks. */
     896    RT_ZERO(pCtx->CmdCtx.Transfers.Callbacks);
     897
     898    pCtx->CmdCtx.Transfers.Callbacks.pvUser = pCtx; /* Assign context as user-provided callback data. */
     899    pCtx->CmdCtx.Transfers.Callbacks.cbUser = sizeof(SHCLCONTEXT);
     900
     901    pCtx->CmdCtx.Transfers.Callbacks.pfnTransferInitialize = vboxClipboardOnTransferInitCallback;
     902    pCtx->CmdCtx.Transfers.Callbacks.pfnTransferStart      = vboxClipboardOnTransferStartCallback;
     903    pCtx->CmdCtx.Transfers.Callbacks.pfnTransferComplete   = vboxClipboardOnTransferCompleteCallback;
     904    pCtx->CmdCtx.Transfers.Callbacks.pfnTransferError      = vboxClipboardOnTransferErrorCallback;
    824905#endif
    825906
    826907    if (RT_SUCCESS(rc))
    827908    {
    828         /* Check if new Clipboard API is available. */
    829909        rc = SharedClipboardWinCtxInit(&pCtx->Win);
    830910        if (RT_SUCCESS(rc))
    … …  
    832912        if (RT_SUCCESS(rc))
    833913        {
    834             rc = vboxClipboardCreateWindow(pCtx);
     914#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
     915            rc = SharedClipboardTransferCtxInit(&pCtx->TransferCtx);
     916#endif
    835917            if (RT_SUCCESS(rc))
    836918            {
    837 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    838                 rc = SharedClipboardTransferCtxInit(&pCtx->TransferCtx);
     919                /* Message pump thread for our proxy window. */
     920                rc = RTThreadCreate(&pCtx->hThread, vboxClipboardWindowThread, pCtx /* pvUser */,
     921                                    0, RTTHREADTYPE_MSG_PUMP, RTTHREADFLAGS_WAITABLE,
     922                                    "shclwnd");
    839923                if (RT_SUCCESS(rc))
    840 #endif
    841                     *ppInstance = pCtx;
     924                {
     925                    int rc2 = RTThreadUserWait(pCtx->hThread, 30 * 1000 /* Timeout in ms */);
     926                    AssertRC(rc2);
     927
     928                    if (!pCtx->fStarted) /* Did the thread fail to start? */
     929                        rc = VERR_NOT_SUPPORTED; /* Report back Shared Clipboard as not being supported. */
     930                }
     931            }
     932
     933            if (RT_SUCCESS(rc))
     934            {
     935                *ppInstance = pCtx;
    842936            }
    843937            else
    844             {
    845938                VbglR3ClipboardDisconnectEx(&pCtx->CmdCtx);
    846             }
    847         }
    848     }
     939        }
     940    }
     941
     942    if (RT_FAILURE(rc))
     943        LogRel(("Shared Clipboard: Unable to initialize, rc=%Rrc\n", rc));
    849944
    850945    LogFlowFuncLeaveRC(rc);
    … …  
    856951    AssertPtr(pInstance);
    857952    LogFlowFunc(("pInstance=%p\n", pInstance));
    858 
    859     HRESULT hr = OleInitialize(NULL);
    860     if (FAILED(hr))
    861     {
    862         LogRel(("Shared Clipboard: Initializing OLE in worker thread failed (%Rhrc) -- file transfers unavailable\n", hr));
    863         /* Not critical, the rest of the clipboard might work. */
    864     }
    865953
    866954    /*
    … …  
    875963    const PSHCLWINCTX pWinCtx = &pCtx->Win;
    876964
     965    LogRel2(("Shared Clipboard: Worker loop running, using protocol v%RU32\n", pCtx->CmdCtx.uProtocolVer));
     966
     967#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
     968    HRESULT hr = OleInitialize(NULL);
     969    if (FAILED(hr))
     970    {
     971        LogRel(("Shared Clipboard: Initializing OLE in worker thread failed (%Rhrc) -- file transfers unavailable\n", hr));
     972        /* Not critical, the rest of the clipboard might work. */
     973    }
     974    else
     975        LogRel(("Shared Clipboard: Initialized OLE in worker thraed\n"));
     976#endif
     977
    877978    int rc;
    878979
    879     LogFlowFunc(("Using protocol %RU32\n", pCtx->CmdCtx.uProtocolVer));
     980    LogFlowFunc(("uProtocolVer=%RU32\n", pCtx->CmdCtx.uProtocolVer));
    880981
    881982    uint32_t uMsg;
    … …  
    9461047        if (RT_FAILURE(rc))
    9471048        {
     1049            LogFlowFunc(("Getting next event failed with %Rrc\n", rc));
     1050
    9481051            VbglR3ClipboardEventFree(pEvent);
    9491052            pEvent = NULL;
    … …  
    9871090                case VBGLR3CLIPBOARDEVENTTYPE_QUIT:
    9881091                {
    989                     /* The host is terminating. */
    990                     LogRel(("Shared Clipboard: Terminating ...\n"));
     1092                    LogRel2(("Shared Clipboard: Host requested termination\n"));
    9911093                    ASMAtomicXchgBool(pfShutdown, true);
    9921094                    break;
    … …  
    9941096
    9951097#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    996                 case VBGLR3CLIPBOARDEVENTTYPE_URI_TRANSFER_STATUS:
     1098                case VBGLR3CLIPBOARDEVENTTYPE_TRANSFER_STATUS:
    9971099                {
    9981100                    /* Nothing to do here. */
     1101                    rc = VINF_SUCCESS;
    9991102                    break;
    10001103                }
    10011104#endif
    1002                 case VBGLR3CLIPBOARDEVENTTYPE_INVALID:
     1105                case VBGLR3CLIPBOARDEVENTTYPE_NONE:
     1106                {
     1107                    /* Nothing to do here. */
     1108                    rc = VINF_SUCCESS;
     1109                    break;
     1110                }
     1111
    10031112                default:
    10041113                {
    1005                     /* Wait a bit before retrying. */
    1006                     RTThreadSleep(1000);
    1007 
    1008                     rc = VERR_NOT_SUPPORTED;
    1009                     break;
     1114                    AssertMsgFailedBreakStmt(("Event type %RU32 not implemented\n", pEvent->enmType), rc = VERR_NOT_SUPPORTED);
    10101115                }
    10111116            }
    … …  
    10221127    }
    10231128
     1129    LogRel(("Shared Clipboard: Worker loop ended\n"));
     1130
    10241131#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    10251132    OleSetClipboard(NULL); /* Make sure to flush the clipboard on destruction. */
    … …  
    10601167
    10611168#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    1062     OleSetClipboard(NULL); /* Make sure to flush the clipboard on destruction. */
    1063     OleUninitialize();
    1064 
    10651169    SharedClipboardTransferCtxDestroy(&pCtx->TransferCtx);
    10661170#endif

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

    r80992 r81025  
    415415
    416416    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
    417                        VBOX_SHCL_GUEST_FN_ROOT_LIST_ENTRY_READ, VBOX_SHCL_CPARMS_ROOT_LIST_ENTRY);
     417                       VBOX_SHCL_GUEST_FN_ROOT_LIST_ENTRY_READ, VBOX_SHCL_CPARMS_ROOT_LIST_ENTRY_READ);
    418418
    419419    Msg.Parms.uContext.SetUInt32(pCtx->uContextID);
    … …  
    567567
    568568    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
    569                        VBOX_SHCL_GUEST_FN_MSG_GET, VBOX_SHCL_CPARMS_ROOT_LIST_HDR_READ);
     569                       VBOX_SHCL_GUEST_FN_MSG_GET, VBOX_SHCL_CPARMS_ROOT_LIST_HDR_READ_REQ);
    570570
    571571    Msg.ReqParms.uContext.SetUInt32(VBOX_SHCL_HOST_MSG_TRANSFER_ROOT_LIST_HDR_READ);
    … …  
    593593
    594594    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
    595                        VBOX_SHCL_GUEST_FN_ROOT_LIST_HDR_WRITE, VBOX_SHCL_CPARMS_ROOT_LIST_HDR);
     595                       VBOX_SHCL_GUEST_FN_ROOT_LIST_HDR_WRITE, VBOX_SHCL_CPARMS_ROOT_LIST_HDR_WRITE);
    596596
    597597    Msg.ReqParms.uContext.SetUInt32(pCtx->uContextID);
    … …  
    645645
    646646    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
    647                        VBOX_SHCL_GUEST_FN_ROOT_LIST_ENTRY_WRITE, VBOX_SHCL_CPARMS_ROOT_LIST_ENTRY);
     647                       VBOX_SHCL_GUEST_FN_ROOT_LIST_ENTRY_WRITE, VBOX_SHCL_CPARMS_ROOT_LIST_ENTRY_WRITE);
    648648
    649649    Msg.Parms.uContext.SetUInt32(pCtx->uContextID);
    … …  
    14271427                    creationCtx.Interface.pfnObjClose      = vbglR3ClipboardTransferIfaceObjClose;
    14281428                    creationCtx.Interface.pfnObjRead       = vbglR3ClipboardTransferIfaceObjRead;
     1429
     1430                    creationCtx.pvUser = pCmdCtx;
    14291431
    14301432                    rc = SharedClipboardTransferSetInterface(pTransfer, &creationCtx);
    … …  
    15861588                    pEvent->u.TransferStatus.uID    = VBOX_SHCL_CONTEXTID_GET_TRANSFER(pCmdCtx->uContextID);
    15871589
    1588                     pEvent->enmType = VBGLR3CLIPBOARDEVENTTYPE_URI_TRANSFER_STATUS;
     1590                    pEvent->enmType = VBGLR3CLIPBOARDEVENTTYPE_TRANSFER_STATUS;
    15891591
    15901592                    LogRel2(("Shared Clipboard: Received status %s (rc=%Rrc) for transfer ID=%RU16\n",
    … …  
    18781880        }
    18791881
     1882        case VBOX_SHCL_HOST_MSG_QUIT:
     1883        {
     1884            pEvent->enmType = VBGLR3CLIPBOARDEVENTTYPE_QUIT;
     1885            rc = VINF_SUCCESS;
     1886            break;
     1887        }
     1888
    18801889        default:
    18811890        {

  • trunk/src/VBox/GuestHost/SharedClipboard/ClipboardDataObjectImpl-win.cpp

    r80905 r81025  
    367367                if (ASMAtomicReadBool(&pTransfer->Thread.fStop))
    368368                {
    369                     LogRel2(("Shared Clipboard: Stopping transfer calculating ...\n"));
     369                    LogRel2(("Shared Clipboard: Stopping transfer calculation ...\n"));
    370370                    break;
    371371                }
    … …  
    378378            pRootList = NULL;
    379379
    380             if (RT_SUCCESS(rc))
     380            if (   RT_SUCCESS(rc)
     381                && !ASMAtomicReadBool(&pTransfer->Thread.fStop))
    381382            {
    382383                LogRel2(("Shared Clipboard: Transfer calculation complete (%zu root entries)\n", pThis->m_lstEntries.size()));
    … …  
    402403                   LogRel(("Shared Clipboard: No transfer root entries found -- should not happen, please file a bug report\n"));
    403404            }
    404             else
     405            else if (RT_FAILURE(rc))
    405406                LogRel(("Shared Clipboard: Transfer failed with %Rrc\n", rc));
    406407        }

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

    r80990 r81025  
    890890        RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_MSG_PEEK_WAIT);
    891891        RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_MSG_GET);
    892         RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_STATUS);
    893892        RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_REPLY);
    894893        RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_ROOT_LIST_HDR_READ);

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

    r80990 r81025  
    11781178        if (pTransfer->Callbacks.pfnTransferInitialize)
    11791179        {
    1180             SHCLTRANSFERCALLBACKDATA Data = { pTransfer, pTransfer->Callbacks.pvUser };
     1180            SHCLTRANSFERCALLBACKDATA Data = { pTransfer, pTransfer->Callbacks.pvUser, pTransfer->Callbacks.cbUser };
    11811181            rc = pTransfer->Callbacks.pfnTransferInitialize(&Data);
    11821182        }
    … …  
    22852285    if (pTransfer->Callbacks.pfnTransferStart)
    22862286    {
    2287         SHCLTRANSFERCALLBACKDATA Data = { pTransfer, pTransfer->Callbacks.pvUser };
     2287        SHCLTRANSFERCALLBACKDATA Data = { pTransfer, pTransfer->Callbacks.pvUser, pTransfer->Callbacks.cbUser };
    22882288        rc = pTransfer->Callbacks.pfnTransferStart(&Data);
    22892289    }
    … …  
    23262326
    23272327    pTransfer->Callbacks.pvUser = pCallbacks->pvUser;
     2328    pTransfer->Callbacks.cbUser = pCallbacks->cbUser;
    23282329}
    23292330
    … …  
    26382639    AssertPtrReturnVoid(pTransferCtx);
    26392640
    2640     LogFlowFunc(("pTransferCtx=%p, cTransfers=%RU32, cRunning=%RU32\n",
     2641    LogFlowFunc(("pTransferCtx=%p, cTransfers=%RU16 cRunning=%RU16\n",
    26412642                 pTransferCtx, pTransferCtx->cTransfers, pTransferCtx->cRunning));
    26422643
    2643     /* Remove all transfers which are not in a running state (e.g. only announced). */
    2644     PSHCLTRANSFER pTransfer, pTransferNext;
    2645     RTListForEachSafe(&pTransferCtx->List, pTransfer, pTransferNext, SHCLTRANSFER, Node)
    2646     {
    2647         if (SharedClipboardTransferGetStatus(pTransfer) != SHCLTRANSFERSTATUS_STARTED)
    2648         {
    2649             SharedClipboardTransferDestroy(pTransfer);
    2650             RTListNodeRemove(&pTransfer->Node);
    2651 
    2652             RTMemFree(pTransfer);
    2653             pTransfer = NULL;
    2654 
    2655             Assert(pTransferCtx->cTransfers);
    2656             pTransferCtx->cTransfers--;
     2644    if (!RTListIsEmpty(&pTransferCtx->List))
     2645    {
     2646        /* Remove all transfers which are not in a running state (e.g. only announced). */
     2647        PSHCLTRANSFER pTransfer, pTransferNext;
     2648        RTListForEachSafe(&pTransferCtx->List, pTransfer, pTransferNext, SHCLTRANSFER, Node)
     2649        {
     2650            if (SharedClipboardTransferGetStatus(pTransfer) != SHCLTRANSFERSTATUS_STARTED)
     2651            {
     2652                SharedClipboardTransferDestroy(pTransfer);
     2653                RTListNodeRemove(&pTransfer->Node);
     2654
     2655                RTMemFree(pTransfer);
     2656                pTransfer = NULL;
     2657
     2658                Assert(pTransferCtx->cTransfers);
     2659                pTransferCtx->cTransfers--;
     2660            }
    26572661        }
    26582662    }

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

    r80966 r81025  
    181181    if (!pWinCtx)
    182182        return;
     183
     184    LogFlowFuncEnter();
    183185
    184186    if (RTCritSectIsInitialized(&pWinCtx->CritSect))
    … …  
    894896    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
    895897
    896     LogFlowFuncEnter();
    897 
    898     int rc;
     898    LogFlowFunc(("pWinCtx=%p\n", pWinCtx));
    899899
    900900    AssertReturn(pTransfer->pvUser == NULL, VERR_WRONG_ORDER);
    901901
    902     SharedClipboardWinTransferCtx *pWinURITransferCtx = new SharedClipboardWinTransferCtx();
    903     if (pWinURITransferCtx)
    904     {
    905         pTransfer->pvUser = pWinURITransferCtx;
    906         pTransfer->cbUser = sizeof(SharedClipboardWinTransferCtx);
    907 
    908         pWinURITransferCtx->pDataObj = new SharedClipboardWinDataObject(pTransfer);
    909         if (pWinURITransferCtx->pDataObj)
    910         {
    911             rc = pWinURITransferCtx->pDataObj->Init();
    912             if (RT_SUCCESS(rc))
     902    /* Make sure to enter the critical section before setting the clipboard data, as otherwise WM_CLIPBOARDUPDATE
     903     * might get called *before* we had the opportunity to set pWinCtx->hWndClipboardOwnerUs below. */
     904    int rc = RTCritSectEnter(&pWinCtx->CritSect);
     905    if (RT_SUCCESS(rc))
     906    {
     907        SharedClipboardWinTransferCtx *pWinURITransferCtx = new SharedClipboardWinTransferCtx();
     908        if (pWinURITransferCtx)
     909        {
     910            pTransfer->pvUser = pWinURITransferCtx;
     911            pTransfer->cbUser = sizeof(SharedClipboardWinTransferCtx);
     912
     913            pWinURITransferCtx->pDataObj = new SharedClipboardWinDataObject(pTransfer);
     914            if (pWinURITransferCtx->pDataObj)
    913915            {
    914                 SharedClipboardWinClose();
    915                 /* Note: Clipboard must be closed first before calling OleSetClipboard(). */
    916 
    917                 /** @todo There is a potential race between SharedClipboardWinClose() and OleSetClipboard(),
    918                  *        where another application could own the clipboard (open), and thus the call to
    919                  *        OleSetClipboard() will fail. Needs (better) fixing. */
    920                 HRESULT hr = S_OK;
    921 
    922                 for (unsigned uTries = 0; uTries < 3; uTries++)
     916                rc = pWinURITransferCtx->pDataObj->Init();
     917                if (RT_SUCCESS(rc))
    923918                {
    924                     /* Make sure to enter the critical section before setting the clipboard data, as otherwise WM_CLIPBOARDUPDATE
    925                      * might get called *before* we had the opportunity to set pWinCtx->hWndClipboardOwnerUs below. */
    926                     rc = RTCritSectEnter(&pWinCtx->CritSect);
    927                     if (RT_SUCCESS(rc))
     919                    SharedClipboardWinClose();
     920                    /* Note: Clipboard must be closed first before calling OleSetClipboard(). */
     921
     922                    /** @todo There is a potential race between SharedClipboardWinClose() and OleSetClipboard(),
     923                     *        where another application could own the clipboard (open), and thus the call to
     924                     *        OleSetClipboard() will fail. Needs (better) fixing. */
     925                    HRESULT hr = S_OK;
     926
     927                    for (unsigned uTries = 0; uTries < 3; uTries++)
    928928                    {
    929929                        hr = OleSetClipboard(pWinURITransferCtx->pDataObj);
    … …  
    939939                            pWinCtx->hWndClipboardOwnerUs = GetClipboardOwner();
    940940
    941                             rc = RTCritSectLeave(&pWinCtx->CritSect);
    942                             AssertRC(rc);
     941                            LogFlowFunc(("hWndClipboardOwnerUs=%p\n", pWinCtx->hWndClipboardOwnerUs));
    943942                            break;
    944943                        }
     944
     945                        LogFlowFunc(("Failed with %Rhrc (try %u/3)\n", hr, uTries + 1));
     946                        RTThreadSleep(500); /* Wait a bit. */
    945947                    }
    946948
    947                     rc = RTCritSectLeave(&pWinCtx->CritSect);
    948                     AssertRCBreak(rc);
    949 
    950                     LogFlowFunc(("Failed with %Rhrc (try %u/3)\n", hr, uTries + 1));
    951                     RTThreadSleep(500); /* Wait a bit. */
    952                 }
    953 
    954                 if (FAILED(hr))
    955                 {
    956                     rc = VERR_ACCESS_DENIED; /** @todo Fudge; fix this. */
    957                     LogRel(("Shared Clipboard: Failed with %Rhrc when setting data object to clipboard\n", hr));
     949                    if (FAILED(hr))
     950                    {
     951                        rc = VERR_ACCESS_DENIED; /** @todo Fudge; fix this. */
     952                        LogRel(("Shared Clipboard: Failed with %Rhrc when setting data object to clipboard\n", hr));
     953                    }
    958954                }
    959955            }
     956            else
     957                rc = VERR_NO_MEMORY;
    960958        }
    961959        else
    962960            rc = VERR_NO_MEMORY;
    963     }
    964     else
    965         rc = VERR_NO_MEMORY;
     961
     962        int rc2 = RTCritSectLeave(&pWinCtx->CritSect);
     963        AssertRC(rc2);
     964    }
    966965
    967966    LogFlowFuncLeaveRC(rc);

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

    r80995 r81025  
    8484
    8585    PSHCLCLIENTMSG pMsgHdr = shclSvcMsgAlloc(VBOX_SHCL_HOST_MSG_TRANSFER_ROOT_LIST_HDR_READ,
    86                                              VBOX_SHCL_CPARMS_ROOT_LIST_HDR_READ);
     86                                             VBOX_SHCL_CPARMS_ROOT_LIST_HDR_READ_REQ);
    8787    if (pMsgHdr)
    8888    {
    … …  
    652652
    653653/**
     654 * Returns whether a HGCM message is allowed in a certain service mode or not.
     655 *
     656 * @returns \c true if message is allowed, \c false if not.
     657 * @param   uMode               Service mode to check allowance for.
     658 * @param   uMsg                HGCM message to check allowance for.
     659 */
     660bool shclSvcTransferMsgIsAllowed(uint32_t uMode, uint32_t uMsg)
     661{
     662    const bool fHostToGuest =    uMode == VBOX_SHCL_MODE_HOST_TO_GUEST
     663                              || uMode == VBOX_SHCL_MODE_BIDIRECTIONAL;
     664
     665    const bool fGuestToHost =    uMode == VBOX_SHCL_MODE_GUEST_TO_HOST
     666                              || uMode == VBOX_SHCL_MODE_BIDIRECTIONAL;
     667
     668    bool fAllowed = false; /* If in doubt, don't allow. */
     669
     670    switch (uMsg)
     671    {
     672        case VBOX_SHCL_GUEST_FN_ROOT_LIST_HDR_WRITE:
     673            RT_FALL_THROUGH();
     674        case VBOX_SHCL_GUEST_FN_ROOT_LIST_ENTRY_WRITE:
     675            RT_FALL_THROUGH();
     676        case VBOX_SHCL_GUEST_FN_LIST_HDR_WRITE:
     677            RT_FALL_THROUGH();
     678        case VBOX_SHCL_GUEST_FN_LIST_ENTRY_WRITE:
     679            RT_FALL_THROUGH();
     680        case VBOX_SHCL_GUEST_FN_OBJ_WRITE:
     681            fAllowed = fGuestToHost;
     682            break;
     683
     684        case VBOX_SHCL_GUEST_FN_ROOT_LIST_HDR_READ:
     685            RT_FALL_THROUGH();
     686        case VBOX_SHCL_GUEST_FN_ROOT_LIST_ENTRY_READ:
     687            RT_FALL_THROUGH();
     688        case VBOX_SHCL_GUEST_FN_LIST_HDR_READ:
     689            RT_FALL_THROUGH();
     690        case VBOX_SHCL_GUEST_FN_LIST_ENTRY_READ:
     691            RT_FALL_THROUGH();
     692        case VBOX_SHCL_GUEST_FN_OBJ_READ:
     693            fAllowed = fHostToGuest;
     694            break;
     695
     696        case VBOX_SHCL_GUEST_FN_CONNECT:
     697            RT_FALL_THROUGH();
     698        case VBOX_SHCL_GUEST_FN_MSG_PEEK_WAIT:
     699            RT_FALL_THROUGH();
     700        case VBOX_SHCL_GUEST_FN_MSG_PEEK_NOWAIT:
     701            RT_FALL_THROUGH();
     702        case VBOX_SHCL_GUEST_FN_MSG_GET:
     703            RT_FALL_THROUGH();
     704        case VBOX_SHCL_GUEST_FN_REPLY:
     705            RT_FALL_THROUGH();
     706        case VBOX_SHCL_GUEST_FN_CANCEL:
     707            RT_FALL_THROUGH();
     708        case VBOX_SHCL_GUEST_FN_ERROR:
     709            RT_FALL_THROUGH();
     710        case VBOX_SHCL_GUEST_FN_LIST_OPEN:
     711            RT_FALL_THROUGH();
     712        case VBOX_SHCL_GUEST_FN_LIST_CLOSE:
     713            RT_FALL_THROUGH();
     714        case VBOX_SHCL_GUEST_FN_OBJ_OPEN:
     715            RT_FALL_THROUGH();
     716        case VBOX_SHCL_GUEST_FN_OBJ_CLOSE:
     717            fAllowed = fHostToGuest || fGuestToHost;
     718            break;
     719
     720        default:
     721            break;
     722    }
     723
     724    LogFlowFunc(("uMsg=%RU32 (%s), uMode=%RU32 -> fAllowed=%RTbool\n", uMsg, VBoxShClGuestMsgToStr(uMsg), uMode, fAllowed));
     725    return fAllowed;
     726}
     727
     728/**
    654729 * Gets a transfer message reply from HGCM service parameters.
    655730 *
    … …  
    740815    int rc;
    741816
    742     if (cParms == VBOX_SHCL_CPARMS_ROOT_LIST_HDR)
     817    if (cParms == VBOX_SHCL_CPARMS_ROOT_LIST_HDR_WRITE)
    743818    {
    744819        rc = HGCMSvcGetU32(&paParms[1], &pRootLstHdr->fRoots);
    … …  
    766841    int rc;
    767842
    768     if (cParms == VBOX_SHCL_CPARMS_ROOT_LIST_ENTRY)
     843    if (cParms == VBOX_SHCL_CPARMS_ROOT_LIST_ENTRY_WRITE)
    769844    {
    770845        rc = HGCMSvcGetU32(&paParms[1], &pListEntry->fInfo);
    … …  
    12201295                 pClient->State.uClientID, u32Function, VBoxShClGuestMsgToStr(u32Function), cParms, g_ExtState.pfnExtension));
    12211296
    1222 #if 0
    12231297    /* Check if we've the right mode set. */
    12241298    if (!shclSvcTransferMsgIsAllowed(shclSvcGetMode(), u32Function))
    … …  
    12271301        return VERR_ACCESS_DENIED;
    12281302    }
    1229 #endif
    12301303
    12311304    /* A (valid) service extension is needed because VBoxSVC needs to keep track of the
    … …  
    12501323    switch (u32Function)
    12511324    {
    1252         case VBOX_SHCL_GUEST_FN_STATUS:
    1253             break;
    12541325        default:
    12551326        {
    … …  
    12871358    switch (u32Function)
    12881359    {
    1289 #if 0
    1290         case VBOX_SHCL_GUEST_FN_STATUS:
    1291         {
    1292             if (cParms != VBOX_SHCL_CPARMS_STATUS)
     1360        case VBOX_SHCL_GUEST_FN_REPLY:
     1361        {
     1362            rc = shclSvcTransferHandleReply(pClient, pTransfer, cParms, paParms);
     1363            break;
     1364        }
     1365
     1366        case VBOX_SHCL_GUEST_FN_ROOT_LIST_HDR_READ:
     1367        {
     1368            if (cParms != VBOX_SHCL_CPARMS_ROOT_LIST_HDR_READ)
    12931369                break;
    12941370
    1295             SHCLTRANSFERSTATUS uStatus = SHCLTRANSFERSTATUS_NONE;
    1296             rc = HGCMSvcGetU32(&paParms[1], &uStatus);
    1297             if (RT_FAILURE(rc))
    1298                 break;
    1299 
    1300             LogFlowFunc(("uStatus: %RU32\n", uStatus));
    1301 
    1302             SharedClipboardTransferCtxTransfersCleanup(&pClient->URI);
    1303 
    1304             if (SharedClipboardTransferCtxTransfersMaximumReached(&pClient->URI))
    1305             {
    1306                 rc = VERR_SHCLPB_MAX_TRANSFERS_REACHED;
    1307                 break;
    1308             }
    1309 
    1310             if (uStatus == SHCLTRANSFERSTATUS_RUNNING)
    1311             {
    1312                 const SHCLTRANSFERDIR enmDir = SHCLTRANSFERDIR_READ;
    1313 
    1314                 PSHCLTRANSFER pTransfer;
    1315                 rc = SharedClipboardTransferCreate(enmDir,
    1316                                                       SHCLSOURCE_REMOTE, &pTransfer);
    1317                 if (RT_SUCCESS(rc))
    1318                 {
    1319                     rc = shclSvcTransferAreaRegister(&pClient->State, pTransfer);
    1320                     if (RT_SUCCESS(rc))
    1321                     {
    1322                         SHCLPROVIDERCREATIONCTX creationCtx;
    1323                         RT_ZERO(creationCtx);
    1324 
    1325                         creationCtx.enmSource = pClient->State.enmSource;
    1326 
    1327                         creationCtx.Interface.pfnTransferOpen  = shclSvcTransferOpen;
    1328                         creationCtx.Interface.pfnTransferClose = shclSvcTransferClose;
    1329                         creationCtx.Interface.pfnListOpen      = shclSvcTransferListOpen;
    1330                         creationCtx.Interface.pfnListClose     = shclSvcTransferListClose;
    1331                         creationCtx.Interface.pfnObjOpen       = shclSvcTransferObjOpen;
    1332                         creationCtx.Interface.pfnObjClose      = shclSvcTransferObjClose;
    1333 
    1334                         if (enmDir == SHCLTRANSFERDIR_READ)
    1335                         {
    1336                             creationCtx.Interface.pfnRootsGet        = shclSvcTransferGetRoots;
    1337                             creationCtx.Interface.pfnListHdrRead     = shclSvcTransferListHdrRead;
    1338                             creationCtx.Interface.pfnListEntryRead   = shclSvcTransferListEntryRead;
    1339                             creationCtx.Interface.pfnObjRead         = shclSvcTransferObjRead;
    1340                         }
    1341                         else
    1342                         {
    1343                             AssertFailed();
    1344                         }
    1345 
    1346                         creationCtx.pvUser = pClient;
    1347 
    1348                         /* Register needed callbacks so that we can wait for the meta data to arrive here. */
    1349                         SHCLTRANSFERCALLBACKS Callbacks;
    1350                         RT_ZERO(Callbacks);
    1351 
    1352                         Callbacks.pvUser                = pClient;
    1353 
    1354                         Callbacks.pfnTransferPrepare    = VBoxSvcClipboardTransferPrepareCallback;
    1355                         Callbacks.pfnTransferComplete   = VBoxSvcClipboardTransferCompleteCallback;
    1356                         Callbacks.pfnTransferCanceled   = VBoxSvcClipboardTransferCanceledCallback;
    1357                         Callbacks.pfnTransferError      = VBoxSvcClipboardTransferErrorCallback;
    1358 
    1359                         SharedClipboardTransferSetCallbacks(pTransfer, &Callbacks);
    1360 
    1361                         rc = SharedClipboardTransferSetInterface(pTransfer, &creationCtx);
    1362                         if (RT_SUCCESS(rc))
    1363                             rc = SharedClipboardTransferCtxTransferAdd(&pClient->URI, pTransfer);
    1364                     }
    1365 
    1366                     if (RT_SUCCESS(rc))
    1367                     {
    1368                         rc = ShClSvcImplTransferCreate(pClient, pTransfer);
    1369                         if (RT_SUCCESS(rc))
    1370                             rc = ShClSvcImplFormatAnnounce(pClient, VBOX_SHCL_FMT_URI_LIST);
    1371                     }
    1372 
    1373                     if (RT_FAILURE(rc))
    1374                     {
    1375                         ShClSvcImplTransferDestroy(pClient, pTransfer);
    1376                         SharedClipboardTransferDestroy(pTransfer);
    1377                     }
    1378                 }
    1379             }
    1380 
    1381             LogFlowFunc(("[Client %RU32] VBOX_SHCL_GUEST_FN_STATUS: %Rrc\n", pClient->uClientID, rc));
    1382 
    1383             if (RT_FAILURE(rc))
    1384                 LogRel(("Shared Clipboard: Initializing transfer failed with %Rrc\n", rc));
    1385 
    1386             break;
    1387         }
    1388 #endif
    1389 
    1390         case VBOX_SHCL_GUEST_FN_REPLY:
    1391         {
    1392             rc = shclSvcTransferHandleReply(pClient, pTransfer, cParms, paParms);
    1393             break;
    1394         }
    1395 
    1396         case VBOX_SHCL_GUEST_FN_ROOT_LIST_HDR_READ:
    1397         {
     1371            SHCLROOTLISTHDR rootListHdr;
     1372            RT_ZERO(rootListHdr);
     1373
     1374            rootListHdr.cRoots = SharedClipboardTransferRootsCount(pTransfer);
     1375
     1376            HGCMSvcSetU32(&paParms[0], 0 /* Context ID */);
     1377            HGCMSvcSetU32(&paParms[1], rootListHdr.fRoots);
     1378            HGCMSvcSetU32(&paParms[2], rootListHdr.cRoots);
     1379
     1380            rc = VINF_SUCCESS;
    13981381            break;
    13991382        }
    … …  
    14241407        case VBOX_SHCL_GUEST_FN_ROOT_LIST_ENTRY_READ:
    14251408        {
    1426     #if 0
    1427             SHCLROOTLISTENTRY lstEntry;
    1428             rc = VBoxSvcClipboardGetRootListEntry(cParms, paParms, &lstEntry);
    1429             if (RT_SUCCESS(rc))
    1430             {
    1431                 void    *pvData = SharedClipboardTransferRootListEntryDup(&lstEntry);
    1432                 uint32_t cbData = sizeof(SHCLROOTLISTENTRY);
    1433 
    1434                 PSHCLTRANSFERPAYLOAD pPayload;
    1435                 rc = SharedClipboardTransferPayloadAlloc(SHCLTRANSFEREVENTTYPE_ROOT_LIST_HDR_READ,
    1436                                                             pvData, cbData, &pPayload);
     1409            if (cParms != VBOX_SHCL_CPARMS_ROOT_LIST_ENTRY_READ)
     1410                break;
     1411
     1412            /* paParms[1] contains fInfo flags, currently unused. */
     1413            uint32_t uIndex;
     1414            rc = HGCMSvcGetU32(&paParms[2], &uIndex);
     1415            if (RT_SUCCESS(rc))
     1416            {
     1417                SHCLROOTLISTENTRY rootListEntry;
     1418                rc = SharedClipboardTransferRootsEntry(pTransfer, uIndex, &rootListEntry);
    14371419                if (RT_SUCCESS(rc))
    1438                     rc = SharedClipboardTransferEventSignal(pTransfer, SHCLTRANSFEREVENTTYPE_ROOT_LIST_HDR_READ,
    1439                                                             pPayload);
    1440             }
    1441             break;
    1442     #endif
     1420                {
     1421                    HGCMSvcSetPv (&paParms[3], rootListEntry.pszName, rootListEntry.cbName);
     1422                    HGCMSvcSetU32(&paParms[4], rootListEntry.cbName);
     1423                    HGCMSvcSetPv (&paParms[5], rootListEntry.pvInfo, rootListEntry.cbInfo);
     1424                }
     1425            }
     1426            break;
    14431427        }
    14441428

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

    r80995 r81025  
    3232
    3333
    34 #ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    35 /**
    36  * Returns whether a HGCM message is allowed in a certain service mode or not.
    37  *
    38  * @returns \c true if message is allowed, \c false if not.
    39  * @param   uMode               Service mode to check allowance for.
    40  * @param   uMsg                HGCM message to check allowance for.
    41  */
    42 bool vboxSvcClipboardURIMsgIsAllowed(uint32_t uMode, uint32_t uMsg)
    43 {
    44     const bool fHostToGuest =    uMode == VBOX_SHCL_MODE_HOST_TO_GUEST
    45                               || uMode == VBOX_SHCL_MODE_BIDIRECTIONAL;
    46 
    47     const bool fGuestToHost =    uMode == VBOX_SHCL_MODE_GUEST_TO_HOST
    48                               || uMode == VBOX_SHCL_MODE_BIDIRECTIONAL;
    49 
    50     bool fAllowed = false; /* If in doubt, don't allow. */
    51 
    52     switch (uMsg)
    53     {
    54         case VBOX_SHCL_GUEST_FN_LIST_OPEN:
    55             RT_FALL_THROUGH();
    56         case VBOX_SHCL_GUEST_FN_LIST_CLOSE:
    57             RT_FALL_THROUGH();
    58         case VBOX_SHCL_GUEST_FN_LIST_HDR_READ:
    59             RT_FALL_THROUGH();
    60         case VBOX_SHCL_GUEST_FN_LIST_ENTRY_READ:
    61             RT_FALL_THROUGH();
    62         case VBOX_SHCL_GUEST_FN_OBJ_OPEN:
    63             RT_FALL_THROUGH();
    64         case VBOX_SHCL_GUEST_FN_OBJ_CLOSE:
    65             RT_FALL_THROUGH();
    66         case VBOX_SHCL_GUEST_FN_OBJ_READ:
    67             fAllowed = fHostToGuest;
    68             break;
    69 
    70         case VBOX_SHCL_GUEST_FN_MSG_PEEK_WAIT:
    71             RT_FALL_THROUGH();
    72         case VBOX_SHCL_GUEST_FN_MSG_PEEK_NOWAIT:
    73             RT_FALL_THROUGH();
    74         case VBOX_SHCL_GUEST_FN_MSG_GET:
    75             RT_FALL_THROUGH();
    76         case VBOX_SHCL_GUEST_FN_STATUS:
    77             RT_FALL_THROUGH();
    78         case VBOX_SHCL_GUEST_FN_CANCEL:
    79             RT_FALL_THROUGH();
    80         case VBOX_SHCL_GUEST_FN_ERROR:
    81             fAllowed = fHostToGuest || fGuestToHost;
    82             break;
    83 
    84         default:
    85             break;
    86     }
    87 
    88     fAllowed = true; /** @todo FIX !!!! */
    89 
    90     LogFlowFunc(("uMsg=%RU32, uMode=%RU32 -> fAllowed=%RTbool\n", uMsg, uMode, fAllowed));
    91     return fAllowed;
    92 }
    93 
    94 #if 0
    95 int vboxSvcClipboardURIReportMsg(PSHCLCLIENT pClient, uint32_t uMsg, uint32_t uParm)
    96 {
    97     AssertPtrReturn(pClient, VERR_INVALID_POINTER);
    98 
    99     int rc = VINF_SUCCESS;
    100 
    101     switch (uMsg)
    102     {
    103         case VBOX_SHCL_HOST_MSG_TRANSFER_TRANSFER_START:
    104         {
    105             Assert(pClient->State.URI.fTransferStart == false);
    106 
    107             LogFlowFunc(("VBOX_SHCL_HOST_MSG_TRANSFER_TRANSFER_START\n"));
    108 
    109             if (   shclSvcGetMode() != VBOX_SHCL_MODE_HOST_TO_GUEST
    110                 && shclSvcGetMode() != VBOX_SHCL_MODE_BIDIRECTIONAL)
    111             {
    112                 LogFlowFunc(("Wrong clipboard mode, skipping\n"));
    113                 break;
    114             }
    115 
    116             pClient->State.URI.fTransferStart = true;
    117             pClient->State.URI.enmTransferDir = (SHCLTRANSFERDIR)uParm;
    118             break;
    119 
    120         }
    121 
    122         default:
    123             AssertMsgFailed(("Invalid message %RU32\n", uMsg));
    124             rc = VERR_INVALID_PARAMETER;
    125             break;
    126     }
    127 
    128     LogFlowFuncLeaveRC(rc);
    129     return rc;
    130 }
    131 
    132 bool shclSvcTransferReturnMsg(PSHCLCLIENT pClient, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    133 {
    134     RT_NOREF(pClient, cParms, paParms);
    135 
    136     bool fHandled = false;
    137 
    138     if (   pClient->State.URI.fTransferStart
    139         && cParms >= 2)
    140     {
    141         HGCMSvcSetU32(&paParms[0], VBOX_SHCL_HOST_MSG_TRANSFER_TRANSFER_START);
    142         HGCMSvcSetU32(&paParms[1], pClient->State.URI.enmTransferDir);
    143         pClient->State.URI.fTransferStart = false;
    144 
    145         fHandled = true;
    146     }
    147 
    148     LogFlowFunc(("fHandled=%RTbool\n", fHandled));
    149     return fHandled;
    150 }
    151 #endif
    152 #endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
    153 
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