Changeset 57500 in vbox for trunk/src/VBox

Timestamp:

Aug 21, 2015 4:54:50 PM (9 years ago)

Author:

vboxsync

Message:

DnD: Use a separate context for URI object when transferring, misc cleanups.

Location:

trunk/src/VBox

Files:

• Additions/common/VBoxGuestLib/VBoxGuestR3LibDragAndDrop.cpp (modified) (8 diffs)
• GuestHost/DragAndDrop/DnDURIObject.cpp (modified) (1 diff)
• Main/include/GuestDnDPrivate.h (modified) (3 diffs)
• Main/include/GuestDnDSourceImpl.h (modified) (1 diff)
• Main/include/GuestDnDTargetImpl.h (modified) (1 diff)
• Main/src-client/GuestDnDPrivate.cpp (modified) (1 diff)
• Main/src-client/GuestDnDSourceImpl.cpp (modified) (10 diffs)
• Main/src-client/GuestDnDTargetImpl.cpp (modified) (16 diffs)

trunk/src/VBox/Additions/common/VBoxGuestLib/VBoxGuestR3LibDragAndDrop.cpp

@@ -414 +414 @@
                     if (pszPathAbs)
                     {
-                        rc = RTDirCreate(pszPathAbs, (fMode & RTFS_UNIX_MASK) | RTFS_UNIX_IRWXU, 0);
+#ifdef RT_OS_WINDOWS
+                        uint32_t fCreationMode = (fMode & RTFS_DOS_MASK) | RTFS_DOS_NT_NORMAL;
+#else
+                        uint32_t fCreationMode = (fMode & RTFS_UNIX_MASK) | RTFS_UNIX_IRWXU;
+#endif
+                        rc = RTDirCreate(pszPathAbs, fCreationMode, 0);
                         if (RT_SUCCESS(rc))
                             rc = DnDDirDroppedAddDir(&dirDroppedFiles, pszPathAbs);
@@ -455 +460 @@
                     if (   RT_SUCCESS(rc)
                         && (   uNextMsg == DragAndDropSvc::HOST_DND_HG_SND_FILE_HDR
-                             /* Protocol v1 always sends the file name, so try opening every time. */
+                             /* Protocol v1 always sends the file name, so opening the file every time. */
                             || pCtx->uProtocol <= 1)
                        )
@@ -465 +470 @@
                                          szPathName, cbPathName, fMode, cbFileSize));
 
-                            uint64_t fOpen = RTFILE_O_WRITE | RTFILE_O_DENY_ALL;
+                            uint64_t fOpen = RTFILE_O_WRITE | RTFILE_O_DENY_WRITE;
                             if (pCtx->uProtocol <= 1)
                                 fOpen |= RTFILE_O_OPEN_CREATE | RTFILE_O_APPEND;
