Changeset 80359 in vbox

Timestamp:

Aug 21, 2019 8:37:54 AM (6 years ago)

Author:

vboxsync

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

132824

Message:

Shared Clipboard/URI: Update.

Location:

trunk

Files:

• include/VBox/GuestHost/SharedClipboard-uri.h (modified) (13 diffs)
• include/VBox/HostServices/VBoxClipboardSvc.h (modified) (3 diffs)
• include/VBox/VBoxGuestLib.h (modified) (3 diffs)
• src/VBox/Additions/WINNT/VBoxTray/VBoxClipboard.cpp (modified) (4 diffs)
• src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR3LibClipboard.cpp (modified) (20 diffs)
• src/VBox/GuestHost/SharedClipboard/ClipboardDataObjectImpl-win.cpp (modified) (4 diffs)
• src/VBox/GuestHost/SharedClipboard/ClipboardStreamImpl-win.cpp (modified) (1 diff)
• src/VBox/GuestHost/SharedClipboard/clipboard-uri.cpp (modified) (19 diffs)
• src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-uri.cpp (modified) (12 diffs)
• src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp (modified) (1 diff)

trunk/include/VBox/GuestHost/SharedClipboard-uri.h

@@ -53 +53 @@
 
 /** Specifies an invalid Shared Clipboard list handle. */
-#define SHAREDCLIPBOARDLISTHANDLE_INVALID        0
+#define SHAREDCLIPBOARDLISTHANDLE_INVALID        ((SHAREDCLIPBOARDLISTHANDLE)~0LL)
 
 /** A Shared Clipboard object handle. */
@@ -61 +61 @@
 
 /** Specifies an invalid Shared Clipboard object handle. */
-#define SHAREDCLIPBOARDOBJHANDLE_INVALID         0
+#define SHAREDCLIPBOARDOBJHANDLE_INVALID         ((SHAREDCLIPBOARDOBJHANDLE)~0LL)
 
 /** @} */
@@ -332 +332 @@
 typedef struct _VBOXCLIPBOARDOBJOPENCREATEPARMS
 {
+    /** Path to object to open / create. */
     char                       *pszPath;
+    /** Size (in bytes) of path to to object. */
     uint32_t                    cbPath;
     /** SHAREDCLIPBOARD_OBJ_CF_* */
     uint32_t                    fCreate;
     /**
-     * Attributes of object to create and
+     * Attributes of object to open/create and
      * returned actual attributes of opened/created object.
      */
@@ -363 +365 @@
             SHAREDCLIPBOARDOBJHANDLE uHandle;
         } ObjOpen;
+        struct
+        {
+            SHAREDCLIPBOARDOBJHANDLE uHandle;
+        } ObjClose;
     } u;
     /** Pointer to optional payload. */
@@ -465 +471 @@
 } VBOXCLIPBOARDLIST, *PVBOXCLIPBOARDLIST;
 
-/**
- * Structure for a Shared Clipboard object header.
- */
-typedef struct _VBOXCLIPBOARDOBJHDR
-{
-    /** Header type. Currently not being used. */
-    uint32_t enmType;
-} VBOXCLIPBOARDOBJHDR, *PVBOXCLIPBOARDOBJHDR;
+typedef struct _VBOXCLIPBOARDOBJDATACHUNK
+{
+    uint64_t  uHandle;
+    void     *pvData;
+    uint32_t  cbData;
+} VBOXCLIPBOARDOBJDATACHUNK, *PVBOXCLIPBOARDOBJDATACHUNK;
 
 /**
@@ -723 +727 @@
 typedef std::map<uint16_t, SHAREDCLIPBOARDURITRANSFEREVENT *> SharedClipboardURITransferEventMap;
 
+/**
+ * Enumeration for specifying a Shared Clipboard object type.
+ */
+typedef enum _SHAREDCLIPBOARDURIOBJTYPE
+{
+    /** Invalid object type. */
+    SHAREDCLIPBOARDURIOBJTYPE_INVALID = 0,
+    /** Object is a directory. */
+    SHAREDCLIPBOARDURIOBJTYPE_DIRECTORY,
+    /** Object is a file. */
+    SHAREDCLIPBOARDURIOBJTYPE_FILE,
+    /** Object is a symbolic link. */
+    SHAREDCLIPBOARDURIOBJTYPE_SYMLINK,
+    /** The usual 32-bit hack. */
+    SHAREDCLIPBOARDURIOBJTYPE_32BIT_SIZE_HACK = 0x7fffffff
+} SHAREDCLIPBOARDURIOBJTYPE;
+
+/**
+ * Structure for keeping URI list handle information.
+ * This is using to map own (local) handles to the underlying file system.
+ */
 typedef struct _SHAREDCLIPBOARDURILISTHANDLEINFO
 {
-    VBOXCLIPBOARDLISTOPENPARMS OpenParms;
-    RTFMODE                    fMode;
+    /** Type of list handle. */
+    SHAREDCLIPBOARDURIOBJTYPE enmType;
+    /** Absolute local path of the list object. */
+    char                     *pszPathLocalAbs;
     union
     {
+        /** Local data, based on enmType. */
         struct
         {
             union
             {
-                RTDIR  hDirRoot;
+                RTDIR  hDir;
                 RTFILE hFile;
             };
@@ -740 +768 @@
 } SHAREDCLIPBOARDURILISTHANDLEINFO, *PSHAREDCLIPBOARDURILISTHANDLEINFO;
 
-typedef struct _SHAREDCLIPBOARDOBJHANDLEINFO
-{
+/** Map of URI list handles.
+ *  The key specifies the list handle. */
+typedef std::map<SHAREDCLIPBOARDLISTHANDLE, SHAREDCLIPBOARDURILISTHANDLEINFO *> SharedClipboardURIListMap;
+
+/**
+ * Structure for keeping URI object handle information.
+ * This is using to map own (local) handles to the underlying file system.
+ */
+typedef struct _SHAREDCLIPBOARDURIOBJHANDLEINFO
+{
+    /** Type of object handle. */
+    SHAREDCLIPBOARDURIOBJTYPE enmType;
+    /** Absolute local path of the object. */
+    char                     *pszPathLocalAbs;
     union
     {
+        /** Local data, based on enmType. */
         struct
         {
-            RTDIR hDirRoot;
+            union
+            {
+                RTDIR  hDir;
+                RTFILE hFile;
+            };
         } Local;
     } u;
 } SHAREDCLIPBOARDURIOBJHANDLEINFO, *PSHAREDCLIPBOARDURIOBJHANDLEINFO;
 
-/** Map of URI list handles.
- *  The key specifies the list handle. */
-typedef std::map<SHAREDCLIPBOARDLISTHANDLE, SHAREDCLIPBOARDURILISTHANDLEINFO *> SharedClipboardURIListMap;
-
 /** Map of URI object handles.
  *  The key specifies the object handle. */
-typedef std::map<SHAREDCLIPBOARDOBJHANDLE, SHAREDCLIPBOARDURILISTHANDLEINFO *> SharedClipboardURIObjMap;
+typedef std::map<SHAREDCLIPBOARDOBJHANDLE, SHAREDCLIPBOARDURIOBJHANDLEINFO *> SharedClipboardURIObjMap;
 
 /**
@@ -796 +837 @@
  * This is handed in to the provider implementation callbacks.
  */
-typedef struct _SHAREDCLIPBOARDPROVIDERCTX
+    typedef struct _SHAREDCLIPBOARDPROVIDERCTX
 {
     /** Pointer to the related URI transfer. */
@@ -958 +999 @@
     /** Timeout (in ms) for waiting of events. Default is 30s. */
     RTMSINTERVAL                        uTimeoutMs;
+    /** Absolute path to root entries. */
+    char                               *pszPathRootAbs;
     /** Maximum data chunk size (in bytes) to transfer. Default is 64K. */
     uint32_t                            cbMaxChunkSize;
@@ -963 +1006 @@
     SharedClipboardURITransferEventMap *pMapEvents;
     /** Next upcoming list handle. */
-    uint64_t                            uListHandleNext;
+    SHAREDCLIPBOARDLISTHANDLE           uListHandleNext;
     /** Map of all lists related to this transfer. */
     SharedClipboardURIListMap          *pMapLists;
@@ -969 +1012 @@
     SharedClipboardURIListRootEntries   lstRootEntries;
     /** Next upcoming object handle. */
-    uint64_t                            uObjHandleNext;
+    SHAREDCLIPBOARDOBJHANDLE            uObjHandleNext;
     /** Next upcoming event ID.
      *  0 is reserved for invalid event IDs. */
@@ -1015 +1058 @@
 bool SharedClipboardURIObjCtxIsValid(PSHAREDCLIPBOARDCLIENTURIOBJCTX pObjCtx);
 
+int SharedClipboardURIObjectOpenParmsInit(PVBOXCLIPBOARDOBJOPENCREATEPARMS pParms);
+int SharedClipboardURIObjectOpenParmsCopy(PVBOXCLIPBOARDOBJOPENCREATEPARMS pParmsDst, PVBOXCLIPBOARDOBJOPENCREATEPARMS pParmsSrc);
+void SharedClipboardURIObjectOpenParmsDestroy(PVBOXCLIPBOARDOBJOPENCREATEPARMS pParms);
+
 int SharedClipboardURIObjectOpen(PSHAREDCLIPBOARDURITRANSFER pTransfer, PVBOXCLIPBOARDOBJOPENCREATEPARMS pOpenCreateParms,
                                  PSHAREDCLIPBOARDOBJHANDLE phObj);
-int SharedClipboardURIObjectClose(SHAREDCLIPBOARDOBJHANDLE hObj);
-int SharedClipboardURIObjectRead(SHAREDCLIPBOARDOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead, uint32_t fFlags);
-int SharedClipboardURIObjectWrite(SHAREDCLIPBOARDOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten, uint32_t fFlags);
-int SharedClipboardURIObjectQueryInfo(SHAREDCLIPBOARDOBJHANDLE hObj, PSHAREDCLIPBOARDFSOBJINFO pObjInfo);
+int SharedClipboardURIObjectClose(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDOBJHANDLE hObj);
+int SharedClipboardURIObjectRead(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead, uint32_t fFlags);
+int SharedClipboardURIObjectWrite(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten, uint32_t fFlags);
+
+PVBOXCLIPBOARDOBJDATACHUNK SharedClipboardURIObjectDataChunkDup(PVBOXCLIPBOARDOBJDATACHUNK pDataChunk);
+void SharedClipboardURIObjectDataChunkDestroy(PVBOXCLIPBOARDOBJDATACHUNK pDataChunk);
+void SharedClipboardURIObjectDataChunkFree(PVBOXCLIPBOARDOBJDATACHUNK pDataChunk);
 
 int SharedClipboardURITransferCreate(SHAREDCLIPBOARDURITRANSFERDIR enmDir, SHAREDCLIPBOARDSOURCE enmSource,
@@ -1046 +1096 @@
 int SharedClipboardURITransferSetInterface(PSHAREDCLIPBOARDURITRANSFER pTransfer,
                                            PSHAREDCLIPBOARDPROVIDERCREATIONCTX pCreationCtx);
-int SharedClipboardURILTransferSetRoots(PSHAREDCLIPBOARDURITRANSFER pTransfer, const char *papszRoots, size_t cbRoots);
+int SharedClipboardURILTransferSetRoots(PSHAREDCLIPBOARDURITRANSFER pTransfer, const char *pszRoots, size_t cbRoots);
 void SharedClipboardURITransferReset(PSHAREDCLIPBOARDURITRANSFER pTransfer);
 SharedClipboardArea *SharedClipboardURITransferGetArea(PSHAREDCLIPBOARDURITRANSFER pTransfer);

trunk/include/VBox/HostServices/VBoxClipboardSvc.h

@@ -585 +585 @@
     /** uint32_t in/out: Open / Create flags of type SHAREDCLIPBOARD_OBJ_CF_. */
     HGCMFunctionParameter fCreate;
-    /** pointer, in/out: SHAREDCLIPBOARDFSOBJINFO. */
-    HGCMFunctionParameter objInfo;
 } VBoxClipboardObjOpenMsg;
 
-#define VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_OPEN 4
+#define VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_OPEN 5
 
 typedef struct _VBoxClipboardObjCloseMsg
@@ -611 +609 @@
     /** uint32_t, in: How many bytes to read. */
     HGCMFunctionParameter cbToRead;
-    /** uint32_t, in: Read flags. Currently unused. */
+    /** uint32_t, in: Read flags. Currently unused and must be 0. */
     HGCMFunctionParameter fRead;
 } VBoxClipboardObjReadReqParms;
@@ -622 +620 @@
 } VBoxClipboardObjReadReqMsg;
 
-#define VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_READ_REQ 3
+#define VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_READ_REQ 4
 
 /**

trunk/include/VBox/VBoxGuestLib.h

@@ -596 +596 @@
     /** IN: Protocol version to use. */
     uint32_t uProtocol;
+    /** IN: Maximum chunk size (in bytes). */
+    uint32_t cbChunkSize;
     /** OUT: Number of parameters retrieved. */
     uint32_t uNumParms;
@@ -644 +646 @@
 
 #  ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
+VBGLR3DECL(int)     VbglR3ClipboardConnectEx(PVBGLR3SHCLCMDCTX pCtx);
+VBGLR3DECL(int)     VbglR3ClipboardDisconnectEx(PVBGLR3SHCLCMDCTX pCtx);
 VBGLR3DECL(int)     VbglR3ClipboardEventGetNext(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDURITRANSFER pTransfer,
                                                 PVBGLR3CLIPBOARDEVENT *ppEvent);
@@ -675 +679 @@
 VBGLR3DECL(int)     VbglR3ClipboardObjReadRecv(PVBGLR3SHCLCMDCTX pCtx, PSHAREDCLIPBOARDOBJHANDLE phObj, uint32_t pcbToRead,
                                                uint32_t *pfFlags);
-VBGLR3DECL(int)     VbglR3ClipboardObjReadSend(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf,
+VBGLR3DECL(int)     VbglR3ClipboardObjRead(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf,
                                                uint32_t *pcbRead);
-VBGLR3DECL(int)     VbglR3ClipboardObjWriteSend(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf,
-                                                uint32_t *pcbWritten);
+VBGLR3DECL(int)     VbglR3ClipboardObjWrite(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf,
+                                            uint32_t *pcbWritten);
 
 VBGLR3DECL(int)     VbglR3ClipboardWriteError(HGCMCLIENTID idClient, int rcErr);

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

@@ -115 +115 @@
 
     VBGLR3SHCLCMDCTX cmdCtx;
-    RT_ZERO(cmdCtx);
-
-    int rc = VbglR3ClipboardConnect(&cmdCtx.uClientID);
+    int rc = VbglR3ClipboardConnectEx(&cmdCtx);
     if (RT_SUCCESS(rc))
     {
@@ -149 +147 @@
         }
 
-        VbglR3ClipboardDisconnect(cmdCtx.uClientID);
+        VbglR3ClipboardDisconnectEx(&cmdCtx);
     }
 
@@ -354 +352 @@
     AssertPtr(pThisCtx);
 
-    int rc = VbglR3ClipboardObjReadSend(&pThisCtx->CmdCtx, hObj, pvData, cbData, pcbRead);
+    int rc = VbglR3ClipboardObjRead(&pThisCtx->CmdCtx, hObj, pvData, cbData, pcbRead);
 
     LogFlowFuncLeaveRC(rc);
@@ -370 +368 @@
     AssertPtr(pThisCtx);
 
-    int rc = VbglR3ClipboardObjWriteSend(&pThisCtx->CmdCtx, hObj, pvData, cbData, pcbWritten);
+    int rc = VbglR3ClipboardObjWrite(&pThisCtx->CmdCtx, hObj, pvData, cbData, pcbWritten);
 
     LogFlowFuncLeaveRC(rc);

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

@@ -54 +54 @@
 
 /**
- * Connects to the clipboard service.
+ * Connects to the Shared Clipboard service.
  *
  * @returns VBox status code
@@ -72 +72 @@
 
 /**
- * Disconnect from the clipboard service.
+ * Connects to the Shared Clipboard service, extended version.
+ *
+ * @returns VBox status code.
+ * @param   pCtx                Shared Clipboard command context to use for the connection.
+ */
+VBGLR3DECL(int) VbglR3ClipboardConnectEx(PVBGLR3SHCLCMDCTX pCtx)
+{
+    int rc = VbglR3ClipboardConnect(&pCtx->uClientID);
+    if (RT_SUCCESS(rc))
+    {
+        pCtx->uProtocol   = 0;    /** @todo Makke this dynamic. */
+        pCtx->cbChunkSize = _64K; /** @todo Makke this dynamic. */
+    }
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+
+/**
+ * Disconnects from the Shared Clipboard service.
  *
  * @returns VBox status code.
@@ -80 +100 @@
 {
     return VbglR3HGCMDisconnect(idClient);
+}
+
+
+/**
+ * Disconnects from the Shared Clipboard service, extended version.
+ *
+ * @returns VBox status code.
+ * @param   pCtx                Shared Clipboard command context to use for the connection.
+ */
+VBGLR3DECL(int) VbglR3ClipboardDisconnectEx(PVBGLR3SHCLCMDCTX pCtx)
+{
+    int rc = VbglR3ClipboardDisconnect(pCtx->uClientID);
+    if (RT_SUCCESS(rc))
+    {
+        pCtx->uClientID = 0;
+    }
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
 }
 
@@ -199 +238 @@
  * @retval  VERR_VM_RESTORED if the VM has been restored (idRestoreCheck).
  *
- * @param   idClient        The client ID returned by VbglR3GuestCtrlConnect().
+ * @param   pCtx            Shared Clipboard command context to use for the connection.
  * @param   pidMsg          Where to store the message id.
  * @param   pcParameters    Where to store the number  of parameters which will
@@ -743 +782 @@
 
     Msg.uContext.SetUInt32(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN);
-    Msg.cbPath.SetUInt64(pCreateParms->cbPath);
+    Msg.uHandle.SetUInt64(0);
+    Msg.cbPath.SetUInt32(pCreateParms->cbPath);
     Msg.szPath.SetPtr(pCreateParms->pszPath, pCreateParms->cbPath);
     Msg.fCreate.SetUInt32(0);
-    Msg.objInfo.SetPtr(&pCreateParms->ObjInfo, sizeof(pCreateParms->ObjInfo));
 
     int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
@@ -804 +843 @@
     Msg.szPath.SetPtr((void *)pCreateParms->pszPath, pCreateParms->cbPath + 1 /* Include terminating zero */);
     Msg.fCreate.SetUInt32(pCreateParms->fCreate);
-    Msg.objInfo.SetPtr((void *)&pCreateParms->ObjInfo, sizeof(pCreateParms->ObjInfo));
 
     int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
@@ -827 +865 @@
                        VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_GET, VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_CLOSE);
 
-    Msg.uContext.SetUInt32(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN);
+    Msg.uContext.SetUInt32(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE);
     Msg.uHandle.SetUInt64(0);
 
@@ -920 +958 @@
 }
 
-VBGLR3DECL(int) VbglR3ClipboardObjReadSend(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj,
-                                           void *pvData, uint32_t cbData, uint32_t *pcbRead)
+VBGLR3DECL(int) VbglR3ClipboardObjRead(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj,
+                                       void *pvData, uint32_t cbData, uint32_t *pcbRead)
 {
     AssertPtrReturn(pCtx,   VERR_INVALID_POINTER);
@@ -931 +969 @@
     RT_ZERO(Msg);
 
-    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_READ, VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_READ);
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
+                       VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_READ, VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_READ);
 
     Msg.uContext.SetUInt32(pCtx->uContextID);
     Msg.uHandle.SetUInt64(hObj);
     Msg.pvData.SetPtr(pvData, cbData);
