Changeset 78307 in vbox for trunk/src

Timestamp:

Apr 26, 2019 6:41:46 AM (6 years ago)

Author:

vboxsync

Message:

Shared Clipboard/URI: First commit; work in progress.

Location:

trunk/src/VBox

Files:

• Additions/WINNT/VBoxTray/Makefile.kmk (modified) (1 diff)
• Additions/WINNT/VBoxTray/VBoxClipboard.cpp (modified) (4 diffs)
• Additions/common/VBoxGuest/lib/Makefile.kmk (modified) (4 diffs)
• Additions/common/VBoxGuest/lib/VBoxGuestR3LibClipboard.cpp (modified) (6 diffs)
• Additions/common/VBoxService/VBoxServiceClipboard-os2.cpp (modified) (3 diffs)
• Additions/haiku/VBoxTray/VBoxClipboard.cpp (modified) (1 diff)
• Additions/x11/VBoxClient/Makefile.kmk (modified) (3 diffs)
• Additions/x11/VBoxClient/clipboard.cpp (modified) (1 diff)
• GuestHost/SharedClipboard/ClipboardFiles.cpp (copied) (copied from trunk/src/VBox/GuestHost/DragAndDrop/DnDDroppedFiles.cpp )
• GuestHost/SharedClipboard/ClipboardMIME.cpp (copied) (copied from trunk/src/VBox/GuestHost/DragAndDrop/DnDMIME.cpp )
• GuestHost/SharedClipboard/ClipboardPath.cpp (copied) (copied from trunk/src/VBox/GuestHost/DragAndDrop/DnDPath.cpp )
• GuestHost/SharedClipboard/ClipboardURIList.cpp (copied) (copied from trunk/src/VBox/GuestHost/DragAndDrop/DnDURIList.cpp )
• GuestHost/SharedClipboard/ClipboardURIObject.cpp (copied) (copied from trunk/src/VBox/GuestHost/DragAndDrop/DnDURIObject.cpp )
• GuestHost/SharedClipboard/clipboard-win.cpp (modified) (1 diff)
• HostServices/SharedClipboard/Makefile.kmk (modified) (1 diff)
• HostServices/SharedClipboard/VBoxSharedClipboardSvc-win.cpp (modified) (15 diffs)
• HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp (modified) (1 diff)

trunk/src/VBox/Additions/WINNT/VBoxTray/Makefile.kmk

@@ -47 +47 @@
 ifdef VBOX_WITH_SHARED_CLIPBOARD
  VBoxTray_DEFS     += \
-        VBOX_WITH_SHARED_CLIPBOARD
+        VBOX_WITH_SHARED_CLIPBOARD \
+        $(if $(VBOX_WITH_SHARED_CLIPBOARD_URI_LIST),VBOX_WITH_SHARED_CLIPBOARD_URI_LIST,)
  VBoxTray_SOURCES  += \
         VBoxClipboard.cpp \

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

@@ -78 +78 @@
                int vboxrc = VBoxClipboardWinGetFormats(&pCtx->Win, &uFormats);
                if (RT_SUCCESS(vboxrc))
-                   vboxrc = VbglR3ClipboardReportFormats(pCtx->u32ClientID, uFormats);
+                   vboxrc = VbglR3ClipboardWriteFormats(pCtx->u32ClientID, uFormats);
            }
         }
@@ -128 +128 @@
                int vboxrc = VBoxClipboardWinGetFormats(pWinCtx, &uFormats);
                if (RT_SUCCESS(vboxrc))
-                   vboxrc = VbglR3ClipboardReportFormats(pCtx->u32ClientID, uFormats);
+                   vboxrc = VbglR3ClipboardWriteFormats(pCtx->u32ClientID, uFormats);
            }
 
@@ -386 +386 @@
                }
 
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
+               if (u32Formats & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
+                   hClip = SetClipboardData(CF_HDROP, NULL);
+#endif
                VBoxClipboardWinClose();
 
@@ -466 +470 @@
                    }
                }
-
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
+               else if (u32Formats & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
+               {
+                   hClip = GetClipboardData(CF_HDROP);
+                   if (hClip)
+                   {
+                       HDROP hDrop = (HDROP)GlobalLock(hClip);
+                       if (hDrop)
+                       {
+                           vboxrc = VbglR3ClipboardWriteData(pCtx->u32ClientID, VBOX_SHARED_CLIPBOARD_FMT_URI_LIST,
+                                                             );
+                           GlobalUnlock(hClip);
+                       }
+                       else
+                       {
+                           hClip = NULL;
+                       }
+                   }
+               }
+#endif
                VBoxClipboardWinClose();
            }

trunk/src/VBox/Additions/common/VBoxGuest/lib/Makefile.kmk

@@ -110 +110 @@
         VBOX_WITH_HGCM \
         $(if $(VBOX_WITH_GUEST_PROPS),VBOX_WITH_GUEST_PROPS,) \
+        $(if $(VBOX_WITH_SHARED_CLIPBOARD),VBOX_WITH_SHARED_CLIPBOARD,) \
         $(if $(VBOX_WITH_SHARED_FOLDERS),VBOX_WITH_SHARED_FOLDERS,) \
         $(if $(VBOX_WITH_GUEST_CONTROL),VBOX_WITH_GUEST_CONTROL,)
@@ -160 +161 @@
         VBoxGuestR3LibDragAndDrop.cpp
 endif
