Changeset 78809 in vbox for trunk/src/VBox/GuestHost/SharedClipboard

Timestamp:

May 28, 2019 10:54:53 AM (6 years ago)

Author:

vboxsync

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

130905

Message:

Shared Clipboard/URI: Update.

Location:

trunk/src/VBox/GuestHost/SharedClipboard

Files:

• ClipboardDataObjectImpl-win.cpp (modified) (12 diffs)
• ClipboardEnumFormatEtcImpl-win.cpp (modified) (3 diffs)
• ClipboardProvider-HostService.cpp (added)
• ClipboardProvider-VbglR3.cpp (added)
• ClipboardProvider.cpp (modified) (3 diffs)
• ClipboardStreamImpl-win.cpp (modified) (12 diffs)
• ClipboardURIList.cpp (modified) (14 diffs)
• ClipboardURIObject.cpp (modified) (2 diffs)
• clipboard-win.cpp (modified) (1 diff)

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

@@ -42 +42 @@
 #include <VBox/log.h>
 
+#if 1 /** Not enabled yet, needs more testing first. */
+# define VBOX_CLIPBOARD_WITH_UNICODE_SUPPORT 1
+#endif
+
 VBoxClipboardWinDataObject::VBoxClipboardWinDataObject(SharedClipboardProvider *pProvider,
                                                        LPFORMATETC pFormatEtc, LPSTGMEDIUM pStgMed, ULONG cFormats)
@@ -48 +52 @@
     , m_cFormats(0)
     , m_pProvider(pProvider)