-    Msg.cbData.SetUInt32(0);
+    Msg.cbData.SetUInt32(cbData);
     Msg.pvChecksum.SetPtr(NULL, 0);
     Msg.cbChecksum.SetUInt32(0);
@@ -943 +982 @@
     if (RT_SUCCESS(rc))
     {
-        /** @todo Context ID not used yet. */
         /** @todo Add checksum support. */
 
@@ -957 +995 @@
 }
 
-VBGLR3DECL(int) VbglR3ClipboardObjWriteSend(PVBGLR3SHCLCMDCTX pCtx,
-                                            SHAREDCLIPBOARDOBJHANDLE hObj,
-                                            void *pvData, uint32_t cbData, uint32_t *pcbWritten)
+VBGLR3DECL(int) VbglR3ClipboardObjWrite(PVBGLR3SHCLCMDCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj,
+                                        void *pvData, uint32_t cbData, uint32_t *pcbWritten)
 {
     AssertPtrReturn(pCtx,   VERR_INVALID_POINTER);
     AssertPtrReturn(pvData, VERR_INVALID_POINTER);
-    AssertReturn(cbData,    VERR_INVALID_PARAMETER);
+    /* cbData can be 0. */
     /* pcbWritten is optional. */
 
@@ -969 +1006 @@
     RT_ZERO(Msg);
 
-    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_WRITE, VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_WRITE);
+    VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID,
+                       VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_WRITE, VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_WRITE);
 
     Msg.uContext.SetUInt32(pCtx->uContextID);
@@ -975 +1013 @@
     Msg.pvData.SetPtr(pvData, cbData);
     Msg.cbData.SetUInt32(cbData);
