Changeset 79299 in vbox for trunk

Timestamp:

Jun 24, 2019 10:18:19 AM (6 years ago)

Author:

vboxsync

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

131514

Message:

Shared Clipboard/URI: Update.

Location:

trunk

Files:

• include/VBox/GuestHost/SharedClipboard-uri.h (modified) (8 diffs)
• include/VBox/GuestHost/SharedClipboard-win.h (modified) (2 diffs)
• include/VBox/HostServices/VBoxClipboardSvc.h (modified) (1 diff)
• src/VBox/Additions/WINNT/VBoxTray/VBoxClipboard.cpp (modified) (2 diffs)
• src/VBox/GuestHost/SharedClipboard/ClipboardDataObjectImpl-win.cpp (modified) (10 diffs)
• src/VBox/GuestHost/SharedClipboard/ClipboardProvider-HostService.cpp (modified) (2 diffs)
• src/VBox/GuestHost/SharedClipboard/ClipboardProvider.cpp (modified) (4 diffs)
• src/VBox/GuestHost/SharedClipboard/clipboard-uri.cpp (modified) (11 diffs)
• src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-uri.cpp (modified) (7 diffs)
• src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-win.cpp (modified) (2 diffs)
• src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp (modified) (1 diff)

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

@@ -503 +503 @@
 
 /**
- * Enumeration to specify the Shared Clipboard provider source type.
- */
-typedef enum SHAREDCLIPBOARDPROVIDERSOURCE
+ * Enumeration to specify the Shared Clipboard URI provider source type.
+ */
+typedef enum SHAREDCLIPBOARDURIPROVIDERSOURCE
 {
     /** Invalid source type. */
-    SHAREDCLIPBOARDPROVIDERSOURCE_INVALID = 0,
+    SHAREDCLIPBOARDURIPROVIDERSOURCE_INVALID = 0,
     /** Source is VbglR3. */
-    SHAREDCLIPBOARDPROVIDERSOURCE_VBGLR3,
+    SHAREDCLIPBOARDURIPROVIDERSOURCE_VBGLR3,
     /** Source is the host service. */
-    SHAREDCLIPBOARDPROVIDERSOURCE_HOSTSERVICE
-} SHAREDCLIPBOARDPROVIDERSOURCE;
+    SHAREDCLIPBOARDURIPROVIDERSOURCE_HOSTSERVICE
+} SHAREDCLIPBOARDURIPROVIDERSOURCE;
 
 class SharedClipboardProvider;