+ifdef VBOX_WITH_SHARED_CLIPBOARD
+ VBoxGuestR3Lib_DEFS      += \
+        $(if $(VBOX_WITH_SHARED_CLIPBOARD_URI_LIST),VBOX_WITH_SHARED_CLIPBOARD_URI_LIST,)
+endif
 
 VBoxGuestR3LibAdditions.cpp_DEFS = VBOX_SVN_REV=$(VBOX_SVN_REV)
@@ -202 +207 @@
         $(if $(VBOX_WITH_GUEST_PROPS),VBOX_WITH_GUEST_PROPS,) \
         $(if $(VBOX_WITH_DRAG_AND_DROP),VBOX_WITH_DRAG_AND_DROP,) \
-        $(if $(VBOX_WITH_DRAG_AND_DROP_GH),VBOX_WITH_DRAG_AND_DROP_GH,)
+        $(if $(VBOX_WITH_DRAG_AND_DROP_GH),VBOX_WITH_DRAG_AND_DROP_GH,) \
+        $(if $(VBOX_WITH_SHARED_CLIPBOARD_URI_LIST),VBOX_WITH_SHARED_CLIPBOARD_URI_LIST,)
 VBoxGuestR3LibXFree86_SOURCES  = \
         VBoxGuestR3Lib.cpp \
@@ -229 +235 @@
         $(if $(VBOX_WITH_GUEST_PROPS),VBOX_WITH_GUEST_PROPS,) \
         $(if $(VBOX_WITH_DRAG_AND_DROP),VBOX_WITH_DRAG_AND_DROP,) \
-        $(if $(VBOX_WITH_DRAG_AND_DROP_GH),VBOX_WITH_DRAG_AND_DROP_GH,)
+        $(if $(VBOX_WITH_DRAG_AND_DROP_GH),VBOX_WITH_DRAG_AND_DROP_GH,) \
+        $(if $(VBOX_WITH_SHARED_CLIPBOARD_URI_LIST),VBOX_WITH_SHARED_CLIPBOARD_URI_LIST,)
 VBoxGuestR3LibXOrg_SOURCES  = $(VBoxGuestR3LibXFree86_SOURCES)
 

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

@@ -29 +29 @@
 *   Header Files                                                                                                                 *
 *********************************************************************************************************************************/
+#include <VBox/GuestHost/SharedClipboard.h>
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
+# include <VBox/GuestHost/SharedClipboard-uri.h>
+#endif
 #include <VBox/HostServices/VBoxClipboardSvc.h>
 #include <VBox/err.h>
 #include <iprt/assert.h>
 #include <iprt/string.h>
+#include <iprt/cpp/ministring.h>
 #include "VBoxGuestR3LibInternal.h"
+
+
+/*********************************************************************************************************************************
+*   Prototypes                                                                                                                   *
+*********************************************************************************************************************************/
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
+static int vbglR3ClipboardSendErrorInternal(HGCMCLIENTID idClient, int rcErr);
+static int vbglR3ClipboardSendURIData(HGCMCLIENTID idClient, const void *pvData, size_t cbData);
+#endif
 
 
@@ -140 +154 @@
 
 /**
- * Advertises guest clipboard formats to the host.
+ * Writes (advertises) guest clipboard formats to the host.
  *
  * @returns VBox status code.
@@ -146 +160 @@
  * @param   fFormats        The formats to advertise.
  */
-VBGLR3DECL(int) VbglR3ClipboardReportFormats(HGCMCLIENTID idClient, uint32_t fFormats)
-{
-    VBoxClipboardFormats Msg;
-
-    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, VBOX_SHARED_CLIPBOARD_FN_FORMATS, 1);
+VBGLR3DECL(int) VbglR3ClipboardWriteFormats(HGCMCLIENTID idClient, uint32_t fFormats)
+{
+    VBoxClipboardWriteFormats Msg;
+
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, VBOX_SHARED_CLIPBOARD_FN_WRITE_FORMATS, 1);
     VbglHGCMParmUInt32Set(&Msg.formats, fFormats);
 
@@ -156 +170 @@
 }
 
-
-/**
- * Send guest clipboard data to the host.
+/**
+ * Sends guest clipboard data to the host.
  *
  * This is usually called in reply to a VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA message
@@ -169 +182 @@
  * @param   cb              The size of the data.
  */
-VBGLR3DECL(int) VbglR3ClipboardWriteData(HGCMCLIENTID idClient, uint32_t fFormat, void *pv, uint32_t cb)
+static int vbglR3ClipboardWriteDataRaw(HGCMCLIENTID idClient, uint32_t fFormat, void *pv, uint32_t cb)
 {
     VBoxClipboardWriteData Msg;
@@ -179 +192 @@
 }
 