-    Msg.pvChecksum.SetPtr(NULL, 0); /** @todo Implement this. */
-    Msg.cbChecksum.SetUInt32(0); /** @todo Implement this. */
-
-    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
-    if (RT_SUCCESS(rc))
-    {
+    Msg.pvChecksum.SetPtr(NULL, 0);
+    Msg.cbChecksum.SetUInt32(0);
+
+    int rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
+    if (RT_SUCCESS(rc))
+    {
+        /** @todo Add checksum support. */
+
         if (pcbWritten)
-            *pcbWritten = cbData;
+            *pcbWritten = cbData; /** @todo For now return all as being written. */
     }
 
@@ -1049 +1089 @@
             case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN:
             {
-                LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_OPEN\n"));
-
                 VBOXCLIPBOARDLISTOPENPARMS openParmsList;
                 rc = SharedClipboardURIListOpenParmsInit(&openParmsList);
@@ -1076 +1114 @@
             case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE:
             {
-                LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE\n"));
-
                 SHAREDCLIPBOARDLISTHANDLE hList;
                 rc = VbglR3ClipboardListCloseRecv(pCtx, &hList);
@@ -1094 +1130 @@
             case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_READ:
             {
-                LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_HDR_READ\n"));
-
                 /** @todo Handle filter + list features. */
 
@@ -1175 +1209 @@
             case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN:
             {
-                LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN\n"));
-
-                VBOXCLIPBOARDOBJOPENCREATEPARMS createParms;
-                rc = VbglR3ClipboardObjOpenRecv(pCtx, &createParms);
+                VBOXCLIPBOARDOBJOPENCREATEPARMS openParms;
+                rc = SharedClipboardURIObjectOpenParmsInit(&openParms);
                 if (RT_SUCCESS(rc))
                 {
-                    SHAREDCLIPBOARDOBJHANDLE hObj;
-                    rc = SharedClipboardURIObjectOpen(pTransfer, &createParms, &hObj);
+                    rc = VbglR3ClipboardObjOpenRecv(pCtx, &openParms);
                     if (RT_SUCCESS(rc))
                     {
+                        SHAREDCLIPBOARDOBJHANDLE hObj;
+                        rc = SharedClipboardURIObjectOpen(pTransfer, &openParms, &hObj);
+
+                        /* Reply in any case. */
                         int rc2 = VbglR3ClipboardObjOpenReply(pCtx, rc, hObj);
                         AssertRC(rc2);
                     }
+
+                    SharedClipboardURIObjectOpenParmsDestroy(&openParms);
                 }
 
@@ -1195 +1232 @@
             case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE:
             {
-                LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE\n"));
-
                 SHAREDCLIPBOARDOBJHANDLE hObj;
                 rc = VbglR3ClipboardObjCloseRecv(pCtx, &hObj);
                 if (RT_SUCCESS(rc))
                 {
-                    rc = SharedClipboardURIObjectClose(hObj);
+                    rc = SharedClipboardURIObjectClose(pTransfer, hObj);
 
                     /* Reply in any case. */
@@ -1212 +1247 @@
             case VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ:
             {
-                LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ\n"));
-
                 SHAREDCLIPBOARDOBJHANDLE hObj;
                 uint32_t cbBuf;
@@ -1220 +1253 @@
                 if (RT_SUCCESS(rc))
                 {
-                    void *pvBuf = RTMemAlloc(RT_MIN(cbBuf, _64K)); /** @todo Make this more flexible. */
+                    AssertBreakStmt(pCtx->cbChunkSize, rc = VERR_INVALID_PARAMETER);
+
+                    const uint32_t cbToRead = RT_MIN(cbBuf, pCtx->cbChunkSize);
+
+                    LogFlowFunc(("hObj=%RU64, cbBuf=%RU32, fFlags=0x%x -> cbChunkSize=%RU32, cbToRead=%RU32\n",
+                                 hObj, cbBuf, fFlags, pCtx->cbChunkSize, cbToRead));
+
+                    void *pvBuf = RTMemAlloc(cbToRead);
                     if (pvBuf)
                     {
                         uint32_t cbRead;
-                        rc = SharedClipboardURIObjectRead(hObj, pvBuf, cbBuf, &cbRead, fFlags);
+                        rc = SharedClipboardURIObjectRead(pTransfer, hObj, pvBuf, cbToRead, &cbRead, fFlags);
                         if (RT_SUCCESS(rc))
-                            rc = VbglR3ClipboardObjReadSend(pCtx, hObj, pvBuf, cbRead, NULL /* pcbWritten */);
+                            rc = VbglR3ClipboardObjWrite(pCtx, hObj, pvBuf, cbRead, NULL /* pcbWritten */);
 
                         RTMemFree(pvBuf);

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

@@ -24 +24 @@
 #include <VBox/GuestHost/SharedClipboard-uri.h>
 
-/** !!! HACK ALERT !!! Dynamically resolve functions! */
-#ifdef _WIN32_IE
-#undef _WIN32_IE
-#define _WIN32_IE 0x0501
-#endif
-
 #include <iprt/win/windows.h>
 #include <iprt/win/shlobj.h>
@@ -55 +49 @@
     , m_pStream(NULL)
     , m_uObjIdx(0)
+    , m_EventListComplete(NIL_RTSEMEVENT)
+    , m_EventTransferComplete(NIL_RTSEMEVENT)
 {
     AssertPtr(m_pTransfer);
@@ -136 +132 @@
 {
     RTSemEventDestroy(m_EventListComplete);
+    m_EventListComplete = NIL_RTSEMEVENT;
+
     RTSemEventDestroy(m_EventTransferComplete);
+    m_EventTransferComplete = NIL_RTSEMEVENT;
 
     if (m_pStream)
@@ -776 +775 @@
     if (fComplete)
     {
+        if (m_EventTransferComplete != NIL_RTSEMEVENT)
+        {
+            int rc2 = RTSemEventSignal(m_EventTransferComplete);
+            AssertRC(rc2);
+        }
+    }
+
+    LogFlowFuncLeaveRC(rc);
+}
+
+void VBoxClipboardWinDataObject::OnTransferCanceled(void)
+{
+    LogFlowFuncEnter();
+
+    if (m_EventTransferComplete != NIL_RTSEMEVENT)
+    {
         int rc2 = RTSemEventSignal(m_EventTransferComplete);
         AssertRC(rc2);
     }
-
-    LogFlowFuncLeaveRC(rc);
-}
-
-void VBoxClipboardWinDataObject::OnTransferCanceled(void)
-{
-    LogFlowFuncEnter();
-
-    int rc2 = RTSemEventSignal(m_EventTransferComplete);
-    AssertRC(rc2);
 
     LogFlowFuncLeave();

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

@@ -187 +187 @@
             && m_pURITransfer->ProviderIface.pfnObjOpen)
         {
-            VBOXCLIPBOARDOBJOPENCREATEPARMS createParms;
-            RT_ZERO(createParms);
-
-            createParms.pszPath = RTStrDup(m_strPath.c_str());
-            if (createParms.pszPath)
+            VBOXCLIPBOARDOBJOPENCREATEPARMS openParms;
+            rc = SharedClipboardURIObjectOpenParmsInit(&openParms);
+            if (RT_SUCCESS(rc))
             {
-                rc = m_pURITransfer->ProviderIface.pfnObjOpen(&m_pURITransfer->ProviderCtx, &createParms, &m_hObj);
-
-                RTStrFree(createParms.pszPath);
+                openParms.fCreate = SHAREDCLIPBOARD_OBJ_CF_ACT_OPEN_IF_EXISTS
+                                  | SHAREDCLIPBOARD_OBJ_CF_ACT_FAIL_IF_NEW
+                                  | SHAREDCLIPBOARD_OBJ_CF_ACCESS_READ
+                                  | SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYWRITE;
+
+                rc = RTStrCopy(openParms.pszPath, openParms.cbPath, m_strPath.c_str());
+                if (RT_SUCCESS(rc))
+                {
+                    rc = m_pURITransfer->ProviderIface.pfnObjOpen(&m_pURITransfer->ProviderCtx, &openParms, &m_hObj);
+                }
+
+                SharedClipboardURIObjectOpenParmsDestroy(&openParms);
             }
-            else
-                rc = VERR_NO_MEMORY;
         }
         else

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

@@ -29 +29 @@
 
 
-#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
 static int sharedClipboardURITransferThreadCreate(PSHAREDCLIPBOARDURITRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser);
 static int sharedClipboardURITransferThreadDestroy(PSHAREDCLIPBOARDURITRANSFER pTransfer, RTMSINTERVAL uTimeoutMs);
 static int sharedClipboardURITransferWriteThread(RTTHREAD hThread, void *pvUser);
 static PSHAREDCLIPBOARDURITRANSFER sharedClipboardURICtxGetTransferInternal(PSHAREDCLIPBOARDURICTX pURI, uint32_t uIdx);
-#endif
+static int sharedClipboardConvertFileCreateFlags(bool fWritable, unsigned fShClFlags, RTFMODE fMode,
+                                                 SHAREDCLIPBOARDOBJHANDLE handleInitial, uint64_t *pfOpen);
 
 /** @todo Split this file up in different modules. */
@@ -156 +156 @@
 {
     return SharedClipboardURIListEntryDestroy(pRootListEntry);
+}
+
+/**
+ * Destroys a list handle info structure.
+ *
+ * @param   pInfo               List handle info structure to destroy.
+ */
+void SharedClipboardURIListHandleInfoDestroy(PSHAREDCLIPBOARDURILISTHANDLEINFO pInfo)
+{
+    if (!pInfo)
+        return;
+
+    if (pInfo->pszPathLocalAbs)
+    {
+        RTStrFree(pInfo->pszPathLocalAbs);
+        pInfo->pszPathLocalAbs = NULL;
+    }
 }
 
@@ -588 +605 @@
 }
 
+/**
+ * Destroys an object handle info structure.
+ *
+ * @param   pInfo               Object handle info structure to destroy.
+ */
+void SharedClipboardURIObjectHandleInfoDestroy(PSHAREDCLIPBOARDURIOBJHANDLEINFO pInfo)
+{
+    if (!pInfo)
+        return;
+
+    if (pInfo->pszPathLocalAbs)
+    {
+        RTStrFree(pInfo->pszPathLocalAbs);
+        pInfo->pszPathLocalAbs = NULL;
+    }
+}
+
+/**
+ * Initializes an URI object open parameters structure.
+ *
+ * @returns VBox status code.
+ * @param   pParms              URI object open parameters structure to initialize.
+ */
+int SharedClipboardURIObjectOpenParmsInit(PVBOXCLIPBOARDOBJOPENCREATEPARMS pParms)
+{
+    AssertPtrReturn(pParms, VERR_INVALID_POINTER);
+
+    int rc;
+
+    RT_BZERO(pParms, sizeof(VBOXCLIPBOARDOBJOPENCREATEPARMS));
+
+    pParms->cbPath    = RTPATH_MAX; /** @todo Make this dynamic. */
+    pParms->pszPath   = RTStrAlloc(pParms->cbPath);
+    if (pParms->pszPath)
+    {
+        rc = VINF_SUCCESS;
+    }
+    else
+        rc = VERR_NO_MEMORY;
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+/**
+ * Copies an URI object open parameters structure from source to destination.
+ *
+ * @returns VBox status code.
+ * @param   pParmsDst           Where to copy the source URI object open parameters to.
+ * @param   pParmsSrc           Which source URI object open parameters to copy.
+ */
+int SharedClipboardURIObjectOpenParmsCopy(PVBOXCLIPBOARDOBJOPENCREATEPARMS pParmsDst, PVBOXCLIPBOARDOBJOPENCREATEPARMS pParmsSrc)
+{
+    int rc;
+
+    *pParmsDst = *pParmsSrc;
+
+    if (pParmsSrc->pszPath)
+    {
+        Assert(pParmsSrc->cbPath);
+        pParmsDst->pszPath = RTStrDup(pParmsSrc->pszPath);
+        if (pParmsDst->pszPath)
+        {
+            rc = VINF_SUCCESS;
+        }
+        else
+            rc = VERR_NO_MEMORY;
+    }
+    else
+        rc = VINF_SUCCESS;
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+/**
+ * Destroys an URI object open parameters structure.
+ *
+ * @param   pParms              URI object open parameters structure to destroy.
+ */
+void SharedClipboardURIObjectOpenParmsDestroy(PVBOXCLIPBOARDOBJOPENCREATEPARMS pParms)
+{
+    if (!pParms)
+        return;
+
+    if (pParms->pszPath)
+    {
+        RTStrFree(pParms->pszPath);
+        pParms->pszPath = NULL;
+    }
+}
+
+/**
+ * Opens an URI object.
+ *
+ * @returns VBox status code.
+ * @param   pTransfer           URI clipboard transfer to open the object for.
+ * @param   pOpenCreateParms    Open / create parameters of URI object to open / create.
+ * @param   phObj               Where to store the handle of URI object opened on success.
+ */
 int SharedClipboardURIObjectOpen(PSHAREDCLIPBOARDURITRANSFER pTransfer, PVBOXCLIPBOARDOBJOPENCREATEPARMS pOpenCreateParms,
                                  PSHAREDCLIPBOARDOBJHANDLE phObj)
 {
-    RT_NOREF(pTransfer, pOpenCreateParms, phObj);
-    return 0;
-}
-
-int SharedClipboardURIObjectClose(SHAREDCLIPBOARDOBJHANDLE hObj)
-{
-    RT_NOREF(hObj);
-    return 0;
-}
-
-int SharedClipboardURIObjectRead(SHAREDCLIPBOARDOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead, uint32_t fFlags)
-{
-    RT_NOREF(hObj, pvBuf, cbBuf, pcbRead, fFlags);
-    return 0;
-}
-
-int SharedClipboardURIObjectWrite(SHAREDCLIPBOARDOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten,
+    AssertPtrReturn(pTransfer,        VERR_INVALID_POINTER);
+    AssertPtrReturn(pOpenCreateParms, VERR_INVALID_POINTER);
+    AssertPtrReturn(phObj,            VERR_INVALID_POINTER);
+
+    int rc = VINF_SUCCESS;
+
+    LogFlowFunc(("pszPath=%s, fCreate=0x%x\n", pOpenCreateParms->pszPath, pOpenCreateParms->fCreate));
+
+    if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL)
+    {
+        PSHAREDCLIPBOARDURIOBJHANDLEINFO pInfo
+            = (PSHAREDCLIPBOARDURIOBJHANDLEINFO)RTMemAlloc(sizeof(SHAREDCLIPBOARDURIOBJHANDLEINFO));
+        if (pInfo)
+        {
+            const bool fWritable = true; /** @todo Fix this. */
+
+            uint64_t fOpen;
+            rc = sharedClipboardConvertFileCreateFlags(fWritable,
+                                                       pOpenCreateParms->fCreate, pOpenCreateParms->ObjInfo.Attr.fMode,
+                                                       SHAREDCLIPBOARDOBJHANDLE_INVALID, &fOpen);
+            if (RT_SUCCESS(rc))
+            {
+                char *pszPathAbs = RTStrAPrintf2("%s/%s", pTransfer->pszPathRootAbs, pOpenCreateParms->pszPath);
+                if (pszPathAbs)
+                {
+                    LogFlowFunc(("%s\n", pszPathAbs));
+
+                    rc = RTFileOpen(&pInfo->u.Local.hFile, pszPathAbs, fOpen);
+                    RTStrFree(pszPathAbs);
+                }
+                else
+                    rc = VERR_NO_MEMORY;
+            }
+
+            if (RT_SUCCESS(rc))
+            {
+                const SHAREDCLIPBOARDOBJHANDLE hObj = pTransfer->uObjHandleNext++;
+
+                pInfo->enmType = SHAREDCLIPBOARDURIOBJTYPE_FILE;
+
+                pTransfer->pMapObj->insert(
+                    std::pair<SHAREDCLIPBOARDOBJHANDLE, PSHAREDCLIPBOARDURIOBJHANDLEINFO>(hObj, pInfo));
+
+                *phObj = hObj;
+            }
+
+            if (RT_FAILURE(rc))
+                RTMemFree(pInfo);
+        }
+        else
+            rc = VERR_NO_MEMORY;
+    }
+    else if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_REMOTE)
+    {
+        if (pTransfer->ProviderIface.pfnObjOpen)
+        {
+            rc = pTransfer->ProviderIface.pfnObjOpen(&pTransfer->ProviderCtx, pOpenCreateParms, phObj);
+        }
+        else
+            rc = VERR_NOT_SUPPORTED;
+    }
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+/**
+ * Closes an URI object.
+ *
+ * @returns VBox status code.
+ * @param   pTransfer           URI clipboard transfer that contains the object to close.
+ * @param   hObj                Handle of URI object to close.
+ */
+int SharedClipboardURIObjectClose(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDOBJHANDLE hObj)
+{
+    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
+
+    int rc = VINF_SUCCESS;
+
+    if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL)
+    {
+        SharedClipboardURIObjMap::iterator itObj = pTransfer->pMapObj->find(hObj);
+        if (itObj != pTransfer->pMapObj->end())
+        {
+            PSHAREDCLIPBOARDURIOBJHANDLEINFO pInfo = itObj->second;
+            AssertPtr(pInfo);
+
+            switch (pInfo->enmType)
+            {
+                case SHAREDCLIPBOARDURIOBJTYPE_DIRECTORY:
+                {
+                    rc = RTDirClose(pInfo->u.Local.hDir);
+                    if (RT_SUCCESS(rc))
+                        pInfo->u.Local.hDir = NIL_RTDIR;
+                    break;
+                }
+
+                case SHAREDCLIPBOARDURIOBJTYPE_FILE:
+                {
+                    rc = RTFileClose(pInfo->u.Local.hFile);
+                    if (RT_SUCCESS(rc))
+                        pInfo->u.Local.hFile = NIL_RTFILE;
+                    break;
+                }
+
+                default:
+                    rc = VERR_NOT_IMPLEMENTED;
+                    break;
+            }
+
+            RTMemFree(pInfo);
+
+            pTransfer->pMapObj->erase(itObj);
+        }
+        else
+            rc = VERR_NOT_FOUND;
+    }
+    else if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_REMOTE)
+    {
+        if (pTransfer->ProviderIface.pfnObjClose)
+        {
+            rc = pTransfer->ProviderIface.pfnObjClose(&pTransfer->ProviderCtx, hObj);
+        }
+        else
+            rc = VERR_NOT_SUPPORTED;
+    }
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+/**
+ * Reads from an URI object.
+ *
+ * @returns VBox status code.
+ * @param   pTransfer           URI clipboard transfer that contains the object to read from.
+ * @param   hObj                Handle of URI object to read from.
+ * @param   pvBuf               Buffer for where to store the read data.
+ * @param   cbBuf               Size (in bytes) of buffer.
+ * @param   pcbRead             How much bytes were read on success. Optional.
+ */
+int SharedClipboardURIObjectRead(PSHAREDCLIPBOARDURITRANSFER pTransfer,
+                                 SHAREDCLIPBOARDOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead, uint32_t fFlags)
+{
+    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
+    AssertPtrReturn(pvBuf,     VERR_INVALID_POINTER);
+    AssertReturn   (cbBuf,     VERR_INVALID_PARAMETER);
+    /* pcbRead is optional. */
+    /** @todo Validate fFlags. */
+
+    int rc = VINF_SUCCESS;
+
+    if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL)
+    {
+        SharedClipboardURIObjMap::iterator itObj = pTransfer->pMapObj->find(hObj);
+        if (itObj != pTransfer->pMapObj->end())
+        {
+            PSHAREDCLIPBOARDURIOBJHANDLEINFO pInfo = itObj->second;
+            AssertPtr(pInfo);
+
+            switch (pInfo->enmType)
+            {
+                case SHAREDCLIPBOARDURIOBJTYPE_FILE:
+                {
+                    size_t cbRead;
+                    rc = RTFileRead(pInfo->u.Local.hFile, pvBuf, cbBuf, &cbRead);
+                    if (RT_SUCCESS(rc))
+                    {
+                        if (pcbRead)
+                            *pcbRead = (uint32_t)cbRead;
+                    }
+                    break;
+                }
+
+                default:
+                    rc = VERR_NOT_SUPPORTED;
+                    break;
+            }
+        }
+        else
+            rc = VERR_NOT_FOUND;
+    }
+    else if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_REMOTE)
+    {
+        if (pTransfer->ProviderIface.pfnObjRead)
+        {
+            rc = pTransfer->ProviderIface.pfnObjRead(&pTransfer->ProviderCtx, hObj, pvBuf, cbBuf, fFlags, pcbRead);
+        }
+        else
+            rc = VERR_NOT_SUPPORTED;
+    }
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+/**
+ * Writes to an URI object.
+ *
+ * @returns VBox status code.
+ * @param   pTransfer           URI clipboard transfer that contains the object to write to.
+ * @param   hObj                Handle of URI object to write to.
+ * @param   pvBuf               Buffer of data to write.
+ * @param   cbBuf               Size (in bytes) of buffer to write.
+ * @param   pcbWritten          How much bytes were writtenon success. Optional.
+ */
+int SharedClipboardURIObjectWrite(PSHAREDCLIPBOARDURITRANSFER pTransfer,
+                                  SHAREDCLIPBOARDOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten,
                                   uint32_t fFlags)
 {
-    RT_NOREF(hObj, pvBuf, cbBuf, pcbWritten, fFlags);
-    return 0;
-}
-
-int SharedClipboardURIObjectQueryInfo(SHAREDCLIPBOARDOBJHANDLE hObj, PSHAREDCLIPBOARDFSOBJINFO pObjInfo)
-{
-    RT_NOREF(hObj, pObjInfo);
-    return 0;
+    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
+    AssertPtrReturn(pvBuf,     VERR_INVALID_POINTER);
+    AssertReturn   (cbBuf,     VERR_INVALID_PARAMETER);
+    /* pcbWritten is optional. */
+
+    int rc = VINF_SUCCESS;
+
+    if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL)
+    {
+        SharedClipboardURIObjMap::iterator itObj = pTransfer->pMapObj->find(hObj);
+        if (itObj != pTransfer->pMapObj->end())
+        {
+            PSHAREDCLIPBOARDURIOBJHANDLEINFO pInfo = itObj->second;
+            AssertPtr(pInfo);
+
+            switch (pInfo->enmType)
+            {
+                case SHAREDCLIPBOARDURIOBJTYPE_FILE:
+                {
+                    rc = RTFileWrite(pInfo->u.Local.hFile, pvBuf, cbBuf, (size_t *)pcbWritten);
+                    break;
+                }
+
+                default:
+                    rc = VERR_NOT_SUPPORTED;
+                    break;
+            }
+        }
+        else
+            rc = VERR_NOT_FOUND;
+    }
+    else if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_REMOTE)
+    {
+        if (pTransfer->ProviderIface.pfnObjWrite)
+        {
+            rc = pTransfer->ProviderIface.pfnObjWrite(&pTransfer->ProviderCtx, hObj, pvBuf, cbBuf, fFlags, pcbWritten);
+        }
+        else
+            rc = VERR_NOT_SUPPORTED;
+    }
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+/**
+ * Duplicaates an URI object data chunk.
+ *
+ * @returns Duplicated object data chunk on success, or NULL on failure.
+ * @param   pDataChunk          URI object data chunk to duplicate.
+ */
+PVBOXCLIPBOARDOBJDATACHUNK SharedClipboardURIObjectDataChunkDup(PVBOXCLIPBOARDOBJDATACHUNK pDataChunk)
+{
+    if (!pDataChunk)
+        return NULL;
+
+    PVBOXCLIPBOARDOBJDATACHUNK pDataChunkDup = (PVBOXCLIPBOARDOBJDATACHUNK)RTMemAllocZ(sizeof(VBOXCLIPBOARDOBJDATACHUNK));
+    if (!pDataChunkDup)
+        return NULL;
+
+    if (pDataChunk->pvData)
+    {
+        Assert(pDataChunk->cbData);
+
+        pDataChunkDup->uHandle = pDataChunk->uHandle;
+        pDataChunkDup->pvData  = RTMemDup(pDataChunk->pvData, pDataChunk->cbData);
+        pDataChunkDup->cbData  = pDataChunk->cbData;
+    }
+
+    return pDataChunkDup;
+}
+
+/**
+ * Destroys an URI object data chunk.
+ *
+ * @param   pDataChunk          URI object data chunk to destroy.
+ */
+void SharedClipboardURIObjectDataChunkDestroy(PVBOXCLIPBOARDOBJDATACHUNK pDataChunk)
+{
+    if (!pDataChunk)
+        return;
+
+    if (pDataChunk->pvData)
+    {
+        Assert(pDataChunk->cbData);
+
+        RTMemFree(pDataChunk->pvData);
+
+        pDataChunk->pvData = NULL;
+        pDataChunk->cbData = 0;
+    }
+
+    pDataChunk->uHandle = 0;
+}
+
+/**
+ * Frees an URI object data chunk.
+ *
+ * @param   pDataChunk          URI object data chunk to free. The handed-in pointer will
+ *                              be invalid after calling this function.
+ */
+void SharedClipboardURIObjectDataChunkFree(PVBOXCLIPBOARDOBJDATACHUNK pDataChunk)
+{
+    if (!pDataChunk)
+        return;
+
+    SharedClipboardURIObjectDataChunkDestroy(pDataChunk);
+
+    RTMemFree(pDataChunk);
+    pDataChunk = NULL;
 }
 
@@ -656 +1066 @@
     pTransfer->Thread.fStop      = false;
 
+    pTransfer->pszPathRootAbs    = NULL;
+
     pTransfer->uListHandleNext   = 1;
     pTransfer->uObjHandleNext    = 1;
@@ -674 +1086 @@
         if (pTransfer->pMapLists)
         {
-            *ppTransfer = pTransfer;
+            pTransfer->pMapObj = new SharedClipboardURIObjMap();
+            if (pTransfer->pMapObj)
+                *ppTransfer = pTransfer;
         }
     }
@@ -706 +1120 @@
         return rc;
 
+    RTStrFree(pTransfer->pszPathRootAbs);
+
     if (pTransfer->pMapEvents)
     {
+        SharedClipboardURITransferEventMap::iterator itEvent = pTransfer->pMapEvents->begin();
+        while (itEvent != pTransfer->pMapEvents->end())
+        {
+
+            itEvent = pTransfer->pMapEvents->begin();
+        }
+
         delete pTransfer->pMapEvents;
         pTransfer->pMapEvents = NULL;
@@ -714 +1137 @@
     if (pTransfer->pMapLists)
     {
+        SharedClipboardURIListMap::iterator itList = pTransfer->pMapLists->begin();
+        while (itList != pTransfer->pMapLists->end())
+        {
+            SharedClipboardURIListHandleInfoDestroy(itList->second);
+            pTransfer->pMapLists->erase(itList);
+            itList = pTransfer->pMapLists->begin();
+        }
+
+        Assert(pTransfer->pMapLists->size() == 0);
+
         delete pTransfer->pMapLists;
         pTransfer->pMapLists = NULL;
+    }
+
+    if (pTransfer->pMapObj)
+    {
+        SharedClipboardURIObjMap::iterator itObj = pTransfer->pMapObj->begin();
+        while (itObj != pTransfer->pMapObj->end())
+        {
+            SharedClipboardURIObjectHandleInfoDestroy(itObj->second);
+            pTransfer->pMapObj->erase(itObj);
+            itObj = pTransfer->pMapObj->begin();
+        }
+
+        Assert(pTransfer->pMapObj->size() == 0);
+
+        delete pTransfer->pMapObj;
+        pTransfer->pMapObj = NULL;
     }
 
@@ -786 +1235 @@
             if (RT_SUCCESS(rc))
             {
-                if (RTFS_IS_DIRECTORY(objInfo.Attr.fMode))
+                switch (pInfo->enmType)
                 {
-                    rc = RTDirOpen(&pInfo->u.Local.hDirRoot, pOpenParms->pszPath);
+                    case SHAREDCLIPBOARDURIOBJTYPE_DIRECTORY:
+                    {
+                        rc = RTDirOpen(&pInfo->u.Local.hDir, pOpenParms->pszPath);
+                    }
+
+                    case SHAREDCLIPBOARDURIOBJTYPE_FILE:
+                    {
+                        rc = RTFileOpen(&pInfo->u.Local.hFile, pOpenParms->pszPath,
+                                        RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_WRITE);
+                        break;
+                    }
+
+                    default:
+                        rc = VERR_NOT_SUPPORTED;
+                        break;
                 }
-                else if (RTFS_IS_FILE(objInfo.Attr.fMode))
-                {
-                    rc = RTFileOpen(&pInfo->u.Local.hFile, pOpenParms->pszPath,
-                                    RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_WRITE);
-                }
-                else if (RTFS_IS_SYMLINK(objInfo.Attr.fMode))
-                {
-                    rc = VERR_NOT_IMPLEMENTED; /** @todo */
-                }
-                else
-                    AssertFailedStmt(rc = VERR_NOT_SUPPORTED);
-
-                if (RT_SUCCESS(rc))
-                    rc = SharedClipboardURIListOpenParmsCopy(&pInfo->OpenParms, pOpenParms);
 
                 if (RT_SUCCESS(rc))
                 {
-                    pInfo->fMode = objInfo.Attr.fMode;
-
                     hList = sharedClipboardURITransferListHandleNew(pTransfer);
 
                     pTransfer->pMapLists->insert(
-                        std::pair<SHAREDCLIPBOARDLISTHANDLE, PSHAREDCLIPBOARDURILISTHANDLEINFO>(hList, pInfo));
+                        std::pair<SHAREDCLIPBOARDLISTHANDLE, PSHAREDCLIPBOARDURILISTHANDLEINFO>(hList, pInfo)); /** @todo Can this throw? */
                 }
                 else
@@ -818 +1265 @@
                     if (RTFS_IS_DIRECTORY(objInfo.Attr.fMode))
                     {
-                        if (RTDirIsValid(pInfo->u.Local.hDirRoot))
-                            RTDirClose(pInfo->u.Local.hDirRoot);
+                        if (RTDirIsValid(pInfo->u.Local.hDir))
+                            RTDirClose(pInfo->u.Local.hDir);
                     }
                     else if (RTFS_IS_FILE(objInfo.Attr.fMode))
@@ -878 +1325 @@
             AssertPtr(pInfo);
 
-            if (RTDirIsValid(pInfo->u.Local.hDirRoot))
-                RTDirClose(pInfo->u.Local.hDirRoot);
+            switch (pInfo->enmType)
+            {
+                case SHAREDCLIPBOARDURIOBJTYPE_DIRECTORY:
+                {
+                    if (RTDirIsValid(pInfo->u.Local.hDir))
+                        RTDirClose(pInfo->u.Local.hDir);
+                    break;
+                }
+
+                default:
+                    rc = VERR_NOT_SUPPORTED;
+                    break;
+            }
 
             RTMemFree(pInfo);
@@ -935 +1393 @@
 static int sharedClipboardURITransferListHdrFromDir(PVBOXCLIPBOARDLISTHDR pHdr,
                                                     const char *pcszSrcPath, const char *pcszDstPath,
-                                                    const char *pcszDstBase, size_t cchDstBase)
+                                                    const char *pcszDstBase)
 {
     AssertPtrReturn(pcszSrcPath, VERR_INVALID_POINTER);
@@ -941 +1399 @@
     AssertPtrReturn(pcszDstPath, VERR_INVALID_POINTER);
 
-    RT_NOREF(cchDstBase);
-
-    LogFlowFunc(("pcszSrcPath=%s, pcszDstPath=%s, pcszDstBase=%s, cchDstBase=%zu\n",
-                 pcszSrcPath, pcszDstPath, pcszDstBase, cchDstBase));
+    LogFlowFunc(("pcszSrcPath=%s, pcszDstPath=%s, pcszDstBase=%s\n",
+                 pcszSrcPath, pcszDstPath, pcszDstBase));
 
     RTFSOBJINFO objInfo;
@@ -1044 +1500 @@
 
 /**
+ * Translates an absolute path to a relative one.
+ *
+ * @returns Translated, allocated path on success, or NULL on failure.
+ *          Must be free'd with RTStrFree().
+ * @param   pszPath             Absolute path to translate.
+ */
+static char *sharedClipboardPathTranslate(const char *pszPath)
+{
+    char *pszPathTranslated = NULL;
+
+    char *pszSrcPath = RTStrDup(pszPath);
+    if (pszSrcPath)
+    {
+        size_t cbSrcPathLen = RTPathStripTrailingSlash(pszSrcPath);
+        if (cbSrcPathLen)
+        {
+            char *pszFileName = RTPathFilename(pszSrcPath);
+            if (pszFileName)
+            {
+                Assert(pszFileName >= pszSrcPath);
+                size_t cchDstBase = pszFileName - pszSrcPath;
+
+                pszPathTranslated = RTStrDup(&pszSrcPath[cchDstBase]);
+
+                LogFlowFunc(("pszSrcPath=%s, pszFileName=%s -> pszPathTranslated=%s\n",
+                             pszSrcPath, pszFileName, pszPathTranslated));
+            }
+        }
+
+        RTStrFree(pszSrcPath);
+    }
+
+    return pszPathTranslated;
+}
+
+/**
  * Retrieves the header of a Shared Clipboard list.
  *
@@ -1072 +1564 @@
                 AssertPtr(pInfo);
 
-                if (RTFS_IS_DIRECTORY(pInfo->fMode))
+                switch (pInfo->enmType)
                 {
-                    char *pszSrcPath = RTStrDup(pInfo->OpenParms.pszPath);
-                    if (pszSrcPath)
+                    case SHAREDCLIPBOARDURIOBJTYPE_DIRECTORY:
                     {
-                        size_t cbSrcPathLen = RTPathStripTrailingSlash(pszSrcPath);
-                        if (cbSrcPathLen)
+                        char *pszPathRel = sharedClipboardPathTranslate(pInfo->pszPathLocalAbs);
+                        if (pszPathRel)
                         {
-                            char *pszFileName = RTPathFilename(pszSrcPath);
-                            if (pszFileName)
-                            {
-                                Assert(pszFileName >= pszSrcPath);
-                                size_t cchDstBase = pszFileName - pszSrcPath;
-#ifdef VBOX_STRICT
-                                char *pszDstPath  = &pszSrcPath[cchDstBase];
-                                LogFlowFunc(("pszSrcPath=%s, pszFileName=%s, pszDstPath=%s\n",
-                                             pszSrcPath, pszFileName, pszDstPath));
-#endif
-                                rc = sharedClipboardURITransferListHdrFromDir(pHdr,
-                                                                              pszSrcPath, pszSrcPath, pszSrcPath, cchDstBase);
-                            }
-                            else
-                                rc = VERR_PATH_NOT_FOUND;
+                            rc = sharedClipboardURITransferListHdrFromDir(pHdr,
+                                                                          pszPathRel, pszPathRel, pszPathRel);
+                            RTStrFree(pszPathRel);
                         }
                         else
-                            rc = VERR_INVALID_PARAMETER;
-
-                        RTStrFree(pszSrcPath);
+                            rc = VERR_NO_MEMORY;
+                        break;
                     }
-                    else
-                        rc = VERR_NO_MEMORY;
+
+                    case SHAREDCLIPBOARDURIOBJTYPE_FILE:
+                    {
+                        pHdr->cTotalObjects = 1;
+
+                        RTFSOBJINFO objInfo;
+                        rc = RTFileQueryInfo(pInfo->u.Local.hFile, &objInfo, RTFSOBJATTRADD_NOTHING);
+                        if (RT_SUCCESS(rc))
+                        {
+                            pHdr->cbTotalSize = objInfo.cbObject;
+                        }
+                        break;
+                    }
+
+                    default:
+                        rc = VERR_NOT_SUPPORTED;
+                        break;
                 }
-                else if (RTFS_IS_FILE(pInfo->fMode))
+            }
+
+            LogFlowFunc(("cTotalObj=%RU64, cbTotalSize=%RU64\n", pHdr->cTotalObjects, pHdr->cbTotalSize));
+        }
+        else
+            rc = VERR_NOT_FOUND;
+    }
+    else if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_REMOTE)
+    {
+        if (pTransfer->ProviderIface.pfnListHdrRead)
+        {
+            rc = pTransfer->ProviderIface.pfnListHdrRead(&pTransfer->ProviderCtx, hList, pHdr);
+        }
+        else
+            rc = VERR_NOT_SUPPORTED;
+    }
+    else
+        AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED);
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+/**
+ * Returns the current URI object for a clipboard URI transfer list.
+ *
+ * Currently not implemented and wil return NULL.
+ *
+ * @returns Pointer to URI object, or NULL if not found / invalid.
+ * @param   pTransfer           URI clipboard transfer to return URI object for.
+ * @param   hList               Handle of URI transfer list to get object for.
+ * @param   uIdx                Index of object to get.
+ */
+PSHAREDCLIPBOARDURITRANSFEROBJ SharedClipboardURITransferListGetObj(PSHAREDCLIPBOARDURITRANSFER pTransfer,
+                                                                    SHAREDCLIPBOARDLISTHANDLE hList, uint64_t uIdx)
+{
+    AssertPtrReturn(pTransfer, NULL);
+
+    RT_NOREF(hList, uIdx);
+
+    LogFlowFunc(("hList=%RU64\n", hList));
+
+    return NULL;
+}
+
+/**
+ * Reads a single Shared Clipboard list entry.
+ *
+ * @returns VBox status code or VERR_NO_MORE_FILES if the end of the list has been reached.
+ * @param   pTransfer           URI clipboard transfer to handle.
+ * @param   hList               List handle of list to read from.
+ * @param   pEntry              Where to store the read information.
+ */
+int SharedClipboardURITransferListRead(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDLISTHANDLE hList,
+                                       PVBOXCLIPBOARDLISTENTRY pEntry)
+{
+    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
+    AssertPtrReturn(pEntry,    VERR_INVALID_POINTER);
+
+    int rc = VINF_SUCCESS;
+
+    LogFlowFunc(("hList=%RU64\n", hList));
+
+    if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL)
+    {
+        SharedClipboardURIListMap::iterator itList = pTransfer->pMapLists->find(hList);
+        if (itList != pTransfer->pMapLists->end())
+        {
+            PSHAREDCLIPBOARDURILISTHANDLEINFO pInfo = itList->second;
+            AssertPtr(pInfo);
+
+            switch (pInfo->enmType)
+            {
+                case SHAREDCLIPBOARDURIOBJTYPE_DIRECTORY:
                 {
-                    pHdr->cTotalObjects = 1;
+                    LogFlowFunc(("\tDirectory: %s\n", pInfo->pszPathLocalAbs));
+
+                    for (;;)
+                    {
+                        bool fSkipEntry = false; /* Whether to skip an entry in the enumeration. */
+
+                        size_t        cbDirEntry = 0;
+                        PRTDIRENTRYEX pDirEntry  = NULL;
+                        rc = RTDirReadExA(pInfo->u.Local.hDir, &pDirEntry, &cbDirEntry, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
+                        if (RT_SUCCESS(rc))
+                        {
+                            switch (pDirEntry->Info.Attr.fMode & RTFS_TYPE_MASK)
+                            {
+                                case RTFS_TYPE_DIRECTORY:
+                                {
+                                    /* Skip "." and ".." entries. */
+                                    if (RTDirEntryExIsStdDotLink(pDirEntry))
+                                    {
+                                        fSkipEntry = true;
+                                        break;
+                                    }
+
+                                    LogFlowFunc(("Directory: %s\n", pDirEntry->szName));
+                                    break;
+                                }
+
+                                case RTFS_TYPE_FILE:
+                                {
+                                    LogFlowFunc(("File: %s\n", pDirEntry->szName));
+                                    break;
+                                }
+
+                                case RTFS_TYPE_SYMLINK:
+                                {
+                                    rc = VERR_NOT_IMPLEMENTED; /** @todo Not implemented yet. */
+                                    break;
+                                }
+
+                                default:
+                                    break;
+                            }
+
+                            if (   RT_SUCCESS(rc)
+                                && !fSkipEntry)
+                            {
+                                pEntry->pvInfo = (PSHAREDCLIPBOARDFSOBJINFO)RTMemAlloc(sizeof(SHAREDCLIPBOARDFSOBJINFO));
+                                if (pEntry->pvInfo)
+                                {
+                                    rc = RTStrCopy(pEntry->pszName, pEntry->cbName, pDirEntry->szName);
+                                    if (RT_SUCCESS(rc))
+                                    {
+                                        SharedClipboardFsObjFromIPRT(PSHAREDCLIPBOARDFSOBJINFO(pEntry->pvInfo), &pDirEntry->Info);
+
+                                        pEntry->cbInfo = sizeof(SHAREDCLIPBOARDFSOBJINFO);
+                                        pEntry->fInfo  = VBOX_SHAREDCLIPBOARD_INFO_FLAG_FSOBJINFO;
+                                    }
+                                }
+                                else
+                                    rc = VERR_NO_MEMORY;
+                            }
+
+                            RTDirReadExAFree(&pDirEntry, &cbDirEntry);
+                        }
+
+                        if (   !fSkipEntry /* Do we have a valid entry? Bail out. */
+                            || RT_FAILURE(rc))
+                        {
+                            break;
+                        }
+                    }
+
+                    break;
+                }
+
+                case SHAREDCLIPBOARDURIOBJTYPE_FILE:
+                {
+                    LogFlowFunc(("\tSingle file: %s\n", pInfo->pszPathLocalAbs));
 
                     RTFSOBJINFO objInfo;
@@ -1112 +1754 @@
                     if (RT_SUCCESS(rc))
                     {
-                        pHdr->cbTotalSize = objInfo.cbObject;
+                        pEntry->pvInfo = (PSHAREDCLIPBOARDFSOBJINFO)RTMemAlloc(sizeof(SHAREDCLIPBOARDFSOBJINFO));
+                        if (pEntry->pvInfo)
+                        {
+                            rc = RTStrCopy(pEntry->pszName, pEntry->cbName, pInfo->pszPathLocalAbs);
+                            if (RT_SUCCESS(rc))
+                            {
+                                SharedClipboardFsObjFromIPRT(PSHAREDCLIPBOARDFSOBJINFO(pEntry->pvInfo), &objInfo);
+
+                                pEntry->cbInfo = sizeof(SHAREDCLIPBOARDFSOBJINFO);
+                                pEntry->fInfo  = VBOX_SHAREDCLIPBOARD_INFO_FLAG_FSOBJINFO;
+                            }
+                        }
+                        else
+                            rc = VERR_NO_MEMORY;
                     }
+
+                    break;
                 }
-                else if (RTFS_IS_SYMLINK(pInfo->fMode))
-                {
-                    rc = VERR_NOT_IMPLEMENTED; /** @todo */
-                }
-                else
-                    AssertFailedStmt(rc = VERR_NOT_SUPPORTED);
+
+                default:
+                    rc = VERR_NOT_SUPPORTED;
+                    break;
             }
-
-            LogFlowFunc(("cTotalObj=%RU64, cbTotalSize=%RU64\n", pHdr->cTotalObjects, pHdr->cbTotalSize));
-        }
-        else
-            rc = VERR_NOT_FOUND;
-    }
-    else if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_REMOTE)
-    {
-        if (pTransfer->ProviderIface.pfnListHdrRead)
-        {
-            rc = pTransfer->ProviderIface.pfnListHdrRead(&pTransfer->ProviderCtx, hList, pHdr);
-        }
-        else
-            rc = VERR_NOT_SUPPORTED;
-    }
-    else
-        AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED);
-
-    LogFlowFuncLeaveRC(rc);
-    return rc;
-}
-
-/**
- * Returns the current URI object for a clipboard URI transfer list.
- *
- * @returns Pointer to URI object.
- * @param   pTransfer           URI clipboard transfer to return URI object for.
- */
-PSHAREDCLIPBOARDURITRANSFEROBJ SharedClipboardURITransferListGetObj(PSHAREDCLIPBOARDURITRANSFER pTransfer,
-                                                                    SHAREDCLIPBOARDLISTHANDLE hList, uint64_t uIdx)
-{
-    AssertPtrReturn(pTransfer, NULL);
-
-    RT_NOREF(hList, uIdx);
-
-    LogFlowFunc(("hList=%RU64\n", hList));
-
-    return NULL;
-}
-
-/**
- * Reads a single Shared Clipboard list entry.
- *
- * @returns VBox status code or VERR_NO_MORE_FILES if the end of the list has been reached.
- * @param   pTransfer           URI clipboard transfer to handle.
- * @param   hList               List handle of list to read from.
- * @param   pEntry              Where to store the read information.
- */
-int SharedClipboardURITransferListRead(PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDLISTHANDLE hList,
-                                       PVBOXCLIPBOARDLISTENTRY pEntry)
-{
-    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
-    AssertPtrReturn(pEntry,    VERR_INVALID_POINTER);
-
-    int rc = VINF_SUCCESS;
-
-    LogFlowFunc(("hList=%RU64\n", hList));
-
-    if (pTransfer->State.enmSource == SHAREDCLIPBOARDSOURCE_LOCAL)
-    {
-        SharedClipboardURIListMap::iterator itList = pTransfer->pMapLists->find(hList);
-        if (itList != pTransfer->pMapLists->end())
-        {
-            PSHAREDCLIPBOARDURILISTHANDLEINFO pInfo = itList->second;
-            AssertPtr(pInfo);
-
-            LogFlowFunc(("\tfMode=%RU32, pszPath=%s\n", pInfo->fMode, pInfo->OpenParms.pszPath));
-
-            if (RTFS_IS_DIRECTORY(pInfo->fMode))
-            {
-                for (;;)
-                {
-                    bool fSkipEntry = false; /* Whether to skip an entry in the enumeration. */
-
-                    size_t        cbDirEntry = 0;
-                    PRTDIRENTRYEX pDirEntry  = NULL;
-                    rc = RTDirReadExA(pInfo->u.Local.hDirRoot, &pDirEntry, &cbDirEntry, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK);
-                    if (RT_SUCCESS(rc))
-                    {
-                        switch (pDirEntry->Info.Attr.fMode & RTFS_TYPE_MASK)
-                        {
-                            case RTFS_TYPE_DIRECTORY:
-                            {
-                                /* Skip "." and ".." entries. */
-                                if (RTDirEntryExIsStdDotLink(pDirEntry))
-                                {
-                                    fSkipEntry = true;
-                                    break;
-                                }
-
-                                LogFlowFunc(("Directory: %s\n", pDirEntry->szName));
-                                break;
-                            }
-
-                            case RTFS_TYPE_FILE:
-                            {
-                                LogFlowFunc(("File: %s\n", pDirEntry->szName));
-                                break;
-                            }
-
-                            case RTFS_TYPE_SYMLINK:
-                            {
-                                rc = VERR_NOT_IMPLEMENTED; /** @todo Not implemented yet. */
-                                break;
-                            }
-
-                            default:
-                                break;
-                        }
-
-                        if (   RT_SUCCESS(rc)
-                            && !fSkipEntry)
-                        {
-                            pEntry->pvInfo = (PSHAREDCLIPBOARDFSOBJINFO)RTMemAlloc(sizeof(SHAREDCLIPBOARDFSOBJINFO));
-                            if (pEntry->pvInfo)
-                            {
-                                rc = RTStrCopy(pEntry->pszName, pEntry->cbName, pDirEntry->szName);
-                                if (RT_SUCCESS(rc))
-                                {
-                                    SharedClipboardFsObjFromIPRT(PSHAREDCLIPBOARDFSOBJINFO(pEntry->pvInfo), &pDirEntry->Info);
-
-                                    pEntry->cbInfo = sizeof(SHAREDCLIPBOARDFSOBJINFO);
-                                    pEntry->fInfo  = VBOX_SHAREDCLIPBOARD_INFO_FLAG_FSOBJINFO;
-                                }
-                            }
-                            else
-                                rc = VERR_NO_MEMORY;
-                        }
-
-                        RTDirReadExAFree(&pDirEntry, &cbDirEntry);
-                    }
-
-                    if (   !fSkipEntry /* Do we have a valid entry? Bail out. */
-                        || RT_FAILURE(rc))
-                    {
-                        break;
-                    }
-                }
-            }
-            else if (RTFS_IS_FILE(pInfo->fMode))
-            {
-                LogFlowFunc(("\tSingle file: %s\n", pInfo->OpenParms.pszPath));
-
-                RTFSOBJINFO objInfo;
-                rc = RTFileQueryInfo(pInfo->u.Local.hFile, &objInfo, RTFSOBJATTRADD_NOTHING);
-                if (RT_SUCCESS(rc))
-                {
-                    pEntry->pvInfo = (PSHAREDCLIPBOARDFSOBJINFO)RTMemAlloc(sizeof(SHAREDCLIPBOARDFSOBJINFO));
-                    if (pEntry->pvInfo)
-                    {
-                        rc = RTStrCopy(pEntry->pszName, pEntry->cbName, pInfo->OpenParms.pszPath);
-                        if (RT_SUCCESS(rc))
-                        {
-                            SharedClipboardFsObjFromIPRT(PSHAREDCLIPBOARDFSOBJINFO(pEntry->pvInfo), &objInfo);
-
-                            pEntry->cbInfo = sizeof(SHAREDCLIPBOARDFSOBJINFO);
-                            pEntry->fInfo  = VBOX_SHAREDCLIPBOARD_INFO_FLAG_FSOBJINFO;
-                        }
-                    }
-                    else
-                        rc = VERR_NO_MEMORY;
-                }
-            }
-            else if (RTFS_IS_SYMLINK(pInfo->fMode))
-            {
-                rc = VERR_NOT_IMPLEMENTED;
-            }
-            else
-                AssertFailedStmt(rc = VERR_NOT_SUPPORTED);
         }
         else
@@ -1418 +1904 @@
     AssertPtrReturnVoid(pTransfer);
 
+    if (pTransfer->pszPathRootAbs)
+    {
+        RTStrFree(pTransfer->pszPathRootAbs);
+        pTransfer->pszPathRootAbs = NULL;
+    }
+
     pTransfer->lstRootEntries.clear();
 }
@@ -1427 +1919 @@
  * @param   pTransfer           Transfer to set URI list entries for.
  * @param   pszRoots            String list (separated by CRLF) of root entries to set.
+ *                              All entries must have the same root path.
  * @param   cbRoots             Size (in bytes) of string list.
  */
 int SharedClipboardURILTransferSetRoots(PSHAREDCLIPBOARDURITRANSFER pTransfer, const char *pszRoots, size_t cbRoots)
 {
-    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
-    AssertPtrReturn(pszRoots,  VERR_INVALID_POINTER);
-    AssertReturn(cbRoots,      VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pTransfer,      VERR_INVALID_POINTER);
+    AssertPtrReturn(pszRoots,       VERR_INVALID_POINTER);
+    AssertReturn(cbRoots,           VERR_INVALID_PARAMETER);
 
     if (!RTStrIsValidEncoding(pszRoots))
@@ -1442 +1935 @@
     sharedClipboardURIListTransferRootsClear(pTransfer);
 
+    char *pszPathRootAbs = NULL;
+
     RTCList<RTCString> lstRootEntries = RTCString(pszRoots, cbRoots - 1).split("\r\n");
     for (size_t i = 0; i < lstRootEntries.size(); ++i)
     {
         SHAREDCLIPBOARDURILISTROOT listRoot;
-
         listRoot.strPathAbs = lstRootEntries.at(i);
 
+        if (!pszPathRootAbs)
+        {
+            pszPathRootAbs = RTStrDup(listRoot.strPathAbs.c_str());
+            if (pszPathRootAbs)
+            {
+                RTPathStripFilename(pszPathRootAbs);
+                LogFlowFunc(("pszPathRootAbs=%s\n", pszPathRootAbs));
+            }
+            else
+                rc = VERR_NO_MEMORY;
+        }
+
+        if (RT_FAILURE(rc))
+            break;
+
+        /* Make sure all entries have the same root path. */
+        if (!RTStrStartsWith(listRoot.strPathAbs.c_str(), pszPathRootAbs))
+        {
+            rc = VERR_INVALID_PARAMETER;
+            break;
+        }
+
         pTransfer->lstRootEntries.append(listRoot);
     }
 
-    LogFlowFunc(("cRoots=%RU32\n", pTransfer->lstRootEntries.size()));
+    /** @todo Entry rollback on failure? */
+
+    if (RT_SUCCESS(rc))
+    {
+        pTransfer->pszPathRootAbs = pszPathRootAbs;
+        LogFlowFunc(("pszPathRootAbs=%s, cRoots=%zu\n", pTransfer->pszPathRootAbs, pTransfer->lstRootEntries.size()));
+    }
 
     LogFlowFuncLeaveRC(rc);
@@ -2249 +2771 @@
 }
 
+/**
+ * Converts Shared Clipboard create flags (see SharedClipboard-uri.) into IPRT create flags.
+ *
+ * @returns IPRT status code.
+ * @param  fWritable            Whether the shared folder is writable
+ * @param  fShClFlags           Shared clipboard create flags.
+ * @param  fMode                File attributes.
+ * @param  handleInitial        Initial handle.
+ * @retval pfOpen               Where to store the IPRT creation / open flags.
+ *
+ * @sa Initially taken from vbsfConvertFileOpenFlags().
+ */
+static int sharedClipboardConvertFileCreateFlags(bool fWritable, unsigned fShClFlags, RTFMODE fMode,
+                                                 SHAREDCLIPBOARDOBJHANDLE handleInitial, uint64_t *pfOpen)
+{
+    uint64_t fOpen = 0;
+    int rc = VINF_SUCCESS;
+
+    if (   (fMode & RTFS_DOS_MASK) != 0
+        && (fMode & RTFS_UNIX_MASK) == 0)
+    {
+        /* A DOS/Windows guest, make RTFS_UNIX_* from RTFS_DOS_*.
+         * @todo this is based on rtFsModeNormalize/rtFsModeFromDos.
+         *       May be better to use RTFsModeNormalize here.
+         */
+        fMode |= RTFS_UNIX_IRUSR | RTFS_UNIX_IRGRP | RTFS_UNIX_IROTH;
+        /* x for directories. */
+        if (fMode & RTFS_DOS_DIRECTORY)
+            fMode |= RTFS_TYPE_DIRECTORY | RTFS_UNIX_IXUSR | RTFS_UNIX_IXGRP | RTFS_UNIX_IXOTH;
+        /* writable? */
+        if (!(fMode & RTFS_DOS_READONLY))
+            fMode |= RTFS_UNIX_IWUSR | RTFS_UNIX_IWGRP | RTFS_UNIX_IWOTH;
+
+        /* Set the requested mode using only allowed bits. */
+        fOpen |= ((fMode & RTFS_UNIX_MASK) << RTFILE_O_CREATE_MODE_SHIFT) & RTFILE_O_CREATE_MODE_MASK;
+    }
+    else
+    {
+        /* Old linux and solaris additions did not initialize the Info.Attr.fMode field
+         * and it contained random bits from stack. Detect this using the handle field value
+         * passed from the guest: old additions set it (incorrectly) to 0, new additions
+         * set it to SHAREDCLIPBOARDOBJHANDLE_INVALID(~0).
+         */
+        if (handleInitial == 0)
+        {
+            /* Old additions. Do nothing, use default mode. */
+        }
+        else
+        {
+            /* New additions or Windows additions. Set the requested mode using only allowed bits.
+             * Note: Windows guest set RTFS_UNIX_MASK bits to 0, which means a default mode
+             *       will be set in fOpen.
+             */
+            fOpen |= ((fMode & RTFS_UNIX_MASK) << RTFILE_O_CREATE_MODE_SHIFT) & RTFILE_O_CREATE_MODE_MASK;
+        }
+    }
+
+    switch ((fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACCESS_MASK_RW))
+    {
+        default:
+        case SHAREDCLIPBOARD_OBJ_CF_ACCESS_NONE:
+        {
+#ifdef RT_OS_WINDOWS
+            if ((fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACCESS_MASK_ATTR) != SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_NONE)
+                fOpen |= RTFILE_O_ATTR_ONLY;
+            else
+#endif
+                fOpen |= RTFILE_O_READ;
+            LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACCESS_NONE\n"));
+            break;
+        }
+
+        case SHAREDCLIPBOARD_OBJ_CF_ACCESS_READ:
+        {
+            fOpen |= RTFILE_O_READ;
+            LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACCESS_READ\n"));
+            break;
+        }
+
+        case SHAREDCLIPBOARD_OBJ_CF_ACCESS_WRITE:
+        {
+            fOpen |= RTFILE_O_WRITE;
+            LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACCESS_WRITE\n"));
+            break;
+        }
+
+        case SHAREDCLIPBOARD_OBJ_CF_ACCESS_READWRITE:
+        {
+            fOpen |= RTFILE_O_READWRITE;
+            LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACCESS_READWRITE\n"));
+            break;
+        }
+    }
+
+    if (fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACCESS_APPEND)
+    {
+        fOpen |= RTFILE_O_APPEND;
+    }
+
+    switch ((fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACCESS_MASK_ATTR))
+    {
+        default:
+        case SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_NONE:
+        {
+            fOpen |= RTFILE_O_ACCESS_ATTR_DEFAULT;
+            LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_NONE\n"));
+            break;
+        }
+
+        case SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_READ:
+        {
+            fOpen |= RTFILE_O_ACCESS_ATTR_READ;
+            LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_READ\n"));
+            break;
+        }
+
+        case SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_WRITE:
+        {
+            fOpen |= RTFILE_O_ACCESS_ATTR_WRITE;
+            LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_WRITE\n"));
+            break;
+        }
+
+        case SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_READWRITE:
+        {
+            fOpen |= RTFILE_O_ACCESS_ATTR_READWRITE;
+            LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACCESS_ATTR_READWRITE\n"));
+            break;
+        }
+    }
+
+    /* Sharing mask */
+    switch ((fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACCESS_MASK_DENY))
+    {
+        default:
+        case SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYNONE:
+            fOpen |= RTFILE_O_DENY_NONE;
+            LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYNONE\n"));
+            break;
+
+        case SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYREAD:
+            fOpen |= RTFILE_O_DENY_READ;
+            LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYREAD\n"));
+            break;
+
+        case SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYWRITE:
+            fOpen |= RTFILE_O_DENY_WRITE;
+            LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYWRITE\n"));
+            break;
+
+        case SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYALL:
+            fOpen |= RTFILE_O_DENY_ALL;
+            LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACCESS_DENYALL\n"));
+            break;
+    }
+
+    /* Open/Create action mask */
+    switch ((fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACT_MASK_IF_EXISTS))
+    {
+        case SHAREDCLIPBOARD_OBJ_CF_ACT_OPEN_IF_EXISTS:
+            if (SHAREDCLIPBOARD_OBJ_CF_ACT_CREATE_IF_NEW == (fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACT_MASK_IF_NEW))
+            {
+                fOpen |= RTFILE_O_OPEN_CREATE;
+                LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACT_OPEN_IF_EXISTS and SHAREDCLIPBOARD_OBJ_CF_ACT_CREATE_IF_NEW\n"));
+            }
+            else if (SHAREDCLIPBOARD_OBJ_CF_ACT_FAIL_IF_NEW == (fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACT_MASK_IF_NEW))
+            {
+                fOpen |= RTFILE_O_OPEN;
+                LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACT_OPEN_IF_EXISTS and SHAREDCLIPBOARD_OBJ_CF_ACT_FAIL_IF_NEW\n"));
+            }
+            else
+            {
+                LogFlowFunc(("invalid open/create action combination\n"));
+                rc = VERR_INVALID_PARAMETER;
+            }
+            break;
+        case SHAREDCLIPBOARD_OBJ_CF_ACT_FAIL_IF_EXISTS:
+            if (SHAREDCLIPBOARD_OBJ_CF_ACT_CREATE_IF_NEW == (fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACT_MASK_IF_NEW))
+            {
+                fOpen |= RTFILE_O_CREATE;
+                LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACT_FAIL_IF_EXISTS and SHAREDCLIPBOARD_OBJ_CF_ACT_CREATE_IF_NEW\n"));
+            }
+            else
+            {
+                LogFlowFunc(("invalid open/create action combination\n"));
+                rc = VERR_INVALID_PARAMETER;
+            }
+            break;
+        case SHAREDCLIPBOARD_OBJ_CF_ACT_REPLACE_IF_EXISTS:
+            if (SHAREDCLIPBOARD_OBJ_CF_ACT_CREATE_IF_NEW == (fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACT_MASK_IF_NEW))
+            {
+                fOpen |= RTFILE_O_CREATE_REPLACE;
+                LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACT_REPLACE_IF_EXISTS and SHAREDCLIPBOARD_OBJ_CF_ACT_CREATE_IF_NEW\n"));
+            }
+            else if (SHAREDCLIPBOARD_OBJ_CF_ACT_FAIL_IF_NEW == (fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACT_MASK_IF_NEW))
+            {
+                fOpen |= RTFILE_O_OPEN | RTFILE_O_TRUNCATE;
+                LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACT_REPLACE_IF_EXISTS and SHAREDCLIPBOARD_OBJ_CF_ACT_FAIL_IF_NEW\n"));
+            }
+            else
+            {
+                LogFlowFunc(("invalid open/create action combination\n"));
+                rc = VERR_INVALID_PARAMETER;
+            }
+            break;
+        case SHAREDCLIPBOARD_OBJ_CF_ACT_OVERWRITE_IF_EXISTS:
+            if (SHAREDCLIPBOARD_OBJ_CF_ACT_CREATE_IF_NEW == (fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACT_MASK_IF_NEW))
+            {
+                fOpen |= RTFILE_O_CREATE_REPLACE;
+                LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACT_OVERWRITE_IF_EXISTS and SHAREDCLIPBOARD_OBJ_CF_ACT_CREATE_IF_NEW\n"));
+            }
+            else if (SHAREDCLIPBOARD_OBJ_CF_ACT_FAIL_IF_NEW == (fShClFlags & SHAREDCLIPBOARD_OBJ_CF_ACT_MASK_IF_NEW))
+            {
+                fOpen |= RTFILE_O_OPEN | RTFILE_O_TRUNCATE;
+                LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACT_OVERWRITE_IF_EXISTS and SHAREDCLIPBOARD_OBJ_CF_ACT_FAIL_IF_NEW\n"));
+            }
+            else
+            {
+                LogFlowFunc(("invalid open/create action combination\n"));
+                rc = VERR_INVALID_PARAMETER;
+            }
+            break;
+        default:
+        {
+            rc = VERR_INVALID_PARAMETER;
+            LogFlowFunc(("SHAREDCLIPBOARD_OBJ_CF_ACT_MASK_IF_EXISTS - invalid parameter\n"));
+            break;
+        }
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        if (!fWritable)
+            fOpen &= ~RTFILE_O_WRITE;
+
+        *pfOpen = fOpen;
+    }
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+

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

@@ -418 +418 @@
                                PSHAREDCLIPBOARDOBJHANDLE phObj)
 {
-    RT_NOREF(pCtx, pCreateParms, phObj);
-
     LogFlowFuncEnter();
 
-    int rc = VINF_SUCCESS;
-
-    PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser;
-    AssertPtr(pThisCtx);
-
-    RT_NOREF(pThisCtx);
+    PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pCtx->pvUser;
+    AssertPtr(pClient);
+
+    int rc;
+
+    PVBOXCLIPBOARDCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_OPEN,
+                                                            VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_OPEN);
+    if (pMsg)
+    {
+        const uint16_t uEvent = SharedClipboardURITransferEventIDGenerate(pCtx->pTransfer);
+
+        LogFlowFunc(("pszPath=%s, fCreate=0x%x\n", pCreateParms->pszPath, pCreateParms->fCreate));
+
+        const uint32_t cbPath = (uint32_t)strlen(pCreateParms->pszPath) + 1; /* Include terminating zero */
+
+        HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent));
+        HGCMSvcSetU64(&pMsg->m_paParms[1], 0); /* uHandle */
+        HGCMSvcSetU32(&pMsg->m_paParms[2], cbPath);
+        HGCMSvcSetPv (&pMsg->m_paParms[3], pCreateParms->pszPath, cbPath);
+        HGCMSvcSetU32(&pMsg->m_paParms[4], pCreateParms->fCreate);
+
+        rc = vboxSvcClipboardMsgAdd(pClient->pData, pMsg, true /* fAppend */);
+        if (RT_SUCCESS(rc))
+        {
+            int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, uEvent);
+            AssertRC(rc2);
+
+            rc = vboxSvcClipboardClientWakeup(pClient);
+            if (RT_SUCCESS(rc))
+            {
+                PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
+                rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
+                if (RT_SUCCESS(rc))
+                {
+                    Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDREPLY));
+
+                    PVBOXCLIPBOARDREPLY pReply = (PVBOXCLIPBOARDREPLY)pPayload->pvData;
+                    AssertPtr(pReply);
+
+                    Assert(pReply->uType == VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_OBJ_OPEN);
+
+                    *phObj = pReply->u.ObjOpen.uHandle;
+
+                    SharedClipboardURITransferPayloadFree(pPayload);
+                }
+            }
+        }
+    }
+    else
+        rc = VERR_NO_MEMORY;
 
     LogFlowFuncLeaveRC(rc);
@@ -435 +477 @@
 int vboxSvcClipboardURIObjClose(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj)
 {
-    RT_NOREF(pCtx, hObj);
-
     LogFlowFuncEnter();
 
-    int rc = VINF_SUCCESS;
-
-    PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser;
-    AssertPtr(pThisCtx);
-
-    RT_NOREF(pThisCtx);
+    PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pCtx->pvUser;
+    AssertPtr(pClient);
+
+    int rc;
+
+    PVBOXCLIPBOARDCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE,
+                                                            VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_CLOSE);
+    if (pMsg)
+    {
+        const uint16_t uEvent = SharedClipboardURITransferEventIDGenerate(pCtx->pTransfer);
+
+        HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent));
+        HGCMSvcSetU64(&pMsg->m_paParms[1], hObj);
+
+        rc = vboxSvcClipboardMsgAdd(pClient->pData, pMsg, true /* fAppend */);
+        if (RT_SUCCESS(rc))
+        {
+            int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, uEvent);
+            AssertRC(rc2);
+
+            rc = vboxSvcClipboardClientWakeup(pClient);
+            if (RT_SUCCESS(rc))
+            {
+                PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
+                rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
+                if (RT_SUCCESS(rc))
+                {
+                    Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDREPLY));
+
+                    PVBOXCLIPBOARDREPLY pReply = (PVBOXCLIPBOARDREPLY)pPayload->pvData;
+                    AssertPtr(pReply);
+
+                    Assert(pReply->uType == VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_OBJ_CLOSE);
+
+                    SharedClipboardURITransferPayloadFree(pPayload);
+                }
+            }
+        }
+    }
+    else
+        rc = VERR_NO_MEMORY;
 
     LogFlowFuncLeaveRC(rc);