+    , m_pStream(NULL)
 {
     AssertPtr(pProvider);
@@ -53 +58 @@
     HRESULT hr;
 
-    const ULONG cFixedFormats = 3; /* CFSTR_FILEDESCRIPTORA + CFSTR_FILEDESCRIPTORW + CFSTR_FILECONTENTS */
+    ULONG cFixedFormats = 2; /* CFSTR_FILEDESCRIPTORA + CFSTR_FILECONTENTS */
+#ifdef VBOX_CLIPBOARD_WITH_UNICODE_SUPPORT
+    cFixedFormats++; /* CFSTR_FILEDESCRIPTORW */
+#endif
     const ULONG cAllFormats   = cFormats + cFixedFormats;
 
@@ -69 +77 @@
          */
 
-        /* IStream interface, implemented in ClipboardStreamImpl-win.cpp. */
+        LogFlowFunc(("Registering CFSTR_FILEDESCRIPTORA ...\n"));
         registerFormat(&m_pFormatEtc[FormatIndex_FileDescriptorA],
                        RegisterClipboardFormat(CFSTR_FILEDESCRIPTORA));
+#ifdef VBOX_CLIPBOARD_WITH_UNICODE_SUPPORT
+        LogFlowFunc(("Registering CFSTR_FILEDESCRIPTORW ...\n"));
         registerFormat(&m_pFormatEtc[FormatIndex_FileDescriptorW],
                        RegisterClipboardFormat(CFSTR_FILEDESCRIPTORW));
+#endif
+        /* IStream interface, implemented in ClipboardStreamImpl-win.cpp. */
+        LogFlowFunc(("Registering CFSTR_FILECONTENTS ...\n"));
         registerFormat(&m_pFormatEtc[FormatIndex_FileContents],
                        RegisterClipboardFormat(CFSTR_FILECONTENTS),
@@ -171 +184 @@
 }
 
+/**
+ * Copies a chunk of data into a HGLOBAL object.
+ *
+ * @returns VBox status code.
+ * @param   pvData              Data to copy.
+ * @param   cbData              Size (in bytes) to copy.
+ * @param   fFlags              GlobalAlloc flags, used for allocating the HGLOBAL block.
+ * @param   phGlobal            Where to store the allocated HGLOBAL object.
+ */
 int VBoxClipboardWinDataObject::copyToHGlobal(const void *pvData, size_t cbData, UINT fFlags, HGLOBAL *phGlobal)
 {
@@ -194 +216 @@
 }
 
-int VBoxClipboardWinDataObject::createFileGroupDescriptor(const SharedClipboardURIList &URIList,
-                                                          bool fUnicode, HGLOBAL *phGlobal)
-{
-//    AssertReturn(URIList.GetRootCount(), VERR_INVALID_PARAMETER);
-    AssertPtrReturn(phGlobal, VERR_INVALID_POINTER);
-
-    RT_NOREF(fUnicode);
-
-    int rc;
-
-    const size_t cItems = 2;  URIList.GetRootCount();
-    const size_t cbFGD  = sizeof(FILEGROUPDESCRIPTOR) + sizeof(FILEDESCRIPTOR) * (cItems - 1);
-
-    LogFunc(("cItmes=%zu\n", cItems));
-
+/**
+ * Creates a FILEGROUPDESCRIPTOR object from a given Shared Clipboard URI list and stores
+ * the result into an HGLOBAL object.
+ *
+ * @returns VBox status code.
+ * @param   URIList             URI list to create object 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);
+
+    LogFlowFuncEnter();
+
+    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 size_t cbFGD  = cbFileGroupDescriptor + (cbFileDescriptor * (cItems - 1));
+
+    LogFunc(("fUnicode=%RTbool, cItems=%u, cbFileDescriptor=%zu\n", fUnicode, cItems, cbFileDescriptor));
+
+    /* FILEGROUPDESCRIPTORA / FILEGROUPDESCRIPTOR matches except the cFileName member (TCHAR vs. WCHAR). */
     FILEGROUPDESCRIPTOR *pFGD = (FILEGROUPDESCRIPTOR *)RTMemAlloc(cbFGD);
-    if (pFGD)
-    {
-        pFGD->cItems = (UINT)cItems;
-
-
-        FILEDESCRIPTOR *pFD = &pFGD->fgd[0];
-        RT_BZERO(pFD, sizeof(FILEDESCRIPTOR));
-
-        RTStrPrintf(pFD->cFileName, sizeof(pFD->cFileName), "barbaz.txt\n");
-
-    #if 1
-        pFD->dwFlags          = FD_ATTRIBUTES | FD_FILESIZE | FD_PROGRESSUI;
-        pFD->dwFileAttributes = FILE_ATTRIBUTE_NORMAL; // FILE_ATTRIBUTE_DIRECTORY;
-
-        uint64_t cbSize = _1M;
-
-        pFD->nFileSizeHigh    = RT_HI_U32(cbSize);
-        pFD->nFileSizeLow     = RT_LO_U32(cbSize);
-    #else
-        pFD->dwFlags = FD_ATTRIBUTES | FD_CREATETIME | FD_ACCESSTIME | FD_WRITESTIME | FD_FILESIZE;
+    if (!pFGD)
+        return VERR_NO_MEMORY;
+
+    int rc = VINF_SUCCESS;
+
+    pFGD->cItems = cItems;
+
+    char *pszFileSpec = NULL;
+
+    for (UINT i = 0; i < cItems; i++)
+    {
+        FILEDESCRIPTOR *pFD = &pFGD->fgd[i];
+        RT_BZERO(pFD, cbFileDescriptor);
+
+        const SharedClipboardURIObject *pObj = URIList.At(i);
+        AssertPtr(pObj);
+        const char *pszFile = pObj->GetSourcePathAbs().c_str();
+        AssertPtr(pszFile);
+
+        pszFileSpec = RTStrDup(pszFile);
+        AssertBreakStmt(pszFileSpec != NULL, rc = VERR_NO_MEMORY);
+
+        if (fUnicode)
+        {
+            PRTUTF16 pwszFileSpec;
+            rc = RTStrToUtf16(pszFileSpec, &pwszFileSpec);
+            if (RT_SUCCESS(rc))
+            {
+                rc = RTUtf16CopyEx((PRTUTF16 )pFD->cFileName, sizeof(pFD->cFileName) / sizeof(WCHAR),
+                                   pwszFileSpec, RTUtf16Len(pwszFileSpec));
+                RTUtf16Free(pwszFileSpec);
+            }
+        }
+        else
+            rc = RTStrCopy(pFD->cFileName, sizeof(pFD->cFileName), pszFileSpec);
+
+        RTStrFree(pszFileSpec);
+        pszFileSpec = NULL;
+
+        if (RT_FAILURE(rc))
+            break;
+
+        pFD->dwFlags          = FD_PROGRESSUI | FD_ATTRIBUTES;
+        if (fUnicode) /** @todo Only >= Vista. */
+            pFD->dwFlags     |= FD_UNICODE;
+        pFD->dwFileAttributes = FILE_ATTRIBUTE_NORMAL;
+
+        switch (pObj->GetType())
+        {
+            case SharedClipboardURIObject::Type_Directory:
+                pFD->dwFileAttributes |= FILE_ATTRIBUTE_DIRECTORY;
+
+                LogFunc(("pszDir=%s\n", pszFile));
+                break;
+
+            case SharedClipboardURIObject::Type_File:
+            {
+                pFD->dwFlags |= FD_FILESIZE;
+
+                const uint64_t cbObjSize = pObj->GetSize();
+
+                pFD->nFileSizeHigh = RT_HI_U32(cbObjSize);
+                pFD->nFileSizeLow  = RT_LO_U32(cbObjSize);
+
+                LogFunc(("pszFile=%s, cbObjSize=%RU64\n", pszFile, cbObjSize));
+                break;
+            }
+
+            default:
+                AssertFailed();
+                break;
+        }
+#if 0
+        pFD->dwFlags = FD_ATTRIBUTES | FD_CREATETIME | FD_ACCESSTIME | FD_WRITESTIME | FD_FILESIZE; /** @todo Implement this. */
         pFD->dwFileAttributes =
         pFD->ftCreationTime   =
         pFD->ftLastAccessTime =
         pFD->ftLastWriteTime  =
-        pFD->nFileSizeHigh    =
-        pFD->nFileSizeLow     =
-    #endif
-
-
-
-        pFD = &pFGD->fgd[1];
-        RT_BZERO(pFD, sizeof(FILEDESCRIPTOR));
-
-        RTStrPrintf(pFD->cFileName, sizeof(pFD->cFileName), "barbaz_dir\n");
-
-    #if 1
-        pFD->dwFlags          = FD_ATTRIBUTES | FD_PROGRESSUI;
-        pFD->dwFileAttributes = FILE_ATTRIBUTE_NORMAL | FILE_ATTRIBUTE_DIRECTORY;
-    #else
-        pFD->dwFlags = FD_ATTRIBUTES | FD_CREATETIME | FD_ACCESSTIME | FD_WRITESTIME | FD_FILESIZE;
-        pFD->dwFileAttributes =
-        pFD->ftCreationTime   =
-        pFD->ftLastAccessTime =
-        pFD->ftLastWriteTime  =
-        pFD->nFileSizeHigh    =
-        pFD->nFileSizeLow     =
-    #endif
-
-
+#endif
+    }
+
+    if (pszFileSpec)
+        RTStrFree(pszFileSpec);
+
+    if (RT_SUCCESS(rc))
+    {
         rc = copyToHGlobal(pFGD, cbFGD, GMEM_MOVEABLE, phGlobal);
     }
     else
-        rc = VERR_NO_MEMORY;
-
+    {
+        RTMemFree(pFGD);
+    }
+
+    LogFlowFuncLeaveRC(rc);
     return rc;
 }
@@ -312 +385 @@
     {
         case FormatIndex_FileDescriptorA: /* ANSI */
+#ifdef VBOX_CLIPBOARD_WITH_UNICODE_SUPPORT
+            RT_FALL_THROUGH();
         case FormatIndex_FileDescriptorW: /* Unicode */
+#endif
         {
             const bool fUnicode = lIndex == FormatIndex_FileDescriptorW;
@@ -319 +395 @@
 
             SharedClipboardURIList uriList;
-            int rc = m_pProvider->ReadMetaData(uriList, 0 /* fFlags */);
-            if (RT_SUCCESS(rc))
+            int rc = m_pProvider->ReadMetaData(uriList); /** @todo Do this asynchronously some time earlier? */
+
+#if 0
+    SharedClipboardURIObject *pObj1 = new SharedClipboardURIObject(SharedClipboardURIObject::Type_File, "foobar.baz1");
+    pObj1->SetSize(_64M);
+    uriList.AppendURIObject(pObj1);
+#endif
+
+            if (   RT_SUCCESS(rc)
+                && !uriList.IsEmpty())
             {
                 HGLOBAL hGlobal;
-                rc = createFileGroupDescriptor(uriList, fUnicode, &hGlobal);
+                rc = createFileGroupDescriptorFromURIList(uriList, fUnicode, &hGlobal);
                 if (RT_SUCCESS(rc))
                 {
+                    LogFlowFunc(("FOO1\n"));
+
                     pMedium->tymed   = TYMED_HGLOBAL;
                     pMedium->hGlobal = hGlobal;
                     /* Note: hGlobal now is being owned by pMedium / the caller. */
 
+                    LogFlowFunc(("FOO2\n"));
                     hr = S_OK;
                 }
             }
+            LogFlowFunc(("FOO2.1\n"));
             break;
         }
@@ -340 +428 @@
             LogFlowFunc(("FormatIndex_FileContents\n"));
 
+            /* Hand-in the provider so that our IStream implementation can continue working with it. */
             hr = VBoxClipboardWinStreamImpl::Create(m_pProvider, &m_pStream);
             if (SUCCEEDED(hr))
             {
                 /* Hand over the stream to the caller. */
-                pMedium->tymed          = TYMED_ISTREAM;
-                pMedium->pstm           = m_pStream;
+                pMedium->tymed = TYMED_ISTREAM;
+                pMedium->pstm  = m_pStream;
             }
 
@@ -355 +444 @@
     }
 
+    LogFlowFunc(("FOO3\n"));
+
     /* Error handling; at least return some basic data. */
     if (FAILED(hr))
@@ -364 +455 @@
     }
 
+LogFlowFunc(("FOO4\n"));
+
     if (hr == DV_E_FORMATETC)
         LogRel(("Clipboard: Error handling format\n"));
+
+LogFlowFunc(("FOO5\n"));
 
     LogFlowFunc(("hr=%Rhrc\n", hr));
@@ -586 +681 @@
     {
         if(    (pFormatEtc->tymed & m_pFormatEtc[i].tymed)
-            && pFormatEtc->cfFormat == m_pFormatEtc[i].cfFormat
-            && pFormatEtc->dwAspect == m_pFormatEtc[i].dwAspect)
+            && pFormatEtc->cfFormat == m_pFormatEtc[i].cfFormat)
+            /* Note: Do *not* compare dwAspect here, as this can be dynamic, depending on how the object should be represented. */
+            //&& pFormatEtc->dwAspect == m_pFormatEtc[i].dwAspect)
         {
             LogRel3(("Clipboard: Format found: tyMed=%RI32, cfFormat=%RI16, sFormats=%s, dwAspect=%RI32, ulIndex=%RU32\n",

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

@@ -92 +92 @@
     if (lCount == 0)
     {
+        LogFlowFunc(("Delete\n"));
         delete this;
         return 0;
@@ -123 +124 @@
            && ulCopied < cFormats)
     {
-        VBoxClipboardWinEnumFormatEtc::CopyFormat(&pFormatEtc[ulCopied],
-                                         &m_pFormatEtc[m_nIndex]);
+        VBoxClipboardWinEnumFormatEtc::CopyFormat(&pFormatEtc[ulCopied], &m_pFormatEtc[m_nIndex]);
         ulCopied++;
         m_nIndex++;
@@ -149 +149 @@
 STDMETHODIMP VBoxClipboardWinEnumFormatEtc::Clone(IEnumFORMATETC **ppEnumFormatEtc)
 {
-    HRESULT hResult =
-        CreateEnumFormatEtc(m_nNumFormats, m_pFormatEtc, ppEnumFormatEtc);
-
+    HRESULT hResult = CreateEnumFormatEtc(m_nNumFormats, m_pFormatEtc, ppEnumFormatEtc);
     if (hResult == S_OK)
         ((VBoxClipboardWinEnumFormatEtc *) *ppEnumFormatEtc)->m_nIndex = m_nIndex;

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

@@ -34 +34 @@
 #include <VBox/log.h>
 
+
+
 SharedClipboardProvider::SharedClipboardProvider(void)
     : m_cRefs(0)
 {
+    LogFlowFuncEnter();
 }
 
 SharedClipboardProvider::~SharedClipboardProvider(void)
 {
+    LogFlowFuncEnter();
     Assert(m_cRefs == 0);
+}
+
+/**
+ * Creates a Shared Clipboard provider.
+ *
+ * @returns New Shared Clipboard provider instance.
+ * @param   enmSource           Source type to create provider for.
+ */
+/* static */
+SharedClipboardProvider *SharedClipboardProvider::Create(SourceType enmSource)
+{
+    SharedClipboardProvider *pProvider = NULL;
+
+    switch (enmSource)
+    {
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_GUEST
+        case SourceType_VbglR3:
+            pProvider = new SharedClipboardProviderVbglR3();
+            break;
+#endif
+
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_HOST
+        case SourceType_HostService:
+            pProvider = new SharedClipboardProviderHostService();
+            break;
+#endif
+        default:
+            AssertFailed();
+            break;
+    }
+
+    return pProvider;
 }
 
@@ -51 +87 @@
 uint32_t SharedClipboardProvider::AddRef(void)
 {
+    LogFlowFuncEnter();
     return ASMAtomicIncU32(&m_cRefs);
 }
@@ -61 +98 @@
 uint32_t SharedClipboardProvider::Release(void)
 {
+    LogFlowFuncEnter();
     Assert(m_cRefs);
     return ASMAtomicDecU32(&m_cRefs);
 }
 
-int SharedClipboardProvider::SetSource(SourceType enmSource)
-{
-    return m_enmSource = enmSource;
-}
-
-int SharedClipboardProvider::ReadMetaData(SharedClipboardURIList &URIList, uint32_t fFlags /* = 0 */)
-{
-    int rc = VINF_SUCCESS;
-
-    RT_NOREF(URIList, fFlags);
-
-    return rc;
-}
-

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

@@ -50 +50 @@
     , m_pProvider(pProvider)
 {
+    LogFlowThisFuncEnter();
+
     m_pProvider->AddRef();
+
+    cbFileSize = _64M;
+    cbSizeRead = 0;
 }
 
 VBoxClipboardWinStreamImpl::~VBoxClipboardWinStreamImpl(void)
 {
+    LogFlowThisFuncEnter();
     m_pProvider->Release();
 }
@@ -114 +120 @@
     RT_NOREF(dwFrags);
 
-    LogFlowFuncEnter();
+    LogFlowThisFuncEnter();
     return E_NOTIMPL;
 }
@@ -123 +129 @@
     RT_NOREF(pDestStream, nBytesToCopy, nBytesRead, nBytesWritten);
 
-    LogFlowFuncEnter();
+    LogFlowThisFuncEnter();
     return E_NOTIMPL;
 }
@@ -131 +137 @@
     RT_NOREF(nStart, nBytes, dwFlags);
 
-    LogFlowFuncEnter();
-    return E_NOTIMPL;
-}
-
-static ULONG cbFileSize = _1M;
-static ULONG cbSizeRead = 0;
+    LogFlowThisFuncEnter();
+    return E_NOTIMPL;
+}
 
 STDMETHODIMP VBoxClipboardWinStreamImpl::Read(void* pvBuffer, ULONG nBytesToRead, ULONG* nBytesRead)
@@ -142 +145 @@
     /* If the file size is 0, already return at least 1 byte, else the whole operation will fail. */
 
-    ULONG cbToRead = RT_MIN(cbFileSize - cbSizeRead,  _4K /* nBytesToRead */);
-
-    if (cbToRead > nBytesToRead)
-        cbToRead = nBytesToRead;
-
-    LogFlowFunc(("pvBuffer=%p, nBytesToRead=%u -> cbSizeRead=%u, cbToRead=%u\n", pvBuffer, nBytesToRead, cbSizeRead, cbToRead));
-
-    if (cbToRead)
-    {
-        memset(pvBuffer, cbToRead, 0x65);
-        cbSizeRead += cbToRead;
-    }
-
-    if (nBytesRead)
-        *nBytesRead = cbToRead;
-
-    if (cbSizeRead == cbFileSize)
-        cbSizeRead = 0;
-
+    size_t cbRead = 0;
+    int rc = m_pProvider->ReadData(pvBuffer, (size_t)nBytesToRead, &cbRead);
+    if (RT_SUCCESS(rc))
+    {
+        if (*nBytesRead)
+            *nBytesRead = (ULONG)cbRead;
+    }
+
+    LogFlowThisFunc(("nBytesToRead=%u, nBytesRead=%zu\n", nBytesToRead, cbRead));
     return S_OK;
 }
@@ -166 +159 @@
 STDMETHODIMP VBoxClipboardWinStreamImpl::Revert(void)
 {
-    LogFlowFuncEnter();
+    LogFlowThisFuncEnter();
     return E_NOTIMPL;
 }
@@ -174 +167 @@
     RT_NOREF(nMove, dwOrigin, nNewPos);
 
-    LogFlowFuncEnter();
+    LogFlowThisFuncEnter();
     return E_NOTIMPL;
 }
