Changeset 85371 in vbox for trunk/src/VBox

Timestamp:

Jul 17, 2020 10:02:58 AM (5 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

139382

Message:

DnD: Revamped code to simplify / untangle of internal data handling:

• C-ifying and renaming classes DnDURIList / DnDURIObject -> DnDTransferList / DnDTransferObject
• Added testcases for DnDTransferList / DnDTransferObject + DnDPath API
• Reduced memory footprint
• Greatly simplified / stripped down internal data flow of Main side
• More (optional) release logging for further diagnosis

Work in progress.

Location:

trunk/src/VBox

Files:

• Additions/WINNT/VBoxTray/VBoxDnD.cpp (modified) (1 diff)
• Additions/WINNT/VBoxTray/VBoxDnD.h (modified) (2 diffs)
• Additions/WINNT/VBoxTray/VBoxDnDDataObject.cpp (modified) (5 diffs)
• Additions/WINNT/VBoxTray/VBoxDnDDropTarget.cpp (modified) (3 diffs)
• Additions/WINNT/VBoxTray/VBoxTray.cpp (modified) (1 diff)
• Additions/common/VBoxGuest/lib/VBoxGuestR3LibDragAndDrop.cpp (modified) (32 diffs)
• Additions/x11/VBoxClient/draganddrop.cpp (modified) (4 diffs)
• GuestHost/DragAndDrop/DnDDroppedFiles.cpp (modified) (18 diffs)
• GuestHost/DragAndDrop/DnDMIME.cpp (modified) (1 diff)
• GuestHost/DragAndDrop/DnDPath.cpp (modified) (5 diffs)
• GuestHost/DragAndDrop/DnDTransferList.cpp (moved) (moved from trunk/src/VBox/GuestHost/DragAndDrop/DnDURIList.cpp ) (5 diffs)
• GuestHost/DragAndDrop/DnDTransferObject.cpp (moved) (moved from trunk/src/VBox/GuestHost/DragAndDrop/DnDURIObject.cpp ) (21 diffs)
• GuestHost/DragAndDrop/Makefile.kmk (modified) (1 diff)
• Main/include/GuestDnDPrivate.h (modified) (18 diffs)
• Main/include/GuestDnDSourceImpl.h (modified) (1 diff)
• Main/include/GuestDnDTargetImpl.h (modified) (2 diffs)
• Main/src-client/GuestDnDPrivate.cpp (modified) (1 diff)
• Main/src-client/GuestDnDSourceImpl.cpp (modified) (19 diffs)
• Main/src-client/GuestDnDTargetImpl.cpp (modified) (28 diffs)

trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxDnD.cpp

@@ -1068 +1068 @@
 int VBoxDnDWnd::OnHgDataReceive(PVBGLR3GUESTDNDMETADATA pMeta)
 {
-    LogFlowThisFunc(("mState=%ld, enmMetaType=%RU32, cbMeta=%RU32\n", mState, pMeta->enmType, pMeta->cbMeta));
-
-    mState = Dropped;
-
-    int rc = VINF_SUCCESS;
-    if (pMeta->pvMeta)
-    {
-        Assert(pMeta->cbMeta);
-        rc = RTCritSectEnter(&mCritSect);
+    LogFlowThisFunc(("mState=%ld, enmMetaType=%RU32\n", mState, pMeta->enmType));
+
+    int rc = RTCritSectEnter(&mCritSect);
+    if (RT_SUCCESS(rc))
+    {
+        mState = Dropped;
+
+        if (startupInfo.pDataObject)
+        {
+            switch (pMeta->enmType)
+            {
+                case VBGLR3GUESTDNDMETADATATYPE_RAW:
+                {
+                    AssertBreakStmt(pMeta->u.Raw.pvMeta != NULL, rc = VERR_INVALID_POINTER);
+                    AssertBreakStmt(pMeta->u.Raw.cbMeta, rc = VERR_INVALID_PARAMETER);
+
+                    rc = startupInfo.pDataObject->Signal(mFormatRequested, pMeta->u.Raw.pvMeta, pMeta->u.Raw.cbMeta);
+                    break;
+                }
+
+                case VBGLR3GUESTDNDMETADATATYPE_URI_LIST:
+                {
+                    LogRel2(("DnD: URI transfer root directory is '%s'\n", DnDTransferListGetRootPathAbs(&pMeta->u.URI.Transfer)));
+
+                    char  *pszBuf;
+                    size_t cbBuf;
+                    /* Note: The transfer list already has its root set to a temporary directory, so no need to set/add a new
+                     *       path base here. */
+                    rc = DnDTransferListGetRootsEx(&pMeta->u.URI.Transfer, DNDTRANSFERLISTFMT_NATIVE, NULL /* pszPathBase */,
+                                                   DND_PATH_SEPARATOR, &pszBuf, &cbBuf);
+                    if (RT_SUCCESS(rc))
+                    {
+                        rc = startupInfo.pDataObject->Signal(mFormatRequested, pszBuf, cbBuf);
+                        RTStrFree(pszBuf);
+                    }
+                    break;
+                }
+
+                default:
+                    AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED);
+                    break;
+            }
+        }
+        else
+            rc = VERR_NOT_FOUND;
+
+        int rc2 = mouseRelease();
         if (RT_SUCCESS(rc))
-        {
-            if (startupInfo.pDataObject)
-                rc = startupInfo.pDataObject->Signal(mFormatRequested, pMeta->pvMeta, pMeta->cbMeta);
-            else
-                rc = VERR_NOT_FOUND;
-
-            RTCritSectLeave(&mCritSect);
-        }
-    }
-
-    int rc2 = mouseRelease();
-    if (RT_SUCCESS(rc))
-        rc = rc2;
+            rc = rc2;
+
+        RTCritSectLeave(&mCritSect);
+    }
 
     LogFlowFuncLeaveRC(rc);

trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxDnD.h

@@ -71 +71 @@
     int Abort(void);
     void SetStatus(Status status);
-    int Signal(const RTCString &strFormat, const void *pvData, uint32_t cbData);
+    int Signal(const RTCString &strFormat, const void *pvData, size_t cbData);
 
 protected:
@@ -88 +88 @@
     RTCString   mstrFormat;
     void       *mpvData;
-    uint32_t    mcbData;
+    size_t      mcbData;
 };
 

trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxDnDDataObject.cpp

@@ -229 +229 @@
          * URI list handling.
          */
-        if (mstrFormat.equalsIgnoreCase("text/uri-list"))
+        if (DnDMIMEHasFileURLs(mstrFormat.c_str(), RTSTR_MAX))
         {
-            int rc = VINF_SUCCESS;
-
-            RTCList<RTCString> lstFilesURI = RTCString((char*)mpvData, mcbData).split("\r\n");
-            RTCList<RTCString> lstFiles;
-            for (size_t i = 0; i < lstFilesURI.size(); i++)
-            {
-                char *pszFilePath = RTUriFilePath(lstFilesURI.at(i).c_str());
-                if (pszFilePath)
-                {
-                    lstFiles.append(pszFilePath);
-                    RTStrFree(pszFilePath);
-                }
-                else /* Unable to parse -- refuse entire request. */
-                {
-                    lstFiles.clear();
-                    rc = VERR_INVALID_PARAMETER;
-                    break;
-                }
-            }
-
-            size_t cFiles = lstFiles.size();
+            char **papszFiles;
+            size_t cFiles;
+            int rc = RTStrSplit((const char *)mpvData, mcbData, DND_PATH_SEPARATOR, &papszFiles, &cFiles);
             if (   RT_SUCCESS(rc)
                 && cFiles)
             {
-#ifdef DEBUG
-                LogFlowFunc(("Files (%zu)\n", cFiles));
+                LogRel2(("DnD: Files (%zu)\n", cFiles));
                 for (size_t i = 0; i < cFiles; i++)
-                    LogFlowFunc(("\tFile: %s\n", lstFiles.at(i).c_str()));
-#endif
+                    LogRel2(("\tDnD: File '%s'\n", papszFiles[i]));
 
 #if 0
@@ -310 +290 @@
                     for (size_t i = 0; i < cFiles; i++)
                     {
-                        cchFiles += strlen(lstFiles.at(i).c_str());
+                        cchFiles += strlen(papszFiles[i]);
                         cchFiles += 1; /* Terminating '\0'. */
                     }
@@ -328 +308 @@
                             size_t cchCurFile;
                             PRTUTF16 pwszFile;
-                            rc = RTStrToUtf16(lstFiles.at(i).c_str(), &pwszFile);
+                            rc = RTStrToUtf16(papszFiles[i], &pwszFile);
                             if (RT_SUCCESS(rc))
                             {
@@ -373 +353 @@
                         rc = VERR_NO_MEMORY;
                 }
+
+                for (size_t i = 0; i < cFiles; ++i)
+                    RTStrFree(papszFiles[i]);
+                RTMemFree(papszFiles);
             }
 
@@ -671 +655 @@
 
 int VBoxDnDDataObject::Signal(const RTCString &strFormat,
-                              const void *pvData, uint32_t cbData)
+                              const void *pvData, size_t cbData)
 {
     int rc;

trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxDnDDropTarget.cpp

@@ -28 +28 @@
 #include "VBox/HostServices/DragAndDropSvc.h"
 
+#include <iprt/path.h>
 #include <iprt/utf16.h>
 #include <VBox/log.h>
@@ -451 +452 @@
                                 LogRel(("DnD: Adding guest file '%s'\n", pszFileUtf8));
 
-                                rc = RTStrAAppendExN(&pszFiles, 1 /* cPairs */, pszFileUtf8, cchFileUtf8);
                                 if (RT_SUCCESS(rc))
-                                    cchFiles += cchFileUtf8;
+                                {
+                                    rc = RTStrAAppendExN(&pszFiles, 1 /* cPairs */, pszFileUtf8, cchFileUtf8);
+                                    if (RT_SUCCESS(rc))
+                                        cchFiles += cchFileUtf8;
+                                }
                             }
-                            else
+
+                            if (RT_FAILURE(rc))
                                 LogRel(("DnD: Error handling file entry #%u, rc=%Rrc\n", i, rc));
 
-                            if (pszFileUtf8)
-                                RTStrFree(pszFileUtf8);
+                            RTStrFree(pszFileUtf8);
 
                             if (RT_FAILURE(rc))
@@ -479 +483 @@
                                          cFiles, cchFiles, cbFiles, pszFiles));
 
-                            /* Translate the list into URI elements. */
-                            DnDURIList lstURI;
-                            rc = lstURI.AppendNativePathsFromList(pszFiles, cbFiles,
-                                                                  DNDURILIST_FLAGS_ABSOLUTE_PATHS);
-                            if (RT_SUCCESS(rc))
-                            {
-                                RTCString strRoot = lstURI.GetRootEntries();
-                                size_t cbRoot = strRoot.length() + 1; /* Include termination */
-
-                                mpvData = RTMemAlloc(cbRoot);
-                                if (mpvData)
-                                {
-                                    memcpy(mpvData, strRoot.c_str(), cbRoot);
-                                    mcbData = cbRoot;
-                                }
-                                else
-                                    rc = VERR_NO_MEMORY;
-                            }
+                            mpvData = pszFiles;
+                            mcbData = cbFiles;
                         }
-
-                        LogFlowFunc(("Building CF_HDROP list rc=%Rrc, pszFiles=0x%p, cFiles=%RU16, cchFiles=%RU32\n",
-                                     rc, pszFiles, cFiles, cchFiles));
-
-                        if (pszFiles)
+                        else
+                        {
                             RTStrFree(pszFiles);
+                            pszFiles = NULL;
+                        }
+
+                        LogFlowFunc(("Building CF_HDROP list rc=%Rrc, cFiles=%RU16, cchFiles=%RU32\n",
+                                     rc, cFiles, cchFiles));
                         break;
                     }

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

@@ -154 +154 @@
 static VBOXSERVICEINFO g_aServices[] =
 {
-    { &g_SvcDescClipboard,      NIL_RTTHREAD, NULL, false, false, false, false, true }
+    {&g_SvcDescDnD,      NIL_RTTHREAD, NULL, false, false, false, false, true }
 };
 #else

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

@@ -349 +349 @@
  * @param   pDroppedFiles       Dropped files object to use for maintaining the file creation / locking.
  */
-static int vbglR3DnDHGRecvURIData(PVBGLR3GUESTDNDCMDCTX pCtx, PVBOXDNDSNDDATAHDR pDataHdr, DnDDroppedFiles *pDroppedFiles)
+static int vbglR3DnDHGRecvURIData(PVBGLR3GUESTDNDCMDCTX pCtx, PVBOXDNDSNDDATAHDR pDataHdr, PDNDDROPPEDFILES pDroppedFiles)
 {
     AssertPtrReturn(pCtx,          VERR_INVALID_POINTER);
@@ -384 +384 @@
      * Create and query the (unique) drop target directory in the user's temporary directory.
      */
-    int rc = pDroppedFiles->OpenTemp(0 /* fFlags */);
+    int rc = DnDDroppedFilesOpenTemp(pDroppedFiles, 0 /* fFlags */);
     if (RT_FAILURE(rc))
     {
@@ -391 +391 @@
     }
 
-    const char *pszDropDir = pDroppedFiles->GetDirAbs();
+    const char *pszDropDir = DnDDroppedFilesGetDirAbs(pDroppedFiles);
     AssertPtr(pszDropDir);
 
@@ -397 +397 @@
      * Enter the main loop of retieving files + directories.
      */
-    DnDURIObject objFile;
+    DNDTRANSFEROBJECT objCur;
+    RT_ZERO(objCur);
 
     char szPathName[RTPATH_MAX] = { 0 };
@@ -424 +425 @@
                                             &cbPathName,
                                             &fMode);