@@ -453 +528 @@
                                void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead)
 {
-    RT_NOREF(pCtx, hObj, pvData, cbData, fFlags, pcbRead);
-
     LogFlowFuncEnter();
 
-    int rc = VINF_SUCCESS;
-
-    *pcbRead = cbData;
+    PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pCtx->pvUser;
+    AssertPtr(pClient);
+
+    int rc;
+
+    PVBOXCLIPBOARDCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ,
+                                                            VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_READ_REQ);
+    if (pMsg)
+    {
+        const uint16_t uEvent = SharedClipboardURITransferEventIDGenerate(pCtx->pTransfer);
+
+        HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent));
+        HGCMSvcSetU64(&pMsg->m_paParms[1], hObj);
+        HGCMSvcSetU32(&pMsg->m_paParms[2], cbData);
+        HGCMSvcSetU32(&pMsg->m_paParms[3], fFlags);
+
+        rc = vboxSvcClipboardMsgAdd(pClient->pData, pMsg, true /* fAppend */);
+        if (RT_SUCCESS(rc))
+        {
+            int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, uEvent);
+            AssertRC(rc2);
+
+            rc = vboxSvcClipboardClientWakeup(pClient);
+            if (RT_SUCCESS(rc))
+            {
+                PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
+                rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
+                if (RT_SUCCESS(rc))
+                {
+                    Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDOBJDATACHUNK));
+
+                    PVBOXCLIPBOARDOBJDATACHUNK pDataChunk = (PVBOXCLIPBOARDOBJDATACHUNK)pPayload->pvData;
+                    AssertPtr(pDataChunk);
+
+                    const uint32_t cbRead = RT_MIN(cbData, pDataChunk->cbData);
+
+                    memcpy(pvData, pDataChunk->pvData, cbRead);
+
+                    if (pcbRead)
+                        *pcbRead = cbRead;
+
+                    SharedClipboardURITransferPayloadFree(pPayload);
+                }
+            }
+        }
+    }
+    else
+        rc = VERR_NO_MEMORY;
 
     LogFlowFuncLeaveRC(rc);
@@ -468 +586 @@
                                 void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten)
 {
-    RT_NOREF(pCtx, pCtx, hObj, pvData, cbData, fFlags, pcbWritten);
-
     LogFlowFuncEnter();
 
-    return VERR_NOT_IMPLEMENTED;
-}
-
+    PVBOXCLIPBOARDCLIENT pClient = (PVBOXCLIPBOARDCLIENT)pCtx->pvUser;
+    AssertPtr(pClient);
+
+    int rc;
+
+    PVBOXCLIPBOARDCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_WRITE,
+                                                            VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_WRITE);
+    if (pMsg)
+    {
+        const uint16_t uEvent = SharedClipboardURITransferEventIDGenerate(pCtx->pTransfer);
+
+        HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent));
+        HGCMSvcSetU64(&pMsg->m_paParms[1], hObj);
+        HGCMSvcSetU64(&pMsg->m_paParms[2], cbData);
+        HGCMSvcSetU64(&pMsg->m_paParms[3], fFlags);
+
+        rc = vboxSvcClipboardMsgAdd(pClient->pData, pMsg, true /* fAppend */);
+        if (RT_SUCCESS(rc))
+        {
+            int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, uEvent);
+            AssertRC(rc2);
+
+            rc = vboxSvcClipboardClientWakeup(pClient);
+            if (RT_SUCCESS(rc))
+            {
+                PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
+                rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload);
+                if (RT_SUCCESS(rc))
+                {
+                    const uint32_t cbRead = RT_MIN(cbData, pPayload->cbData);
+
+                    memcpy(pvData, pPayload->pvData, cbRead);
+
+                    if (pcbWritten)
+                        *pcbWritten = cbRead;
+
+                    SharedClipboardURITransferPayloadFree(pPayload);
+                }
+            }
+        }
+    }
+    else
+        rc = VERR_NO_MEMORY;
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
 
 /*********************************************************************************************************************************
@@ -549 +709 @@
         if (RT_SUCCESS(rc))
         {
+            rc = VERR_INVALID_PARAMETER; /* Play safe. */
+
             switch (pReply->uType)
             {
@@ -554 +716 @@
                 {
                     if (cParms >= 6)
-                    {
                         rc = HGCMSvcGetU64(&paParms[5], &pReply->u.ListOpen.uHandle);
-                    }
-                    else
-                        rc = VERR_INVALID_PARAMETER;
                     break;
                 }
@@ -565 +723 @@
                 {
                     if (cParms >= 6)
-                    {
                         rc = HGCMSvcGetU64(&paParms[5], &pReply->u.ObjOpen.uHandle);
-                    }
-                    else
-                        rc = VERR_INVALID_PARAMETER;
                     break;
                 }
 
+                case VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_OBJ_CLOSE:
+                {
+                    if (cParms >= 6)
+                        rc = HGCMSvcGetU64(&paParms[5], &pReply->u.ObjClose.uHandle);
+                    break;
+                }
+
                 default:
+                    rc = VERR_NOT_SUPPORTED;
                     break;
             }
@@ -903 +1065 @@
 
         rc = VINF_SUCCESS;
+    }
+    else
+        rc = VERR_INVALID_PARAMETER;
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+/**
+ * Gets an URI object data chunk from HGCM service parameters.
+ *
+ * @returns VBox status code.
+ * @param   cParms              Number of HGCM parameters supplied in \a paParms.
+ * @param   paParms             Array of HGCM parameters.
+ * @param   pDataChunk          Where to store the object data chunk data.
+ */
+static int vboxSvcClipboardURIGetObjDataChunk(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDOBJDATACHUNK pDataChunk)
+{
+    AssertPtrReturn(paParms,    VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pDataChunk, VERR_INVALID_PARAMETER);
+
+    int rc;
+
+    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_WRITE)
+    {
+        rc = HGCMSvcGetU64(&paParms[1], &pDataChunk->uHandle);
+        if (RT_SUCCESS(rc))
+        {
+            uint32_t cbData;
+            rc = HGCMSvcGetU32(&paParms[2], &cbData);
+            if (RT_SUCCESS(rc))
+            {
+                rc = HGCMSvcGetPv(&paParms[3], &pDataChunk->pvData, &pDataChunk->cbData);
+                AssertReturn(cbData == pDataChunk->cbData, VERR_INVALID_PARAMETER);
+
+                /** @todo Implement checksum handling. */
+            }
+        }
     }
     else