+/**
+ * Send guest clipboard data to the host.
+ *
+ * This is usually called in reply to a VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA message
+ * from the host.
+ *
+ * @returns VBox status code.
+ * @param   idClient        The client id returned by VbglR3ClipboardConnect().
+ * @param   fFormat         The format of the data.
+ * @param   pv              The data.
+ * @param   cb              The size of the data.
+ */
+VBGLR3DECL(int) VbglR3ClipboardWriteData(HGCMCLIENTID idClient, uint32_t fFormat, void *pv, uint32_t cb)
+{
+    int rc;
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
+    if (fFormat == VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
+    {
+        rc = vbglR3ClipboardSendURIData(idClient, pv, cb);
+    }
+    else
+#else
+        RT_NOREF(fFormat);
+#endif
+        rc = vbglR3ClipboardWriteDataRaw(idClient, fFormat, pv, cb);
+
+    if (RT_FAILURE(rc))
+    {
+        int rc2 = vbglR3ClipboardSendErrorInternal(idClient, rc);
+        if (RT_FAILURE(rc2))
+            LogFlowFunc(("Unable to send error (%Rrc) to host, rc=%Rrc\n", rc, rc2));
+    }
+
+    return rc;
+}
+
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
+/**
+ * Guest -> Host
+ * Utility function to send clipboard data from guest to the host.
+ *
+ * @returns IPRT status code.
+ * @param   idClient            The client id returned by VbglR3ClipboardConnect().
+ * @param   pvData              Data block to send.
+ * @param   cbData              Size (in bytes) of data block to send.
+ * @param   pDataHdr            Data header to use -- needed for accounting.
+ */
+static int vbglR3ClipboardSendDataInternal(HGCMCLIENTID idClient,
+                                           void *pvData, uint64_t cbData, PVBOXCLIPBOARDDATAHDR pDataHdr)
+{
+    AssertPtrReturn(pvData,   VERR_INVALID_POINTER);
+    AssertReturn(cbData,      VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pDataHdr, VERR_INVALID_POINTER);
+
+    VBoxClipboardWriteDataHdrMsg MsgHdr;
+    RT_ZERO(MsgHdr);
+
+    VBGL_HGCM_HDR_INIT(&MsgHdr.hdr, idClient, VBOX_SHARED_CLIPBOARD_FN_WRITE_DATA_HDR, 12);
+    MsgHdr.uContext.SetUInt32(0);                           /** @todo Not used yet. */
+    MsgHdr.uFlags.SetUInt32(0);                             /** @todo Not used yet. */
+    MsgHdr.uScreenId.SetUInt32(0);                          /** @todo Not used for guest->host (yet). */
+    MsgHdr.cbTotal.SetUInt64(pDataHdr->cbTotal);
+    MsgHdr.cbMeta.SetUInt32(pDataHdr->cbMeta);
+    MsgHdr.pvMetaFmt.SetPtr(pDataHdr->pvMetaFmt, pDataHdr->cbMetaFmt);
+    MsgHdr.cbMetaFmt.SetUInt32(pDataHdr->cbMetaFmt);
+    MsgHdr.cObjects.SetUInt64(pDataHdr->cObjects);
+    MsgHdr.enmCompression.SetUInt32(0);                     /** @todo Not used yet. */
+    MsgHdr.enmChecksumType.SetUInt32(RTDIGESTTYPE_INVALID); /** @todo Not used yet. */
+    MsgHdr.pvChecksum.SetPtr(NULL, 0);                      /** @todo Not used yet. */
+    MsgHdr.cbChecksum.SetUInt32(0);                         /** @todo Not used yet. */
+
+    int rc = VbglR3HGCMCall(&MsgHdr.hdr, sizeof(MsgHdr));
+
+    LogFlowFunc(("cbTotal=%RU64, cbMeta=%RU32, cObjects=%RU64, rc=%Rrc\n",
+                 pDataHdr->cbTotal, pDataHdr->cbMeta, pDataHdr->cObjects, rc));
+
+    if (RT_SUCCESS(rc))
+    {
+        VBoxClipboardWriteDataChunkMsg MsgData;
+        RT_ZERO(MsgData);
+
+        VBGL_HGCM_HDR_INIT(&MsgData.hdr, idClient, VBOX_SHARED_CLIPBOARD_FN_WRITE_DATA_CHUNK, 5);
+        MsgData.uContext.SetUInt32(0);      /** @todo Not used yet. */
+        MsgData.pvChecksum.SetPtr(NULL, 0); /** @todo Not used yet. */
+        MsgData.cbChecksum.SetUInt32(0);    /** @todo Not used yet. */
+
+        uint32_t       cbCurChunk;
+        const uint32_t cbMaxChunk = VBOX_SHARED_CLIPBOARD_MAX_CHUNK_SIZE;
+        uint32_t       cbSent     = 0;
+
+        HGCMFunctionParameter *pParm = &MsgData.pvData;
+
+        while (cbSent < cbData)
+        {
+            cbCurChunk = RT_MIN(cbData - cbSent, cbMaxChunk);
+            pParm->SetPtr(static_cast<uint8_t *>(pvData) + cbSent, cbCurChunk);
+
+            MsgData.cbData.SetUInt32(cbCurChunk);
+
+            rc = VbglR3HGCMCall(&MsgData.hdr, sizeof(MsgData));
+            if (RT_FAILURE(rc))
+                break;
+
+            cbSent += cbCurChunk;
+        }
+
+        LogFlowFunc(("cbMaxChunk=%RU32, cbData=%RU64, cbSent=%RU32, rc=%Rrc\n",
+                     cbMaxChunk, cbData, cbSent, rc));
+
+        if (RT_SUCCESS(rc))
+            Assert(cbSent == cbData);
+    }
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+/**
+ * Guest -> Host
+ * Utility function to send a guest directory to the host.
+ *
+ * @returns IPRT status code.
+ * @param   idClient        The client id returned by VbglR3ClipboardConnect().
+ * @param   pObj            URI object containing the directory to send.
+ */
+static int vbglR3ClipboardSendDir(HGCMCLIENTID idClient, SharedClipboardURIObject *pObj)
+{
+    AssertPtrReturn(pObj,                                         VERR_INVALID_POINTER);
+    AssertReturn(pObj->GetType() == SharedClipboardURIObject::Type_Directory, VERR_INVALID_PARAMETER);
+
+    RTCString strPath = pObj->GetDestPathAbs();
+    LogFlowFunc(("strDir=%s (%zu), fMode=0x%x\n",
+                 strPath.c_str(), strPath.length(), pObj->GetMode()));
+
+    if (strPath.length() > RTPATH_MAX)
+        return VERR_INVALID_PARAMETER;
+
+    const uint32_t cbPath = (uint32_t)strPath.length() + 1; /* Include termination. */
+
+    VBoxClipboardWriteDirMsg Msg;
+    RT_ZERO(Msg);
+
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, VBOX_SHARED_CLIPBOARD_FN_WRITE_DIR, 4);
+    /** @todo Context ID not used yet. */
+    Msg.pvName.SetPtr((void *)strPath.c_str(), (uint32_t)cbPath);
+    Msg.cbName.SetUInt32((uint32_t)cbPath);
+    Msg.fMode.SetUInt32(pObj->GetMode());
+
+    return VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
+}
+
+/**
+ * Guest -> Host
+ * Utility function to send a file from the guest to the host.
+ *
+ * @returns IPRT status code.
+ * @param   idClient            The client id returned by VbglR3ClipboardConnect().
+ * @param   pObj                URI object containing the file to send.
+ */
+static int vbglR3ClipboardSendFile(HGCMCLIENTID idClient, SharedClipboardURIObject *pObj)
+{
+    AssertPtrReturn(pObj,                                    VERR_INVALID_POINTER);
+    AssertReturn(pObj->GetType() == SharedClipboardURIObject::Type_File, VERR_INVALID_PARAMETER);
+    AssertReturn(pObj->IsOpen(),                             VERR_INVALID_STATE);
+
+    uint32_t cbBuf = _64K;           /** @todo Make this configurable? */
+    void *pvBuf = RTMemAlloc(cbBuf);
+    if (!pvBuf)
+        return VERR_NO_MEMORY;
+
+    RTCString strPath = pObj->GetDestPathAbs();
+
+    LogFlowFunc(("strFile=%s (%zu), cbSize=%RU64, fMode=0x%x\n", strPath.c_str(), strPath.length(),
+                 pObj->GetSize(), pObj->GetMode()));
+
+    VBoxClipboardWriteFileHdrMsg MsgHdr;
+    RT_ZERO(MsgHdr);
+
+    VBGL_HGCM_HDR_INIT(&MsgHdr.hdr, idClient, VBOX_SHARED_CLIPBOARD_FN_WRITE_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.uFlags.SetUInt32(0);                                                      /* Flags; unused at the moment. */
+    MsgHdr.fMode.SetUInt32(pObj->GetMode());                                         /* File mode */
+    MsgHdr.cbTotal.SetUInt64(pObj->GetSize());                                       /* File size (in bytes). */
+
+    int rc = VbglR3HGCMCall(&MsgHdr.hdr, sizeof(MsgHdr));
+
+    LogFlowFunc(("Sending file header resulted in %Rrc\n", rc));
+
+    if (RT_SUCCESS(rc))
+    {
+        /*
+         * Send the actual file data, chunk by chunk.
+         */
+        VBoxClipboardWriteFileDataMsg Msg;
+        RT_ZERO(Msg);
+
+        VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, VBOX_SHARED_CLIPBOARD_FN_WRITE_FILE_DATA, 5);
+        Msg.uContext.SetUInt32(0);
+        Msg.pvChecksum.SetPtr(NULL, 0);
+        Msg.cbChecksum.SetUInt32(0);
+
+        uint64_t cbToReadTotal  = pObj->GetSize();
+        uint64_t cbWrittenTotal = 0;
+        while (cbToReadTotal)
+        {
+            uint32_t cbToRead = RT_MIN(cbToReadTotal, cbBuf);
+            uint32_t cbRead   = 0;
+            if (cbToRead)
+                rc = pObj->Read(pvBuf, cbToRead, &cbRead);
+
+            LogFlowFunc(("cbToReadTotal=%RU64, cbToRead=%RU32, cbRead=%RU32, rc=%Rrc\n",
+                         cbToReadTotal, cbToRead, cbRead, rc));
+
+            if (   RT_SUCCESS(rc)
+                && cbRead)
+            {
+                Msg.pvData.SetPtr(pvBuf, cbRead);
+                Msg.cbData.SetUInt32(cbRead);
+                /** @todo Calculate + set checksums. */
+
+                rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
+            }
+
+            if (RT_FAILURE(rc))
+            {
+                LogFlowFunc(("Reading failed with rc=%Rrc\n", rc));
+                break;
+            }
+
+            Assert(cbRead  <= cbToReadTotal);
+            cbToReadTotal  -= cbRead;
+            cbWrittenTotal += cbRead;
+
+            LogFlowFunc(("%RU64/%RU64 -- %RU8%%\n", cbWrittenTotal, pObj->GetSize(), cbWrittenTotal * 100 / pObj->GetSize()));
+        };
+    }
+
+    RTMemFree(pvBuf);
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+/**
+ * Guest -> Host
+ * Utility function to send an URI object from guest to the host.
+ *
+ * @returns IPRT status code.
+ * @param   idClient            The client id returned by VbglR3ClipboardConnect().
+ * @param   pObj                URI object to send from guest to the host.
+ */
+static int vbglR3ClipboardSendURIObject(HGCMCLIENTID idClient, SharedClipboardURIObject *pObj)
+{
+    AssertPtrReturn(pObj, VERR_INVALID_POINTER);
+
+    int rc;
+
+    switch (pObj->GetType())
+    {
+        case SharedClipboardURIObject::Type_Directory:
+            rc = vbglR3ClipboardSendDir(idClient, pObj);
+            break;
+
+        case SharedClipboardURIObject::Type_File:
+            rc = vbglR3ClipboardSendFile(idClient, pObj);
+            break;
+
+        default:
+            AssertMsgFailed(("Object type %ld not implemented\n", pObj->GetType()));
+            rc = VERR_NOT_IMPLEMENTED;
+            break;
+    }
+
+    return rc;
+}
+
+/**
+ * Guest -> Host
+ * Utility function to send URI data from guest to the host.
+ *
+ * @returns IPRT status code.
+ * @param   idClient            The client id returned by VbglR3ClipboardConnect().
+ * @param   pvData              Block to URI data to send.
+ * @param   cbData              Size (in bytes) of URI data to send.
+ */
+static int vbglR3ClipboardSendURIData(HGCMCLIENTID idClient, const void *pvData, size_t cbData)
+{
+    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 (SHAREDCLIPBOARDURILIST_FLAGS_RESOLVE_SYMLINKS) here. */
+    /** @todo Add lazy loading (SHAREDCLIPBOARDURILIST_FLAGS_LAZY) here. */
+    uint32_t fFlags = SHAREDCLIPBOARDURILIST_FLAGS_KEEP_OPEN;
+
+    SharedClipboardURIList lstURI;
+    int rc = lstURI.AppendURIPathsFromList(lstPaths, fFlags);
+    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())
+        {
+            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. */
+
+            VBOXCLIPBOARDDATAHDR 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 = vbglR3ClipboardSendDataInternal(idClient,
+                                                 pvURIList, cbURLIist, &dataHdr);
+        }
+        else
+            rc = VERR_INVALID_PARAMETER;
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        while (!lstURI.IsEmpty())
+        {
+            SharedClipboardURIObject *pNextObj = lstURI.First();
+
+            rc = vbglR3ClipboardSendURIObject(idClient, pNextObj);
+            if (RT_FAILURE(rc))
+                break;
+
+            lstURI.RemoveFirst();
+        }
+    }
+
+    return rc;
+}
+
+/**
+ * Guest -> Host
+ * Sends an error back to the host.
+ *
+ * @returns IPRT status code.
+ * @param   idClient            The client id returned by VbglR3ClipboardConnect().
+ * @param   rcErr               Error (IPRT-style) to send.
+ */
+static int vbglR3ClipboardSendErrorInternal(HGCMCLIENTID idClient, int rcErr)
+{
+    VBoxClipboardWriteErrorMsg Msg;
+    RT_ZERO(Msg);
+
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, VBOX_SHARED_CLIPBOARD_FN_WRITE_ERROR, 2);
+    /** @todo Context ID not used yet. */
+    Msg.uContext.SetUInt32(0);
+    Msg.rc.SetUInt32((uint32_t)rcErr); /* uint32_t vs. int. */
+
+    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
+
+    /*
+     * Never return an error if the host did not accept the error at the current
+     * time.  This can be due to the host not having any appropriate callbacks
+     * set which would handle that error.
+     *
+     * bird: Looks like VERR_NOT_SUPPORTED is what the host will return if it
+     *       doesn't an appropriate callback.  The code used to ignore ALL errors
+     *       the host would return, also relevant ones.
+     */
+    if (RT_FAILURE(rc))
+        LogFlowFunc(("Sending error %Rrc failed with rc=%Rrc\n", rcErr, rc));
+    if (rc == VERR_NOT_SUPPORTED)
+        rc = VINF_SUCCESS;
+
+    return rc;
+}
+
+/**
+ * Guest -> Host
+ * Send an error back to the host.
+ *
+ * @returns IPRT status code.
+ * @param   idClient            The client id returned by VbglR3ClipboardConnect().
+ * @param   rcErr               Error (IPRT-style) to send.
+ */
+VBGLR3DECL(int) VbglR3ClipboardSendError(HGCMCLIENTID idClient, int rcErr)
+{
+    return vbglR3ClipboardSendErrorInternal(idClient, rcErr);
+}
+#endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
+

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