@@ -553 +553 @@
 {
     /** Specifies what the source of the provider is. */
-    SHAREDCLIPBOARDPROVIDERSOURCE     enmSource;
+    SHAREDCLIPBOARDURIPROVIDERSOURCE  enmSource;
+    /** Specifies whether the provider will read or write data. */
+    SHAREDCLIPBOARDURITRANSFERDIR     enmDir;
     /** Optional callback table; can be NULL if not needed. */
     PSHAREDCLIPBOARDPROVIDERCALLBACKS pCallbacks;
@@ -625 +627 @@
 public: /* Interface to be implemented. */
 
+    virtual int Prepare(void);
+
     virtual int ReadDataHdr(PVBOXCLIPBOARDDATAHDR *ppDataHdr);
     virtual int WriteDataHdr(const PVBOXCLIPBOARDDATAHDR pDataHdr);
@@ -697 +701 @@
     /** Number of references to this instance. */
     volatile uint32_t                m_cRefs;
+    /** The provider's transfer direction. */
+    SHAREDCLIPBOARDURITRANSFERDIR    m_enmDir;
     /** The provider's callback table. */
     SHAREDCLIPBOARDPROVIDERCALLBACKS m_Callbacks;
@@ -759 +765 @@
 public:
 
+    int Prepare(void);
+
     int ReadDataHdr(PVBOXCLIPBOARDDATAHDR *ppDataHdr);
     int WriteDataHdr(const PVBOXCLIPBOARDDATAHDR pDataHdr);
@@ -811 +819 @@
 typedef FNSHAREDCLIPBOARDURITRANSFERSTARTED *PFNSHAREDCLIPBOARDURITRANSFERSTARTED;
 
+typedef DECLCALLBACK(void) FNSHAREDCLIPBOARDURITRANSFERPREPARE(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData);
+/** Pointer to a FNSHAREDCLIPBOARDURITRANSFERPREPARE function. */
+typedef FNSHAREDCLIPBOARDURITRANSFERPREPARE *PFNSHAREDCLIPBOARDURITRANSFERPREPARE;
+
+typedef DECLCALLBACK(void) FNSHAREDCLIPBOARDURIMETADATACOMPLETE(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData);
+/** Pointer to a FNSHAREDCLIPBOARDURIMETADATACOMPLETE function. */
+typedef FNSHAREDCLIPBOARDURIMETADATACOMPLETE *PFNSHAREDCLIPBOARDURIMETADATACOMPLETE;
+
 typedef DECLCALLBACK(void) FNSHAREDCLIPBOARDURITRANSFERCANCELED(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData);
 /** Pointer to a FNSHAREDCLIPBOARDURITRANSFERCANCELED function. */
@@ -831 +847 @@
     /** Saved user pointer. */
     void                                 *pvUser;
+    /** Function pointer, called when the transfer is going to be prepared. */
+    PFNSHAREDCLIPBOARDURITRANSFERPREPARE  pfnTransferPrepare;
     /** Function pointer, called when the transfer has been started. */
     PFNSHAREDCLIPBOARDURITRANSFERSTARTED  pfnTransferStarted;
+    /** Function pointer, called when reading / writing meta data is complete. */
+    PFNSHAREDCLIPBOARDURIMETADATACOMPLETE pfnMetaDataComplete;
     /** Function pointer, called when the transfer is complete. */
     PFNSHAREDCLIPBOARDURITRANSFERCOMPLETE pfnTransferComplete;
@@ -933 +953 @@
 SharedClipboardURIObject *SharedClipboardURITransferGetObject(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint64_t uIdx);
 int SharedClipboardURITransferRun(PSHAREDCLIPBOARDURITRANSFER pTransfer, bool fAsync);
-void SharedClipboardURITransferSetCallbacks(PSHAREDCLIPBOARDURITRANSFER pTransfer, PSHAREDCLIPBOARDURITRANSFERCALLBACKS pCallbacks);
+void SharedClipboardURITransferSetCallbacks(PSHAREDCLIPBOARDURITRANSFER pTransfer,
+                                            PSHAREDCLIPBOARDURITRANSFERCALLBACKS pCallbacks);
 
 int SharedClipboardURITransferMetaDataAdd(PSHAREDCLIPBOARDURITRANSFER pTransfer, const void *pvMeta, uint32_t cbMeta);
 bool SharedClipboardURITransferMetaDataIsComplete(PSHAREDCLIPBOARDURITRANSFER pTransfer);
-int SharedClipboardURITransferMetaGet(PSHAREDCLIPBOARDURITRANSFER pTransfer, const void *pvMeta, uint32_t cbMeta);
 int SharedClipboardURITransferMetaDataRead(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint32_t *pcbRead);
 int SharedClipboardURITransferMetaDataWrite(PSHAREDCLIPBOARDURITRANSFER pTransfer, uint32_t *pcbWritten);

trunk/include/VBox/GuestHost/SharedClipboard-win.h ¶

@@ -216 +216 @@
 
     int copyToHGlobal(const void *pvData, size_t cbData, UINT fFlags, HGLOBAL *phGlobal);
-    int createFileGroupDescriptorFromURIList(const SharedClipboardURIList &URIList, bool fUnicode, HGLOBAL *phGlobal);
+    int createFileGroupDescriptorFromTransfer(PSHAREDCLIPBOARDURITRANSFER pTransfer,
+                                              bool fUnicode, HGLOBAL *phGlobal);
 
     bool lookupFormatEtc(LPFORMATETC pFormatEtc, ULONG *puIndex);
     void registerFormat(LPFORMATETC pFormatEtc, CLIPFORMAT clipFormat, TYMED tyMed = TYMED_HGLOBAL,
                         LONG lindex = -1, DWORD dwAspect = DVASPECT_CONTENT, DVTARGETDEVICE *pTargetDevice = NULL);
+
+protected: /* URI transfer callbacks */
+
+    static DECLCALLBACK(void) onMetaDataCompleteCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData);
 
 protected:
@@ -232 +237 @@
     IStream                    *m_pStream;
     ULONG                       m_uObjIdx;
+    /** Event being triggered when reading the meta data has been completed.*/
+    RTSEMEVENT                  m_EventMetaDataComplete;
 };
 

trunk/include/VBox/HostServices/VBoxClipboardSvc.h ¶

@@ -449 +449 @@
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
 int VBoxSvcClipboardURIReadDataHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDATAHDR pDataHdr);
+int VBoxSvcClipboardURIWriteDataHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDATAHDR pDataHdr);
 int VBoxSvcClipboardURIReadDataChunk(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDATACHUNK pDataChunk);
+int VBoxSvcClipboardURIWriteDataChunk(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDATACHUNK pDataChunk);
 int VBoxSvcClipboardURIReadDir(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDIRDATA pDirData);
+int VBoxSvcClipboardURIWriteDir(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDIRDATA pDirData);
 int VBoxSvcClipboardURIReadFileHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEHDR pFileHdr);
+int VBoxSvcClipboardURIWriteFileHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEHDR pFileHdr);
 int VBoxSvcClipboardURIReadFileData(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEDATA pFileData);