@@ -1252 +1452 @@
                     rc = SharedClipboardURITransferPayloadAlloc(uEvent, pvData, cbData, &pPayload);
                     if (RT_SUCCESS(rc))
+                    {
                         rc = SharedClipboardURITransferEventSignal(pTransfer, uEvent, pPayload);
+                        if (RT_FAILURE(rc))
+                            SharedClipboardURITransferPayloadFree(pPayload);
+                    }
                 }
             }
@@ -1297 +1501 @@
                     rc = SharedClipboardURITransferPayloadAlloc(uEvent, pvData, cbData, &pPayload);
                     if (RT_SUCCESS(rc))
+                    {
                         rc = SharedClipboardURITransferEventSignal(pTransfer, uEvent, pPayload);
+                        if (RT_FAILURE(rc))
+                            SharedClipboardURITransferPayloadFree(pPayload);
+                    }
                 }
             }
@@ -1373 +1581 @@
                         rc = SharedClipboardURITransferPayloadAlloc(uEvent, pvData, cbData, &pPayload);
                         if (RT_SUCCESS(rc))
+                        {
                             rc = SharedClipboardURITransferEventSignal(pTransfer, uEvent, pPayload);
+                            if (RT_FAILURE(rc))
+                                SharedClipboardURITransferPayloadFree(pPayload);
+                        }
                     }
                 }