@@ -475 +480 @@
                             {
                                 RTCString strPathAbs(pszPathAbs);
-                                rc = objFile.OpenEx(strPathAbs, DnDURIObject::File, DnDURIObject::Target, fOpen,
-                                                    (fMode & RTFS_UNIX_MASK) | RTFS_UNIX_IRUSR | RTFS_UNIX_IWUSR);
+#ifdef RT_OS_WINDOWS
+                                uint32_t fCreationMode = (fMode & RTFS_DOS_MASK) | RTFS_DOS_NT_NORMAL;
+#else
+                                uint32_t fCreationMode = (fMode & RTFS_UNIX_MASK) | RTFS_UNIX_IRUSR | RTFS_UNIX_IWUSR;
+#endif
+                                rc = objFile.OpenEx(strPathAbs, DnDURIObject::File, DnDURIObject::Target, fOpen, fCreationMode);
                                 if (RT_SUCCESS(rc))
                                 {
@@ -927 +936 @@
             rc = VINF_PERMISSION_DENIED;
 
-        /* Set the protocol version to use. */
-        pCtx->uProtocol = 2;
-
-        Assert(Info.u32ClientID);
-        pCtx->uClientID = Info.u32ClientID;
+        if (RT_SUCCESS(rc))
+        {
+            /* Set the protocol version to use. */
+            pCtx->uProtocol = 2;
+
+            Assert(Info.u32ClientID);
+            pCtx->uClientID = Info.u32ClientID;
+        }
     }
 
@@ -941 +953 @@
          *       does not implement this command.
          */
-        DragAndDropSvc::VBOXDNDCONNECTPMSG Msg;
+        DragAndDropSvc::VBOXDNDCONNECTMSG Msg;
         RT_ZERO(Msg);
         Msg.hdr.result      = VERR_WRONG_ORDER;
@@ -1142 +1154 @@
 {
     AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
+    AssertReturn(uStatus > DragAndDropSvc::DND_PROGRESS_UNKNOWN, VERR_INVALID_PARAMETER);
 
     DragAndDropSvc::VBOXDNDHGEVTPROGRESSMSG Msg;
@@ -1147 +1160 @@
     Msg.hdr.result      = VERR_WRONG_ORDER;
     Msg.hdr.u32ClientID = pCtx->uClientID;
-    Msg.hdr.u32Function = DragAndDropSvc::GUEST_DND_HG_EVT_PROGRESS;
+    Msg.hdr.u32Function = uStatus;
     Msg.hdr.cParms      = 3;
 

trunk/src/VBox/GuestHost/DragAndDrop/DnDURIObject.cpp

@@ -364 +364 @@
     Close();
 
-    m_Type          = Unknown;
-    m_strSrcPath    = "";
-    m_strTgtPath    = "";
-    m_fMode = 0;
-    m_cbSize        = 0;
-    m_cbProcessed   = 0;
+    m_Type        = Unknown;
+    m_strSrcPath  = "";
+    m_strTgtPath  = "";
+    m_fMode       = 0;
+    m_cbSize      = 0;
+    m_cbProcessed = 0;
 }
 

trunk/src/VBox/Main/include/GuestDnDPrivate.h

@@ -91 +91 @@
 
 /**
+ * Structure for keeping an URI object's context around.
+ */
+typedef struct GuestDnDURIObjCtx
+{
+    GuestDnDURIObjCtx(void)
+        : pObjURI(NULL)
+        , fAllocated(false)
+        , fHeaderSent(false) { }
+
+    virtual ~GuestDnDURIObjCtx(void)
+    {
+        Reset();
+    }
+
+public:
+
+    void Reset(void)
+    {
+        if (   pObjURI
+            && fAllocated)
+        {
+            delete pObjURI;
+        }
+
+        pObjURI     = NULL;
+
+        fAllocated  = false;
+        fHeaderSent = false;
+    }
+
+
+    /** Pointer to current object being handled. */
+    DnDURIObject             *pObjURI;
+    /** Flag whether pObjURI needs deletion after use. */
+    bool                      fAllocated;
+    /** Flag whether the object's file header has been sent already. */
+    bool                      fHeaderSent;
+    /** @todo Add more statistics / information here. */
+
+} GuestDnDURIObjCtx;
+
+/**
  * Structure for keeping around URI (list) data.
  */
@@ -126 +168 @@
     {
         lstURI.Clear();
-        objURI.Close();
+        objCtx.Reset();
 
         DnDDirDroppedFilesRollback(&mDropDir);
@@ -141 +183 @@
 
     DNDDIRDROPPEDFILES              mDropDir;
-    /** (Non-recursive) List of root URI objects to receive. */
+    /** (Non-recursive) List of URI objects to handle. */
     DnDURIList                      lstURI;
-    /** Current object to receive. */
-    DnDURIObject                    objURI;
+    /** Context to current object being handled.
+     *  As we currently do all transfers one after another we
+     *  only have one context at a time. */
+    GuestDnDURIObjCtx               objCtx;
 
 protected:

trunk/src/VBox/Main/include/GuestDnDSourceImpl.h

@@ -67 +67 @@
     int i_onReceiveData(PRECVDATACTX pCtx, const void *pvData, uint32_t cbData, uint64_t cbTotalSize);
     int i_onReceiveDir(PRECVDATACTX pCtx, const char *pszPath, uint32_t cbPath, uint32_t fMode);
-    int i_onReceiveFileHdr(PRECVDATACTX pCtx, const char *pszPath, uint32_t cbPath, uint64_t cbSize, uint32_t fMode, uint32_t fFlags);
-    int i_onReceiveFileData(PRECVDATACTX pCtx, const void *pvData, uint32_t cbData);
+    int i_onReceiveFileHdr(PRECVDATACTX pCtx, GuestDnDURIObjCtx *pObjCtx, const char *pszPath, uint32_t cbPath, uint64_t cbSize, uint32_t fMode, uint32_t fFlags);
+    int i_onReceiveFileData(PRECVDATACTX pCtx, GuestDnDURIObjCtx *pObjCtx, const void *pvData, uint32_t cbData);
     /** @}  */
 #endif

trunk/src/VBox/Main/include/GuestDnDTargetImpl.h

@@ -85 +85 @@
     int i_cancelOperation(void);
     int i_sendData(PSENDDATACTX pCtx, RTMSINTERVAL msTimeout);
-    int i_sendDirectory(PSENDDATACTX pCtx, GuestDnDMsg *pMsg, DnDURIObject *pObject);
-    int i_sendFile(PSENDDATACTX pCtx, GuestDnDMsg *pMsg, DnDURIObject *pObject);
-    int i_sendFileData(PSENDDATACTX pCtx, GuestDnDMsg *pMsg, DnDURIObject *pObject);
+    int i_sendDirectory(PSENDDATACTX pCtx, GuestDnDURIObjCtx *pObjCtx, GuestDnDMsg *pMsg);
+    int i_sendFile(PSENDDATACTX pCtx, GuestDnDURIObjCtx *pObjCtx, GuestDnDMsg *pMsg);
+    int i_sendFileData(PSENDDATACTX pCtx, GuestDnDURIObjCtx *pObjCtx, GuestDnDMsg *pMsg);
     int i_sendURIData(PSENDDATACTX pCtx, RTMSINTERVAL msTimeout);
     int i_sendRawData(PSENDDATACTX pCtx, RTMSINTERVAL msTimeout);

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

@@ -421 +421 @@
 
             if (   pCBData->cbFormat == 0
-                || pCBData->cbFormat >  _64K)
+                || pCBData->cbFormat > _64K) /** @todo Make the maximum size configurable? */
             {
                 rc = VERR_INVALID_PARAMETER;

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

@@ -620 +620 @@
 }
 
-int GuestDnDSource::i_onReceiveFileHdr(PRECVDATACTX pCtx, const char *pszPath, uint32_t cbPath,
+int GuestDnDSource::i_onReceiveFileHdr(PRECVDATACTX pCtx, GuestDnDURIObjCtx *pObjCtx, const char *pszPath, uint32_t cbPath,
                                        uint64_t cbSize, uint32_t fMode, uint32_t fFlags)
 {
     AssertPtrReturn(pCtx,    VERR_INVALID_POINTER);
+    AssertPtrReturn(pObjCtx, VERR_INVALID_POINTER);
     AssertPtrReturn(pszPath, VERR_INVALID_POINTER);
     AssertReturn(cbPath,     VERR_INVALID_PARAMETER);
@@ -635 +636 @@
     do
     {
-        if (    pCtx->mURI.objURI.IsOpen()
-            && !pCtx->mURI.objURI.IsComplete())
-        {
-            AssertMsgFailed(("Object '%s' not complete yet\n", pCtx->mURI.objURI.GetDestPath().c_str()));
+        DnDURIObject *pObj = pObjCtx->pObjURI;
+
+        if (    pObj
+            &&  pObj->IsOpen()
+            && !pObj->IsComplete())
+        {
+            AssertMsgFailed(("Object '%s' not complete yet\n", pObj->GetDestPath().c_str()));
             rc = VERR_WRONG_ORDER;
             break;
         }
 
-        if (pCtx->mURI.objURI.IsOpen()) /* File already opened? */
-        {
-            AssertMsgFailed(("Current opened object is '%s', close this first\n", pCtx->mURI.objURI.GetDestPath().c_str()));
+        if (   pObj
+            && pObj->IsOpen()) /* File already opened? */
+        {
+            AssertMsgFailed(("Current opened object is '%s', close this first\n", pObj->GetDestPath().c_str()));
             rc = VERR_WRONG_ORDER;
             break;
@@ -674 +679 @@
         LogFunc(("Rebased to: %s\n", pszPathAbs));
 
-        /** @todo Add sparse file support based on fFlags? (Use Open(..., fFlags | SPARSE). */
-        rc = pCtx->mURI.objURI.OpenEx(pszPathAbs, DnDURIObject::File, DnDURIObject::Target,
-                                      RTFILE_O_CREATE_REPLACE | RTFILE_O_WRITE | RTFILE_O_DENY_WRITE,
-                                      (fMode & RTFS_UNIX_MASK) | RTFS_UNIX_IRUSR | RTFS_UNIX_IWUSR);
+        if (   pObj
+            && pObjCtx->fAllocated)
+        {
+            delete pObj;
+            pObj = NULL;
+        }
+
+        try
+        {
+            pObj = new DnDURIObject();
+
+            pObjCtx->pObjURI    = pObj;
+            pObjCtx->fAllocated = true;
+        }
+        catch (std::bad_alloc &)
+        {
+            rc = VERR_NO_MEMORY;
+        }
+
+        if (RT_SUCCESS(rc))
+        {
+            /** @todo Add sparse file support based on fFlags? (Use Open(..., fFlags | SPARSE). */
+            rc = pObj->OpenEx(pszPathAbs, DnDURIObject::File, DnDURIObject::Target,
+                              RTFILE_O_CREATE_REPLACE | RTFILE_O_WRITE | RTFILE_O_DENY_WRITE,
+                              (fMode & RTFS_UNIX_MASK) | RTFS_UNIX_IRUSR | RTFS_UNIX_IWUSR);
+        }
+
         if (RT_SUCCESS(rc))
         {
             /* Note: Protocol v1 does not send any file sizes, so always 0. */
             if (mDataBase.mProtocolVersion >= 2)
-                rc = pCtx->mURI.objURI.SetSize(cbSize);
+                rc = pObj->SetSize(cbSize);
 
             /** @todo Unescpae path before printing. */
             LogRel2(("DnD: Transferring guest file to host: %s (%RU64 bytes, mode 0x%x)\n",
-                     pCtx->mURI.objURI.GetDestPath().c_str(), pCtx->mURI.objURI.GetSize(), pCtx->mURI.objURI.GetMode()));
+                     pObj->GetDestPath().c_str(), pObj->GetSize(), pObj->GetMode()));
 
             /** @todo Set progress object title to current file being transferred? */
 
             if (!cbSize) /* 0-byte file? Close again. */
-                pCtx->mURI.objURI.Close();
-        }
-        else
+                pObj->Close();
+        }
+
+        if (RT_FAILURE(rc))
         {
             LogRel2(("DnD: Error opening/creating guest file '%s' on host, rc=%Rrc\n",
-                     pCtx->mURI.objURI.GetDestPath().c_str(), rc));
+                     pObj->GetDestPath().c_str(), rc));
             break;
         }
@@ -706 +735 @@
 }
 
-int GuestDnDSource::i_onReceiveFileData(PRECVDATACTX pCtx, const void *pvData, uint32_t cbData)
+int GuestDnDSource::i_onReceiveFileData(PRECVDATACTX pCtx, GuestDnDURIObjCtx *pObjCtx, const void *pvData, uint32_t cbData)
 {
     AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
+    AssertPtrReturn(pObjCtx, VERR_INVALID_POINTER);
     AssertPtrReturn(pvData, VERR_INVALID_POINTER);
     AssertReturn(cbData, VERR_INVALID_PARAMETER);
@@ -716 +746 @@
     do
     {
-        if (pCtx->mURI.objURI.IsComplete())
-        {
-            LogFlowFunc(("Warning: Object '%s' already completed\n", pCtx->mURI.objURI.GetDestPath().c_str()));
+        DnDURIObject *pObj = pObjCtx->pObjURI;
+        if (!pObj)
+        {
+            rc = VERR_INVALID_PARAMETER;
+            break;
+        }
+
+        if (pObj->IsComplete())
+        {
+            LogFlowFunc(("Warning: Object '%s' already completed\n", pObj->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()));
+        if (!pObj->IsOpen()) /* File opened on host? */
+        {
+            LogFlowFunc(("Warning: Object '%s' not opened\n", pObj->GetDestPath().c_str()));
             rc = VERR_WRONG_ORDER;
             break;
@@ -731 +768 @@
 
         uint32_t cbWritten;
-        rc = pCtx->mURI.objURI.Write(pvData, cbData, &cbWritten);
+        rc = pObj->Write(pvData, cbData, &cbWritten);
         if (RT_SUCCESS(rc))
         {
@@ -747 +784 @@
         if (RT_SUCCESS(rc))
         {
-            if (pCtx->mURI.objURI.IsComplete())
+            if (pObj->IsComplete())
             {
                 /** @todo Sanitize path. */
-                LogRel2(("DnD: File transfer to host complete: %s\n", pCtx->mURI.objURI.GetDestPath().c_str()));
+                LogRel2(("DnD: File transfer to host complete: %s\n", pObj->GetDestPath().c_str()));
                 rc = VINF_EOF;
 
-                /* Prepare URI object for next use. */
-                pCtx->mURI.objURI.Reset();
+                /* Deletion needed? */
+                if (pObjCtx->fAllocated)
+                {
+                    delete pObj;
+                    pObj = NULL;
+
+                    pObjCtx->fAllocated = false;
+                }
             }
         }
@@ -760 +803 @@
         {
             /** @todo What to do when the host's disk is full? */
-            LogRel(("DnD: Error writing guest file to host to '%s': %Rrc\n", pCtx->mURI.objURI.GetDestPath().c_str(), rc));
+            LogRel(("DnD: Error writing guest file to host to '%s': %Rrc\n", pObj->GetDestPath().c_str(), rc));
         }
 
@@ -1180 +1223 @@
             AssertReturn(DragAndDropSvc::CB_MAGIC_DND_GH_SND_FILE_HDR == pCBData->hdr.u32Magic, VERR_INVALID_PARAMETER);
 
-            rc = pThis->i_onReceiveFileHdr(pCtx, pCBData->pszFilePath, pCBData->cbFilePath,
+            rc = pThis->i_onReceiveFileHdr(pCtx, &pCtx->mURI.objCtx, pCBData->pszFilePath, pCBData->cbFilePath,
                                            pCBData->cbSize, pCBData->fMode, pCBData->fFlags);
             break;
@@ -1200 +1243 @@
                  *   appended data to the desired file. So just pass 0 as cbSize.
                  */
-                rc = pThis->i_onReceiveFileHdr(pCtx,
+                rc = pThis->i_onReceiveFileHdr(pCtx, &pCtx->mURI.objCtx,
                                                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);
+                    rc = pThis->i_onReceiveFileData(pCtx, &pCtx->mURI.objCtx, pCBData->pvData, pCBData->cbData);
             }
             else /* Protocol v2 and up. */
-                rc = pThis->i_onReceiveFileData(pCtx, pCBData->pvData, pCBData->cbData);
+                rc = pThis->i_onReceiveFileData(pCtx, &pCtx->mURI.objCtx, pCBData->pvData, pCBData->cbData);
             break;
         }

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

@@ -771 +771 @@
     ASMAtomicWriteBool(&pCtx->mIsActive, false);
 
-#undef DATA_IS_VALID_BREAK
-
     LogFlowFuncLeaveRC(rc);
     return rc;
 }
 
-int GuestDnDTarget::i_sendDirectory(PSENDDATACTX pCtx, GuestDnDMsg *pMsg, DnDURIObject *pObject)
-{
-    AssertPtrReturn(pObject, VERR_INVALID_POINTER);
+int GuestDnDTarget::i_sendDirectory(PSENDDATACTX pCtx, GuestDnDURIObjCtx *pObjCtx, GuestDnDMsg *pMsg)
+{
     AssertPtrReturn(pCtx,    VERR_INVALID_POINTER);
-
-    RTCString strPath = pObject->GetDestPath();
+    AssertPtrReturn(pObjCtx, VERR_INVALID_POINTER);
+    AssertPtrReturn(pMsg,    VERR_INVALID_POINTER);
+
+    DnDURIObject *pObj = pObjCtx->pObjURI;
+    AssertPtr(pObj);
+
+    RTCString strPath = pObj->GetDestPath();
     if (strPath.isEmpty())
         return VERR_INVALID_PARAMETER;
@@ -793 +795 @@
     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(pObject->GetMode());             /* mode */
+    pMsg->setNextUInt32(pObj->GetMode());                  /* mode */
 
     return VINF_SUCCESS;
 }
 
-int GuestDnDTarget::i_sendFile(PSENDDATACTX pCtx, GuestDnDMsg *pMsg, DnDURIObject *pObject)
-{
-    AssertPtrReturn(pObject, VERR_INVALID_POINTER);
+int GuestDnDTarget::i_sendFile(PSENDDATACTX pCtx, GuestDnDURIObjCtx *pObjCtx, GuestDnDMsg *pMsg)
+{
     AssertPtrReturn(pCtx,    VERR_INVALID_POINTER);
-
-    RTCString strPathSrc = pObject->GetSourcePath();
+    AssertPtrReturn(pObjCtx, VERR_INVALID_POINTER);
+    AssertPtrReturn(pMsg,    VERR_INVALID_POINTER);
+
+    DnDURIObject *pObj = pObjCtx->pObjURI;
+    AssertPtr(pObj);
+
+    RTCString strPathSrc = pObj->GetSourcePath();
     if (strPathSrc.isEmpty())
         return VERR_INVALID_PARAMETER;
@@ -809 +815 @@
     int rc = VINF_SUCCESS;
 
-    LogFlowFunc(("Sending \"%s\" (%RU32 bytes buffer) using protocol v%RU32 ...\n",
-                 strPathSrc.c_str(), mData.mcbBlockSize, mDataBase.mProtocolVersion));
-
-    bool fOpen = pObject->IsOpen();
-    if (!fOpen)
-    {
-        LogFlowFunc(("Opening \"%s\" ...\n", strPathSrc.c_str()));
-        rc = pObject->OpenEx(strPathSrc, DnDURIObject::File, DnDURIObject::Source,
+    LogFlowFunc(("Sending file with %RU32 bytes buffer, using protocol v%RU32 ...\n",
+                  mData.mcbBlockSize, mDataBase.mProtocolVersion));
+    LogFlowFunc(("strPathSrc=%s, fIsOpen=%RTbool, cbSize=%RU64\n", strPathSrc.c_str(), pObj->IsOpen(), pObj->GetSize()));
+
+    if (!pObj->IsOpen())
+    {
+        LogRel2(("DnD: Opening host file for transferring to guest: %s\n", strPathSrc.c_str()));
+        rc = pObj->OpenEx(strPathSrc, DnDURIObject::File, DnDURIObject::Source,
                           RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_WRITE, 0 /* fFlags */);
         if (RT_FAILURE(rc))
-            LogRel(("DnD: Error opening host file \"%s\", rc=%Rrc\n", strPathSrc.c_str(), rc));
-    }
-
-    bool fSendFileData = false;
+            LogRel(("DnD: Error opening host file '%s', rc=%Rrc\n", strPathSrc.c_str(), rc));
+    }
+
+    bool fSendData = false;
     if (RT_SUCCESS(rc))
     {
         if (mDataBase.mProtocolVersion >= 2)
         {
-            if (!fOpen)
+            if (!pObjCtx->fHeaderSent)
             {
                 /*
@@ -835 +841 @@
                  */
                 pMsg->setType(DragAndDropSvc::HOST_DND_HG_SND_FILE_HDR);
-                pMsg->setNextUInt32(0);                                            /* context ID */
-                rc = pMsg->setNextString(pObject->GetDestPath().c_str());             /* pvName */
+                pMsg->setNextUInt32(0);                                            /* uContextID */
+                rc = pMsg->setNextString(pObj->GetDestPath().c_str());             /* pvName */
                 AssertRC(rc);
-                pMsg->setNextUInt32((uint32_t)(pObject->GetDestPath().length() + 1)); /* cbName */
+                pMsg->setNextUInt32((uint32_t)(pObj->GetDestPath().length() + 1)); /* cbName */
                 pMsg->setNextUInt32(0);                                            /* uFlags */
-                pMsg->setNextUInt32(pObject->GetMode());                              /* fMode */
-                pMsg->setNextUInt64(pObject->GetSize());                              /* uSize */
+                pMsg->setNextUInt32(pObj->GetMode());                              /* fMode */
+                pMsg->setNextUInt64(pObj->GetSize());                              /* uSize */
 
                 LogFlowFunc(("Sending file header ...\n"));
                 LogRel2(("DnD: Transferring host file to guest: %s (%RU64 bytes, mode 0x%x)\n",
-                         strPathSrc.c_str(), pObject->GetSize(), pObject->GetMode()));
+                         strPathSrc.c_str(), pObj->GetSize(), pObj->GetMode()));
 
                 /** @todo Set progress object title to current file being transferred? */
+
+                pObjCtx->fHeaderSent = true;
             }
             else
             {
                 /* File header was sent, so only send the actual file data. */
-                fSendFileData = true;
+                fSendData = true;
             }
         }
@@ -858 +866 @@
         {
             /* Always send the file data, every time. */
-            fSendFileData = true;
+            fSendData = true;
         }
     }
 
     if (   RT_SUCCESS(rc)
-        && fSendFileData)
-    {
-        rc = i_sendFileData(pCtx, pMsg, pObject);
+        && fSendData)
+    {
+        rc = i_sendFileData(pCtx, pObjCtx, pMsg);
     }
 
@@ -872 +880 @@
 }
 
-int GuestDnDTarget::i_sendFileData(PSENDDATACTX pCtx, GuestDnDMsg *pMsg, DnDURIObject *pObject)
-{
-    AssertPtrReturn(pObject, VERR_INVALID_POINTER);
+int GuestDnDTarget::i_sendFileData(PSENDDATACTX pCtx, GuestDnDURIObjCtx *pObjCtx, GuestDnDMsg *pMsg)
+{
     AssertPtrReturn(pCtx,    VERR_INVALID_POINTER);
+    AssertPtrReturn(pObjCtx, VERR_INVALID_POINTER);
     AssertPtrReturn(pMsg,    VERR_INVALID_POINTER);
+
+    DnDURIObject *pObj = pObjCtx->pObjURI;
+    AssertPtr(pObj);
 
     GuestDnDResponse *pResp = pCtx->mpResp;
@@ -882 +893 @@
 
     /** @todo Don't allow concurrent reads per context! */
-
-    /* Something to transfer? */
-    if (   pCtx->mURI.lstURI.IsEmpty()
-        || !pCtx->mIsActive)
-    {
-        return VERR_WRONG_ORDER;
-    }
 
     /*
@@ -901 +905 @@
     if (mDataBase.mProtocolVersion <= 1)
     {
-        pMsg->setNextString(pObject->GetDestPath().c_str());                  /* pvName */
-        pMsg->setNextUInt32((uint32_t)(pObject->GetDestPath().length() + 1)); /* cbName */
+        pMsg->setNextString(pObj->GetDestPath().c_str());                  /* pvName */
+        pMsg->setNextUInt32((uint32_t)(pObj->GetDestPath().length() + 1)); /* cbName */
     }
     else
     {
         /* Protocol version 2 also sends the context ID. Currently unused. */
-        pMsg->setNextUInt32(0);                                              /* context ID */
+        pMsg->setNextUInt32(0);                                            /* context ID */
     }
 
     uint32_t cbRead = 0;
 
-    int rc = pObject->Read(pCtx->mURI.GetBufferMutable(), pCtx->mURI.GetBufferSize(), &cbRead);
+    int rc = pObj->Read(pCtx->mURI.GetBufferMutable(), pCtx->mURI.GetBufferSize(), &cbRead);
     if (RT_SUCCESS(rc))
     {
         pCtx->mData.cbProcessed += cbRead;
+        LogFlowFunc(("cbBufSize=%zu, cbRead=%RU32, cbProcessed=%RU64, rc=%Rrc\n",
+                     pCtx->mURI.GetBufferSize(), cbRead, pCtx->mData.cbProcessed, rc));
 
         if (mDataBase.mProtocolVersion <= 1)
         {
-            pMsg->setNextPointer(pCtx->mURI.GetBufferMutable(), cbRead); /* pvData */
-            pMsg->setNextUInt32(cbRead);                                 /* cbData */
-            pMsg->setNextUInt32(pObject->GetMode());                     /* fMode */
+            pMsg->setNextPointer(pCtx->mURI.GetBufferMutable(), cbRead);   /* pvData */
+            pMsg->setNextUInt32(cbRead);                                   /* cbData */
+            pMsg->setNextUInt32(pObj->GetMode());                          /* fMode */
         }
         else
         {
-            pMsg->setNextPointer(pCtx->mURI.GetBufferMutable(), cbRead); /* pvData */
-            pMsg->setNextUInt32(cbRead);                                 /* cbData */
-        }
-
-        if (pObject->IsComplete()) /* Done reading? */
-        {
-            LogRel2(("DnD: File transfer to guest complete: %s\n", pObject->GetSourcePath().c_str()));
-            LogFlowFunc(("File \"%s\" complete\n", pObject->GetSourcePath().c_str()));
-            rc = VINF_EOF;
+            pMsg->setNextPointer(pCtx->mURI.GetBufferMutable(), cbRead);   /* pvData */
+            pMsg->setNextUInt32(cbRead);                                   /* cbData */
+        }
+
+        if (pObj->IsComplete()) /* Done reading? */
+        {
+            LogRel2(("DnD: File transfer to guest complete: %s\n", pObj->GetSourcePath().c_str()));
+            LogFlowFunc(("File '%s' complete\n", pObj->GetSourcePath().c_str()));
+
+            /* DnDURIObject::Read() returns VINF_EOF when finished reading the entire fire,
+             * but we don't want this here -- so just override this with VINF_SUCCESS. */
+            rc = VINF_SUCCESS;
         }
     }
@@ -952 +961 @@
     LogFlowFunc(("pThis=%p, uMsg=%RU32\n", pThis, uMsg));
 
-    int rc = VINF_SUCCESS; /* Will be reported back to guest. */
-
-    int rcCallback = VINF_SUCCESS; /* rc for the callback. */
+    int rc      = VINF_SUCCESS; /* Will be reported back to guest. */
+    int rcGuest;                /* Contains error code from guest in case of VERR_GSTDND_GUEST_ERROR. */
     bool fNotify = false;
 
@@ -971 +979 @@
 
                 rc = pThis->i_sendURIDataLoop(pCtx, pMsg);
-                if (RT_SUCCESS(rc))
+                if (rc == VINF_EOF) /* Transfer complete? */
+                {
+                    LogFlowFunc(("Last URI item processed, bailing out\n"));
+                }
+                else if (RT_SUCCESS(rc))
                 {
                     rc = pThis->msgQueueAdd(pMsg);
@@ -982 +994 @@
                 }
 
-                if (RT_FAILURE(rc))
+                if (   RT_FAILURE(rc)
+                    || rc == VINF_EOF) /* Transfer complete? */
+                {
                     delete pMsg;
+                    pMsg = NULL;
+                }
             }
             catch(std::bad_alloc & /*e*/)
@@ -1001 +1017 @@
 
             if (RT_SUCCESS(pCBData->rc))
+            {
+                AssertMsgFailed(("Guest has sent an error event but did not specify an actual error code\n"));
                 pCBData->rc = VERR_GENERAL_FAILURE; /* Make sure some error is set. */
+            }
 
             rc = pCtx->mpResp->setProgress(100, DragAndDropSvc::DND_PROGRESS_ERROR, pCBData->rc,
                                            GuestDnDTarget::i_guestErrorToString(pCBData->rc));
             if (RT_SUCCESS(rc))
-                rcCallback = VERR_GSTDND_GUEST_ERROR;
+            {
+                rc      = VERR_GSTDND_GUEST_ERROR;
+                rcGuest = pCBData->rc;
+            }
             break;
         }
@@ -1061 +1083 @@
     }
 
-    if (   RT_FAILURE(rc)
-        || RT_FAILURE(rcCallback))
-    {
-        fNotify = true;
-        if (RT_SUCCESS(rcCallback))
-            rcCallback = rc;
+    int rcToGuest = VINF_SUCCESS; /* Status which will be sent back to the guest. */
+
+    /*
+     * Resolve errors.
+     */
+    switch (rc)
+    {
+        case VINF_SUCCESS:
+            break;
+
+        case VINF_EOF:
+        {
+            LogRel2(("DnD: Transfer to guest complete\n"));
+
+            /* Complete operation on host side. */
+            fNotify = true;
+
+            /* The guest expects VERR_NO_DATA if the transfer is complete. */
+            rcToGuest = VERR_NO_DATA;
+            break;
+        }
+
+        case VERR_GSTDND_GUEST_ERROR:
+        {
+            LogRel(("DnD: Guest reported error %Rrc, aborting transfer to guest\n", rcGuest));
+            break;
+        }
+
+        case VERR_CANCELLED:
+        {
+            LogRel2(("DnD: Transfer to guest canceled\n"));
+            rcToGuest = VERR_CANCELLED; /* Also cancel on guest side. */
+            break;
+        }
+
+        default:
+        {
+            LogRel(("DnD: Host error %Rrc occurred, aborting transfer to guest\n", rc));
+            rcToGuest = VERR_CANCELLED; /* Also cancel on guest side. */
+            break;
+        }
     }
 
     if (RT_FAILURE(rc))
     {
-        switch (rc)
-        {
-            case VERR_NO_DATA:
-                LogRel2(("DnD: Transfer to guest complete\n"));
-                break;
-
-            case VERR_CANCELLED:
-                LogRel2(("DnD: Transfer to guest canceled\n"));
-                break;
-
-            default:
-                LogRel(("DnD: Error %Rrc occurred, aborting transfer to guest\n", rc));
-                break;
-        }
-
         /* Unregister this callback. */
         AssertPtr(pCtx->mpResp);
         int rc2 = pCtx->mpResp->setCallback(uMsg, NULL /* PFNGUESTDNDCALLBACK */);
         AssertRC(rc2);
-    }
-
-    LogFlowFunc(("fNotify=%RTbool, rcCallback=%Rrc, rc=%Rrc\n", fNotify, rcCallback, rc));
+
+        /* Let the waiter(s) know. */
+        fNotify = true;
+    }
+
+    LogFlowFunc(("fNotify=%RTbool, rc=%Rrc, rcToGuest=%Rrc\n", fNotify, rc, rcToGuest));
 
     if (fNotify)
     {
-        int rc2 = pCtx->mCallback.Notify(rcCallback);
+        int rc2 = pCtx->mCallback.Notify(rc); /** @todo Also pass guest error back? */
         AssertRC(rc2);
     }
 
     LogFlowFuncLeaveRC(rc);
-    return rc; /* Tell the guest. */
+    return rcToGuest; /* Tell the guest. */
 }
 
@@ -1164 +1209 @@
         URI_DATA_IS_VALID_BREAK(!lstURIOrg.isEmpty());
 
-        uint32_t fFlags = DNDURILIST_FLAGS_KEEP_OPEN;
-
-        rc = lstURI.AppendURIPathsFromList(lstURIOrg, fFlags);
+        /* Note: All files to be transferred will be kept open during the entire DnD
+         *       operation, also to keep the accounting right. */
+        rc = lstURI.AppendURIPathsFromList(lstURIOrg, DNDURILIST_FLAGS_KEEP_OPEN);
         if (RT_SUCCESS(rc))
             LogFlowFunc(("URI root objects: %zu, total bytes (raw data to transfer): %zu\n",
@@ -1267 +1312 @@
 
     if (fComplete)
-    {
-        LogFlowFunc(("Last URI item processed, bailing out\n"));
-        return VERR_NO_DATA;
-    }
+        return VINF_EOF;
 
     Assert(!lstURI.IsEmpty());
     DnDURIObject *pCurObj = lstURI.First();
+
+    /* As we transfer all objects one after another at a time at the moment,
+     * we only need one object context at the moment. */
+    GuestDnDURIObjCtx *pObjCtx = &pCtx->mURI.objCtx;
+
+    /* Assign the pointer of the current object to our context. */
+    pObjCtx->pObjURI = pCurObj;
 
     uint32_t fMode = pCurObj->GetMode();
@@ -1283 +1332 @@
     if (RTFS_IS_DIRECTORY(fMode))
     {
-        rc = i_sendDirectory(pCtx, pMsg, pCurObj);
+        rc = i_sendDirectory(pCtx, pObjCtx, pMsg);
     }
     else if (RTFS_IS_FILE(fMode))
     {
-        rc = i_sendFile(pCtx, pMsg, pCurObj);
+        rc = i_sendFile(pCtx, pObjCtx, pMsg);
     }
     else