@@ -182 +175 @@
     RT_NOREF(nNewSize);
 
-    LogFlowFuncEnter();
+    LogFlowThisFuncEnter();
     return E_NOTIMPL;
 }
@@ -190 +183 @@
     RT_NOREF(statstg, dwFlags);
 
-    LogFlowFuncEnter();
+    LogFlowThisFuncEnter();
     return E_NOTIMPL;
 }
@@ -198 +191 @@
     RT_NOREF(nStart, nBytes, dwFlags);
 
-    LogFlowFuncEnter();
+    LogFlowThisFuncEnter();
     return E_NOTIMPL;
 }
@@ -206 +199 @@
     RT_NOREF(pvBuffer, nBytesToRead, nBytesRead);
 
-    LogFlowFuncEnter();
+    LogFlowThisFuncEnter();
     return E_NOTIMPL;
 }
@@ -224 +217 @@
 HRESULT VBoxClipboardWinStreamImpl::Create(SharedClipboardProvider *pProvider, IStream **ppStream)
 {
+    AssertPtrReturn(pProvider, E_POINTER);
+
     VBoxClipboardWinStreamImpl *pStream = new VBoxClipboardWinStreamImpl(pProvider);
     if (pStream)

trunk/src/VBox/GuestHost/SharedClipboard/ClipboardURIList.cpp

@@ -46 +46 @@
 }
 