@@ -611 +611 @@
     }
     VGSvcVerbose(4, "clipboard: reporting fFormats=%#x\n", fFormats);
-    VbglR3ClipboardReportFormats(g_u32ClientId, fFormats);
+    VbglR3ClipboardWriteFormats(g_u32ClientId, fFormats);
 }
 
@@ -658 +658 @@
                 g_fEmptyClipboard = true;
                 VGSvcVerbose(3, "Reporting empty clipboard\n");
-                VbglR3ClipboardReportFormats(g_u32ClientId, 0);
+                VbglR3ClipboardWriteFormats(g_u32ClientId, 0);
             }
         }
@@ -681 +681 @@
     g_fEmptyClipboard = true;
     VGSvcVerbose(3, "Reporting empty clipboard\n");
-    VbglR3ClipboardReportFormats(g_u32ClientId, 0);
+    VbglR3ClipboardWriteFormats(g_u32ClientId, 0);
 
     vgsvcClipboardOs2PollViewer();

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

@@ -345 +345 @@
             be_clipboard->Unlock();
 
-            VbglR3ClipboardReportFormats(fClientId, formats);
+            VbglR3ClipboardWriteFormats(fClientId, formats);
             break;
         }

trunk/src/VBox/Additions/x11/VBoxClient/Makefile.kmk

@@ -41 +41 @@
         check3d.cpp
 
-ifdef VBOX_WITH_SHARED_CLIPBOARD
- VBoxClient_DEFS += \
-        VBOX_WITH_SHARED_CLIPBOARD
- VBoxClient_SOURCES += \
-        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/clipboard-common.cpp \
-        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/clipboard-x11.cpp \
-        clipboard.cpp
-endif
-
 VBoxClient_SOURCES.linux = \
         chk_stubs.c
@@ -91 +82 @@
 VBoxClient_DEFS += VBOX_WITH_GUEST_PROPS
 endif
+
 ifdef VBOX_WITH_DRAG_AND_DROP
 VBoxClient_DEFS += \
@@ -100 +92 @@
         $(VBOX_LIB_VBGL_R3) \
         $(PATH_STAGE_LIB)/additions/VBoxDnDGuestR3Lib$(VBOX_SUFF_LIB)
+endif
+
+ifdef VBOX_WITH_SHARED_CLIPBOARD
+ VBoxClient_DEFS += \
+        VBOX_WITH_SHARED_CLIPBOARD \
+        $(if $(VBOX_WITH_SHARED_CLIPBOARD_URI_LIST),VBOX_WITH_SHARED_CLIPBOARD_URI_LIST,)
+ VBoxClient_SOURCES += \
+        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/clipboard-common.cpp \
+        $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/clipboard-x11.cpp \
+        clipboard.cpp
+ ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
+  ifdef VBOX_WITH_LIBFUSE
+   VBoxClient_SOURCES += \
+        clipboard-fuse.cpp
+   VBoxClient_LIBS += \
+        libfuse
+  endif
+  ifdef VBOX_WITH_LIBGVFS
+  VBoxClient_SOURCES += \
+        clipboard-gvfs.c
+  VBOX_VBOXCLIENT_GVFS_VER:=1.31.92
+  VBoxClient_INCS += \
+        gvfs-$(VBOX_VBOXCLIENT_GVFS_VER)/common \
+        gvfs-$(VBOX_VBOXCLIENT_GVFS_VER)/client \
+        gvfs-$(VBOX_VBOXCLIENT_GVFS_VER)/daemon \
+        /usr/lib/x86_64-linux-gnu/glib-2.0/include \
+        /usr/include/glib-2.0
+  VBoxClient_LIBS += \
+        libgio-2.0 \
+        libglib-2.0
+  endif
+ endif
 endif
 

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