+int VBoxSvcClipboardURIWriteFileData(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEDATA pFileData);
 #endif
 

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

@@ -347 +347 @@
                             SHAREDCLIPBOARDPROVIDERCREATIONCTX creationCtx;
                             RT_ZERO(creationCtx);
-                            creationCtx.enmSource = SHAREDCLIPBOARDPROVIDERSOURCE_VBGLR3;
+                            creationCtx.enmSource = SHAREDCLIPBOARDURIPROVIDERSOURCE_VBGLR3;
+                            creationCtx.enmDir    = SHAREDCLIPBOARDURITRANSFERDIR_READ;
                             creationCtx.u.VbglR3.uClientID = pCtx->u32ClientID;
 
@@ -469 +470 @@
                         SHAREDCLIPBOARDPROVIDERCREATIONCTX creationCtx;
                         RT_ZERO(creationCtx);
-                        creationCtx.enmSource = SHAREDCLIPBOARDPROVIDERSOURCE_VBGLR3;
+                        creationCtx.enmSource = SHAREDCLIPBOARDURIPROVIDERSOURCE_VBGLR3;
+                        creationCtx.enmDir    = SHAREDCLIPBOARDURITRANSFERDIR_WRITE;
                         creationCtx.u.VbglR3.uClientID = pCtx->u32ClientID;
 

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

@@ -121 +121 @@
         m_enmStatus = Initialized;
 
+        int rc2 = RTSemEventCreate(&m_EventMetaDataComplete);
+        AssertRC(rc2);
+
         AssertPtr(m_pTransfer->pProvider);
         m_pTransfer->pProvider->AddRef();
@@ -130 +133 @@
 VBoxClipboardWinDataObject::~VBoxClipboardWinDataObject(void)
 {
+    RTSemEventDestroy(m_EventMetaDataComplete);
+
     if (m_pTransfer->pProvider)
         m_pTransfer->pProvider->Release();
@@ -218 +223 @@
 
 /**
- * Creates a FILEGROUPDESCRIPTOR object from a given Shared Clipboard URI list and stores
- * the result into an HGLOBAL object.
+ * Creates a FILEGROUPDESCRIPTOR object from a given URI transfer and stores the result into an HGLOBAL object.
  *
  * @returns VBox status code.
- * @param   URIList             URI list to create object for.
+ * @param   pTransfer           URI transfer to create file grou desciprtor for.
  * @param   fUnicode            Whether the FILEGROUPDESCRIPTOR object shall contain Unicode data or not.
  * @param   phGlobal            Where to store the allocated HGLOBAL object on success.
  */
-int VBoxClipboardWinDataObject::createFileGroupDescriptorFromURIList(const SharedClipboardURIList &URIList,
-                                                                     bool fUnicode, HGLOBAL *phGlobal)
-{
-    AssertReturn(URIList.GetRootCount(), VERR_INVALID_PARAMETER);
-    AssertPtrReturn(phGlobal,            VERR_INVALID_POINTER);
+int VBoxClipboardWinDataObject::createFileGroupDescriptorFromTransfer(PSHAREDCLIPBOARDURITRANSFER pTransfer,
+                                                                      bool fUnicode, HGLOBAL *phGlobal)
+{
+    AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
+    AssertPtrReturn(phGlobal,  VERR_INVALID_POINTER);
 
     LogFlowFuncEnter();
+
+    SharedClipboardURIList *pURIList = SharedClipboardURITransferGetList(pTransfer);
+    if (!pURIList)
+        return VERR_WRONG_ORDER;
 
     const size_t cbFileGroupDescriptor = fUnicode ? sizeof(FILEGROUPDESCRIPTORW) : sizeof(FILEGROUPDESCRIPTORA);
     const size_t cbFileDescriptor = fUnicode ? sizeof(FILEDESCRIPTORW) : sizeof(FILEDESCRIPTORA);
 
-    const UINT   cItems = (UINT)URIList.GetRootCount(); /** @todo UINT vs. uint64_t */
+    const UINT   cItems = (UINT)pURIList->GetRootCount(); /** @todo UINT vs. uint64_t */
     const size_t cbFGD  = cbFileGroupDescriptor + (cbFileDescriptor * (cItems - 1));
 
@@ -258 +266 @@
         RT_BZERO(pFD, cbFileDescriptor);
 
-        const SharedClipboardURIObject *pObj = URIList.At(i);
+        const SharedClipboardURIObject *pObj = pURIList->At(i);
         AssertPtr(pObj);
         const char *pszFile = pObj->GetSourcePathAbs().c_str();
@@ -373 +381 @@
     HRESULT hr = DV_E_FORMATETC; /* Play safe. */
 
-    LogRel2(("Clipboard: cfFormat=%RI16, sFormat=%s, tyMed=%RU32, dwAspect=%RU32 -> lIndex=%u\n",
+    LogRel2(("Shared Clipboard: cfFormat=%RI16, sFormat=%s, tyMed=%RU32, dwAspect=%RU32 -> lIndex=%u\n",
              pThisFormat->cfFormat, VBoxClipboardWinDataObject::ClipboardFormatToString(pFormatEtc->cfFormat),
              pThisFormat->tymed, pThisFormat->dwAspect, lIndex));
@@ -391 +399 @@
 #endif
         {
-            break;
-#if 0
-            const bool fUnicode = lIndex == FormatIndex_FileDescriptorW;
-
-            LogFlowFunc(("FormatIndex_FileDescriptor%s\n", fUnicode ? "W" : "A"));
-
-            int rc = SharedClipboardURITransferMetaDataRead(m_pTransfer, NULL /* cbRead */);
+            int rc = SharedClipboardURITransferPrepare(m_pTransfer);
             if (RT_SUCCESS(rc))
             {
-                const SharedClipboardURIList *pURIList = SharedClipboardURITransferGetList(m_pTransfer);
-                if (    pURIList
-                    && !pURIList->IsEmpty())
+                const bool fUnicode = lIndex == FormatIndex_FileDescriptorW;
+
+                LogFlowFunc(("FormatIndex_FileDescriptor%s\n", fUnicode ? "W" : "A"));
+
+                /* Register needed callbacks so that we can wait for the meta data to arrive here. */
+                SHAREDCLIPBOARDURITRANSFERCALLBACKS Callbacks;
+                RT_ZERO(Callbacks);
+                Callbacks.pfnMetaDataComplete = VBoxClipboardWinDataObject::onMetaDataCompleteCallback;
+
+                SharedClipboardURITransferSetCallbacks(m_pTransfer, &Callbacks);
+
+                /* Start the transfer asynchronously in a separate thread. */
+                rc = SharedClipboardURITransferRun(m_pTransfer, true /* fAsync */);
+                if (RT_SUCCESS(rc))
                 {
-                    HGLOBAL hGlobal;
-                    rc = createFileGroupDescriptorFromURIList(*pURIList, fUnicode, &hGlobal);
+                    /* Wait for the meta data to arrive. */
+                    LogFlowFunc(("Waiting for meta data to arrive ...\n"));
+                    rc = RTSemEventWait(m_EventMetaDataComplete, 30 * 1000 /* 30s timeout */);
                     if (RT_SUCCESS(rc))
                     {
-                        pMedium->tymed   = TYMED_HGLOBAL;
-                        pMedium->hGlobal = hGlobal;
-                        /* Note: hGlobal now is being owned by pMedium / the caller. */
-
-                        hr = S_OK;
+                        const SharedClipboardURIList *pURIList = SharedClipboardURITransferGetList(m_pTransfer);
+                        if (    pURIList
+                            && !pURIList->IsEmpty())
+                        {
+                            HGLOBAL hGlobal;
+                            rc = createFileGroupDescriptorFromTransfer(m_pTransfer, fUnicode, &hGlobal);
+                            if (RT_SUCCESS(rc))
+                            {
+                                pMedium->tymed   = TYMED_HGLOBAL;
+                                pMedium->hGlobal = hGlobal;
+                                /* Note: hGlobal now is being owned by pMedium / the caller. */
+
+                                hr = S_OK;
+                            }
+                        }
                     }
                 }
             }
-#endif
             break;
         }
@@ -452 +475 @@
 
     if (hr == DV_E_FORMATETC)
-        LogRel(("Clipboard: Error handling format\n"));
+        LogRel(("Shared Clipboard: Error handling format\n"));
 
     LogFlowFunc(("hr=%Rhrc\n", hr));
@@ -689 +712 @@
             //&& pFormatEtc->dwAspect == m_pFormatEtc[i].dwAspect)
         {
-            LogRel3(("Clipboard: Format found: tyMed=%RI32, cfFormat=%RI16, sFormats=%s, dwAspect=%RI32, ulIndex=%RU32\n",
+            LogRel3(("Shared Clipboard: Format found: tyMed=%RI32, cfFormat=%RI16, sFormats=%s, dwAspect=%RI32, ulIndex=%RU32\n",
                       pFormatEtc->tymed, pFormatEtc->cfFormat, VBoxClipboardWinDataObject::ClipboardFormatToString(m_pFormatEtc[i].cfFormat),
                       pFormatEtc->dwAspect, i));
@@ -698 +721 @@
     }
 
-    LogRel3(("Clipboard: Format NOT found: tyMed=%RI32, cfFormat=%RI16, sFormats=%s, dwAspect=%RI32\n",
+    LogRel3(("Shared Clipboard: Format NOT found: tyMed=%RI32, cfFormat=%RI16, sFormats=%s, dwAspect=%RI32\n",
              pFormatEtc->tymed, pFormatEtc->cfFormat, VBoxClipboardWinDataObject::ClipboardFormatToString(pFormatEtc->cfFormat),
              pFormatEtc->dwAspect));
@@ -721 +744 @@
 }
 
+/* static */
+DECLCALLBACK(void) VBoxClipboardWinDataObject::onMetaDataCompleteCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData)
+{
+    VBoxClipboardWinDataObject *pThis = (VBoxClipboardWinDataObject *)pData->pvUser;
+
+    LogFlowFunc(("pThis=%p\n", pThis));
+
+    int rc2 = RTSemEventSignal(pThis->m_EventMetaDataComplete);
+    AssertRC(rc2);
+}
+

trunk/src/VBox/GuestHost/SharedClipboard/ClipboardProvider-HostService.cpp ¶

@@ -51 +51 @@
 }
 
+int SharedClipboardProviderHostService::Prepare(void)
+{
+    LogFlowFuncEnter();
+
+    /*return vboxSvcClipboardReportMsg(,
+                                     VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, );*/
+    return 0;
+}
+
 int SharedClipboardProviderHostService::ReadDataHdr(PVBOXCLIPBOARDDATAHDR *ppDataHdr)
 {
-    RT_NOREF(ppDataHdr);
+    AssertPtrReturn(ppDataHdr, VERR_INVALID_POINTER);
+
+    LogFlowFuncEnter();
+
     /*return eventWait(VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DATA_HDR, m_Callbacks.pfnReadDataHdr, m_uTimeoutMs,
                      (void **)ppDataHdr);*/
@@ -61 +73 @@
 int SharedClipboardProviderHostService::WriteDataHdr(const PVBOXCLIPBOARDDATAHDR pDataHdr)
 {
-    RT_NOREF(pDataHdr);
+    AssertPtrReturn(pDataHdr, VERR_INVALID_POINTER);
 
     LogFlowFuncEnter();

trunk/src/VBox/GuestHost/SharedClipboard/ClipboardProvider.cpp ¶

@@ -148 +148 @@
 SharedClipboardProvider::SharedClipboardProvider(void)
     : m_cRefs(0)
+    , m_enmDir(SHAREDCLIPBOARDURITRANSFERDIR_UNKNOWN)
     , m_uTimeoutMs(30 * 1000 /* 30s timeout by default */)
 {
@@ -178 +179 @@
     {
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_GUEST
-        case SHAREDCLIPBOARDPROVIDERSOURCE_VBGLR3:
+        case SHAREDCLIPBOARDURIPROVIDERSOURCE_VBGLR3:
             pProvider = new SharedClipboardProviderVbglR3(pCtx->u.VbglR3.uClientID);
             break;
@@ -184 +185 @@
 
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_HOST
-        case SHAREDCLIPBOARDPROVIDERSOURCE_HOSTSERVICE:
+        case SHAREDCLIPBOARDURIPROVIDERSOURCE_HOSTSERVICE:
             pProvider = new SharedClipboardProviderHostService(pCtx->u.HostService.pArea);
             break;
@@ -245 +246 @@
  * Stubs.
  */
+
+int SharedClipboardProvider::Prepare(void)
+{
+    return VINF_SUCCESS;
+}
 
 int SharedClipboardProvider::ReadDataHdr(PVBOXCLIPBOARDDATAHDR *ppDataHdr)

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

@@ -637 +637 @@
     pTransfer->cbUser = 0;
 
+    RT_ZERO(pTransfer->Callbacks);
+
     pTransfer->pURIList = new SharedClipboardURIList();
     if (!pTransfer->pURIList)
@@ -708 +710 @@
     LogFlowFuncEnter();
 
-    AssertPtrReturn(pTransfer->State.pMeta, VERR_WRONG_ORDER);
-    AssertPtrReturn(pTransfer->pURIList,    VERR_WRONG_ORDER);
-
-    PSHAREDCLIPBOARDMETADATA pMeta = pTransfer->State.pMeta;
-    AssertPtrReturn(pMeta, VERR_WRONG_ORDER);
-
     int rc;
 
     LogFlowFunc(("enmDir=%RU32\n", pTransfer->State.enmDir));
 
+    if (pTransfer->Callbacks.pfnTransferPrepare)
+    {
+        SHAREDCLIPBOARDURITRANSFERCALLBACKDATA callbackData = { pTransfer, pTransfer->Callbacks.pvUser };
+        pTransfer->Callbacks.pfnTransferPrepare(&callbackData);
+    }
+
     if (pTransfer->State.enmDir == SHAREDCLIPBOARDURITRANSFERDIR_READ)
     {
+        rc = pTransfer->pProvider->Prepare();
+    #if 0
         rc = pTransfer->pURIList->SetFromURIData(SharedClipboardMetaDataRaw(pMeta),
                                                  SharedClipboardMetaDataGetUsed(pMeta),
                                                  SHAREDCLIPBOARDURILIST_FLAGS_NONE);
         /** @todo Verify pvMetaFmt. */
+    #endif
 
         sharedClipboardURITransferMetaDataDestroyInternal(pTransfer);
@@ -729 +734 @@
     else if (pTransfer->State.enmDir == SHAREDCLIPBOARDURITRANSFERDIR_WRITE)
     {
+        AssertPtrReturn(pTransfer->State.pMeta, VERR_WRONG_ORDER);
+        AssertPtrReturn(pTransfer->pURIList,    VERR_WRONG_ORDER);
+
+        const PSHAREDCLIPBOARDMETADATA pMeta = pTransfer->State.pMeta;
+
         rc = pTransfer->pURIList->AppendURIPathsFromList((char *)SharedClipboardMetaDataRaw(pMeta),
                                                          SharedClipboardMetaDataGetUsed(pMeta),
@@ -947 +957 @@
  * @returns VBox status code.
  * @param   pTransfer           URI clipboard transfer to set callbacks for.
- * @param   pCallbacks          Pointer to callback table to set. Specify NULL to unset existing callbacks.
- */
-void SharedClipboardURITransferSetCallbacks(PSHAREDCLIPBOARDURITRANSFER pTransfer, PSHAREDCLIPBOARDURITRANSFERCALLBACKS pCallbacks)
+ * @param   pCallbacks          Pointer to callback table to set.
+ */
+void SharedClipboardURITransferSetCallbacks(PSHAREDCLIPBOARDURITRANSFER pTransfer,
+                                            PSHAREDCLIPBOARDURITRANSFERCALLBACKS pCallbacks)
 {
     AssertPtrReturnVoid(pTransfer);
-    /* pCallbacks might be NULL to unset callbacks. */
+    AssertPtrReturnVoid(pCallbacks);
 
     LogFlowFunc(("pCallbacks=%p\n", pCallbacks));
 
-    if (pCallbacks)
-    {
-        pTransfer->Callbacks = *pCallbacks;
-    }
-    else
-        RT_ZERO(pTransfer->Callbacks);
+#define SET_CALLBACK(a_pfnCallback)             \
+    if (pCallbacks->a_pfnCallback)              \
+        pTransfer->Callbacks.a_pfnCallback = pCallbacks->a_pfnCallback
+
+    SET_CALLBACK(pfnTransferPrepare);
+    SET_CALLBACK(pfnTransferStarted);
+    SET_CALLBACK(pfnMetaDataComplete);
+    SET_CALLBACK(pfnTransferCanceled);
+    SET_CALLBACK(pfnTransferError);
+    SET_CALLBACK(pfnTransferStarted);
+
+#undef SET_CALLBACK
 }
 
@@ -1033 +1050 @@
 
     LogFlowFuncEnter();
+
+    if (pTransfer->Callbacks.pfnTransferStarted)
+    {
+        SHAREDCLIPBOARDURITRANSFERCALLBACKDATA callbackData = { pTransfer, pTransfer->Callbacks.pvUser };
+        pTransfer->Callbacks.pfnTransferStarted(&callbackData);
+    }
 
     int rc = SharedClipboardURITransferMetaDataRead(pTransfer, NULL /* pcbRead */);
@@ -1234 +1257 @@
 {
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
+    /* pcbRead is optional. */
 
     LogFlowFuncEnter();
@@ -1250 +1274 @@
         if (pvMeta)
         {
+            AssertPtr(pTransfer->State.pHeader);
             uint32_t cbMetaToRead = pTransfer->State.pHeader->cbMeta;
             while (cbMetaToRead)
@@ -1273 +1298 @@
                 if (pcbRead)
                     *pcbRead = cbReadTotal;
+
+                if (pTransfer->Callbacks.pfnMetaDataComplete)
+                {
+                    SHAREDCLIPBOARDURITRANSFERCALLBACKDATA callbackData = { pTransfer, pTransfer->Callbacks.pvUser };
+                    pTransfer->Callbacks.pfnMetaDataComplete(&callbackData);
+                }
             }
         }
@@ -1293 +1324 @@
 {
     AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
+    /* pcbWritten is optional. */
 
     AssertPtr(pTransfer->pProvider);
@@ -1329 +1361 @@
             if (pcbWritten)
                 *pcbWritten = cbWrittenTotal;
+
+            if (pTransfer->Callbacks.pfnMetaDataComplete)
+            {
+                SHAREDCLIPBOARDURITRANSFERCALLBACKDATA callbackData = { pTransfer, pTransfer->Callbacks.pvUser };
+                pTransfer->Callbacks.pfnMetaDataComplete(&callbackData);
+            }
         }
     }
@@ -1493 +1531 @@
     LogFlowFuncEnter();
 
+    if (pTransfer->Callbacks.pfnTransferStarted)
+    {
+        SHAREDCLIPBOARDURITRANSFERCALLBACKDATA callbackData = { pTransfer, pTransfer->Callbacks.pvUser };
+        pTransfer->Callbacks.pfnTransferStarted(&callbackData);
+    }
+
     int rc = SharedClipboardURITransferMetaDataWrite(pTransfer, NULL /* pcbWritten */);
     if (RT_SUCCESS(rc))

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

@@ -97 +97 @@
 
 /**
+ * Reads an URI data header 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   pDataHdr            Pointer to data to write the the HGCM parameters.
+ */
+int VBoxSvcClipboardURIWriteDataHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDATAHDR pDataHdr)
+{
+    int rc;
+
+    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_READ_DATA_HDR)
+    {
+        /** @todo Set pvMetaFmt + cbMetaFmt. */
+        /** @todo Calculate header checksum. */
+
+        /* Note: Context ID (paParms[0]) not used yet. */
+        HGCMSvcSetU32(&paParms[1],  pDataHdr->uFlags);
+        HGCMSvcSetU32(&paParms[2],  pDataHdr->uScreenId);
+        HGCMSvcSetU64(&paParms[3],  pDataHdr->cbTotal);
+        HGCMSvcSetU32(&paParms[4],  pDataHdr->cbMeta);
+        HGCMSvcSetU32(&paParms[5],  pDataHdr->cbMetaFmt);
+        HGCMSvcSetPv (&paParms[6],  pDataHdr->pvMetaFmt, pDataHdr->cbMetaFmt);
+        HGCMSvcSetU64(&paParms[7],  pDataHdr->cObjects);
+        HGCMSvcSetU32(&paParms[8],  pDataHdr->enmCompression);
+        HGCMSvcSetU32(&paParms[9],  (uint32_t)pDataHdr->enmChecksumType);
+        HGCMSvcSetU32(&paParms[10], pDataHdr->cbChecksum);
+        HGCMSvcSetPv (&paParms[11], pDataHdr->pvChecksum, pDataHdr->cbChecksum);
+
+        LogFlowFunc(("fFlags=0x%x, cbMeta=%RU32, cbTotalSize=%RU64, cObj=%RU64\n",
+                     pDataHdr->uFlags, pDataHdr->cbMeta, pDataHdr->cbTotal, pDataHdr->cObjects));
+
+        rc = VINF_SUCCESS;
+    }
+    else
+        rc = VERR_INVALID_PARAMETER;
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+/**
  * Reads an URI data chunk from HGCM service parameters.
  *
@@ -133 +175 @@
 
 /**
+ * Writes an URI data chunk to 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          Pointer to data to write the the HGCM parameters.
+ */
+int VBoxSvcClipboardURIWriteDataChunk(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDATACHUNK pDataChunk)
+{
+    int rc;
+
+    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_READ_DATA_CHUNK)
+    {
+        /** @todo Calculate chunk checksum. */
+
+        /* Note: Context ID (paParms[0]) not used yet. */
+        HGCMSvcSetU32(&paParms[1], pDataChunk->cbData);
+        HGCMSvcSetPv (&paParms[2], pDataChunk->pvData, pDataChunk->cbData);
+        HGCMSvcSetU32(&paParms[3], pDataChunk->cbChecksum);
+        HGCMSvcSetPv (&paParms[4], pDataChunk->pvChecksum, pDataChunk->cbChecksum);
+
+        rc = VINF_SUCCESS;
+    }
+    else
+        rc = VERR_INVALID_PARAMETER;
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+/**
  * Reads an URI directory entry from HGCM service parameters.
  *
@@ -169 +242 @@
 
 /**
+ * Writes an URI directory entry to HGCM service parameters.
+ *
+ * @returns VBox status code.
+ * @param   cParms              Number of HGCM parameters supplied in \a paParms.
+ * @param   paParms             Array of HGCM parameters.
+ * @param   pDirData            Pointer to data to write the the HGCM parameters.
+ */
+int VBoxSvcClipboardURIWriteDir(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDIRDATA pDirData)
+{
+    int rc;
+
+    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_READ_DIR)
+    {
+        /* Note: Context ID (paParms[0]) not used yet. */
+        HGCMSvcSetU32(&paParms[1], pDirData->cbPath);
+        HGCMSvcSetPv (&paParms[2], pDirData->pszPath, pDirData->cbPath);
+        HGCMSvcSetU32(&paParms[3], pDirData->fMode);
+
+        rc = VINF_SUCCESS;
+    }
+    else
+        rc = VERR_INVALID_PARAMETER;
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+/**
  * Reads an URI file header from HGCM service parameters.
  *
@@ -204 +305 @@
 
 /**
+ * Writes an URI file header to HGCM service parameters.
+ *
+ * @returns VBox status code.
+ * @param   cParms              Number of HGCM parameters supplied in \a paParms.
+ * @param   paParms             Array of HGCM parameters.
+ * @param   pFileHdr            Pointer to data to write the the HGCM parameters.
+ */
+int VBoxSvcClipboardURIWriteFileHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEHDR pFileHdr)
+{
+    int rc;
+
+    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_READ_FILE_HDR)
+    {
+        /* Note: Context ID (paParms[0]) not used yet. */
+        HGCMSvcSetU32(&paParms[1], pFileHdr->cbFilePath);
+        HGCMSvcSetPv (&paParms[2], pFileHdr->pszFilePath, pFileHdr->cbFilePath);
+        HGCMSvcSetU32(&paParms[3], pFileHdr->fFlags);
+        HGCMSvcSetU32(&paParms[4], pFileHdr->fMode);
+        HGCMSvcSetU64(&paParms[5], pFileHdr->cbSize);
+
+        rc = VINF_SUCCESS;
+    }
+    else
+        rc = VERR_INVALID_PARAMETER;
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+/**
  * Reads an URI file data chunk from HGCM service parameters.
  *
@@ -227 +358 @@
 
         LogFlowFunc(("pvData=0x%p, cbData=%RU32\n", pFileData->pvData, pFileData->cbData));
+    }
+    else
+        rc = VERR_INVALID_PARAMETER;
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+/**
+ * Writes an URI file data chunk to HGCM service parameters.
+ *
+ * @returns VBox status code.
+ * @param   cParms              Number of HGCM parameters supplied in \a paParms.
+ * @param   paParms             Array of HGCM parameters.
+ * @param   pFileData           Pointer to data to write the the HGCM parameters.
+ */
+int VBoxSvcClipboardURIWriteFileData(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEDATA pFileData)
+{
+    int rc;
+
+    if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_READ_FILE_DATA)
+    {
+        /* Note: Context ID (paParms[0]) not used yet. */
+        HGCMSvcSetU32(&paParms[1], pFileData->cbData);
+        HGCMSvcSetPv (&paParms[2], pFileData->pvData, pFileData->cbData);
+        HGCMSvcSetU32(&paParms[3], pFileData->cbChecksum);
+        HGCMSvcSetPv (&paParms[4], pFileData->pvChecksum, pFileData->cbChecksum);
+
+        rc = VINF_SUCCESS;
     }
     else
@@ -293 +453 @@
     }
 
-    bool fDispatchToProvider = false; /* Whether to (also) dispatch the HGCM data to the transfer provider. */
+    bool fWriteToProvider = false; /* Whether to (also) dispatch the HGCM data to the transfer provider. */
 
     int rc = VERR_INVALID_PARAMETER; /* Play safe. */
@@ -597 +757 @@
     }
 
-    if (fDispatchToProvider)
+    if (fWriteToProvider)
         rc = VINF_SUCCESS;
 
     if (RT_SUCCESS(rc))
     {
-        if (fDispatchToProvider)
+        if (fWriteToProvider)
         {
             SHAREDCLIPBOARDPROVIDERWRITEPARMS writeParms;

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

@@ -128 +128 @@
  * @param   pCtx                Clipboard context to use.
  * @param   fFormat             Format to receive data in.
- * @param   uTimeoutMs          Timeout (in ms). Specify 0 if no waiting is required.
+ * @param   uTimeoutMs          Timeout (in ms) to wait until the render event has been triggered.
+ *                              Specify 0 if no waiting is required.
  */
 static int vboxClipboardWinRequestData(PVBOXCLIPBOARDCONTEXT pCtx, VBOXCLIPBOARDFORMAT fFormat,
@@ -328 +329 @@
                         {
                             rc = VBoxClipboardWinURIAnnounce(pWinCtx, &pCtx->pClientData->URI, pTransfer);
-                            if (RT_SUCCESS(rc))
-                            {
-                                rc = vboxClipboardWinRequestData(pCtx, fFormats, 0 /* Waiting not required */); /** FIX !!!!!!!!!!!! NEEDS TO GO INTO IDATAOBJECT GetData() !!!! */
-                            }
+
+                            /* Note: The actual requesting + retrieving of data will be done in the IDataObject implementation
+                                     (ClipboardDataObjectImpl::GetData()). */
                         }
                         else

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

@@ -638 +638 @@
                                         SHAREDCLIPBOARDPROVIDERCREATIONCTX creationCtx;
                                         RT_ZERO(creationCtx);
-                                        creationCtx.enmSource = SHAREDCLIPBOARDPROVIDERSOURCE_HOSTSERVICE;
+                                        creationCtx.enmSource = SHAREDCLIPBOARDURIPROVIDERSOURCE_HOSTSERVICE;
+                                        creationCtx.enmDir    = SHAREDCLIPBOARDURITRANSFERDIR_READ;
                                         creationCtx.u.HostService.pArea = pTransfer->pArea;