-int SharedClipboardURIList::addEntry(const char *pcszSource, const char *pcszTarget, SHAREDCLIPBOARDURILISTFLAGS fFlags)
+int SharedClipboardURIList::appendEntry(const char *pcszSource, const char *pcszTarget, SHAREDCLIPBOARDURILISTFLAGS fFlags)
 {
     AssertPtrReturn(pcszSource, VERR_INVALID_POINTER);
@@ -57 +57 @@
     if (RT_SUCCESS(rc))
     {
-        if (RTFS_IS_FILE(objInfo.Attr.fMode))
-        {
-            LogFlowFunc(("File '%s' -> '%s' (%RU64 bytes, file mode 0x%x)\n",
-                         pcszSource, pcszTarget, (uint64_t)objInfo.cbObject, objInfo.Attr.fMode));
-
-            SharedClipboardURIObject *pObjFile = new SharedClipboardURIObject(SharedClipboardURIObject::Type_File,
-                                                                              pcszSource, pcszTarget);
-            if (pObjFile)
-            {
-                /** @todo Add a standard fOpen mode for this list. */
-                rc = pObjFile->Open(SharedClipboardURIObject::View_Source, RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_WRITE);
-                if (RT_SUCCESS(rc))
-                {
-                    m_lstTree.append(pObjFile);
-
+        try
+        {
+            if (RTFS_IS_FILE(objInfo.Attr.fMode))
+            {
+                LogFlowFunc(("File '%s' -> '%s' (%RU64 bytes, file mode 0x%x)\n",
+                             pcszSource, pcszTarget, (uint64_t)objInfo.cbObject, objInfo.Attr.fMode));
+
+                SharedClipboardURIObject *pObjFile = new SharedClipboardURIObject(SharedClipboardURIObject::Type_File,
+                                                                                  pcszSource, pcszTarget);
+                if (pObjFile)
+                {
+                    /** @todo Add a standard fOpen mode for this list. */
+                    rc = pObjFile->Open(SharedClipboardURIObject::View_Source, RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_WRITE);
+                    if (RT_SUCCESS(rc))
+                    {
+                        rc = appendObject(pObjFile);
+                        if (!(fFlags & SHAREDCLIPBOARDURILIST_FLAGS_KEEP_OPEN)) /* Shall we keep the file open while being added to this list? */
+                            pObjFile->Close();
+                    }
+                    else
+                        delete pObjFile;
+                }
+                else
+                    rc = VERR_NO_MEMORY;
+            }
+            else if (RTFS_IS_DIRECTORY(objInfo.Attr.fMode))
+            {
+                LogFlowFunc(("Directory '%s' -> '%s' (file mode 0x%x)\n", pcszSource, pcszTarget, objInfo.Attr.fMode));
+
+                SharedClipboardURIObject *pObjDir = new SharedClipboardURIObject(SharedClipboardURIObject::Type_Directory,
+                                                                                 pcszSource, pcszTarget);
+                if (pObjDir)
+                {
+                    m_lstTree.append(pObjDir);
+
+                    /** @todo Add SHAREDCLIPBOARDURILIST_FLAGS_KEEP_OPEN handling? */
                     m_cTotal++;
-                    m_cbTotal += pObjFile->GetSize();
-
-                    if (!(fFlags & SHAREDCLIPBOARDURILIST_FLAGS_KEEP_OPEN)) /* Shall we keep the file open while being added to this list? */
-                        pObjFile->Close();
                 }
                 else
-                    delete pObjFile;
-            }
+                    rc = VERR_NO_MEMORY;
+            }
+            /* Note: Symlinks already should have been resolved at this point. */
             else
-                rc = VERR_NO_MEMORY;
-        }
-        else if (RTFS_IS_DIRECTORY(objInfo.Attr.fMode))
-        {
-            LogFlowFunc(("Directory '%s' -> '%s' (file mode 0x%x)\n", pcszSource, pcszTarget, objInfo.Attr.fMode));
-
-            SharedClipboardURIObject *pObjDir = new SharedClipboardURIObject(SharedClipboardURIObject::Type_Directory,
-                                                                             pcszSource, pcszTarget);
-            if (pObjDir)
-            {
-                m_lstTree.append(pObjDir);
-
-                /** @todo Add SHAREDCLIPBOARDURILIST_FLAGS_KEEP_OPEN handling? */
-                m_cTotal++;
-            }
-            else
-                rc = VERR_NO_MEMORY;
-        }
-        /* Note: Symlinks already should have been resolved at this point. */
-        else
-            rc = VERR_NOT_SUPPORTED;
+                rc = VERR_NOT_SUPPORTED;
+        }
+        catch (std::bad_alloc &)
+        {
+            rc = VERR_NO_MEMORY;
+        }
     }
 
@@ -126 +129 @@
         if (RTFS_IS_DIRECTORY(objInfo.Attr.fMode))
         {
-            rc = addEntry(pcszSrcPath, &pcszDstPath[cchDstBase], fFlags);
+            rc = appendEntry(pcszSrcPath, &pcszDstPath[cchDstBase], fFlags);
             if (RT_SUCCESS(rc))
             {
@@ -181 +184 @@
                                     if (pszDst)
                                     {
-                                        rc = addEntry(pszSrc, &pszDst[cchDstBase], fFlags);
+                                        rc = appendEntry(pszSrc, &pszDst[cchDstBase], fFlags);
                                         RTStrFree(pszDst);
                                     }
@@ -210 +213 @@
                                             {
                                                 LogFlowFunc(("Directory entry is symlink to file\n"));
-                                                rc = addEntry(pszSrc, &pcszDstPath[cchDstBase], fFlags);
+                                                rc = appendEntry(pszSrc, &pcszDstPath[cchDstBase], fFlags);
                                             }
                                             else
@@ -237 +240 @@
         else if (RTFS_IS_FILE(objInfo.Attr.fMode))
         {
-            rc = addEntry(pcszSrcPath, &pcszDstPath[cchDstBase], fFlags);
+            rc = appendEntry(pcszSrcPath, &pcszDstPath[cchDstBase], fFlags);
         }
         else if (RTFS_IS_SYMLINK(objInfo.Attr.fMode))
@@ -257 +260 @@
                         {
                             LogFlowFunc(("Symlink to file\n"));
-                            rc = addEntry(pszSrc, &pcszDstPath[cchDstBase], fFlags);
+                            rc = appendEntry(pszSrc, &pcszDstPath[cchDstBase], fFlags);
                         }
                         else
@@ -277 +280 @@
 }
 
+int SharedClipboardURIList::appendObject(SharedClipboardURIObject *pObject)
+{
+    int rc;
+
+    try
+    {
+        m_lstTree.append(pObject);
+        m_lstRoot.append(pObject->GetSourcePathAbs());;
+
+        m_cTotal++;
+        m_cbTotal += pObject->GetSize();
+
+        rc = VINF_SUCCESS;
+    }
+    catch (std::bad_alloc &)
+    {
+        rc = VERR_NO_MEMORY;
+    }
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
 int SharedClipboardURIList::AppendNativePath(const char *pszPath, SHAREDCLIPBOARDURILISTFLAGS fFlags)
 {
@@ -331 +357 @@
     LogFlowFuncLeaveRC(rc);
     return rc;
+}
+
+int SharedClipboardURIList::AppendURIObject(SharedClipboardURIObject *pObject)
+{
+    AssertPtrReturn(pObject, VERR_INVALID_POINTER);
+
+    return appendObject(pObject);
 }
 
@@ -386 +419 @@
                                   : pszFileName - pszSrcPath;
                 char *pszDstPath = &pszSrcPath[cchDstBase];
-                m_lstRoot.append(pszDstPath);
-
-                LogFlowFunc(("pszSrcPath=%s, pszFileName=%s, pszRoot=%s\n",
-                             pszSrcPath, pszFileName, pszDstPath));
-
-                rc = appendPathRecursive(pszSrcPath, pszSrcPath, pszSrcPath, cchDstBase, fFlags);
+
+                try
+                {
+                    m_lstRoot.append(pszDstPath);
+
+                    LogFlowFunc(("pszSrcPath=%s, pszFileName=%s, pszRoot=%s\n", pszSrcPath, pszFileName, pszDstPath));
+                    rc = appendPathRecursive(pszSrcPath, pszSrcPath, pszSrcPath, cchDstBase, fFlags);
+                }
+                catch (std::bad_alloc &)
+                {
+                    rc = VERR_NO_MEMORY;
+                }
             }
             else
@@ -437 +476 @@
 void SharedClipboardURIList::Clear(void)
 {
+    LogFlowThisFuncEnter();
+
     m_lstRoot.clear();
 
@@ -443 +484 @@
         SharedClipboardURIObject *pCurObj = m_lstTree.at(i);
         AssertPtr(pCurObj);
-        RTMemFree(pCurObj);
-    }
+        delete pCurObj;
+    }
+
     m_lstTree.clear();
 
     m_cTotal  = 0;
     m_cbTotal = 0;
+
+    LogFlowThisFuncLeave();
 }
 
@@ -464 +508 @@
 
     pCurObj->Close();
-    RTMemFree(pCurObj);
+    delete pCurObj;
 
     m_lstTree.removeFirst();
@@ -499 +543 @@
             if (RT_SUCCESS(rc))
             {
-                m_lstRoot.append(pszFilePath);
-                m_cTotal++;
+                try
+                {
+                    m_lstRoot.append(pszFilePath);
+                    m_cTotal++;
+                }
+                catch (std::bad_alloc &)
+                {
+                    rc = VERR_NO_MEMORY;
+                }
             }
 

trunk/src/VBox/GuestHost/SharedClipboard/ClipboardURIObject.cpp

@@ -86 +86 @@
         case Type_File:
         {
-            RTFileClose(u.File.hFile);
-            u.File.hFile = NIL_RTFILE;
+            if (RTFileIsValid(u.File.hFile))
+            {
+                RTFileClose(u.File.hFile);
+                u.File.hFile = NIL_RTFILE;
+            }
             RT_ZERO(u.File.objInfo);
             break;
@@ -94 +97 @@
         case Type_Directory:
         {
-            RTDirClose(u.Dir.hDir);
-            u.Dir.hDir = NIL_RTDIR;
+            if (RTDirIsValid(u.Dir.hDir))
+            {
+                RTDirClose(u.Dir.hDir);
+                u.Dir.hDir = NIL_RTDIR;
+            }
             RT_ZERO(u.Dir.objInfo);
             break;

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

@@ -743 +743 @@
     return rc;
 }
+
+/**
+ * Initializes a Windows-specific URI clipboard information struct.
+ *
+ * @returns VBox status code.
+ * @param   pURI                URI clipboard information struct to initialize.
+ * @param   enmType             What type of clipboard provider to use.
+ */
+int VBoxClipboardWinURIInit(PVBOXCLIPBOARDWINURI pURI, SharedClipboardProvider::SourceType enmType)
+{
+    LogFlowFuncEnter();
+
+    pURI->Transfer.pProvider = SharedClipboardProvider::Create(enmType);
+    if (!pURI->Transfer.pProvider)
+        return VERR_NO_MEMORY;
+
+    VBoxClipboardWinURIReset(pURI);
+
+    return VINF_SUCCESS;
+}
+
+/**
+ * Destroys a Windows-specific URI clipboard information struct.
+ *
+ * @param   pURI                URI clipboard information struct to destroy.
+ */
+void VBoxClipboardWinURIDestroy(PVBOXCLIPBOARDWINURI pURI)
+{
+    LogFlowFuncEnter();
+
+    if (pURI->Transfer.pProvider)
+    {
+        delete pURI->Transfer.pProvider;
+        pURI->Transfer.pProvider = NULL;
+    }
+}
+
+/**
+ * Resets a Windows-specific URI clipboard information struct.
+ *
+ * @param   pURI                URI clipboard information struct to reset.
+ */
+void VBoxClipboardWinURIReset(PVBOXCLIPBOARDWINURI pURI)
+{
+    LogFlowFuncEnter();
+
+    pURI->cTransfers = 0;
+
+    if (pURI->Transfer.pProvider)
+        pURI->Transfer.pProvider->Reset();
+}
 #endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */