Changeset 55422 in vbox for trunk/src/VBox/Main/src-client

Timestamp:

Apr 24, 2015 1:52:33 PM (10 years ago)

Author:

vboxsync

Message:

DnD: Protocol overhaul with versioning added which now can communicate with Main.

Location:

trunk/src/VBox/Main/src-client

Files:

• GuestDnDPrivate.cpp (modified) (19 diffs)
• GuestDnDSourceImpl.cpp (modified) (15 diffs)
• GuestDnDTargetImpl.cpp (modified) (20 diffs)

trunk/src/VBox/Main/src-client/GuestDnDPrivate.cpp

@@ -6 +6 @@
 
 /*
- * Copyright (C) 2011-2014 Oracle Corporation
+ * Copyright (C) 2011-2015 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -37 +37 @@
 # include <VBox/GuestHost/DragAndDrop.h>
 # include <VBox/HostServices/DragAndDropSvc.h>
+# include <VBox/version.h>
 
 # ifdef LOG_GROUP
@@ -167 +168 @@
     , m_cbDataCurrent(0)
     , m_cbDataTotal(0)
-    , m_hFile(NIL_RTFILE)
     , m_parent(pGuest)
 {
     int rc = RTSemEventCreate(&m_EventSem);
-    AssertRC(rc);
+    if (RT_FAILURE(rc))
+        throw rc;
 }
 
@@ -242 +243 @@
 }
 
-int GuestDnDResponse::notifyAboutGuestResponse(void)
+int GuestDnDResponse::notifyAboutGuestResponse(void) const
 {
     return RTSemEventSignal(m_EventSem);
@@ -262 +263 @@
         m_pvData = NULL;
     }
-    m_cbData = 0;
+
+    m_cbData        = 0;
     m_cbDataCurrent = 0;
-    m_cbDataTotal = 0;
-
-    if (m_hFile != NIL_RTFILE)
-    {
-        RTFileClose(m_hFile);
-        m_hFile = NIL_RTFILE;
-    }
-    m_strFile = "";
+    m_cbDataTotal   = 0;
 }
 
@@ -280 +275 @@
     if (SUCCEEDED(rc))
     {
-        rc = m_progress->init(static_cast<IGuest*>(pParent),
+        rc = m_progress->init(static_cast<IGuest *>(pParent),
                               Bstr(pParent->tr("Dropping data")).raw(),
-                              FALSE /* fCancelable */);
+                              TRUE /* aCancelable */);
     }
     return rc;
 }
 
+bool GuestDnDResponse::isProgressCanceled(void) const
+{
+    BOOL fCanceled;
+    if (!m_progress.isNull())
+    {
+        HRESULT hr = m_progress->COMGETTER(Canceled)(&fCanceled);
+        AssertComRC(hr);
+    }
+    else fCanceled = TRUE;
+
+    return RT_BOOL(fCanceled);
+}
+
+int GuestDnDResponse::setCallback(uint32_t uMsg, PFNGUESTDNDCALLBACK pfnCallback, void *pvUser /* = NULL */)
+{
+    GuestDnDCallbackMap::const_iterator it = m_mapCallbacks.find(uMsg);
+
+    /* Add. */
+    if (pfnCallback)
+    {
+        if (it == m_mapCallbacks.end())
+        {
+            m_mapCallbacks[uMsg] = GuestDnDCallback(pfnCallback, uMsg, pvUser);
+            return VINF_SUCCESS;
+        }
+
+        AssertMsgFailed(("Callback for message %RU32 already registered\n", uMsg));
+        return VERR_ALREADY_EXISTS;
+    }
+
+    /* Remove. */
+    if (it != m_mapCallbacks.end())
+        m_mapCallbacks.erase(it);
+
+    return VINF_SUCCESS;
+}
+
 int GuestDnDResponse::setProgress(unsigned uPercentage,
-                                  uint32_t uState, int rcOp /* = VINF_SUCCESS */)
-{
-    LogFlowFunc(("uPercentage=%RU32, uState=%RU32, rcOp=%Rrc\n",
-                 uPercentage, uState, rcOp));
+                                  uint32_t uStatus, int rcOp /* = VINF_SUCCESS */)
+{
+    LogFlowFunc(("uStatus=%RU32, uPercentage=%RU32, rcOp=%Rrc\n",
+                 uStatus, uPercentage, rcOp));
 
     int vrc = VINF_SUCCESS;
@@ -298 +330 @@
         BOOL fCompleted;
         HRESULT hr = m_progress->COMGETTER(Completed)(&fCompleted);
+        AssertComRC(hr);
+
+        BOOL fCanceled;
+        hr = m_progress->COMGETTER(Canceled)(&fCanceled);
+        AssertComRC(hr);
+
+        LogFlowFunc(("fCompleted=%RTbool, fCanceled=%RTbool\n", fCompleted, fCanceled));
+
         if (!fCompleted)
         {
-            if (uState == DragAndDropSvc::DND_PROGRESS_ERROR)
+            switch (uStatus)
             {
-                hr = m_progress->i_notifyComplete(VBOX_E_IPRT_ERROR,
-                                                  COM_IIDOF(IGuest),
-                                                  m_parent->getComponentName(),
-                                                  GuestDnDResponse::errorToString(m_parent, rcOp).c_str());
-                reset();
-            }
-            else if (uState == DragAndDropSvc::DND_PROGRESS_CANCELLED)
-            {
-                hr = m_progress->Cancel();
-                if (SUCCEEDED(hr))
-                    vrc = VERR_CANCELLED;
-
-                reset();
-            }
-            else /* uState == DragAndDropSvc::DND_PROGRESS_RUNNING */
-            {
-                hr = m_progress->SetCurrentOperationProgress(uPercentage);
-                AssertComRC(hr);
-                if (   uState      == DragAndDropSvc::DND_PROGRESS_COMPLETE
-                    || uPercentage >= 100)
+                case DragAndDropSvc::DND_PROGRESS_ERROR:
+                {
+                    hr = m_progress->i_notifyComplete(VBOX_E_IPRT_ERROR,
+                                                      COM_IIDOF(IGuest),
+                                                      m_parent->getComponentName(),
+                                                      GuestDnDResponse::errorToString(m_parent, rcOp).c_str());
+                    reset();
+                    break;
+                }
+
+                case DragAndDropSvc::DND_PROGRESS_CANCELLED:
+                {
                     hr = m_progress->i_notifyComplete(S_OK);
+                    AssertComRC(hr);
+
+                    reset();
+                    break;
+                }
+
+                case DragAndDropSvc::DND_PROGRESS_RUNNING:
+                case DragAndDropSvc::DND_PROGRESS_COMPLETE:
+                {
+                    if (!fCanceled)
+                    {
+                        hr = m_progress->SetCurrentOperationProgress(uPercentage);
+                        AssertComRC(hr);
+                        if (   uStatus     == DragAndDropSvc::DND_PROGRESS_COMPLETE
+                            || uPercentage >= 100)
+                        {
+                            hr = m_progress->i_notifyComplete(S_OK);
+                            AssertComRC(hr);
+                        }
+                    }
+                    break;
+                }
+
+                default:
+                    break;
             }
         }
     }
 
+    LogFlowFuncLeaveRC(vrc);
     return vrc;
 }
@@ -348 +406 @@
     /** @todo Don't use anonymous enums (uint32_t). */
     uint32_t uStatus = DragAndDropSvc::DND_PROGRESS_RUNNING;
-    if (m_cbDataCurrent >= m_cbDataTotal)
-        uStatus = DragAndDropSvc::DND_PROGRESS_COMPLETE;
-
-#ifdef DEBUG_andy
-    LogFlowFunc(("Updating transfer status (%zu/%zu), status=%ld\n",
-                 m_cbDataCurrent, m_cbDataTotal, uStatus));
-#else
+    Assert(m_cbDataCurrent <= m_cbDataTotal);
+    if (m_cbDataCurrent >= m_cbDataTotal) uStatus = DragAndDropSvc::DND_PROGRESS_COMPLETE;
+
+    LogFlowFunc(("Updating transfer status (%zu/%zu), status=%ld\n", m_cbDataCurrent, m_cbDataTotal, uStatus));
     AssertMsg(m_cbDataCurrent <= m_cbDataTotal,
               ("More data transferred (%zu) than initially announced (%zu), cbDataAdd=%zu\n",
-              m_cbDataCurrent, m_cbDataTotal, cbDataAdd));
-#endif
+               m_cbDataCurrent, m_cbDataTotal, cbDataAdd));
+
     int rc = setProgress(cPercentage, uStatus);
 
@@ -364 +419 @@
      *        guest should first clean up stuff itself and than really confirm
      *        the cancel request by an extra message. */
-    if (rc == VERR_CANCELLED)
-        rc = setProgress(100, DragAndDropSvc::DND_PROGRESS_CANCELLED);
+    if (rc == VERR_CANCELLED) rc = setProgress(100, DragAndDropSvc::DND_PROGRESS_CANCELLED);
 
     LogFlowFuncLeaveRC(rc);
@@ -371 +425 @@
 }
 
+int GuestDnDResponse::onDispatch(uint32_t u32Function, void *pvParms, uint32_t cbParms)
+{
+    LogFlowFunc(("u32Function=%RU32, pvParms=%p, cbParms=%RU32\n", u32Function, pvParms, cbParms));
+
+    int rc = VERR_WRONG_ORDER; /* Play safe. */
+    bool fTryCallbacks = false;
+
+    switch (u32Function)
+    {
+        case DragAndDropSvc::GUEST_DND_HG_ACK_OP:
+        {
+            DragAndDropSvc::PVBOXDNDCBHGACKOPDATA pCBData = reinterpret_cast<DragAndDropSvc::PVBOXDNDCBHGACKOPDATA>(pvParms);
+            AssertPtr(pCBData);
+            AssertReturn(sizeof(DragAndDropSvc::VBOXDNDCBHGACKOPDATA) == cbParms, VERR_INVALID_PARAMETER);
+            AssertReturn(DragAndDropSvc::CB_MAGIC_DND_HG_ACK_OP == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
+
+            setDefAction(pCBData->uAction);
+            rc = notifyAboutGuestResponse();
+            break;
+        }
+
+        case DragAndDropSvc::GUEST_DND_HG_REQ_DATA:
+        {
+            DragAndDropSvc::PVBOXDNDCBHGREQDATADATA pCBData = reinterpret_cast<DragAndDropSvc::PVBOXDNDCBHGREQDATADATA>(pvParms);
+            AssertPtr(pCBData);
+            AssertReturn(sizeof(DragAndDropSvc::VBOXDNDCBHGREQDATADATA) == cbParms, VERR_INVALID_PARAMETER);
+            AssertReturn(DragAndDropSvc::CB_MAGIC_DND_HG_REQ_DATA == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
+
+            setFormat(pCBData->pszFormat);
+            rc = notifyAboutGuestResponse();
+            break;
+        }
+
+        case DragAndDropSvc::GUEST_DND_HG_EVT_PROGRESS:
+        {
+            DragAndDropSvc::PVBOXDNDCBHGEVTPROGRESSDATA pCBData =
+               reinterpret_cast<DragAndDropSvc::PVBOXDNDCBHGEVTPROGRESSDATA>(pvParms);
+            AssertPtr(pCBData);
+            AssertReturn(sizeof(DragAndDropSvc::VBOXDNDCBHGEVTPROGRESSDATA) == cbParms, VERR_INVALID_PARAMETER);
+            AssertReturn(DragAndDropSvc::CB_MAGIC_DND_HG_EVT_PROGRESS == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
+
+            rc = setProgress(pCBData->uPercentage, pCBData->uStatus, pCBData->rc);
+            if (RT_SUCCESS(rc))
+                rc = notifyAboutGuestResponse();
+            break;
+        }
+#ifdef VBOX_WITH_DRAG_AND_DROP_GH
+        case DragAndDropSvc::GUEST_DND_GH_ACK_PENDING:
+        {
+            DragAndDropSvc::PVBOXDNDCBGHACKPENDINGDATA pCBData =
+               reinterpret_cast<DragAndDropSvc::PVBOXDNDCBGHACKPENDINGDATA>(pvParms);
+            AssertPtr(pCBData);
+            AssertReturn(sizeof(DragAndDropSvc::VBOXDNDCBGHACKPENDINGDATA) == cbParms, VERR_INVALID_PARAMETER);
+            AssertReturn(DragAndDropSvc::CB_MAGIC_DND_GH_ACK_PENDING == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
+
+            setFormat    (pCBData->pszFormat);
+            setDefAction (pCBData->uDefAction);
+            setAllActions(pCBData->uAllActions);
+
+            rc = notifyAboutGuestResponse();
+            break;
+        }
+#endif /* VBOX_WITH_DRAG_AND_DROP_GH */
+        default:
+            /* * Try if the event is covered by a registered callback. */
+            fTryCallbacks = true;
+            break;
+    }
+
+    /*
+     * Try the host's installed callbacks (if any).
+     */
+    if (fTryCallbacks)
+    {
+        GuestDnDCallbackMap::const_iterator it = m_mapCallbacks.find(u32Function);
+        if (it != m_mapCallbacks.end())
+        {
+            AssertPtr(it->second.pfnCallback);
+            rc = it->second.pfnCallback(u32Function, pvParms, cbParms, it->second.pvUser);
+        }
+        else
+            rc = VERR_NO_DATA; /* Tell the guest. */
+    }
+
+    LogFlowFunc(("Returning rc=%Rrc\n", rc));
+    return rc;
+}
+
 HRESULT GuestDnDResponse::queryProgressTo(IProgress **ppProgress)
 {
@@ -376 +518 @@
 }
 
-int GuestDnDResponse::waitForGuestResponse(RTMSINTERVAL msTimeout /*= 500 */)
+int GuestDnDResponse::waitForGuestResponse(RTMSINTERVAL msTimeout /*= 500 */) const
 {
     int rc = RTSemEventWait(m_EventSem, msTimeout);
@@ -382 +524 @@
     LogFlowFunc(("msTimeout=%RU32, rc=%Rrc\n", msTimeout, rc));
 #endif
-    return rc;
-}
-
-int GuestDnDResponse::writeToFile(const char *pszPath, size_t cbPath,
-                                  void *pvData, size_t cbData, uint32_t fMode)
-{
-    /** @todo Support locking more than one file at a time! We
-     *        might want to have a table in DnDGuestImpl which
-     *        keeps those file pointers around, or extend the
-     *        actual protocol for explicit open calls.
-     *
-     *        For now we only keep one file open at a time, so if
-     *        a client does alternating writes to different files
-     *        this function will close the old and re-open the new
-     *        file on every call. */
-    int rc;
-    if (   m_hFile == NIL_RTFILE
-        || m_strFile != pszPath)
-    {
-        char *pszFile = RTPathJoinA(m_strDropDir.c_str(), pszPath);
-        if (pszFile)
-        {
-            RTFILE hFile;
-            /** @todo Respect fMode!  */
-            rc = RTFileOpen(&hFile, pszFile,
-                              RTFILE_O_OPEN_CREATE | RTFILE_O_DENY_WRITE
-                            | RTFILE_O_WRITE | RTFILE_O_APPEND);
-            if (RT_SUCCESS(rc))
-            {
-                LogFlowFunc(("Opening \"%s\" (fMode=0x%x) for writing ...\n",
-                             pszFile, fMode));
-
-                m_hFile = hFile;
-                m_strFile = pszPath;
-            }
-
-            RTStrFree(pszFile);
-        }
-        else
-            rc = VERR_NO_MEMORY;
-    }
-    else
-        rc = VINF_SUCCESS;
-
-    if (RT_SUCCESS(rc))
-    {
-        rc = RTFileWrite(m_hFile, pvData, cbData,
-                         NULL /* No partial writes */);
-
-        if (RT_SUCCESS(rc))
-            rc = dataSetStatus(cbData);
-    }
-
     return rc;
 }
@@ -507 +596 @@
         return VERR_COM_OBJECT_NOT_FOUND;
 
-    int rc = pVMMDev->hgcmHostCall("VBoxDragAndDropSvc", u32Function,
-                                   cParms, paParms);
-    LogFlowFunc(("uMsg=%RU32, cParms=%RU32, rc=%Rrc\n",
-                 u32Function, cParms, rc));
+    int rc = pVMMDev->hgcmHostCall("VBoxDragAndDropSvc", u32Function, cParms, paParms);
+    LogFlowFunc(("uMsg=%RU32, cParms=%RU32, rc=%Rrc\n", u32Function, cParms, rc));
     return rc;
 }
+
+/* static */
+DECLCALLBACK(int) GuestDnD::notifyDnDDispatcher(void *pvExtension, uint32_t u32Function,
+                                                void *pvParms, uint32_t cbParms)
+{
+    LogFlowFunc(("pvExtension=%p, u32Function=%RU32, pvParms=%p, cbParms=%RU32\n",
+                 pvExtension, u32Function, pvParms, cbParms));
+
+    GuestDnD *pGuestDnD = reinterpret_cast<GuestDnD*>(pvExtension);
+    AssertPtrReturn(pGuestDnD, VERR_INVALID_POINTER);
+
+    /** @todo In case we need to handle multiple guest DnD responses at a time this
+     *        would be the place to lookup and dispatch to those. For the moment we
+     *        only have one response -- simple. */
+    GuestDnDResponse *pResp = pGuestDnD->m_pResponse;
+    if (pResp)
+        return pResp->onDispatch(u32Function, pvParms, cbParms);
+
+    return VERR_NOT_SUPPORTED;
+}
+
 
 /* static */
@@ -637 +745 @@
 }
 
-/* static */
-DECLCALLBACK(int) GuestDnD::notifyDnDDispatcher(void *pvExtension, uint32_t u32Function,
-                                                void *pvParms, uint32_t cbParms)
-{
-    LogFlowFunc(("pvExtension=%p, u32Function=%RU32, pvParms=%p, cbParms=%RU32\n",
-                 pvExtension, u32Function, pvParms, cbParms));
-
-    GuestDnD *pGuestDnD = reinterpret_cast<GuestDnD*>(pvExtension);
-    AssertPtrReturn(pGuestDnD, VERR_INVALID_POINTER);
-
-    GuestDnDResponse *pResp = pGuestDnD->m_pResponse;
-    AssertPtrReturn(pResp, VERR_INVALID_POINTER);
-
-    int rc;
-    switch (u32Function)
-    {
-        case DragAndDropSvc::GUEST_DND_HG_ACK_OP:
-        {
-            DragAndDropSvc::PVBOXDNDCBHGACKOPDATA pCBData = reinterpret_cast<DragAndDropSvc::PVBOXDNDCBHGACKOPDATA>(pvParms);
-            AssertPtr(pCBData);
-            AssertReturn(sizeof(DragAndDropSvc::VBOXDNDCBHGACKOPDATA) == cbParms, VERR_INVALID_PARAMETER);
-            AssertReturn(DragAndDropSvc::CB_MAGIC_DND_HG_ACK_OP == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
-
-            pResp->setDefAction(pCBData->uAction);
-
-            rc = pResp->notifyAboutGuestResponse();
-            break;
-        }
-
-        case DragAndDropSvc::GUEST_DND_HG_REQ_DATA:
-        {
-            DragAndDropSvc::PVBOXDNDCBHGREQDATADATA pCBData = reinterpret_cast<DragAndDropSvc::PVBOXDNDCBHGREQDATADATA>(pvParms);
-            AssertPtr(pCBData);
-            AssertReturn(sizeof(DragAndDropSvc::VBOXDNDCBHGREQDATADATA) == cbParms, VERR_INVALID_PARAMETER);
-            AssertReturn(DragAndDropSvc::CB_MAGIC_DND_HG_REQ_DATA == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
-
-            pResp->setFormat(pCBData->pszFormat);
-
-            rc = pResp->notifyAboutGuestResponse();
-            break;
-        }
-
-        case DragAndDropSvc::GUEST_DND_HG_EVT_PROGRESS:
-        {
-            DragAndDropSvc::PVBOXDNDCBHGEVTPROGRESSDATA pCBData =
-                reinterpret_cast <DragAndDropSvc::PVBOXDNDCBHGEVTPROGRESSDATA>(pvParms);
-            AssertPtr(pCBData);
-            AssertReturn(sizeof(DragAndDropSvc::VBOXDNDCBHGEVTPROGRESSDATA) == cbParms, VERR_INVALID_PARAMETER);
-            AssertReturn(DragAndDropSvc::CB_MAGIC_DND_HG_EVT_PROGRESS == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
-
-            rc = pResp->setProgress(pCBData->uPercentage, pCBData->uState, pCBData->rc);
-            break;
-        }
-
-# ifdef VBOX_WITH_DRAG_AND_DROP_GH
-        case DragAndDropSvc::GUEST_DND_GH_ACK_PENDING:
-        {
-            DragAndDropSvc::PVBOXDNDCBGHACKPENDINGDATA pCBData =
-                reinterpret_cast <DragAndDropSvc::PVBOXDNDCBGHACKPENDINGDATA>(pvParms);
-            AssertPtr(pCBData);
-            AssertReturn(sizeof(DragAndDropSvc::VBOXDNDCBGHACKPENDINGDATA) == cbParms, VERR_INVALID_PARAMETER);
-            AssertReturn(DragAndDropSvc::CB_MAGIC_DND_GH_ACK_PENDING == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
-
-            pResp->setFormat(pCBData->pszFormat);
-            pResp->setDefAction(pCBData->uDefAction);
-            pResp->setAllActions(pCBData->uAllActions);
-
-            rc = pResp->notifyAboutGuestResponse();
-            break;
-        }
-
-        case DragAndDropSvc::GUEST_DND_GH_SND_DATA:
-        {
-            DragAndDropSvc::PVBOXDNDCBSNDDATADATA pCBData = reinterpret_cast<DragAndDropSvc::PVBOXDNDCBSNDDATADATA>(pvParms);
-            AssertPtr(pCBData);
-            AssertReturn(sizeof(DragAndDropSvc::VBOXDNDCBSNDDATADATA) == cbParms, VERR_INVALID_PARAMETER);
-            AssertReturn(DragAndDropSvc::CB_MAGIC_DND_GH_SND_DATA == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
-
-            rc = pGuestDnD->onGHSendData(pResp, pCBData->pvData, pCBData->cbData,
-                                         pCBData->cbTotalSize);
-            break;
-        }
-
-        case DragAndDropSvc::GUEST_DND_GH_SND_DIR:
-        {
-            DragAndDropSvc::PVBOXDNDCBSNDDIRDATA pCBData = reinterpret_cast<DragAndDropSvc::PVBOXDNDCBSNDDIRDATA>(pvParms);
-            AssertPtr(pCBData);
-            AssertReturn(sizeof(DragAndDropSvc::VBOXDNDCBSNDDIRDATA) == cbParms, VERR_INVALID_PARAMETER);
-            AssertReturn(DragAndDropSvc::CB_MAGIC_DND_GH_SND_DIR == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
-
-            rc = pGuestDnD->onGHSendDir(pResp, pCBData->pszPath, pCBData->cbPath, pCBData->fMode);
-            break;
-        }
-
-        case DragAndDropSvc::GUEST_DND_GH_SND_FILE:
-        {
-            DragAndDropSvc::PVBOXDNDCBSNDFILEDATA pCBData = reinterpret_cast<DragAndDropSvc::PVBOXDNDCBSNDFILEDATA>(pvParms);
-            AssertPtr(pCBData);
-            AssertReturn(sizeof(DragAndDropSvc::VBOXDNDCBSNDFILEDATA) == cbParms, VERR_INVALID_PARAMETER);
-            AssertReturn(DragAndDropSvc::CB_MAGIC_DND_GH_SND_FILE == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
-
-            rc = pGuestDnD->onGHSendFile(pResp, pCBData->pszFilePath, pCBData->cbFilePath,
-                                         pCBData->pvData, pCBData->cbData, pCBData->fMode);
-            break;
-        }
-
-        case DragAndDropSvc::GUEST_DND_GH_EVT_ERROR:
-        {
-            DragAndDropSvc::PVBOXDNDCBEVTERRORDATA pCBData = reinterpret_cast<DragAndDropSvc::PVBOXDNDCBEVTERRORDATA>(pvParms);
-            AssertPtr(pCBData);
-            AssertReturn(sizeof(DragAndDropSvc::VBOXDNDCBEVTERRORDATA) == cbParms, VERR_INVALID_PARAMETER);
-            AssertReturn(DragAndDropSvc::CB_MAGIC_DND_GH_EVT_ERROR == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
-
-            /* Cleanup. */
-            pResp->reset();
-            rc = pResp->setProgress(100, DragAndDropSvc::DND_PROGRESS_ERROR, pCBData->rc);
-            break;
-        }
-# endif /* VBOX_WITH_DRAG_AND_DROP_GH */
-        default:
-            rc = VERR_NOT_SUPPORTED; /* Tell the guest. */
-            break;
-    }
-
-    LogFlowFunc(("Returning rc=%Rrc\n", rc));
-    return rc;
-}
-
-# ifdef VBOX_WITH_DRAG_AND_DROP_GH
-int GuestDnD::onGHSendData(GuestDnDResponse *pResp,
-                           const void *pvData, size_t cbData, size_t cbTotalSize)
-{
-    AssertPtrReturn(pResp, VERR_INVALID_POINTER);
-    AssertPtrReturn(pvData, VERR_INVALID_POINTER);
-    AssertReturn(cbData, VERR_INVALID_PARAMETER);
-    AssertReturn(cbTotalSize, VERR_INVALID_PARAMETER);
-
-    int rc = pResp->dataAdd(pvData, cbData, NULL /* Current size */);
-    if (RT_SUCCESS(rc))
-        rc = pResp->dataSetStatus(cbData, cbTotalSize);
-
-    LogFlowFuncLeaveRC(rc);
-    return rc;
-}
-
-int GuestDnD::onGHSendDir(GuestDnDResponse *pResp,
-                          const char *pszPath, size_t cbPath, uint32_t fMode)
-{
-    AssertPtrReturn(pResp, VERR_INVALID_POINTER);
-    AssertPtrReturn(pszPath, VERR_INVALID_POINTER);
-    AssertReturn(cbPath, VERR_INVALID_PARAMETER);
-
-    LogFlowFunc(("pszPath=%s, cbPath=%zu, fMode=0x%x\n",
-                 pszPath, cbPath, fMode));
-
-    int rc;
-    char *pszDir = RTPathJoinA(pResp->dropDir().c_str(), pszPath);
-    if (pszDir)
-    {
-        rc = RTDirCreateFullPath(pszDir, fMode);
-        RTStrFree(pszDir);
-    }
-    else
-        rc = VERR_NO_MEMORY;
-
-    if (RT_SUCCESS(rc))
-        rc = pResp->dataSetStatus(cbPath);
-
-    LogFlowFuncLeaveRC(rc);
-    return rc;
-}
-
-int GuestDnD::onGHSendFile(GuestDnDResponse *pResp,
-                           const char *pszPath, size_t cbPath,
-                           void *pvData, size_t cbData, uint32_t fMode)
-{
-    AssertPtrReturn(pResp, VERR_INVALID_POINTER);
-    AssertPtrReturn(pszPath, VERR_INVALID_POINTER);
-    AssertReturn(cbPath, VERR_INVALID_PARAMETER);
-
-    LogFlowFunc(("pszPath=%s, cbPath=%zu, fMode=0x%x\n",
-                 pszPath, cbPath, fMode));
-
-    int rc = pResp->writeToFile(pszPath, cbPath,
-                                pvData, cbData, fMode);
-    LogFlowFuncLeaveRC(rc);
-    return rc;
-}
-# endif /* VBOX_WITH_DRAG_AND_DROP_GH */
-
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -834 +752 @@
 }
 
-HRESULT GuestDnDBase::isFormatSupported(const com::Utf8Str &aFormat, BOOL *aSupported)
+HRESULT GuestDnDBase::i_isFormatSupported(const com::Utf8Str &aFormat, BOOL *aSupported)
 {
     *aSupported = std::find(m_strFormats.begin(),
@@ -842 +760 @@
 }
 
-HRESULT GuestDnDBase::getFormats(std::vector<com::Utf8Str> &aFormats)
+HRESULT GuestDnDBase::i_getFormats(std::vector<com::Utf8Str> &aFormats)
 {
     aFormats = m_strFormats;
@@ -849 +767 @@
 }
 
-HRESULT GuestDnDBase::addFormats(const std::vector<com::Utf8Str> &aFormats)
+HRESULT GuestDnDBase::i_addFormats(const std::vector<com::Utf8Str> &aFormats)
 {
     for (size_t i = 0; i < aFormats.size(); ++i)
@@ -864 +782 @@
 }
 
-HRESULT GuestDnDBase::removeFormats(const std::vector<com::Utf8Str> &aFormats)
+HRESULT GuestDnDBase::i_removeFormats(const std::vector<com::Utf8Str> &aFormats)
 {
     for (size_t i = 0; i < aFormats.size(); ++i)
@@ -878 +796 @@
 }
 
+HRESULT GuestDnDBase::i_getProtocolVersion(ULONG *puVersion)
+{
+    int rc = getProtocolVersion((uint32_t *)puVersion);
+    return RT_SUCCESS(rc) ? S_OK : E_FAIL;
+}
+
+int GuestDnDBase::getProtocolVersion(uint32_t *puVersion)
+{
+    AssertPtrReturn(puVersion, VERR_INVALID_POINTER);
+
+    int rc;
+
+    uint32_t uVer, uVerAdditions = 0;
+    if (   m_pGuest
+        && (uVerAdditions = m_pGuest->i_getAdditionsVersion()) > 0)
+    {
+        uint32_t uVBoxMajor = VBOX_FULL_VERSION_GET_MAJOR(uVerAdditions);
+        uint32_t uVBoxMinor = VBOX_FULL_VERSION_GET_MINOR(uVerAdditions);
+
+#if 0 /*def DEBUG_andy*/
+        /* Hardcode the to-used protocol version; nice for testing side effects. */
+        uVer = 2;
+#else
+        uVer = (  uVBoxMajor  >= 5)
+             ? 2  /* VBox 5.0 and up: Protocol version 2. */
+             : 1; /* VBox <= 4.3:     Protocol version 1. */
+        /* Build revision is ignored. */
+#endif
+
+        LogFlowThisFunc(("uVerAdditions=%RU32 (%RU32.%RU32)\n", uVerAdditions, uVBoxMajor, uVBoxMinor));
+        rc = VINF_SUCCESS;
+    }
+    else
+    {
+        uVer = 1; /* Fallback. */
+        rc = VERR_NOT_FOUND;
+    }
+
+    LogFlowThisFunc(("uVer=%RU32, uVerAdditions=%RU32, rc=%Rrc\n", uVer, uVerAdditions, rc));
+
+    *puVersion = uVer;
+    return rc;
+}
+
+#if 0
+/**
+ * Returns back information (message type + parameter count) of the current message in
+ * the local outgoing message queue.
+ *
+ * @return  IPRT status code.
+ * @param   pThis
+ * @param   puMsg
+ * @param   pcParms
+ * @param   paParms
+ */
+/* static */
+DECLCALLBACK(int) GuestDnDBase::i_getNextMsgCallback(GuestDnDBase *pThis, uint32_t *puMsg,
+                                                     uint32_t *pcParms, PVBOXHGCMSVCPARM paParms)
+{
+    AssertPtrReturn(pThis,   VERR_INVALID_POINTER);
+    AssertPtrReturn(puMsg,   VERR_INVALID_POINTER);
+    AssertPtrReturn(pcParms, VERR_INVALID_POINTER);
+    AssertPtrReturn(paParms, VERR_INVALID_POINTER);
+
+    if (pThis->mData.m_lstOutgoing.empty())
+        return VERR_NO_DATA;
+
+    GuestDnDMsg *pMsg = pThis->mData.m_lstOutgoing.front();
+    AssertPtr(pMsg);
+
+    *puMsg   = pMsg->uMsg;
+    *pcParms = pMsg->cParms;
+
+    return VINF_SUCCESS;
+}
+#endif
 #endif /* VBOX_WITH_DRAG_AND_DROP */
 

trunk/src/VBox/Main/src-client/GuestDnDSourceImpl.cpp

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2014 Oracle Corporation
+ * Copyright (C) 2014-2015 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -27 +27 @@
 #include "AutoCaller.h"
 
+#include <memory>    /* For unique_ptr, seee #7179. */
+
+#include <iprt/dir.h>
+#include <iprt/file.h>
+#include <iprt/path.h>
+
 #include <iprt/cpp/utils.h> /* For unconst(). */
 
@@ -39 +45 @@
 #include <VBox/log.h>
 
+/**
+ * Base class for a source task.
+ */
+class GuestDnDSourceTask
+{
+public:
+
+    GuestDnDSourceTask(GuestDnDSource *pSource)
+        : mSource(pSource),
+          mRC(VINF_SUCCESS) { }
+
+    virtual ~GuestDnDSourceTask(void) { }
+
+    int getRC(void) const { return mRC; }
+    bool isOk(void) const { return RT_SUCCESS(mRC); }
+    const ComObjPtr<GuestDnDSource> &getSource(void) const { return mSource; }
+
+protected:
+
+    const ComObjPtr<GuestDnDSource>     mSource;
+    int                                 mRC;
+};
+
+/**
+ * Task structure for receiving data from a source using
+ * a worker thread.
+ */
+class RecvDataTask : public GuestDnDSourceTask
+{
+public:
+
+    RecvDataTask(GuestDnDSource *pSource, PRECVDATACTX pCtx)
+        : GuestDnDSourceTask(pSource)
+        , mpCtx(pCtx) { }
+
+    virtual ~RecvDataTask(void)
+    {
+        if (mpCtx)
+        {
+            delete mpCtx;
+            mpCtx = NULL;
+        }
+    }
+
+    PRECVDATACTX getCtx(void) { return mpCtx; }
+
+protected:
+
+    /** Pointer to receive data context. */
+    PRECVDATACTX mpCtx;
+};
 
 // constructor / destructor
@@ -95 +152 @@
 /////////////////////////////////////////////////////////////////////////////
 
-HRESULT GuestDnDSource::isFormatSupported(const com::Utf8Str &aFormat,
-                                          BOOL *aSupported)
+HRESULT GuestDnDSource::isFormatSupported(const com::Utf8Str &aFormat, BOOL *aSupported)
 {
 #if !defined(VBOX_WITH_DRAG_AND_DROP) || !defined(VBOX_WITH_DRAG_AND_DROP_GH)
@@ -107 +163 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    return GuestDnDBase::isFormatSupported(aFormat, aSupported);
+    return GuestDnDBase::i_isFormatSupported(aFormat, aSupported);
 #endif /* VBOX_WITH_DRAG_AND_DROP */
 }
@@ -122 +178 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    return GuestDnDBase::getFormats(aFormats);
+    return GuestDnDBase::i_getFormats(aFormats);
 #endif /* VBOX_WITH_DRAG_AND_DROP */
 }
@@ -137 +193 @@
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    return GuestDnDBase::addFormats(aFormats);
+    return GuestDnDBase::i_addFormats(aFormats);
 #endif /* VBOX_WITH_DRAG_AND_DROP */
 }
@@ -152 +208 @@
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    return GuestDnDBase::removeFormats(aFormats);
+    return GuestDnDBase::i_removeFormats(aFormats);
+#endif /* VBOX_WITH_DRAG_AND_DROP */
+}
+
+HRESULT GuestDnDSource::getProtocolVersion(ULONG *aProtocolVersion)
+{
+#if !defined(VBOX_WITH_DRAG_AND_DROP)
+    ReturnComNotImplemented();
+#else /* VBOX_WITH_DRAG_AND_DROP */
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    return GuestDnDBase::i_getProtocolVersion(aProtocolVersion);
 #endif /* VBOX_WITH_DRAG_AND_DROP */
 }
@@ -171 +242 @@
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
+    /* Determine guest DnD protocol to use. */
+    GuestDnDBase::getProtocolVersion(&mData.mProtocolVersion);
+
     /* Default is ignoring the action. */
     DnDAction_T defaultAction = DnDAction_Ignore;
@@ -180 +254 @@
     paParms[i++].setUInt32(uScreenId);
 
-    int rc = GuestDnDInst()->hostCall(DragAndDropSvc::HOST_DND_GH_REQ_PENDING,
-                                      i, paParms);
+    int rc = GuestDnDInst()->hostCall(DragAndDropSvc::HOST_DND_GH_REQ_PENDING, i, paParms);
     if (RT_SUCCESS(rc))
     {
@@ -210 +283 @@
     if (RT_FAILURE(rc))
         hr = setError(VBOX_E_IPRT_ERROR,
-                      tr("Unable to retrieve pending status (%Rrc)\n"), rc);
+                      tr("Unable to retrieve drag'n drop pending status (%Rrc)\n"), rc);
 
     LogFlowFunc(("hr=%Rhrc, defaultAction=0x%x\n", hr, defaultAction));
@@ -238 +311 @@
     HRESULT hr = S_OK;
 
-    const char *pcszFormat = aFormat.c_str();
-    bool fNeedsDropDir = DnDMIMENeedsDropDir(pcszFormat, strlen(pcszFormat));
-    LogFlowFunc(("strFormat=%s, uAction=0x%x, fNeedsDropDir=%RTbool\n",
-                 pcszFormat, uAction, fNeedsDropDir));
-
+    /* Note: At the moment we only support one response at a time. */
     GuestDnDResponse *pResp = GuestDnDInst()->response();
     if (pResp)
     {
-        /* Reset any old data. */
-        pResp->reset();
         pResp->resetProgress(m_pGuest);
 
-        /* Set the format we are going to retrieve to have it around
-         * when retrieving the data later. */
-        pResp->setFormat(aFormat);
-
-        if (fNeedsDropDir)
-        {
-            char szDropDir[RTPATH_MAX];
-            int rc = DnDDirCreateDroppedFiles(szDropDir, sizeof(szDropDir));
-            LogFlowFunc(("rc=%Rrc, szDropDir=%s\n", rc, szDropDir));
-            if (RT_FAILURE(rc))
-                return setError(VBOX_E_IPRT_ERROR,
-                                tr("Unable to create the temporary drag and drop directory \"%s\" (%Rrc)\n"),
-                                szDropDir, rc);
-
-            pResp->setDropDir(szDropDir);
-        }
-
-        VBOXHGCMSVCPARM paParms[4];
-        int i = 0;
-        paParms[i++].setPointer((void*)aFormat.c_str(), (uint32_t)aFormat.length() + 1);
-        paParms[i++].setUInt32((uint32_t)aFormat.length() + 1);
-        paParms[i++].setUInt32(uAction);
-
-        int rc = GuestDnDInst()->hostCall(DragAndDropSvc::HOST_DND_GH_EVT_DROPPED,
-                                          i, paParms);
-        if (RT_SUCCESS(rc))
-        {
-            /* Query the progress object to the caller. */
-            pResp->queryProgressTo(aProgress.asOutParam());
-        }
-        else
-            hr = setError(VBOX_E_IPRT_ERROR,
-                          tr("Error signalling to drop data (%Rrc)\n"), rc);
-    }
+        int rc;
+
+        try
+        {
+            PRECVDATACTX pRecvCtx = new RECVDATACTX;
+            RT_BZERO(pRecvCtx, sizeof(RECVDATACTX));
+
+            pRecvCtx->mpSource  = this;
+            pRecvCtx->mpResp    = pResp;
+            pRecvCtx->mFormat   = aFormat;
+
+            std::unique_ptr <RecvDataTask> pTask(new RecvDataTask(this, pRecvCtx));
+            AssertReturn(pTask->isOk(), pTask->getRC());
+
+            rc = RTThreadCreate(NULL, GuestDnDSource::i_receiveDataThread,
+                                (void *)pTask.get(), 0, RTTHREADTYPE_MAIN_WORKER, 0, "dndSrcRcvData");
+            if (RT_SUCCESS(rc))
+            {
+                hr = pResp->queryProgressTo(aProgress.asOutParam());
+                ComAssertComRC(hr);
+
+                /* pTask is now owned by i_receiveDataThread(), so release it. */
+                pTask.release();
+            }
+            else if (pRecvCtx)
+                delete pRecvCtx;
+        }
+        catch(std::bad_alloc &)
+        {
+            rc = VERR_NO_MEMORY;
+        }
+
+        /*if (RT_FAILURE(vrc)) @todo SetError(...) */
+    }
+    /** @todo SetError(...) */
 
     LogFlowFunc(("Returning hr=%Rhrc\n", hr));
@@ -313 +381 @@
 
             Utf8Str strFormat = pResp->format();
-            LogFlowFunc(("strFormat=%s, cbData=%zu, pvData=0x%p\n",
-                         strFormat.c_str(), cbData, pvData));
+            LogFlowFunc(("strFormat=%s, cbData=%zu, pvData=0x%p\n", strFormat.c_str(), cbData, pvData));
 
             try
@@ -329 +396 @@
                         size_t cbURIs = strURIs.length();
 
-                        LogFlowFunc(("Found %zu root URIs (%zu bytes)\n",
-                                     lstURI.RootCount(), cbURIs));
+                        LogFlowFunc(("Found %zu root URIs (%zu bytes)\n", lstURI.RootCount(), cbURIs));
 
                         aData.resize(cbURIs + 1 /* Include termination */);
@@ -362 +428 @@
 }
 
+// implementation of internal methods.
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef VBOX_WITH_DRAG_AND_DROP_GH
+int GuestDnDSource::i_onReceiveData(PRECVDATACTX pCtx, const void *pvData, uint32_t cbData, uint64_t cbTotalSize)
+{
+    AssertPtrReturn(pCtx,     VERR_INVALID_POINTER);
+    AssertPtrReturn(pvData,   VERR_INVALID_POINTER);
+    AssertReturn(cbData,      VERR_INVALID_PARAMETER);
+    AssertReturn(cbTotalSize, VERR_INVALID_PARAMETER);
+
+    LogFlowFunc(("cbData=%RU32, cbTotalSize=%RU64\n", cbData, cbTotalSize));
+
+    int rc = VINF_SUCCESS;
+
+    try
+    {
+        if (   cbData > cbTotalSize
+            || cbData > _64K) /** @todo Make this configurable? */
+        {
+            LogFlowFunc(("Data sizes invalid: cbData=%RU32, cbTotalSize=%RU64\n", cbData, cbTotalSize));
+            rc = VERR_INVALID_PARAMETER;
+        }
+        else if (cbData < pCtx->mData.size())
+        {
+            AssertMsgFailed(("New size (%RU64) is smaller than current size (%zu)\n", cbTotalSize, pCtx->mData.size()));
+            rc = VERR_INVALID_PARAMETER;
+        }
+
+        if (RT_SUCCESS(rc))
+        {
+            pCtx->mData.insert(pCtx->mData.begin(), (BYTE *)pvData, (BYTE *)pvData + cbData);
+
+            LogFlowFunc(("mDataSize=%zu\n", pCtx->mData.size()));
+
+            /* Data transfer complete? */
+            Assert(cbData <= pCtx->mData.size());
+            if (cbData == pCtx->mData.size())
+            {
+                bool fHasURIList = DnDMIMENeedsDropDir(pCtx->mFormat.c_str(), pCtx->mFormat.length());
+                if (fHasURIList)
+                {
+                    LogFlowFunc(("Parsing URI data ...\n"));
+
+                    /* Try parsing the data as URI list. */
+                    rc = pCtx->mURI.lstURI.RootFromURIData(&pCtx->mData[0], pCtx->mData.size(), 0 /* uFlags */);
+                    if (RT_SUCCESS(rc))
+                    {
+                        pCtx->mURI.cbProcessed = 0;
+                        pCtx->mURI.cbToProcess = cbTotalSize;
+                    }
+                }
+            }
+        }
+    }
+    catch (std::bad_alloc &)
+    {
+        rc = VERR_NO_MEMORY;
+    }
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+int GuestDnDSource::i_onReceiveDir(PRECVDATACTX pCtx, const char *pszPath, uint32_t cbPath, uint32_t fMode)
+{
+    AssertPtrReturn(pCtx,    VERR_INVALID_POINTER);
+    AssertPtrReturn(pszPath, VERR_INVALID_POINTER);
+    AssertReturn(cbPath,     VERR_INVALID_PARAMETER);
+
+    LogFlowFunc(("pszPath=%s, cbPath=%zu, fMode=0x%x\n", pszPath, cbPath, fMode));
+
+    int rc;
+    char *pszDir = RTPathJoinA(pCtx->mURI.strDropDir.c_str(), pszPath);
+    if (pszDir)
+    {
+        rc = RTDirCreateFullPath(pszDir, fMode);
+        RTStrFree(pszDir);
+    }
+    else
+         rc = VERR_NO_MEMORY;
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+int GuestDnDSource::i_onReceiveFileHdr(PRECVDATACTX pCtx, const char *pszPath, uint32_t cbPath,
+                                       uint64_t cbSize, uint32_t fMode, uint32_t fFlags)
+{
+    AssertPtrReturn(pCtx,    VERR_INVALID_POINTER);
+    AssertPtrReturn(pszPath, VERR_INVALID_POINTER);
+    AssertReturn(cbPath,     VERR_INVALID_PARAMETER);
+    AssertReturn(fMode,      VERR_INVALID_PARAMETER);
+    /* fFlags are optional. */
+
+    LogFlowFunc(("pszPath=%s, cbPath=%RU32, cbSize=%RU64, fMode=0x%x, fFlags=0x%x\n", pszPath, cbPath, cbSize, fMode, fFlags));
+
+    int rc = VINF_SUCCESS;
+
+    do
+    {
+        if (!pCtx->mURI.objURI.IsComplete())
+        {
+            LogFlowFunc(("Warning: Object \"%s\" not complete yet\n", pCtx->mURI.objURI.GetDestPath().c_str()));
+            rc = VERR_INVALID_PARAMETER;
+            break;
+        }
+
+        if (pCtx->mURI.objURI.IsOpen()) /* File already opened? */
+        {
+            LogFlowFunc(("Warning: Current opened object is \"%s\"\n", pCtx->mURI.objURI.GetDestPath().c_str()));
+            rc = VERR_WRONG_ORDER;
+            break;
+        }
+
+        char pszPathAbs[RTPATH_MAX];
+        rc = RTPathJoin(pszPathAbs, sizeof(pszPathAbs), pCtx->mURI.strDropDir.c_str(), pszPath);
+        if (RT_FAILURE(rc))
+        {
+            LogFlowFunc(("Warning: Rebasing current file failed with rc=%Rrc\n", rc));
+            break;
+        }
+
+        rc = DnDPathSanitize(pszPathAbs, sizeof(pszPathAbs));
+        if (RT_FAILURE(rc))
+        {
+            LogFlowFunc(("Warning: Rebasing current file failed with rc=%Rrc\n", rc));
+            break;
+        }
+
+        LogFunc(("Rebased to: %s\n", pszPathAbs));
+
+        /** @todo Add sparse file support based on fFlags? (Use Open(..., fFlags | SPARSE). */
+        /** @todo Add fMode to opening flags. */
+        rc = pCtx->mURI.objURI.OpenEx(pszPathAbs, DnDURIObject::File, DnDURIObject::Target,
+                                      RTFILE_O_CREATE_REPLACE | RTFILE_O_WRITE | RTFILE_O_DENY_WRITE);
+        if (RT_SUCCESS(rc))
+        {
+            /** @todo Unescpae path before printing. */
+            LogRel2(("DnD: Transferring file to host: %s\n", pCtx->mURI.objURI.GetDestPath().c_str()));
+
+            /* Note: Protocol v1 does not send any file sizes, so always 0. */
+            if (mData.mProtocolVersion >= 2)
+                rc = pCtx->mURI.objURI.SetSize(cbSize);
+        }
+
+    } while (0);
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+int GuestDnDSource::i_onReceiveFileData(PRECVDATACTX pCtx, const void *pvData, uint32_t cbData)
+{
+    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
+    AssertPtrReturn(pvData, VERR_INVALID_POINTER);
+    AssertReturn(cbData, VERR_INVALID_PARAMETER);
+
+    int rc = VINF_SUCCESS;
+
+    do
+    {
+        if (pCtx->mURI.objURI.IsComplete())
+        {
+            LogFlowFunc(("Warning: Object \"%s\" already completed\n", pCtx->mURI.objURI.GetDestPath().c_str()));
+            rc = VERR_WRONG_ORDER;
+            break;
+        }
+
+        if (!pCtx->mURI.objURI.IsOpen()) /* File opened on host? */
+        {
+            LogFlowFunc(("Warning: Object \"%s\" not opened\n", pCtx->mURI.objURI.GetDestPath().c_str()));
+            rc = VERR_WRONG_ORDER;
+            break;
+        }
+
+        uint32_t cbWritten;
+        rc = pCtx->mURI.objURI.Write(pvData, cbData, &cbWritten);
+        if (RT_SUCCESS(rc))
+        {
+            Assert(cbWritten <= cbData);
+            if (cbWritten < cbData)
+            {
+                /** @todo What to do when the host's disk is full? */
+                rc = VERR_DISK_FULL;
+            }
+        }
+
+        if (RT_SUCCESS(rc))
+        {
+            if (pCtx->mURI.objURI.IsComplete())
+            {
+                LogRel2(("DnD: File transfer to host complete: %s", pCtx->mURI.objURI.GetDestPath().c_str()));
+                rc = VINF_EOF;
+            }
+        }
+        else
+            LogRel(("DnD: Error: Can't write guest file to host to \"%s\": %Rrc\n", pCtx->mURI.objURI.GetDestPath().c_str(), rc));
+
+    } while (0);
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+#endif /* VBOX_WITH_DRAG_AND_DROP_GH */
+
+int GuestDnDSource::i_receiveData(PRECVDATACTX pCtx)
+{
+    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
+
+    int rc;
+
+    GuestDnD *pInst = GuestDnDInst();
+    if (!pInst)
+        return VERR_INVALID_POINTER;
+
+    GuestDnDResponse *pResp = pCtx->mpResp;
+    AssertPtr(pCtx->mpResp);
+
+    ASMAtomicWriteBool(&pCtx->mIsActive, true);
+
+    /* Create event semaphore. */
+    pCtx->SemEvent = NIL_RTSEMEVENT;
+    rc = RTSemEventCreate(&pCtx->SemEvent);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    pCtx->mURI.cbToProcess = 0;
+    pCtx->mURI.cbProcessed = 0;
+    pCtx->mURI.cProcessed  = 0;
+
+    do
+    {
+        /* Reset any old data. */
+        pResp->reset();
+        pResp->resetProgress(m_pGuest);
+
+        /* Set the format we are going to retrieve to have it around
+         * when retrieving the data later. */
+        pResp->setFormat(pCtx->mFormat);
+
+        bool fHasURIList = DnDMIMENeedsDropDir(pCtx->mFormat.c_str(), pCtx->mFormat.length());
+        LogFlowFunc(("strFormat=%s, uAction=0x%x, fHasURIList=%RTbool\n", pCtx->mFormat.c_str(), pCtx->mAction, fHasURIList));
+
+        if (fHasURIList)
+        {
+            rc = i_receiveURIData(pCtx);
+        }
+        else
+        {
+            rc = i_receiveRawData(pCtx);
+        }
+
+    } while (0);
+
+    if (pCtx->SemEvent != NIL_RTSEMEVENT)
+    {
+        RTSemEventDestroy(pCtx->SemEvent);
+        pCtx->SemEvent = NIL_RTSEMEVENT;
+    }
+
+    ASMAtomicWriteBool(&pCtx->mIsActive, false);
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+/* static */
+DECLCALLBACK(int) GuestDnDSource::i_receiveDataThread(RTTHREAD Thread, void *pvUser)
+{
+    LogFlowFunc(("pvUser=%p\n", pvUser));
+
+    std::unique_ptr<RecvDataTask> pTask(static_cast<RecvDataTask*>(pvUser));
+    AssertPtr(pTask.get());
+
+    const ComObjPtr<GuestDnDSource> pTarget(pTask->getSource());
+    Assert(!pTarget.isNull());
+
+    AutoCaller autoCaller(pTarget);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    int rc = pTarget->i_receiveData(pTask->getCtx());
+    /* Nothing to do here anymore. */
+
+    LogFlowFunc(("pSource=%p returning rc=%Rrc\n", (GuestDnDSource *)pTarget, rc));
+    return rc;
+}
+
+int GuestDnDSource::i_receiveRawData(PRECVDATACTX pCtx)
+{
+    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
+
+    int rc;
+
+    GuestDnDResponse *pResp = pCtx->mpResp;
+    AssertPtr(pCtx->mpResp);
+
+    GuestDnD *pInst = GuestDnDInst();
+    if (!pInst)
+        return VERR_INVALID_POINTER;
+
+#define REGISTER_CALLBACK(x) \
+    rc = pResp->setCallback(x, i_receiveRawDataCallback, pCtx); \
+    if (RT_FAILURE(rc)) \
+        return rc;
+
+#define UNREGISTER_CALLBACK(x) \
+    rc = pCtx->mpResp->setCallback(x, NULL); \
+    AssertRC(rc);
+
+    /*
+     * Register callbacks.
+     */
+    /* Guest callbacks. */
+    REGISTER_CALLBACK(DragAndDropSvc::GUEST_DND_GH_SND_DATA);
+
+    do
+    {
+        /*
+         * Receive the raw data.
+         */
+        GuestDnDMsg Msg;
+        Msg.setType(DragAndDropSvc::HOST_DND_GH_EVT_DROPPED);
+        Msg.setNextPointer((void*)pCtx->mFormat.c_str(), (uint32_t)pCtx->mFormat.length() + 1);
+        Msg.setNextUInt32((uint32_t)pCtx->mFormat.length() + 1);
+        Msg.setNextUInt32(pCtx->mAction);
+
+        /* Make the initial call to the guest by telling that we initiated the "dropped" event on
+         * the host and therefore now waiting for the actual raw data. */
+        rc = pInst->hostCall(Msg.getType(), Msg.getCount(), Msg.getParms());
+        if (RT_SUCCESS(rc))
+        {
+            /*
+             * Wait until our callback i_receiveRawDataCallback triggered the
+             * wait event.
+             */
+            LogFlowFunc(("Waiting for raw data callback ...\n"));
+            rc = RTSemEventWait(pCtx->SemEvent, RT_INDEFINITE_WAIT);
+            LogFlowFunc(("Raw data callback done\n"));
+        }
+
+    } while (0);
+
+    /*
+     * Unregister callbacks.
+     */
+    UNREGISTER_CALLBACK(DragAndDropSvc::GUEST_DND_GH_SND_DATA);
+
+#undef REGISTER_CALLBACK
+#undef UNREGISTER_CALLBACK
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+int GuestDnDSource::i_receiveURIData(PRECVDATACTX pCtx)
+{
+    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
+
+    int rc;
+
+    GuestDnDResponse *pResp = pCtx->mpResp;
+    AssertPtr(pCtx->mpResp);
+
+    GuestDnD *pInst = GuestDnDInst();
+    if (!pInst)
+        return VERR_INVALID_POINTER;
+
+#define REGISTER_CALLBACK(x) \
+    rc = pResp->setCallback(x, i_receiveURIDataCallback, pCtx); \
+    if (RT_FAILURE(rc)) \
+        return rc;
+
+#define UNREGISTER_CALLBACK(x) \
+    rc = pResp->setCallback(x, NULL); \
+    AssertRC(rc);
+
+    /*
+     * Register callbacks.
+     */
+    /* Guest callbacks. */
+    REGISTER_CALLBACK(DragAndDropSvc::GUEST_DND_GH_SND_DATA);
+    REGISTER_CALLBACK(DragAndDropSvc::GUEST_DND_GH_SND_DIR);
+    if (mData.mProtocolVersion >= 2)
+        REGISTER_CALLBACK(DragAndDropSvc::GUEST_DND_GH_SND_FILE_HDR);
+    REGISTER_CALLBACK(DragAndDropSvc::GUEST_DND_GH_SND_FILE_DATA);
+
+    do
+    {
+        char szDropDir[RTPATH_MAX];
+        rc = DnDDirCreateDroppedFiles(szDropDir, sizeof(szDropDir));
+        LogFlowFunc(("rc=%Rrc, szDropDir=%s\n", rc, szDropDir));
+        if (RT_FAILURE(rc))
+            break;
+
+        pCtx->mURI.strDropDir = szDropDir; /** @todo Keep directory handle open? */
+        pResp->setDropDir(szDropDir);
+
+        /*
+         * Receive the URI list.
+         */
+        GuestDnDMsg Msg;
+        Msg.setType(DragAndDropSvc::HOST_DND_GH_EVT_DROPPED);
+        Msg.setNextPointer((void*)pCtx->mFormat.c_str(), (uint32_t)pCtx->mFormat.length() + 1);
+        Msg.setNextUInt32((uint32_t)pCtx->mFormat.length() + 1);
+        Msg.setNextUInt32(pCtx->mAction);
+
+        /* Make the initial call to the guest by telling that we initiated the "dropped" event on
+         * the host and therefore now waiting for the actual URI actual data. */
+        rc = pInst->hostCall(Msg.getType(), Msg.getCount(), Msg.getParms());
+        if (RT_SUCCESS(rc))
+        {
+            /*
+             * Wait until our callback i_receiveURIDataCallback triggered the
+             * wait event.
+             */
+            LogFlowFunc(("Waiting for URI callback ...\n"));
+            rc = RTSemEventWait(pCtx->SemEvent, RT_INDEFINITE_WAIT);
+            LogFlowFunc(("URI callback done, rc=%Rrc\n", rc));
+        }
+
+    } while (0);
+
+    /*
+     * Unregister callbacks.
+     */
+    UNREGISTER_CALLBACK(DragAndDropSvc::GUEST_DND_GH_SND_DATA);
+    UNREGISTER_CALLBACK(DragAndDropSvc::GUEST_DND_GH_SND_DIR);
+    if (mData.mProtocolVersion >= 2)
+        UNREGISTER_CALLBACK(DragAndDropSvc::GUEST_DND_GH_SND_FILE_HDR);
+    UNREGISTER_CALLBACK(DragAndDropSvc::GUEST_DND_GH_SND_FILE_DATA);
+
+#undef REGISTER_CALLBACK
+#undef UNREGISTER_CALLBACK
+
+    if (RT_FAILURE(rc))
+    {
+        LogFlowFunc(("Rolling back ...\n"));
+
+        /* Rollback by removing any stuff created. */
+        for (size_t i = 0; i < pCtx->mURI.lstFiles.size(); ++i)
+            RTFileDelete(pCtx->mURI.lstFiles.at(i).c_str());
+        for (size_t i = 0; i < pCtx->mURI.lstDirs.size(); ++i)
+            RTDirRemove(pCtx->mURI.lstDirs.at(i).c_str());
+    }
+
+    /* Try removing (hopefully) empty drop directory in any case. */
+    if (pCtx->mURI.strDropDir.isNotEmpty())
+        RTDirRemove(pCtx->mURI.strDropDir.c_str());
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+/* static */
+DECLCALLBACK(int) GuestDnDSource::i_receiveRawDataCallback(uint32_t uMsg, void *pvParms, size_t cbParms, void *pvUser)
+{
+    PRECVDATACTX pCtx = (PRECVDATACTX)pvUser;
+    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
+
+    GuestDnDSource *pThis = pCtx->mpSource;
+    AssertPtrReturn(pThis, VERR_INVALID_POINTER);
+
+    LogFlowFunc(("pThis=%p, uMsg=%RU32\n", pThis, uMsg));
+
+    int rc = VINF_SUCCESS;
+
+    switch (uMsg)
+    {
+        case DragAndDropSvc::GUEST_DND_GH_SND_DATA:
+        {
+            DragAndDropSvc::PVBOXDNDCBSNDDATADATA pCBData = reinterpret_cast<DragAndDropSvc::PVBOXDNDCBSNDDATADATA>(pvParms);
+            AssertPtr(pCBData);
+            AssertReturn(sizeof(DragAndDropSvc::VBOXDNDCBSNDDATADATA) == cbParms, VERR_INVALID_PARAMETER);
+            AssertReturn(DragAndDropSvc::CB_MAGIC_DND_GH_SND_DATA == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
+
+            rc = pThis->i_onReceiveData(pCtx, pCBData->pvData, pCBData->cbData, pCBData->cbTotalSize);
+            break;
+        }
+        case DragAndDropSvc::GUEST_DND_GH_EVT_ERROR:
+        {
+            DragAndDropSvc::PVBOXDNDCBEVTERRORDATA pCBData = reinterpret_cast<DragAndDropSvc::PVBOXDNDCBEVTERRORDATA>(pvParms);
+            AssertPtr(pCBData);
+            AssertReturn(sizeof(DragAndDropSvc::VBOXDNDCBEVTERRORDATA) == cbParms, VERR_INVALID_PARAMETER);
+            AssertReturn(DragAndDropSvc::CB_MAGIC_DND_GH_EVT_ERROR == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
+
+            /* Cleanup. */
+            pCtx->mpResp->reset();
+            rc = pCtx->mpResp->setProgress(100, DragAndDropSvc::DND_PROGRESS_ERROR, pCBData->rc);
+            break;
+        }
+        default:
+            rc = VERR_NOT_SUPPORTED;
+            break;
+    }
+
+    if (RT_FAILURE(rc))
+    {
+        if (pCtx->SemEvent != NIL_RTSEMEVENT)
+        {
+            LogFlowFunc(("Signalling ...\n"));
+            int rc2 = RTSemEventSignal(pCtx->SemEvent);
+            AssertRC(rc2);
+        }
+    }
+
+    LogFlowFuncLeaveRC(rc);
+    return rc; /* Tell the guest. */
+}
+
+/* static */
+DECLCALLBACK(int) GuestDnDSource::i_receiveURIDataCallback(uint32_t uMsg, void *pvParms, size_t cbParms, void *pvUser)
+{
+    PRECVDATACTX pCtx = (PRECVDATACTX)pvUser;
+    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
+
+    GuestDnDSource *pThis = pCtx->mpSource;
+    AssertPtrReturn(pThis, VERR_INVALID_POINTER);
+
+    LogFlowFunc(("pThis=%p, uMsg=%RU32\n", pThis, uMsg));
+
+    int rc = VINF_SUCCESS;
+
+    switch (uMsg)
+    {
+        case DragAndDropSvc::GUEST_DND_GH_SND_DATA:
+        {
+            DragAndDropSvc::PVBOXDNDCBSNDDATADATA pCBData = reinterpret_cast<DragAndDropSvc::PVBOXDNDCBSNDDATADATA>(pvParms);
+            AssertPtr(pCBData);
+            AssertReturn(sizeof(DragAndDropSvc::VBOXDNDCBSNDDATADATA) == cbParms, VERR_INVALID_PARAMETER);
+            AssertReturn(DragAndDropSvc::CB_MAGIC_DND_GH_SND_DATA == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
+
+            rc = pThis->i_onReceiveData(pCtx, pCBData->pvData, pCBData->cbData, pCBData->cbTotalSize);
+            break;
+        }
+        case DragAndDropSvc::GUEST_DND_GH_SND_DIR:
+        {
+            DragAndDropSvc::PVBOXDNDCBSNDDIRDATA pCBData = reinterpret_cast<DragAndDropSvc::PVBOXDNDCBSNDDIRDATA>(pvParms);
+            AssertPtr(pCBData);
+            AssertReturn(sizeof(DragAndDropSvc::VBOXDNDCBSNDDIRDATA) == cbParms, VERR_INVALID_PARAMETER);
+            AssertReturn(DragAndDropSvc::CB_MAGIC_DND_GH_SND_DIR == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
+
+            rc = pThis->i_onReceiveDir(pCtx, pCBData->pszPath, pCBData->cbPath, pCBData->fMode);
+            break;
+        }
+        case DragAndDropSvc::GUEST_DND_GH_SND_FILE_HDR:
+        {
+            DragAndDropSvc::PVBOXDNDCBSNDFILEHDRDATA pCBData = reinterpret_cast<DragAndDropSvc::PVBOXDNDCBSNDFILEHDRDATA>(pvParms);
+            AssertPtr(pCBData);
+            AssertReturn(sizeof(DragAndDropSvc::VBOXDNDCBSNDFILEHDRDATA) == cbParms, VERR_INVALID_PARAMETER);
+            AssertReturn(DragAndDropSvc::CB_MAGIC_DND_GH_SND_FILE_HDR == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
+
+            rc = pThis->i_onReceiveFileHdr(pCtx, pCBData->pszFilePath, pCBData->cbFilePath,
+                                           pCBData->cbSize, pCBData->fMode, pCBData->fFlags);
+            break;
+        }
+        case DragAndDropSvc::GUEST_DND_GH_SND_FILE_DATA:
+        {
+            DragAndDropSvc::PVBOXDNDCBSNDFILEDATADATA pCBData = reinterpret_cast<DragAndDropSvc::PVBOXDNDCBSNDFILEDATADATA>(pvParms);
+            AssertPtr(pCBData);
+            AssertReturn(sizeof(DragAndDropSvc::VBOXDNDCBSNDFILEDATADATA) == cbParms, VERR_INVALID_PARAMETER);
+            AssertReturn(DragAndDropSvc::CB_MAGIC_DND_GH_SND_FILE_DATA == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
+
+            if (pThis->mData.mProtocolVersion <= 1)
+            {
+                /**
+                 * Notes for protocol v1 (< VBox 5.0):
+                 * - Every time this command is being sent it includes the file header,
+                 *   so just process both calls here.
+                 * - There was no information whatsoever about the total file size; the old code only
+                 *   appended data to the desired file. So just pass 0 as cbSize.
+                 */
+                rc = pThis->i_onReceiveFileHdr(pCtx,
+                                               pCBData->u.v1.pszFilePath, pCBData->u.v1.cbFilePath,
+                                               0 /* cbSize */, pCBData->u.v1.fMode, 0 /* fFlags */);
+                if (RT_SUCCESS(rc))
+                    rc = pThis->i_onReceiveFileData(pCtx, pCBData->pvData, pCBData->cbData);
+            }
+            else /* Protocol v2 and up. */
+                rc = pThis->i_onReceiveFileData(pCtx, pCBData->pvData, pCBData->cbData);
+
+            /* Current file done? */
+            if (rc == VINF_EOF)
+            {
+                /* Remove it from the list. */
+                pCtx->mURI.lstURI.RemoveFirst();
+
+                if (pCtx->mURI.lstURI.IsEmpty()) /* Current file processed? Check if there's more. */
+                {
+                    /* Let waiters know. */
+                    if (pCtx->SemEvent != NIL_RTSEMEVENT)
+                    {
+                        LogFlowFunc(("Signalling ...\n"));
+                        int rc2 = RTSemEventSignal(pCtx->SemEvent);
+                        AssertRC(rc2);
+                    }
+                }
+            }
+            break;
+        }
+        case DragAndDropSvc::GUEST_DND_GH_EVT_ERROR:
+        {
+            DragAndDropSvc::PVBOXDNDCBEVTERRORDATA pCBData = reinterpret_cast<DragAndDropSvc::PVBOXDNDCBEVTERRORDATA>(pvParms);
+            AssertPtr(pCBData);
+            AssertReturn(sizeof(DragAndDropSvc::VBOXDNDCBEVTERRORDATA) == cbParms, VERR_INVALID_PARAMETER);
+            AssertReturn(DragAndDropSvc::CB_MAGIC_DND_GH_EVT_ERROR == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
+
+            /* Cleanup. */
+            pCtx->mpResp->reset();
+            rc = pCtx->mpResp->setProgress(100, DragAndDropSvc::DND_PROGRESS_ERROR, pCBData->rc);
+            break;
+        }
+        default:
+            rc = VERR_NOT_SUPPORTED;
+            break;
+    }
+
+    if (RT_FAILURE(rc))
+    {
+        if (pCtx->SemEvent != NIL_RTSEMEVENT)
+        {
+            LogFlowFunc(("Signalling ...\n"));
+            int rc2 = RTSemEventSignal(pCtx->SemEvent);
+            AssertRC(rc2);
+        }
+    }
+
+    LogFlowFuncLeaveRC(rc);
+    return rc; /* Tell the guest. */
+}
+

trunk/src/VBox/Main/src-client/GuestDnDTargetImpl.cpp

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2014 Oracle Corporation
+ * Copyright (C) 2014-2015 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -22 +22 @@
 #include "GuestImpl.h"
 #include "GuestDnDTargetImpl.h"
+#include "VirtualBoxErrorInfoImpl.h"
 
 #include "Global.h"
@@ -27 +28 @@
 
 #include <algorithm> /* For std::find(). */
+#include <memory>    /* For unique_ptr, see #7179. */
+
+#include <iprt/file.h>
+#include <iprt/dir.h>
+#include <iprt/path.h>
+#include <iprt/uri.h>
 #include <iprt/cpp/utils.h> /* For unconst(). */
 
 #include <VBox/com/array.h>
-#include <VBox/HostServices/DragAndDropSvc.h>
+
+#include <VBox/GuestHost/DragAndDrop.h>
+#include <VBox/HostServices/Service.h>
 
 #ifdef LOG_GROUP
@@ -39 +48 @@
 
 
+/**
+ * Base class for a target task.
+ */
+class GuestDnDTargetTask
+{
+public:
+
+    GuestDnDTargetTask(GuestDnDTarget *pTarget)
+        : mTarget(pTarget),
+          mRC(VINF_SUCCESS) { }
+
+    virtual ~GuestDnDTargetTask(void) { }
+
+    int getRC(void) const { return mRC; }
+    bool isOk(void) const { return RT_SUCCESS(mRC); }
+    const ComObjPtr<GuestDnDTarget> &getTarget(void) const { return mTarget; }
+
+protected:
+
+    const ComObjPtr<GuestDnDTarget>     mTarget;
+    int                                 mRC;
+};
+
+/**
+ * Task structure for sending data to a target using
+ * a worker thread.
+ */
+class SendDataTask : public GuestDnDTargetTask
+{
+public:
+
+    SendDataTask(GuestDnDTarget *pTarget, PSENDDATACTX pCtx)
+        : GuestDnDTargetTask(pTarget),
+          mpCtx(pCtx) { }
+
+    virtual ~SendDataTask(void)
+    {
+        if (mpCtx)
+        {
+            delete mpCtx;
+            mpCtx = NULL;
+        }
+    }
+
+
+    PSENDDATACTX getCtx(void) { return mpCtx; }
+
+protected:
+
+    /** Pointer to send data context. */
+    PSENDDATACTX mpCtx;
+};
+
 // constructor / destructor
 /////////////////////////////////////////////////////////////////////////////
@@ -46 +108 @@
 HRESULT GuestDnDTarget::FinalConstruct(void)
 {
+    /* Set the maximum block size our guests can handle to 64K. This always has
+     * been hardcoded until now. */
+    /* Note: Never ever rely on information from the guest; the host dictates what and
+     *       how to do something, so try to negogiate a sensible value here later. */
+    m_cbBlockSize = _32K; /** @todo Make this configurable. */
+
     LogFlowThisFunc(("\n"));
     return BaseFinalConstruct();
@@ -94 +162 @@
 /////////////////////////////////////////////////////////////////////////////
 
-HRESULT GuestDnDTarget::isFormatSupported(const com::Utf8Str &aFormat,
-                                          BOOL *aSupported)
-{
-#if !defined(VBOX_WITH_DRAG_AND_DROP) || !defined(VBOX_WITH_DRAG_AND_DROP_GH)
+HRESULT GuestDnDTarget::isFormatSupported(const com::Utf8Str &aFormat, BOOL *aSupported)
+{
+#if !defined(VBOX_WITH_DRAG_AND_DROP)
     ReturnComNotImplemented();
 #else /* VBOX_WITH_DRAG_AND_DROP */
@@ -106 +173 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    return GuestDnDBase::isFormatSupported(aFormat, aSupported);
+    return GuestDnDBase::i_isFormatSupported(aFormat, aSupported);
 #endif /* VBOX_WITH_DRAG_AND_DROP */
 }
@@ -112 +179 @@
 HRESULT GuestDnDTarget::getFormats(std::vector<com::Utf8Str> &aFormats)
 {
-#if !defined(VBOX_WITH_DRAG_AND_DROP) || !defined(VBOX_WITH_DRAG_AND_DROP_GH)
+#if !defined(VBOX_WITH_DRAG_AND_DROP)
     ReturnComNotImplemented();
 #else /* VBOX_WITH_DRAG_AND_DROP */
@@ -121 +188 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    return GuestDnDBase::getFormats(aFormats);
+    return GuestDnDBase::i_getFormats(aFormats);
 #endif /* VBOX_WITH_DRAG_AND_DROP */
 }
@@ -127 +194 @@
 HRESULT GuestDnDTarget::addFormats(const std::vector<com::Utf8Str> &aFormats)
 {
-#if !defined(VBOX_WITH_DRAG_AND_DROP) || !defined(VBOX_WITH_DRAG_AND_DROP_GH)
+#if !defined(VBOX_WITH_DRAG_AND_DROP)
     ReturnComNotImplemented();
 #else /* VBOX_WITH_DRAG_AND_DROP */
@@ -136 +203 @@
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    return GuestDnDBase::addFormats(aFormats);
+    return GuestDnDBase::i_addFormats(aFormats);
 #endif /* VBOX_WITH_DRAG_AND_DROP */
 }
@@ -142 +209 @@
 HRESULT GuestDnDTarget::removeFormats(const std::vector<com::Utf8Str> &aFormats)
 {
-#if !defined(VBOX_WITH_DRAG_AND_DROP) || !defined(VBOX_WITH_DRAG_AND_DROP_GH)
+#if !defined(VBOX_WITH_DRAG_AND_DROP)
     ReturnComNotImplemented();
 #else /* VBOX_WITH_DRAG_AND_DROP */
@@ -151 +218 @@
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    return GuestDnDBase::removeFormats(aFormats);
+    return GuestDnDBase::i_removeFormats(aFormats);
+#endif /* VBOX_WITH_DRAG_AND_DROP */
+}
+
+HRESULT GuestDnDTarget::getProtocolVersion(ULONG *aProtocolVersion)
+{
+#if !defined(VBOX_WITH_DRAG_AND_DROP)
+    ReturnComNotImplemented();
+#else /* VBOX_WITH_DRAG_AND_DROP */
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    return GuestDnDBase::i_getProtocolVersion(aProtocolVersion);
 #endif /* VBOX_WITH_DRAG_AND_DROP */
 }
@@ -164 +246 @@
                               DnDAction_T *aResultAction)
 {
-#if !defined(VBOX_WITH_DRAG_AND_DROP) || !defined(VBOX_WITH_DRAG_AND_DROP_GH)
+#if !defined(VBOX_WITH_DRAG_AND_DROP)
     ReturnComNotImplemented();
 #else /* VBOX_WITH_DRAG_AND_DROP */
@@ -178 +260 @@
     AutoCaller autoCaller(this);
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    /* Determine guest DnD protocol to use. */
+    GuestDnDBase::getProtocolVersion(&mData.mProtocolVersion);
 
     /* Default action is ignoring. */
@@ -237 +322 @@
                              DnDAction_T *aResultAction)
 {
-#if !defined(VBOX_WITH_DRAG_AND_DROP) || !defined(VBOX_WITH_DRAG_AND_DROP_GH)
+#if !defined(VBOX_WITH_DRAG_AND_DROP)
     ReturnComNotImplemented();
 #else /* VBOX_WITH_DRAG_AND_DROP */
@@ -299 +384 @@
 HRESULT GuestDnDTarget::leave(ULONG uScreenId)
 {
-#if !defined(VBOX_WITH_DRAG_AND_DROP) || !defined(VBOX_WITH_DRAG_AND_DROP_GH)
+#if !defined(VBOX_WITH_DRAG_AND_DROP)
     ReturnComNotImplemented();
 #else /* VBOX_WITH_DRAG_AND_DROP */
@@ -327 +412 @@
                              com::Utf8Str &aFormat, DnDAction_T *aResultAction)
 {
-#if !defined(VBOX_WITH_DRAG_AND_DROP) || !defined(VBOX_WITH_DRAG_AND_DROP_GH)
+#if !defined(VBOX_WITH_DRAG_AND_DROP)
     ReturnComNotImplemented();
 #else /* VBOX_WITH_DRAG_AND_DROP */
@@ -395 +480 @@
 }
 
-HRESULT GuestDnDTarget::sendData(ULONG aScreenId,
-                                 const com::Utf8Str &aFormat,
-                                 const std::vector<BYTE> &aData,
+/* static */
+DECLCALLBACK(int) GuestDnDTarget::i_sendDataThread(RTTHREAD Thread, void *pvUser)
+{
+    LogFlowFunc(("pvUser=%p\n", pvUser));
+
+    std::unique_ptr<SendDataTask> pTask(static_cast<SendDataTask*>(pvUser));
+    AssertPtr(pTask.get());
+
+    const ComObjPtr<GuestDnDTarget> pTarget(pTask->getTarget());
+    Assert(!pTarget.isNull());
+
+    AutoCaller autoCaller(pTarget);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    int rc = pTarget->i_sendData(pTask->getCtx());
+    /* Nothing to do here anymore. */
+
+    LogFlowFunc(("pTarget=%p returning rc=%Rrc\n", (GuestDnDTarget *)pTarget, rc));
+    return rc;
+}
+
+/**
+ * Initiates a data transfer from the host to the guest. The source is the host whereas the target is the
+ * guest in this case.
+ *
+ * @return  HRESULT
+ * @param   aScreenId
+ * @param   aFormat
+ * @param   aData
+ * @param   aProgress
+ */
+HRESULT GuestDnDTarget::sendData(ULONG aScreenId, const com::Utf8Str &aFormat, const std::vector<BYTE> &aData,
                                  ComPtr<IProgress> &aProgress)
 {
-#if !defined(VBOX_WITH_DRAG_AND_DROP) || !defined(VBOX_WITH_DRAG_AND_DROP_GH)
+#if !defined(VBOX_WITH_DRAG_AND_DROP)
     ReturnComNotImplemented();
 #else /* VBOX_WITH_DRAG_AND_DROP */
 
-    /* Input validation */
-
+    /** @todo Add input validation. */
+    /** @todo Check if another sendData() call currently is being processed. */
 
     AutoCaller autoCaller(this);
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
-    HRESULT hr = S_OK;
-
-    VBOXHGCMSVCPARM paParms[8];
-    int i = 0;
-    paParms[i++].setUInt32(aScreenId);
-    paParms[i++].setPointer((void *)aFormat.c_str(), (uint32_t)aFormat.length() + 1);
-    paParms[i++].setUInt32((uint32_t)aFormat.length() + 1);
-    paParms[i++].setPointer((void*)&aData.front(), (uint32_t)aData.size());
-    paParms[i++].setUInt32((uint32_t)aData.size());
-
+    HRESULT hr;
+    int vrc;
+
+    /* Note: At the moment we only support one response at a time. */
     GuestDnDResponse *pResp = GuestDnDInst()->response();
     if (pResp)
     {
-        /* Reset any old progress status. */
         pResp->resetProgress(m_pGuest);
 
-        /* Note: The actual data transfer of files/directoies is performed by the
-         *       DnD host service. */
-        int rc = GuestDnDInst()->hostCall(DragAndDropSvc::HOST_DND_HG_SND_DATA,
-                                          i, paParms);
-        if (RT_SUCCESS(rc))
-        {
-            hr = pResp->queryProgressTo(aProgress.asOutParam());
-            ComAssertComRC(hr);
-        }
-    }
+        try
+        {
+            PSENDDATACTX pSendCtx = new SENDDATACTX;
+            RT_BZERO(pSendCtx, sizeof(SENDDATACTX));
+
+            pSendCtx->mpTarget  = this;
+            pSendCtx->mpResp    = pResp;
+            pSendCtx->mScreenID = aScreenId;
+            pSendCtx->mFormat   = aFormat;
+            pSendCtx->mData     = aData;
+
+            std::unique_ptr<SendDataTask> pTask(new SendDataTask(this, pSendCtx));
+            AssertReturn(pTask->isOk(), pTask->getRC());
+
+            vrc = RTThreadCreate(NULL, GuestDnDTarget::i_sendDataThread,
+                                 (void *)pTask.get(), 0, RTTHREADTYPE_MAIN_WORKER, 0, "dndTgtSndData");
+            if (RT_SUCCESS(vrc))
+            {
+                hr = pResp->queryProgressTo(aProgress.asOutParam());
+                ComAssertComRC(hr);
+
+                /* pTask is now owned by i_sendDataThread(), so release it. */
+                pTask.release();
+            }
+            else if (pSendCtx)
+                delete pSendCtx;
+        }
+        catch(std::bad_alloc &)
+        {
+            vrc = VERR_NO_MEMORY;
+        }
+
+        /*if (RT_FAILURE(vrc)) ** @todo SetError(...) */
+    }
+    /** @todo SetError(...) */
 
     return hr;
@@ -441 +573 @@
 }
 
+int GuestDnDTarget::i_cancelOperation(void)
+{
+    /** @todo Check for pending cancel requests. */
+
+#if 0 /** @todo Later. */
+    /* Cancel any outstanding waits for guest responses first. */
+    if (pResp)
+        pResp->notifyAboutGuestResponse();
+#endif
+
+    LogFlowFunc(("Cancelling operation, telling guest ...\n"));
+    return GuestDnDInst()->hostCall(DragAndDropSvc::HOST_DND_HG_EVT_CANCEL, 0 /* cParms */, NULL /*paParms*/);
+}
+
+int GuestDnDTarget::i_sendData(PSENDDATACTX pCtx)
+{
+    AssertPtrReturn(pCtx,  VERR_INVALID_POINTER);
+
+#define DATA_IS_VALID_BREAK(x) \
+    if (!x) \
+    { \
+        LogFlowFunc(("Invalid URI data value for \"" #x "\"\n")); \
+        rc = VERR_INVALID_PARAMETER; \
+        break; \
+    }
+
+    GuestDnD *pInst = GuestDnDInst();
+    if (!pInst)
+        return VERR_INVALID_POINTER;
+
+    int rc;
+
+    ASMAtomicWriteBool(&pCtx->mIsActive, true);
+
+    do
+    {
+        const char *pszFormat = pCtx->mFormat.c_str();
+        DATA_IS_VALID_BREAK(pszFormat);
+        uint32_t cbFormat = pCtx->mFormat.length() + 1;
+
+        /* Do we need to build up a file tree? */
+        bool fHasURIList = DnDMIMEHasFileURLs(pszFormat, cbFormat);
+        if (fHasURIList)
+        {
+            rc = i_sendURIData(pCtx);
+        }
+        else
+        {
+            GuestDnDMsg Msg;
+
+            size_t cbDataTotal = pCtx->mData.size();
+            DATA_IS_VALID_BREAK(cbDataTotal);
+
+            /* Just copy over the raw data. */
+            Msg.setType(DragAndDropSvc::HOST_DND_HG_SND_DATA);
+            Msg.setNextUInt32(pCtx->mScreenID);
+            Msg.setNextPointer((void *)pCtx->mFormat.c_str(), (uint32_t)pCtx->mFormat.length() + 1);
+            Msg.setNextUInt32((uint32_t)pCtx->mFormat.length() + 1);
+            Msg.setNextPointer((void*)&pCtx->mData.front(), (uint32_t)cbDataTotal);
+            Msg.setNextUInt32(cbDataTotal);
+
+            LogFlowFunc(("%zu total bytes of raw data to transfer\n", cbDataTotal));
+
+            /* Make the initial call to the guest by sending the actual data. This might
+             * be an URI list which in turn can lead to more data to send afterwards. */
+            rc = pInst->hostCall(Msg.getType(), Msg.getCount(), Msg.getParms());
+            if (RT_FAILURE(rc))
+                break;
+        }
+
+    } while (0);
+
+    ASMAtomicWriteBool(&pCtx->mIsActive, false);
+
+#undef DATA_IS_VALID_BREAK
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+int GuestDnDTarget::i_sendDirectory(PSENDDATACTX pCtx, GuestDnDMsg *pMsg, DnDURIObject &aDirectory)
+{
+    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
+
+    RTCString strPath = aDirectory.GetDestPath();
+    if (strPath.isEmpty())
+        return VERR_INVALID_PARAMETER;
+    if (strPath.length() >= RTPATH_MAX) /* Note: Maximum is RTPATH_MAX on guest side. */
+        return VERR_BUFFER_OVERFLOW;
+
+    LogFlowFunc(("Sending directory \"%s\" using protocol v%RU32 ...\n", strPath.c_str(), mData.mProtocolVersion));
+
+    pMsg->setType(DragAndDropSvc::HOST_DND_HG_SND_DIR);
+    pMsg->setNextString(strPath.c_str());                  /* path */
+    pMsg->setNextUInt32((uint32_t)(strPath.length() + 1)); /* path length - note: Maximum is RTPATH_MAX on guest side. */
+    pMsg->setNextUInt32(aDirectory.GetMode());             /* mode */
+
+    return VINF_SUCCESS;
+}
+
+int GuestDnDTarget::i_sendFile(PSENDDATACTX pCtx, GuestDnDMsg *pMsg, DnDURIObject &aFile)
+{
+    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
+
+    RTCString strPath = aFile.GetDestPath();
+    if (strPath.isEmpty())
+        return VERR_INVALID_PARAMETER;
+
+    int rc = VINF_SUCCESS;
+
+    LogFlowFunc(("Sending \"%s\" (%RU32 bytes buffer) using protocol v%RU32 ...\n",
+                 aFile.GetDestPath().c_str(), m_cbBlockSize, mData.mProtocolVersion));
+
+    bool fSendFileData = false;
+    if (mData.mProtocolVersion >= 2)
+    {
+        if (!aFile.IsOpen())
+        {
+            rc = aFile.OpenEx(aFile.GetSourcePath(), DnDURIObject::Type::File, DnDURIObject::Dest::Source,
+                              RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_WRITE, 0 /* fFlags */);
+            if (RT_SUCCESS(rc))
+            {
+                /*
+                 * Since protocol v2 the file header and the actual file contents are
+                 * separate messages, so send the file header first.
+                 * The just registered callback will be called by the guest afterwards.
+                 */
+                pMsg->setType(DragAndDropSvc::HOST_DND_HG_SND_FILE_HDR);
+                pMsg->setNextUInt32(0);                                /* context ID */
+                pMsg->setNextString(strPath.c_str());                  /* pvName */
+                pMsg->setNextUInt32((uint32_t)(strPath.length() + 1)); /* cbName */
+                pMsg->setNextUInt32(0);                                /* uFlags */
+                pMsg->setNextUInt32(aFile.GetMode());                  /* fMode */
+                pMsg->setNextUInt64(aFile.GetSize());                  /* uSize */
+
+                LogFlowFunc(("Sending file header ...\n"));
+            }
+        }
+        else
+        {
+            /* File header was sent, so only send the actual file data. */
+            fSendFileData = true;
+        }
+    }
+    else /* Protocol v1. */
+    {
+        /* Always send the file data, every time. */
+        fSendFileData = true;
+    }
+
+    if (   RT_SUCCESS(rc)
+        && fSendFileData)
+    {
+        rc = i_sendFileData(pCtx, pMsg, aFile);
+    }
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+int GuestDnDTarget::i_sendFileData(PSENDDATACTX pCtx, GuestDnDMsg *pMsg, DnDURIObject &aFile)
+{
+    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
+    AssertPtrReturn(pMsg, VERR_INVALID_POINTER);
+
+    GuestDnDResponse *pResp = pCtx->mpResp;
+    AssertPtr(pResp);
+
+    /** @todo Don't allow concurrent reads per context! */
+
+    /* Something to transfer? */
+    if (   pCtx->mURI.lstURI.IsEmpty()
+        || !pCtx->mIsActive)
+    {
+        return VERR_WRONG_ORDER;
+    }
+
+    /*
+     * Start sending stuff.
+     */
+
+    /* Set the message type. */
+    pMsg->setType(DragAndDropSvc::HOST_DND_HG_SND_FILE_DATA);
+
+    /* Protocol version 1 sends the file path *every* time with a new file chunk.
+     * In protocol version 2 we only do this once with HOST_DND_HG_SND_FILE_HDR. */
+    if (mData.mProtocolVersion <= 1)
+    {
+        pMsg->setNextUInt32(0);                                              /* context ID */
+        pMsg->setNextString(aFile.GetSourcePath().c_str());                  /* pvName */
+        pMsg->setNextUInt32((uint32_t)(aFile.GetSourcePath().length() + 1)); /* cbName */
+    }
+
+    uint32_t cbRead = 0;
+
+    int rc = aFile.Read(pCtx->mURI.pvScratchBuf, pCtx->mURI.cbScratchBuf, &cbRead);
+    if (RT_SUCCESS(rc))
+    {
+        pCtx->mURI.cbProcessed += cbRead;
+
+        if (mData.mProtocolVersion <= 1)
+        {
+            pMsg->setNextPointer(pCtx->mURI.pvScratchBuf, cbRead);  /* pvData */
+            pMsg->setNextUInt32(cbRead);                            /* cbData */
+            pMsg->setNextUInt32(aFile.GetMode());                   /* fMode */
+        }
+        else
+        {
+            pMsg->setNextPointer(pCtx->mURI.pvScratchBuf, cbRead); /* pvData */
+            pMsg->setNextUInt32(cbRead);                           /* cbData */
+        }
+
+        if (aFile.IsComplete()) /* Done reading? */
+        {
+            LogFlowFunc(("File \"%s\" complete\n", aFile.GetSourcePath().c_str()));
+            rc = VINF_EOF;
+        }
+    }
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+/* static */
+DECLCALLBACK(int) GuestDnDTarget::i_sendURIDataCallback(uint32_t uMsg, void *pvParms, size_t cbParms, void *pvUser)
+{
+    PSENDDATACTX pCtx = (PSENDDATACTX)pvUser;
+    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
+
+    GuestDnDTarget *pThis = pCtx->mpTarget;
+    AssertPtrReturn(pThis, VERR_INVALID_POINTER);
+
+    LogFlowFunc(("pThis=%p, uMsg=%RU32\n", pThis, uMsg));
+
+    int rc = VINF_SUCCESS;
+
+    switch (uMsg)
+    {
+        case DragAndDropSvc::GUEST_DND_GET_NEXT_HOST_MSG:
+        {
+            DragAndDropSvc::PVBOXDNDCBHGGETNEXTHOSTMSG pCBData = reinterpret_cast<DragAndDropSvc::PVBOXDNDCBHGGETNEXTHOSTMSG>(pvParms);
+            AssertPtr(pCBData);
+            AssertReturn(sizeof(DragAndDropSvc::VBOXDNDCBHGGETNEXTHOSTMSG) == cbParms, VERR_INVALID_PARAMETER);
+            AssertReturn(DragAndDropSvc::CB_MAGIC_DND_HG_GET_NEXT_HOST_MSG == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
+
+            GuestDnDMsg *pMsg;
+            try
+            {
+                pMsg = new GuestDnDMsg();
+                rc = pThis->i_sendURIDataLoop(pCtx, pMsg);
+                if (RT_SUCCESS(rc))
+                {
+                    rc = pThis->addMsg(pMsg);
+                    if (RT_SUCCESS(rc)) /* Return message type & required parameter count to the guest. */
+                    {
+                        LogFlowFunc(("GUEST_DND_GET_NEXT_HOST_MSG -> %RU32 (%RU32 params)\n", pMsg->getType(), pMsg->getCount()));
+                        pCBData->uMsg   = pMsg->getType();
+                        pCBData->cParms = pMsg->getCount();
+                    }
+                }
+
+                if (RT_FAILURE(rc))
+                {
+                    if (rc == VERR_NO_DATA) /* All URI objects processed? */
+                    {
+                        /* Unregister this callback. */
+                        AssertPtr(pCtx->mpResp);
+                        int rc2 = pCtx->mpResp->setCallback(uMsg, NULL /* PFNGUESTDNDCALLBACK */);
+                        if (RT_FAILURE(rc2))
+                            LogFlowFunc(("Error: Unable to unregister callback for message %RU32, rc=%Rrc\n", uMsg, rc2));
+                    }
+
+                    delete pMsg;
+                }
+            }
+            catch(std::bad_alloc & /*e*/)
+            {
+                rc = VERR_NO_MEMORY;
+            }
+            break;
+        }
+        case DragAndDropSvc::HOST_DND_HG_SND_DIR:
+        case DragAndDropSvc::HOST_DND_HG_SND_FILE_HDR:
+        case DragAndDropSvc::HOST_DND_HG_SND_FILE_DATA:
+        {
+            DragAndDropSvc::PVBOXDNDCBHGGETNEXTHOSTMSGDATA pCBData
+                = reinterpret_cast<DragAndDropSvc::PVBOXDNDCBHGGETNEXTHOSTMSGDATA>(pvParms);
+            AssertPtr(pCBData);
+            AssertReturn(sizeof(DragAndDropSvc::VBOXDNDCBHGGETNEXTHOSTMSGDATA) == cbParms, VERR_INVALID_PARAMETER);
+            AssertReturn(DragAndDropSvc::CB_MAGIC_DND_HG_GET_NEXT_HOST_MSG_DATA == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
+
+            GuestDnDMsg *pMsg = pThis->nextMsg();
+            if (pMsg)
+            {
+                /*
+                 * Sanity checks.
+                 */
+                if (   pCBData->uMsg    != uMsg
+                    || pCBData->paParms == NULL
+                    || pCBData->cParms  != pMsg->getCount())
+                {
+                    rc = VERR_INVALID_PARAMETER;
+                }
+
+                if (RT_SUCCESS(rc))
+                {
+                    LogFlowFunc(("Sending uMsg=%RU32, cParms=%RU32 ...\n", uMsg, pCBData->cParms));
+                    rc = HGCM::Message::copyParms(pMsg->getCount(), pMsg->getParms(), pCBData->paParms);
+                    if (RT_SUCCESS(rc))
+                    {
+                        pCBData->cParms = pMsg->getCount();
+                        pThis->removeNext();
+                    }
+                }
+            }
+            else
+                rc = VERR_NO_DATA;
+
+            LogFlowFunc(("Returning msg %RU32, rc=%Rrc\n", uMsg, rc));
+            break;
+        }
+        default:
+            rc = VERR_NOT_SUPPORTED;
+            break;
+    }
+
+    if (RT_FAILURE(rc))
+    {
+        if (pCtx->mURI.SemEvent != NIL_RTSEMEVENT)
+        {
+            LogFlowFunc(("Signalling ...\n"));
+            int rc2 = RTSemEventSignal(pCtx->mURI.SemEvent);
+            AssertRC(rc2);
+        }
+    }
+
+    LogFlowFuncLeaveRC(rc);
+    return rc; /* Tell the guest. */
+}
+
+int GuestDnDTarget::i_sendURIData(PSENDDATACTX pCtx)
+{
+    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
+    AssertPtr(pCtx->mpResp);
+
+#define URI_DATA_IS_VALID_BREAK(x) \
+    if (!x) \
+    { \
+        LogFlowFunc(("Invalid URI data value for \"" #x "\"\n")); \
+        rc = VERR_INVALID_PARAMETER; \
+        break; \
+    }
+
+    void *pvBuf = RTMemAlloc(m_cbBlockSize);
+    if (!pvBuf)
+        return VERR_NO_MEMORY;
+
+    int rc;
+
+#define REGISTER_CALLBACK(x) \
+    rc = pCtx->mpResp->setCallback(x, i_sendURIDataCallback, pCtx); \
+    if (RT_FAILURE(rc)) \
+        return rc;
+
+#define UNREGISTER_CALLBACK(x) \
+    rc = pCtx->mpResp->setCallback(x, NULL); \
+    AssertRC(rc);
+
+    /*
+     * Register callbacks.
+     */
+    /* Generic callbacks. */
+    REGISTER_CALLBACK(DragAndDropSvc::GUEST_DND_GET_NEXT_HOST_MSG);
+    /* Host callbacks. */
+    REGISTER_CALLBACK(DragAndDropSvc::HOST_DND_HG_SND_DIR);
+    if (mData.mProtocolVersion >= 2)
+        REGISTER_CALLBACK(DragAndDropSvc::HOST_DND_HG_SND_FILE_HDR);
+    REGISTER_CALLBACK(DragAndDropSvc::HOST_DND_HG_SND_FILE_DATA);
+
+    do
+    {
+        /*
+         * Set our scratch buffer.
+         */
+        pCtx->mURI.pvScratchBuf = pvBuf;
+        pCtx->mURI.cbScratchBuf = m_cbBlockSize;
+
+        /* Create event semaphore. */
+        pCtx->mURI.SemEvent = NIL_RTSEMEVENT;
+        rc = RTSemEventCreate(&pCtx->mURI.SemEvent);
+        if (RT_FAILURE(rc))
+            break;
+
+        /*
+         * Extract URI list from byte data.
+         */
+        DnDURIList &lstURI = pCtx->mURI.lstURI; /* Use the URI list from the context. */
+
+        const char *pszList = (const char *)&pCtx->mData.front();
+        URI_DATA_IS_VALID_BREAK(pszList);
+
+        uint32_t cbList = pCtx->mData.size();
+        URI_DATA_IS_VALID_BREAK(cbList);
+
+        RTCList<RTCString> lstURIOrg = RTCString(pszList, cbList).split("\r\n");
+        URI_DATA_IS_VALID_BREAK(!lstURIOrg.isEmpty());
+
+        rc = lstURI.AppendURIPathsFromList(lstURIOrg, 0 /* fFlags */);
+        if (RT_SUCCESS(rc))
+            LogFlowFunc(("URI root objects: %zu, total bytes (raw data to transfer): %zu\n",
+                         lstURI.RootCount(), lstURI.TotalBytes()));
+        else
+            break;
+
+        /*
+         * The first message always is the meta info for the data. The meta
+         * info *only* contains the root elements of an URI list.
+         *
+         * After the meta data we generate the messages required to send the data itself.
+         */
+        Assert(!lstURI.IsEmpty());
+        RTCString strData = lstURI.RootToString().c_str();
+        size_t    cbData  = strData.length() + 1; /* Include terminating zero. */
+
+        GuestDnDMsg Msg;
+        Msg.setType(DragAndDropSvc::HOST_DND_HG_SND_DATA);
+        Msg.setNextUInt32(pCtx->mScreenID);
+        Msg.setNextPointer((void *)pCtx->mFormat.c_str(), (uint32_t)pCtx->mFormat.length() + 1);
+        Msg.setNextUInt32((uint32_t)pCtx->mFormat.length() + 1);
+        Msg.setNextPointer((void*)strData.c_str(), (uint32_t)cbData);
+        Msg.setNextUInt32((uint32_t)cbData);
+
+        rc = GuestDnDInst()->hostCall(Msg.getType(), Msg.getCount(), Msg.getParms());
+        if (RT_SUCCESS(rc))
+        {
+            /*
+             * Wait until our callback i_sendURIDataCallback triggered the
+             * wait event.
+             */
+            LogFlowFunc(("Waiting for URI callback ...\n"));
+            rc = RTSemEventWait(pCtx->mURI.SemEvent, RT_INDEFINITE_WAIT);
+            LogFlowFunc(("URI callback done\n"));
+        }
+
+    } while (0);
+
+     if (pCtx->mURI.SemEvent != NIL_RTSEMEVENT)
+     {
+         RTSemEventDestroy(pCtx->mURI.SemEvent);
+         pCtx->mURI.SemEvent = NIL_RTSEMEVENT;
+     }
+
+    /*
+     * Unregister callbacksagain.
+     */
+    /* Guest callbacks. */
+    UNREGISTER_CALLBACK(DragAndDropSvc::GUEST_DND_GET_NEXT_HOST_MSG);
+    /* Host callbacks. */
+    UNREGISTER_CALLBACK(DragAndDropSvc::HOST_DND_HG_SND_DIR);
+    if (mData.mProtocolVersion >= 2)
+        UNREGISTER_CALLBACK(DragAndDropSvc::HOST_DND_HG_SND_FILE_HDR);
+    UNREGISTER_CALLBACK(DragAndDropSvc::HOST_DND_HG_SND_FILE_DATA);
+
+#undef REGISTER_CALLBACK
+#undef UNREGISTER_CALLBACK
+
+    if (pvBuf)
+        RTMemFree(pvBuf);
+
+#undef URI_DATA_IS_VALID_BREAK
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+int GuestDnDTarget::i_sendURIDataLoop(PSENDDATACTX pCtx, GuestDnDMsg *pMsg)
+{
+    AssertPtrReturn(pCtx,  VERR_INVALID_POINTER);
+
+    DnDURIList &lstURI = pCtx->mURI.lstURI;
+
+    int rc;
+
+    uint64_t cbTotal = pCtx->mURI.lstURI.TotalBytes();
+    uint8_t uPercent = pCtx->mURI.cbProcessed * 100 / (cbTotal ? cbTotal : 1);
+    Assert(uPercent <= 100);
+
+    LogFlowFunc(("%RU64 / %RU64 -- %RU8%%\n", pCtx->mURI.cbProcessed, cbTotal, uPercent));
+
+    bool fComplete = (uPercent >= 100) || lstURI.IsEmpty();
+
+    if (pCtx->mpResp)
+    {
+        int rc2 = pCtx->mpResp->setProgress(uPercent,
+                                              fComplete
+                                            ? DragAndDropSvc::DND_PROGRESS_COMPLETE
+                                            : DragAndDropSvc::DND_PROGRESS_RUNNING);
+        AssertRC(rc2);
+    }
+
+    if (fComplete)
+    {
+        LogFlowFunc(("Last URI item processed, bailing out\n"));
+        return VERR_NO_DATA;
+    }
+
+    Assert(!lstURI.IsEmpty());
+    DnDURIObject &curObj = lstURI.First();
+
+    uint32_t fMode = curObj.GetMode();
+    LogFlowFunc(("Processing srcPath=%s, dstPath=%s, fMode=0x%x, cbSize=%RU32, fIsDir=%RTbool, fIsFile=%RTbool\n",
+                 curObj.GetSourcePath().c_str(), curObj.GetDestPath().c_str(),
+                 fMode, curObj.GetSize(),
+                 RTFS_IS_DIRECTORY(fMode), RTFS_IS_FILE(fMode)));
+
+    if (RTFS_IS_DIRECTORY(fMode))
+    {
+        rc = i_sendDirectory(pCtx, pMsg, curObj);
+    }
+    else if (RTFS_IS_FILE(fMode))
+    {
+        rc = i_sendFile(pCtx, pMsg, curObj);
+    }
+    else
+    {
+        AssertMsgFailed(("fMode=0x%x is not supported for srcPath=%s, dstPath=%s\n",
+                         fMode, curObj.GetSourcePath().c_str(), curObj.GetDestPath().c_str()));
+        rc = VERR_NOT_SUPPORTED;
+    }
+
+    bool fRemove = false; /* Remove current entry? */
+    if (   curObj.IsComplete()
+        || RT_FAILURE(rc))
+    {
+        fRemove = true;
+    }
+
+    if (fRemove)
+    {
+        LogFlowFunc(("Removing \"%s\" from list, rc=%Rrc\n", curObj.GetSourcePath().c_str(), rc));
+        lstURI.RemoveFirst();
+    }
+
+    if (   pCtx->mpResp
+        && pCtx->mpResp->isProgressCanceled())
+    {
+        LogFlowFunc(("Cancelling ...\n"));
+
+        rc = i_cancelOperation();
+        if (RT_SUCCESS(rc))
+            rc = VERR_CANCELLED;
+    }
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+HRESULT GuestDnDTarget::cancel(BOOL *aVeto)
+{
+#if !defined(VBOX_WITH_DRAG_AND_DROP)
+    ReturnComNotImplemented();
+#else /* VBOX_WITH_DRAG_AND_DROP */
+
+    int rc = i_cancelOperation();
+
+    if (aVeto)
+        *aVeto = FALSE; /** @todo */
+
+    return RT_SUCCESS(rc) ? S_OK : VBOX_E_IPRT_ERROR;
+#endif /* VBOX_WITH_DRAG_AND_DROP */
+}
+