@@ -152 +152 @@
     RT_NOREF1(pCtx);
     LogRelFlowFunc(("u32Formats=%d\n", u32Formats));
-    int rc = VbglR3ClipboardReportFormats(g_ctx.client, u32Formats);
+    int rc = VbglR3ClipboardWriteFormats(g_ctx.client, u32Formats);
     LogRelFlowFunc(("rc=%Rrc\n", rc));
 }

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

@@ -303 +303 @@
                     break;
 
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
+                case CF_HDROP:
+                    uFormats |= VBOX_SHARED_CLIPBOARD_FMT_URI_LIST;
+                    break;
+#endif
                 default:
                 {

trunk/src/VBox/HostServices/SharedClipboard/Makefile.kmk

@@ -27 +27 @@
 DLLS += VBoxSharedClipboard
 VBoxSharedClipboard_TEMPLATE  = VBOXR3
-VBoxSharedClipboard_DEFS      = VBOX_WITH_HGCM
+VBoxSharedClipboard_DEFS      = \
+        VBOX_WITH_HGCM \
+        $(if $(VBOX_WITH_SHARED_CLIPBOARD_URI_LIST),VBOX_WITH_SHARED_CLIPBOARD_URI_LIST,)
 VBoxSharedClipboard_INCS.win  = \
         $(VBOX_PATH_SDK)

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

@@ -32 +32 @@
 #include <iprt/thread.h>
 #include <iprt/ldr.h>
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
+# include <iprt/utf16.h>
+#endif
+
 #include <process.h>
+#include <shlobj.h> /* Needed for shell objects. */
 
 #include "VBoxClipboard.h"
@@ -112 +117 @@
     LogFlow(("vboxClipboardGetData cbSrc = %d, cbDst = %d\n", cbSrc, cbDst));
 
-    if (u32Format == VBOX_SHARED_CLIPBOARD_FMT_HTML
+    if (   u32Format == VBOX_SHARED_CLIPBOARD_FMT_HTML
         && IsWindowsHTML((const char *)pvSrc))
     {
@@ -134 +139 @@
             *pcbActualDst = 0;
     }
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
+    if (u32Format == VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
+    {
+        /* Convert data to URI list. */
+    }
+#endif
     else
     {
@@ -283 +294 @@
             UINT format = (UINT)wParam;
 
-            Log(("WM_RENDERFORMAT %d\n", format));
+            Log(("WM_RENDERFORMAT: Format %u\n", format));
 
             switch (format)
@@ -298 +309 @@
                     if (format >= 0xC000)
                     {
-                        TCHAR szFormatName[256];
-
-                        int cActual = GetClipboardFormatName(format, szFormatName, sizeof(szFormatName)/sizeof (TCHAR));
-
+                        TCHAR szFormatName[256]; /** @todo r=andy Unicode, 256 is enough? */
+                        int cActual = GetClipboardFormatName(format, szFormatName, sizeof(szFormatName) / sizeof (TCHAR));
                         if (cActual)
                         {
-                            if (strcmp (szFormatName, "HTML Format") == 0)
-                            {
+                            if (RTStrCmp(szFormatName, "HTML Format") == 0)
                                 u32Format |= VBOX_SHARED_CLIPBOARD_FMT_HTML;
-                            }
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
+                            if (   RTStrCmp(szFormatName, CFSTR_FILEDESCRIPTOR) == 0
+                                || RTStrCmp(szFormatName, CFSTR_FILECONTENTS) == 0)
+                                u32Format |= VBOX_SHARED_CLIPBOARD_FMT_URI_LIST;
+#endif
                         }
                     }
@@ -321 +333 @@
             else
             {
-                int vboxrc = vboxClipboardReadDataFromClient (pCtx, u32Format);
+                int vboxrc = vboxClipboardReadDataFromClient(pCtx, u32Format);
 
                 LogFunc(("vboxClipboardReadDataFromClient vboxrc = %d, pv %p, cb %d, u32Format %d\n",
@@ -331 +343 @@
                     && pCtx->pClient->data.u32Format == u32Format)
                 {
-                    HANDLE hMem = GlobalAlloc (GMEM_DDESHARE | GMEM_MOVEABLE, pCtx->pClient->data.cb);
+                    HANDLE hMem = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, pCtx->pClient->data.cb);
 
                     LogFunc(("hMem %p\n", hMem));
@@ -337 +349 @@
                     if (hMem)
                     {
-                        void *pMem = GlobalLock (hMem);
-
-                        LogFunc(("pMem %p, GlobalSize %d\n", pMem, GlobalSize (hMem)));
+                        void *pMem = GlobalLock(hMem);
+
+                        LogFunc(("pMem %p, GlobalSize %d\n", pMem, GlobalSize(hMem)));
 
                         if (pMem)
@@ -347 +359 @@
                             if (pCtx->pClient->data.pv)
                             {
-                                memcpy (pMem, pCtx->pClient->data.pv, pCtx->pClient->data.cb);
-
-                                RTMemFree (pCtx->pClient->data.pv);
+                                memcpy(pMem, pCtx->pClient->data.pv, pCtx->pClient->data.cb);
+
+                                RTMemFree(pCtx->pClient->data.pv);
                                 pCtx->pClient->data.pv        = NULL;
                             }
@@ -357 +369 @@
 
                             /* The memory must be unlocked before inserting to the Clipboard. */
-                            GlobalUnlock (hMem);
+                            GlobalUnlock(hMem);
 
                             /* 'hMem' contains the host clipboard data.
                              * size is 'cb' and format is 'format'.
                              */
-                            HANDLE hClip = SetClipboardData (format, hMem);
+                            HANDLE hClip = SetClipboardData(format, hMem);
 
                             LogFunc(("vboxClipboardHostEvent hClip %p\n", hClip));
@@ -373 +385 @@
                         }
 
-                        GlobalFree (hMem);
+                        GlobalFree(hMem);
                     }
                 }
 
-                RTMemFree (pCtx->pClient->data.pv);
+                RTMemFree(pCtx->pClient->data.pv);
                 pCtx->pClient->data.pv        = NULL;
                 pCtx->pClient->data.cb        = 0;
@@ -446 +458 @@
                 }
 
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
+                if (u32Formats & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
+                {
+                    UINT format = RegisterClipboardFormat(CFSTR_FILEDESCRIPTOR);
+                    if (format)
+                        hClip = SetClipboardData(format, NULL);
+                }
+#endif
                 VBoxClipboardWinClose();
 
@@ -590 +610 @@
     g_ctx.hRenderEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
 
-    rc = RTThreadCreate(&g_ctx.hThread, VBoxClipboardThread, NULL, 65536,
+    rc = RTThreadCreate(&g_ctx.hThread, VBoxClipboardThread, NULL, _64K /* Stack size */,
                         RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "SHCLIP");
 
@@ -788 +808 @@
             }
         }
-
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
+        else if (u32Format & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
+        {
+    #if 0
+            UINT format = RegisterClipboardFormat(CFSTR_FILEDESCRIPTOR);
+            if (format)
+            {
+                hClip = GetClipboardData(format);
+                if (hClip != NULL)
+                {
+                    LPVOID lp = GlobalLock(hClip);
+
+                    if (lp != NULL)
+                    {
+                        LogFunc(("CF_HTML\n"));
+
+                        vboxClipboardGetData(VBOX_SHARED_CLIPBOARD_FMT_HTML, lp, GlobalSize(hClip),
+                                             pv, cb, pcbActual);
+                        LogRelFlowFunc(("Raw HTML clipboard data from host :"));
+                        DumpHtml((char *)pv, cb);
+                        GlobalUnlock(hClip);
+                    }
+                    else
+                    {
+                        hClip = NULL;
+                    }
+                }
+            }
+    #else
+            /* Convert to a string list, separated by \r\n. */
+            DROPFILES *pDropFiles = (DROPFILES *)hClip;
+            AssertPtr(pDropFiles);
+
+            /* Do we need to do Unicode stuff? */
+            const bool fUnicode = RT_BOOL(pDropFiles->fWide);
+
+            /* Get the offset of the file list. */
+            Assert(pDropFiles->pFiles >= sizeof(DROPFILES));
+
+            /* Note: This is *not* pDropFiles->pFiles! DragQueryFile only
+             *       will work with the plain storage medium pointer! */
+            HDROP hDrop = (HDROP)(hClip);
+
+            /* First, get the file count. */
+            /** @todo Does this work on Windows 2000 / NT4? */
+            char *pszFiles = NULL;
+            uint32_t cchFiles = 0;
+            UINT cFiles = DragQueryFile(hDrop, UINT32_MAX /* iFile */, NULL /* lpszFile */, 0 /* cchFile */);
+
+            LogRel(("DnD: Got %RU16 file(s), fUnicode=%RTbool\n", cFiles, fUnicode));
+
+            for (UINT i = 0; i < cFiles; i++)
+            {
+                UINT cchFile = DragQueryFile(hDrop, i /* File index */, NULL /* Query size first */, 0 /* cchFile */);
+                Assert(cchFile);
+
+                if (RT_FAILURE(rc))
+                    break;
+
+                char *pszFileUtf8 = NULL; /* UTF-8 version. */
+                UINT cchFileUtf8 = 0;
+                if (fUnicode)
+                {
+                    /* Allocate enough space (including terminator). */
+                    WCHAR *pwszFile = (WCHAR *)RTMemAlloc((cchFile + 1) * sizeof(WCHAR));
+                    if (pwszFile)
+                    {
+                        const UINT cwcFileUtf16 = DragQueryFileW(hDrop, i /* File index */,
+                                                                 pwszFile, cchFile + 1 /* Include terminator */);
+
+                        AssertMsg(cwcFileUtf16 == cchFile, ("cchFileUtf16 (%RU16) does not match cchFile (%RU16)\n",
+                                                            cwcFileUtf16, cchFile));
+                        RT_NOREF(cwcFileUtf16);
+
+                        rc = RTUtf16ToUtf8(pwszFile, &pszFileUtf8);
+                        if (RT_SUCCESS(rc))
+                        {
+                            cchFileUtf8 = (UINT)strlen(pszFileUtf8);
+                            Assert(cchFileUtf8);
+                        }
+
+                        RTMemFree(pwszFile);
+                    }
+                    else
+                        rc = VERR_NO_MEMORY;
+                }
+                else /* ANSI */
+                {
+                    /* Allocate enough space (including terminator). */
+                    pszFileUtf8 = (char *)RTMemAlloc((cchFile + 1) * sizeof(char));
+                    if (pszFileUtf8)
+                    {
+                        cchFileUtf8 = DragQueryFileA(hDrop, i /* File index */,
+                                                     pszFileUtf8, cchFile + 1 /* Include terminator */);
+
+                        AssertMsg(cchFileUtf8 == cchFile, ("cchFileUtf8 (%RU16) does not match cchFile (%RU16)\n",
+                                                           cchFileUtf8, cchFile));
+                    }
+                    else
+                        rc = VERR_NO_MEMORY;
+                }
+
+                if (RT_SUCCESS(rc))
+                {
+                    LogFlowFunc(("\tFile: %s (cchFile=%RU16)\n", pszFileUtf8, cchFileUtf8));
+
+                    LogRel(("DnD: Adding guest file '%s'\n", pszFileUtf8));
+
+                    rc = RTStrAAppendExN(&pszFiles, 1 /* cPairs */, pszFileUtf8, cchFileUtf8);
+                    if (RT_SUCCESS(rc))
+                        cchFiles += cchFileUtf8;
+                }
+                else
+                    LogRel(("DnD: Error handling file entry #%u, rc=%Rrc\n", i, rc));
+
+                if (pszFileUtf8)
+                    RTStrFree(pszFileUtf8);
+
+                if (RT_FAILURE(rc))
+                    break;
+
+                /* Add separation between filenames.
+                 * Note: Also do this for the last element of the list. */
+                rc = RTStrAAppendExN(&pszFiles, 1 /* cPairs */, "\r\n", 2 /* Bytes */);
+                if (RT_SUCCESS(rc))
+                    cchFiles += 2; /* Include \r\n */
+            }
+
+            if (RT_SUCCESS(rc))
+            {
+                cchFiles += 1; /* Add string termination. */
+                uint32_t cbFiles = cchFiles * sizeof(char);
+
+                LogFlowFunc(("cFiles=%u, cchFiles=%RU32, cbFiles=%RU32, pszFiles=0x%p\n",
+                             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;
+                }
+            }
+
+            LogFlowFunc(("Building CF_HDROP list rc=%Rrc, pszFiles=0x%p, cFiles=%RU16, cchFiles=%RU32\n",
+                         rc, pszFiles, cFiles, cchFiles));
+
+            if (pszFiles)
+                RTStrFree(pszFiles);
+            break;
+    #endif /* 0 */
+        }
+#endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
         VBoxClipboardWinClose();
     }
@@ -893 +1077 @@
 
 
-/*
- * Converts clipboard data from CF_HTML format to mimie clipboard format
+/**
+ * Converts clipboard data from CF_HTML format to MIME clipboard format.
  *
  * Returns allocated buffer that contains html converted to text/html mime type

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

@@ -484 +484 @@
         } break;
 
-        case VBOX_SHARED_CLIPBOARD_FN_FORMATS:
+        case VBOX_SHARED_CLIPBOARD_FN_WRITE_FORMATS:
         {
             /* The guest reports that some formats are available. */