-                    LogFlowFunc(("HOST_DND_HG_SND_DIR pszPathName=%s, cbPathName=%RU32, fMode=0x%x, rc=%Rrc\n",
+                    LogFlowFunc(("HOST_DND_HG_SND_DIR: "
+                                 "pszPathName=%s, cbPathName=%RU32, fMode=0x%x, rc=%Rrc\n",
                                  szPathName, cbPathName, fMode, rc));
 
@@ -437 +439 @@
                         rc = RTDirCreate(pszPathAbs, fCreationMode, 0);
                         if (RT_SUCCESS(rc))
-                            rc = pDroppedFiles->AddDir(pszPathAbs);
+                            rc = DnDDroppedFilesAddDir(pDroppedFiles, pszPathAbs);
 
                         if (RT_SUCCESS(rc))
@@ -452 +454 @@
                 }
                 case HOST_DND_HG_SND_FILE_HDR:
+                    RT_FALL_THROUGH();
                 case HOST_DND_HG_SND_FILE_DATA:
                 {
@@ -489 +492 @@
 
                             /* Is there already a file open, e.g. in transfer? */
-                            if (!objFile.IsOpen())
+                            if (!DnDTransferObjectIsOpen(&objCur))
                             {
-                                RTCString strPathAbs(pszPathAbs);
 #ifdef RT_OS_WINDOWS
                                 uint32_t fCreationMode = (fMode & RTFS_DOS_MASK) | RTFS_DOS_NT_NORMAL;
@@ -497 +499 @@
                                 uint32_t fCreationMode = (fMode & RTFS_UNIX_MASK) | RTFS_UNIX_IRUSR | RTFS_UNIX_IWUSR;
 #endif
-                                rc = objFile.Init(DnDURIObject::Type_File, strPathAbs);
+                                rc = DnDTransferObjectInit(&objCur, DNDTRANSFEROBJTYPE_FILE,
+                                                           pszDropDir /* Source (base) path */, szPathName /* Destination path */);
                                 if (RT_SUCCESS(rc))
                                 {
-                                    rc = objFile.Open(fOpen, fCreationMode);
+                                    rc = DnDTransferObjectOpen(&objCur, fOpen, fCreationMode, DNDTRANSFEROBJECT_FLAGS_NONE);
                                     if (RT_SUCCESS(rc))
                                     {
-                                        rc = pDroppedFiles->AddFile(strPathAbs.c_str());
+                                        rc = DnDDroppedFilesAddFile(pDroppedFiles, pszPathAbs);
                                         if (RT_SUCCESS(rc))
                                         {
                                             cbFileWritten = 0;
-                                            objFile.SetSize(cbFileSize);
+                                            DnDTransferObjectSetSize(&objCur, cbFileSize);
                                         }
                                     }
@@ -514 +517 @@
                             else
                             {
-                                AssertMsgFailed(("ObjType=%RU32\n", objFile.GetType()));
+                                AssertMsgFailed(("ObjType=%RU32\n", DnDTransferObjectGetType(&objCur)));
                                 rc = VERR_WRONG_ORDER;
                             }
@@ -529 +532 @@
                     {
                         uint32_t cbChunkWritten;
-                        rc = objFile.Write(pvChunk, cbChunkRead, &cbChunkWritten);
+                        rc = DnDTransferObjectWrite(&objCur, pvChunk, cbChunkRead, &cbChunkWritten);
                         if (RT_SUCCESS(rc))
                         {
-                            LogFlowFunc(("HOST_DND_HG_SND_FILE_DATA "
+                            LogFlowFunc(("HOST_DND_HG_SND_FILE_DATA: "
                                          "cbChunkRead=%RU32, cbChunkWritten=%RU32, cbFileWritten=%RU64 cbFileSize=%RU64\n",
                                          cbChunkRead, cbChunkWritten, cbFileWritten + cbChunkWritten, cbFileSize));
@@ -544 +547 @@
 
                     /* Data transfer complete? Close the file. */
-                    bool fClose = objFile.IsComplete();
+                    bool fClose = DnDTransferObjectIsComplete(&objCur);
                     if (fClose)
                     {
@@ -557 +560 @@
                     {
                         LogFlowFunc(("Closing file\n"));
-                        objFile.Close();
+                        DnDTransferObjectDestroy(&objCur);
                     }
 
@@ -604 +607 @@
     if (RT_FAILURE(rc))
     {
-        objFile.Close();
-        pDroppedFiles->Rollback();
+        DnDTransferObjectDestroy(&objCur);
+        DnDDroppedFilesRollback(pDroppedFiles);
     }
     else
     {
-        /** @todo Compare the URI list with the dirs/files we really transferred. */
+        /** @todo Compare the transfer list with the dirs/files we really transferred. */
         /** @todo Implement checksum verification, if any. */
     }
@@ -618 +621 @@
      * by the client's drag'n drop operation lateron.
      */
-    int rc2 = pDroppedFiles->Reset(false /* fRemoveDropDir */);
+    int rc2 = DnDDroppedFilesReset(pDroppedFiles, false /* fRemoveDropDir */);
     if (RT_FAILURE(rc2)) /* Not fatal, don't report back to host. */
         LogFlowFunc(("Closing dropped files directory failed with %Rrc\n", rc2));
@@ -805 +808 @@
 /**
  * Host -> Guest
- * Main function for receiving the actual DnD data from the host, extended version.
- *
- * @returns IPRT status code.
- * @param   pCtx                DnD context to use.
- * @param   pEnmType            Where to store the meta data type. Optional.
- * @param   ppvData             Returns the received meta data. Needs to be free'd by the caller.  Optional.
- * @param   pcbData             Where to store the size (in bytes) of the received meta data. Optional.
- */
-static int vbglR3DnDHGRecvDataMainEx(PVBGLR3GUESTDNDCMDCTX        pCtx,
-                                     VBGLR3GUESTDNDMETADATATYPE  *pEnmType,
-                                     void                       **ppvData,
-                                     uint32_t                    *pcbData)
+ * Main function for receiving the actual DnD data from the host.
+ *
+ * @returns IPRT status code.
+ * @param   pCtx                DnD context to use.
+ * @param   pMeta               Where to store the actual meta data received from the host.
+ */
+static int vbglR3DnDHGRecvDataMain(PVBGLR3GUESTDNDCMDCTX   pCtx,
+                                   PVBGLR3GUESTDNDMETADATA pMeta)
 {
     AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
-    /* The rest is optional. */
+    AssertPtrReturn(pMeta, VERR_INVALID_POINTER);
 
     VBOXDNDDATAHDR dataHdr;
@@ -831 +830 @@
         return VERR_NO_MEMORY;
 
-    DnDURIList lstURI;
-    DnDDroppedFiles droppedFiles;
+    DNDDROPPEDFILES droppedFiles;
 
     void    *pvData = NULL;
@@ -855 +853 @@
             Assert(cbData);
 
-            rc = lstURI.SetFromURIData(pvData, cbData, 0 /* fFlags */);
+            /* Use the dropped files directory as the root directory for the current transfer. */
+            rc = DnDTransferListInit(&pMeta->u.URI.Transfer, DnDDroppedFilesGetDirAbs(&droppedFiles));
             if (RT_SUCCESS(rc))
-                rc = vbglR3DnDHGRecvURIData(pCtx, &dataHdr, &droppedFiles);
-
-            if (RT_SUCCESS(rc)) /** @todo Remove this block as soon as we hand in DnDURIList. */
             {
-                if (pvData)
-                {
-                    /* Reuse data buffer to fill in the transformed URI file list. */
-                    RTMemFree(pvData);
-                    pvData = NULL;
-                }
-
-                RTCString strData = lstURI.GetRootEntries(droppedFiles.GetDirAbs());
-                Assert(!strData.isEmpty());
-
-                cbData = strData.length() + 1;
-                LogFlowFunc(("URI list has %zu bytes\n", cbData));
-
-                pvData = RTMemAlloc(cbData);
-                if (pvData)
-                {
-                    memcpy(pvData, strData.c_str(), cbData);
-
-                    if (pEnmType)
-                        *pEnmType = VBGLR3GUESTDNDMETADATATYPE_URI_LIST;
-                }
-                else
-                    rc =  VERR_NO_MEMORY;
+                rc = DnDTransferListAppendPathsFromBuffer(&pMeta->u.URI.Transfer, DNDTRANSFERLISTFMT_URI, (const char *)pvData, cbData,
+                                                          DND_PATH_SEPARATOR, 0 /* fFlags */);
+                if (RT_SUCCESS(rc))
+                    rc = vbglR3DnDHGRecvURIData(pCtx, &dataHdr, &droppedFiles);
             }
         }
         else /* Raw data. */
         {
-            if (pEnmType)
-                *pEnmType = VBGLR3GUESTDNDMETADATATYPE_RAW;
+            pMeta->enmType = VBGLR3GUESTDNDMETADATATYPE_RAW;
         }
     }
@@ -898 +874 @@
     if (RT_SUCCESS(rc))
     {
-        if (   pvData
-            && cbData)
-        {
-            if (pcbData)
-                *pcbData = cbData;
-            if (ppvData)
-                *ppvData = pvData;
-            else
-                RTMemFree(pvData);
-        }
+
     }
     else if (   RT_FAILURE(rc)
@@ -921 +888 @@
 
     LogFlowFuncLeaveRC(rc);
-    return rc;
-}
-
-/**
- * Host -> Guest
- * Main function for receiving the actual DnD data from the host.
- *
- * @returns IPRT status code.
- * @param   pCtx                DnD context to use.
- * @param   pMeta               Where to store the actual meta data received from the host.
- */
-static int vbglR3DnDHGRecvDataMain(PVBGLR3GUESTDNDCMDCTX   pCtx,
-                                   PVBGLR3GUESTDNDMETADATA pMeta)
-{
-    AssertPtrReturn(pMeta, VERR_INVALID_POINTER);
-
-    int rc = vbglR3DnDHGRecvDataMainEx(pCtx,
-                                       &pMeta->enmType,
-                                       &pMeta->pvMeta,
-                                       &pMeta->cbMeta);
     return rc;
 }
@@ -1300 +1247 @@
         {
             PVBGLR3GUESTDNDMETADATA pMeta = &pEvent->u.HG_Received.Meta;
-            if (pMeta->pvMeta)
+            switch (pMeta->enmType)
             {
-                Assert(pMeta->cbMeta);
-                RTMemFree(pMeta->pvMeta);
-                pMeta->cbMeta = 0;
+                case VBGLR3GUESTDNDMETADATATYPE_RAW:
+                {
+                    if (pMeta->u.Raw.pvMeta)
+                    {
+                        Assert(pMeta->u.Raw.cbMeta);
+                        RTMemFree(pMeta->u.Raw.pvMeta);
+                        pMeta->u.Raw.cbMeta = 0;
+                    }
+                    break;
+                }
+
+                case VBGLR3GUESTDNDMETADATATYPE_URI_LIST:
+                {
+                    DnDTransferListDestroy(&pMeta->u.URI.Transfer);
+                    break;
+                }
+
+                default:
+                    break;
             }
             break;
@@ -1503 +1466 @@
  * @returns IPRT status code.
  * @param   pCtx                DnD context to use.
- * @param   pObj                URI object containing the directory to send.
- */
-static int vbglR3DnDGHSendDir(PVBGLR3GUESTDNDCMDCTX pCtx, DnDURIObject *pObj)
+ * @param   pObj                transfer object containing the directory to send.
+ */
+static int vbglR3DnDGHSendDir(PVBGLR3GUESTDNDCMDCTX pCtx, DNDTRANSFEROBJECT *pObj)
 {
     AssertPtrReturn(pObj,                                         VERR_INVALID_POINTER);
     AssertPtrReturn(pCtx,                                         VERR_INVALID_POINTER);
-    AssertReturn(pObj->GetType() == DnDURIObject::Type_Directory, VERR_INVALID_PARAMETER);
-
-    RTCString strPath = pObj->GetPath();
-    LogFlowFunc(("strDir=%s (%zu), fMode=0x%x\n",
-                 strPath.c_str(), strPath.length(), pObj->GetMode()));
-
-    if (strPath.length() > RTPATH_MAX)
+    AssertReturn(DnDTransferObjectGetType(pObj) == DNDTRANSFEROBJTYPE_DIRECTORY, VERR_INVALID_PARAMETER);
+
+    const char *pcszPath = DnDTransferObjectGetDestPath(pObj);
+    const size_t cchPath = RTStrNLen(pcszPath, RTPATH_MAX);
+    const RTFMODE fMode  = DnDTransferObjectGetMode(pObj);
+
+    LogFlowFunc(("strDir=%s (%zu), fMode=0x%x\n", pcszPath, cchPath, fMode));
+
+    if (cchPath > RTPATH_MAX) /* Can't happen, but check anyway. */
         return VERR_INVALID_PARAMETER;
-
-    const uint32_t cbPath = (uint32_t)strPath.length() + 1; /* Include termination. */
 
     HGCMMsgGHSendDir Msg;
@@ -1524 +1487 @@
     /** @todo Context ID not used yet. */
     Msg.u.v3.uContext.SetUInt32(0);
-    Msg.u.v3.pvName.SetPtr((void *)strPath.c_str(), (uint32_t)cbPath);
-    Msg.u.v3.cbName.SetUInt32((uint32_t)cbPath);
-    Msg.u.v3.fMode.SetUInt32(pObj->GetMode());
+    Msg.u.v3.pvName.SetPtr((void *)pcszPath, (uint32_t)cchPath);
+    Msg.u.v3.cbName.SetUInt32((uint32_t)cchPath + 1); /* Include termination. */
+    Msg.u.v3.fMode.SetUInt32(fMode);
 
     return VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
@@ -1537 +1500 @@
  * @returns IPRT status code.
  * @param   pCtx                DnD context to use.
- * @param   pObj                URI object containing the file to send.
- */
-static int vbglR3DnDGHSendFile(PVBGLR3GUESTDNDCMDCTX pCtx, DnDURIObject *pObj)
+ * @param   pObj                Transfer object containing the file to send.
+ */
+static int vbglR3DnDGHSendFile(PVBGLR3GUESTDNDCMDCTX pCtx, PDNDTRANSFEROBJECT pObj)
 {
     AssertPtrReturn(pCtx,                                    VERR_INVALID_POINTER);
     AssertPtrReturn(pObj,                                    VERR_INVALID_POINTER);
-    AssertReturn(pObj->GetType() == DnDURIObject::Type_File, VERR_INVALID_PARAMETER);
-    AssertReturn(pObj->IsOpen(),                             VERR_INVALID_STATE);
+    AssertReturn(DnDTransferObjectGetType(pObj) == DNDTRANSFEROBJTYPE_FILE, VERR_INVALID_PARAMETER);
+    AssertReturn(DnDTransferObjectIsOpen(pObj),              VERR_INVALID_STATE);
 
     uint32_t cbBuf = _64K;           /** @todo Make this configurable? */
@@ -1551 +1514 @@
         return VERR_NO_MEMORY;
 
-    RTCString strPath = pObj->GetPath();
-
-    LogFlowFunc(("strFile=%s (%zu), cbSize=%RU64, fMode=0x%x\n", strPath.c_str(), strPath.length(),
-                 pObj->GetSize(), pObj->GetMode()));
+    const char *pcszPath  = DnDTransferObjectGetDestPath(pObj);
+    const size_t cchPath  = RTStrNLen(pcszPath, RTPATH_MAX);
+    const uint64_t cbSize = DnDTransferObjectGetSize(pObj);
+    const RTFMODE fMode   = DnDTransferObjectGetMode(pObj);
+
+    LogFlowFunc(("strFile=%s (%zu), cbSize=%RU64, fMode=0x%x\n", pcszPath, cchPath, cbSize, fMode));
 
     HGCMMsgGHSendFileHdr MsgHdr;
     VBGL_HGCM_HDR_INIT(&MsgHdr.hdr, pCtx->uClientID, GUEST_DND_GH_SND_FILE_HDR, 6);
     MsgHdr.uContext.SetUInt32(0);                                                    /* Context ID; unused at the moment. */
-    MsgHdr.pvName.SetPtr((void *)strPath.c_str(), (uint32_t)(strPath.length() + 1));
-    MsgHdr.cbName.SetUInt32((uint32_t)(strPath.length() + 1));
+    MsgHdr.pvName.SetPtr((void *)pcszPath, (uint32_t)(cchPath + 1));                 /* Include termination. */
+    MsgHdr.cbName.SetUInt32((uint32_t)(cchPath + 1));                                /* Ditto. */
     MsgHdr.uFlags.SetUInt32(0);                                                      /* Flags; unused at the moment. */
-    MsgHdr.fMode.SetUInt32(pObj->GetMode());                                         /* File mode */
-    MsgHdr.cbTotal.SetUInt64(pObj->GetSize());                                       /* File size (in bytes). */
+    MsgHdr.fMode.SetUInt32(fMode);                                                   /* File mode */
+    MsgHdr.cbTotal.SetUInt64(cbSize);                                                /* File size (in bytes). */
 
     int rc = VbglR3HGCMCall(&MsgHdr.hdr, sizeof(MsgHdr));
@@ -1580 +1545 @@
         Msg.u.v3.cbChecksum.SetUInt32(0);
 
-        uint64_t cbToReadTotal  = pObj->GetSize();
+        uint64_t cbToReadTotal  = cbSize;
         uint64_t cbWrittenTotal = 0;
         while (cbToReadTotal)
@@ -1587 +1552 @@
             uint32_t cbRead   = 0;
             if (cbToRead)
-                rc = pObj->Read(pvBuf, cbToRead, &cbRead);
+                rc = DnDTransferObjectRead(pObj, pvBuf, cbToRead, &cbRead);
 
             LogFlowFunc(("cbToReadTotal=%RU64, cbToRead=%RU32, cbRead=%RU32, rc=%Rrc\n",
@@ -1612 +1577 @@
             cbWrittenTotal += cbRead;
 
-            LogFlowFunc(("%RU64/%RU64 -- %RU8%%\n", cbWrittenTotal, pObj->GetSize(), cbWrittenTotal * 100 / pObj->GetSize()));
+            LogFlowFunc(("%RU64/%RU64 -- %RU8%%\n", cbWrittenTotal, cbSize, cbWrittenTotal * 100 / cbSize));
         };
     }
@@ -1624 +1589 @@
 /**
  * Guest -> Host
- * Utility function to send an URI object from guest to the host.
- *
- * @returns IPRT status code.
- * @param   pCtx                DnD context to use.
- * @param   pObj                URI object to send from guest to the host.
- */
-static int vbglR3DnDGHSendURIObject(PVBGLR3GUESTDNDCMDCTX pCtx, DnDURIObject *pObj)
+ * Utility function to send a transfer object from guest to the host.
+ *
+ * @returns IPRT status code.
+ * @param   pCtx                DnD context to use.
+ * @param   pObj                Transfer object to send from guest to the host.
+ */
+static int vbglR3DnDGHSendURIObject(PVBGLR3GUESTDNDCMDCTX pCtx, PDNDTRANSFEROBJECT pObj)
 {
     AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
@@ -1637 +1602 @@
     int rc;
 
-    switch (pObj->GetType())
-    {
-        case DnDURIObject::Type_Directory:
+    const DNDTRANSFEROBJTYPE enmType = DnDTransferObjectGetType(pObj);
+
+    switch (enmType)
+    {
+        case DNDTRANSFEROBJTYPE_DIRECTORY:
             rc = vbglR3DnDGHSendDir(pCtx, pObj);
             break;
 
-        case DnDURIObject::Type_File:
+        case DNDTRANSFEROBJTYPE_FILE:
             rc = vbglR3DnDGHSendFile(pCtx, pObj);
             break;
 
         default:
-            AssertMsgFailed(("Object type %ld not implemented\n", pObj->GetType()));
+            AssertMsgFailed(("Object type %ld not implemented\n", enmType));
             rc = VERR_NOT_IMPLEMENTED;
             break;
@@ -1682 +1649 @@
 /**
  * Guest -> Host
- * Utility function to send URI data from guest to the host.
- *
- * @returns IPRT status code.
- * @param   pCtx                DnD context to use.
- * @param   pvData              Block to URI data to send.
- * @param   cbData              Size (in bytes) of URI data to send.
- */
-static int vbglR3DnDGHSendURIData(PVBGLR3GUESTDNDCMDCTX pCtx, const void *pvData, size_t cbData)
-{
-    AssertPtrReturn(pCtx,   VERR_INVALID_POINTER);
-    AssertPtrReturn(pvData, VERR_INVALID_POINTER);
-    AssertReturn(cbData,    VERR_INVALID_PARAMETER);
-
-    RTCList<RTCString> lstPaths =
-        RTCString((const char *)pvData, cbData).split("\r\n");
-
-    /** @todo Add symlink support (DNDURILIST_FLAGS_RESOLVE_SYMLINKS) here. */
-    /** @todo Add lazy loading (DNDURILIST_FLAGS_LAZY) here. */
-    uint32_t fFlags = DNDURILIST_FLAGS_KEEP_OPEN;
-
-    DnDURIList lstURI;
-    int rc = lstURI.AppendURIPathsFromList(lstPaths, fFlags);
+ * Utility function to send transfer data from guest to the host.
+ *
+ * @returns IPRT status code.
+ * @param   pCtx                DnD context to use.
+ * @param   pTransferList       Dnd transfer list to send.
+ */
+static int vbglR3DnDGHSendTransferData(PVBGLR3GUESTDNDCMDCTX pCtx, PDNDTRANSFERLIST pTransferList)
+{
+    AssertPtrReturn(pCtx,VERR_INVALID_POINTER);
+    AssertPtrReturn(pTransferList, VERR_INVALID_POINTER);
+
+    /*
+     * Send the (meta) data; in case of URIs it's the root entries of a
+     * transfer list the host needs to know upfront to set up the drag'n drop operation.
+     */
+    char *pszList = NULL;
+    size_t cbList;
+    int rc = DnDTransferListGetRoots(pTransferList, DNDTRANSFERLISTFMT_URI, &pszList, &cbList);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    void    *pvURIList = (void *)pszList;
+    uint32_t cbURLIist = (uint32_t)cbList;
+
+    /* The total size also contains the size of the meta data. */
+    uint64_t cbTotal  = cbURLIist;
+             cbTotal += DnDTransferListObjTotalBytes(pTransferList);
+
+    /* We're going to send a transfer list in text format. */
+    const char     szMetaFmt[] = "text/uri-list";
+    const uint32_t cbMetaFmt   = (uint32_t)strlen(szMetaFmt) + 1; /* Include termination. */
+
+    VBOXDNDDATAHDR dataHdr;
+    dataHdr.uFlags    = 0; /* Flags not used yet. */
+    dataHdr.cbTotal   = cbTotal;
+    dataHdr.cbMeta    = cbURLIist;
+    dataHdr.pvMetaFmt = (void *)szMetaFmt;
+    dataHdr.cbMetaFmt = cbMetaFmt;
+    dataHdr.cObjects  = DnDTransferListObjCount(pTransferList);
+
+    rc = vbglR3DnDGHSendDataInternal(pCtx, pvURIList, cbURLIist, &dataHdr);
+
     if (RT_SUCCESS(rc))
     {
-        /*
-         * Send the (meta) data; in case of URIs it's the (non-recursive) file/directory
-         * URI list the host needs to know upfront to set up the drag'n drop operation.
-         */
-        RTCString strRootDest = lstURI.GetRootEntries();
-        if (strRootDest.isNotEmpty())
+        while (DnDTransferListObjCount(pTransferList))
         {
-            void *pvURIList  = (void *)strRootDest.c_str(); /* URI root list. */
-            uint32_t cbURLIist = (uint32_t)strRootDest.length() + 1; /* Include string termination. */
-
-            /* The total size also contains the size of the meta data. */
-            uint64_t cbTotal  = cbURLIist;
-                     cbTotal += lstURI.GetTotalBytes();
-
-            /* We're going to send an URI list in text format. */
-            const char     szMetaFmt[] = "text/uri-list";
-            const uint32_t cbMetaFmt   = (uint32_t)strlen(szMetaFmt) + 1; /* Include termination. */
-
-            VBOXDNDDATAHDR dataHdr;
-            dataHdr.uFlags    = 0; /* Flags not used yet. */
-            dataHdr.cbTotal   = cbTotal;
-            dataHdr.cbMeta    = cbURLIist;
-            dataHdr.pvMetaFmt = (void *)szMetaFmt;
-            dataHdr.cbMetaFmt = cbMetaFmt;
-            dataHdr.cObjects  = lstURI.GetTotalCount();
-
-            rc = vbglR3DnDGHSendDataInternal(pCtx,
-                                             pvURIList, cbURLIist, &dataHdr);
-        }
-        else
-            rc = VERR_INVALID_PARAMETER;
-    }
-
-    if (RT_SUCCESS(rc))
-    {
-        while (!lstURI.IsEmpty())
-        {
-            DnDURIObject *pNextObj = lstURI.First();
-
-            rc = vbglR3DnDGHSendURIObject(pCtx, pNextObj);
+            PDNDTRANSFEROBJECT pObj = DnDTransferListObjGetFirst(pTransferList);
+
+            rc = vbglR3DnDGHSendURIObject(pCtx, pObj);
             if (RT_FAILURE(rc))
                 break;
 
-            lstURI.RemoveFirst();
+            DnDTransferListObjRemoveFirst(pTransferList);
         }
+
+        Assert(DnDTransferListObjCount(pTransferList) == 0);
     }
 
@@ -1779 +1733 @@
     if (DnDMIMEHasFileURLs(pszFormat, strlen(pszFormat)))
     {
-        /* Send file data. */
-        rc = vbglR3DnDGHSendURIData(pCtx, pvData, cbData);
+        DNDTRANSFERLIST lstTransfer;
+        rc = DnDTransferListInit(&lstTransfer, NULL /* pcszRootPathAbs */);
+        if (RT_SUCCESS(rc))
+        {
+            /** @todo Add symlink support (DNDTRANSFERLIST_FLAGS_RESOLVE_SYMLINKS) here. */
+            /** @todo Add lazy loading (DNDTRANSFERLIST_FLAGS_LAZY) here. */
+            const DNDTRANSFERLISTFLAGS fFlags = DNDTRANSFERLIST_FLAGS_KEEP_OPEN;
+
+            rc = DnDTransferListAppendPathsFromBuffer(&lstTransfer, DNDTRANSFERLISTFMT_NATIVE, (const char *)pvData, cbData,
+                                                      DND_PATH_SEPARATOR, fFlags);
+            if (RT_SUCCESS(rc))
+                rc = vbglR3DnDGHSendTransferData(pCtx, &lstTransfer);
+            DnDTransferListDestroy(&lstTransfer);
+        }
     }
     else

trunk/src/VBox/Additions/x11/VBoxClient/draganddrop.cpp

@@ -549 +549 @@
     int hgMove(uint32_t uPosX, uint32_t uPosY, VBOXDNDACTION dndActionDefault);
     int hgDrop(uint32_t uPosX, uint32_t uPosY, VBOXDNDACTION dndActionDefault);
-    int hgDataReceive(PVBGLR3GUESTDNDMETADATA pMetaData);
+    int hgDataReceive(PVBGLR3GUESTDNDMETADATA pMeta);
 
     /* X11 helpers. */
@@ -1900 +1900 @@
  *
  * @returns IPRT status code.
- * @param   pMetaData               Pointer to meta data from host.
- */
-int DragInstance::hgDataReceive(PVBGLR3GUESTDNDMETADATA pMetaData)
+ * @param   pMeta               Pointer to meta data from host.
+ */
+int DragInstance::hgDataReceive(PVBGLR3GUESTDNDMETADATA pMeta)
 {
     LogFlowThisFunc(("enmMode=%RU32, enmState=%RU32\n", m_enmMode, m_enmState));
-    LogFlowThisFunc(("enmMetaDataType=%RU32\n", pMetaData->enmType));
+    LogFlowThisFunc(("enmMetaType=%RU32\n", pMeta->enmType));
 
     if (   m_enmMode  != HG
@@ -1913 +1913 @@
     }
 
-    if (   pMetaData->pvMeta == NULL
-        || pMetaData->cbMeta == 0)
-    {
-        return VERR_INVALID_PARAMETER;
-    }
-
-    int rc = VINF_SUCCESS;
-
-    const void    *pvData = pMetaData->pvMeta;
-    const uint32_t cbData = pMetaData->cbMeta;
+    void  *pvData = NULL;
+    size_t cbData = 0;
+
+    int rc;
+
+    switch (pMeta->enmType)
+    {
+        case VBGLR3GUESTDNDMETADATATYPE_RAW:
+        {
+            AssertBreakStmt(pMeta->u.Raw.pvMeta != NULL, rc = VERR_INVALID_POINTER);
+            pvData = pMeta->u.Raw.pvMeta;
+            AssertBreakStmt(pMeta->u.Raw.cbMeta, rc = VERR_INVALID_PARAMETER);
+            cbData = pMeta->u.Raw.cbMeta;
+
+            rc = VINF_SUCCESS;
+            break;
+        }
+
+        case VBGLR3GUESTDNDMETADATATYPE_URI_LIST:
+        {
+            VBClLogInfo(("URI transfer root directory is '%s'\n", DnDTransferListGetRootPathAbs(&pMeta->u.URI.Transfer)));
+
+            /* Note: The transfer list already has its root set to a temporary directory, so no need to set/add a new
+             *       path base here. */
+            rc = DnDTransferListGetRootsEx(&pMeta->u.URI.Transfer, DNDTRANSFERLISTFMT_NATIVE, NULL /* pszPathBase */,
+                                           DND_PATH_SEPARATOR, (char **)&pvData, &cbData);
+            break;
+        }
+
+        default:
+            AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED);
+            break;
+    }
+
+    if (RT_FAILURE(rc))
+        return rc;
 
     /*
@@ -1928 +1954 @@
      * be on the guest, so proceed working on communicating with the target window.
      */
-    VBClLogInfo("Received %RU32 bytes of URI list meta data from host\n", cbData);
+    VBClLogInfo("Received %RU32 bytes of meta data from host\n", cbData);
 
     /* Destroy any old data. */

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

@@ -27 +27 @@
 #include <iprt/err.h>
 #include <iprt/file.h>
+#include <iprt/mem.h>
 #include <iprt/path.h>
 #include <iprt/string.h>
 
-
 #include <VBox/log.h>
 
-DnDDroppedFiles::DnDDroppedFiles(void)
-    : m_fOpen(0)
-    , m_hDir(NULL) { }
-
-DnDDroppedFiles::DnDDroppedFiles(const char *pszPath, DNDURIDROPPEDFILEFLAGS fFlags /* = DNDURIDROPPEDFILE_FLAGS_NONE */)
-    : m_fOpen(0)
-    , m_hDir(NULL)
-{
-    OpenEx(pszPath, fFlags);
-}
-
-DnDDroppedFiles::~DnDDroppedFiles(void)
+
+/*********************************************************************************************************************************
+*   Prototypes                                                                                                                   *
+*********************************************************************************************************************************/
+static int dndDroppedFilesCloseInternal(PDNDDROPPEDFILES pDF);
+
+
+int DnDDroppedFilesInit(PDNDDROPPEDFILES pDF,
+                        const char *pszPath, DNDURIDROPPEDFILEFLAGS fFlags /* = DNDURIDROPPEDFILE_FLAGS_NONE */)
+{
+    pDF->m_fOpen = 0;
+    pDF->m_hDir  = NIL_RTDIR;
+
+    return DnDDroppedFilesOpenEx(pDF, pszPath, fFlags);
+}
+
+void DnDDroppedFilesDestroy(PDNDDROPPEDFILES pDF)
 {
     /* Only make sure to not leak any handles and stuff, don't delete any
      * directories / files here. */
-    closeInternal();
+    dndDroppedFilesCloseInternal(pDF);
 }
 
@@ -57 +62 @@
  * @param   pszFile             Path of file entry to add.
  */
-int DnDDroppedFiles::AddFile(const char *pszFile)
+int DnDDroppedFilesAddFile(PDNDDROPPEDFILES pDF, const char *pszFile)
 {
     AssertPtrReturn(pszFile, VERR_INVALID_POINTER);
 
-    if (!this->m_lstFiles.contains(pszFile))
-        this->m_lstFiles.append(pszFile);
-    return VINF_SUCCESS;
+    PDNDDROPPEDFILESENTRY pEntry = (PDNDDROPPEDFILESENTRY)RTMemAlloc(sizeof(DNDDROPPEDFILESENTRY));
+    if (!pEntry)
+        return VERR_NO_MEMORY;
+
+    pEntry->pszPath = RTStrDup(pszFile);
+    if (pEntry->pszPath)
+    {
+        RTListAppend(&pDF->m_lstFiles, &pEntry->Node);
+        return VINF_SUCCESS;
+    }
+
+    RTMemFree(pEntry);
+    return VERR_NO_MEMORY;
 }
 
@@ -73 +88 @@
  * @param   pszDir              Path of directory entry to add.
  */
-int DnDDroppedFiles::AddDir(const char *pszDir)
+int DnDDroppedFilesAddDir(PDNDDROPPEDFILES pDF, const char *pszDir)
 {
     AssertPtrReturn(pszDir, VERR_INVALID_POINTER);
 
-    if (!this->m_lstDirs.contains(pszDir))
-        this->m_lstDirs.append(pszDir);
-    return VINF_SUCCESS;
+    PDNDDROPPEDFILESENTRY pEntry = (PDNDDROPPEDFILESENTRY)RTMemAlloc(sizeof(DNDDROPPEDFILESENTRY));
+    if (!pEntry)
+        return VERR_NO_MEMORY;
+
+    pEntry->pszPath = RTStrDup(pszDir);
+    if (pEntry->pszPath)
+    {
+        RTListAppend(&pDF->m_lstDirs, &pEntry->Node);
+        return VINF_SUCCESS;
+    }
+
+    RTMemFree(pEntry);
+    return VERR_NO_MEMORY;
 }
 
@@ -87 +112 @@
  * @returns VBox status code.
  */
-int DnDDroppedFiles::closeInternal(void)
+static int dndDroppedFilesCloseInternal(PDNDDROPPEDFILES pDF)
 {
     int rc;
-    if (this->m_hDir != NULL)
-    {
-        rc = RTDirClose(this->m_hDir);
+    if (pDF->m_hDir != NULL)
+    {
+        rc = RTDirClose(pDF->m_hDir);
         if (RT_SUCCESS(rc))
-            this->m_hDir = NULL;
+            pDF->m_hDir = NULL;
     }
     else
@@ -108 +133 @@
  * @returns VBox status code.
  */
-int DnDDroppedFiles::Close(void)
-{
-    return closeInternal();
+int DnDDroppedFilesClose(PDNDDROPPEDFILES pDF)
+{
+    return dndDroppedFilesCloseInternal(pDF);
 }
 
@@ -118 +143 @@
  * @returns Pointer to absolute path of the dropped files directory.
  */
-const char *DnDDroppedFiles::GetDirAbs(void) const
-{
-    return this->m_strPathAbs.c_str();
+const char *DnDDroppedFilesGetDirAbs(PDNDDROPPEDFILES pDF)
+{
+    return pDF->pszPathAbs;
 }
 
@@ -128 +153 @@
  * @returns \c true if open, \c false if not.
  */
-bool DnDDroppedFiles::IsOpen(void) const
-{
-    return (this->m_hDir != NULL);
+bool DnDDroppedFilesIsOpen(PDNDDROPPEDFILES pDF)
+{
+    return (pDF->m_hDir != NULL);
 }
 
@@ -140 +165 @@
  * @param   fFlags              Dropped files flags to use for this directory.
  */
-int DnDDroppedFiles::OpenEx(const char *pszPath, DNDURIDROPPEDFILEFLAGS fFlags /* = DNDURIDROPPEDFILE_FLAGS_NONE */)
+int DnDDroppedFilesOpenEx(PDNDDROPPEDFILES pDF,
+                          const char *pszPath, DNDURIDROPPEDFILEFLAGS fFlags /* = DNDURIDROPPEDFILE_FLAGS_NONE */)
 {
     AssertPtrReturn(pszPath, VERR_INVALID_POINTER);
@@ -179 +205 @@
         }
 
-        rc = DnDPathSanitize(szTime, sizeof(szTime));
+        rc = DnDPathSanitizeFileName(szTime, sizeof(szTime));
         if (RT_FAILURE(rc))
             break;
@@ -195 +221 @@
             if (RT_SUCCESS(rc))
             {
-                this->m_hDir       = hDir;
-                this->m_strPathAbs = szDropDir;
-                this->m_fOpen      = fFlags;
+                pDF->m_hDir     = hDir;
+                pDF->pszPathAbs = szDropDir;
+                pDF->m_fOpen    = fFlags;
             }
         }
@@ -213 +239 @@
  * @param   fFlags              Dropped files flags to use for this directory.
  */
-int DnDDroppedFiles::OpenTemp(DNDURIDROPPEDFILEFLAGS fFlags /* = DNDURIDROPPEDFILE_FLAGS_NONE */)
+int DnDDroppedFilesOpenTemp(PDNDDROPPEDFILES pDF, DNDURIDROPPEDFILEFLAGS fFlags)
 {
     AssertReturn(fFlags == 0, VERR_INVALID_PARAMETER); /* Flags not supported yet. */
@@ -225 +251 @@
     int rc = RTPathTemp(szTemp, sizeof(szTemp));
     if (RT_SUCCESS(rc))
-        rc = OpenEx(szTemp, fFlags);
-
-    return rc;
+        rc = DnDDroppedFilesOpenEx(pDF, szTemp, fFlags);
+
+    return rc;
+}
+
+static void dndDroppedFilesEntryFree(PDNDDROPPEDFILESENTRY pEntry)
+{
+    if (!pEntry)
+        return;
+    RTStrFree(pEntry->pszPath);
+    RTListNodeRemove(&pEntry->Node);
+    RTMemFree(pEntry);
+}
+
+static void dndDroppedFilesResetList(PRTLISTANCHOR pListAnchor)
+{
+    PDNDDROPPEDFILESENTRY pEntryCur, pEntryNext;
+    RTListForEachSafe(pListAnchor, pEntryCur, pEntryNext, DNDDROPPEDFILESENTRY, Node)
+        dndDroppedFilesEntryFree(pEntryCur);
+    Assert(RTListIsEmpty(pListAnchor));
 }
 
@@ -237 +280 @@
  *                              or just clear the internal references.
  */
-int DnDDroppedFiles::Reset(bool fDelete)
-{
-    int rc = closeInternal();
+int DnDDroppedFilesReset(PDNDDROPPEDFILES pDF, bool fDelete)
+{
+    int rc = dndDroppedFilesCloseInternal(pDF);
     if (RT_SUCCESS(rc))
     {
         if (fDelete)
         {
-            rc = Rollback();
+            rc = DnDDroppedFilesRollback(pDF);
         }
         else
         {
-            this->m_lstDirs.clear();
-            this->m_lstFiles.clear();
+            dndDroppedFilesResetList(&pDF->m_lstDirs);
+            dndDroppedFilesResetList(&pDF->m_lstFiles);
         }
     }
@@ -262 +305 @@
  * @returns VBox status code, or VERR_NOT_FOUND if the dropped files directory has not been opened before.
  */
-int DnDDroppedFiles::Reopen(void)
-{
-    if (this->m_strPathAbs.isEmpty())
+int DnDDroppedFilesReopen(PDNDDROPPEDFILES pDF)
+{
+    if (!pDF->pszPathAbs)
         return VERR_NOT_FOUND;
 
-    return OpenEx(this->m_strPathAbs.c_str(), this->m_fOpen);
+    return DnDDroppedFilesOpenEx(pDF, pDF->pszPathAbs, pDF->m_fOpen);
 }
 
@@ -276 +319 @@
  * @returns VBox status code.
  */
-int DnDDroppedFiles::Rollback(void)
-{
-    if (this->m_strPathAbs.isEmpty())
+int DnDDroppedFilesRollback(PDNDDROPPEDFILES pDF)
+{
+    if (!pDF->pszPathAbs)
         return VINF_SUCCESS;
 
@@ -287 +330 @@
      *       anything recursive here! Steam (tm) knows best ... :-) */
     int rc2;
-    for (size_t i = 0; i < this->m_lstFiles.size(); i++)
-    {
-        rc2 = RTFileDelete(this->m_lstFiles.at(i).c_str());
+    PDNDDROPPEDFILESENTRY pEntryCur, pEntryNext;
+    RTListForEachSafe(&pDF->m_lstFiles, pEntryCur, pEntryNext, DNDDROPPEDFILESENTRY, Node)
+    {
+        rc2 = RTFileDelete(pEntryCur->pszPath);
         if (RT_SUCCESS(rc2))
-            this->m_lstFiles.removeAt(i);
+            dndDroppedFilesEntryFree(pEntryCur);
         else if (RT_SUCCESS(rc))
            rc = rc2;
@@ -297 +341 @@
     }
 
-    for (size_t i = 0; i < this->m_lstDirs.size(); i++)
-    {
-        rc2 = RTDirRemove(this->m_lstDirs.at(i).c_str());
+    RTListForEachSafe(&pDF->m_lstDirs, pEntryCur, pEntryNext, DNDDROPPEDFILESENTRY, Node)
+    {
+        rc2 = RTDirRemove(pEntryCur->pszPath);
         if (RT_SUCCESS(rc2))
-            this->m_lstDirs.removeAt(i);
+            dndDroppedFilesEntryFree(pEntryCur);
         else if (RT_SUCCESS(rc))
             rc = rc2;
@@ -309 +353 @@
     if (RT_SUCCESS(rc))
     {
-        Assert(this->m_lstFiles.isEmpty());
-        Assert(this->m_lstDirs.isEmpty());
-
-        rc2 = closeInternal();
+        rc2 = dndDroppedFilesCloseInternal(pDF);
         if (RT_SUCCESS(rc2))
         {
             /* Try to remove the empty root dropped files directory as well.
              * Might return VERR_DIR_NOT_EMPTY or similar. */
-            rc2 = RTDirRemove(this->m_strPathAbs.c_str());
+            rc2 = RTDirRemove(pDF->pszPathAbs);
         }
         if (RT_SUCCESS(rc))

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

@@ -35 +35 @@
 bool DnDMIMENeedsDropDir(const char *pcszFormat, size_t cchFormatMax)
 {
-    bool fNeedsDropDir = false;
-    if (!RTStrNICmp(pcszFormat, "text/uri-list", cchFormatMax)) /** @todo Add "x-special/gnome-icon-list"? */
-        fNeedsDropDir = true;
-
-    return fNeedsDropDir;
+    return DnDMIMEHasFileURLs(pcszFormat, cchFormatMax);
 }
 

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

@@ -28 +28 @@
 #include <iprt/path.h>
 #include <iprt/string.h>
-
-
-/**
- * Sanitizes a path so that unsupported characters will be replaced by an underscore ("_").
+#include <iprt/uri.h>
+
+
+/**
+ * Sanitizes the file name portion of a path so that unsupported characters will be replaced by an underscore ("_").
  *
  * @return  IPRT status code.
- * @param   pszPath             Path to sanitize.
- * @param   cbPath              Size (in bytes) of path to sanitize.
- */
-int DnDPathSanitize(char *pszPath, size_t cbPath)
-{
-    if (!pszPath) /* No path given? Bail out early. */
+ * @param   pszFileName         File name to sanitize.
+ * @param   cbFileName          Size (in bytes) of file name to sanitize.
+ */
+int DnDPathSanitizeFileName(char *pszFileName, size_t cbFileName)
+{
+    if (!pszFileName) /* No path given? Bail out early. */
         return VINF_SUCCESS;
 
-    AssertReturn(cbPath, VERR_INVALID_PARAMETER);
+    AssertReturn(cbFileName, VERR_INVALID_PARAMETER);
 
     int rc = VINF_SUCCESS;
 #ifdef RT_OS_WINDOWS
-    RT_NOREF1(cbPath);
+    RT_NOREF1(cbFileName);
     /* Replace out characters not allowed on Windows platforms, put in by RTTimeSpecToString(). */
     /** @todo Use something like RTPathSanitize() if available later some time. */
@@ -62 +63 @@
     };
 
-    ssize_t cReplaced = RTStrPurgeComplementSet(pszPath, s_uszValidRangePairs, '_' /* chReplacement */);
+    ssize_t cReplaced = RTStrPurgeComplementSet(pszFileName, s_uszValidRangePairs, '_' /* chReplacement */);
     if (cReplaced < 0)
         rc = VERR_INVALID_UTF8_ENCODING;
 #else
-    RT_NOREF2(pszPath, cbPath);
+    RT_NOREF2(pszFileName, cbFileName);
 #endif
     return rc;
@@ -73 +74 @@
 /**
  * Validates whether a given path matches our set of rules or not.
+ *
+ * Rules:
+ * - An empty path is allowed.
+ * - Dot components ("." or "..") are forbidden.
+ * - If \a fMustExist is \c true, the path either has to be a file or a directory and must exist.
+ * - Symbolic links are forbidden.
  *
  * @returns VBox status code.
@@ -81 +88 @@
 int DnDPathValidate(const char *pcszPath, bool fMustExist)
 {
+    if (!pcszPath)
+        return VERR_INVALID_POINTER;
+
     int rc = VINF_SUCCESS;
-
-    if (!strlen(pcszPath))
-        rc = VERR_INVALID_PARAMETER;
 
     if (   RT_SUCCESS(rc)
@@ -136 +143 @@
     AssertReturn(!(fFlags & ~DNDPATHCONVERT_FLAGS_VALID_MASK), VERR_INVALID_FLAGS);
 
-#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
-    if (fFlags & DNDPATHCONVERT_FLAGS_TO_NATIVE)
-        RTPathChangeToDosSlashes(pszPath, true);
+    if (fFlags & DNDPATHCONVERT_FLAGS_TO_DOS)
+        RTPathChangeToDosSlashes(pszPath, true /* fForce */);
     else
-#else
-    RT_NOREF(fFlags);
-#endif
-    {
         RTPathChangeToUnixSlashes(pszPath, true /* fForce */);
-    }
 
     return VINF_SUCCESS;
 }
 
+/**
+ * Rebases an absolute path from an old path base to a new path base.
+ * Note: Does *not* do any path conversion.
+ *
+ * @return  IPRT status code.
+ * @param   pcszPath            Path to rebase.
+ * @param   strBaseOld          Old base path to rebase from. Optional and can be NULL.
+ * @param   strBaseNew          New base path to rebase to.
+ * @param   ppszPath            Where to store the allocated rebased path on success. Needs to be free'd with RTStrFree().
+ */
+int DnDPathRebase(const char *pcszPath, const char *pcszBaseOld, const char *pcszBaseNew,
+                  char **ppszPath)
+{
+    AssertPtrReturn(pcszPath, VERR_INVALID_POINTER);
+    AssertPtrReturn(pcszBaseOld, VERR_INVALID_POINTER);
+    AssertPtrReturn(pcszBaseNew, VERR_INVALID_POINTER);
+    AssertPtrReturn(ppszPath, VERR_INVALID_POINTER);
+
+    char szPath[RTPATH_MAX];
+
+    /* Do we need to see if the given path is part of the old base? */
+    size_t idxBase;
+    if (   pcszBaseOld
+        && RTPathStartsWith(pcszPath, pcszBaseOld))
+    {
+        idxBase = strlen(pcszBaseOld);
+    }
+    else
+        idxBase = 0;
+
+    int rc = RTStrCopy(szPath, sizeof(szPath), pcszBaseNew);
+    if (RT_SUCCESS(rc))
+    {
+        rc = RTPathAppend(szPath, sizeof(szPath), &pcszPath[idxBase]);
+        if (RT_SUCCESS(rc))
+            rc = DnDPathValidate(szPath, false /* fMustExist */);
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        char *pszPath = RTStrDup(szPath);
+        if (pszPath)
+            *ppszPath = pszPath;
+        else
+            rc = VERR_NO_MEMORY;
+    }
+
+    return rc;
+}
+

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

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * DnD - URI list class.
+ * DnD - transfer list implemenation.
  */
 
@@ -27 +27 @@
 #include <iprt/file.h>
 #include <iprt/fs.h>
+#include <iprt/mem.h>
 #include <iprt/path.h>
 #include <iprt/string.h>
@@ -35 +36 @@
 
 
-DnDURIList::DnDURIList(void)
-    : m_cTotal(0)
-    , m_cbTotal(0)
-{
-}
-
-DnDURIList::~DnDURIList(void)
-{
-    Clear();
-}
-
-int DnDURIList::addEntry(const char *pcszSource, const char *pcszTarget, DNDURILISTFLAGS fFlags)
-{
-    AssertPtrReturn(pcszSource, VERR_INVALID_POINTER);
-    AssertPtrReturn(pcszTarget, VERR_INVALID_POINTER);
-
-    LogFlowFunc(("pcszSource=%s, pcszTarget=%s, fFlags=0x%x\n", pcszSource, pcszTarget, fFlags));
-
-    RTFSOBJINFO objInfo;
-    int rc = RTPathQueryInfo(pcszSource, &objInfo, RTFSOBJATTRADD_NOTHING);
+/*********************************************************************************************************************************
+*   Prototypes                                                                                                                   *
+*********************************************************************************************************************************/
+static int dndTransferListSetRootPath(PDNDTRANSFERLIST pList, const char *pcszRootPathAbs);
+
+static int dndTransferListRootAdd(PDNDTRANSFERLIST pList, const char *pcszRoot);
+static void dndTransferListRootFree(PDNDTRANSFERLIST pList, PDNDTRANSFERLISTROOT pRootObj);
+
+static int dndTransferListObjAdd(PDNDTRANSFERLIST pList, const char *pcszSrcAbs, RTFMODE fMode, DNDTRANSFERLISTFLAGS fFlags);
+static void dndTransferListObjFree(PDNDTRANSFERLIST pList, PDNDTRANSFEROBJECT pLstObj);
+
+
+/** The size of the directory entry buffer we're using. */
+#define DNDTRANSFERLIST_DIRENTRY_BUF_SIZE (sizeof(RTDIRENTRYEX) + RTPATH_MAX)
+
+
+/**
+ * Initializes a transfer list.
+ *
+ * @returns VBox status code.
+ * @param   pList               Transfer list to initialize.
+ * @param   pcszRootPathAbs     Absolute root path to use for this list. Optional and can be NULL.
+ */
+int DnDTransferListInit(PDNDTRANSFERLIST pList, const char *pcszRootPathAbs)
+{
+    AssertPtrReturn(pList, VERR_INVALID_POINTER);
+    /* pcszRootPathAbs is optional. */
+
+    if (!strlen(pcszRootPathAbs))
+        return VERR_INVALID_PARAMETER;
+
+    if (pList->pszPathRootAbs)
+        return VERR_WRONG_ORDER;
+
+    pList->pszPathRootAbs = NULL;
+
+    RTListInit(&pList->lstRoot);
+    pList->cRoots = 0;
+
+    RTListInit(&pList->lstObj);
+    pList->cObj = 0;
+    pList->cbObjTotal = 0;
+
+    if (pcszRootPathAbs)
+        return dndTransferListSetRootPath(pList, pcszRootPathAbs);
+
+    return VINF_SUCCESS;
+}
+
+/**
+ * Destroys a transfer list.
+ *
+ * @param   pList               Transfer list to destroy.
+ */
+void DnDTransferListDestroy(PDNDTRANSFERLIST pList)
+{
+    if (!pList)
+        return;
+
+    DnDTransferListReset(pList);
+
+    RTStrFree(pList->pszPathRootAbs);
+    pList->pszPathRootAbs = NULL;
+}
+
+/**
+ * Resets a transfer list.
+ *
+ * Note: Does *not* clear the root path!
+ *
+ * @param   pList               Transfer list to clear.
+ */
+void DnDTransferListReset(PDNDTRANSFERLIST pList)
+{
+    AssertPtrReturnVoid(pList);
+
+    /* Note: This does not clear the root path! */
+
+    PDNDTRANSFERLISTROOT pRootCur, pRootNext;
+    RTListForEachSafe(&pList->lstRoot, pRootCur, pRootNext, DNDTRANSFERLISTROOT, Node)
+        dndTransferListRootFree(pList, pRootCur);
+    Assert(RTListIsEmpty(&pList->lstRoot));
+
+    PDNDTRANSFEROBJECT pObjCur, pObjNext;
+    RTListForEachSafe(&pList->lstObj, pObjCur, pObjNext, DNDTRANSFEROBJECT, Node)
+        dndTransferListObjFree(pList, pObjCur);
+    Assert(RTListIsEmpty(&pList->lstObj));
+
+    Assert(pList->cRoots == 0);
+    Assert(pList->cObj == 0);
+
+    pList->cbObjTotal = 0;
+}
+
+/**
+ * Adds a single transfer object entry to a transfer List.
+ *
+ * @returns VBox status code.
+ * @param   pList               Transfer list to add entry to.
+ * @param   pcszSrcAbs          Absolute source path (local) to use.
+ * @param   fMode               File mode of entry to add.
+ * @param   fFlags              Transfer list flags to use for appending.
+ */
+static int dndTransferListObjAdd(PDNDTRANSFERLIST pList, const char *pcszSrcAbs, RTFMODE fMode, DNDTRANSFERLISTFLAGS fFlags)
+{
+    AssertPtrReturn(pList, VERR_INVALID_POINTER);
+    AssertPtrReturn(pcszSrcAbs, VERR_INVALID_POINTER);
+
+    LogFlowFunc(("pcszSrcAbs=%s, fMode=%#x, fFlags=0x%x\n", pcszSrcAbs, fMode, fFlags));
+
+    int rc = VINF_SUCCESS;
+
+    if (   !RTFS_IS_FILE(fMode)
+        && !RTFS_IS_DIRECTORY(fMode))
+        /** @todo Symlinks not allowed. */
+    {
+        rc = VERR_NOT_SUPPORTED;
+    }
+
     if (RT_SUCCESS(rc))
     {
-        if (RTFS_IS_FILE(objInfo.Attr.fMode))
-        {
-            LogFlowFunc(("File '%s' -> '%s' (%RU64 bytes, file mode 0x%x)\n",
-                         pcszSource, pcszTarget, (uint64_t)objInfo.cbObject, objInfo.Attr.fMode));
-
-            DnDURIObject *pObjFile = new DnDURIObject(DnDURIObject::Type_File, pcszSource);
-            if (pObjFile)
+        /* Calculate the path to add as the destination path to our URI object. */
+        const size_t idxPathToAdd = strlen(pList->pszPathRootAbs);
+        AssertReturn(strlen(pcszSrcAbs) > idxPathToAdd, VERR_INVALID_PARAMETER); /* Should never happen (tm). */
+
+        PDNDTRANSFEROBJECT pObj = (PDNDTRANSFEROBJECT)RTMemAllocZ(sizeof(DNDTRANSFEROBJECT));
+        if (pObj)
+        {
+            pObj = (PDNDTRANSFEROBJECT)RTMemAllocZ(sizeof(DNDTRANSFEROBJECT));
+            if (pObj)
             {
-                /** @todo Add a standard fOpen mode for this list. */
-                rc = pObjFile->Open(RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_WRITE);
+                const bool fIsFile = RTFS_IS_FILE(fMode);
+
+                rc = DnDTransferObjectInit(pObj, fIsFile ? DNDTRANSFEROBJTYPE_FILE : DNDTRANSFEROBJTYPE_DIRECTORY,
+                                           pList->pszPathRootAbs, &pcszSrcAbs[idxPathToAdd]);
                 if (RT_SUCCESS(rc))
                 {
-                    m_lstTree.append(pObjFile);
-
-                    m_cTotal++;
-                    m_cbTotal += pObjFile->GetSize();
-
-                    if (!(fFlags & DNDURILIST_FLAGS_KEEP_OPEN)) /* Shall we keep the file open while being added to this list? */
-                        pObjFile->Close();
+                    if (fIsFile)
+                        rc = DnDTransferObjectOpen(pObj,
+                                                   RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_WRITE, /** @todo Add a standard fOpen mode for this list. */
+                                                   0 /* fMode */, DNDTRANSFEROBJECT_FLAGS_NONE);
+                    if (RT_SUCCESS(rc))
+                    {
+                        RTListAppend(&pList->lstObj, &pObj->Node);
+
+                        pList->cObj++;
+                        if (fIsFile)
+                            pList->cbObjTotal += DnDTransferObjectGetSize(pObj);
+
+                        if (   fIsFile
+                            && !(fFlags & DNDTRANSFERLIST_FLAGS_KEEP_OPEN)) /* Shall we keep the file open while being added to this list? */
+                            DnDTransferObjectClose(pObj);
+                    }
+
+                    if (RT_FAILURE(rc))
+                        DnDTransferObjectDestroy(pObj);
                 }
 
                 if (RT_FAILURE(rc))
-                    delete pObjFile;
+                    RTMemFree(pObj);
             }
             else
                 rc = VERR_NO_MEMORY;
-        }
-        else if (RTFS_IS_DIRECTORY(objInfo.Attr.fMode))
-        {
-            LogFlowFunc(("Directory '%s' -> '%s' (file mode 0x%x)\n", pcszSource, pcszTarget, objInfo.Attr.fMode));
-
-            DnDURIObject *pObjDir = new DnDURIObject(DnDURIObject::Type_Directory, pcszSource);
-            if (pObjDir)
+
+            if (RT_FAILURE(rc))
+                RTMemFree(pObj);
+        }
+        else
+            rc = VERR_NO_MEMORY;
+    }
+
+    if (RT_FAILURE(rc))
+        LogRel(("DnD: Adding entry '%s' of type %#x failed with rc=%Rrc\n", pcszSrcAbs, fMode & RTFS_TYPE_MASK, rc));
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+/**
+ * Frees an internal DnD transfer list object.
+ *
+ * @param   pList               Transfer list to free object for.
+ * @param   pLstObj             transfer list object to free. The pointer will be invalid after calling.
+ */
+static void dndTransferListObjFree(PDNDTRANSFERLIST pList, PDNDTRANSFEROBJECT pObj)
+{
+    if (!pObj)
+        return;
+
+    DnDTransferObjectDestroy(pObj);
+    RTListNodeRemove(&pObj->Node);
+    RTMemFree(pObj);
+
+    AssertReturnVoid(pList->cObj);
+    pList->cObj--;
+}
+
+/**
+ * Helper routine for handling adding sub directories.
+ *
+ * @return  IPRT status code.
+ * @param   pList           transfer list to add found entries to.
+ * @param   pszDir          Pointer to the directory buffer.
+ * @param   cchDir          The length of pszDir in pszDir.
+ * @param   pDirEntry       Pointer to the directory entry.
+ * @param   fFlags          Flags of type DNDTRANSFERLISTFLAGS.
+ */
+static int dndTransferListAppendPathRecursiveSub(PDNDTRANSFERLIST pList,
+                                                 char *pszDir, size_t cchDir, PRTDIRENTRYEX pDirEntry,
+                                                 DNDTRANSFERLISTFLAGS fFlags)
+
+{
+    Assert(cchDir > 0); Assert(pszDir[cchDir] == '\0');
+
+    /* Make sure we've got some room in the path, to save us extra work further down. */
+    if (cchDir + 3 >= RTPATH_MAX)
+        return VERR_BUFFER_OVERFLOW;
+
+    /* Open directory. */
+    RTDIR hDir;
+    int rc = RTDirOpen(&hDir, pszDir);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    /* Ensure we've got a trailing slash (there is space for it see above). */
+    if (!RTPATH_IS_SEP(pszDir[cchDir - 1]))
+    {
+        pszDir[cchDir++] = RTPATH_SLASH;
+        pszDir[cchDir]   = '\0';
+    }
+
+    LogFlowFunc(("pszDir=%s\n", pszDir));
+
+    /*
+     * Process the files and subdirs.
+     */
+    for (;;)
+    {
+        /* Get the next directory. */
+        size_t cbDirEntry = DNDTRANSFERLIST_DIRENTRY_BUF_SIZE;
+        rc = RTDirReadEx(hDir, pDirEntry, &cbDirEntry, RTFSOBJATTRADD_UNIX, RTPATH_F_ON_LINK);
+        if (RT_FAILURE(rc))
+            break;
+
+        /* Check length. */
+        if (pDirEntry->cbName + cchDir + 3 >= RTPATH_MAX)
+        {
+            rc = VERR_BUFFER_OVERFLOW;
+            break;
+        }
+
+        switch (pDirEntry->Info.Attr.fMode & RTFS_TYPE_MASK)
+        {
+            case RTFS_TYPE_SYMLINK:
             {
-                m_lstTree.append(pObjDir);
-
-                /** @todo Add DNDURILIST_FLAGS_KEEP_OPEN handling? */
-                m_cTotal++;
+                if (!(fFlags & DNDTRANSFERLIST_FLAGS_RESOLVE_SYMLINKS))
+                    break;
+                RT_FALL_THRU();
+            }
+            case RTFS_TYPE_DIRECTORY:
+            {
+                if (RTDirEntryExIsStdDotLink(pDirEntry))
+                    continue;
+
+                memcpy(&pszDir[cchDir], pDirEntry->szName, pDirEntry->cbName + 1);
+                int rc2 = dndTransferListAppendPathRecursiveSub(pList, pszDir, cchDir + pDirEntry->cbName, pDirEntry, fFlags);
+                if (RT_SUCCESS(rc))
+                    rc = rc2;
+                break;
+            }
+
+            case RTFS_TYPE_FILE:
+            {
+                memcpy(&pszDir[cchDir], pDirEntry->szName, pDirEntry->cbName + 1);
+                rc = dndTransferListObjAdd(pList, pszDir, pDirEntry->Info.Attr.fMode, fFlags);
+                break;
+            }
+
+            default:
+            {
+
+                break;
+            }
+        }
+    }
+
+    if (rc == VERR_NO_MORE_FILES) /* Done reading current directory? */
+    {
+        rc = VINF_SUCCESS;
+    }
+    else if (RT_FAILURE(rc))
+        LogRel(("DnD: Error while adding files recursively, rc=%Rrc\n", rc));
+
+    int rc2 = RTDirClose(hDir);
+    if (RT_FAILURE(rc2))
+    {
+        if (RT_SUCCESS(rc))
+            rc = rc2;
+    }
+
+    return rc;
+}
+
+/**
+ * Appends a native system path recursively by adding these entries as transfer objects.
+ *
+ * @returns VBox status code.
+ * @param   pList               Transfer list to add found entries to.
+ * @param   pcszPathAbs         Absolute path to add.
+ * @param   fFlags              Flags of type DNDTRANSFERLISTFLAGS.
+ */
+static int dndTransferListAppendPathNativeRecursive(PDNDTRANSFERLIST pList,
+                                                    const char *pcszPathAbs, DNDTRANSFERLISTFLAGS fFlags)
+{
+    char szPathAbs[RTPATH_MAX];
+    int rc = RTStrCopy(szPathAbs, sizeof(szPathAbs), pcszPathAbs);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    union
+    {
+        uint8_t         abPadding[DNDTRANSFERLIST_DIRENTRY_BUF_SIZE];
+        RTDIRENTRYEX    DirEntry;
+    } uBuf;
+    const size_t cchPathAbs = strlen(szPathAbs);
+    if (!cchPathAbs)
+        return VINF_SUCCESS;
+    return dndTransferListAppendPathRecursiveSub(pList, szPathAbs, cchPathAbs, &uBuf.DirEntry, fFlags);
+}
+
+static int dndTransferListAppendPathNative(PDNDTRANSFERLIST pList, const char *pcszPath, DNDTRANSFERLISTFLAGS fFlags)
+{
+    /* We don't want to have a relative directory here. */
+    if (!RTPathStartsWithRoot(pcszPath))
+        return VERR_INVALID_PARAMETER;
+
+    int rc = DnDPathValidate(pcszPath, false /* fMustExist */);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    char szPathAbs[RTPATH_MAX];
+    rc = RTStrCopy(szPathAbs, sizeof(szPathAbs), pcszPath);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    size_t cchPathAbs = RTStrNLen(szPathAbs, sizeof(szPathAbs));
+    AssertReturn(cchPathAbs, VERR_INVALID_PARAMETER);
+
+    /* Convert path to transport style. */
+    rc = DnDPathConvert(szPathAbs, sizeof(szPathAbs), DNDPATHCONVERT_FLAGS_TRANSPORT);
+    if (RT_SUCCESS(rc))
+    {
+        /* Make sure the path has the same root path as our list. */
+        if (RTPathStartsWith(szPathAbs, pList->pszPathRootAbs))
+        {
+            RTDIR hDir;
+            rc = RTDirOpen(&hDir, szPathAbs);
+            if (RT_SUCCESS(rc))
+            {
+                for (;;)
+                {
+                    /* Get the next directory. */
+                    RTDIRENTRYEX dirEntry;
+                    rc = RTDirReadEx(hDir, &dirEntry, NULL, RTFSOBJATTRADD_UNIX, RTPATH_F_ON_LINK /** @todo No symlinks yet. */);
+                    if (RT_SUCCESS(rc))
+                    {
+                        if (RTDirEntryExIsStdDotLink(&dirEntry))
+                            continue;
+
+                        /* Check length. */
+                        if (dirEntry.cbName + cchPathAbs + 3 >= sizeof(szPathAbs))
+                        {
+                            rc = VERR_BUFFER_OVERFLOW;
+                            break;
+                        }
+
+                        /* Append the directory entry to our absolute path. */
+                        memcpy(&szPathAbs[cchPathAbs], dirEntry.szName, dirEntry.cbName + 1);
+
+                        LogFlowFunc(("szName=%s, szPathAbs=%s\n", dirEntry.szName, szPathAbs));
+
+                        switch (dirEntry.Info.Attr.fMode & RTFS_TYPE_MASK)
+                        {
+                            case RTFS_TYPE_DIRECTORY:
+                            {
+                                rc = dndTransferListAppendPathNativeRecursive(pList, szPathAbs, fFlags);
+                                break;
+                            }
+
+                            case RTFS_TYPE_FILE:
+                            {
+                                rc = dndTransferListObjAdd(pList, szPathAbs, dirEntry.Info.Attr.fMode, fFlags);
+                                break;
+                            }
+
+                            default:
+                                rc = VERR_NOT_SUPPORTED;
+                                break;
+                        }
+
+                        if (RT_SUCCESS(rc))
+                            rc = dndTransferListRootAdd(pList, dirEntry.szName);
+                    }
+                    else if (rc == VERR_NO_MORE_FILES)
+                    {
+                        rc = VINF_SUCCESS;
+                        break;
+                    }
+                    else
+                        break;
+
+                    if (RT_FAILURE(rc))
+                        break;
+                }
+            }
+        }
+        else
+            rc = VERR_INVALID_PARAMETER;
+    }
+
+    if (RT_FAILURE(rc))
+        LogRel(("DnD: Adding native path '%s' failed with rc=%Rrc\n", pcszPath, rc));
+
+    return rc;
+}
+
+static int dndTransferListAppendPathURI(PDNDTRANSFERLIST pList, const char *pcszPath, DNDTRANSFERLISTFLAGS fFlags)
+{
+    RT_NOREF(fFlags);
+
+    /* Query the path component of a file URI. If this hasn't a
+     * file scheme, NULL is returned. */
+    char *pszFilePath;
+    int rc = RTUriFilePathEx(pcszPath, RTPATH_STR_F_STYLE_UNIX, &pszFilePath, 0 /*cbPath*/, NULL /*pcchPath*/);
+    if (RT_SUCCESS(rc))
+    {
+        LogFlowFunc(("pcszPath=%s -> pszFilePath=%s\n", pcszPath, pszFilePath));
+        rc = dndTransferListRootAdd(pList, pszFilePath);
+        RTStrFree(pszFilePath);
+
+    }
+
+    if (RT_FAILURE(rc))
+        LogRel(("DnD: Adding URI path '%s' failed with rc=%Rrc\n", pcszPath, rc));
+
+    return rc;
+}
+
+/**
+ * Appends a single path to a transfer list.
+ *
+ * @returns VBox status code. VERR_NOT_SUPPORTED if the path is not supported.
+ * @param   pList               Transfer list to append to.
+ * @param   enmFmt              Format of \a pszPaths to append.
+ * @param   pcszPath            Path to append. Must be part of the list's set root path.
+ * @param   fFlags              Transfer list flags to use for appending.
+ */
+int DnDTransferListAppendPath(PDNDTRANSFERLIST pList,
+                              DNDTRANSFERLISTFMT enmFmt, const char *pcszPath, DNDTRANSFERLISTFLAGS fFlags)
+{
+    AssertPtrReturn(pList, VERR_INVALID_POINTER);
+    AssertPtrReturn(pcszPath, VERR_INVALID_POINTER);
+    AssertReturn(!(fFlags & ~DNDTRANSFERLIST_FLAGS_VALID_MASK), VERR_INVALID_FLAGS);
+    AssertReturn(!(fFlags & DNDTRANSFERLIST_FLAGS_RESOLVE_SYMLINKS), VERR_NOT_SUPPORTED);
+
+    int rc;
+
+    switch (enmFmt)
+    {
+        case DNDTRANSFERLISTFMT_NATIVE:
+            rc = dndTransferListAppendPathNative(pList, pcszPath, fFlags);
+            break;
+
+        case DNDTRANSFERLISTFMT_URI:
+            rc = dndTransferListAppendPathURI(pList, pcszPath, fFlags);
+            break;
+
+        default:
+            AssertFailedStmt(rc = VERR_NOT_SUPPORTED);
+            break; /* Never reached */
+    }
+
+    return rc;
+}
+
+/**
+ * Appends native paths to a transfer list.
+ *
+ * @returns VBox status code.
+ * @param   pList               Transfer list to append to.
+ * @param   enmFmt              Format of \a pszPaths to append.
+ * @param   pszPaths            Buffer of paths to append.
+ * @param   cbPaths             Size (in bytes) of buffer of paths to append.
+ * @param   pcszSeparator       Separator string to use.
+ * @param   fFlags              Transfer list flags to use for appending.
+ */
+int DnDTransferListAppendPathsFromBuffer(PDNDTRANSFERLIST pList,
+                                         DNDTRANSFERLISTFMT enmFmt, const char *pszPaths, size_t cbPaths,
+                                         const char *pcszSeparator, DNDTRANSFERLISTFLAGS fFlags)
+{
+    AssertPtrReturn(pList, VERR_INVALID_POINTER);
+    AssertPtrReturn(pszPaths, VERR_INVALID_POINTER);
+    AssertReturn(cbPaths, VERR_INVALID_PARAMETER);
+
+    char **papszPaths = NULL;
+    size_t cPaths = 0;
+    int rc = RTStrSplit(pszPaths, cbPaths, pcszSeparator, &papszPaths, &cPaths);
+    if (RT_SUCCESS(rc))
+        rc = DnDTransferListAppendPathsFromArray(pList, enmFmt, papszPaths, cPaths, fFlags);
+
+    for (size_t i = 0; i < cPaths; ++i)
+        RTStrFree(papszPaths[i]);
+    RTMemFree(papszPaths);
+
+    return rc;
+}
+
+/**
+ * Appends paths to a transfer list.
+ *
+ * @returns VBox status code. Will return VERR_INVALID_PARAMETER if a common root path could not be found.
+ * @param   pList               Transfer list to append path to.
+ * @param   enmFmt              Format of \a papcszPaths to append.
+ * @param   papcszPaths         Array of paths to append.
+ * @param   cPaths              Number of paths in \a papcszPaths to append.
+ * @param   fFlags              Transfer list flags to use for appending.
+ */
+int DnDTransferListAppendPathsFromArray(PDNDTRANSFERLIST pList,
+                                        DNDTRANSFERLISTFMT enmFmt,
+                                        const char * const *papcszPaths, size_t cPaths, DNDTRANSFERLISTFLAGS fFlags)
+{
+    AssertPtrReturn(pList, VERR_INVALID_POINTER);
+    AssertPtrReturn(papcszPaths, VERR_INVALID_POINTER);
+    AssertReturn(!(fFlags & ~DNDTRANSFERLIST_FLAGS_VALID_MASK), VERR_INVALID_FLAGS);
+
+    int rc = VINF_SUCCESS;
+
+    if (!cPaths) /* Nothing to add? Bail out. */
+        return VINF_SUCCESS;
+
+    /* If we don't have a root path set, try to find the common path of all handed-in paths. */
+    if (!pList->pszPathRootAbs)
+    {
+        size_t cchRootPath = RTPathFindCommon(papcszPaths, cPaths);
+        if (cchRootPath)
+        {
+            /* Just use the first path in the array as the reference. */
+            char *pszRootPath = RTStrDupN(papcszPaths[0], cchRootPath);
+            if (pszRootPath)
+            {
+                LogRel2(("DnD: Determined root path is '%s'\n", pszRootPath));
+                rc = dndTransferListSetRootPath(pList, pszRootPath);
+                RTStrFree(pszRootPath);
             }
             else
                 rc = VERR_NO_MEMORY;
         }
-        /* Note: Symlinks already should have been resolved at this point. */
+    }
+
+    /*
+     * Go through the created list and make sure all entries have the same root path.
+     */
+    for (size_t i = 0; i < cPaths; i++)
+    {
+        rc = DnDTransferListAppendPath(pList, enmFmt, papcszPaths[i], fFlags);
+        if (RT_FAILURE(rc))
+            break;
+    }
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+/**
+ * Returns the first transfer object in a list.
+ *
+ * @returns Pointer to transfer object if found, or NULL if not found.
+ * @param   pList               Transfer list to get first transfer object from.
+ */
+PDNDTRANSFEROBJECT DnDTransferListObjGetFirst(PDNDTRANSFERLIST pList)
+{
+    AssertPtrReturn(pList, NULL);
+
+    return RTListGetFirst(&pList->lstObj, DNDTRANSFEROBJECT, Node);
+}
+
+/**
+ * Removes the first DnD transfer object from a transfer list.
+ *
+ * @param   pList               Transfer list to remove first entry for.
+ */
+void DnDTransferListObjRemoveFirst(PDNDTRANSFERLIST pList)
+{
+    AssertPtrReturnVoid(pList);
+
+    if (!pList->cObj)
+        return;
+
+    PDNDTRANSFEROBJECT pObj = RTListGetFirst(&pList->lstObj, DNDTRANSFEROBJECT, Node);
+    AssertPtr(pObj);
+
+    uint64_t cbSize = DnDTransferObjectGetSize(pObj);
+    Assert(pList->cbObjTotal >= cbSize);
+    pList->cbObjTotal -= cbSize; /* Adjust total size. */
+
+    dndTransferListObjFree(pList, pObj);
+}
+
+/**
+ * Returns all root entries of a transfer list as a string.
+ *
+ * @returns VBox status code.
+ * @param   pList               Transfer list to return root paths for.
+ * @param   pcszPathBase        Root path to use as a base path. If NULL, the list's absolute root path will be used (if any).
+ * @param   pcszSeparator       Separator to use for separating the root entries.
+ * @param   ppszBuffer          Where to return the allocated string on success. Needs to be free'd with RTStrFree().
+ * @param   pcbBuffer           Where to return the size (in bytes) of the allocated string on success, including terminator.
+ */
+int DnDTransferListGetRootsEx(PDNDTRANSFERLIST pList,
+                              DNDTRANSFERLISTFMT enmFmt, const char *pcszPathBase, const char *pcszSeparator,
+                              char **ppszBuffer, size_t *pcbBuffer)
+{
+    AssertPtrReturn(pList, VERR_INVALID_POINTER);
+    /* pcszPathBase can be NULL. */
+    AssertPtrReturn(pcszSeparator, VERR_INVALID_POINTER);
+    AssertPtrReturn(ppszBuffer, VERR_INVALID_POINTER);
+    AssertPtrReturn(pcbBuffer, VERR_INVALID_POINTER);
+
+    char *pszString = NULL;
+
+    /* Find out which root path to use. */
+    const char *pcszPathRootTmp = pcszPathBase ? pcszPathBase : pList->pszPathRootAbs;
+    /* pcszPathRootTmp can be NULL*/
+
+    LogFlowFunc(("Using root path '%s'\n", pcszPathRootTmp ? pcszPathRootTmp : "<None>"));
+
+    int rc = DnDPathValidate(pcszPathRootTmp, false /* fMustExist */);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    char szPath[RTPATH_MAX];
+
+    PDNDTRANSFERLISTROOT pRoot;
+    RTListForEach(&pList->lstRoot, pRoot, DNDTRANSFERLISTROOT, Node)
+    {
+        if (pcszPathRootTmp)
+        {
+            rc = RTStrCopy(szPath, sizeof(szPath), pcszPathRootTmp);
+            AssertRCBreak(rc);
+        }
+
+        rc = RTPathAppend(szPath, sizeof(szPath), pRoot->pszPathRoot);
+        AssertRCBreak(rc);
+
+        if (enmFmt == DNDTRANSFERLISTFMT_URI)
+        {
+            char *pszPathURI = RTUriFileCreate(szPath);
+            AssertPtrBreakStmt(pszPathURI, rc = VERR_NO_MEMORY);
+
+            rc = RTStrAAppend(&pszString, pszPathURI);
+            RTStrFree(pszPathURI);
+            AssertRCBreak(rc);
+        }
         else
-            rc = VERR_NOT_SUPPORTED;
-    }
-
-    LogFlowFuncLeaveRC(rc);
-    return rc;
-}
-
-int DnDURIList::appendPathRecursive(const char *pcszSrcPath,
-                                    const char *pcszDstPath, const char *pcszDstBase, size_t cchDstBase,
-                                    DNDURILISTFLAGS fFlags)
-{
-    AssertPtrReturn(pcszSrcPath, VERR_INVALID_POINTER);
-    AssertPtrReturn(pcszDstBase, VERR_INVALID_POINTER);
-    AssertPtrReturn(pcszDstPath, VERR_INVALID_POINTER);
-
-    LogFlowFunc(("pcszSrcPath=%s, pcszDstPath=%s, pcszDstBase=%s, cchDstBase=%zu, fFlags=0x%x\n",
-                 pcszSrcPath, pcszDstPath, pcszDstBase, cchDstBase, fFlags));
-
-    RTFSOBJINFO objInfo;
-    int rc = RTPathQueryInfo(pcszSrcPath, &objInfo, RTFSOBJATTRADD_NOTHING);
+        {
+            rc = RTStrAAppend(&pszString, szPath);
+            AssertRCBreak(rc);
+        }
+
+        rc = RTStrAAppend(&pszString, pcszSeparator);
+        AssertRCBreak(rc);
+    }
+
     if (RT_SUCCESS(rc))
     {
-        if (RTFS_IS_DIRECTORY(objInfo.Attr.fMode))
-        {
-            rc = addEntry(pcszSrcPath, &pcszDstPath[cchDstBase], fFlags);
+        *ppszBuffer = pszString;
+        *pcbBuffer  = pszString ? strlen(pszString) + 1 /* Include termination */ : 0;
+    }
+    else
+        RTStrFree(pszString);
+    return rc;
+}
+
+int DnDTransferListGetRoots(PDNDTRANSFERLIST pList,
+                            DNDTRANSFERLISTFMT enmFmt, char **ppszBuffer, size_t *pcbBuffer)
+{
+    return DnDTransferListGetRootsEx(pList, enmFmt, "" /* pcszPathRoot */, DND_PATH_SEPARATOR,
+                                     ppszBuffer, pcbBuffer);
+}
+
+/**
+ * Returns the total root entries count for a DnD transfer list.
+ *
+ * @returns Total number of root entries.
+ * @param   pList               Transfer list to return total number of root entries for.
+ */
+uint64_t DnDTransferListGetRootCount(PDNDTRANSFERLIST pList)
+{
+    AssertPtrReturn(pList, 0);
+    return pList->cRoots;
+}
+
+/**
+ * Returns the absolute root path for a DnD transfer list.
+ *
+ * @returns Pointer to the root path.
+ * @param   pList               Transfer list to return root path for.
+ */
+const char *DnDTransferListGetRootPathAbs(PDNDTRANSFERLIST pList)
+{
+    AssertPtrReturn(pList, NULL);
+    return pList->pszPathRootAbs;
+}
+
+/**
+ * Returns the total transfer object count for a DnD transfer list.
+ *
+ * @returns Total number of transfer objects.
+ * @param   pList               Transfer list to return total number of transfer objects for.
+ */
+uint64_t DnDTransferListObjCount(PDNDTRANSFERLIST pList)
+{
+    AssertPtrReturn(pList, 0);
+    return pList->cObj;
+}
+
+/**
+ * Returns the total bytes of all handled transfer objects for a DnD transfer list.
+ *
+ * @returns VBox status code.
+ * @param   pList               Transfer list to return total bytes for.
+ */
+uint64_t DnDTransferListObjTotalBytes(PDNDTRANSFERLIST pList)
+{
+    AssertPtrReturn(pList, 0);
+    return pList->cbObjTotal;
+}
+
+/**
+ * Sets the absolute root path of a transfer list.
+ *
+ * @returns VBox status code.
+ * @param   pList               Transfer list to set root path for.
+ * @param   pcszRootPathAbs     Absolute root path to set.
+ */
+static int dndTransferListSetRootPath(PDNDTRANSFERLIST pList, const char *pcszRootPathAbs)
+{
+    AssertPtrReturn(pList, VERR_INVALID_POINTER);
+    AssertPtrReturn(pcszRootPathAbs, VERR_INVALID_POINTER);
+    AssertReturn(pList->pszPathRootAbs == NULL, VERR_WRONG_ORDER); /* Already initialized? */
+
+    LogFlowFunc(("pcszRootPathAbs=%s\n", pcszRootPathAbs));
+
+    char szRootPath[RTPATH_MAX];
+    int rc = RTStrCopy(szRootPath, sizeof(szRootPath), pcszRootPathAbs);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    /* Note: The list's root path is kept in native style, so no conversion needed here. */
+
+    RTPathEnsureTrailingSeparatorEx(szRootPath, sizeof(szRootPath), RTPATH_STR_F_STYLE_HOST);
+
+    pList->pszPathRootAbs = RTStrDup(szRootPath);
+    if (pList->pszPathRootAbs)
+    {
+        LogFlowFunc(("Root path is '%s'\n", pList->pszPathRootAbs));
+    }
+    else
+        rc = VERR_NO_MEMORY;
+
+    return rc;
+}
+
+static int dndTransferListRootAdd(PDNDTRANSFERLIST pList, const char *pcszRoot)
+{
+    int rc;
+
+    PDNDTRANSFERLISTROOT pRoot = (PDNDTRANSFERLISTROOT)RTMemAllocZ(sizeof(DNDTRANSFERLISTROOT));
+    if (pRoot)
+    {
+        pRoot->pszPathRoot = RTStrDup(pcszRoot);
+        if (pRoot->pszPathRoot)
+        {
+            RTListAppend(&pList->lstRoot, &pRoot->Node);
+            pList->cRoots++;
+
+            rc = VINF_SUCCESS;
+        }
+        else
+            rc = VERR_NO_MEMORY;
+
+        if (RT_FAILURE(rc))
+        {
+            RTMemFree(pRoot);
+            pRoot = NULL;
+        }
+    }
+    else
+        rc = VERR_NO_MEMORY;
+
+    return rc;
+}
+
+/**
+ * Frees an internal DnD transfer root.
+ *
+ * @param   pList               Transfer list to free root for.
+ * @param   pRootObj            Transfer list root to free. The pointer will be invalid after calling.
+ */
+static void dndTransferListRootFree(PDNDTRANSFERLIST pList, PDNDTRANSFERLISTROOT pRootObj)
+{
+    if (!pRootObj)
+        return;
+
+    RTStrFree(pRootObj->pszPathRoot);
+
+    RTListNodeRemove(&pRootObj->Node);
+    RTMemFree(pRootObj);
+
+    AssertReturnVoid(pList->cRoots);
+    pList->cRoots--;
+}
+
+
+#if 0
+/**
+ * Appends a single URI path to a transfer list.
+ *
+ * @returns VBox status code.
+ * @param   pList               Transfer list to append URI path to.
+ * @param   pszURIPath          URI path to append.
+ * @param   fFlags              Transfer list flags to use for appending.
+ */
+int DnDTransferListURIAppendPath(PDNDTRANSFERLIST pList, const char *pszURIPath, DNDTRANSFERLISTFLAGS fFlags)
+{
+    AssertPtrReturn(pList, VERR_INVALID_POINTER);
+    AssertPtrReturn(pszURIPath, VERR_INVALID_POINTER);
+    AssertReturn(!(fFlags & ~DNDTRANSFERLIST_FLAGS_VALID_MASK), VERR_INVALID_FLAGS);
+
+    in rc;
+
+    /* Query the path component of a file URI. If this hasn't a
+     * file scheme, NULL is returned. */
+    char *pszFilePath = RTUriFilePathEx(pszURIPath, RTPATH_STR_F_STYLE_UNIX, &pszFilePath, 0 /*cbPath*/, NULL /*pcchPath*/);
+    LogFlowFunc(("pszPath=%s, pszFilePath=%s\n", pszFilePath));
+    if (pszFilePath)
+    {
+        rc = DnDPathValidate(pszFilePath, false /* fMustExist */);
+        if (RT_SUCCESS(rc))
+        {
+            uint32_t fPathConvert = DNDPATHCONVERT_FLAGS_TRANSPORT;
+#ifdef RT_OS_WINDOWS
+            fPathConvert |= DNDPATHCONVERT_FLAGS_TO_DOS;
+#endif
+            rc = DnDPathConvert(pszFilePath, strlen(pszFilePath) + 1, fPathConvert);
             if (RT_SUCCESS(rc))
             {
-                RTDIR hDir;
-                rc = RTDirOpen(&hDir, pcszSrcPath);
-                if (RT_SUCCESS(rc))
+                LogRel2(("DnD: Got URI data item '%s'\n", pszFilePath));
+
+                PDNDTRANSFERLISTROOT pRoot = (PDNDTRANSFERLISTROOT)RTMemAlloc(sizeof(DNDTRANSFERLISTROOT));
+                if (pRoot)
                 {
-                    size_t        cbDirEntry = 0;
-                    PRTDIRENTRYEX pDirEntry  = NULL;
-                    do
-                    {
-                        /* Retrieve the next directory entry. */
-                        rc = RTDirReadExA(hDir, &pDirEntry, &cbDirEntry, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
-                        if (RT_FAILURE(rc))
-                        {
-                            if (rc == VERR_NO_MORE_FILES)
-                                rc = VINF_SUCCESS;
-                            break;
-                        }
-
-                        switch (pDirEntry->Info.Attr.fMode & RTFS_TYPE_MASK)
-                        {
-                            case RTFS_TYPE_DIRECTORY:
-                            {
-                                /* Skip "." and ".." entries. */
-                                if (RTDirEntryExIsStdDotLink(pDirEntry))
-                                    break;
-
-                                char *pszSrc = RTPathJoinA(pcszSrcPath, pDirEntry->szName);
-                                if (pszSrc)
-                                {
-                                    char *pszDst = RTPathJoinA(pcszDstPath, pDirEntry->szName);
-                                    if (pszDst)
-                                    {
-                                        rc = appendPathRecursive(pszSrc, pszDst, pcszDstBase, cchDstBase, fFlags);
-                                        RTStrFree(pszDst);
-                                    }
-                                    else
-                                        rc = VERR_NO_MEMORY;
-
-                                    RTStrFree(pszSrc);
-                                }
-                                else
-                                    rc = VERR_NO_MEMORY;
-                                break;
-                            }
-
-                            case RTFS_TYPE_FILE:
-                            {
-                                char *pszSrc = RTPathJoinA(pcszSrcPath, pDirEntry->szName);
-                                if (pszSrc)
-                                {
-                                    char *pszDst = RTPathJoinA(pcszDstPath, pDirEntry->szName);
-                                    if (pszDst)
-                                    {
-                                        rc = addEntry(pszSrc, &pszDst[cchDstBase], fFlags);
-                                        RTStrFree(pszDst);
-                                    }
-                                    else
-                                        rc = VERR_NO_MEMORY;
-                                    RTStrFree(pszSrc);
-                                }
-                                else
-                                    rc = VERR_NO_MEMORY;
-                                break;
-                            }
-                            case RTFS_TYPE_SYMLINK:
-                            {
-                                if (fFlags & DNDURILIST_FLAGS_RESOLVE_SYMLINKS)
-                                {
-                                    char *pszSrc = RTPathRealDup(pcszDstBase);
-                                    if (pszSrc)
-                                    {
-                                        rc = RTPathQueryInfo(pszSrc, &objInfo, RTFSOBJATTRADD_NOTHING);
-                                        if (RT_SUCCESS(rc))
-                                        {
-                                            if (RTFS_IS_DIRECTORY(objInfo.Attr.fMode))
-                                            {
-                                                LogFlowFunc(("Directory entry is symlink to directory\n"));
-                                                rc = appendPathRecursive(pszSrc, pcszDstPath, pcszDstBase, cchDstBase, fFlags);
-                                            }
-                                            else if (RTFS_IS_FILE(objInfo.Attr.fMode))
-                                            {
-                                                LogFlowFunc(("Directory entry is symlink to file\n"));
-                                                rc = addEntry(pszSrc, &pcszDstPath[cchDstBase], fFlags);
-                                            }
-                                            else
-                                                rc = VERR_NOT_SUPPORTED;
-                                        }
-
-                                        RTStrFree(pszSrc);
-                                    }
-                                    else
-                                        rc = VERR_NO_MEMORY;
-                                }
-                                break;
-                            }
-
-                            default:
-                                break;
-                        }
-
-                    } while (RT_SUCCESS(rc));
-
-                    RTDirReadExAFree(&pDirEntry, &cbDirEntry);
-                    RTDirClose(hDir);
-                }
-            }
-        }
-        else if (RTFS_IS_FILE(objInfo.Attr.fMode))
-        {
-            rc = addEntry(pcszSrcPath, &pcszDstPath[cchDstBase], fFlags);
-        }
-        else if (RTFS_IS_SYMLINK(objInfo.Attr.fMode))
-        {
-            if (fFlags & DNDURILIST_FLAGS_RESOLVE_SYMLINKS)
-            {
-                char *pszSrc = RTPathRealDup(pcszSrcPath);
-                if (pszSrc)
-                {
-                    rc = RTPathQueryInfo(pszSrc, &objInfo, RTFSOBJATTRADD_NOTHING);
-                    if (RT_SUCCESS(rc))
-                    {
-                        if (RTFS_IS_DIRECTORY(objInfo.Attr.fMode))
-                        {
-                            LogFlowFunc(("Symlink to directory\n"));
-                            rc = appendPathRecursive(pszSrc, pcszDstPath, pcszDstBase, cchDstBase, fFlags);
-                        }
-                        else if (RTFS_IS_FILE(objInfo.Attr.fMode))
-                        {
-                            LogFlowFunc(("Symlink to file\n"));
-                            rc = addEntry(pszSrc, &pcszDstPath[cchDstBase], fFlags);
-                        }
-                        else
-                            rc = VERR_NOT_SUPPORTED;
-                    }
-
-                    RTStrFree(pszSrc);
+                    pRoot->pszPathRoot = pszFilePath;
+
+                    RTListAppend(&pList->lstRoot, &pRoot->Node);
+                    pList->cRoots++;
+
                 }
                 else
                     rc = VERR_NO_MEMORY;
             }
+            else
+                LogRel(("DnD: Path conversion of URI data item '%s' failed with %Rrc\n", pszFilePath, rc));
         }
         else
-            rc = VERR_NOT_SUPPORTED;
+            LogRel(("DnD: Path validation for URI data item '%s' failed with %Rrc\n", pszFilePath, rc));
+
+        if (RT_FAILURE(rc))
+            RTStrFree(pszFilePath);
     }
 
@@ -276 +921 @@
 }
 
-int DnDURIList::AppendNativePath(const char *pszPath, DNDURILISTFLAGS fFlags)
-{
-    AssertPtrReturn(pszPath, VERR_INVALID_POINTER);
-
-    int rc;
-    char *pszPathNative = RTStrDup(pszPath);
-    if (pszPathNative)
-    {
-        RTPathChangeToUnixSlashes(pszPathNative, true /* fForce */);
-
-        char *pszPathURI = RTUriCreate("file" /* pszScheme */, NULL /* pszAuthority */,
-                                       pszPathNative, NULL /* pszQuery */, NULL /* pszFragment */);
-        if (pszPathURI)
-        {
-            rc = AppendURIPath(pszPathURI, fFlags);
-            RTStrFree(pszPathURI);
-        }
-        else
-            rc = VERR_INVALID_PARAMETER;
-
-        RTStrFree(pszPathNative);
-    }
-    else
-        rc = VERR_NO_MEMORY;
-
-    return rc;
-}
-
-int DnDURIList::AppendNativePathsFromList(const char *pszNativePaths, size_t cbNativePaths,
-                                          DNDURILISTFLAGS fFlags)
-{
-    AssertPtrReturn(pszNativePaths, VERR_INVALID_POINTER);
-    AssertReturn(cbNativePaths, VERR_INVALID_PARAMETER);
-
-    RTCList<RTCString> lstPaths
-        = RTCString(pszNativePaths, cbNativePaths - 1).split("\r\n");
-    return AppendNativePathsFromList(lstPaths, fFlags);
-}
-
-int DnDURIList::AppendNativePathsFromList(const RTCList<RTCString> &lstNativePaths,
-                                          DNDURILISTFLAGS fFlags)
-{
-    int rc = VINF_SUCCESS;
-
-    for (size_t i = 0; i < lstNativePaths.size(); i++)
-    {
-        const RTCString &strPath = lstNativePaths.at(i);
-        rc = AppendNativePath(strPath.c_str(), fFlags);
-        if (RT_FAILURE(rc))
-            break;
-    }
-
-    LogFlowFuncLeaveRC(rc);
-    return rc;
-}
-
-int DnDURIList::AppendURIPath(const char *pszURI, DNDURILISTFLAGS fFlags)
-{
-    AssertPtrReturn(pszURI, VERR_INVALID_POINTER);
-    AssertReturn(!(fFlags & ~DNDURILIST_FLAGS_VALID_MASK), VERR_INVALID_FLAGS);
-    /** @todo Check for string termination?  */
-
-    RTURIPARSED Parsed;
-    int rc = RTUriParse(pszURI, &Parsed);
-    if (RT_FAILURE(rc))
-        return rc;
-
-    char *pszSrcPath = NULL;
-
-    /* file://host.example.com/path/to/file.txt */
-    const char *pszParsedAuthority = RTUriParsedAuthority(pszURI, &Parsed);
-    if (   pszParsedAuthority
-        && pszParsedAuthority[0] != '\0') /* Authority present? */
-    {
-        const char *pszParsedPath = RTUriParsedPath(pszURI, &Parsed);
-        if (pszParsedPath)
-        {
-            /* Always use UNIXy paths internally. */
-            if (RTStrAPrintf(&pszSrcPath,  "//%s%s", pszParsedAuthority, pszParsedPath) == -1)
-                rc = VERR_NO_MEMORY;
-        }
-        else
-            rc = VERR_INVALID_PARAMETER;
-    }
-    else
-    {
-        pszSrcPath = RTUriFilePath(pszURI);
-        if (!pszSrcPath)
-            rc = VERR_INVALID_PARAMETER;
-    }
-
-    LogFlowFunc(("pszURI=%s, fFlags=0x%x -> pszParsedAuthority=%s, pszSrcPath=%s, rc=%Rrc\n",
-                 pszURI, fFlags, pszParsedAuthority ? pszParsedAuthority : "<None>", pszSrcPath, rc));
-
-    if (RT_SUCCESS(rc))
-    {
-        /* Add the path to our internal file list (recursive in
-         * the case of a directory). */
-        size_t cbPathLen = RTPathStripTrailingSlash(pszSrcPath);
-        if (cbPathLen)
-        {
-            char *pszFileName = RTPathFilename(pszSrcPath);
-            if (pszFileName)
-            {
-                Assert(pszFileName >= pszSrcPath);
-                size_t cchDstBase = (fFlags & DNDURILIST_FLAGS_ABSOLUTE_PATHS)
-                                  ? 0 /* Use start of path as root. */
-                                  : pszFileName - pszSrcPath;
-                char *pszDstPath = &pszSrcPath[cchDstBase];
-                rc = DnDPathConvert(pszDstPath, strlen(pszDstPath), DNDPATHCONVERT_FLAGS_NONE);
-                if (RT_SUCCESS(rc))
-                {
-                    m_lstRoot.append(pszDstPath);
-
-                    LogFlowFunc(("pszSrcPath=%s, pszFileName=%s, pszDstPath=%s\n",
-                                 pszSrcPath, pszFileName, pszDstPath));
-
-                    rc = appendPathRecursive(pszSrcPath, pszSrcPath, pszSrcPath, cchDstBase, fFlags);
-                }
-            }
-            else
-                rc = VERR_PATH_NOT_FOUND;
-        }
-        else
-            rc = VERR_INVALID_PARAMETER;
-    }
-
-    RTStrFree(pszSrcPath);
-
-    LogFlowFuncLeaveRC(rc);
-    return rc;
-}
-
-int DnDURIList::AppendURIPathsFromList(const char *pszURIPaths, size_t cbURIPaths,
-                                       DNDURILISTFLAGS fFlags)
-{
+/**
+ * Appends transfer list items from an URI string buffer.
+ *
+ * @returns VBox status code.
+ * @param   pList               Transfer list to append list data to.
+ * @param   pszURIPaths         String list to append.
+ * @param   cbURIPaths          Size (in bytes) of string list to append.
+ * @param   pcszSeparator       Separator string to use for separating strings of \a pszURIPathsAbs.
+ * @param   fFlags              Transfer list flags to use for appending.
+ */
+int DnDTransferListURIAppendFromBuffer(PDNDTRANSFERLIST pList,
+                                       const char *pszURIPaths, size_t cbURIPaths,
+                                       const char *pcszSeparator, DNDTRANSFERLISTFLAGS fFlags)
+{
+    AssertPtrReturn(pList, VERR_INVALID_POINTER);
     AssertPtrReturn(pszURIPaths, VERR_INVALID_POINTER);
     AssertReturn(cbURIPaths, VERR_INVALID_PARAMETER);
-
-    RTCList<RTCString> lstPaths
-        = RTCString(pszURIPaths, cbURIPaths - 1).split("\r\n");
-    return AppendURIPathsFromList(lstPaths, fFlags);
-}
-
-int DnDURIList::AppendURIPathsFromList(const RTCList<RTCString> &lstURI,
-                                       DNDURILISTFLAGS fFlags)
-{
-    int rc = VINF_SUCCESS;
-
-    for (size_t i = 0; i < lstURI.size(); i++)
-    {
-        RTCString strURI = lstURI.at(i);
-        rc = AppendURIPath(strURI.c_str(), fFlags);
-
-        if (RT_FAILURE(rc))
-            break;
+    AssertReturn(!(fFlags & ~DNDTRANSFERLIST_FLAGS_VALID_MASK), VERR_INVALID_FLAGS);
+
+    char **papszPaths = NULL;
+    size_t cPaths = 0;
+    int rc = RTStrSplit(pszURIPaths, cbURIPaths, pcszSeparator, &papszPaths, &cPaths);
+    if (RT_SUCCESS(rc))
+    {
+        for (size_t i = 0; i < cPaths; i++)
+        {
+            rc = DnDTransferListURIAppendPath(pList, papszPaths[i], fFlags);
+            if (RT_FAILURE(rc))
+                break;
+        }
+
+        for (size_t i = 0; i < cPaths; ++i)
+            RTStrFree(papszPaths[i]);
+        RTMemFree(papszPaths);
     }
 
@@ -437 +960 @@
     return rc;
 }
-
-void DnDURIList::Clear(void)
-{
-    m_lstRoot.clear();
-
-    for (size_t i = 0; i < m_lstTree.size(); i++)
-    {
-        DnDURIObject *pCurObj = m_lstTree.at(i);
-        AssertPtr(pCurObj);
-        delete pCurObj;
-    }
-    m_lstTree.clear();
-
-    m_cTotal  = 0;
-    m_cbTotal = 0;
-}
-
-void DnDURIList::RemoveFirst(void)
-{
-    if (m_lstTree.isEmpty())
-        return;
-
-    DnDURIObject *pCurObj = m_lstTree.first();
-    AssertPtr(pCurObj);
-
-    uint64_t cbSize = pCurObj->GetSize();
-    Assert(m_cbTotal >= cbSize);
-    m_cbTotal -= cbSize; /* Adjust total size. */
-
-    pCurObj->Close();
-    delete pCurObj;
-
-    m_lstTree.removeFirst();
-}
-
-int DnDURIList::SetFromURIData(const void *pvData, size_t cbData, DNDURILISTFLAGS fFlags)
-{
-    Assert(fFlags == 0); RT_NOREF1(fFlags);
-    AssertPtrReturn(pvData, VERR_INVALID_POINTER);
-    AssertReturn(cbData, VERR_INVALID_PARAMETER);
-
-    if (!RTStrIsValidEncoding(static_cast<const char *>(pvData)))
-        return VERR_INVALID_PARAMETER;
-
-    RTCList<RTCString> lstURI =
-        RTCString(static_cast<const char *>(pvData), cbData - 1).split("\r\n");
-    if (lstURI.isEmpty())
-        return VINF_SUCCESS;
-
-    int rc = VINF_SUCCESS;
-
-    for (size_t i = 0; i < lstURI.size(); ++i)
-    {
-        /* Query the path component of a file URI. If this hasn't a
-         * file scheme, NULL is returned. */
-        const char *pszURI = lstURI.at(i).c_str();
-        char *pszFilePath = RTUriFilePath(pszURI);
-#ifdef DEBUG_andy
-        LogFlowFunc(("pszURI=%s, pszFilePath=%s\n", pszURI, pszFilePath));
 #endif
-        if (pszFilePath)
-        {
-            rc = DnDPathConvert(pszFilePath, strlen(pszFilePath), DNDPATHCONVERT_FLAGS_NONE);
-            if (RT_SUCCESS(rc))
-            {
-                m_lstRoot.append(pszFilePath);
-                m_cTotal++;
-            }
-
-            RTStrFree(pszFilePath);
-        }
-        else
-            rc = VERR_INVALID_PARAMETER;
-
-        if (RT_FAILURE(rc))
-            break;
-    }
-
-    return rc;
-}
-
-RTCString DnDURIList::GetRootEntries(const RTCString &strPathBase /* = "" */,
-                                   const RTCString &strSeparator /* = "\r\n" */) const
-{
-    RTCString strRet;
-    for (size_t i = 0; i < m_lstRoot.size(); i++)
-    {
-        const char *pszCurRoot = m_lstRoot.at(i).c_str();
-#ifdef DEBUG_andy
-        LogFlowFunc(("pszCurRoot=%s\n", pszCurRoot));
-#endif
-        if (strPathBase.isNotEmpty())
-        {
-            char *pszPath = RTPathJoinA(strPathBase.c_str(), pszCurRoot);
-            if (pszPath)
-            {
-                char *pszPathURI = RTUriFileCreate(pszPath);
-                if (pszPathURI)
-                {
-                    strRet += RTCString(pszPathURI) + strSeparator;
-                    LogFlowFunc(("URI (Base): %s\n", strRet.c_str()));
-                    RTStrFree(pszPathURI);
-                }
-
-                RTStrFree(pszPath);
-
-                if (!pszPathURI)
-                    break;
-            }
-            else
-                break;
-        }
-        else
-        {
-            char *pszPathURI = RTUriFileCreate(pszCurRoot);
-            if (pszPathURI)
-            {
-                strRet += RTCString(pszPathURI) + strSeparator;
-                LogFlowFunc(("URI: %s\n", strRet.c_str()));
-                RTStrFree(pszPathURI);
-            }
-            else
-                break;
-        }
-    }
-
-    return strRet;
-}
-

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

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * DnD - URI object class. For handling creation/reading/writing to files and directories on host or guest side.
+ * DnD - Transfer object implemenation for handling creation/reading/writing to files and directories on host or guest side.
  */
 
@@ -28 +28 @@
 #include <iprt/fs.h>
 #include <iprt/path.h>
+#include <iprt/string.h>
 #include <iprt/uri.h>
 
 #include <VBox/log.h>
 
-
-DnDURIObject::DnDURIObject(Type enmType /* = Type_Unknown */, const RTCString &strPathAbs /* = "" */)
-    : m_enmType(Type_Unknown)
-{
-    if (   enmType != Type_Unknown
-        && strPathAbs.isNotEmpty())
-    {
-        int rc2 = Init(enmType, strPathAbs);
-        AssertRC(rc2);
-    }
-}
-
-DnDURIObject::~DnDURIObject(void)
-{
-    closeInternal();
+/*********************************************************************************************************************************
+*   Prototypes                                                                                                                   *
+*********************************************************************************************************************************/
+static void dndTransferObjectCloseInternal(PDNDTRANSFEROBJECT pObj);
+static int dndTransferObjectQueryInfoInternal(PDNDTRANSFEROBJECT pObj);
+
+
+/**
+ * Initializes the object with an expected object type and file path.
+ *
+ * @returns VBox status code.
+ * @param   pObj                DnD transfer object to initialize.
+ * @param   enmType             Type we expect this object to be.
+ * @param   pcszPathSrcAbs      Absolute source (local) path of file this object represents. Can be empty (e.g. for root stuff).
+ * @param   pcszPathDst         Relative path of file this object represents at the destination.
+ *                              Together with \a pcszPathSrcAbs this represents the complete absolute local path.
+ */
+int DnDTransferObjectInit(PDNDTRANSFEROBJECT pObj, DNDTRANSFEROBJTYPE enmType, const char *pcszPathSrcAbs, const char *pcszPathDst)
+{
+    AssertPtrReturn(pObj, VERR_INVALID_POINTER);
+    AssertReturn(pObj->enmType == DNDTRANSFEROBJTYPE_UNKNOWN, VERR_WRONG_ORDER); /* Already initialized? */
+    /* pcszPathSrcAbs can be empty. */
+    AssertPtrReturn(pcszPathDst, VERR_INVALID_POINTER);
+
+    switch (enmType)
+    {
+        case DNDTRANSFEROBJTYPE_FILE:
+        {
+            pObj->u.File.hFile = NIL_RTFILE;
+            break;
+        }
+
+        case DNDTRANSFEROBJTYPE_DIRECTORY:
+        {
+            pObj->u.Dir.hDir = NIL_RTDIR;
+            break;
+        }
+
+        default:
+            AssertFailedReturn(VERR_NOT_IMPLEMENTED);
+            break; /* Never reached */
+    }
+
+    int rc = DnDPathValidate(pcszPathDst, false /* Does not need to exist */);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    char szPath[RTPATH_MAX + 1];
+
+    /* Save the index (in characters) where the first destination segment starts. */
+    if (   pcszPathSrcAbs
+        && RTStrNLen(pcszPathSrcAbs, RTSTR_MAX))
+    {
+        rc = DnDPathValidate(pcszPathSrcAbs, false /* Does not need to exist */);
+        if (RT_FAILURE(rc))
+            return rc;
+
+        rc = RTStrCopy(szPath, sizeof(szPath), pcszPathSrcAbs);
+        if (RT_SUCCESS(rc))
+            rc = RTPathEnsureTrailingSeparator(szPath, sizeof(szPath)) == 0 ? VERR_BUFFER_OVERFLOW : VINF_SUCCESS;
+
+        /* Save the index (in characters) where the destination part starts. */
+        pObj->idxDst = (uint16_t)RTStrNLen(szPath, RTSTR_MAX);
+        AssertReturn(pObj->idxDst != RTSTR_MAX, VERR_INVALID_PARAMETER);
+    }
+    else
+    {
+        szPath[0]    = '\0'; /* Init empty string. */
+        pObj->idxDst = 0;
+    }
+
+    if (RT_FAILURE(rc))
+        return rc;
+
+    /* Append the destination part. */
+    rc = RTPathAppend(szPath, sizeof(szPath), pcszPathDst);
+    if (   RT_SUCCESS(rc)
+        && enmType == DNDTRANSFEROBJTYPE_DIRECTORY)
+        rc = RTPathEnsureTrailingSeparator(szPath, sizeof(szPath)) == 0 ? VERR_BUFFER_OVERFLOW : VINF_SUCCESS;
+
+    if (RT_FAILURE(rc))
+        return rc;
+
+    pObj->pszPath = RTStrDup(szPath);
+    if (!pObj->pszPath)
+        return VERR_NO_MEMORY;
+
+    /* Convert paths into transport format. */
+    rc = DnDPathConvert(pObj->pszPath, strlen(pObj->pszPath), DNDPATHCONVERT_FLAGS_TRANSPORT);
+    if (RT_FAILURE(rc))
+    {
+        RTStrFree(pObj->pszPath);
+        pObj->pszPath = NULL;
+        return rc;
+    }
+
+    LogFlowFunc(("enmType=%RU32, pcszPathSrcAbs=%s, pcszPathDst=%s -> pszPath=%s\n",
+                 enmType, pcszPathSrcAbs, pcszPathDst, pObj->pszPath));
+
+    pObj->enmType = enmType;
+
+    return VINF_SUCCESS;
+}
+
+/**
+ * Destroys a DnD transfer object.
+ *
+ * @param   pObj                DnD transfer object to destroy.
+ */
+void DnDTransferObjectDestroy(PDNDTRANSFEROBJECT pObj)
+{
+    if (!pObj)
+        return;
+
+    DnDTransferObjectReset(pObj);
 }
 
 /**
  * Closes the object's internal handles (to files / ...).
- */
-void DnDURIObject::closeInternal(void)
-{
-    LogFlowThisFuncEnter();
+ *
+ * @param   pObj                DnD transfer object to close internally.
+ */
+static void dndTransferObjectCloseInternal(PDNDTRANSFEROBJECT pObj)
+{
+    AssertPtrReturnVoid(pObj);
 
     int rc;
 
-    switch (m_enmType)
-    {
-        case Type_File:
-        {
-            if (RTFileIsValid(u.File.hFile))
+    LogRel2(("DnD: Closing '%s'\n", pObj->pszPath));
+
+    switch (pObj->enmType)
+    {
+        case DNDTRANSFEROBJTYPE_FILE:
+        {
+            if (RTFileIsValid(pObj->u.File.hFile))
             {
-                LogRel2(("DnD: Closing file '%s'\n", m_strPathAbs.c_str()));
-
-                rc = RTFileClose(u.File.hFile);
+                rc = RTFileClose(pObj->u.File.hFile);
                 if (RT_SUCCESS(rc))
                 {
-                    u.File.hFile = NIL_RTFILE;
-                    RT_ZERO(u.File.objInfo);
+                    pObj->u.File.hFile = NIL_RTFILE;
+                    RT_ZERO(pObj->u.File.objInfo);
                 }
                 else
-                    LogRel(("DnD: Closing file '%s' failed with %Rrc\n", m_strPathAbs.c_str(), rc));
+                    LogRel(("DnD: Closing file '%s' failed with %Rrc\n", pObj->pszPath, rc));
             }
             break;
         }
 
-        case Type_Directory:
-        {
-            if (RTDirIsValid(u.Dir.hDir))
+        case DNDTRANSFEROBJTYPE_DIRECTORY:
+        {
+            if (RTDirIsValid(pObj->u.Dir.hDir))
             {
-                LogRel2(("DnD: Closing directory '%s'\n", m_strPathAbs.c_str()));
-
-                rc = RTDirClose(u.Dir.hDir);
+                rc = RTDirClose(pObj->u.Dir.hDir);
                 if (RT_SUCCESS(rc))
                 {
-                    u.Dir.hDir = NIL_RTDIR;
-                    RT_ZERO(u.Dir.objInfo);
+                    pObj->u.Dir.hDir = NIL_RTDIR;
+                    RT_ZERO(pObj->u.Dir.objInfo);
                 }
                 else
-                    LogRel(("DnD: Closing directory '%s' failed with %Rrc\n", m_strPathAbs.c_str(), rc));
+                    LogRel(("DnD: Closing directory '%s' failed with %Rrc\n", pObj->pszPath, rc));
             }
             break;
@@ -106 +207 @@
  * Closes the object.
  * This also closes the internal handles associated with the object (to files / ...).
- */
-void DnDURIObject::Close(void)
-{
-    closeInternal();
+ *
+ * @param   pObj                DnD transfer object to close.
+ */
+void DnDTransferObjectClose(PDNDTRANSFEROBJECT pObj)
+{
+    AssertPtrReturnVoid(pObj);
+
+    dndTransferObjectCloseInternal(pObj);
+}
+
+/**
+ * Returns the absolute source path of the object.
+ *
+ * @return  Absolute source path of the object.
+ * @param   pObj                DnD transfer object to get source path for.
+ */
+const char *DnDTransferObjectGetSourcePath(PDNDTRANSFEROBJECT pObj)
+{
+    AssertPtrReturn(pObj, NULL);
+    return pObj->pszPath;
+}
+
+/**
+ * Returns the (relative) destination path of the object, in transport style.
+ *
+ * @return  Relative destination path of the object, or NULL if not set.
+ * @param   pObj                DnD transfer object to get destination path for.
+ */
+const char *DnDTransferObjectGetDestPath(PDNDTRANSFEROBJECT pObj)
+{
+    AssertPtrReturn(pObj, NULL);
+
+    if (!pObj->pszPath)
+        return NULL;
+
+    AssertReturn(strlen(pObj->pszPath) >= pObj->idxDst, NULL);
+
+    return &pObj->pszPath[pObj->idxDst];
+}
+
+/**
+ * Returns the (relative) destination path of the object, extended version.
+ *
+ * @return  VBox status code, or VERR_NOT_FOUND if not initialized yet.
+ * @param   pObj                DnD transfer object to get destination path for.
+ * @param   enmStyle            Which path style to return.
+ * @param   pszBuf              Where to store the path.
+ * @param   cbBuf               Size (in bytes) where to store the path.
+ */
+int DnDTransferObjectGetDestPathEx(PDNDTRANSFEROBJECT pObj, DNDTRANSFEROBJPATHSTYLE enmStyle, char *pszBuf, size_t cbBuf)
+{
+    AssertPtrReturn(pObj, VERR_INVALID_POINTER);
+    AssertPtrReturn(pszBuf, VERR_INVALID_POINTER);
+    AssertReturn(cbBuf, VERR_INVALID_PARAMETER);
+
+    if (!pObj->pszPath)
+        return VERR_NOT_FOUND;
+
+    AssertReturn(strlen(pObj->pszPath) >= pObj->idxDst, VERR_INTERNAL_ERROR);
+
+    int rc = RTStrCopy(pszBuf, cbBuf, &pObj->pszPath[pObj->idxDst]);
+    if (   RT_SUCCESS(rc)
+        && enmStyle == DNDTRANSFEROBJPATHSTYLE_DOS)
+        rc = DnDPathConvert(pszBuf, cbBuf, DNDPATHCONVERT_FLAGS_TO_DOS);
+
+    return rc;
 }
 
@@ -116 +279 @@
  *
  * @return  File / directory mode.
- */
-RTFMODE DnDURIObject::GetMode(void) const
-{
-    switch (m_enmType)
-    {
-        case Type_File:
-            return u.File.objInfo.Attr.fMode;
-
-        case Type_Directory:
-            return u.Dir.objInfo.Attr.fMode;
-
-        default:
-            break;
-    }
-
-    AssertFailed();
+ * @param   pObj                DnD transfer object to get directory / file mode for.
+ */
+RTFMODE DnDTransferObjectGetMode(PDNDTRANSFEROBJECT pObj)
+{
+    AssertPtrReturn(pObj, 0);
+
+    switch (pObj->enmType)
+    {
+        case DNDTRANSFEROBJTYPE_FILE:
+            return pObj->u.File.objInfo.Attr.fMode;
+
+        case DNDTRANSFEROBJTYPE_DIRECTORY:
+            return pObj->u.Dir.objInfo.Attr.fMode;
+
+        default:
+            break;
+    }
+
     return 0;
 }
@@ -138 +303 @@
  * Returns the bytes already processed (read / written).
  *
- * Note: Only applies if the object is of type DnDURIObject::Type_File.
+ * Note: Only applies if the object is of type DnDTransferObjectType_File.
  *
  * @return  Bytes already processed (read / written).
- */
-uint64_t DnDURIObject::GetProcessed(void) const
-{
-    if (m_enmType == Type_File)
-        return u.File.cbProcessed;
+ * @param   pObj                DnD transfer object to get processed bytes for.
+ */
+uint64_t DnDTransferObjectGetProcessed(PDNDTRANSFEROBJECT pObj)
+{
+    if (pObj->enmType == DNDTRANSFEROBJTYPE_FILE)
+        return pObj->u.File.cbProcessed;
 
     return 0;
@@ -153 +319 @@
  * Returns the file's logical size (in bytes).
  *
- * Note: Only applies if the object is of type DnDURIObject::Type_File.
+ * Note: Only applies if the object is of type DnDTransferObjectType_File.
  *
  * @return  The file's logical size (in bytes).
- */
-uint64_t DnDURIObject::GetSize(void) const
-{
-    if (m_enmType == Type_File)
-        return u.File.cbToProcess;
+ * @param   pObj                DnD transfer object to get size for.
+ */
+uint64_t DnDTransferObjectGetSize(PDNDTRANSFEROBJECT pObj)
+{
+    if (pObj->enmType == DNDTRANSFEROBJTYPE_FILE)
+        return pObj->u.File.cbToProcess;
 
     return 0;
@@ -166 +333 @@
 
 /**
- * Initializes the object with an expected object type and file path.
- *
- * @returns VBox status code.
- * @param   enmType             Type we expect this object to be.
- * @param   strPathAbs          Absolute path of file this object represents. Optional.
- */
-int DnDURIObject::Init(Type enmType, const RTCString &strPathAbs /* = */)
-{
-    AssertReturn(m_enmType == Type_Unknown, VERR_WRONG_ORDER);
-
-    int rc;
-
-    switch (enmType)
-    {
-        case Type_File:
-        {
-            u.File.hFile = NIL_RTFILE;
-            break;
-        }
-
-        case Type_Directory:
-        {
-            u.Dir.hDir = NIL_RTDIR;
-            break;
-        }
-
-        default:
-            break;
-    }
-
-    if (enmType != Type_Unknown)
-    {
-        AssertReturn(strPathAbs.isNotEmpty(), VERR_INVALID_PARAMETER);
-        RTCString strPathAbsCopy = strPathAbs;
-        rc = DnDPathConvert(strPathAbsCopy.mutableRaw(), strPathAbsCopy.capacity(), DNDPATHCONVERT_FLAGS_TO_NATIVE);
-        if (RT_SUCCESS(rc))
-        {
-            m_enmType    = enmType;
-            m_strPathAbs = strPathAbsCopy;
-        }
-        else
-            LogRel2(("DnD: Absolute file path for guest file on the host is now '%s'\n", strPathAbs.c_str()));
-    }
-    else
-        rc = VERR_INVALID_PARAMETER;
-
-    return rc;
+ * Returns the object's type.
+ *
+ * @return  The object's type.
+ * @param   pObj                DnD transfer object to get type for.
+ */
+DNDTRANSFEROBJTYPE DnDTransferObjectGetType(PDNDTRANSFEROBJECT pObj)
+{
+    return pObj->enmType;
 }
 
@@ -220 +348 @@
  *
  * @return  True if complete, False if not.
- */
-bool DnDURIObject::IsComplete(void) const
+ * @param   pObj                DnD transfer object to get completion status for.
+ */
+bool DnDTransferObjectIsComplete(PDNDTRANSFEROBJECT pObj)
 {
     bool fComplete;
 
-    switch (m_enmType)
-    {
-        case Type_File:
-            Assert(u.File.cbProcessed <= u.File.cbToProcess);
-            fComplete = u.File.cbProcessed == u.File.cbToProcess;
-            break;
-
-        case Type_Directory:
+    switch (pObj->enmType)
+    {
+        case DNDTRANSFEROBJTYPE_FILE:
+            Assert(pObj->u.File.cbProcessed <= pObj->u.File.cbToProcess);
+            fComplete = pObj->u.File.cbProcessed == pObj->u.File.cbToProcess;
+            break;
+
+        case DNDTRANSFEROBJTYPE_DIRECTORY:
             fComplete = true;
             break;
@@ -246 +375 @@
 /**
  * Returns whether the object is in an open state or not.
- */
-bool DnDURIObject::IsOpen(void) const
-{
-    switch (m_enmType)
-    {
-        case Type_File:      return RTFileIsValid(u.File.hFile);
-        case Type_Directory: return RTDirIsValid(u.Dir.hDir);
-        default:             break;
+ * @param   pObj                DnD transfer object to get open status for.
+ */
+bool DnDTransferObjectIsOpen(PDNDTRANSFEROBJECT pObj)
+{
+    switch (pObj->enmType)
+    {
+        case DNDTRANSFEROBJTYPE_FILE:      return RTFileIsValid(pObj->u.File.hFile);
+        case DNDTRANSFEROBJTYPE_DIRECTORY: return RTDirIsValid(pObj->u.Dir.hDir);
+        default:                           break;
     }
 
@@ -263 +393 @@
  *
  * @return  IPRT status code.
+ * @param   pObj                DnD transfer object to open.
  * @param   fOpen               Open mode to use; only valid for file objects.
  * @param   fMode               File mode to set; only valid for file objects. Depends on fOpen and and can be 0.
- * @param   fFlags              Additional DnD URI object flags.
- */
-int DnDURIObject::Open(uint64_t fOpen, RTFMODE fMode /* = 0 */,
-                       DNDURIOBJECTFLAGS fFlags /* = DNDURIOBJECT_FLAGS_NONE */)
-{
+ * @param   fFlags              Additional DnD transfer object flags.
+ */
+int DnDTransferObjectOpen(PDNDTRANSFEROBJECT pObj, uint64_t fOpen, RTFMODE fMode, DNDTRANSFEROBJECTFLAGS fFlags)
+{
+    AssertPtrReturn(pObj, VERR_INVALID_POINTER);
     AssertReturn(fOpen, VERR_INVALID_FLAGS);
     /* fMode is optional. */
-    AssertReturn(!(fFlags & ~DNDURIOBJECT_FLAGS_VALID_MASK), VERR_INVALID_FLAGS);
+    AssertReturn(!(fFlags & ~DNDTRANSFEROBJECT_FLAGS_VALID_MASK), VERR_INVALID_FLAGS);
     RT_NOREF1(fFlags);
 
     int rc = VINF_SUCCESS;
 
-    if (fOpen) /* Opening mode specified? */
-    {
-        LogFlowThisFunc(("strPath=%s, fOpen=0x%x, fMode=0x%x, fFlags=0x%x\n",
-                         m_strPathAbs.c_str(), fOpen, fMode, fFlags));
-        switch (m_enmType)
-        {
-            case Type_File:
+    LogFlowFunc(("pszPath=%s, fOpen=0x%x, fMode=0x%x, fFlags=0x%x\n", pObj->pszPath, fOpen, fMode, fFlags));
+
+    switch (pObj->enmType)
+    {
+        case DNDTRANSFEROBJTYPE_FILE:
+        {
+            LogRel2(("DnD: Opening file '%s'\n", pObj->pszPath));
+
+            /*
+             * Open files on the source with RTFILE_O_DENY_WRITE to prevent races
+             * where the OS writes to the file while the destination side transfers
+             * it over.
+             */
+            rc = RTFileOpen(&pObj->u.File.hFile, pObj->pszPath, fOpen);
+            if (RT_SUCCESS(rc))
             {
-                LogRel2(("DnD: Opening file '%s'\n", m_strPathAbs.c_str()));
-
-                /*
-                 * Open files on the source with RTFILE_O_DENY_WRITE to prevent races
-                 * where the OS writes to the file while the destination side transfers
-                 * it over.
-                 */
-                rc = RTFileOpen(&u.File.hFile, m_strPathAbs.c_str(), fOpen);
-                if (RT_SUCCESS(rc))
+                if (   (fOpen & RTFILE_O_WRITE) /* Only set the file mode on write. */
+                    &&  fMode                   /* Some file mode to set specified? */)
                 {
-                    if (   (fOpen & RTFILE_O_WRITE) /* Only set the file mode on write. */
-                        &&  fMode                   /* Some file mode to set specified? */)
-                    {
-                        rc = RTFileSetMode(u.File.hFile, fMode);
-                        if (RT_FAILURE(rc))
-                            LogRel(("DnD: Setting mode %#x for file '%s' failed with %Rrc\n", fMode, m_strPathAbs.c_str(), rc));
-                    }
-                    else if (fOpen & RTFILE_O_READ)
-                    {
-                        rc = queryInfoInternal();
-                    }
+                    rc = RTFileSetMode(pObj->u.File.hFile, fMode);
+                    if (RT_FAILURE(rc))
+                        LogRel(("DnD: Setting mode %#x for file '%s' failed with %Rrc\n", fMode, pObj->pszPath, rc));
                 }
-                else
-                    LogRel(("DnD: Opening file '%s' failed with %Rrc\n", m_strPathAbs.c_str(), rc));
-
-                if (RT_SUCCESS(rc))
+                else if (fOpen & RTFILE_O_READ)
                 {
-                    LogFlowThisFunc(("File cbObject=%RU64, fMode=0x%x\n",
-                                     u.File.objInfo.cbObject, u.File.objInfo.Attr.fMode));
-                    u.File.cbToProcess = u.File.objInfo.cbObject;
-                    u.File.cbProcessed = 0;
+                    rc = dndTransferObjectQueryInfoInternal(pObj);
                 }
-
-                break;
             }
-
-            case Type_Directory:
+            else
+                LogRel(("DnD: Opening file '%s' failed with %Rrc\n", pObj->pszPath, rc));
+
+            if (RT_SUCCESS(rc))
             {
-                LogRel2(("DnD: Opening directory '%s'\n", m_strPathAbs.c_str()));
-
-                rc = RTDirOpen(&u.Dir.hDir, m_strPathAbs.c_str());
-                if (RT_SUCCESS(rc))
-                {
-                    rc = queryInfoInternal();
-                }
-                else
-                    LogRel(("DnD: Opening directory '%s' failed with %Rrc\n", m_strPathAbs.c_str(), rc));
-                break;
+                LogFlowFunc(("File cbObject=%RU64, fMode=0x%x\n",
+                             pObj->u.File.objInfo.cbObject, pObj->u.File.objInfo.Attr.fMode));
+                pObj->u.File.cbToProcess = pObj->u.File.objInfo.cbObject;
+                pObj->u.File.cbProcessed = 0;
             }
 
-            default:
-                rc = VERR_NOT_IMPLEMENTED;
-                break;
-        }
+            break;
+        }
+
+        case DNDTRANSFEROBJTYPE_DIRECTORY:
+        {
+            LogRel2(("DnD: Opening directory '%s'\n", pObj->pszPath));
+
+            rc = RTDirOpen(&pObj->u.Dir.hDir, pObj->pszPath);
+            if (RT_SUCCESS(rc))
+            {
+                rc = dndTransferObjectQueryInfoInternal(pObj);
+            }
+            else
+                LogRel(("DnD: Opening directory '%s' failed with %Rrc\n", pObj->pszPath, rc));
+            break;
+        }
+
+        default:
+            rc = VERR_NOT_IMPLEMENTED;
+            break;
     }
 
@@ -349 +477 @@
  *
  * @return  IPRT status code.
- */
-int DnDURIObject::queryInfoInternal(void)
+ * @param   pObj                DnD transfer object to query info for.
+ */
+static int dndTransferObjectQueryInfoInternal(PDNDTRANSFEROBJECT pObj)
 {
     int rc;
 
-    switch (m_enmType)
-    {
-        case Type_File:
-            AssertMsgReturn(RTFileIsValid(u.File.hFile), ("Object has invalid file handle\n"), VERR_INVALID_STATE);
-            rc = RTFileQueryInfo(u.File.hFile, &u.File.objInfo, RTFSOBJATTRADD_NOTHING);
-            break;
-
-        case Type_Directory:
-            AssertMsgReturn(RTDirIsValid(u.Dir.hDir), ("Object has invalid directory handle\n"), VERR_INVALID_STATE);
-            rc = RTDirQueryInfo(u.Dir.hDir, &u.Dir.objInfo, RTFSOBJATTRADD_NOTHING);
+    switch (pObj->enmType)
+    {
+        case DNDTRANSFEROBJTYPE_FILE:
+            AssertMsgReturn(RTFileIsValid(pObj->u.File.hFile), ("Object has invalid file handle\n"), VERR_INVALID_STATE);
+            rc = RTFileQueryInfo(pObj->u.File.hFile, &pObj->u.File.objInfo, RTFSOBJATTRADD_NOTHING);
+            break;
+
+        case DNDTRANSFEROBJTYPE_DIRECTORY:
+            AssertMsgReturn(RTDirIsValid(pObj->u.Dir.hDir), ("Object has invalid directory handle\n"), VERR_INVALID_STATE);
+            rc = RTDirQueryInfo(pObj->u.Dir.hDir, &pObj->u.Dir.objInfo, RTFSOBJATTRADD_NOTHING);
             break;
 
@@ -372 +501 @@
 
     if (RT_FAILURE(rc))
-        LogRel(("DnD: Querying information for '%s' failed with %Rrc\n", m_strPathAbs.c_str(), rc));
+        LogRel(("DnD: Querying information for '%s' failed with %Rrc\n", pObj->pszPath, rc));
 
     return rc;
@@ -381 +510 @@
  *
  * @return  IPRT status code.
- */
-int DnDURIObject::QueryInfo(void)
-{
-    return queryInfoInternal();
-}
-
-/**
- * Rebases an absolute URI path from an old path base to a new path base.
- * This function is needed in order to transform path from the source side to the target side.
+ * @param   pObj                DnD transfer object to query info for.
+ */
+int DnDTransferObjectQueryInfo(PDNDTRANSFEROBJECT pObj)
+{
+    AssertPtrReturn(pObj, VERR_INVALID_POINTER);
+    return dndTransferObjectQueryInfoInternal(pObj);
+}
+
+/**
+ * Reads data from the object. Only applies to files objects.
  *
  * @return  IPRT status code.
- * @param   strPathAbs          Absolute URI path to rebase.
- * @param   strBaseOld          Old base path to rebase from.
- * @param   strBaseNew          New base path to rebase to.
- *
- ** @todo Put this into an own class like DnDURIPath : public RTCString?
- */
-/* static */
-int DnDURIObject::RebaseURIPath(RTCString &strPathAbs,
-                                const RTCString &strBaseOld /* = "" */,
-                                const RTCString &strBaseNew /* = "" */)
-{
-    char *pszPath = RTUriFilePath(strPathAbs.c_str());
-    if (!pszPath) /* No URI? */
-         pszPath = RTStrDup(strPathAbs.c_str());
-
-    int rc;
-
-    if (pszPath)
-    {
-        const char *pszPathStart = pszPath;
-        const char *pszBaseOld = strBaseOld.c_str();
-        if (   pszBaseOld
-            && RTPathStartsWith(pszPath, pszBaseOld))
-        {
-            pszPathStart += strlen(pszBaseOld);
-        }
-
-        rc = VINF_SUCCESS;
-
-        if (RT_SUCCESS(rc))
-        {
-            char *pszPathNew = RTPathJoinA(strBaseNew.c_str(), pszPathStart);
-            if (pszPathNew)
-            {
-                rc = DnDPathValidate(pszPathNew, false /* fMustExist */);
-                if (RT_SUCCESS(rc))
-                {
-                    char *pszPathURI = RTUriCreate("file" /* pszScheme */, "/" /* pszAuthority */,
-                                                   pszPathNew /* pszPath */,
-                                                   NULL /* pszQuery */, NULL /* pszFragment */);
-                    if (pszPathURI)
-                    {
-                        LogFlowFunc(("Rebasing \"%s\" to \"%s\"\n", strPathAbs.c_str(), pszPathURI));
-
-                        strPathAbs = RTCString(pszPathURI) + "\r\n";
-                        RTStrFree(pszPathURI);
-                    }
-                    else
-                        rc = VERR_INVALID_PARAMETER;
-                }
-                else
-                    LogRel(("DnD: Path validation for '%s' failed with %Rrc\n", pszPathNew, rc));
-
-                RTStrFree(pszPathNew);
-            }
-            else
-                rc = VERR_NO_MEMORY;
-        }
-
-        RTStrFree(pszPath);
-    }
-    else
-        rc = VERR_NO_MEMORY;
-
-    if (RT_FAILURE(rc))
-        LogRel(("DnD: Rebasing absolute path '%s' (baseOld=%s, baseNew=%s) failed with %Rrc\n",
-                strPathAbs.c_str(), strBaseOld.c_str(), strBaseNew.c_str(), rc));
-
-    return rc;
-}
-
-/**
- * Reads data from the object. Only applies to files objects.
- *
- * @return  IPRT status code.
+ * @param   pObj                DnD transfer object to read data from.
  * @param   pvBuf               Buffer where to store the read data.
  * @param   cbBuf               Size (in bytes) of the buffer.
  * @param   pcbRead             Pointer where to store how many bytes were read. Optional.
  */
-int DnDURIObject::Read(void *pvBuf, size_t cbBuf, uint32_t *pcbRead)
-{
+int DnDTransferObjectRead(PDNDTRANSFEROBJECT pObj, void *pvBuf, size_t cbBuf, uint32_t *pcbRead)
+{
+    AssertPtrReturn(pObj, VERR_INVALID_POINTER);
     AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
     AssertReturn(cbBuf, VERR_INVALID_PARAMETER);
@@ -480 +537 @@
 
     int rc;
-    switch (m_enmType)
-    {
-        case Type_File:
-        {
-            rc = RTFileRead(u.File.hFile, pvBuf, cbBuf, &cbRead);
+    switch (pObj->enmType)
+    {
+        case DNDTRANSFEROBJTYPE_FILE:
+        {
+            rc = RTFileRead(pObj->u.File.hFile, pvBuf, cbBuf, &cbRead);
             if (RT_SUCCESS(rc))
             {
-                u.File.cbProcessed += cbRead;
-                Assert(u.File.cbProcessed <= u.File.cbToProcess);
+                pObj->u.File.cbProcessed += cbRead;
+                Assert(pObj->u.File.cbProcessed <= pObj->u.File.cbToProcess);
 
                 /* End of file reached or error occurred? */
-                if (   u.File.cbToProcess
-                    && u.File.cbProcessed == u.File.cbToProcess)
+                if (   pObj->u.File.cbToProcess
+                    && pObj->u.File.cbProcessed == pObj->u.File.cbToProcess)
                 {
                     rc = VINF_EOF;
@@ -498 +555 @@
             }
             else
-                LogRel(("DnD: Reading from file '%s' failed with %Rrc\n", m_strPathAbs.c_str(), rc));
-            break;
-        }
-
-        case Type_Directory:
+                LogRel(("DnD: Reading from file '%s' failed with %Rrc\n", pObj->pszPath, rc));
+            break;
+        }
+
+        case DNDTRANSFEROBJTYPE_DIRECTORY:
         {
             rc = VINF_SUCCESS;
@@ -519 +576 @@
     }
 
-    LogFlowFunc(("Returning strSourcePath=%s, cbRead=%zu, rc=%Rrc\n", m_strPathAbs.c_str(), cbRead, rc));
+    LogFlowFunc(("Returning cbRead=%zu, rc=%Rrc\n", cbRead, rc));
     return rc;
 }
@@ -525 +582 @@
 /**
  * Resets the object's state and closes all related handles.
- */
-void DnDURIObject::Reset(void)
-{
-    LogFlowThisFuncEnter();
-
-    Close();
-
-    m_enmType    = Type_Unknown;
-    m_strPathAbs = "";
-
-    RT_ZERO(u);
+ *
+ * @param   pObj                DnD transfer object to reset.
+ */
+void DnDTransferObjectReset(PDNDTRANSFEROBJECT pObj)
+{
+    AssertPtrReturnVoid(pObj);
+
+    LogFlowFuncEnter();
+
+    dndTransferObjectCloseInternal(pObj);
+
+    pObj->enmType    = DNDTRANSFEROBJTYPE_UNKNOWN;
+    pObj->idxDst     = 0;
+
+    RTStrFree(pObj->pszPath);
+    pObj->pszPath = NULL;
+
+    RT_ZERO(pObj->u);
 }
 
@@ -541 +605 @@
  * Sets the bytes to process by the object.
  *
- * Note: Only applies if the object is of type DnDURIObject::Type_File.
+ * Note: Only applies if the object is of type DnDTransferObjectType_File.
  *
  * @return  IPRT return code.
- * @param   cbSize          Size (in bytes) to process.
- */
-int DnDURIObject::SetSize(uint64_t cbSize)
-{
-    AssertReturn(m_enmType == Type_File, VERR_INVALID_PARAMETER);
+ * @param   pObj                DnD transfer object to set size for.
+ * @param   cbSize              Size (in bytes) to process.
+ */
+int DnDTransferObjectSetSize(PDNDTRANSFEROBJECT pObj, uint64_t cbSize)
+{
+    AssertPtrReturn(pObj, VERR_INVALID_POINTER);
+    AssertReturn(pObj->enmType == DNDTRANSFEROBJTYPE_FILE, VERR_INVALID_PARAMETER);
 
     /** @todo Implement sparse file support here. */
 
-    u.File.cbToProcess = cbSize;
+    pObj->u.File.cbToProcess = cbSize;
     return VINF_SUCCESS;
 }
@@ -560 +626 @@
  *
  * @return  IPRT status code.
+ * @param   pObj                DnD transfer object to write to.
  * @param   pvBuf               Buffer of data to write.
  * @param   cbBuf               Size (in bytes) of data to write.
  * @param   pcbWritten          Pointer where to store how many bytes were written. Optional.
  */
-int DnDURIObject::Write(const void *pvBuf, size_t cbBuf, uint32_t *pcbWritten)
-{
+int DnDTransferObjectWrite(PDNDTRANSFEROBJECT pObj, const void *pvBuf, size_t cbBuf, uint32_t *pcbWritten)
+{
+    AssertPtrReturn(pObj, VERR_INVALID_POINTER);
     AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
     AssertReturn(cbBuf, VERR_INVALID_PARAMETER);
@@ -573 +641 @@
 
     int rc;
-    switch (m_enmType)
-    {
-        case Type_File:
-        {
-            rc = RTFileWrite(u.File.hFile, pvBuf, cbBuf, &cbWritten);
+    switch (pObj->enmType)
+    {
+        case DNDTRANSFEROBJTYPE_FILE:
+        {
+            rc = RTFileWrite(pObj->u.File.hFile, pvBuf, cbBuf, &cbWritten);
             if (RT_SUCCESS(rc))
             {
-                u.File.cbProcessed += cbWritten;
+                pObj->u.File.cbProcessed += cbWritten;
             }
             else
-                LogRel(("DnD: Writing to file '%s' failed with %Rrc\n", m_strPathAbs.c_str(), rc));
-            break;
-        }
-
-        case Type_Directory:
+                LogRel(("DnD: Writing to file '%s' failed with %Rrc\n", pObj->pszPath, rc));
+            break;
+        }
+
+        case DNDTRANSFEROBJTYPE_DIRECTORY:
         {
             rc = VINF_SUCCESS;
@@ -604 +672 @@
     }
 
-    LogFlowThisFunc(("Returning strSourcePathAbs=%s, cbWritten=%zu, rc=%Rrc\n", m_strPathAbs.c_str(), cbWritten, rc));
+    LogFlowFunc(("Returning cbWritten=%zu, rc=%Rrc\n", cbWritten, rc));
     return rc;
 }

trunk/src/VBox/GuestHost/DragAndDrop/Makefile.kmk

@@ -19 +19 @@
 include $(KBUILD_PATH)/subheader.kmk
 
+ifdef VBOX_WITH_TESTCASES
+ include $(PATH_SUB_CURRENT)/testcase/Makefile.kmk
+endif
+
 VBOX_DND_GUESTHOST_FILES := \
         DnDDroppedFiles.cpp \
         DnDMIME.cpp \
         DnDPath.cpp \
-        DnDURIList.cpp \
-        DnDURIObject.cpp
+        DnDTransferObject.cpp \
+        DnDTransferList.cpp
 
 #

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

@@ -82 +82 @@
 
 /**
- * Class for handling the (raw) meta data.
- */
-class GuestDnDMetaData
-{
-public:
-
+ * Struct for handling the (raw) meta data.
+ */
+struct GuestDnDMetaData
+{
     GuestDnDMetaData(void)
         : pvData(NULL)
         , cbData(0)
-        , cbDataUsed(0) { }
+        , cbAllocated(0) { }
 
     virtual ~GuestDnDMetaData(void)
@@ -97 +95 @@
         reset();
     }
-
-public:
 
     uint32_t add(const void *pvDataAdd, uint32_t cbDataAdd)
@@ -108 +104 @@
         AssertPtrReturn(pvDataAdd, 0);
 
-        int rc = resize(cbData + cbDataAdd);
+        int rc = resize(cbAllocated + cbDataAdd);
         if (RT_FAILURE(rc))
             return 0;
 
-        Assert(cbData >= cbDataUsed + cbDataAdd);
-        memcpy((uint8_t *)pvData + cbDataUsed, pvDataAdd, cbDataAdd);
-
-        cbDataUsed += cbDataAdd;
-
-        return cbDataAdd;
+        Assert(cbAllocated >= cbData + cbDataAdd);
+        memcpy((uint8_t *)pvData + cbData, pvDataAdd, cbDataAdd);
+
+        cbData += cbDataAdd;
+
+        return cbData;
     }
 
@@ -133 +129 @@
     void reset(void)
     {
+        strFmt = "";
+
         if (pvData)
         {
-            Assert(cbData);
+            Assert(cbAllocated);
             RTMemFree(pvData);
             pvData = NULL;
         }
 
-        cbData     = 0;
-        cbDataUsed = 0;
-    }
-
-    const void *getData(void) const { return pvData; }
-
-    void *getDataMutable(void) { return pvData; }
-
-    uint32_t getSize(void) const { return cbDataUsed; }
-
-public:
-
-    int fromString(const RTCString &strData)
-    {
-        int rc = VINF_SUCCESS;
-
-        if (strData.isNotEmpty())
-        {
-            const uint32_t cbStrData = (uint32_t)strData.length() + 1; /* Include terminating zero. */
-            rc = resize(cbStrData);
-            if (RT_SUCCESS(rc))
-                memcpy(pvData, strData.c_str(), cbStrData);
-        }
-
-        return rc;
-    }
-
-    int fromURIList(const DnDURIList &lstURI)
-    {
-        return fromString(lstURI.GetRootEntries());
-    }
-
-protected:
+        cbAllocated = 0;
+        cbData      = 0;
+    }
 
     int resize(uint32_t cbSize)
@@ -182 +150 @@
         }
 
-        if (cbSize == cbData)
+        if (cbSize == cbAllocated)
             return VINF_SUCCESS;
 
@@ -189 +157 @@
 
         void *pvTmp = NULL;
-        if (!cbData)
-        {
-            Assert(cbDataUsed == 0);
+        if (!cbAllocated)
+        {
+            Assert(cbData == 0);
             pvTmp = RTMemAllocZ(cbSize);
         }
@@ -203 +171 @@
         if (pvTmp)
         {
-            pvData = pvTmp;
-            cbData = cbSize;
+            pvData      = pvTmp;
+            cbAllocated = cbSize;
             return VINF_SUCCESS;
         }
@@ -211 +179 @@
     }
 
-protected:
-
-    void     *pvData;
-    uint32_t  cbData;
-    uint32_t  cbDataUsed;
-};
-
-/**
- * Class for keeping drag and drop (meta) data
- * to be sent/received.
- */
-class GuestDnDData
-{
-public:
-
+    /** Format string of this meta data. */
+    com::Utf8Str strFmt;
+    /** Pointer to allocated meta data. */
+    void        *pvData;
+    /** Used bytes of meta data. Must not exceed cbAllocated. */
+    uint32_t     cbData;
+    /** Size (in bytes) of allocated meta data. */
+    uint32_t     cbAllocated;
+};
+
+/**
+ * Struct for accounting shared DnD data to be sent/received.
+ */
+struct GuestDnDData
+{
     GuestDnDData(void)
-        : cbEstTotal(0)
-        , cbEstMeta(0)
-        , cbProcessed(0)
-    {
-        RT_ZERO(dataHdr);
-    }
+        : cbExtra(0)
+        , cbProcessed(0) { }
 
     virtual ~GuestDnDData(void)
@@ -239 +203 @@
     }
 
-public:
-
     uint64_t addProcessed(uint32_t cbDataAdd)
     {
-        const uint64_t cbTotal = getTotal(); NOREF(cbTotal);
+        const uint64_t cbTotal = Meta.cbData + cbExtra;
         Assert(cbProcessed + cbDataAdd <= cbTotal);
         cbProcessed += cbDataAdd;
@@ -251 +213 @@
     bool isComplete(void) const
     {
-        const uint64_t cbTotal = getTotal();
+        const uint64_t cbTotal = Meta.cbData + cbExtra;
         LogFlowFunc(("cbProcessed=%RU64, cbTotal=%RU64\n", cbProcessed, cbTotal));
         Assert(cbProcessed <= cbTotal);
@@ -257 +219 @@
     }
 
-    void *getChkSumMutable(void) { return dataHdr.pvChecksum; }
-
-    uint32_t getChkSumSize(void) const { return dataHdr.cbChecksum; }
-
-    void *getFmtMutable(void) { return dataHdr.pvMetaFmt; }
-
-    uint32_t getFmtSize(void) const { return dataHdr.cbMetaFmt; }
-
-    GuestDnDMetaData &getMeta(void) { return dataMeta; }
-
     uint8_t getPercentComplete(void) const
     {
-        int64_t cbTotal = RT_MAX(getTotal(), 1);
-        return (uint8_t)(cbProcessed * 100 / cbTotal);
-    }
-
-    uint64_t getProcessed(void) const { return cbProcessed; }
+        const uint64_t cbTotal = Meta.cbData + cbExtra;
+        return (uint8_t)(cbProcessed * 100 / RT_MAX(cbTotal, 1));
+    }
 
     uint64_t getRemaining(void) const
     {
-        const uint64_t cbTotal = getTotal();
-        Assert(cbProcessed <= cbTotal);
+        const uint64_t cbTotal = Meta.cbData + cbExtra;
+        AssertReturn(cbProcessed <= cbTotal, 0);
         return cbTotal - cbProcessed;
     }
 
-    uint64_t getTotal(void) const { return cbEstTotal; }
+    uint64_t getTotal(void) const
+    {
+        return Meta.cbData + cbExtra;
+    }
 
     void reset(void)
     {
-        clearFmt();
-        clearChkSum();
-
-        RT_ZERO(dataHdr);
-
-        dataMeta.reset();
-
-        cbEstTotal  = 0;
-        cbEstMeta   = 0;
+        Meta.reset();
+
+        cbExtra     = 0;
         cbProcessed = 0;
     }
 
-    int setFmt(const void *pvFmt, uint32_t cbFmt)
-    {
-        if (cbFmt)
-        {
-            AssertPtrReturn(pvFmt, VERR_INVALID_POINTER);
-            void *pvFmtTmp = RTMemAlloc(cbFmt);
-            if (!pvFmtTmp)
-                return VERR_NO_MEMORY;
-
-            clearFmt();
-
-            memcpy(pvFmtTmp, pvFmt, cbFmt);
-
-            dataHdr.pvMetaFmt = pvFmtTmp;
-            dataHdr.cbMetaFmt = cbFmt;
-        }
-        else
-            clearFmt();
-
-        return VINF_SUCCESS;
-    }
-
-    void setEstimatedSize(uint64_t cbTotal, uint32_t cbMeta)
-    {
-        Assert(cbMeta <= cbTotal);
-
-        LogFlowFunc(("cbTotal=%RU64, cbMeta=%RU32\n", cbTotal, cbMeta));
-
-        cbEstTotal = cbTotal;
-        cbEstMeta  = cbMeta;
-    }
-
-protected:
-
-    void clearChkSum(void)
-    {
-        if (dataHdr.pvChecksum)
-        {
-            Assert(dataHdr.cbChecksum);
-            RTMemFree(dataHdr.pvChecksum);
-            dataHdr.pvChecksum = NULL;
-        }
-
-        dataHdr.cbChecksum = 0;
-    }
-
-    void clearFmt(void)
-    {
-        if (dataHdr.pvMetaFmt)
-        {
-            Assert(dataHdr.cbMetaFmt);
-            RTMemFree(dataHdr.pvMetaFmt);
-            dataHdr.pvMetaFmt = NULL;
-        }
-
-        dataHdr.cbMetaFmt = 0;
-    }
-
-protected:
-
-    /** The data header. */
-    VBOXDNDDATAHDR    dataHdr;
     /** For storing the actual meta data.
      *  This might be an URI list or just plain raw data,
      *  according to the format being sent. */
-    GuestDnDMetaData  dataMeta;
-    /** Estimated total data size when receiving data. */
-    uint64_t          cbEstTotal;
-    /** Estimated meta data size when receiving data. */
-    uint32_t          cbEstMeta;
+    GuestDnDMetaData  Meta;
+    /** Extra data to send/receive (in bytes). Can be 0 for raw data.
+     *  For (file) transfers this is the total size for all files. */
+    uint64_t          cbExtra;
     /** Overall size (in bytes) of processed data. */
     uint64_t          cbProcessed;
@@ -373 +257 @@
 
 /** Initial object context state / no state set. */
-#define DND_OBJCTX_STATE_NONE           0
+#define DND_OBJ_STATE_NONE           0
 /** The header was received / sent. */
-#define DND_OBJCTX_STATE_HAS_HDR        RT_BIT(0)
+#define DND_OBJ_STATE_HAS_HDR        RT_BIT(0)
 /** Validation mask for object context state. */
-#define DND_OBJCTX_STATE_VALID_MASK     UINT32_C(0x00000001)
-
-/**
- * Structure for keeping a DnDURIObject context around.
- */
-class GuestDnDURIObjCtx
-{
-public:
-
-    GuestDnDURIObjCtx(void)
-        : pObjURI(NULL)
-        , fIntermediate(false)
-        , fState(DND_OBJCTX_STATE_NONE) { }
-
-    virtual ~GuestDnDURIObjCtx(void)
-    {
-        destroy();
-    }
-
-public:
-
-    int createIntermediate(DnDURIObject::Type enmType)
-    {
-        reset();
-
-        int rc;
-
-        try
-        {
-            pObjURI       = new DnDURIObject(enmType);
-            fIntermediate = true;
-
-            rc = VINF_SUCCESS;
-        }
-        catch (std::bad_alloc &)
-        {
-            rc = VERR_NO_MEMORY;
-        }
-
-        LogThisFunc(("Returning %Rrc\n", rc));
-        return rc;
-    }
-
-    void destroy(void)
-    {
-        LogFlowThisFuncEnter();
-
-        if (   pObjURI
-            && fIntermediate)
-        {
-            delete pObjURI;
-        }
-
-        pObjURI       = NULL;
-        fIntermediate = false;
-    }
-
-    DnDURIObject *getObj(void) const { return pObjURI; }
-
-    bool isIntermediate(void) { return fIntermediate; }
-
-    bool isValid(void) const { return (pObjURI != NULL); }
-
-    /** Returns the current state. */
-    uint32_t getState(void) const { return fState; }
-
-    void reset(void)
-    {
-        LogFlowThisFuncEnter();
-
-        destroy();
-
-        fIntermediate = false;
-        fState        = DND_OBJCTX_STATE_NONE;
-    }
-
-    void setObj(DnDURIObject *pObj)
-    {
-        LogFlowThisFunc(("%p\n", pObj));
-
-        destroy();
-
-        pObjURI = pObj;
-    }
-
-    /**
-     * Sets the new state.
-     *
-     * @returns The new state, if set.
-     * @param   fStateNew       New state to set.
-     */
-    uint32_t setState(uint32_t fStateNew)
-    {
-        AssertReturn(!(fStateNew & ~DND_OBJCTX_STATE_VALID_MASK), fState /* Return old state */);
-        fState = fStateNew;
-        return fState;
-    }
-
-protected:
-
-    /** Pointer to current object being handled. */
-    DnDURIObject             *pObjURI;
-    /** Flag whether pObjURI needs deletion after use. */
-    bool                      fIntermediate;
-    /** Internal context state, corresponding to DND_OBJCTX_STATE_XXX. */
-    uint32_t                  fState;
-    /** @todo Add more statistics / information here. */
-};
-
-/**
- * Structure for keeping around an URI (data) transfer.
- */
-class GuestDnDURIData
-{
-
-public:
-
-    GuestDnDURIData(void)
+#define DND_OBJ_STATE_VALID_MASK     UINT32_C(0x00000001)
+
+/**
+ * Class for keeping around DnD (file) transfer data.
+ */
+struct GuestDnDTransferData
+{
+
+public:
+
+    GuestDnDTransferData(void)
         : cObjToProcess(0)
         , cObjProcessed(0)
@@ -500 +277 @@
         , cbScratchBuf(0) { }
 
-    virtual ~GuestDnDURIData(void)
+    virtual ~GuestDnDTransferData(void)
+    {
+        destroy();
+    }
+
+    int init(size_t cbBuf = _64K)
+    {
+        reset();
+
+        pvScratchBuf = RTMemAlloc(cbBuf);
+        if (!pvScratchBuf)
+            return VERR_NO_MEMORY;
+
+        cbScratchBuf = cbBuf;
+        return VINF_SUCCESS;
+    }
+
+    void destroy(void)
     {
         reset();
@@ -513 +307 @@
     }
 
-    DnDDroppedFiles &getDroppedFiles(void) { return droppedFiles; }
-
-    DnDURIList &getURIList(void) { return lstURI; }
-
-    int init(size_t cbBuf = _64K)
-    {
-        reset();
-
-        pvScratchBuf = RTMemAlloc(cbBuf);
-        if (!pvScratchBuf)
-            return VERR_NO_MEMORY;
-
-        cbScratchBuf = cbBuf;
-        return VINF_SUCCESS;
-    }
-
-    bool isComplete(void) const
-    {
-        LogFlowFunc(("cObjProcessed=%RU64, cObjToProcess=%RU64\n", cObjProcessed, cObjToProcess));
-
-        if (!cObjToProcess) /* Always return true if we don't have an object count. */
-            return true;
-
-        Assert(cObjProcessed <= cObjToProcess);
-        return (cObjProcessed == cObjToProcess);
-    }
-
-    const void *getBuffer(void) const { return pvScratchBuf; }
-
-    void *getBufferMutable(void) { return pvScratchBuf; }
-
-    size_t getBufferSize(void) const { return cbScratchBuf; }
-
-    GuestDnDURIObjCtx &getObj(uint64_t uID = 0)
-    {
-        RT_NOREF(uID);
-        AssertMsg(uID == 0, ("Other objects than object 0 is not supported yet\n"));
-        return objCtx;
-    }
-
-    GuestDnDURIObjCtx &getObjCurrent(void)
-    {
-        DnDURIObject *pCurObj = lstURI.First();
-        if (   !lstURI.IsEmpty()
-            && pCurObj)
-        {
-            /* Point the context object to the current DnDURIObject to process. */
-            objCtx.setObj(pCurObj);
-        }
-        else
-            objCtx.reset();
-
-        return objCtx;
-    }
-
-    uint64_t getObjToProcess(void) const { return cObjToProcess; }
-
-    uint64_t getObjProcessed(void) const { return cObjProcessed; }
-
-    int processObject(const DnDURIObject &Obj)
-    {
-        int rc;
-
-        /** @todo Find objct in lstURI first! */
-        switch (Obj.GetType())
-        {
-            case DnDURIObject::Type_Directory:
-            case DnDURIObject::Type_File:
-                rc = VINF_SUCCESS;
-                break;
-
-            default:
-                rc = VERR_NOT_IMPLEMENTED;
-                break;
-        }
-
-        if (RT_SUCCESS(rc))
-        {
-            if (cObjToProcess)
-            {
-                cObjProcessed++;
-                Assert(cObjProcessed <= cObjToProcess);
-            }
-        }
-
-        return rc;
-    }
-
-    void removeObjCurrent(void)
-    {
-        if (cObjToProcess)
-        {
-            cObjProcessed++;
-            Assert(cObjProcessed <= cObjToProcess);
-        }
-
-        lstURI.RemoveFirst();
-        objCtx.reset();
-    }
-
     void reset(void)
     {
@@ -619 +313 @@
         cObjToProcess = 0;
         cObjProcessed = 0;
-
-        droppedFiles.Close();
-
-        lstURI.Clear();
-        objCtx.reset();
-    }
-
-    void setEstimatedObjects(uint64_t cObjs)
-    {
-        Assert(cObjToProcess == 0);
-        cObjToProcess = cObjs;
-        LogFlowFunc(("cObjToProcess=%RU64\n", cObjs));
-    }
-
-public:
-
-    int fromLocalMetaData(const GuestDnDMetaData &Data)
-    {
-        reset();
-
-        if (!Data.getSize())
-            return VINF_SUCCESS;
-
-        char *pszList;
-        int rc = RTStrCurrentCPToUtf8(&pszList, (const char *)Data.getData());
-        if (RT_FAILURE(rc))
-        {
-            LogFlowThisFunc(("String conversion failed with rc=%Rrc\n", rc));
-            return rc;
-        }
-
-        const size_t cbList = Data.getSize();
-        LogFlowThisFunc(("metaData=%p, cbList=%zu\n", &Data, cbList));
-
-        if (cbList)
-        {
-            RTCList<RTCString> lstURIOrg = RTCString(pszList, cbList).split("\r\n");
-            if (!lstURIOrg.isEmpty())
-            {
-                /* 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))
-                    cObjToProcess = lstURI.GetTotalCount();
-            }
-        }
-
-        RTStrFree(pszList);
-        return rc;
-    }
-
-    int fromRemoteMetaData(const GuestDnDMetaData &Data)
-    {
-        LogFlowFuncEnter();
-
-        int rc = lstURI.SetFromURIData(Data.getData(), Data.getSize(), 0 /* uFlags */);
-        if (RT_SUCCESS(rc))
-        {
-            const size_t cRootCount = lstURI.GetRootCount();
-            LogFlowFunc(("cRootCount=%zu, cObjToProcess=%RU64\n", cRootCount, cObjToProcess));
-            if (cRootCount > cObjToProcess)
-                rc = VERR_INVALID_PARAMETER;
-        }
-
-        return rc;
-    }
-
-    int toMetaData(std::vector<BYTE> &vecData)
-    {
-        const char *pszDroppedFilesDir = droppedFiles.GetDirAbs();
-
-        Utf8Str strURIs = lstURI.GetRootEntries(RTCString(pszDroppedFilesDir));
-        size_t cbData = strURIs.length();
-
-        LogFlowFunc(("%zu root URIs (%zu bytes)\n", lstURI.GetRootCount(), cbData));
-
-        int rc;
-
-        try
-        {
-            vecData.resize(cbData + 1 /* Include termination */);
-            memcpy(&vecData.front(), strURIs.c_str(), cbData);
-
-            rc = VINF_SUCCESS;
-        }
-        catch (std::bad_alloc &)
-        {
-            rc = VERR_NO_MEMORY;
-        }
-
-        return rc;
-    }
-
-protected:
-
-    int processDirectory(const char *pszPath, uint32_t fMode)
-    {
-        /** @todo Find directory in lstURI first! */
-        int rc;
-
-        const char *pszDroppedFilesDir = droppedFiles.GetDirAbs();
-        char *pszDir = RTPathJoinA(pszDroppedFilesDir, pszPath);
-        if (pszDir)
-        {
-            rc = RTDirCreateFullPath(pszDir, fMode);
-            if (cObjToProcess)
-            {
-                cObjProcessed++;
-                Assert(cObjProcessed <= cObjToProcess);
-            }
-
-            RTStrFree(pszDir);
-        }
-        else
-             rc = VERR_NO_MEMORY;
-
-        return rc;
-    }
-
-protected:
+    }
+
+    bool isComplete(void) const
+    {
+        return (cObjProcessed == cObjToProcess);
+    }
 
     /** Number of objects to process. */
-    uint64_t                        cObjToProcess;
+    uint64_t cObjToProcess;
     /** Number of objects already processed. */
-    uint64_t                        cObjProcessed;
-    /** Handles all drop files for this operation. */
-    DnDDroppedFiles                 droppedFiles;
-    /** (Non-recursive) List of URI objects to handle. */
-    DnDURIList                      lstURI;
-    /** 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;
+    uint64_t cObjProcessed;
     /** Pointer to an optional scratch buffer to use for
      *  doing the actual chunk transfers. */
-    void                           *pvScratchBuf;
+    void    *pvScratchBuf;
     /** Size (in bytes) of scratch buffer. */
-    size_t                          cbScratchBuf;
+    size_t   cbScratchBuf;
+};
+
+struct GuestDnDTransferSendData : public GuestDnDTransferData
+{
+    GuestDnDTransferSendData()
+        : mfObjState(0) { }
+
+    virtual ~GuestDnDTransferSendData()
+    {
+        destroy();
+    }
+
+    void destroy(void)
+    {
+        DnDTransferListDestroy(&mList);
+    }
+
+    void reset(void)
+    {
+        DnDTransferListReset(&mList);
+        mfObjState = 0;
+
+        GuestDnDTransferData::reset();
+    }
+
+    /** Transfer List to handle. */
+    DNDTRANSFERLIST                     mList;
+    /** Current state of object in transfer.
+     *  This is needed for keeping compatibility to old(er) DnD HGCM protocols.
+     *
+     *  At the moment we only support transferring one object at a time. */
+    uint32_t                            mfObjState;
 };
 
@@ -762 +366 @@
  * Context structure for sending data to the guest.
  */
-struct GuestDnDSendCtx
+struct GuestDnDSendCtx : public GuestDnDData
 {
     /** Pointer to guest target class this context belongs to. */
@@ -775 +379 @@
     /** Drag'n drop format requested by the guest. */
     com::Utf8Str                        mFmtReq;
-    /** Drag'n drop data to send.
-     *  This can be arbitrary data or an URI list. */
-    GuestDnDData                        mData;
-    /** URI data structure. */
-    GuestDnDURIData                     mURI;
+    /** Transfer data structure. */
+    GuestDnDTransferSendData            mTransfer;
     /** Callback event to use. */
     GuestDnDCallbackEvent               mCBEvent;
 };
 
+struct GuestDnDTransferRecvData : public GuestDnDTransferData
+{
+    GuestDnDTransferRecvData()
+    {
+        RT_ZERO(mDroppedFiles);
+        RT_ZERO(mList);
+        RT_ZERO(mObj);
+    }
+
+    virtual ~GuestDnDTransferRecvData()
+    {
+        destroy();
+    }
+
+    void destroy(void)
+    {
+        DnDTransferListDestroy(&mList);
+    }
+
+    void reset(void)
+    {
+        DnDDroppedFilesClose(&mDroppedFiles);
+        DnDTransferListReset(&mList);
+        DnDTransferObjectReset(&mObj);
+
+        GuestDnDTransferData::reset();
+    }
+
+    /** The "VirtualBox Dropped Files" directory on the host we're going
+     *  to utilize for transferring files from guest to the host. */
+    DNDDROPPEDFILES                     mDroppedFiles;
+    /** Transfer List to handle.
+     *  Currently we only support one transfer list at a time. */
+    DNDTRANSFERLIST                     mList;
+    /** Current transfer object being handled.
+     *  Currently we only support one transfer object at a time. */
+    DNDTRANSFEROBJECT                   mObj;
+};
+
 /**
  * Context structure for receiving data from the guest.
  */
-struct GuestDnDRecvCtx
+struct GuestDnDRecvCtx : public GuestDnDData
 {
     /** Pointer to guest source class this context belongs to. */
@@ -813 +453 @@
      *  deleted e.g. when moving instead of copying. */
     VBOXDNDACTION                       mAction;
-    /** Drag'n drop received from the guest.
-     *  This can be arbitrary data or an URI list. */
-    GuestDnDData                        mData;
-    /** URI data structure. */
-    GuestDnDURIData                     mURI;
+    /** Transfer data structure. */
+    GuestDnDTransferRecvData            mTransfer;
     /** Callback event to use. */
     GuestDnDCallbackEvent               mCBEvent;

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

@@ -101 +101 @@
     int i_receiveData(GuestDnDRecvCtx *pCtx, RTMSINTERVAL msTimeout);
     int i_receiveRawData(GuestDnDRecvCtx *pCtx, RTMSINTERVAL msTimeout);
-    int i_receiveURIData(GuestDnDRecvCtx *pCtx, RTMSINTERVAL msTimeout);
+    int i_receiveTransferData(GuestDnDRecvCtx *pCtx, RTMSINTERVAL msTimeout);
 
 protected:

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

@@ -87 +87 @@
 
     int i_sendData(GuestDnDSendCtx *pCtx, RTMSINTERVAL msTimeout);
-    int i_sendDataBody(GuestDnDSendCtx *pCtx, GuestDnDData *pData);
-    int i_sendDataHeader(GuestDnDSendCtx *pCtx, GuestDnDData *pData, GuestDnDURIData *pURIData /* = NULL */);
-    int i_sendDirectory(GuestDnDSendCtx *pCtx, GuestDnDURIObjCtx *pObjCtx, GuestDnDMsg *pMsg);
-    int i_sendFile(GuestDnDSendCtx *pCtx, GuestDnDURIObjCtx *pObjCtx, GuestDnDMsg *pMsg);
-    int i_sendFileData(GuestDnDSendCtx *pCtx, GuestDnDURIObjCtx *pObjCtx, GuestDnDMsg *pMsg);
+
+    int i_sendMetaDataBody(GuestDnDSendCtx *pCtx);
+    int i_sendMetaDataHeader(GuestDnDSendCtx *pCtx);
+
+    int i_sendTransferData(GuestDnDSendCtx *pCtx, RTMSINTERVAL msTimeout);
+    int i_sendTransferDataLoop(GuestDnDSendCtx *pCtx, GuestDnDMsg *pMsg);
+
+    int i_sendDirectory(GuestDnDSendCtx *pCtx, PDNDTRANSFEROBJECT pObj, GuestDnDMsg *pMsg);
+    int i_sendFile(GuestDnDSendCtx *pCtx, PDNDTRANSFEROBJECT pObj, GuestDnDMsg *pMsg);
+    int i_sendFileData(GuestDnDSendCtx *pCtx, PDNDTRANSFEROBJECT pObj, GuestDnDMsg *pMsg);
+
     int i_sendRawData(GuestDnDSendCtx *pCtx, RTMSINTERVAL msTimeout);
-    int i_sendURIData(GuestDnDSendCtx *pCtx, RTMSINTERVAL msTimeout);
-    int i_sendURIDataLoop(GuestDnDSendCtx *pCtx, GuestDnDMsg *pMsg);
 
 protected:
@@ -100 +104 @@
     struct
     {
+        /** Flag indicating whether a data transfer currently is active. */
         bool     mfTransferIsPending;
         /** Maximum data block size (in bytes) the target can handle. */

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

@@ -939 +939 @@
     /* cbDataAdd is optional. */
 
-    LogFlowFunc(("cbTotal=%RU64, cbProcessed=%RU64, cbRemaining=%RU64, cbDataAdd=%RU32\n",
-                 pData->getTotal(), pData->getProcessed(), pData->getRemaining(), cbDataAdd));
+    LogFlowFunc(("cbExtra=%RU64, cbProcessed=%RU64, cbRemaining=%RU64, cbDataAdd=%RU32\n",
+                 pData->cbExtra, pData->cbProcessed, pData->getRemaining(), cbDataAdd));
 
     if (!pResp)

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

@@ -420 +420 @@
     LogFlowThisFunc(("cTransfersPending=%RU32\n", mDataBase.m_cTransfersPending));
 
-    /* Don't allow receiving the actual data until our transfer actually is complete. */
+    /* Don't allow receiving the actual data until our current transfer is complete. */
     if (mDataBase.m_cTransfersPending)
         return setError(E_FAIL, tr("Current drop operation still in progress"));
 
-    GuestDnDRecvCtx *pCtx = &mData.mRecvCtx;
     HRESULT hr = S_OK;
 
     try
     {
-        bool fHasURIList = DnDMIMENeedsDropDir(pCtx->mFmtRecv.c_str(), pCtx->mFmtRecv.length());
-        if (fHasURIList)
-        {
-            LogRel2(("DnD: Drop directory is: %s\n", pCtx->mURI.getDroppedFiles().GetDirAbs()));
-            int rc2 = pCtx->mURI.toMetaData(aData);
-            if (RT_FAILURE(rc2))
-                hr = E_OUTOFMEMORY;
+        GuestDnDRecvCtx *pCtx = &mData.mRecvCtx;
+        if (DnDMIMENeedsDropDir(pCtx->mFmtRecv.c_str(), pCtx->mFmtRecv.length()))
+        {
+            PDNDDROPPEDFILES pDF = &pCtx->mTransfer.mDroppedFiles;
+
+            const char *pcszDropDirAbs = DnDDroppedFilesGetDirAbs(pDF);
+            AssertPtr(pcszDropDirAbs);
+
+            LogRel2(("DnD: Using drop directory '%s'\n", pcszDropDirAbs));
+
+            char  *pszBuf;
+            size_t cbBuf;
+            int rc = DnDTransferListGetRootsEx(&pCtx->mTransfer.mList, DNDTRANSFERLISTFMT_NATIVE,
+                                               pcszDropDirAbs, "\n" /* On all platforms */, &pszBuf, &cbBuf);
+            if (RT_SUCCESS(rc))
+            {
+                aData.resize(cbBuf);
+                memcpy(&aData.front(), pszBuf, cbBuf);
+                RTStrFree(pszBuf);
+            }
+            else
+                LogRel(("DnD: Unable to build source root list, rc=%Rrc\n", rc));
         }
         else
         {
-            const size_t cbData = pCtx->mData.getMeta().getSize();
-            LogFlowFunc(("cbData=%zu\n", cbData));
-            if (cbData)
+            if (pCtx->Meta.cbData)
             {
                 /* Copy the data into a safe array of bytes. */
-                aData.resize(cbData);
-                memcpy(&aData.front(), pCtx->mData.getMeta().getData(), cbData);
+                aData.resize(pCtx->Meta.cbData);
+                memcpy(&aData.front(), pCtx->Meta.pvData, pCtx->Meta.cbData);
             }
             else
@@ -541 +553 @@
 
 #ifdef VBOX_WITH_DRAG_AND_DROP_GH
+/**
+ * Handles receiving a send data header from the guest.
+ *
+ * @returns VBox status code.
+ * @param   pCtx                Receive context to use.
+ * @param   pDataHdr            Pointer to send data header from the guest.
+ */
 int GuestDnDSource::i_onReceiveDataHdr(GuestDnDRecvCtx *pCtx, PVBOXDNDSNDDATAHDR pDataHdr)
 {
-    AssertPtrReturn(pCtx,  VERR_INVALID_POINTER);
-    AssertReturn(pDataHdr, VERR_INVALID_POINTER);
-
-    pCtx->mData.setEstimatedSize(pDataHdr->cbTotal, pDataHdr->cbMeta);
-
-    Assert(pCtx->mURI.getObjToProcess() == 0);
-    pCtx->mURI.reset();
-    pCtx->mURI.setEstimatedObjects(pDataHdr->cObjects);
+    AssertPtrReturn(pCtx,     VERR_INVALID_POINTER);
+    AssertPtrReturn(pDataHdr, VERR_INVALID_POINTER);
+
+    LogRel2(("DnD: Receiving %RU64 bytes total data (%RU64 bytes meta data, %RU64 objects) from guest ...\n",
+             pDataHdr->cbTotal, pDataHdr->cbMeta, pDataHdr->cObjects));
+
+    AssertReturn(pDataHdr->cbTotal >= pDataHdr->cbMeta, VERR_INVALID_PARAMETER);
+
+    int rc = pCtx->Meta.resize(pDataHdr->cbMeta);
+    AssertRCReturn(rc, rc);
+
+    pCtx->cbExtra = pDataHdr->cbTotal - pDataHdr->cbMeta;
+
+    Assert(pCtx->mTransfer.cObjToProcess == 0); /* Sanity. */
+    Assert(pCtx->mTransfer.cObjProcessed == 0);
+
+    pCtx->mTransfer.reset();
+
+    pCtx->mTransfer.cObjToProcess = pDataHdr->cObjects;
 
     /** @todo Handle compression type. */
@@ -559 +589 @@
 }
 
+/**
+ * Handles receiving a send data block from the guest.
+ *
+ * @returns VBox status code.
+ * @param   pCtx                Receive context to use.
+ * @param   pSndData            Pointer to send data block from the guest.
+ */
 int GuestDnDSource::i_onReceiveData(GuestDnDRecvCtx *pCtx, PVBOXDNDSNDDATA pSndData)
 {
@@ -568 +605 @@
     try
     {
-        GuestDnDData    *pData = &pCtx->mData;
-        GuestDnDURIData *pURI  = &pCtx->mURI;
+        GuestDnDTransferRecvData *pTransfer = &pCtx->mTransfer;
 
         uint32_t cbData;
@@ -593 +629 @@
             pvData  = pSndData->u.v3.pvData;
 
-            /* Note: Data sizes get updated in i_onReceiveDataHdr(). */
-            cbTotal = pData->getTotal();
-            cbMeta  = pData->getMeta().getSize();
-        }
-        Assert(cbTotal);
+            /* Note: Data sizes get initialized in i_onReceiveDataHdr().
+             *       So just use the set values here. */
+            cbTotal = pCtx->getTotal();
+            cbMeta  = pCtx->Meta.cbData;
+        }
 
         if (   cbData == 0
-            || cbData >  cbTotal /* Paranoia */)
-        {
-            LogFlowFunc(("Incoming data size invalid: cbData=%RU32, cbToProcess=%RU64\n", cbData, pData->getTotal()));
+            || cbData > cbTotal /* Paranoia */)
+        {
+            LogFlowFunc(("Incoming data size invalid: cbData=%RU32, cbToProcess=%RU64\n", cbData, cbTotal));
             rc = VERR_INVALID_PARAMETER;
         }
-        else if (cbTotal < cbMeta)
+        else if (   cbTotal == 0
+                 || cbTotal  < cbMeta)
         {
             AssertMsgFailed(("cbTotal (%RU64) is smaller than cbMeta (%RU32)\n", cbTotal, cbMeta));
@@ -611 +648 @@
         }
 
-        if (RT_SUCCESS(rc))
-        {
-            cbMeta = pData->getMeta().add(pvData, cbData);
-            LogFlowThisFunc(("cbMetaSize=%zu, cbData=%RU32, cbMeta=%RU32, cbTotal=%RU64\n",
-                             pData->getMeta().getSize(), cbData, cbMeta, cbTotal));
-        }
-
-        if (RT_SUCCESS(rc))
-        {
-            /*
-             * (Meta) Data transfer complete?
-             */
-            Assert(cbMeta <= pData->getMeta().getSize());
-            if (cbMeta == pData->getMeta().getSize())
+        if (RT_FAILURE(rc))
+            return rc;
+
+        cbMeta = pCtx->Meta.add(pvData, cbData);
+
+        LogFlowThisFunc(("cbData=%RU32, cbMeta=%RU32, cbTotal=%RU64\n", cbData, cbMeta, cbTotal));
+
+        /*
+         * (Meta) Data transfer complete?
+         */
+        Assert(cbMeta <= pCtx->Meta.cbAllocated);
+        if (cbMeta == pCtx->Meta.cbAllocated)
+        {
+            LogRel2(("DnD: Receiving meta data complete\n"));
+
+            if (DnDMIMENeedsDropDir(pCtx->mFmtRecv.c_str(), pCtx->mFmtRecv.length()))
             {
-                bool fHasURIList = DnDMIMENeedsDropDir(pCtx->mFmtRecv.c_str(), pCtx->mFmtRecv.length());
-                LogFlowThisFunc(("fHasURIList=%RTbool\n", fHasURIList));
-                if (fHasURIList)
+                LogRel2(("DnD: Building transfer list from meta data ...\n"));
+
+                rc = DnDTransferListAppendPathsFromBuffer(&pTransfer->mList, DNDTRANSFERLISTFMT_URI,
+                                                          (const char *)pCtx->Meta.pvData, pCtx->Meta.cbData, DND_PATH_SEPARATOR,
+                                                          DNDTRANSFERLIST_FLAGS_NONE);
+                /* Validation. */
+                if (RT_SUCCESS(rc))
                 {
-                    /* Try parsing the data as URI list. */
-                    rc = pURI->fromRemoteMetaData(pData->getMeta());
-                    if (RT_SUCCESS(rc))
-                    {
-                        if (mDataBase.m_uProtocolVersion < 3)
-                            pData->setEstimatedSize(cbTotal, cbMeta);
-
-                        /*
-                         * Update our process with the data we already received.
-                         * Note: The total size will consist of the meta data (in pVecData) and
-                         *       the actual accumulated file/directory data from the guest.
-                         */
-                        rc = updateProgress(pData, pCtx->mpResp, (uint32_t)pData->getMeta().getSize());
-                    }
+                    uint64_t cRoots = DnDTransferListGetRootCount(&pTransfer->mList);
+                    if (   cRoots == 0
+                        || cRoots > pTransfer->cObjToProcess)
+                        rc = VERR_INVALID_PARAMETER;
                 }
-                else /* Raw data. */
-                    rc = updateProgress(pData, pCtx->mpResp, cbData);
+
+                if (RT_SUCCESS(rc))
+                {
+                    /* Update our process with the data we already received. */
+                    rc = updateProgress(pCtx, pCtx->mpResp, cbMeta);
+                    AssertRC(rc);
+                }
+
+                if (RT_FAILURE(rc))
+                    LogRel(("DnD: Error building transfer list, rc=%Rrc\n", rc));
             }
+            else /* Raw data. */
+            {
+                rc = updateProgress(pCtx, pCtx->mpResp, cbData);
+                AssertRC(rc);
+            }
+
+            if (RT_FAILURE(rc))
+                LogRel(("DnD: Error receiving meta data, rc=%Rrc\n", rc));
         }
     }
@@ -667 +716 @@
     LogFlowFunc(("pszPath=%s, cbPath=%RU32, fMode=0x%x\n", pszPath, cbPath, fMode));
 
-    /*
-     * Sanity checking.
-     */
-    if (   !cbPath
-        || cbPath > RTPATH_MAX)
-    {
-        LogFlowFunc(("Path length invalid, bailing out\n"));
-        return VERR_INVALID_PARAMETER;
-    }
-
-    int rc = RTStrValidateEncodingEx(pszPath, RTSTR_MAX, 0);
+    AssertMsgReturn(pCtx->isComplete() == false,
+                    ("Data transfer already complete, bailing out\n"), VERR_INVALID_PARAMETER);
+
+    const PDNDTRANSFEROBJECT pObj = &pCtx->mTransfer.mObj;
+    const PDNDDROPPEDFILES   pDF  = &pCtx->mTransfer.mDroppedFiles;
+
+    int rc = DnDTransferObjectInit(pObj, DNDTRANSFEROBJTYPE_DIRECTORY,
+                                   DnDDroppedFilesGetDirAbs(pDF), pszPath);
+    if (RT_SUCCESS(rc))
+    {
+        const char *pcszPathAbs = DnDTransferObjectGetSourcePath(pObj);
+        AssertPtr(pcszPathAbs);
+
+        rc = RTDirCreateFullPath(pcszPathAbs, fMode);
+        if (RT_SUCCESS(rc))
+        {
+            pCtx->mTransfer.cObjProcessed++;
+            if (pCtx->mTransfer.cObjProcessed <= pCtx->mTransfer.cObjToProcess)
+            {
+                rc = DnDDroppedFilesAddDir(pDF, pcszPathAbs);
+            }
+            else
+                rc = VERR_TOO_MUCH_DATA;
+
+            DnDTransferObjectDestroy(pObj);
+
+            if (RT_SUCCESS(rc))
+                LogRel2(("DnD: Created guest directory '%s' on host\n", pcszPathAbs));
+        }
+        else
+            LogRel(("DnD: Error creating guest directory '%s' on host, rc=%Rrc\n", pcszPathAbs, rc));
+    }
+
     if (RT_FAILURE(rc))
-    {
-        LogFlowFunc(("Path validation failed with %Rrc, bailing out\n", rc));
-        return VERR_INVALID_PARAMETER;
-    }
-
-    if (pCtx->mURI.isComplete())
-    {
-        LogFlowFunc(("Data transfer already complete, bailing out\n"));
-        return VERR_INVALID_PARAMETER;
-    }
-
-    GuestDnDURIObjCtx &objCtx = pCtx->mURI.getObj(0); /** @todo Fill in context ID. */
-
-    rc = objCtx.createIntermediate(DnDURIObject::Type_Directory);
-    if (RT_FAILURE(rc))
-        return rc;
-
-    DnDURIObject *pObj = objCtx.getObj();
-    AssertPtr(pObj);
-
-    const char *pszDroppedFilesDir = pCtx->mURI.getDroppedFiles().GetDirAbs();
-    char *pszDir = RTPathJoinA(pszDroppedFilesDir, pszPath);
-    if (pszDir)
-    {
-#ifdef RT_OS_WINDOWS
-        RTPathChangeToDosSlashes(pszDir, true /* fForce */);
-#else
-        RTPathChangeToDosSlashes(pszDir, true /* fForce */);
-#endif
-        rc = RTDirCreateFullPath(pszDir, fMode);
-        if (RT_SUCCESS(rc))
-        {
-            pCtx->mURI.processObject(*pObj);
-
-            /* Add for having a proper rollback. */
-            int rc2 = pCtx->mURI.getDroppedFiles().AddDir(pszDir);
-            AssertRC(rc2);
-
-            objCtx.reset();
-            LogRel2(("DnD: Created guest directory '%s' on host\n", pszDir));
-        }
-        else
-            LogRel(("DnD: Error creating guest directory '%s' on host, rc=%Rrc\n", pszDir, rc));
-
-        RTStrFree(pszDir);
-    }
-    else
-         rc = VERR_NO_MEMORY;
+        LogRel(("DnD: Receiving guest directory '%s' failed with rc=%Rrc\n", pszPath, rc));
 
     LogFlowFuncLeaveRC(rc);
@@ -732 +756 @@
 }
 
+/**
+ * Receives a file header from the guest.
+ *
+ * @returns VBox status code.
+ * @param   pCtx                Receive context to use.
+ * @param   pszPath             File path of file to use.
+ * @param   cbPath              Size (in bytes, including terminator) of file path.
+ * @param   cbSize              File size (in bytes) to receive.
+ * @param   fMode               File mode to use.
+ * @param   fFlags              Additional receive flags; not used yet.
+ */
 int GuestDnDSource::i_onReceiveFileHdr(GuestDnDRecvCtx *pCtx, const char *pszPath, uint32_t cbPath,
                                        uint64_t cbSize, uint32_t fMode, uint32_t fFlags)
 {
-    RT_NOREF(fFlags);
     AssertPtrReturn(pCtx,    VERR_INVALID_POINTER);
     AssertPtrReturn(pszPath, VERR_INVALID_POINTER);
@@ -742 +776 @@
     /* fFlags are optional. */
 
+    RT_NOREF(fFlags);
+
     LogFlowFunc(("pszPath=%s, cbPath=%RU32, cbSize=%RU64, fMode=0x%x, fFlags=0x%x\n", pszPath, cbPath, cbSize, fMode, fFlags));
 
-    /*
-     * Sanity checking.
-     */
-    if (   !cbPath
-        || cbPath > RTPATH_MAX)
-    {
-        return VERR_INVALID_PARAMETER;
-    }
-
-    if (!RTStrIsValidEncoding(pszPath))
-        return VERR_INVALID_PARAMETER;
-
-    if (cbSize > pCtx->mData.getTotal())
-    {
-        AssertMsgFailed(("File size (%RU64) exceeds total size to transfer (%RU64)\n", cbSize, pCtx->mData.getTotal()));
-        return VERR_INVALID_PARAMETER;
-    }
-
-    if (pCtx->mURI.getObjToProcess() && pCtx->mURI.isComplete())
-        return VERR_INVALID_PARAMETER;
+    AssertMsgReturn(cbSize <= pCtx->cbExtra,
+                    ("File size (%RU64) exceeds extra size to transfer (%RU64)\n", cbSize, pCtx->cbExtra), VERR_INVALID_PARAMETER);
+    AssertMsgReturn(   pCtx->isComplete() == false
+                    && pCtx->mTransfer.cObjToProcess,
+                    ("Data transfer already complete, bailing out\n"), VERR_INVALID_PARAMETER);
 
     int rc = VINF_SUCCESS;
@@ -769 +790 @@
     do
     {
-        GuestDnDURIObjCtx &objCtx = pCtx->mURI.getObj(0); /** @todo Fill in context ID. */
-        DnDURIObject *pObj        = objCtx.getObj();
-
-        /*
-         * Sanity checking.
-         */
-        if (pObj)
-        {
-            if (    pObj->IsOpen()
-                && !pObj->IsComplete())
+        const PDNDTRANSFEROBJECT pObj = &pCtx->mTransfer.mObj;
+
+        if (    DnDTransferObjectIsOpen(pObj)
+            && !DnDTransferObjectIsComplete(pObj))
+        {
+            AssertMsgFailed(("Object '%s' not complete yet\n", DnDTransferObjectGetSourcePath(pObj)));
+            rc = VERR_WRONG_ORDER;
+            break;
+        }
+
+        const PDNDDROPPEDFILES pDF = &pCtx->mTransfer.mDroppedFiles;
+
+        rc = DnDTransferObjectInit(pObj, DNDTRANSFEROBJTYPE_FILE, DnDDroppedFilesGetDirAbs(pDF), pszPath);
+        AssertRCBreak(rc);
+
+        const char *pcszSource = DnDTransferObjectGetSourcePath(pObj);
+        AssertPtrBreakStmt(pcszSource, VERR_INVALID_POINTER);
+
+        /** @todo Add sparse file support based on fFlags? (Use Open(..., fFlags | SPARSE). */
+        rc = DnDTransferObjectOpen(pObj, RTFILE_O_CREATE_REPLACE | RTFILE_O_WRITE | RTFILE_O_DENY_WRITE,
+                                   (fMode & RTFS_UNIX_MASK) | RTFS_UNIX_IRUSR | RTFS_UNIX_IWUSR, DNDTRANSFEROBJECT_FLAGS_NONE);
+        if (RT_FAILURE(rc))
+        {
+            LogRel(("DnD: Error opening/creating guest file '%s' on host, rc=%Rrc\n", pcszSource, rc));
+            break;
+        }
+
+        /* Note: Protocol v1 does not send any file sizes, so always 0. */
+        if (mDataBase.m_uProtocolVersion >= 2)
+            rc = DnDTransferObjectSetSize(pObj, cbSize);
+
+        /** @todo Unescape path before printing. */
+        LogRel2(("DnD: Transferring guest file '%s' to host (%RU64 bytes, mode %#x)\n",
+                 pcszSource, DnDTransferObjectGetSize(pObj), DnDTransferObjectGetMode(pObj)));
+
+        /** @todo Set progress object title to current file being transferred? */
+
+        if (DnDTransferObjectIsComplete(pObj)) /* 0-byte file? We're done already. */
+        {
+            LogRel2(("DnD: Transferring guest file '%s' (0 bytes) to host complete\n", pcszSource));
+
+            pCtx->mTransfer.cObjProcessed++;
+            if (pCtx->mTransfer.cObjProcessed <= pCtx->mTransfer.cObjToProcess)
             {
-                AssertMsgFailed(("Object '%s' not complete yet\n", pObj->GetPath().c_str()));
-                rc = VERR_WRONG_ORDER;
-                break;
+                /* Add for having a proper rollback. */
+                rc = DnDDroppedFilesAddFile(pDF, pcszSource);
             }
-
-            if (pObj->IsOpen()) /* File already opened? */
-            {
-                AssertMsgFailed(("Current opened object is '%s', close this first\n", pObj->GetPath().c_str()));
-                rc = VERR_WRONG_ORDER;
-                break;
-            }
-        }
-        else
-        {
-            /*
-             * Create new intermediate object to work with.
-             */
-            rc = objCtx.createIntermediate(DnDURIObject::Type_File);
-        }
-
-        if (RT_SUCCESS(rc))
-        {
-            pObj = objCtx.getObj();
-            AssertPtr(pObj);
-
-            const char *pszDroppedFilesDir = pCtx->mURI.getDroppedFiles().GetDirAbs();
-            AssertPtr(pszDroppedFilesDir);
-
-            char pszPathAbs[RTPATH_MAX];
-            rc = RTPathJoin(pszPathAbs, sizeof(pszPathAbs), pszDroppedFilesDir, pszPath);
-            if (RT_FAILURE(rc))
-            {
-                LogFlowFunc(("Warning: Rebasing current file failed with rc=%Rrc\n", rc));
-                break;
-            }
-
-            rc = pObj->Init(DnDURIObject::Type_File, pszPathAbs);
-            if (RT_SUCCESS(rc))
-            {
-                /** @todo Add sparse file support based on fFlags? (Use Open(..., fFlags | SPARSE). */
-                rc = pObj->Open(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))
-                {
-                    /* Add for having a proper rollback. */
-                    int rc2 = pCtx->mURI.getDroppedFiles().AddFile(pszPathAbs);
-                    AssertRC(rc2);
-                }
-            }
-
-            if (RT_FAILURE(rc))
-                LogRel(("DnD: Error opening/creating guest file '%s' on host, rc=%Rrc\n", pszPathAbs, rc));
-        }
-
-        if (RT_SUCCESS(rc))
-        {
-            /* Note: Protocol v1 does not send any file sizes, so always 0. */
-            if (mDataBase.m_uProtocolVersion >= 2)
-                rc = pObj->SetSize(cbSize);
-
-            /** @todo Unescape path before printing. */
-            LogRel2(("DnD: Transferring guest file '%s' to host (%RU64 bytes, mode 0x%x)\n",
-                     pObj->GetPath().c_str(), pObj->GetSize(), pObj->GetMode()));
-
-            /** @todo Set progress object title to current file being transferred? */
-
-            if (pObj->IsComplete()) /* 0-byte file? We're done already. */
-            {
-                LogRel2(("DnD: Transferring guest file '%s' (0 bytes) to host complete\n", pObj->GetPath().c_str()));
-
-                pCtx->mURI.processObject(*pObj);
-                pObj->Close();
-
-                objCtx.reset();
-            }
+            else
+                rc = VERR_TOO_MUCH_DATA;
+
+            DnDTransferObjectDestroy(pObj);
         }
 
@@ -884 +870 @@
     do
     {
-        GuestDnDURIObjCtx &objCtx = pCtx->mURI.getObj(0); /** @todo Fill in context ID. */
-        DnDURIObject *pObj        = objCtx.getObj();
-
-        if (!pObj)
-        {
-            LogFlowFunc(("Warning: No current object set\n"));
+        const PDNDTRANSFEROBJECT pObj = &pCtx->mTransfer.mObj;
+
+        if (    DnDTransferObjectIsOpen(pObj)
+            && !DnDTransferObjectIsComplete(pObj))
+        {
+            AssertMsgFailed(("Object '%s' not complete yet\n", DnDTransferObjectGetSourcePath(pObj)));
             rc = VERR_WRONG_ORDER;
             break;
         }
 
-        if (pObj->IsComplete())
-        {
-            LogFlowFunc(("Warning: Object '%s' already completed\n", pObj->GetPath().c_str()));
-            rc = VERR_WRONG_ORDER;
-            break;
-        }
-
-        if (!pObj->IsOpen()) /* File opened on host? */
-        {
-            LogFlowFunc(("Warning: Object '%s' not opened\n", pObj->GetPath().c_str()));
-            rc = VERR_WRONG_ORDER;
-            break;
-        }
+        const char *pcszSource = DnDTransferObjectGetSourcePath(pObj);
+        AssertPtrBreakStmt(pcszSource, VERR_INVALID_POINTER);
 
         uint32_t cbWritten;
-        rc = pObj->Write(pvData, cbData, &cbWritten);
-        if (RT_SUCCESS(rc))
-        {
-            Assert(cbWritten <= cbData);
-            if (cbWritten < cbData)
-            {
-                LogRel(("DnD: Only written %RU32 of %RU32 bytes of guest file '%s' -- disk full?\n",
-                        cbWritten, cbData, pObj->GetPath().c_str()));
-                rc = VERR_IO_GEN_FAILURE; /** @todo Find a better rc. */
-            }
-
-            if (RT_SUCCESS(rc))
-                rc = updateProgress(&pCtx->mData, pCtx->mpResp, cbWritten);
-        }
-        else
-            LogRel(("DnD: Error writing guest file data for '%s', rc=%Rrc\n", pObj->GetPath().c_str(), rc));
-
-        if (RT_SUCCESS(rc))
-        {
-            if (pObj->IsComplete())
-            {
-                /** @todo Sanitize path. */
-                LogRel2(("DnD: Transferring guest file '%s' to host complete\n", pObj->GetPath().c_str()));
-                pCtx->mURI.processObject(*pObj);
-                objCtx.reset();
-            }
+        rc = DnDTransferObjectWrite(pObj, pvData, cbData, &cbWritten);
+        if (RT_FAILURE(rc))
+            LogRel(("DnD: Error writing guest file data for '%s', rc=%Rrc\n", pcszSource, rc));
+
+        Assert(cbWritten <= cbData);
+        if (cbWritten < cbData)
+        {
+            LogRel(("DnD: Only written %RU32 of %RU32 bytes of guest file '%s' -- disk full?\n",
+                    cbWritten, cbData, pcszSource));
+            rc = VERR_IO_GEN_FAILURE; /** @todo Find a better rc. */
+            break;
+        }
+
+        rc = updateProgress(pCtx, pCtx->mpResp, cbWritten);
+        AssertRCBreak(rc);
+
+        if (DnDTransferObjectIsComplete(pObj))
+        {
+            LogRel2(("DnD: Transferring guest file '%s' to host complete\n", pcszSource));
+
+            pCtx->mTransfer.cObjProcessed++;
+            if (pCtx->mTransfer.cObjProcessed > pCtx->mTransfer.cObjToProcess)
+                rc = VERR_TOO_MUCH_DATA;
+
+            DnDTransferObjectDestroy(pObj);
         }
 
@@ -974 +948 @@
      * Reset any old data.
      */
-    pCtx->mData.reset();
-    pCtx->mURI.reset();
+    pCtx->reset();
+    pCtx->mTransfer.reset();
     pResp->reset();
 
@@ -1029 +1003 @@
         if (fURIData)
         {
-            rc = i_receiveURIData(pCtx, msTimeout);
+            rc = i_receiveTransferData(pCtx, msTimeout);
         }
         else
@@ -1184 +1158 @@
 }
 
-int GuestDnDSource::i_receiveURIData(GuestDnDRecvCtx *pCtx, RTMSINTERVAL msTimeout)
+int GuestDnDSource::i_receiveTransferData(GuestDnDRecvCtx *pCtx, RTMSINTERVAL msTimeout)
 {
     AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
@@ -1227 +1201 @@
     REGISTER_CALLBACK(GUEST_DND_GH_SND_FILE_DATA);
 
-    DnDDroppedFiles &droppedFiles = pCtx->mURI.getDroppedFiles();
+    const PDNDDROPPEDFILES pDF = &pCtx->mTransfer.mDroppedFiles;
 
     do
     {
-        rc = droppedFiles.OpenTemp(0 /* fFlags */);
+        rc = DnDDroppedFilesOpenTemp(pDF, 0 /* fFlags */);
         if (RT_FAILURE(rc))
         {
-            LogRel(("DnD: Opening dropped files directory '%s' on the host failed with rc=%Rrc\n", droppedFiles.GetDirAbs(), rc));
+            LogRel(("DnD: Opening dropped files directory '%s' on the host failed with rc=%Rrc\n",
+                    DnDDroppedFilesGetDirAbs(pDF), rc));
             break;
         }
 
         /*
-         * Receive the URI list.
+         * Receive the transfer list.
          */
         GuestDnDMsg Msg;
@@ -1282 +1257 @@
     if (RT_FAILURE(rc))
     {
-        int rc2 = droppedFiles.Rollback();
+        int rc2 = DnDDroppedFilesRollback(pDF);
         if (RT_FAILURE(rc2))
             LogRel(("DnD: Deleting left over temporary files failed (%Rrc), please remove directory '%s' manually\n",
-                    rc2, droppedFiles.GetDirAbs()));
+                    rc2, DnDDroppedFilesGetDirAbs(pDF)));
 
         if (rc == VERR_CANCELLED)
@@ -1310 +1285 @@
     }
 
-    droppedFiles.Close();
+    DnDDroppedFilesClose(pDF);
 
     LogFlowFuncLeaveRC(rc);
@@ -1429 +1404 @@
 
     /* All data processed? */
-    if (pCtx->mData.isComplete())
+    if (pCtx->isComplete())
         fNotify = true;
 
-    LogFlowFunc(("cbProcessed=%RU64, cbToProcess=%RU64, fNotify=%RTbool, rcCallback=%Rrc, rc=%Rrc\n",
-                 pCtx->mData.getProcessed(), pCtx->mData.getTotal(), fNotify, rcCallback, rc));
+    LogFlowFunc(("cbProcessed=%RU64, cbExtra=%RU64, fNotify=%RTbool, rcCallback=%Rrc, rc=%Rrc\n",
+                 pCtx->cbProcessed, pCtx->cbExtra, fNotify, rcCallback, rc));
 
     if (fNotify)
@@ -1604 +1579 @@
 
     /* All data processed? */
-    if (   pCtx->mURI.isComplete()
-        && pCtx->mData.isComplete())
+    if (   pCtx->mTransfer.isComplete()
+        && pCtx->isComplete())
     {
         fNotify = true;
     }
 
-    LogFlowFunc(("cbProcessed=%RU64, cbToProcess=%RU64, fNotify=%RTbool, rcCallback=%Rrc, rc=%Rrc\n",
-                 pCtx->mData.getProcessed(), pCtx->mData.getTotal(), fNotify, rcCallback, rc));
+    LogFlowFunc(("cbProcessed=%RU64, cbExtra=%RU64, fNotify=%RTbool, rcCallback=%Rrc, rc=%Rrc\n",
+                 pCtx->cbProcessed, pCtx->cbExtra, fNotify, rcCallback, rc));
 
     if (fNotify)

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

@@ -563 +563 @@
 }
 
+/**
+ * Thread handler function for sending data to the guest.
+ *
+ * @param   pTask               Thread task this handler is associated with.
+ */
 /* static */
 void GuestDnDTarget::i_sendDataThreadTask(GuestDnDSendDataTask *pTask)
@@ -593 +598 @@
 
 /**
- * Initiates a data transfer from the host to the guest. The source is the host whereas the target is the
- * guest in this case.
+ * Initiates a data transfer from the host to the guest.
+ *
+ * The source is the host, whereas the target is the guest.
  *
  * @return  HRESULT
- * @param   aScreenId
- * @param   aFormat
- * @param   aData
- * @param   aProgress
+ * @param   aScreenId           Screen ID where this data transfer was initiated from.
+ * @param   aFormat             Format of data to send. MIME-style.
+ * @param   aData               Actual data to send.
+ * @param   aProgress           Where to return the progress object on success.
  */
 HRESULT GuestDnDTarget::sendData(ULONG aScreenId, const com::Utf8Str &aFormat, const std::vector<BYTE> &aData,
@@ -632 +638 @@
         return hr;
 
-    GuestDnDSendDataTask *pTask = NULL;
-    GuestDnDSendCtx *pSendCtx = NULL;
+    GuestDnDSendDataTask *pTask    = NULL;
+    GuestDnDSendCtx      *pSendCtx = NULL;
 
     try
     {
-        //pSendCtx is passed into SendDataTask where one is deleted in destructor
+        /* pSendCtx is passed into SendDataTask where one is deleted in destructor. */
         pSendCtx = new GuestDnDSendCtx();
-        pSendCtx->mpTarget      = this;
-        pSendCtx->mpResp        = pResp;
-        pSendCtx->mScreenID     = aScreenId;
-        pSendCtx->mFmtReq       = aFormat;
-        pSendCtx->mData.getMeta().add(aData);
+        pSendCtx->mpTarget  = this;
+        pSendCtx->mpResp    = pResp;
+        pSendCtx->mScreenID = aScreenId;
+        pSendCtx->mFmtReq   = aFormat;
+
+        pSendCtx->Meta.add(aData);
 
         /* pTask is responsible for deletion of pSendCtx after creating */
@@ -757 +764 @@
 
 /**
- * @returns VBox status code that the caller ignores. Not sure if that's
- *          intentional or not.
+ * Main function for sending DnD host data to the guest.
+ *
+ * @returns VBox status code.
+ * @param   pCtx                Send context to use.
+ * @param   msTimeout           Timeout (in ms) to wait for getting the data sent.
  */
 int GuestDnDTarget::i_sendData(GuestDnDSendCtx *pCtx, RTMSINTERVAL msTimeout)
@@ -776 +786 @@
      * Note: The decision whether we need to build up a file tree and sending
      *       actual file data only depends on the actual formats offered by this target.
-     *       If the guest does not want an URI list ("text/uri-list") but text ("TEXT" and
+     *       If the guest does not want a transfer list ("text/uri-list") but text ("TEXT" and
      *       friends) instead, still send the data over to the guest -- the file as such still
      *       is needed on the guest in this case, as the guest then just wants a simple path
-     *       instead of an URI list (pointing to a file on the guest itself).
+     *       instead of a transfer list (pointing to a file on the guest itself).
      *
      ** @todo Support more than one format; add a format<->function handler concept. Later. */
@@ -787 +797 @@
     if (fHasURIList)
     {
-        rc = i_sendURIData(pCtx, msTimeout);
+        rc = i_sendTransferData(pCtx, msTimeout);
     }
     else
@@ -800 +810 @@
 }
 
-int GuestDnDTarget::i_sendDataBody(GuestDnDSendCtx *pCtx, GuestDnDData *pData)
-{
-    AssertPtrReturn(pCtx,  VERR_INVALID_POINTER);
-    AssertPtrReturn(pData, VERR_INVALID_POINTER);
+/**
+ * Sends the common meta data body to the guest.
+ *
+ * @returns VBox status code.
+ * @param   pCtx                Send context to use.
+ */
+int GuestDnDTarget::i_sendMetaDataBody(GuestDnDSendCtx *pCtx)
+{
+    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
 
     /** @todo Add support for multiple HOST_DND_HG_SND_DATA messages in case of more than 64K data! */
-    if (pData->getMeta().getSize() > _64K)
+    if (pCtx->Meta.cbData > _64K)
         return VERR_NOT_IMPLEMENTED;
 
+    const uint32_t cbFmt = (uint32_t)pCtx->Meta.strFmt.length() + 1; /* Include terminator. */
+
+    LogFlowFunc(("cbFmt=%RU32, cbMeta=%RU32\n", cbFmt, pCtx->Meta.cbData));
+
     GuestDnDMsg Msg;
-
-    LogFlowFunc(("cbFmt=%RU32, cbMeta=%RU32, cbChksum=%RU32\n",
-                 pData->getFmtSize(), pData->getMeta().getSize(), pData->getChkSumSize()));
-
     Msg.setType(HOST_DND_HG_SND_DATA);
     if (mDataBase.m_uProtocolVersion < 3)
     {
-        Msg.setNextUInt32(pCtx->mScreenID);                                                /* uScreenId */
-        Msg.setNextPointer(pData->getFmtMutable(), pData->getFmtSize());                   /* pvFormat */
-        Msg.setNextUInt32(pData->getFmtSize());                                            /* cbFormat */
-        Msg.setNextPointer(pData->getMeta().getDataMutable(), pData->getMeta().getSize()); /* pvData */
+        Msg.setNextUInt32(pCtx->mScreenID);                                 /* uScreenId */
+        Msg.setNextPointer(pCtx->Meta.strFmt.mutableRaw(), cbFmt);          /* pvFormat */
+        Msg.setNextUInt32(cbFmt);                                           /* cbFormat */
+        Msg.setNextPointer(pCtx->Meta.pvData, (uint32_t)pCtx->Meta.cbData); /* pvData */
         /* Fill in the current data block size to send.
          * Note: Only supports uint32_t. */
-        Msg.setNextUInt32((uint32_t)pData->getMeta().getSize());                           /* cbData */
+        Msg.setNextUInt32((uint32_t)pCtx->Meta.cbData);                     /* cbData */
     }
     else
     {
         Msg.setNextUInt32(0); /** @todo ContextID not used yet. */
-        Msg.setNextPointer(pData->getMeta().getDataMutable(), pData->getMeta().getSize()); /* pvData */
-        Msg.setNextUInt32(pData->getMeta().getSize());                                     /* cbData */
-        Msg.setNextPointer(pData->getChkSumMutable(), pData->getChkSumSize());             /** @todo pvChecksum; not used yet. */
-        Msg.setNextUInt32(pData->getChkSumSize());                                         /** @todo cbChecksum; not used yet. */
+        Msg.setNextPointer(pCtx->Meta.pvData, (uint32_t)pCtx->Meta.cbData); /* pvData */
+        Msg.setNextUInt32((uint32_t)pCtx->Meta.cbData);                     /* cbData */
+        Msg.setNextPointer(NULL, 0);                                        /** @todo pvChecksum; not used yet. */
+        Msg.setNextUInt32(0);                                               /** @todo cbChecksum; not used yet. */
     }
 
     int rc = GUESTDNDINST()->hostCall(Msg.getType(), Msg.getCount(), Msg.getParms());
     if (RT_SUCCESS(rc))
-        rc = updateProgress(pData, pCtx->mpResp, pData->getMeta().getSize());
+    {
+        rc = updateProgress(pCtx, pCtx->mpResp, pCtx->Meta.cbData);
+        AssertRC(rc);
+    }
 
     LogFlowFuncLeaveRC(rc);
@@ -842 +860 @@
 }
 
-int GuestDnDTarget::i_sendDataHeader(GuestDnDSendCtx *pCtx, GuestDnDData *pData, GuestDnDURIData *pURIData /* = NULL */)
-{
-    AssertPtrReturn(pCtx,  VERR_INVALID_POINTER);
-    AssertPtrReturn(pData, VERR_INVALID_POINTER);
-    /* pURIData is optional. */
+/**
+ * Sends the common meta data header to the guest.
+ *
+ * @returns VBox status code.
+ * @param   pCtx                Send context to use.
+ */
+int GuestDnDTarget::i_sendMetaDataHeader(GuestDnDSendCtx *pCtx)
+{
+    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
+
+    if (mDataBase.m_uProtocolVersion < 3) /* Protocol < v3 did not support this, skip. */
+        return VINF_SUCCESS;
 
     GuestDnDMsg Msg;
@@ -855 +880 @@
     Msg.setNextUInt32(0);                                                /** @todo uFlags; not used yet. */
     Msg.setNextUInt32(pCtx->mScreenID);                                  /* uScreen */
-    Msg.setNextUInt64(pData->getTotal());                                /* cbTotal */
-    Msg.setNextUInt32(pData->getMeta().getSize());                       /* cbMeta*/
-    Msg.setNextPointer(pData->getFmtMutable(), pData->getFmtSize());     /* pvMetaFmt */
-    Msg.setNextUInt32(pData->getFmtSize());                              /* cbMetaFmt */
-    Msg.setNextUInt64(pURIData ? pURIData->getObjToProcess() : 0);       /* cObjects */
+    Msg.setNextUInt64(pCtx->getTotal());                                 /* cbTotal */
+    Msg.setNextUInt32(pCtx->Meta.cbData);                                /* cbMeta*/
+    Msg.setNextPointer(unconst(pCtx->Meta.strFmt.c_str()), (uint32_t)pCtx->Meta.strFmt.length() + 1); /* pvMetaFmt */
+    Msg.setNextUInt32((uint32_t)pCtx->Meta.strFmt.length() + 1);                                      /* cbMetaFmt */
+    Msg.setNextUInt64(pCtx->mTransfer.cObjToProcess );                   /* cObjects */
     Msg.setNextUInt32(0);                                                /** @todo enmCompression; not used yet. */
     Msg.setNextUInt32(0);                                                /** @todo enmChecksumType; not used yet. */
@@ -871 +896 @@
 }
 
-int GuestDnDTarget::i_sendDirectory(GuestDnDSendCtx *pCtx, GuestDnDURIObjCtx *pObjCtx, GuestDnDMsg *pMsg)
-{
-    AssertPtrReturn(pCtx,    VERR_INVALID_POINTER);
-    AssertPtrReturn(pObjCtx, VERR_INVALID_POINTER);
-    AssertPtrReturn(pMsg,    VERR_INVALID_POINTER);
-
-    DnDURIObject *pObj = pObjCtx->getObj();
-    AssertPtr(pObj);
-
-    RTCString strPath = pObj->GetPath();
-    if (strPath.isEmpty())
-        return VERR_INVALID_PARAMETER;
-    if (strPath.length() >= RTPATH_MAX) /* Note: Maximum is RTPATH_MAX on guest side. */
-        return VERR_BUFFER_OVERFLOW;
-
-    LogRel2(("DnD: Transferring host directory '%s' to guest\n", strPath.c_str()));
+int GuestDnDTarget::i_sendDirectory(GuestDnDSendCtx *pCtx, PDNDTRANSFEROBJECT pObj, GuestDnDMsg *pMsg)
+{
+    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
+    AssertPtrReturn(pMsg, VERR_INVALID_POINTER);
+
+    const char *pcszDstPath = DnDTransferObjectGetDestPath(pObj);
+    AssertPtrReturn(pcszDstPath, VERR_INVALID_POINTER);
+    const size_t cchPath = RTStrNLen(pcszDstPath, RTPATH_MAX); /* Note: Maximum is RTPATH_MAX on guest side. */
+    AssertReturn(cchPath, VERR_INVALID_PARAMETER);
+
+    LogRel2(("DnD: Transferring host directory '%s' to guest\n", DnDTransferObjectGetSourcePath(pObj)));
 
     pMsg->setType(HOST_DND_HG_SND_DIR);
     if (mDataBase.m_uProtocolVersion >= 3)
         pMsg->setNextUInt32(0); /** @todo ContextID not used yet. */
-    pMsg->setNextString(strPath.c_str());                  /* path */
-    pMsg->setNextUInt32((uint32_t)(strPath.length() + 1)); /* path length (maximum is RTPATH_MAX on guest side). */
-    pMsg->setNextUInt32(pObj->GetMode());                  /* mode */
+    pMsg->setNextString(pcszDstPath);                    /* path */
+    pMsg->setNextUInt32((uint32_t)(cchPath + 1));        /* path length, including terminator. */
+    pMsg->setNextUInt32(DnDTransferObjectGetMode(pObj)); /* mode */
 
     return VINF_SUCCESS;
 }
 
-int GuestDnDTarget::i_sendFile(GuestDnDSendCtx *pCtx, GuestDnDURIObjCtx *pObjCtx, GuestDnDMsg *pMsg)
-{
-    AssertPtrReturn(pCtx,    VERR_INVALID_POINTER);
-    AssertPtrReturn(pObjCtx, VERR_INVALID_POINTER);
-    AssertPtrReturn(pMsg,    VERR_INVALID_POINTER);
-
-    DnDURIObject *pObj = pObjCtx->getObj();
-    AssertPtr(pObj);
-
-    RTCString strPathSrc = pObj->GetPath();
-    if (strPathSrc.isEmpty())
-        return VERR_INVALID_PARAMETER;
+/**
+ * Sends a transfer file to the guest.
+ *
+ * @returns VBox status code.
+ * @param   pCtx
+ * @param   pObj
+ * @param   pMsg
+ */
+int GuestDnDTarget::i_sendFile(GuestDnDSendCtx *pCtx,
+                               PDNDTRANSFEROBJECT pObj, GuestDnDMsg *pMsg)
+{
+    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
+    AssertPtrReturn(pObj, VERR_INVALID_POINTER);
+    AssertPtrReturn(pMsg, VERR_INVALID_POINTER);
+
+    const char *pcszSrcPath = DnDTransferObjectGetSourcePath(pObj);
+    AssertPtrReturn(pcszSrcPath, VERR_INVALID_POINTER);
+    const char *pcszDstPath = DnDTransferObjectGetDestPath(pObj);
+    AssertPtrReturn(pcszDstPath, VERR_INVALID_POINTER);
 
     int rc = VINF_SUCCESS;
 
-    LogFlowFunc(("Sending file with %RU32 bytes buffer, using protocol v%RU32 ...\n",
-                  mData.mcbBlockSize, mDataBase.m_uProtocolVersion));
-    LogFlowFunc(("strPathSrc=%s, fIsOpen=%RTbool, cbSize=%RU64\n", strPathSrc.c_str(), pObj->IsOpen(), pObj->GetSize()));
-
-    if (!pObj->IsOpen())
-    {
-        LogRel2(("DnD: Opening host file '%s' for transferring to guest\n", strPathSrc.c_str()));
-        rc = pObj->Init(DnDURIObject::Type_File, strPathSrc);
-        if (RT_SUCCESS(rc))
-            rc = pObj->Open(RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_WRITE);
-
+    if (!DnDTransferObjectIsOpen(pObj))
+    {
+        LogRel2(("DnD: Opening host file '%s' for transferring to guest\n", pcszSrcPath));
+
+        rc = DnDTransferObjectOpen(pObj, RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_WRITE, 0 /* fMode */,
+                                   DNDTRANSFEROBJECT_FLAGS_NONE);
         if (RT_FAILURE(rc))
-            LogRel(("DnD: Opening host file '%s' failed, rc=%Rrc\n", strPathSrc.c_str(), rc));
-    }
+            LogRel(("DnD: Opening host file '%s' failed, rc=%Rrc\n", pcszSrcPath, rc));
+    }
+
+    if (RT_FAILURE(rc))
+        return rc;
 
     bool fSendData = false;
@@ -933 +958 @@
         if (mDataBase.m_uProtocolVersion >= 2)
         {
-            uint32_t fState = pObjCtx->getState();
-            if (!(fState & DND_OBJCTX_STATE_HAS_HDR))
+            if (!(pCtx->mTransfer.mfObjState & DND_OBJ_STATE_HAS_HDR))
             {
+                const size_t  cchDstPath = RTStrNLen(pcszDstPath, RTPATH_MAX);
+                const size_t  cbSize     = DnDTransferObjectGetSize(pObj);
+                const RTFMODE fMode      = DnDTransferObjectGetMode(pObj);
+
                 /*
                  * Since protocol v2 the file header and the actual file contents are
@@ -943 +971 @@
                 pMsg->setType(HOST_DND_HG_SND_FILE_HDR);
                 pMsg->setNextUInt32(0); /** @todo ContextID not used yet. */
-                pMsg->setNextString(pObj->GetPath().c_str());                  /* pvName */
-                pMsg->setNextUInt32((uint32_t)(pObj->GetPath().length() + 1)); /* cbName */
-                pMsg->setNextUInt32(0);                                        /* uFlags */
-                pMsg->setNextUInt32(pObj->GetMode());                          /* fMode */
-                pMsg->setNextUInt64(pObj->GetSize());                          /* uSize */
-
-                LogFlowFunc(("Sending file header ...\n"));
-                LogRel2(("DnD: Transferring host file '%s' to guest (%RU64 bytes, mode 0x%x)\n",
-                         pObj->GetPath().c_str(), pObj->GetSize(), pObj->GetMode()));
+                pMsg->setNextString(pcszDstPath);                    /* pvName */
+                pMsg->setNextUInt32((uint32_t)(cchDstPath + 1));     /* cbName */
+                pMsg->setNextUInt32(0);                              /* uFlags */
+                pMsg->setNextUInt32(fMode);                          /* fMode */
+                pMsg->setNextUInt64(cbSize);                         /* uSize */
+
+                LogRel2(("DnD: Transferring host file '%s' to guest (%zu bytes, mode %#x)\n",
+                         pcszSrcPath, cbSize, fMode));
 
                 /** @todo Set progress object title to current file being transferred? */
 
-                pObjCtx->setState(fState | DND_OBJCTX_STATE_HAS_HDR);
+                /* Update object state to reflect that we have sent the file header. */
+                pCtx->mTransfer.mfObjState |= DND_OBJ_STATE_HAS_HDR;
             }
             else
@@ -973 +1001 @@
         && fSendData)
     {
-        rc = i_sendFileData(pCtx, pObjCtx, pMsg);
+        rc = i_sendFileData(pCtx, pObj, pMsg);
     }
 
     if (RT_FAILURE(rc))
-        LogRel(("DnD: Sending host file to guest failed, rc=%Rrc\n", rc));
+        LogRel(("DnD: Sending host file '%s' to guest failed, rc=%Rrc\n", pcszSrcPath, rc));
 
     LogFlowFuncLeaveRC(rc);
@@ -983 +1011 @@
 }
 
-int GuestDnDTarget::i_sendFileData(GuestDnDSendCtx *pCtx, GuestDnDURIObjCtx *pObjCtx, GuestDnDMsg *pMsg)
-{
-    AssertPtrReturn(pCtx,    VERR_INVALID_POINTER);
-    AssertPtrReturn(pObjCtx, VERR_INVALID_POINTER);
-    AssertPtrReturn(pMsg,    VERR_INVALID_POINTER);
-
-    DnDURIObject *pObj = pObjCtx->getObj();
-    AssertPtr(pObj);
-
-    AssertPtr(pCtx->mpResp);
+int GuestDnDTarget::i_sendFileData(GuestDnDSendCtx *pCtx,
+                                   PDNDTRANSFEROBJECT pObj, GuestDnDMsg *pMsg)
+{
+    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
+    AssertPtrReturn(pObj, VERR_INVALID_POINTER);
+    AssertPtrReturn(pMsg, VERR_INVALID_POINTER);
+
+    AssertPtrReturn(pCtx->mpResp, VERR_WRONG_ORDER);
 
     /** @todo Don't allow concurrent reads per context! */
-
-    /*
-     * Start sending stuff.
-     */
 
     /* Set the message type. */
     pMsg->setType(HOST_DND_HG_SND_FILE_DATA);
+
+    const char *pcszSrcPath = DnDTransferObjectGetSourcePath(pObj);
+    const char *pcszDstPath = DnDTransferObjectGetDestPath(pObj);
 
     /* Protocol version 1 sends the file path *every* time with a new file chunk.
@@ -1007 +1032 @@
     if (mDataBase.m_uProtocolVersion <= 1)
     {
-        pMsg->setNextString(pObj->GetPath().c_str());                  /* pvName */
-        pMsg->setNextUInt32((uint32_t)(pObj->GetPath().length() + 1)); /* cbName */
+        const size_t cchDstPath = RTStrNLen(pcszDstPath, RTPATH_MAX);
+
+        pMsg->setNextString(pcszDstPath);              /* pvName */
+        pMsg->setNextUInt32((uint32_t)cchDstPath + 1); /* cbName */
     }
     else if (mDataBase.m_uProtocolVersion >= 2)
     {
-        pMsg->setNextUInt32(0);                                            /** @todo ContextID not used yet. */
-    }
-
-    uint32_t cbRead = 0;
-
-    int rc = pObj->Read(pCtx->mURI.getBufferMutable(), pCtx->mURI.getBufferSize(), &cbRead);
+        pMsg->setNextUInt32(0);                        /** @todo ContextID not used yet. */
+    }
+
+    void *pvBuf  = pCtx->mTransfer.pvScratchBuf;
+    AssertPtr(pvBuf);
+    size_t cbBuf = pCtx->mTransfer.cbScratchBuf;
+    Assert(cbBuf);
+
+    uint32_t cbRead;
+
+    int rc = DnDTransferObjectRead(pObj, pvBuf, cbBuf, &cbRead);
     if (RT_SUCCESS(rc))
     {
-        pCtx->mData.addProcessed(cbRead);
-        LogFlowFunc(("cbBufSize=%zu, cbRead=%RU32\n", pCtx->mURI.getBufferSize(), cbRead));
+        pCtx->addProcessed(cbRead);
+
+        LogFlowFunc(("cbBufe=%zu, cbRead=%RU32\n", cbBuf, cbRead));
 
         if (mDataBase.m_uProtocolVersion <= 1)
         {
-            pMsg->setNextPointer(pCtx->mURI.getBufferMutable(), cbRead);    /* pvData */
+            pMsg->setNextPointer(pvBuf, cbRead);                            /* pvData */
             pMsg->setNextUInt32(cbRead);                                    /* cbData */
-            pMsg->setNextUInt32(pObj->GetMode());                           /* fMode */
+            pMsg->setNextUInt32(DnDTransferObjectGetMode(pObj));            /* fMode */
         }
         else /* Protocol v2 and up. */
         {
-            pMsg->setNextPointer(pCtx->mURI.getBufferMutable(), cbRead);    /* pvData */
+            pMsg->setNextPointer(pvBuf, cbRead);                            /* pvData */
             pMsg->setNextUInt32(cbRead);                                    /* cbData */
 
@@ -1042 +1075 @@
         }
 
-        if (pObj->IsComplete()) /* Done reading? */
-        {
-            LogRel2(("DnD: Transferring file '%s' to guest complete\n", pObj->GetPath().c_str()));
-            LogFlowFunc(("File '%s' complete\n", pObj->GetPath().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. */
+        if (DnDTransferObjectIsComplete(pObj)) /* Done reading? */
+        {
+            LogRel2(("DnD: Transferring host file '%s' to guest complete\n", pcszSrcPath));
+
+            /* DnDTransferObjectRead() returns VINF_EOF when finished reading the entire file,
+             * but we don't want this here -- so just set VINF_SUCCESS. */
             rc = VINF_SUCCESS;
         }
     }
-
-    if (RT_FAILURE(rc))
-        LogRel(("DnD: Reading from host file '%s' failed, rc=%Rrc\n", pObj->GetPath().c_str(), rc));
+    else
+        LogRel(("DnD: Reading from host file '%s' failed, rc=%Rrc\n", pcszSrcPath, rc));
 
     LogFlowFuncLeaveRC(rc);
@@ -1096 +1127 @@
                 GuestDnDMsg *pMsg = new GuestDnDMsg();
 
-                rc = pThis->i_sendURIDataLoop(pCtx, pMsg);
+                rc = pThis->i_sendTransferDataLoop(pCtx, pMsg);
                 if (rc == VINF_EOF) /* Transfer complete? */
                 {
@@ -1272 +1303 @@
 }
 
-int GuestDnDTarget::i_sendURIData(GuestDnDSendCtx *pCtx, RTMSINTERVAL msTimeout)
+/**
+ * Main function for sending the actual transfer data (i.e. files + directories) to the guest.
+ *
+ * @returns VBox status code.
+ * @param   pCtx                Send context to use.
+ * @param   msTimeout           Timeout (in ms) to use for getting the data sent.
+ */
+int GuestDnDTarget::i_sendTransferData(GuestDnDSendCtx *pCtx, RTMSINTERVAL msTimeout)
 {
     AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
@@ -1290 +1328 @@
     } while (0)
 
-    int rc = pCtx->mURI.init(mData.mcbBlockSize);
+    int rc = pCtx->mTransfer.init(mData.mcbBlockSize);
     if (RT_FAILURE(rc))
         return rc;
@@ -1315 +1353 @@
     {
         /*
-         * Extract URI list from current meta data.
+         * Extract transfer list from current meta data.
          */
-        GuestDnDData    *pData = &pCtx->mData;
-        GuestDnDURIData *pURI  = &pCtx->mURI;
-
-        rc = pURI->fromLocalMetaData(pData->getMeta());
+        rc = DnDTransferListAppendPathsFromBuffer(&pCtx->mTransfer.mList, DNDTRANSFERLISTFMT_NATIVE,
+                                                  (const char *)pCtx->Meta.pvData, pCtx->Meta.cbData, "\n", DNDTRANSFERLIST_FLAGS_NONE);
         if (RT_FAILURE(rc))
             break;
 
-        LogFlowFunc(("URI root objects: %zu, total bytes (raw data to transfer): %zu\n",
-                     pURI->getURIList().GetRootCount(), pURI->getURIList().GetTotalBytes()));
-
         /*
-         * Set the new meta data with the URI list in it.
+         * Set the extra data size
          */
-        rc = pData->getMeta().fromURIList(pURI->getURIList());
-        if (RT_FAILURE(rc))
-            break;
-
-        /*
-         * Set the estimated data sizes we are going to send.
-         * The total size also contains the meta data size.
-         */
-        const uint32_t cbMeta = pData->getMeta().getSize();
-        pData->setEstimatedSize(pURI->getURIList().GetTotalBytes() + cbMeta /* cbTotal */,
-                                                                     cbMeta /* cbMeta  */);
-
-        /*
-         * Set the meta format.
-         */
-        void    *pvFmt = (void *)pCtx->mFmtReq.c_str();
-        uint32_t cbFmt = (uint32_t)pCtx->mFmtReq.length() + 1;           /* Include terminating zero. */
-
-        pData->setFmt(pvFmt, cbFmt);
+        pCtx->cbExtra = DnDTransferListObjTotalBytes(&pCtx->mTransfer.mList);
 
         /*
          * The first message always is the data header. The meta data itself then follows
-         * and *only* contains the root elements of an URI list.
+         * and *only* contains the root elements of a transfer list.
          *
          * After the meta data we generate the messages required to send the
@@ -1365 +1380 @@
          */
         if (mDataBase.m_uProtocolVersion >= 3)
-            rc = i_sendDataHeader(pCtx, pData, &pCtx->mURI);
+            rc = i_sendMetaDataHeader(pCtx);
 
         /*
@@ -1371 +1386 @@
          */
         if (RT_SUCCESS(rc))
-            rc = i_sendDataBody(pCtx, pData);
+            rc = i_sendMetaDataBody(pCtx);
 
         if (RT_SUCCESS(rc))
@@ -1411 +1426 @@
             AssertRC(rc2);
 
+            LogRel2(("DnD: Sending transfer data to guest cancelled by user\n"));
+
             rc2 = pCtx->mpResp->setProgress(100, DND_PROGRESS_CANCELLED, VINF_SUCCESS);
             AssertRC(rc2);
@@ -1416 +1433 @@
         else if (rc != VERR_GSTDND_GUEST_ERROR) /* Guest-side error are already handled in the callback. */
         {
+            LogRel(("DnD: Sending transfer data to guest failed with rc=%Rrc\n", rc));
             int rc2 = pCtx->mpResp->setProgress(100, DND_PROGRESS_ERROR, rc,
                                                 GuestDnDTarget::i_hostErrorToString(rc));
@@ -1428 +1446 @@
 }
 
-int GuestDnDTarget::i_sendURIDataLoop(GuestDnDSendCtx *pCtx, GuestDnDMsg *pMsg)
+int GuestDnDTarget::i_sendTransferDataLoop(GuestDnDSendCtx *pCtx, GuestDnDMsg *pMsg)
 {
     AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
     AssertPtrReturn(pMsg, VERR_INVALID_POINTER);
 
-    int rc = updateProgress(&pCtx->mData, pCtx->mpResp);
+    int rc = updateProgress(pCtx, pCtx->mpResp);
     AssertRC(rc);
 
-    if (   pCtx->mData.isComplete()
-        && pCtx->mURI.isComplete())
+    if (   pCtx->isComplete()
+        && pCtx->mTransfer.isComplete())
     {
         return VINF_EOF;
     }
 
-    GuestDnDURIObjCtx &objCtx = pCtx->mURI.getObjCurrent();
-    if (!objCtx.isValid())
+    PDNDTRANSFEROBJECT pObj = DnDTransferListObjGetFirst(&pCtx->mTransfer.mList);
+    if (!pObj)
         return VERR_WRONG_ORDER;
 
-    DnDURIObject *pCurObj = objCtx.getObj();
-    AssertPtr(pCurObj);
-
-    const DnDURIObject::Type enmType = pCurObj->GetType();
-
-    LogRel3(("DnD: Processing: srcPath=%s, dstPath=%s, enmType=%RU32, cbSize=%RU32\n",
-             pCurObj->GetPath().c_str(), pCurObj->GetPath().c_str(),
-             enmType, pCurObj->GetSize()));
-
-    if (enmType == DnDURIObject::Type_Directory)
-    {
-        rc = i_sendDirectory(pCtx, &objCtx, pMsg);
-    }
-    else if (DnDURIObject::Type_File)
-    {
-        rc = i_sendFile(pCtx, &objCtx, pMsg);
-    }
-    else
-    {
-        AssertMsgFailed(("enmType=%RU32 is not supported for srcPath=%s, dstPath=%s\n",
-                         enmType, pCurObj->GetPath().c_str(), pCurObj->GetPath().c_str()));
-        rc = VERR_NOT_SUPPORTED;
-    }
-
-    bool fRemove = false; /* Remove current entry? */
-    if (   pCurObj->IsComplete()
+    switch (DnDTransferObjectGetType(pObj))
+    {
+        case DNDTRANSFEROBJTYPE_DIRECTORY:
+            rc = i_sendDirectory(pCtx, pObj, pMsg);
+            break;
+
+        case DNDTRANSFEROBJTYPE_FILE:
+            rc = i_sendFile(pCtx, pObj, pMsg);
+            break;
+
+        default:
+            AssertFailedStmt(rc = VERR_NOT_SUPPORTED);
+            break;
+    }
+
+    if (   DnDTransferObjectIsComplete(pObj)
         || RT_FAILURE(rc))
-    {
-        fRemove = true;
-    }
-
-    if (fRemove)
-    {
-        LogFlowFunc(("Removing \"%s\" from list, rc=%Rrc\n", pCurObj->GetPath().c_str(), rc));
-        pCtx->mURI.removeObjCurrent();
-    }
+        DnDTransferListObjRemoveFirst(&pCtx->mTransfer.mList);
 
     LogFlowFuncLeaveRC(rc);
@@ -1487 +1487 @@
 }
 
+/**
+ * Main function for sending raw data (e.g. text, RTF, ...) to the guest.
+ *
+ * @returns VBox status code.
+ * @param   pCtx                Send context to use.
+ * @param   msTimeout           Timeout (in ms) to use for getting the data sent.
+ */
 int GuestDnDTarget::i_sendRawData(GuestDnDSendCtx *pCtx, RTMSINTERVAL msTimeout)
 {
     AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
     NOREF(msTimeout);
-
-    GuestDnDData *pData = &pCtx->mData;
 
     /** @todo At the moment we only allow sending up to 64K raw data.
      *        For protocol v1+v2: Fix this by using HOST_DND_HG_SND_MORE_DATA.
      *        For protocol v3   : Send another HOST_DND_HG_SND_DATA message. */
-    if (!pData->getMeta().getSize())
+    if (!pCtx->Meta.cbData)
         return VINF_SUCCESS;
 
-    int rc = VINF_SUCCESS;
-
-    /*
-     * Send the data header first.
-     */
-    if (mDataBase.m_uProtocolVersion >= 3)
-        rc = i_sendDataHeader(pCtx, pData, NULL /* URI list */);
-
-    /*
-     * Send the (meta) data body.
-     */
+    int rc = i_sendMetaDataHeader(pCtx);
     if (RT_SUCCESS(rc))
-        rc = i_sendDataBody(pCtx, pData);
+        rc = i_sendMetaDataBody(pCtx);
 
     int rc2;
     if (RT_FAILURE(rc))
-        rc2 = pCtx->mpResp->setProgress(100, DND_PROGRESS_ERROR, rc,
+    {
+        LogRel(("DnD: Sending raw data to guest failed with rc=%Rrc\n", rc));
+        rc2 = pCtx->mpResp->setProgress(100 /* Percent */, DND_PROGRESS_ERROR, rc,
                                         GuestDnDTarget::i_hostErrorToString(rc));
+    }
     else
-        rc2 = pCtx->mpResp->setProgress(100, DND_PROGRESS_COMPLETE, rc);
+        rc2 = pCtx->mpResp->setProgress(100 /* Percent */, DND_PROGRESS_COMPLETE, rc);
     AssertRC(rc2);
 
@@ -1526 +1524 @@
 }
 
+/**
+ * Cancels sending DnD data.
+ *
+ * @returns VBox status code.
+ * @param   aVeto               Whether cancelling was vetoed or not.
+ *                              Not implemented yet.
+ */
 HRESULT GuestDnDTarget::cancel(BOOL *aVeto)
 {
@@ -1532 +1537 @@
 #else /* VBOX_WITH_DRAG_AND_DROP */
 
+    LogRel2(("DnD: Sending cancelling request to the guest ...\n"));
+
     int rc = GuestDnDBase::sendCancel();
 
     if (aVeto)
-        *aVeto = FALSE; /** @todo */
+        *aVeto = FALSE; /** @todo Impplement vetoing. */
 
     HRESULT hr = RT_SUCCESS(rc) ? S_OK : VBOX_E_IPRT_ERROR;