@@ -1417 +1629 @@
                         rc = SharedClipboardURITransferPayloadAlloc(uEvent, pvData, cbData, &pPayload);
                         if (RT_SUCCESS(rc))
+                        {
                             rc = SharedClipboardURITransferEventSignal(pTransfer, uEvent, pPayload);
+                            if (RT_FAILURE(rc))
+                                SharedClipboardURITransferPayloadFree(pPayload);
+                        }
                     }
                 }
             }
+            break;
+        }
+
+    #if 0
+        case VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_OPEN:
+        {
+            break;
+        }
+
+        case VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_CLOSE:
+        {
+            break;
+        }
+
+        case VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_READ:
+        {
+            break;
+        }
+    #endif
+
+        case VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_WRITE:
+        {
+            VBOXCLIPBOARDOBJDATACHUNK dataChunk;
+            rc = vboxSvcClipboardURIGetObjDataChunk(cParms, paParms, &dataChunk);
+            if (RT_SUCCESS(rc))
+            {
+                void    *pvData = SharedClipboardURIObjectDataChunkDup(&dataChunk);
+                uint32_t cbData = sizeof(VBOXCLIPBOARDOBJDATACHUNK);
+
+                uint32_t uCID;
+                rc = HGCMSvcGetU32(&paParms[0], &uCID);
+                if (RT_SUCCESS(rc))
+                {
+                    const uint16_t uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);
+
+                    PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;
+                    rc = SharedClipboardURITransferPayloadAlloc(uEvent, pvData, cbData, &pPayload);
+                    if (RT_SUCCESS(rc))
+                    {
+                        rc = SharedClipboardURITransferEventSignal(pTransfer, uEvent, pPayload);
+                        if (RT_FAILURE(rc))
+                            SharedClipboardURITransferPayloadFree(pPayload);
+                    }
+                }
+            }
+
             break;
         }

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

@@ -640 +640 @@
             if (pFirstMsg)
             {
-                LogFlowFunc(("[Client %RU32] Current host message is %RU32 (cParms=%RU32)\n",
-                             pClient->uClientID, pFirstMsg->m_uMsg, pFirstMsg->m_cParms));
+                LogFlowFunc(("[Client %RU32] Current host message is %RU32 (%s), cParms=%RU32\n",
+                             pClient->uClientID, pFirstMsg->m_uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->m_uMsg),
+                             pFirstMsg->m_cParms));
 
                 if (pClient->Pending.uType == VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT)