diff options
Diffstat (limited to 'src/VBox/GuestHost/SharedClipboard')
16 files changed, 11935 insertions, 0 deletions
diff --git a/src/VBox/GuestHost/SharedClipboard/ClipboardDataObjectImpl-win.cpp b/src/VBox/GuestHost/SharedClipboard/ClipboardDataObjectImpl-win.cpp new file mode 100644 index 00000000..fc462109 --- /dev/null +++ b/src/VBox/GuestHost/SharedClipboard/ClipboardDataObjectImpl-win.cpp @@ -0,0 +1,978 @@ +/* $Id: ClipboardDataObjectImpl-win.cpp $ */ +/** @file + * ClipboardDataObjectImpl-win.cpp - Shared Clipboard IDataObject implementation. + */ + +/* + * Copyright (C) 2019-2022 Oracle and/or its affiliates. + * + * This file is part of VirtualBox base platform packages, as + * available from https://www.virtualbox.org. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, in version 3 of the + * License. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <https://www.gnu.org/licenses>. + * + * SPDX-License-Identifier: GPL-3.0-only + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP LOG_GROUP_SHARED_CLIPBOARD +#include <VBox/GuestHost/SharedClipboard-win.h> +#include <VBox/GuestHost/SharedClipboard-transfers.h> + +#include <iprt/win/windows.h> +#include <iprt/win/shlobj.h> +#include <iprt/win/shlwapi.h> + +#include <iprt/asm.h> +#include <iprt/err.h> +#include <iprt/path.h> +#include <iprt/semaphore.h> +#include <iprt/uri.h> +#include <iprt/utf16.h> + +#include <iprt/errcore.h> +#include <VBox/log.h> + +/** @todo Also handle Unicode entries. + * !!! WARNING: Buggy, doesn't work yet (some memory corruption / garbage in the file name descriptions) !!! */ +//#define VBOX_CLIPBOARD_WITH_UNICODE_SUPPORT 1 + +SharedClipboardWinDataObject::SharedClipboardWinDataObject(PSHCLTRANSFER pTransfer, + LPFORMATETC pFormatEtc, LPSTGMEDIUM pStgMed, ULONG cFormats) + : m_enmStatus(Uninitialized) + , m_lRefCount(0) + , m_cFormats(0) + , m_pTransfer(pTransfer) + , m_pStream(NULL) + , m_uObjIdx(0) + , m_fRunning(false) + , m_EventListComplete(NIL_RTSEMEVENT) + , m_EventTransferComplete(NIL_RTSEMEVENT) +{ + AssertPtr(m_pTransfer); + + HRESULT hr; + + ULONG cFixedFormats = 3; /* CFSTR_FILEDESCRIPTORA + CFSTR_FILECONTENTS + CFSTR_PERFORMEDDROPEFFECT */ +#ifdef VBOX_CLIPBOARD_WITH_UNICODE_SUPPORT + cFixedFormats++; /* CFSTR_FILEDESCRIPTORW */ +#endif + const ULONG cAllFormats = cFormats + cFixedFormats; + + try + { + m_pFormatEtc = new FORMATETC[cAllFormats]; + RT_BZERO(m_pFormatEtc, sizeof(FORMATETC) * cAllFormats); + m_pStgMedium = new STGMEDIUM[cAllFormats]; + RT_BZERO(m_pStgMedium, sizeof(STGMEDIUM) * cAllFormats); + + /** @todo Do we need CFSTR_FILENAME / CFSTR_SHELLIDLIST here? */ + + /* + * Register fixed formats. + */ + unsigned uIdx = 0; + + LogFlowFunc(("Registering CFSTR_FILEDESCRIPTORA ...\n")); + m_cfFileDescriptorA = RegisterClipboardFormat(CFSTR_FILEDESCRIPTORA); + registerFormat(&m_pFormatEtc[uIdx++], m_cfFileDescriptorA); +#ifdef VBOX_CLIPBOARD_WITH_UNICODE_SUPPORT + LogFlowFunc(("Registering CFSTR_FILEDESCRIPTORW ...\n")); + m_cfFileDescriptorW = RegisterClipboardFormat(CFSTR_FILEDESCRIPTORW); + registerFormat(&m_pFormatEtc[uIdx++], m_cfFileDescriptorW); +#endif + + /* IStream interface, implemented in ClipboardStreamImpl-win.cpp. */ + LogFlowFunc(("Registering CFSTR_FILECONTENTS ...\n")); + m_cfFileContents = RegisterClipboardFormat(CFSTR_FILECONTENTS); + registerFormat(&m_pFormatEtc[uIdx++], m_cfFileContents, TYMED_ISTREAM, 0 /* lIndex */); + + /* We want to know from the target what the outcome of the operation was to react accordingly (e.g. abort a transfer). */ + LogFlowFunc(("Registering CFSTR_PERFORMEDDROPEFFECT ...\n")); + m_cfPerformedDropEffect = RegisterClipboardFormat(CFSTR_PERFORMEDDROPEFFECT); + registerFormat(&m_pFormatEtc[uIdx++], m_cfPerformedDropEffect, TYMED_HGLOBAL, -1 /* lIndex */, DVASPECT_CONTENT); + + /* + * Registration of dynamic formats needed? + */ + LogFlowFunc(("%RU32 dynamic formats\n", cFormats)); + if (cFormats) + { + AssertPtr(pFormatEtc); + AssertPtr(pStgMed); + + for (ULONG i = 0; i < cFormats; i++) + { + LogFlowFunc(("Format %RU32: cfFormat=%RI16, tyMed=%RU32, dwAspect=%RU32\n", + i, pFormatEtc[i].cfFormat, pFormatEtc[i].tymed, pFormatEtc[i].dwAspect)); + m_pFormatEtc[cFixedFormats + i] = pFormatEtc[i]; + m_pStgMedium[cFixedFormats + i] = pStgMed[i]; + } + } + + hr = S_OK; + } + catch (std::bad_alloc &) + { + hr = E_OUTOFMEMORY; + } + + if (SUCCEEDED(hr)) + { + m_cFormats = cAllFormats; + m_enmStatus = Initialized; + + int rc2 = RTSemEventCreate(&m_EventListComplete); + AssertRC(rc2); + rc2 = RTSemEventCreate(&m_EventTransferComplete); + AssertRC(rc2); + } + + LogFlowFunc(("cAllFormats=%RU32, hr=%Rhrc\n", cAllFormats, hr)); +} + +SharedClipboardWinDataObject::~SharedClipboardWinDataObject(void) +{ + LogFlowFuncEnter(); + + RTSemEventDestroy(m_EventListComplete); + m_EventListComplete = NIL_RTSEMEVENT; + + RTSemEventDestroy(m_EventTransferComplete); + m_EventTransferComplete = NIL_RTSEMEVENT; + + if (m_pStream) + m_pStream->Release(); + + if (m_pFormatEtc) + delete[] m_pFormatEtc; + + if (m_pStgMedium) + delete[] m_pStgMedium; + + LogFlowFunc(("mRefCount=%RI32\n", m_lRefCount)); +} + +/* + * IUnknown methods. + */ + +STDMETHODIMP_(ULONG) SharedClipboardWinDataObject::AddRef(void) +{ + LONG lCount = InterlockedIncrement(&m_lRefCount); + LogFlowFunc(("lCount=%RI32\n", lCount)); + return lCount; +} + +STDMETHODIMP_(ULONG) SharedClipboardWinDataObject::Release(void) +{ + LONG lCount = InterlockedDecrement(&m_lRefCount); + LogFlowFunc(("lCount=%RI32\n", m_lRefCount)); + if (lCount == 0) + { + delete this; + return 0; + } + + return lCount; +} + +STDMETHODIMP SharedClipboardWinDataObject::QueryInterface(REFIID iid, void **ppvObject) +{ + AssertPtrReturn(ppvObject, E_INVALIDARG); + + if ( iid == IID_IDataObject + || iid == IID_IUnknown) + { + AddRef(); + *ppvObject = this; + return S_OK; + } + + *ppvObject = 0; + return E_NOINTERFACE; +} + +/** + * 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 SharedClipboardWinDataObject::copyToHGlobal(const void *pvData, size_t cbData, UINT fFlags, HGLOBAL *phGlobal) +{ + AssertPtrReturn(phGlobal, VERR_INVALID_POINTER); + + HGLOBAL hGlobal = GlobalAlloc(fFlags, cbData); + if (!hGlobal) + return VERR_NO_MEMORY; + + void *pvAlloc = GlobalLock(hGlobal); + if (pvAlloc) + { + CopyMemory(pvAlloc, pvData, cbData); + GlobalUnlock(hGlobal); + + *phGlobal = hGlobal; + + return VINF_SUCCESS; + } + + GlobalFree(hGlobal); + return VERR_ACCESS_DENIED; +} + +/** + * Reads (handles) a specific directory reursively and inserts its entry into the + * objects's entry list. + * + * @returns VBox status code. + * @param pTransfer Shared Clipboard transfer object to handle. + * @param strDir Directory path to handle. + */ +int SharedClipboardWinDataObject::readDir(PSHCLTRANSFER pTransfer, const Utf8Str &strDir) +{ + LogFlowFunc(("strDir=%s\n", strDir.c_str())); + + SHCLLISTOPENPARMS openParmsList; + int rc = ShClTransferListOpenParmsInit(&openParmsList); + if (RT_SUCCESS(rc)) + { + rc = RTStrCopy(openParmsList.pszPath, openParmsList.cbPath, strDir.c_str()); + if (RT_SUCCESS(rc)) + { + SHCLLISTHANDLE hList; + rc = ShClTransferListOpen(pTransfer, &openParmsList, &hList); + if (RT_SUCCESS(rc)) + { + LogFlowFunc(("strDir=%s -> hList=%RU64\n", strDir.c_str(), hList)); + + SHCLLISTHDR hdrList; + rc = ShClTransferListGetHeader(pTransfer, hList, &hdrList); + if (RT_SUCCESS(rc)) + { + LogFlowFunc(("cTotalObjects=%RU64, cbTotalSize=%RU64\n\n", + hdrList.cTotalObjects, hdrList.cbTotalSize)); + + for (uint64_t o = 0; o < hdrList.cTotalObjects; o++) + { + SHCLLISTENTRY entryList; + rc = ShClTransferListEntryInit(&entryList); + if (RT_SUCCESS(rc)) + { + rc = ShClTransferListRead(pTransfer, hList, &entryList); + if (RT_SUCCESS(rc)) + { + if (ShClTransferListEntryIsValid(&entryList)) + { + PSHCLFSOBJINFO pFsObjInfo = (PSHCLFSOBJINFO)entryList.pvInfo; + Assert(entryList.cbInfo == sizeof(SHCLFSOBJINFO)); + + Utf8Str strPath = strDir + Utf8Str("\\") + Utf8Str(entryList.pszName); + + LogFlowFunc(("\t%s (%RU64 bytes) -> %s\n", + entryList.pszName, pFsObjInfo->cbObject, strPath.c_str())); + + if (RTFS_IS_DIRECTORY(pFsObjInfo->Attr.fMode)) + { + FSOBJENTRY objEntry = { strPath.c_str(), *pFsObjInfo }; + + m_lstEntries.push_back(objEntry); /** @todo Can this throw? */ + + rc = readDir(pTransfer, strPath.c_str()); + } + else if (RTFS_IS_FILE(pFsObjInfo->Attr.fMode)) + { + FSOBJENTRY objEntry = { strPath.c_str(), *pFsObjInfo }; + + m_lstEntries.push_back(objEntry); /** @todo Can this throw? */ + } + else + rc = VERR_NOT_SUPPORTED; + + /** @todo Handle symlinks. */ + } + else + rc = VERR_INVALID_PARAMETER; + } + + ShClTransferListEntryDestroy(&entryList); + } + + if ( RT_FAILURE(rc) + && pTransfer->Thread.fStop) + break; + } + } + + ShClTransferListClose(pTransfer, hList); + } + } + + ShClTransferListOpenParmsDestroy(&openParmsList); + } + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Thread for reading transfer data. + * The data object needs the (high level, root) transfer listing at the time of ::GetData(), so we need + * to block and wait until we have this data (via this thread) and continue. + * + * @returns VBox status code. + * @param ThreadSelf Thread handle. Unused at the moment. + * @param pvUser Pointer to user-provided data. Of type SharedClipboardWinDataObject. + */ +/* static */ +DECLCALLBACK(int) SharedClipboardWinDataObject::readThread(RTTHREAD ThreadSelf, void *pvUser) +{ + RT_NOREF(ThreadSelf); + + LogFlowFuncEnter(); + + SharedClipboardWinDataObject *pThis = (SharedClipboardWinDataObject *)pvUser; + + PSHCLTRANSFER pTransfer = pThis->m_pTransfer; + AssertPtr(pTransfer); + + pTransfer->Thread.fStarted = true; + pTransfer->Thread.fStop = false; + + RTThreadUserSignal(RTThreadSelf()); + + LogRel2(("Shared Clipboard: Calculating transfer ...\n")); + + PSHCLROOTLIST pRootList; + int rc = ShClTransferRootsGet(pTransfer, &pRootList); + if (RT_SUCCESS(rc)) + { + LogFlowFunc(("cRoots=%RU32\n\n", pRootList->Hdr.cRoots)); + + for (uint32_t i = 0; i < pRootList->Hdr.cRoots; i++) + { + PSHCLLISTENTRY pRootEntry = &pRootList->paEntries[i]; + AssertPtr(pRootEntry); + + Assert(pRootEntry->cbInfo == sizeof(SHCLFSOBJINFO)); + PSHCLFSOBJINFO pFsObjInfo = (PSHCLFSOBJINFO)pRootEntry->pvInfo; + + LogFlowFunc(("pszRoot=%s, fMode=0x%x\n", pRootEntry->pszName, pFsObjInfo->Attr.fMode)); + + if (RTFS_IS_DIRECTORY(pFsObjInfo->Attr.fMode)) + { + FSOBJENTRY objEntry = { pRootEntry->pszName, *pFsObjInfo }; + + pThis->m_lstEntries.push_back(objEntry); /** @todo Can this throw? */ + + rc = pThis->readDir(pTransfer, pRootEntry->pszName); + } + else if (RTFS_IS_FILE(pFsObjInfo->Attr.fMode)) + { + FSOBJENTRY objEntry = { pRootEntry->pszName, *pFsObjInfo }; + + pThis->m_lstEntries.push_back(objEntry); /** @todo Can this throw? */ + } + else + rc = VERR_NOT_SUPPORTED; + + if (ASMAtomicReadBool(&pTransfer->Thread.fStop)) + { + LogRel2(("Shared Clipboard: Stopping transfer calculation ...\n")); + break; + } + + if (RT_FAILURE(rc)) + break; + } + + ShClTransferRootListFree(pRootList); + pRootList = NULL; + + if ( RT_SUCCESS(rc) + && !ASMAtomicReadBool(&pTransfer->Thread.fStop)) + { + LogRel2(("Shared Clipboard: Transfer calculation complete (%zu root entries)\n", pThis->m_lstEntries.size())); + + /* + * Signal the "list complete" event so that this data object can return (valid) data via ::GetData(). + * This in turn then will create IStream instances (by the OS) for each file system object to handle. + */ + int rc2 = RTSemEventSignal(pThis->m_EventListComplete); + AssertRC(rc2); + + if (pThis->m_lstEntries.size()) + { + LogRel2(("Shared Clipboard: Waiting for transfer to complete ...\n")); + + LogFlowFunc(("Waiting for transfer to complete ...\n")); + + /* Transferring stuff can take a while, so don't use any timeout here. */ + rc2 = RTSemEventWait(pThis->m_EventTransferComplete, RT_INDEFINITE_WAIT); + AssertRC(rc2); + + switch (pThis->m_enmStatus) + { + case Completed: + LogRel2(("Shared Clipboard: Transfer complete\n")); + break; + + case Canceled: + LogRel2(("Shared Clipboard: Transfer canceled\n")); + break; + + case Error: + LogRel2(("Shared Clipboard: Transfer error occurred\n")); + break; + + default: + break; + } + } + else + LogRel(("Shared Clipboard: No transfer root entries found -- should not happen, please file a bug report\n")); + } + else if (RT_FAILURE(rc)) + LogRel(("Shared Clipboard: Transfer failed with %Rrc\n", rc)); + } + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Creates a FILEGROUPDESCRIPTOR object from a given Shared Clipboard transfer and stores the result into an HGLOBAL object. + * + * @returns VBox status code. + * @param pTransfer Shared Clipboard 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 SharedClipboardWinDataObject::createFileGroupDescriptorFromTransfer(PSHCLTRANSFER pTransfer, + bool fUnicode, HGLOBAL *phGlobal) +{ + AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); + 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)m_lstEntries.size(); /** UINT vs. size_t. */ + if (!cItems) + return VERR_NOT_FOUND; + + UINT curIdx = 0; /* Current index of the handled file group descriptor (FGD). */ + + 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 *)RTMemAllocZ(cbFGD); + if (!pFGD) + return VERR_NO_MEMORY; + + int rc = VINF_SUCCESS; + + pFGD->cItems = cItems; + + char *pszFileSpec = NULL; + + FsObjEntryList::const_iterator itRoot = m_lstEntries.begin(); + while (itRoot != m_lstEntries.end()) + { + FILEDESCRIPTOR *pFD = &pFGD->fgd[curIdx]; + RT_BZERO(pFD, cbFileDescriptor); + + const char *pszFile = itRoot->strPath.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); + + LogFlowFunc(("pFD->cFileNameW=%ls\n", pFD->cFileName)); + } + } + else + { + rc = RTStrCopy(pFD->cFileName, sizeof(pFD->cFileName), pszFileSpec); + LogFlowFunc(("pFD->cFileNameA=%s\n", pFD->cFileName)); + } + + 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; + + const SHCLFSOBJINFO *pObjInfo = &itRoot->objInfo; + + if (RTFS_IS_DIRECTORY(pObjInfo->Attr.fMode)) + { + pFD->dwFileAttributes |= FILE_ATTRIBUTE_DIRECTORY; + } + else if (RTFS_IS_FILE(pObjInfo->Attr.fMode)) + { + pFD->dwFlags |= FD_FILESIZE; + + const uint64_t cbObjSize = pObjInfo->cbObject; + + pFD->nFileSizeHigh = RT_HI_U32(cbObjSize); + pFD->nFileSizeLow = RT_LO_U32(cbObjSize); + } + else if (RTFS_IS_SYMLINK(pObjInfo->Attr.fMode)) + { + /** @todo Implement. */ + } +#if 0 /** @todo Implement this. */ + pFD->dwFlags = FD_ATTRIBUTES | FD_CREATETIME | FD_ACCESSTIME | FD_WRITESTIME | FD_FILESIZE; + pFD->dwFileAttributes = + pFD->ftCreationTime = + pFD->ftLastAccessTime = + pFD->ftLastWriteTime = +#endif + ++curIdx; + ++itRoot; + } + + if (pszFileSpec) + RTStrFree(pszFileSpec); + + if (RT_SUCCESS(rc)) + rc = copyToHGlobal(pFGD, cbFGD, GMEM_MOVEABLE, phGlobal); + + RTMemFree(pFGD); + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Retrieves the data stored in this object and store the result in + * pMedium. + * + * @return IPRT status code. + * @return HRESULT + * @param pFormatEtc + * @param pMedium + */ +STDMETHODIMP SharedClipboardWinDataObject::GetData(LPFORMATETC pFormatEtc, LPSTGMEDIUM pMedium) +{ + AssertPtrReturn(pFormatEtc, DV_E_FORMATETC); + AssertPtrReturn(pMedium, DV_E_FORMATETC); + + LogFlowFuncEnter(); + + LogFlowFunc(("lIndex=%RI32\n", pFormatEtc->lindex)); + + /* + * Initialize default values. + */ + RT_BZERO(pMedium, sizeof(STGMEDIUM)); + + HRESULT hr = DV_E_FORMATETC; /* Play safe. */ + + if ( pFormatEtc->cfFormat == m_cfFileDescriptorA +#ifdef VBOX_CLIPBOARD_WITH_UNICODE_SUPPORT + || pFormatEtc->cfFormat == m_cfFileDescriptorW +#endif + ) + { + const bool fUnicode = pFormatEtc->cfFormat == m_cfFileDescriptorW; + + const uint32_t enmTransferStatus = ShClTransferGetStatus(m_pTransfer); + RT_NOREF(enmTransferStatus); + + LogFlowFunc(("FormatIndex_FileDescriptor%s, enmTransferStatus=%s, m_fRunning=%RTbool\n", + fUnicode ? "W" : "A", ShClTransferStatusToStr(enmTransferStatus), m_fRunning)); + + int rc; + + /* The caller can call GetData() several times, so make sure we don't do the same transfer multiple times. */ + if (!m_fRunning) + { + /* Start the transfer asynchronously in a separate thread. */ + rc = ShClTransferRun(m_pTransfer, &SharedClipboardWinDataObject::readThread, this); + if (RT_SUCCESS(rc)) + { + m_fRunning = true; + + /* Don't block for too long here, as this also will screw other apps running on the OS. */ + LogFunc(("Waiting for listing to arrive ...\n")); + rc = RTSemEventWait(m_EventListComplete, 30 * 1000 /* 30s timeout */); + if (RT_SUCCESS(rc)) + { + LogFunc(("Listing complete\n")); + } + } + } + else + rc = VINF_SUCCESS; + + if (RT_SUCCESS(rc)) + { + 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; + } + else /* We can't tell any better to the caller, unfortunately. */ + hr = E_UNEXPECTED; + } + + if (RT_FAILURE(rc)) + LogRel(("Shared Clipboard: Data object unable to get data, rc=%Rrc\n", rc)); + } + + if (pFormatEtc->cfFormat == m_cfFileContents) + { + if ( pFormatEtc->lindex >= 0 + && (ULONG)pFormatEtc->lindex < m_lstEntries.size()) + { + m_uObjIdx = pFormatEtc->lindex; /* lIndex of FormatEtc contains the actual index to the object being handled. */ + + FSOBJENTRY &fsObjEntry = m_lstEntries.at(m_uObjIdx); + + LogFlowFunc(("FormatIndex_FileContents: m_uObjIdx=%u (entry '%s')\n", m_uObjIdx, fsObjEntry.strPath.c_str())); + + LogRel2(("Shared Clipboard: Receiving object '%s' ...\n", fsObjEntry.strPath.c_str())); + + /* Hand-in the provider so that our IStream implementation can continue working with it. */ + hr = SharedClipboardWinStreamImpl::Create(this /* pParent */, m_pTransfer, + fsObjEntry.strPath.c_str()/* File name */, &fsObjEntry.objInfo /* PSHCLFSOBJINFO */, + &m_pStream); + if (SUCCEEDED(hr)) + { + /* Hand over the stream to the caller. */ + pMedium->tymed = TYMED_ISTREAM; + pMedium->pstm = m_pStream; + } + } + } + else if (pFormatEtc->cfFormat == m_cfPerformedDropEffect) + { + HGLOBAL hGlobal = GlobalAlloc(GHND, sizeof(DWORD)); + + DWORD* pdwDropEffect = (DWORD*)GlobalLock(hGlobal); + *pdwDropEffect = DROPEFFECT_COPY; + + GlobalUnlock(hGlobal); + + pMedium->tymed = TYMED_HGLOBAL; + pMedium->hGlobal = hGlobal; + pMedium->pUnkForRelease = NULL; + } + + if ( FAILED(hr) + && hr != DV_E_FORMATETC) /* Can happen if the caller queries unknown / unhandled formats. */ + { + LogRel(("Shared Clipboard: Error returning data from data object (%Rhrc)\n", hr)); + } + + LogFlowFunc(("hr=%Rhrc\n", hr)); + return hr; +} + +/** + * Only required for IStream / IStorage interfaces. + * + * @return IPRT status code. + * @return HRESULT + * @param pFormatEtc + * @param pMedium + */ +STDMETHODIMP SharedClipboardWinDataObject::GetDataHere(LPFORMATETC pFormatEtc, LPSTGMEDIUM pMedium) +{ + RT_NOREF(pFormatEtc, pMedium); + LogFlowFunc(("\n")); + return E_NOTIMPL; +} + +/** + * Query if this objects supports a specific format. + * + * @return IPRT status code. + * @return HRESULT + * @param pFormatEtc + */ +STDMETHODIMP SharedClipboardWinDataObject::QueryGetData(LPFORMATETC pFormatEtc) +{ + LogFlowFunc(("\n")); + return lookupFormatEtc(pFormatEtc, NULL /* puIndex */) ? S_OK : DV_E_FORMATETC; +} + +STDMETHODIMP SharedClipboardWinDataObject::GetCanonicalFormatEtc(LPFORMATETC pFormatEtc, LPFORMATETC pFormatEtcOut) +{ + RT_NOREF(pFormatEtc); + LogFlowFunc(("\n")); + + /* Set this to NULL in any case. */ + pFormatEtcOut->ptd = NULL; + return E_NOTIMPL; +} + +STDMETHODIMP SharedClipboardWinDataObject::SetData(LPFORMATETC pFormatEtc, LPSTGMEDIUM pMedium, BOOL fRelease) +{ + if ( pFormatEtc == NULL + || pMedium == NULL) + return E_INVALIDARG; + + if (pFormatEtc->lindex != -1) + return DV_E_LINDEX; + + if (pFormatEtc->tymed != TYMED_HGLOBAL) + return DV_E_TYMED; + + if (pFormatEtc->dwAspect != DVASPECT_CONTENT) + return DV_E_DVASPECT; + + LogFlowFunc(("cfFormat=%RU16, lookupFormatEtc=%RTbool\n", + pFormatEtc->cfFormat, lookupFormatEtc(pFormatEtc, NULL /* puIndex */))); + + /* CFSTR_PERFORMEDDROPEFFECT is used by the drop target (caller of this IDataObject) to communicate + * the outcome of the overall operation. */ + if ( pFormatEtc->cfFormat == m_cfPerformedDropEffect + && pMedium->tymed == TYMED_HGLOBAL) + { + DWORD dwEffect = *(DWORD *)GlobalLock(pMedium->hGlobal); + GlobalUnlock(pMedium->hGlobal); + + LogFlowFunc(("dwEffect=%RI32\n", dwEffect)); + + /* Did the user cancel the operation via UI (shell)? This also might happen when overwriting an existing file + * and the user doesn't want to allow this. */ + if (dwEffect == DROPEFFECT_NONE) + { + LogRel2(("Shared Clipboard: Transfer canceled by user interaction\n")); + + OnTransferCanceled(); + } + /** @todo Detect move / overwrite actions here. */ + + if (fRelease) + ReleaseStgMedium(pMedium); + + return S_OK; + } + + return E_NOTIMPL; +} + +STDMETHODIMP SharedClipboardWinDataObject::EnumFormatEtc(DWORD dwDirection, IEnumFORMATETC **ppEnumFormatEtc) +{ + LogFlowFunc(("dwDirection=%RI32, mcFormats=%RI32, mpFormatEtc=%p\n", dwDirection, m_cFormats, m_pFormatEtc)); + + HRESULT hr; + if (dwDirection == DATADIR_GET) + hr = SharedClipboardWinEnumFormatEtc::CreateEnumFormatEtc(m_cFormats, m_pFormatEtc, ppEnumFormatEtc); + else + hr = E_NOTIMPL; + + LogFlowFunc(("hr=%Rhrc\n", hr)); + return hr; +} + +STDMETHODIMP SharedClipboardWinDataObject::DAdvise(LPFORMATETC pFormatEtc, DWORD fAdvise, IAdviseSink *pAdvSink, DWORD *pdwConnection) +{ + RT_NOREF(pFormatEtc, fAdvise, pAdvSink, pdwConnection); + return OLE_E_ADVISENOTSUPPORTED; +} + +STDMETHODIMP SharedClipboardWinDataObject::DUnadvise(DWORD dwConnection) +{ + RT_NOREF(dwConnection); + return OLE_E_ADVISENOTSUPPORTED; +} + +STDMETHODIMP SharedClipboardWinDataObject::EnumDAdvise(IEnumSTATDATA **ppEnumAdvise) +{ + RT_NOREF(ppEnumAdvise); + return OLE_E_ADVISENOTSUPPORTED; +} + +#ifdef VBOX_WITH_SHARED_CLIPBOARD_WIN_ASYNC +/* + * IDataObjectAsyncCapability methods. + */ + +STDMETHODIMP SharedClipboardWinDataObject::EndOperation(HRESULT hResult, IBindCtx *pbcReserved, DWORD dwEffects) +{ + RT_NOREF(hResult, pbcReserved, dwEffects); + return E_NOTIMPL; +} + +STDMETHODIMP SharedClipboardWinDataObject::GetAsyncMode(BOOL *pfIsOpAsync) +{ + RT_NOREF(pfIsOpAsync); + return E_NOTIMPL; +} + +STDMETHODIMP SharedClipboardWinDataObject::InOperation(BOOL *pfInAsyncOp) +{ + RT_NOREF(pfInAsyncOp); + return E_NOTIMPL; +} + +STDMETHODIMP SharedClipboardWinDataObject::SetAsyncMode(BOOL fDoOpAsync) +{ + RT_NOREF(fDoOpAsync); + return E_NOTIMPL; +} + +STDMETHODIMP SharedClipboardWinDataObject::StartOperation(IBindCtx *pbcReserved) +{ + RT_NOREF(pbcReserved); + return E_NOTIMPL; +} +#endif /* VBOX_WITH_SHARED_CLIPBOARD_WIN_ASYNC */ + +/* + * Own stuff. + */ + +int SharedClipboardWinDataObject::Init(void) +{ + LogFlowFuncLeaveRC(VINF_SUCCESS); + return VINF_SUCCESS; +} + +void SharedClipboardWinDataObject::OnTransferComplete(int rc /* = VINF_SUCESS */) +{ + RT_NOREF(rc); + + LogFlowFunc(("m_uObjIdx=%RU32 (total: %zu)\n", m_uObjIdx, m_lstEntries.size())); + + if (RT_SUCCESS(rc)) + { + const bool fComplete = m_uObjIdx == m_lstEntries.size() - 1 /* Object index is zero-based */; + if (fComplete) + { + m_enmStatus = Completed; + } + } + else + m_enmStatus = Error; + + if (m_enmStatus != Initialized) + { + if (m_EventTransferComplete != NIL_RTSEMEVENT) + { + int rc2 = RTSemEventSignal(m_EventTransferComplete); + AssertRC(rc2); + } + } + + LogFlowFuncLeaveRC(rc); +} + +void SharedClipboardWinDataObject::OnTransferCanceled(void) +{ + LogFlowFuncEnter(); + + m_enmStatus = Canceled; + + if (m_EventTransferComplete != NIL_RTSEMEVENT) + { + int rc2 = RTSemEventSignal(m_EventTransferComplete); + AssertRC(rc2); + } + + LogFlowFuncLeave(); +} + +/* static */ +void SharedClipboardWinDataObject::logFormat(CLIPFORMAT fmt) +{ + char szFormat[128]; + if (GetClipboardFormatName(fmt, szFormat, sizeof(szFormat))) + { + LogFlowFunc(("clipFormat=%RI16 -> %s\n", fmt, szFormat)); + } + else + LogFlowFunc(("clipFormat=%RI16 is unknown\n", fmt)); +} + +bool SharedClipboardWinDataObject::lookupFormatEtc(LPFORMATETC pFormatEtc, ULONG *puIndex) +{ + AssertReturn(pFormatEtc, false); + /* puIndex is optional. */ + + for (ULONG i = 0; i < m_cFormats; i++) + { + if( (pFormatEtc->tymed & m_pFormatEtc[i].tymed) + && 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) + { + LogRel2(("Shared Clipboard: Format found: tyMed=%RI32, cfFormat=%RI16, dwAspect=%RI32, ulIndex=%RU32\n", + pFormatEtc->tymed, pFormatEtc->cfFormat, pFormatEtc->dwAspect, i)); + if (puIndex) + *puIndex = i; + return true; + } + } + + LogRel2(("Shared Clipboard: Format NOT found: tyMed=%RI32, cfFormat=%RI16, dwAspect=%RI32\n", + pFormatEtc->tymed, pFormatEtc->cfFormat, pFormatEtc->dwAspect)); + + logFormat(pFormatEtc->cfFormat); + + return false; +} + +void SharedClipboardWinDataObject::registerFormat(LPFORMATETC pFormatEtc, CLIPFORMAT clipFormat, + TYMED tyMed, LONG lIndex, DWORD dwAspect, + DVTARGETDEVICE *pTargetDevice) +{ + AssertPtr(pFormatEtc); + + pFormatEtc->cfFormat = clipFormat; + pFormatEtc->tymed = tyMed; + pFormatEtc->lindex = lIndex; + pFormatEtc->dwAspect = dwAspect; + pFormatEtc->ptd = pTargetDevice; + + LogFlowFunc(("Registered format=%ld\n", pFormatEtc->cfFormat)); + + logFormat(pFormatEtc->cfFormat); +} diff --git a/src/VBox/GuestHost/SharedClipboard/ClipboardEnumFormatEtcImpl-win.cpp b/src/VBox/GuestHost/SharedClipboard/ClipboardEnumFormatEtcImpl-win.cpp new file mode 100644 index 00000000..330ca7c8 --- /dev/null +++ b/src/VBox/GuestHost/SharedClipboard/ClipboardEnumFormatEtcImpl-win.cpp @@ -0,0 +1,205 @@ +/* $Id: ClipboardEnumFormatEtcImpl-win.cpp $ */ +/** @file + * ClipboardEnumFormatEtcImpl-win.cpp - Shared Clipboard IEnumFORMATETC ("Format et cetera") implementation. + */ + +/* + * Copyright (C) 2013-2022 Oracle and/or its affiliates. + * + * This file is part of VirtualBox base platform packages, as + * available from https://www.virtualbox.org. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, in version 3 of the + * License. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <https://www.gnu.org/licenses>. + * + * SPDX-License-Identifier: GPL-3.0-only + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <new> /* For bad_alloc. */ + +#define LOG_GROUP LOG_GROUP_SHARED_CLIPBOARD +#include <VBox/GuestHost/SharedClipboard-win.h> + +#include <iprt/win/windows.h> + +#include <VBox/log.h> + + + +SharedClipboardWinEnumFormatEtc::SharedClipboardWinEnumFormatEtc(LPFORMATETC pFormatEtc, ULONG cFormats) + : m_lRefCount(1), + m_nIndex(0) +{ + HRESULT hr; + + try + { + LogFlowFunc(("pFormatEtc=%p, cFormats=%RU32\n", pFormatEtc, cFormats)); + m_pFormatEtc = new FORMATETC[cFormats]; + + for (ULONG i = 0; i < cFormats; i++) + { + LogFlowFunc(("Format %RU32: cfFormat=%RI16, tyMed=%RU32, dwAspect=%RU32\n", + i, pFormatEtc[i].cfFormat, pFormatEtc[i].tymed, pFormatEtc[i].dwAspect)); + + SharedClipboardWinDataObject::logFormat(pFormatEtc[i].cfFormat); + + SharedClipboardWinEnumFormatEtc::CopyFormat(&m_pFormatEtc[i], &pFormatEtc[i]); + } + + m_nNumFormats = cFormats; + hr = S_OK; + } + catch (std::bad_alloc &) + { + hr = E_OUTOFMEMORY; + } + + LogFlowFunc(("hr=%Rhrc\n", hr)); +} + +SharedClipboardWinEnumFormatEtc::~SharedClipboardWinEnumFormatEtc(void) +{ + if (m_pFormatEtc) + { + for (ULONG i = 0; i < m_nNumFormats; i++) + { + if(m_pFormatEtc[i].ptd) + CoTaskMemFree(m_pFormatEtc[i].ptd); + } + + delete[] m_pFormatEtc; + m_pFormatEtc = NULL; + } + + LogFlowFunc(("m_lRefCount=%RI32\n", m_lRefCount)); +} + +/* + * IUnknown methods. + */ + +STDMETHODIMP_(ULONG) SharedClipboardWinEnumFormatEtc::AddRef(void) +{ + return InterlockedIncrement(&m_lRefCount); +} + +STDMETHODIMP_(ULONG) SharedClipboardWinEnumFormatEtc::Release(void) +{ + LONG lCount = InterlockedDecrement(&m_lRefCount); + if (lCount == 0) + { + LogFlowFunc(("Delete\n")); + delete this; + return 0; + } + + return lCount; +} + +STDMETHODIMP SharedClipboardWinEnumFormatEtc::QueryInterface(REFIID iid, void **ppvObject) +{ + if ( iid == IID_IEnumFORMATETC + || iid == IID_IUnknown) + { + AddRef(); + *ppvObject = this; + return S_OK; + } + + *ppvObject = 0; + return E_NOINTERFACE; +} + +STDMETHODIMP SharedClipboardWinEnumFormatEtc::Next(ULONG cFormats, LPFORMATETC pFormatEtc, ULONG *pcFetched) +{ + ULONG ulCopied = 0; + + if(cFormats == 0 || pFormatEtc == 0) + return E_INVALIDARG; + + while ( m_nIndex < m_nNumFormats + && ulCopied < cFormats) + { + SharedClipboardWinEnumFormatEtc::CopyFormat(&pFormatEtc[ulCopied], &m_pFormatEtc[m_nIndex]); + ulCopied++; + m_nIndex++; + } + + if (pcFetched) + *pcFetched = ulCopied; + + return (ulCopied == cFormats) ? S_OK : S_FALSE; +} + +STDMETHODIMP SharedClipboardWinEnumFormatEtc::Skip(ULONG cFormats) +{ + m_nIndex += cFormats; + return (m_nIndex <= m_nNumFormats) ? S_OK : S_FALSE; +} + +STDMETHODIMP SharedClipboardWinEnumFormatEtc::Reset(void) +{ + m_nIndex = 0; + return S_OK; +} + +STDMETHODIMP SharedClipboardWinEnumFormatEtc::Clone(IEnumFORMATETC **ppEnumFormatEtc) +{ + HRESULT hResult = CreateEnumFormatEtc(m_nNumFormats, m_pFormatEtc, ppEnumFormatEtc); + if (hResult == S_OK) + ((SharedClipboardWinEnumFormatEtc *) *ppEnumFormatEtc)->m_nIndex = m_nIndex; + + return hResult; +} + +/* static */ +void SharedClipboardWinEnumFormatEtc::CopyFormat(LPFORMATETC pDest, LPFORMATETC pSource) +{ + AssertPtrReturnVoid(pDest); + AssertPtrReturnVoid(pSource); + + *pDest = *pSource; + + if (pSource->ptd) + { + pDest->ptd = (DVTARGETDEVICE*)CoTaskMemAlloc(sizeof(DVTARGETDEVICE)); + *(pDest->ptd) = *(pSource->ptd); + } +} + +/* static */ +HRESULT SharedClipboardWinEnumFormatEtc::CreateEnumFormatEtc(UINT nNumFormats, LPFORMATETC pFormatEtc, IEnumFORMATETC **ppEnumFormatEtc) +{ + AssertReturn(nNumFormats, E_INVALIDARG); + AssertPtrReturn(pFormatEtc, E_INVALIDARG); + AssertPtrReturn(ppEnumFormatEtc, E_INVALIDARG); + + HRESULT hr; + try + { + *ppEnumFormatEtc = new SharedClipboardWinEnumFormatEtc(pFormatEtc, nNumFormats); + hr = S_OK; + } + catch(std::bad_alloc &) + { + hr = E_OUTOFMEMORY; + } + + return hr; +} + diff --git a/src/VBox/GuestHost/SharedClipboard/ClipboardMIME.cpp b/src/VBox/GuestHost/SharedClipboard/ClipboardMIME.cpp new file mode 100644 index 00000000..b8e0a993 --- /dev/null +++ b/src/VBox/GuestHost/SharedClipboard/ClipboardMIME.cpp @@ -0,0 +1,53 @@ +/* $Id: ClipboardMIME.cpp $ */ +/** @file + * Shared Clipboard - Path list class. + */ + +/* + * Copyright (C) 2019-2022 Oracle and/or its affiliates. + * + * This file is part of VirtualBox base platform packages, as + * available from https://www.virtualbox.org. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, in version 3 of the + * License. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <https://www.gnu.org/licenses>. + * + * SPDX-License-Identifier: GPL-3.0-only + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP LOG_GROUP_SHARED_CLIPBOARD +#include <VBox/GuestHost/SharedClipboard-transfers.h> + +#include <iprt/string.h> + + +bool ShClMIMEHasFileURLs(const char *pcszFormat, size_t cchFormatMax) +{ + /** @todo "text/uri" also an official variant? */ + return ( RTStrNICmp(pcszFormat, "text/uri-list", cchFormatMax) == 0 + || RTStrNICmp(pcszFormat, "x-special/gnome-icon-list", cchFormatMax) == 0); +} + +bool ShClMIMENeedsCache(const char *pcszFormat, size_t cchFormatMax) +{ + bool fNeedsDropDir = false; + if (!RTStrNICmp(pcszFormat, "text/uri-list", cchFormatMax)) /** @todo Add "x-special/gnome-icon-list"? */ + fNeedsDropDir = true; + + return fNeedsDropDir; +} + diff --git a/src/VBox/GuestHost/SharedClipboard/ClipboardPath.cpp b/src/VBox/GuestHost/SharedClipboard/ClipboardPath.cpp new file mode 100644 index 00000000..db49d7ee --- /dev/null +++ b/src/VBox/GuestHost/SharedClipboard/ClipboardPath.cpp @@ -0,0 +1,92 @@ +/* $Id: ClipboardPath.cpp $ */ +/** @file + * Shared Clipboard - Path handling. + */ + +/* + * Copyright (C) 2019-2022 Oracle and/or its affiliates. + * + * This file is part of VirtualBox base platform packages, as + * available from https://www.virtualbox.org. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, in version 3 of the + * License. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <https://www.gnu.org/licenses>. + * + * SPDX-License-Identifier: GPL-3.0-only + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP LOG_GROUP_SHARED_CLIPBOARD +#include <VBox/GuestHost/SharedClipboard-transfers.h> + +#include <iprt/err.h> +#include <iprt/path.h> +#include <iprt/string.h> + + +/** + * Sanitizes the file name component so that unsupported characters + * will be replaced by an underscore ("_"). + * + * @return IPRT status code. + * @param pszPath Path to sanitize. + * @param cbPath Size (in bytes) of path to sanitize. + */ +int ShClPathSanitizeFilename(char *pszPath, size_t cbPath) +{ + int rc = VINF_SUCCESS; +#ifdef RT_OS_WINDOWS + RT_NOREF1(cbPath); + /* Replace out characters not allowed on Windows platforms, put in by RTTimeSpecToString(). */ + /** @todo Use something like RTPathSanitize() if available later some time. */ + static const RTUNICP s_uszValidRangePairs[] = + { + ' ', ' ', + '(', ')', + '-', '.', + '0', '9', + 'A', 'Z', + 'a', 'z', + '_', '_', + 0xa0, 0xd7af, + '\0' + }; + ssize_t cReplaced = RTStrPurgeComplementSet(pszPath, s_uszValidRangePairs, '_' /* chReplacement */); + if (cReplaced < 0) + rc = VERR_INVALID_UTF8_ENCODING; +#else + RT_NOREF2(pszPath, cbPath); +#endif + return rc; +} + +/** + * Sanitizes a given path regarding invalid / unhandled characters. + * Currently not implemented. + * + * @returns VBox status code. + * @param pszPath Path to sanitize. UTF-8. + * @param cbPath Size (in bytes) of the path to sanitize. + */ +int ShClPathSanitize(char *pszPath, size_t cbPath) +{ + RT_NOREF(pszPath, cbPath); + + /** @todo */ + + return VINF_SUCCESS; +} + diff --git a/src/VBox/GuestHost/SharedClipboard/ClipboardStreamImpl-win.cpp b/src/VBox/GuestHost/SharedClipboard/ClipboardStreamImpl-win.cpp new file mode 100644 index 00000000..fc7b8274 --- /dev/null +++ b/src/VBox/GuestHost/SharedClipboard/ClipboardStreamImpl-win.cpp @@ -0,0 +1,382 @@ +/* $Id: ClipboardStreamImpl-win.cpp $ */ +/** @file + * ClipboardStreamImpl-win.cpp - Shared Clipboard IStream object implementation (guest and host side). + */ + +/* + * Copyright (C) 2019-2022 Oracle and/or its affiliates. + * + * This file is part of VirtualBox base platform packages, as + * available from https://www.virtualbox.org. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, in version 3 of the + * License. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <https://www.gnu.org/licenses>. + * + * SPDX-License-Identifier: GPL-3.0-only + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP LOG_GROUP_SHARED_CLIPBOARD +#include <VBox/GuestHost/SharedClipboard-win.h> + +#include <iprt/asm.h> +#include <iprt/ldr.h> +#include <iprt/thread.h> + +#include <VBox/GuestHost/SharedClipboard.h> +#include <VBox/GuestHost/SharedClipboard-win.h> +#include <strsafe.h> + +#include <VBox/log.h> + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ + + + +/********************************************************************************************************************************* +* Static variables * +*********************************************************************************************************************************/ + + + +SharedClipboardWinStreamImpl::SharedClipboardWinStreamImpl(SharedClipboardWinDataObject *pParent, PSHCLTRANSFER pTransfer, + const Utf8Str &strPath, PSHCLFSOBJINFO pObjInfo) + : m_pParent(pParent) + , m_lRefCount(1) /* Our IDataObjct *always* holds the last reference to this object; needed for the callbacks. */ + , m_pTransfer(pTransfer) + , m_hObj(SHCLOBJHANDLE_INVALID) + , m_strPath(strPath) + , m_objInfo(*pObjInfo) + , m_cbProcessed(0) + , m_fIsComplete(false) +{ + AssertPtr(m_pTransfer); + + LogFunc(("m_strPath=%s\n", m_strPath.c_str())); +} + +SharedClipboardWinStreamImpl::~SharedClipboardWinStreamImpl(void) +{ + LogFlowThisFuncEnter(); +} + +/* + * IUnknown methods. + */ + +STDMETHODIMP SharedClipboardWinStreamImpl::QueryInterface(REFIID iid, void **ppvObject) +{ + AssertPtrReturn(ppvObject, E_INVALIDARG); + + if (iid == IID_IUnknown) + { + LogFlowFunc(("IID_IUnknown\n")); + *ppvObject = (IUnknown *)(ISequentialStream *)this; + } + else if (iid == IID_ISequentialStream) + { + LogFlowFunc(("IID_ISequentialStream\n")); + *ppvObject = (ISequentialStream *)this; + } + else if (iid == IID_IStream) + { + LogFlowFunc(("IID_IStream\n")); + *ppvObject = (IStream *)this; + } + else + { + *ppvObject = NULL; + return E_NOINTERFACE; + } + + AddRef(); + return S_OK; +} + +STDMETHODIMP_(ULONG) SharedClipboardWinStreamImpl::AddRef(void) +{ + LONG lCount = InterlockedIncrement(&m_lRefCount); + LogFlowFunc(("lCount=%RI32\n", lCount)); + return lCount; +} + +STDMETHODIMP_(ULONG) SharedClipboardWinStreamImpl::Release(void) +{ + LONG lCount = InterlockedDecrement(&m_lRefCount); + LogFlowFunc(("lCount=%RI32\n", m_lRefCount)); + if (lCount == 0) + { + delete this; + return 0; + } + + return lCount; +} + +/* + * IStream methods. + */ + +STDMETHODIMP SharedClipboardWinStreamImpl::Clone(IStream** ppStream) +{ + RT_NOREF(ppStream); + + LogFlowFuncEnter(); + return E_NOTIMPL; +} + +STDMETHODIMP SharedClipboardWinStreamImpl::Commit(DWORD dwFrags) +{ + RT_NOREF(dwFrags); + + LogFlowThisFuncEnter(); + return E_NOTIMPL; +} + +STDMETHODIMP SharedClipboardWinStreamImpl::CopyTo(IStream *pDestStream, ULARGE_INTEGER nBytesToCopy, ULARGE_INTEGER *nBytesRead, + ULARGE_INTEGER *nBytesWritten) +{ + RT_NOREF(pDestStream, nBytesToCopy, nBytesRead, nBytesWritten); + + LogFlowThisFuncEnter(); + return E_NOTIMPL; +} + +STDMETHODIMP SharedClipboardWinStreamImpl::LockRegion(ULARGE_INTEGER nStart, ULARGE_INTEGER nBytes,DWORD dwFlags) +{ + RT_NOREF(nStart, nBytes, dwFlags); + + LogFlowThisFuncEnter(); + return STG_E_INVALIDFUNCTION; +} + +/* Note: Windows seems to assume EOF if nBytesRead < nBytesToRead. */ +STDMETHODIMP SharedClipboardWinStreamImpl::Read(void *pvBuffer, ULONG nBytesToRead, ULONG *nBytesRead) +{ + LogFlowThisFunc(("Enter: m_cbProcessed=%RU64\n", m_cbProcessed)); + + /** @todo Is there any locking required so that parallel reads aren't possible? */ + + if (!pvBuffer) + return STG_E_INVALIDPOINTER; + + if ( nBytesToRead == 0 + || m_fIsComplete) + { + if (nBytesRead) + *nBytesRead = 0; + return S_OK; + } + + int rc; + + try + { + if ( m_hObj == SHCLOBJHANDLE_INVALID + && m_pTransfer->ProviderIface.pfnObjOpen) + { + SHCLOBJOPENCREATEPARMS openParms; + rc = ShClTransferObjOpenParmsInit(&openParms); + if (RT_SUCCESS(rc)) + { + openParms.fCreate = SHCL_OBJ_CF_ACCESS_READ + | SHCL_OBJ_CF_ACCESS_DENYWRITE; + + rc = RTStrCopy(openParms.pszPath, openParms.cbPath, m_strPath.c_str()); + if (RT_SUCCESS(rc)) + { + rc = m_pTransfer->ProviderIface.pfnObjOpen(&m_pTransfer->ProviderCtx, &openParms, &m_hObj); + } + + ShClTransferObjOpenParmsDestroy(&openParms); + } + } + else + rc = VINF_SUCCESS; + + uint32_t cbRead = 0; + + const uint64_t cbSize = (uint64_t)m_objInfo.cbObject; + const uint32_t cbToRead = RT_MIN(cbSize - m_cbProcessed, nBytesToRead); + + if (RT_SUCCESS(rc)) + { + if (cbToRead) + { + rc = m_pTransfer->ProviderIface.pfnObjRead(&m_pTransfer->ProviderCtx, m_hObj, + pvBuffer, cbToRead, 0 /* fFlags */, &cbRead); + if (RT_SUCCESS(rc)) + { + m_cbProcessed += cbRead; + Assert(m_cbProcessed <= cbSize); + } + } + + /* Transfer complete? Make sure to close the object again. */ + m_fIsComplete = m_cbProcessed == cbSize; + + if (m_fIsComplete) + { + if (m_pTransfer->ProviderIface.pfnObjClose) + { + int rc2 = m_pTransfer->ProviderIface.pfnObjClose(&m_pTransfer->ProviderCtx, m_hObj); + AssertRC(rc2); + } + + if (m_pParent) + m_pParent->OnTransferComplete(); + } + } + + LogFlowThisFunc(("Leave: rc=%Rrc, cbSize=%RU64, cbProcessed=%RU64 -> nBytesToRead=%RU32, cbToRead=%RU32, cbRead=%RU32\n", + rc, cbSize, m_cbProcessed, nBytesToRead, cbToRead, cbRead)); + + if (nBytesRead) + *nBytesRead = (ULONG)cbRead; + + if (nBytesToRead != cbRead) + return S_FALSE; + + return S_OK; + } + catch (...) + { + LogFunc(("Caught exception\n")); + } + + return E_FAIL; +} + +STDMETHODIMP SharedClipboardWinStreamImpl::Revert(void) +{ + LogFlowThisFuncEnter(); + return E_NOTIMPL; +} + +STDMETHODIMP SharedClipboardWinStreamImpl::Seek(LARGE_INTEGER nMove, DWORD dwOrigin, ULARGE_INTEGER* nNewPos) +{ + RT_NOREF(nMove, dwOrigin, nNewPos); + + LogFlowThisFunc(("nMove=%RI64, dwOrigin=%RI32\n", nMove, dwOrigin)); + + return E_NOTIMPL; +} + +STDMETHODIMP SharedClipboardWinStreamImpl::SetSize(ULARGE_INTEGER nNewSize) +{ + RT_NOREF(nNewSize); + + LogFlowThisFuncEnter(); + return E_NOTIMPL; +} + +STDMETHODIMP SharedClipboardWinStreamImpl::Stat(STATSTG *pStatStg, DWORD dwFlags) +{ + HRESULT hr = S_OK; + + if (pStatStg) + { + RT_ZERO(*pStatStg); + + switch (dwFlags) + { + case STATFLAG_NONAME: + pStatStg->pwcsName = NULL; + break; + + case STATFLAG_DEFAULT: + { + /** @todo r=bird: This is using the wrong allocator. According to MSDN the + * caller will pass this to CoTaskMemFree, so we should use CoTaskMemAlloc to + * allocate it. */ + int rc2 = RTStrToUtf16(m_strPath.c_str(), &pStatStg->pwcsName); + if (RT_FAILURE(rc2)) + hr = E_FAIL; + break; + } + + default: + hr = STG_E_INVALIDFLAG; + break; + } + + if (SUCCEEDED(hr)) + { + pStatStg->type = STGTY_STREAM; + pStatStg->grfMode = STGM_READ; + pStatStg->grfLocksSupported = 0; + pStatStg->cbSize.QuadPart = (uint64_t)m_objInfo.cbObject; + } + } + else + hr = STG_E_INVALIDPOINTER; + + LogFlowThisFunc(("hr=%Rhrc\n", hr)); + return hr; +} + +STDMETHODIMP SharedClipboardWinStreamImpl::UnlockRegion(ULARGE_INTEGER nStart, ULARGE_INTEGER nBytes, DWORD dwFlags) +{ + RT_NOREF(nStart, nBytes, dwFlags); + + LogFlowThisFuncEnter(); + return E_NOTIMPL; +} + +STDMETHODIMP SharedClipboardWinStreamImpl::Write(const void *pvBuffer, ULONG nBytesToRead, ULONG *nBytesRead) +{ + RT_NOREF(pvBuffer, nBytesToRead, nBytesRead); + + LogFlowThisFuncEnter(); + return E_NOTIMPL; +} + +/* + * Own stuff. + */ + +/** + * Factory to create our own IStream implementation. + * + * @returns HRESULT + * @param pParent Pointer to the parent data object. + * @param pTransfer Pointer to Shared Clipboard transfer object to use. + * @param strPath Path of object to handle for the stream. + * @param pObjInfo Pointer to object information. + * @param ppStream Where to return the created stream object on success. + */ +/* static */ +HRESULT SharedClipboardWinStreamImpl::Create(SharedClipboardWinDataObject *pParent, PSHCLTRANSFER pTransfer, + const Utf8Str &strPath, PSHCLFSOBJINFO pObjInfo, + IStream **ppStream) +{ + AssertPtrReturn(pTransfer, E_POINTER); + + SharedClipboardWinStreamImpl *pStream = new SharedClipboardWinStreamImpl(pParent, pTransfer, strPath, pObjInfo); + if (pStream) + { + pStream->AddRef(); + + *ppStream = pStream; + return S_OK; + } + + return E_FAIL; +} + diff --git a/src/VBox/GuestHost/SharedClipboard/Makefile.kmk b/src/VBox/GuestHost/SharedClipboard/Makefile.kmk new file mode 100644 index 00000000..92431ccc --- /dev/null +++ b/src/VBox/GuestHost/SharedClipboard/Makefile.kmk @@ -0,0 +1,36 @@ +# $Id: Makefile.kmk $ +## @file +# Sub-Makefile for the VirtualBox Shared Clipboard guest/host code. +# + +# +# Copyright (C) 2020-2022 Oracle and/or its affiliates. +# +# This file is part of VirtualBox base platform packages, as +# available from https://www.virtualbox.org. +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation, in version 3 of the +# License. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, see <https://www.gnu.org/licenses>. +# +# SPDX-License-Identifier: GPL-3.0-only +# + +SUB_DEPTH = ../../../.. +include $(KBUILD_PATH)/subheader.kmk + +ifdef VBOX_WITH_TESTCASES + include $(PATH_SUB_CURRENT)/testcase/Makefile.kmk +endif + +include $(FILE_KBUILD_SUB_FOOTER) + diff --git a/src/VBox/GuestHost/SharedClipboard/clipboard-common.cpp b/src/VBox/GuestHost/SharedClipboard/clipboard-common.cpp new file mode 100644 index 00000000..929fec61 --- /dev/null +++ b/src/VBox/GuestHost/SharedClipboard/clipboard-common.cpp @@ -0,0 +1,1226 @@ +/* $Id: clipboard-common.cpp $ */ +/** @file + * Shared Clipboard: Some helper function for converting between the various eol. + */ + +/* + * Includes contributions from François Revol + * + * Copyright (C) 2006-2022 Oracle and/or its affiliates. + * + * This file is part of VirtualBox base platform packages, as + * available from https://www.virtualbox.org. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, in version 3 of the + * License. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <https://www.gnu.org/licenses>. + * + * SPDX-License-Identifier: GPL-3.0-only + */ + +#define LOG_GROUP LOG_GROUP_SHARED_CLIPBOARD + +#include <iprt/alloc.h> +#include <iprt/assert.h> +#include <iprt/semaphore.h> +#include <iprt/path.h> +#include <iprt/rand.h> +#include <iprt/utf16.h> + +#include <iprt/formats/bmp.h> + +#include <iprt/errcore.h> +#include <VBox/log.h> +#include <VBox/GuestHost/clipboard-helper.h> +#include <VBox/HostServices/VBoxClipboardSvc.h> + + +/********************************************************************************************************************************* +* Prototypes * +*********************************************************************************************************************************/ +static void shClEventSourceResetInternal(PSHCLEVENTSOURCE pSource); + +static void shClEventDestroy(PSHCLEVENT pEvent); +DECLINLINE(PSHCLEVENT) shclEventGet(PSHCLEVENTSOURCE pSource, SHCLEVENTID idEvent); + + +/********************************************************************************************************************************* +* Implementation * +*********************************************************************************************************************************/ + +/** + * Allocates a new event payload. + * + * @returns VBox status code. + * @param uID Payload ID to set for this payload. Useful for consequtive payloads. + * @param pvData Data block to associate to this payload. + * @param cbData Size (in bytes) of data block to associate. + * @param ppPayload Where to store the allocated event payload on success. + */ +int ShClPayloadAlloc(uint32_t uID, const void *pvData, uint32_t cbData, + PSHCLEVENTPAYLOAD *ppPayload) +{ + AssertPtrReturn(pvData, VERR_INVALID_POINTER); + AssertReturn(cbData > 0, VERR_INVALID_PARAMETER); + + PSHCLEVENTPAYLOAD pPayload = (PSHCLEVENTPAYLOAD)RTMemAlloc(sizeof(SHCLEVENTPAYLOAD)); + if (pPayload) + { + pPayload->pvData = RTMemDup(pvData, cbData); + if (pPayload->pvData) + { + pPayload->cbData = cbData; + pPayload->uID = uID; + + *ppPayload = pPayload; + return VINF_SUCCESS; + } + + RTMemFree(pPayload); + } + return VERR_NO_MEMORY; +} + +/** + * Frees an event payload. + * + * @returns VBox status code. + * @param pPayload Event payload to free. + */ +void ShClPayloadFree(PSHCLEVENTPAYLOAD pPayload) +{ + if (!pPayload) + return; + + if (pPayload->pvData) + { + Assert(pPayload->cbData); + RTMemFree(pPayload->pvData); + pPayload->pvData = NULL; + } + + pPayload->cbData = 0; + pPayload->uID = UINT32_MAX; + + RTMemFree(pPayload); +} + +/** + * Creates a new event source. + * + * @returns VBox status code. + * @param pSource Event source to create. + * @param uID ID to use for event source. + */ +int ShClEventSourceCreate(PSHCLEVENTSOURCE pSource, SHCLEVENTSOURCEID uID) +{ + LogFlowFunc(("pSource=%p, uID=%RU16\n", pSource, uID)); + AssertPtrReturn(pSource, VERR_INVALID_POINTER); + + int rc = RTCritSectInit(&pSource->CritSect); + AssertRCReturn(rc, rc); + + RTListInit(&pSource->lstEvents); + + pSource->uID = uID; + /* Choose a random event ID starting point. */ + pSource->idNextEvent = RTRandU32Ex(1, VBOX_SHCL_MAX_EVENTS - 1); + + return VINF_SUCCESS; +} + +/** + * Destroys an event source. + * + * @returns VBox status code. + * @param pSource Event source to destroy. + */ +int ShClEventSourceDestroy(PSHCLEVENTSOURCE pSource) +{ + if (!pSource) + return VINF_SUCCESS; + + LogFlowFunc(("ID=%RU32\n", pSource->uID)); + + int rc = RTCritSectEnter(&pSource->CritSect); + if (RT_SUCCESS(rc)) + { + shClEventSourceResetInternal(pSource); + + rc = RTCritSectLeave(&pSource->CritSect); + AssertRC(rc); + + RTCritSectDelete(&pSource->CritSect); + + pSource->uID = UINT16_MAX; + pSource->idNextEvent = UINT32_MAX; + } + + return rc; +} + +/** + * Resets an event source, internal version. + * + * @param pSource Event source to reset. + */ +static void shClEventSourceResetInternal(PSHCLEVENTSOURCE pSource) +{ + LogFlowFunc(("ID=%RU32\n", pSource->uID)); + + PSHCLEVENT pEvIt; + PSHCLEVENT pEvItNext; + RTListForEachSafe(&pSource->lstEvents, pEvIt, pEvItNext, SHCLEVENT, Node) + { + RTListNodeRemove(&pEvIt->Node); + + shClEventDestroy(pEvIt); + + RTMemFree(pEvIt); + pEvIt = NULL; + } +} + +/** + * Resets an event source. + * + * @param pSource Event source to reset. + */ +void ShClEventSourceReset(PSHCLEVENTSOURCE pSource) +{ + int rc2 = RTCritSectEnter(&pSource->CritSect); + if (RT_SUCCESS(rc2)) + { + shClEventSourceResetInternal(pSource); + + rc2 = RTCritSectLeave(&pSource->CritSect); + AssertRC(rc2); + } +} + +/** + * Generates a new event ID for a specific event source and registers it. + * + * @returns VBox status code. + * @param pSource Event source to generate event for. + * @param ppEvent Where to return the new event generated on success. + */ +int ShClEventSourceGenerateAndRegisterEvent(PSHCLEVENTSOURCE pSource, PSHCLEVENT *ppEvent) +{ + AssertPtrReturn(pSource, VERR_INVALID_POINTER); + AssertPtrReturn(ppEvent, VERR_INVALID_POINTER); + + PSHCLEVENT pEvent = (PSHCLEVENT)RTMemAllocZ(sizeof(SHCLEVENT)); + AssertReturn(pEvent, VERR_NO_MEMORY); + int rc = RTSemEventMultiCreate(&pEvent->hEvtMulSem); + if (RT_SUCCESS(rc)) + { + rc = RTCritSectEnter(&pSource->CritSect); + if (RT_SUCCESS(rc)) + { + /* + * Allocate an unique event ID. + */ + for (uint32_t cTries = 0;; cTries++) + { + SHCLEVENTID idEvent = ++pSource->idNextEvent; + if (idEvent < VBOX_SHCL_MAX_EVENTS) + { /* likely */ } + else + pSource->idNextEvent = idEvent = 1; /* zero == error, remember! */ + + if (shclEventGet(pSource, idEvent) == NULL) + { + pEvent->pParent = pSource; + pEvent->idEvent = idEvent; + RTListAppend(&pSource->lstEvents, &pEvent->Node); + + rc = RTCritSectLeave(&pSource->CritSect); + AssertRC(rc); + + LogFlowFunc(("uSource=%RU16: New event: %#x\n", pSource->uID, idEvent)); + + ShClEventRetain(pEvent); + *ppEvent = pEvent; + + return VINF_SUCCESS; + } + + AssertBreak(cTries < 4096); + } + + rc = RTCritSectLeave(&pSource->CritSect); + AssertRC(rc); + } + } + + AssertMsgFailed(("Unable to register a new event ID for event source %RU16\n", pSource->uID)); + + RTSemEventMultiDestroy(pEvent->hEvtMulSem); + pEvent->hEvtMulSem = NIL_RTSEMEVENTMULTI; + RTMemFree(pEvent); + return rc; +} + +/** + * Destroys an event. + * + * @param pEvent Event to destroy. + */ +static void shClEventDestroy(PSHCLEVENT pEvent) +{ + if (!pEvent) + return; + + AssertMsgReturnVoid(pEvent->cRefs == 0, ("Event %RU32 still has %RU32 references\n", + pEvent->idEvent, pEvent->cRefs)); + + LogFlowFunc(("Event %RU32\n", pEvent->idEvent)); + + if (pEvent->hEvtMulSem != NIL_RTSEMEVENT) + { + RTSemEventMultiDestroy(pEvent->hEvtMulSem); + pEvent->hEvtMulSem = NIL_RTSEMEVENT; + } + + ShClPayloadFree(pEvent->pPayload); + + pEvent->idEvent = NIL_SHCLEVENTID; +} + +/** + * Unregisters an event. + * + * @returns VBox status code. + * @param pSource Event source to unregister event for. + * @param pEvent Event to unregister. On success the pointer will be invalid. + */ +static int shClEventSourceUnregisterEventInternal(PSHCLEVENTSOURCE pSource, PSHCLEVENT pEvent) +{ + LogFlowFunc(("idEvent=%RU32, cRefs=%RU32\n", pEvent->idEvent, pEvent->cRefs)); + + AssertReturn(pEvent->cRefs == 0, VERR_WRONG_ORDER); + + int rc = RTCritSectEnter(&pSource->CritSect); + if (RT_SUCCESS(rc)) + { + RTListNodeRemove(&pEvent->Node); + + shClEventDestroy(pEvent); + + rc = RTCritSectLeave(&pSource->CritSect); + if (RT_SUCCESS(rc)) + { + RTMemFree(pEvent); + pEvent = NULL; + } + } + + return rc; +} + +/** + * Returns a specific event of a event source. Inlined version. + * + * @returns Pointer to event if found, or NULL if not found. + * @param pSource Event source to get event from. + * @param uID Event ID to get. + */ +DECLINLINE(PSHCLEVENT) shclEventGet(PSHCLEVENTSOURCE pSource, SHCLEVENTID idEvent) +{ + PSHCLEVENT pEvent; + RTListForEach(&pSource->lstEvents, pEvent, SHCLEVENT, Node) + { + if (pEvent->idEvent == idEvent) + return pEvent; + } + + return NULL; +} + +/** + * Returns a specific event of a event source. + * + * @returns Pointer to event if found, or NULL if not found. + * @param pSource Event source to get event from. + * @param idEvent ID of event to return. + */ +PSHCLEVENT ShClEventSourceGetFromId(PSHCLEVENTSOURCE pSource, SHCLEVENTID idEvent) +{ + AssertPtrReturn(pSource, NULL); + + int rc = RTCritSectEnter(&pSource->CritSect); + if (RT_SUCCESS(rc)) + { + PSHCLEVENT pEvent = shclEventGet(pSource, idEvent); + + rc = RTCritSectLeave(&pSource->CritSect); + AssertRC(rc); + + return pEvent; + } + + return NULL; +} + +/** + * Returns the last (newest) event ID which has been registered for an event source. + * + * @returns Pointer to last registered event, or NULL if not found. + * @param pSource Event source to get last registered event from. + */ +PSHCLEVENT ShClEventSourceGetLast(PSHCLEVENTSOURCE pSource) +{ + AssertPtrReturn(pSource, NULL); + + int rc = RTCritSectEnter(&pSource->CritSect); + if (RT_SUCCESS(rc)) + { + PSHCLEVENT pEvent = RTListGetLast(&pSource->lstEvents, SHCLEVENT, Node); + + rc = RTCritSectLeave(&pSource->CritSect); + AssertRC(rc); + + return pEvent; + } + + return NULL; +} + +/** + * Returns the current reference count for a specific event. + * + * @returns Reference count. + * @param pSource Event source the specific event is part of. + * @param idEvent Event ID to return reference count for. + */ +uint32_t ShClEventGetRefs(PSHCLEVENT pEvent) +{ + AssertPtrReturn(pEvent, 0); + + return ASMAtomicReadU32(&pEvent->cRefs); +} + +/** + * Detaches a payload from an event, internal version. + * + * @returns Pointer to the detached payload. Can be NULL if the payload has no payload. + * @param pEvent Event to detach payload for. + */ +static PSHCLEVENTPAYLOAD shclEventPayloadDetachInternal(PSHCLEVENT pEvent) +{ +#ifdef VBOX_STRICT + AssertPtrReturn(pEvent, NULL); +#endif + + PSHCLEVENTPAYLOAD pPayload = pEvent->pPayload; + + pEvent->pPayload = NULL; + + return pPayload; +} + +/** + * Waits for an event to get signalled. + * + * @returns VBox status code. + * @param pEvent Event to wait for. + * @param uTimeoutMs Timeout (in ms) to wait. + * @param ppPayload Where to store the (allocated) event payload on success. Needs to be free'd with + * SharedClipboardPayloadFree(). Optional. + */ +int ShClEventWait(PSHCLEVENT pEvent, RTMSINTERVAL uTimeoutMs, PSHCLEVENTPAYLOAD *ppPayload) +{ + AssertPtrReturn(pEvent, VERR_INVALID_POINTER); + AssertPtrNullReturn(ppPayload, VERR_INVALID_POINTER); + LogFlowFuncEnter(); + + int rc = RTSemEventMultiWait(pEvent->hEvtMulSem, uTimeoutMs); + if (RT_SUCCESS(rc)) + { + if (ppPayload) + { + /* Make sure to detach payload here, as the caller now owns the data. */ + *ppPayload = shclEventPayloadDetachInternal(pEvent); + } + } + + if (RT_FAILURE(rc)) + LogRel2(("Shared Clipboard: Waiting for event %RU32 failed, rc=%Rrc\n", pEvent->idEvent, rc)); + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Retains an event by increasing its reference count. + * + * @returns New reference count, or UINT32_MAX if failed. + * @param pEvent Event to retain. + */ +uint32_t ShClEventRetain(PSHCLEVENT pEvent) +{ + AssertPtrReturn(pEvent, UINT32_MAX); + AssertReturn(ASMAtomicReadU32(&pEvent->cRefs) < 64, UINT32_MAX); + return ASMAtomicIncU32(&pEvent->cRefs); +} + +/** + * Releases an event by decreasing its reference count. + * + * @returns New reference count, or UINT32_MAX if failed. + * @param pEvent Event to release. + * If the reference count reaches 0, the event will + * be destroyed and \a pEvent will be invalid. + */ +uint32_t ShClEventRelease(PSHCLEVENT pEvent) +{ + if (!pEvent) + return 0; + + AssertReturn(ASMAtomicReadU32(&pEvent->cRefs) > 0, UINT32_MAX); + + uint32_t const cRefs = ASMAtomicDecU32(&pEvent->cRefs); + if (cRefs == 0) + { + AssertPtr(pEvent->pParent); + int rc2 = shClEventSourceUnregisterEventInternal(pEvent->pParent, pEvent); + AssertRC(rc2); + + return RT_SUCCESS(rc2) ? 0 : UINT32_MAX; + } + + return cRefs; +} + +/** + * Signals an event. + * + * @returns VBox status code. + * @param pEvent Event to signal. + * @param pPayload Event payload to associate. Takes ownership on + * success. Optional. + */ +int ShClEventSignal(PSHCLEVENT pEvent, PSHCLEVENTPAYLOAD pPayload) +{ + AssertPtrReturn(pEvent, VERR_INVALID_POINTER); + + Assert(pEvent->pPayload == NULL); + + pEvent->pPayload = pPayload; + + int rc = RTSemEventMultiSignal(pEvent->hEvtMulSem); + if (RT_FAILURE(rc)) + pEvent->pPayload = NULL; /* (no race condition if consumer also enters the critical section) */ + + LogFlowFuncLeaveRC(rc); + return rc; +} + +int ShClUtf16LenUtf8(PCRTUTF16 pcwszSrc, size_t cwcSrc, size_t *pchLen) +{ + AssertPtrReturn(pcwszSrc, VERR_INVALID_POINTER); + AssertPtrReturn(pchLen, VERR_INVALID_POINTER); + + size_t chLen = 0; + int rc = RTUtf16CalcUtf8LenEx(pcwszSrc, cwcSrc, &chLen); + if (RT_SUCCESS(rc)) + *pchLen = chLen; + return rc; +} + +int ShClConvUtf16CRLFToUtf8LF(PCRTUTF16 pcwszSrc, size_t cwcSrc, + char *pszBuf, size_t cbBuf, size_t *pcbLen) +{ + AssertPtrReturn(pcwszSrc, VERR_INVALID_POINTER); + AssertReturn (cwcSrc, VERR_INVALID_PARAMETER); + AssertPtrReturn(pszBuf, VERR_INVALID_POINTER); + AssertPtrReturn(pcbLen, VERR_INVALID_POINTER); + + int rc; + + PRTUTF16 pwszTmp = NULL; + size_t cchTmp = 0; + + size_t cbLen = 0; + + /* How long will the converted text be? */ + rc = ShClUtf16CRLFLenUtf8(pcwszSrc, cwcSrc, &cchTmp); + if (RT_SUCCESS(rc)) + { + cchTmp++; /* Add space for terminator. */ + + pwszTmp = (PRTUTF16)RTMemAlloc(cchTmp * sizeof(RTUTF16)); + if (pwszTmp) + { + rc = ShClConvUtf16CRLFToLF(pcwszSrc, cwcSrc, pwszTmp, cchTmp); + if (RT_SUCCESS(rc)) + rc = RTUtf16ToUtf8Ex(pwszTmp + 1, cchTmp - 1, &pszBuf, cbBuf, &cbLen); + + RTMemFree(reinterpret_cast<void *>(pwszTmp)); + } + else + rc = VERR_NO_MEMORY; + } + + if (RT_SUCCESS(rc)) + { + *pcbLen = cbLen; + } + + return rc; +} + +int ShClConvUtf16LFToCRLFA(PCRTUTF16 pcwszSrc, size_t cwcSrc, + PRTUTF16 *ppwszDst, size_t *pcwDst) +{ + AssertPtrReturn(pcwszSrc, VERR_INVALID_POINTER); + AssertPtrReturn(ppwszDst, VERR_INVALID_POINTER); + AssertPtrReturn(pcwDst, VERR_INVALID_POINTER); + + PRTUTF16 pwszDst = NULL; + size_t cchDst; + + int rc = ShClUtf16LFLenUtf8(pcwszSrc, cwcSrc, &cchDst); + if (RT_SUCCESS(rc)) + { + pwszDst = (PRTUTF16)RTMemAlloc((cchDst + 1 /* Leave space for terminator */) * sizeof(RTUTF16)); + if (pwszDst) + { + rc = ShClConvUtf16LFToCRLF(pcwszSrc, cwcSrc, pwszDst, cchDst + 1 /* Include terminator */); + } + else + rc = VERR_NO_MEMORY; + } + + if (RT_SUCCESS(rc)) + { + *ppwszDst = pwszDst; + *pcwDst = cchDst; + } + else + RTMemFree(pwszDst); + + LogFlowFuncLeaveRC(rc); + return rc; +} + +int ShClConvUtf8LFToUtf16CRLF(const char *pcszSrc, size_t cbSrc, + PRTUTF16 *ppwszDst, size_t *pcwDst) +{ + AssertPtrReturn(pcszSrc, VERR_INVALID_POINTER); + AssertReturn(cbSrc, VERR_INVALID_PARAMETER); + AssertPtrReturn(ppwszDst, VERR_INVALID_POINTER); + AssertPtrReturn(pcwDst, VERR_INVALID_POINTER); + + /* Intermediate conversion to UTF-16. */ + size_t cwcTmp; + PRTUTF16 pwcTmp = NULL; + int rc = RTStrToUtf16Ex(pcszSrc, cbSrc, &pwcTmp, 0, &cwcTmp); + if (RT_SUCCESS(rc)) + { + rc = ShClConvUtf16LFToCRLFA(pwcTmp, cwcTmp, ppwszDst, pcwDst); + RTUtf16Free(pwcTmp); + } + + return rc; +} + +/** + * Converts a Latin-1 string with LF line endings into an UTF-16 string with CRLF endings. + * + * @returns VBox status code. + * @param pcszSrc Latin-1 string to convert. + * @param cbSrc Size (in bytes) of Latin-1 string to convert. + * @param ppwszDst Where to return the converted UTF-16 string on success. + * @param pcwDst Where to return the length (in UTF-16 characters) on success. + * + * @note Only converts the source until the string terminator is found (or length limit is hit). + */ +int ShClConvLatin1LFToUtf16CRLF(const char *pcszSrc, size_t cbSrc, + PRTUTF16 *ppwszDst, size_t *pcwDst) +{ + AssertPtrReturn(pcszSrc, VERR_INVALID_POINTER); + AssertReturn(cbSrc, VERR_INVALID_PARAMETER); + AssertPtrReturn(ppwszDst, VERR_INVALID_POINTER); + AssertPtrReturn(pcwDst, VERR_INVALID_POINTER); + + size_t chSrc = 0; + + PRTUTF16 pwszDst = NULL; + + /* Calculate the space needed. */ + size_t cwDst = 0; + for (size_t i = 0; i < cbSrc && pcszSrc[i] != '\0'; ++i) + { + if (pcszSrc[i] == VBOX_SHCL_LINEFEED) + cwDst += 2; /* Space for VBOX_SHCL_CARRIAGERETURN + VBOX_SHCL_LINEFEED. */ + else + ++cwDst; + chSrc++; + } + + pwszDst = (PRTUTF16)RTMemAlloc((cwDst + 1 /* Leave space for the terminator */) * sizeof(RTUTF16)); + AssertPtrReturn(pwszDst, VERR_NO_MEMORY); + + /* Do the conversion, bearing in mind that Latin-1 expands "naturally" to UTF-16. */ + for (size_t i = 0, j = 0; i < chSrc; ++i, ++j) + { + AssertMsg(j <= cwDst, ("cbSrc=%zu, j=%u vs. cwDst=%u\n", cbSrc, j, cwDst)); + if (pcszSrc[i] != VBOX_SHCL_LINEFEED) + pwszDst[j] = pcszSrc[i]; + else + { + pwszDst[j] = VBOX_SHCL_CARRIAGERETURN; + pwszDst[j + 1] = VBOX_SHCL_LINEFEED; + ++j; + } + } + + pwszDst[cwDst] = '\0'; /* Make sure we are zero-terminated. */ + + *ppwszDst = pwszDst; + *pcwDst = cwDst; + + return VINF_SUCCESS; +} + +int ShClConvUtf16ToUtf8HTML(PCRTUTF16 pcwszSrc, size_t cwcSrc, char **ppszDst, size_t *pcbDst) +{ + AssertPtrReturn(pcwszSrc, VERR_INVALID_POINTER); + AssertReturn (cwcSrc, VERR_INVALID_PARAMETER); + AssertPtrReturn(ppszDst, VERR_INVALID_POINTER); + AssertPtrReturn(pcbDst, VERR_INVALID_POINTER); + + int rc = VINF_SUCCESS; + + size_t cwTmp = cwcSrc; + PCRTUTF16 pwTmp = pcwszSrc; + + char *pchDst = NULL; + size_t cbDst = 0; + + size_t i = 0; + while (i < cwTmp) + { + /* Find zero symbol (end of string). */ + for (; i < cwTmp && pcwszSrc[i] != 0; i++) + ; + + /* Convert found string. */ + char *psz = NULL; + size_t cch = 0; + rc = RTUtf16ToUtf8Ex(pwTmp, cwTmp, &psz, pwTmp - pcwszSrc, &cch); + if (RT_FAILURE(rc)) + break; + + /* Append new substring. */ + char *pchNew = (char *)RTMemRealloc(pchDst, cbDst + cch + 1); + if (!pchNew) + { + RTStrFree(psz); + rc = VERR_NO_MEMORY; + break; + } + + pchDst = pchNew; + memcpy(pchDst + cbDst, psz, cch + 1); + + RTStrFree(psz); + + cbDst += cch + 1; + + /* Skip zero symbols. */ + for (; i < cwTmp && pcwszSrc[i] == 0; i++) + ; + + /* Remember start of string. */ + pwTmp += i; + } + + if (RT_SUCCESS(rc)) + { + *ppszDst = pchDst; + *pcbDst = cbDst; + + return VINF_SUCCESS; + } + + RTMemFree(pchDst); + + return rc; +} + +int ShClUtf16LFLenUtf8(PCRTUTF16 pcwszSrc, size_t cwSrc, size_t *pchLen) +{ + AssertPtrReturn(pcwszSrc, VERR_INVALID_POINTER); + AssertPtrReturn(pchLen, VERR_INVALID_POINTER); + + AssertMsgReturn(pcwszSrc[0] != VBOX_SHCL_UTF16BEMARKER, + ("Big endian UTF-16 not supported yet\n"), VERR_NOT_SUPPORTED); + + size_t cLen = 0; + + /* Don't copy the endian marker. */ + size_t i = pcwszSrc[0] == VBOX_SHCL_UTF16LEMARKER ? 1 : 0; + + /* Calculate the size of the destination text string. */ + /* Is this Utf16 or Utf16-LE? */ + for (; i < cwSrc; ++i, ++cLen) + { + /* Check for a single line feed */ + if (pcwszSrc[i] == VBOX_SHCL_LINEFEED) + ++cLen; +#ifdef RT_OS_DARWIN + /* Check for a single carriage return (MacOS) */ + if (pcwszSrc[i] == VBOX_SHCL_CARRIAGERETURN) + ++cLen; +#endif + if (pcwszSrc[i] == 0) + { + /* Don't count this, as we do so below. */ + break; + } + } + + *pchLen = cLen; + + return VINF_SUCCESS; +} + +int ShClUtf16CRLFLenUtf8(PCRTUTF16 pcwszSrc, size_t cwSrc, size_t *pchLen) +{ + AssertPtrReturn(pcwszSrc, VERR_INVALID_POINTER); + AssertReturn(cwSrc, VERR_INVALID_PARAMETER); + AssertPtrReturn(pchLen, VERR_INVALID_POINTER); + + AssertMsgReturn(pcwszSrc[0] != VBOX_SHCL_UTF16BEMARKER, + ("Big endian UTF-16 not supported yet\n"), VERR_NOT_SUPPORTED); + + size_t cLen = 0; + + /* Calculate the size of the destination text string. */ + /* Is this Utf16 or Utf16-LE? */ + if (pcwszSrc[0] == VBOX_SHCL_UTF16LEMARKER) + cLen = 0; + else + cLen = 1; + + for (size_t i = 0; i < cwSrc; ++i, ++cLen) + { + if ( (i + 1 < cwSrc) + && (pcwszSrc[i] == VBOX_SHCL_CARRIAGERETURN) + && (pcwszSrc[i + 1] == VBOX_SHCL_LINEFEED)) + { + ++i; + } + if (pcwszSrc[i] == 0) + break; + } + + *pchLen = cLen; + + return VINF_SUCCESS; +} + +int ShClConvUtf16LFToCRLF(PCRTUTF16 pcwszSrc, size_t cwcSrc, PRTUTF16 pu16Dst, size_t cwDst) +{ + AssertPtrReturn(pcwszSrc, VERR_INVALID_POINTER); + AssertPtrReturn(pu16Dst, VERR_INVALID_POINTER); + AssertReturn(cwDst, VERR_INVALID_PARAMETER); + + AssertMsgReturn(pcwszSrc[0] != VBOX_SHCL_UTF16BEMARKER, + ("Big endian UTF-16 not supported yet\n"), VERR_NOT_SUPPORTED); + + int rc = VINF_SUCCESS; + + /* Don't copy the endian marker. */ + size_t i = pcwszSrc[0] == VBOX_SHCL_UTF16LEMARKER ? 1 : 0; + size_t j = 0; + + for (; i < cwcSrc; ++i, ++j) + { + /* Don't copy the null byte, as we add it below. */ + if (pcwszSrc[i] == 0) + break; + + /* Not enough space in destination? */ + if (j == cwDst) + { + rc = VERR_BUFFER_OVERFLOW; + break; + } + + if (pcwszSrc[i] == VBOX_SHCL_LINEFEED) + { + pu16Dst[j] = VBOX_SHCL_CARRIAGERETURN; + ++j; + + /* Not enough space in destination? */ + if (j == cwDst) + { + rc = VERR_BUFFER_OVERFLOW; + break; + } + } +#ifdef RT_OS_DARWIN + /* Check for a single carriage return (MacOS) */ + else if (pcwszSrc[i] == VBOX_SHCL_CARRIAGERETURN) + { + /* Set CR.r */ + pu16Dst[j] = VBOX_SHCL_CARRIAGERETURN; + ++j; + + /* Not enough space in destination? */ + if (j == cwDst) + { + rc = VERR_BUFFER_OVERFLOW; + break; + } + + /* Add line feed. */ + pu16Dst[j] = VBOX_SHCL_LINEFEED; + continue; + } +#endif + pu16Dst[j] = pcwszSrc[i]; + } + + if (j == cwDst) + rc = VERR_BUFFER_OVERFLOW; + + if (RT_SUCCESS(rc)) + { + /* Add terminator. */ + pu16Dst[j] = 0; + } + + return rc; +} + +int ShClConvUtf16CRLFToLF(PCRTUTF16 pcwszSrc, size_t cwcSrc, PRTUTF16 pu16Dst, size_t cwDst) +{ + AssertPtrReturn(pcwszSrc, VERR_INVALID_POINTER); + AssertReturn(cwcSrc, VERR_INVALID_PARAMETER); + AssertPtrReturn(pu16Dst, VERR_INVALID_POINTER); + AssertReturn(cwDst, VERR_INVALID_PARAMETER); + + AssertMsgReturn(pcwszSrc[0] != VBOX_SHCL_UTF16BEMARKER, + ("Big endian UTF-16 not supported yet\n"), VERR_NOT_SUPPORTED); + + /* Prepend the Utf16 byte order marker if it is missing. */ + size_t cwDstPos; + if (pcwszSrc[0] == VBOX_SHCL_UTF16LEMARKER) + { + cwDstPos = 0; + } + else + { + pu16Dst[0] = VBOX_SHCL_UTF16LEMARKER; + cwDstPos = 1; + } + + for (size_t i = 0; i < cwcSrc; ++i, ++cwDstPos) + { + if (pcwszSrc[i] == 0) + break; + + if (cwDstPos == cwDst) + return VERR_BUFFER_OVERFLOW; + + if ( (i + 1 < cwcSrc) + && (pcwszSrc[i] == VBOX_SHCL_CARRIAGERETURN) + && (pcwszSrc[i + 1] == VBOX_SHCL_LINEFEED)) + { + ++i; + } + + pu16Dst[cwDstPos] = pcwszSrc[i]; + } + + if (cwDstPos == cwDst) + return VERR_BUFFER_OVERFLOW; + + /* Add terminating zero. */ + pu16Dst[cwDstPos] = 0; + + return VINF_SUCCESS; +} + +int ShClDibToBmp(const void *pvSrc, size_t cbSrc, void **ppvDest, size_t *pcbDest) +{ + AssertPtrReturn(pvSrc, VERR_INVALID_POINTER); + AssertReturn(cbSrc, VERR_INVALID_PARAMETER); + AssertPtrReturn(ppvDest, VERR_INVALID_POINTER); + AssertPtrReturn(pcbDest, VERR_INVALID_POINTER); + + PBMPWIN3XINFOHDR coreHdr = (PBMPWIN3XINFOHDR)pvSrc; + /** @todo Support all the many versions of the DIB headers. */ + if ( cbSrc < sizeof(BMPWIN3XINFOHDR) + || RT_LE2H_U32(coreHdr->cbSize) < sizeof(BMPWIN3XINFOHDR) + || RT_LE2H_U32(coreHdr->cbSize) != sizeof(BMPWIN3XINFOHDR)) + { + return VERR_INVALID_PARAMETER; + } + + size_t offPixel = sizeof(BMPFILEHDR) + + RT_LE2H_U32(coreHdr->cbSize) + + RT_LE2H_U32(coreHdr->cClrUsed) * sizeof(uint32_t); + if (cbSrc < offPixel) + return VERR_INVALID_PARAMETER; + + size_t cbDst = sizeof(BMPFILEHDR) + cbSrc; + + void *pvDest = RTMemAlloc(cbDst); + if (!pvDest) + return VERR_NO_MEMORY; + + PBMPFILEHDR fileHdr = (PBMPFILEHDR)pvDest; + + fileHdr->uType = BMP_HDR_MAGIC; + fileHdr->cbFileSize = (uint32_t)RT_H2LE_U32(cbDst); + fileHdr->Reserved1 = 0; + fileHdr->Reserved2 = 0; + fileHdr->offBits = (uint32_t)RT_H2LE_U32(offPixel); + + memcpy((uint8_t *)pvDest + sizeof(BMPFILEHDR), pvSrc, cbSrc); + + *ppvDest = pvDest; + *pcbDest = cbDst; + + return VINF_SUCCESS; +} + +int ShClBmpGetDib(const void *pvSrc, size_t cbSrc, const void **ppvDest, size_t *pcbDest) +{ + AssertPtrReturn(pvSrc, VERR_INVALID_POINTER); + AssertReturn(cbSrc, VERR_INVALID_PARAMETER); + AssertPtrReturn(ppvDest, VERR_INVALID_POINTER); + AssertPtrReturn(pcbDest, VERR_INVALID_POINTER); + + PBMPFILEHDR pBmpHdr = (PBMPFILEHDR)pvSrc; + if ( cbSrc < sizeof(BMPFILEHDR) + || pBmpHdr->uType != BMP_HDR_MAGIC + || RT_LE2H_U32(pBmpHdr->cbFileSize) != cbSrc) + { + return VERR_INVALID_PARAMETER; + } + + *ppvDest = ((uint8_t *)pvSrc) + sizeof(BMPFILEHDR); + *pcbDest = cbSrc - sizeof(BMPFILEHDR); + + return VINF_SUCCESS; +} + +#ifdef LOG_ENABLED + +int ShClDbgDumpHtml(const char *pcszSrc, size_t cbSrc) +{ + int rc = VINF_SUCCESS; + char *pszBuf = (char *)RTMemTmpAllocZ(cbSrc + 1); + if (pszBuf) + { + memcpy(pszBuf, pcszSrc, cbSrc); + pszBuf[cbSrc] = '\0'; + for (size_t off = 0; off < cbSrc; ++off) + if (pszBuf[off] == '\n' || pszBuf[off] == '\r') + pszBuf[off] = ' '; + LogFunc(("Removed \\r\\n: %s\n", pszBuf)); + RTMemTmpFree(pszBuf); + } + else + rc = VERR_NO_MEMORY; + return rc; +} + +void ShClDbgDumpData(const void *pv, size_t cb, SHCLFORMAT uFormat) +{ + if (LogIsEnabled()) + { + if (uFormat & VBOX_SHCL_FMT_UNICODETEXT) + { + LogFunc(("VBOX_SHCL_FMT_UNICODETEXT:\n")); + if (pv && cb) + LogFunc(("%ls\n", pv)); + else + LogFunc(("%p %zu\n", pv, cb)); + } + else if (uFormat & VBOX_SHCL_FMT_BITMAP) + LogFunc(("VBOX_SHCL_FMT_BITMAP\n")); + else if (uFormat & VBOX_SHCL_FMT_HTML) + { + LogFunc(("VBOX_SHCL_FMT_HTML:\n")); + if (pv && cb) + { + LogFunc(("%s\n", pv)); + ShClDbgDumpHtml((const char *)pv, cb); + } + else + LogFunc(("%p %zu\n", pv, cb)); + } + else + LogFunc(("Invalid format %02X\n", uFormat)); + } +} + +#endif /* LOG_ENABLED */ + +/** + * Translates a Shared Clipboard host function number to a string. + * + * @returns Function ID string name. + * @param uFn The function to translate. + */ +const char *ShClHostFunctionToStr(uint32_t uFn) +{ + switch (uFn) + { + RT_CASE_RET_STR(VBOX_SHCL_HOST_FN_SET_MODE); + RT_CASE_RET_STR(VBOX_SHCL_HOST_FN_SET_TRANSFER_MODE); + RT_CASE_RET_STR(VBOX_SHCL_HOST_FN_SET_HEADLESS); + RT_CASE_RET_STR(VBOX_SHCL_HOST_FN_CANCEL); + RT_CASE_RET_STR(VBOX_SHCL_HOST_FN_ERROR); + } + return "Unknown"; +} + +/** + * Translates a Shared Clipboard host message enum to a string. + * + * @returns Message ID string name. + * @param uMsg The message to translate. + */ +const char *ShClHostMsgToStr(uint32_t uMsg) +{ + switch (uMsg) + { + RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_QUIT); + RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_READ_DATA); + RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_FORMATS_REPORT); + RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_CANCELED); + RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_READ_DATA_CID); + RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_STATUS); + RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_ROOT_LIST_HDR_READ); + RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_ROOT_LIST_HDR_WRITE); + RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_ROOT_LIST_ENTRY_READ); + RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_ROOT_LIST_ENTRY_WRITE); + RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_OPEN); + RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_CLOSE); + RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_HDR_READ); + RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_HDR_WRITE); + RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_ENTRY_READ); + RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_LIST_ENTRY_WRITE); + RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_OPEN); + RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_CLOSE); + RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_READ); + RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_WRITE); + RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_CANCEL); + RT_CASE_RET_STR(VBOX_SHCL_HOST_MSG_TRANSFER_ERROR); + } + return "Unknown"; +} + +/** + * Translates a Shared Clipboard guest message enum to a string. + * + * @returns Message ID string name. + * @param uMsg The message to translate. + */ +const char *ShClGuestMsgToStr(uint32_t uMsg) +{ + switch (uMsg) + { + RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_MSG_OLD_GET_WAIT); + RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_REPORT_FORMATS); + RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_DATA_READ); + RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_DATA_WRITE); + RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_CONNECT); + RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_REPORT_FEATURES); + RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_QUERY_FEATURES); + RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_MSG_PEEK_NOWAIT); + RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_MSG_PEEK_WAIT); + RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_MSG_GET); + RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_MSG_CANCEL); + RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_REPLY); + RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_ROOT_LIST_HDR_READ); + RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_ROOT_LIST_HDR_WRITE); + RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_ROOT_LIST_ENTRY_READ); + RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_ROOT_LIST_ENTRY_WRITE); + RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_LIST_OPEN); + RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_LIST_CLOSE); + RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_LIST_HDR_READ); + RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_LIST_HDR_WRITE); + RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_LIST_ENTRY_READ); + RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_LIST_ENTRY_WRITE); + RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_OBJ_OPEN); + RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_OBJ_CLOSE); + RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_OBJ_READ); + RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_OBJ_WRITE); + RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_ERROR); + RT_CASE_RET_STR(VBOX_SHCL_GUEST_FN_NEGOTIATE_CHUNK_SIZE); + } + return "Unknown"; +} + +/** + * Converts Shared Clipboard formats to a string. + * + * @returns Stringified Shared Clipboard formats, or NULL on failure. Must be free'd with RTStrFree(). + * @param fFormats Shared Clipboard formats to convert. + * + */ +char *ShClFormatsToStrA(SHCLFORMATS fFormats) +{ +#define APPEND_FMT_TO_STR(_aFmt) \ + if (fFormats & VBOX_SHCL_FMT_##_aFmt) \ + { \ + if (pszFmts) \ + { \ + rc2 = RTStrAAppend(&pszFmts, ", "); \ + if (RT_FAILURE(rc2)) \ + break; \ + } \ + \ + rc2 = RTStrAAppend(&pszFmts, #_aFmt); \ + if (RT_FAILURE(rc2)) \ + break; \ + } + + char *pszFmts = NULL; + int rc2 = VINF_SUCCESS; + + do + { + APPEND_FMT_TO_STR(UNICODETEXT); + APPEND_FMT_TO_STR(BITMAP); + APPEND_FMT_TO_STR(HTML); +# ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS + APPEND_FMT_TO_STR(URI_LIST); +# endif + + } while (0); + + if (!pszFmts) + rc2 = RTStrAAppend(&pszFmts, "NONE"); + + if ( RT_FAILURE(rc2) + && pszFmts) + { + RTStrFree(pszFmts); + pszFmts = NULL; + } + +#undef APPEND_FMT_TO_STR + + return pszFmts; +} + diff --git a/src/VBox/GuestHost/SharedClipboard/clipboard-transfers-http.cpp b/src/VBox/GuestHost/SharedClipboard/clipboard-transfers-http.cpp new file mode 100644 index 00000000..4c0c6100 --- /dev/null +++ b/src/VBox/GuestHost/SharedClipboard/clipboard-transfers-http.cpp @@ -0,0 +1,862 @@ +/* $Id: clipboard-transfers-http.cpp $ */ +/** @file + * Shared Clipboard: HTTP server implementation for Shared Clipboard transfers on UNIX-y guests / hosts. + */ + +/* + * Copyright (C) 2020-2022 Oracle and/or its affiliates. + * + * This file is part of VirtualBox base platform packages, as + * available from https://www.virtualbox.org. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, in version 3 of the + * License. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <https://www.gnu.org/licenses>. + * + * SPDX-License-Identifier: GPL-3.0-only + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <signal.h> + +#include <iprt/http.h> +#include <iprt/http-server.h> + +#include <iprt/net.h> /* To make use of IPv4Addr in RTGETOPTUNION. */ + +#include <iprt/asm.h> +#include <iprt/assert.h> +#include <iprt/ctype.h> +#include <iprt/errcore.h> +#include <iprt/file.h> +#include <iprt/getopt.h> +#include <iprt/initterm.h> +#include <iprt/list.h> +#define LOG_GROUP LOG_GROUP_SHARED_CLIPBOARD +#include <iprt/log.h> +#include <iprt/mem.h> +#include <iprt/message.h> +#include <iprt/path.h> +#include <iprt/rand.h> +#include <iprt/stream.h> +#include <iprt/string.h> +#include <iprt/thread.h> +#include <iprt/uuid.h> +#include <iprt/vfs.h> + +#include <VBox/HostServices/VBoxClipboardSvc.h> +#include <VBox/GuestHost/SharedClipboard-x11.h> +#include <VBox/GuestHost/SharedClipboard-transfers.h> + + +/********************************************************************************************************************************* +* Definitations * +*********************************************************************************************************************************/ + +typedef struct _SHCLHTTPSERVERTRANSFER +{ + /** The node list. */ + RTLISTNODE Node; + /** Pointer to associated transfer. */ + PSHCLTRANSFER pTransfer; + /** The (cached) root list of the transfer. NULL if not cached yet. */ + PSHCLROOTLIST pRootList; + /** Critical section for serializing access. */ + RTCRITSECT CritSect; + /** The handle we're going to use for this HTTP transfer. */ + SHCLOBJHANDLE hObj; + /** The virtual path of the HTTP server's root directory for this transfer. */ + char szPathVirtual[RTPATH_MAX]; +} SHCLHTTPSERVERTRANSFER; +typedef SHCLHTTPSERVERTRANSFER *PSHCLHTTPSERVERTRANSFER; + + +/********************************************************************************************************************************* +* Prototypes * +*********************************************************************************************************************************/ +static int shClTransferHttpServerDestroyInternal(PSHCLHTTPSERVER pThis); +static const char *shClTransferHttpServerGetHost(PSHCLHTTPSERVER pSrv); + + +/********************************************************************************************************************************* +* Public Shared Clipboard HTTP transfer functions * +*********************************************************************************************************************************/ + +/** + * Registers a Shared Clipboard transfer to a HTTP context. + * + * @returns VBox status code. + * @param pCtx HTTP context to register transfer for. + * @param pTransfer Transfer to register. + */ +int ShClHttpTransferRegister(PSHCLHTTPCONTEXT pCtx, PSHCLTRANSFER pTransfer) +{ + int rc = VINF_SUCCESS; + + /* Start the built-in HTTP server to serve file(s). */ + if (!ShClTransferHttpServerIsRunning(&pCtx->HttpServer)) /* Only one HTTP server per transfer context. */ + rc = ShClTransferHttpServerCreate(&pCtx->HttpServer, NULL /* puPort */); + + if (RT_SUCCESS(rc)) + rc = ShClTransferHttpServerRegisterTransfer(&pCtx->HttpServer, pTransfer); + + return rc; +} + +/** + * Unregisters a formerly registered Shared Clipboard transfer. + * + * @returns VBox status code. + * @param pCtx HTTP context to unregister transfer from. + * @param pTransfer Transfer to unregister. + */ +int ShClHttpTransferUnregister(PSHCLHTTPCONTEXT pCtx, PSHCLTRANSFER pTransfer) +{ + int rc = VINF_SUCCESS; + + if (ShClTransferHttpServerIsRunning(&pCtx->HttpServer)) + { + /* Try unregistering transfer (if it was registered before). */ + rc = ShClTransferHttpServerUnregisterTransfer(&pCtx->HttpServer, pTransfer); + if (RT_SUCCESS(rc)) + { + /* No more registered transfers left? Tear down the HTTP server instance then. */ + if (ShClTransferHttpServerGetTransferCount(&pCtx->HttpServer) == 0) + rc = ShClTransferHttpServerDestroy(&pCtx->HttpServer); + } + AssertRC(rc); + } + + return rc; +} + + +/********************************************************************************************************************************* +* Internal Shared Clipboard HTTP transfer functions * +*********************************************************************************************************************************/ + +DECLINLINE(void) shClHttpTransferLock(PSHCLHTTPSERVERTRANSFER pSrvTx) +{ + int rc2 = RTCritSectEnter(&pSrvTx->CritSect); + AssertRC(rc2); +} + +DECLINLINE(void) shClHttpTransferUnlock(PSHCLHTTPSERVERTRANSFER pSrvTx) +{ + int rc2 = RTCritSectEnter(&pSrvTx->CritSect); + AssertRC(rc2); +} + +/** + * Return the HTTP server transfer for a specific transfer ID. + * + * @returns Pointer to HTTP server transfer if found, NULL if not found. + * @param pSrv HTTP server instance. + * @param idTransfer Transfer ID to return HTTP server transfer for. + */ +static PSHCLHTTPSERVERTRANSFER shClTransferHttpServerGetTransferById(PSHCLHTTPSERVER pSrv, SHCLTRANSFERID idTransfer) +{ + PSHCLHTTPSERVERTRANSFER pSrvTx; + RTListForEach(&pSrv->lstTransfers, pSrvTx, SHCLHTTPSERVERTRANSFER, Node) /** @todo Slow O(n) lookup, but does it for now. */ + { + if (pSrvTx->pTransfer->State.uID == idTransfer) + return pSrvTx; + } + + return NULL; +} + +/** + * Returns a HTTP server transfer from a given URL. + * + * @returns Pointer to HTTP server transfer if found, NULL if not found. + * @param pThis HTTP server instance data. + * @param pszUrl URL to validate. + */ +DECLINLINE(PSHCLHTTPSERVERTRANSFER) shClTransferHttpGetTransferFromUrl(PSHCLHTTPSERVER pThis, const char *pszUrl) +{ + AssertPtrReturn(pszUrl, NULL); + + PSHCLHTTPSERVERTRANSFER pSrvTx = NULL; + + PSHCLHTTPSERVERTRANSFER pSrvTxCur; + RTListForEach(&pThis->lstTransfers, pSrvTxCur, SHCLHTTPSERVERTRANSFER, Node) + { + AssertPtr(pSrvTxCur->pTransfer); + + LogFlowFunc(("pSrvTxCur=%s\n", pSrvTxCur->szPathVirtual)); + + /* Be picky here, do a case sensitive comparison. */ + if (RTStrStartsWith(pszUrl, pSrvTxCur->szPathVirtual)) + { + pSrvTx = pSrvTxCur; + break; + } + } + + if (!pSrvTx) + LogRel2(("Shared Clipboard: HTTP URL '%s' not valid\n", pszUrl)); + + LogFlowFunc(("pszUrl=%s, pSrvTx=%p\n", pszUrl, pSrvTx)); + return pSrvTx; +} + +/** + * Returns a HTTP server transfer from an internal HTTP handle. + * + * @returns Pointer to HTTP server transfer if found, NULL if not found. + * @param pThis HTTP server instance data. + * @param pvHandle Handle to return transfer for. + */ +DECLINLINE(PSHCLHTTPSERVERTRANSFER) shClTransferHttpGetTransferFromHandle(PSHCLHTTPSERVER pThis, void *pvHandle) +{ + AssertPtrReturn(pvHandle, NULL); + + const SHCLTRANSFERID uHandle = *(uint16_t *)pvHandle; + + /** @ŧodo Use a handle lookup table (map) later. */ + PSHCLHTTPSERVERTRANSFER pSrvTxCur; + RTListForEach(&pThis->lstTransfers, pSrvTxCur, SHCLHTTPSERVERTRANSFER, Node) + { + AssertPtr(pSrvTxCur->pTransfer); + + if (pSrvTxCur->pTransfer->State.uID == uHandle) /** @ŧodo We're using the transfer ID as handle for now. */ + return pSrvTxCur; + } + + return NULL; +} + +static int shClTransferHttpGetTransferRoots(PSHCLHTTPSERVER pThis, PSHCLHTTPSERVERTRANSFER pSrvTx) +{ + RT_NOREF(pThis); + + int rc = VINF_SUCCESS; + + if (pSrvTx->pRootList == NULL) + { + AssertPtr(pSrvTx->pTransfer); + rc = ShClTransferRootsGet(pSrvTx->pTransfer, &pSrvTx->pRootList); + } + + return rc; +} + + +/********************************************************************************************************************************* +* HTTP server callback implementations * +*********************************************************************************************************************************/ + +/** @copydoc RTHTTPSERVERCALLBACKS::pfnOpen */ +static DECLCALLBACK(int) shClTransferHttpOpen(PRTHTTPCALLBACKDATA pData, PRTHTTPSERVERREQ pReq, void **ppvHandle) +{ + PSHCLHTTPSERVER pThis = (PSHCLHTTPSERVER)pData->pvUser; + Assert(pData->cbUser == sizeof(SHCLHTTPSERVER)); + + int rc; + + PSHCLHTTPSERVERTRANSFER pSrvTx = shClTransferHttpGetTransferFromUrl(pThis, pReq->pszUrl); + if (pSrvTx) + { + shClHttpTransferLock(pSrvTx); + + AssertPtr(pSrvTx->pTransfer); + + SHCLOBJOPENCREATEPARMS openParms; + rc = ShClTransferObjOpenParmsInit(&openParms); + if (RT_SUCCESS(rc)) + { + openParms.fCreate = SHCL_OBJ_CF_ACCESS_READ + | SHCL_OBJ_CF_ACCESS_DENYWRITE; + + rc = RTStrCopy(openParms.pszPath, openParms.cbPath, "foo"); /** @ŧodo BUGBUG !!!! */ + if (RT_SUCCESS(rc)) + { + rc = ShClTransferObjOpen(pSrvTx->pTransfer, &openParms, &pSrvTx->hObj); + if (RT_SUCCESS(rc)) + { + *ppvHandle = &pSrvTx->hObj; + LogRel2(("Shared Clipboard: HTTP transfer (handle %RU64) started ...\n", pSrvTx->hObj)); + } + } + + ShClTransferObjOpenParmsDestroy(&openParms); + } + + shClHttpTransferUnlock(pSrvTx); + } + else + rc = VERR_NOT_FOUND; + + if (RT_FAILURE(rc)) + LogRel(("Shared Clipboard: Error starting HTTP transfer for '%s', rc=%Rrc\n", pReq->pszUrl, rc)); + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** @copydoc RTHTTPSERVERCALLBACKS::pfnRead */ +static DECLCALLBACK(int) shClTransferHttpRead(PRTHTTPCALLBACKDATA pData, void *pvHandle, void *pvBuf, size_t cbBuf, size_t *pcbRead) +{ + PSHCLHTTPSERVER pThis = (PSHCLHTTPSERVER)pData->pvUser; + Assert(pData->cbUser == sizeof(SHCLHTTPSERVER)); + + RT_NOREF(pvBuf, cbBuf, pcbRead); + + int rc; + + PSHCLHTTPSERVERTRANSFER pSrvTx = shClTransferHttpGetTransferFromHandle(pThis, pvHandle); + if (pSrvTx) + { + Assert(pSrvTx->hObj != SHCLOBJHANDLE_INVALID); + + uint32_t cbRead; + rc = ShClTransferObjRead(pSrvTx->pTransfer, pSrvTx->hObj, pvBuf, cbBuf, 0 /* fFlags */, &cbRead); + if (RT_SUCCESS(rc)) + { + *pcbRead = (uint32_t)cbRead; + } + + if (RT_FAILURE(rc)) + LogRel(("Shared Clipboard: Error reading HTTP transfer (handle %RU64), rc=%Rrc\n", pSrvTx->hObj, rc)); + } + else + rc = VERR_NOT_FOUND; + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** @copydoc RTHTTPSERVERCALLBACKS::pfnClose */ +static DECLCALLBACK(int) shClTransferHttpClose(PRTHTTPCALLBACKDATA pData, void *pvHandle) +{ + PSHCLHTTPSERVER pThis = (PSHCLHTTPSERVER)pData->pvUser; + Assert(pData->cbUser == sizeof(SHCLHTTPSERVER)); + + int rc; + + PSHCLHTTPSERVERTRANSFER pSrvTx = shClTransferHttpGetTransferFromHandle(pThis, pvHandle); + if (pSrvTx) + { + shClHttpTransferLock(pSrvTx); + + Assert(pSrvTx->hObj != SHCLOBJHANDLE_INVALID); + rc = ShClTransferObjClose(pSrvTx->pTransfer, pSrvTx->hObj); + if (RT_SUCCESS(rc)) + { + pSrvTx->hObj = SHCLOBJHANDLE_INVALID; + LogRel2(("Shared Clipboard: HTTP transfer %RU16 done\n", pSrvTx->pTransfer->State.uID)); + } + + if (RT_FAILURE(rc)) + LogRel(("Shared Clipboard: Error closing HTTP transfer (handle %RU64), rc=%Rrc\n", pSrvTx->hObj, rc)); + + shClHttpTransferUnlock(pSrvTx); + } + else + rc = VERR_NOT_FOUND; + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** @copydoc RTHTTPSERVERCALLBACKS::pfnQueryInfo */ +static DECLCALLBACK(int) shClTransferHttpQueryInfo(PRTHTTPCALLBACKDATA pData, + PRTHTTPSERVERREQ pReq, PRTFSOBJINFO pObjInfo, char **ppszMIMEHint) +{ + PSHCLHTTPSERVER pThis = (PSHCLHTTPSERVER)pData->pvUser; + Assert(pData->cbUser == sizeof(SHCLHTTPSERVER)); + + int rc; + + PSHCLHTTPSERVERTRANSFER pSrvTx = shClTransferHttpGetTransferFromUrl(pThis, pReq->pszUrl); + if (pSrvTx) + { + shClHttpTransferLock(pSrvTx); + + rc = shClTransferHttpGetTransferRoots(pThis, pSrvTx); + + shClHttpTransferUnlock(pSrvTx); + } + else + rc = VERR_NOT_FOUND; + + RT_NOREF(pObjInfo, ppszMIMEHint); + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** @copydoc RTHTTPSERVERCALLBACKS::pfnDestroy */ +static DECLCALLBACK(int) shClTransferHttpDestroy(PRTHTTPCALLBACKDATA pData) +{ + PSHCLHTTPSERVER pThis = (PSHCLHTTPSERVER)pData->pvUser; + Assert(pData->cbUser == sizeof(SHCLHTTPSERVER)); + + return shClTransferHttpServerDestroyInternal(pThis); +} + + +/********************************************************************************************************************************* +* Internal Shared Clipboard HTTP server functions * +*********************************************************************************************************************************/ + +/** + * Destroys a Shared Clipboard HTTP server instance, internal version. + * + * @returns VBox status code. + * @param pSrv Shared Clipboard HTTP server instance to destroy. + */ +static int shClTransferHttpServerDestroyInternal(PSHCLHTTPSERVER pSrv) +{ + PSHCLHTTPSERVERTRANSFER pSrvTx, pSrvTxNext; + RTListForEachSafe(&pSrv->lstTransfers, pSrvTx, pSrvTxNext, SHCLHTTPSERVERTRANSFER, Node) + { + RTListNodeRemove(&pSrvTx->Node); + + RTMemFree(pSrvTx); + pSrvTx = NULL; + } + + RTHttpServerResponseDestroy(&pSrv->Resp); + + pSrv->hHTTPServer = NIL_RTHTTPSERVER; + + int rc = VINF_SUCCESS; + + if (RTCritSectIsInitialized(&pSrv->CritSect)) + rc = RTCritSectDelete(&pSrv->CritSect); + + return rc; +} + +/** + * Locks the critical section of a Shared Clipboard HTTP server instance. + * + * @param pSrv Shared Clipboard HTTP server instance to lock. + */ +DECLINLINE(void) shClTransferHttpServerLock(PSHCLHTTPSERVER pSrv) +{ + int rc2 = RTCritSectEnter(&pSrv->CritSect); + AssertRC(rc2); +} + +/** + * Unlocks the critical section of a Shared Clipboard HTTP server instance. + * + * @param pSrv Shared Clipboard HTTP server instance to unlock. + */ +DECLINLINE(void) shClTransferHttpServerUnlock(PSHCLHTTPSERVER pSrv) +{ + int rc2 = RTCritSectLeave(&pSrv->CritSect); + AssertRC(rc2); +} + +/** + * Initializes a new Shared Clipboard HTTP server instance. + * + * @param pSrv HTTP server instance to initialize. + */ +static void shClTransferHttpServerInitInternal(PSHCLHTTPSERVER pSrv) +{ + pSrv->hHTTPServer = NIL_RTHTTPSERVER; + pSrv->uPort = 0; + RTListInit(&pSrv->lstTransfers); + pSrv->cTransfers = 0; + int rc2 = RTHttpServerResponseInit(&pSrv->Resp); + AssertRC(rc2); +} + + +/********************************************************************************************************************************* +* Public Shared Clipboard HTTP server functions * +*********************************************************************************************************************************/ + +/** + * Initializes a new Shared Clipboard HTTP server instance. + * + * @param pSrv HTTP server instance to initialize. + */ +void ShClTransferHttpServerInit(PSHCLHTTPSERVER pSrv) +{ + AssertPtrReturnVoid(pSrv); + + shClTransferHttpServerInitInternal(pSrv); +} + +/** + * Creates a new Shared Clipboard HTTP server instance, extended version. + * + * @returns VBox status code. + * @param pSrv HTTP server instance to create. + * @param uPort TCP port number to use. + */ +int ShClTransferHttpServerCreateEx(PSHCLHTTPSERVER pSrv, uint16_t uPort) +{ + AssertPtrReturn(pSrv, VERR_INVALID_POINTER); + + RTHTTPSERVERCALLBACKS Callbacks; + RT_ZERO(Callbacks); + + Callbacks.pfnOpen = shClTransferHttpOpen; + Callbacks.pfnRead = shClTransferHttpRead; + Callbacks.pfnClose = shClTransferHttpClose; + Callbacks.pfnQueryInfo = shClTransferHttpQueryInfo; + Callbacks.pfnDestroy = shClTransferHttpDestroy; + + /* Note: The server always and *only* runs against the localhost interface. */ + int rc = RTHttpServerCreate(&pSrv->hHTTPServer, "localhost", uPort, &Callbacks, + pSrv, sizeof(SHCLHTTPSERVER)); + if (RT_SUCCESS(rc)) + { + rc = RTCritSectInit(&pSrv->CritSect); + AssertRCReturn(rc, rc); + + pSrv->uPort = uPort; + + LogRel2(("Shared Clipboard: HTTP server running at port %RU16\n", pSrv->uPort)); + } + else + { + int rc2 = shClTransferHttpServerDestroyInternal(pSrv); + AssertRC(rc2); + } + + if (RT_FAILURE(rc)) + LogRel(("Shared Clipboard: HTTP server failed to run, rc=%Rrc\n", rc)); + + return rc; +} + +/** + * Creates a new Shared Clipboard HTTP server instance. + * + * This does automatic probing of TCP ports if one already is being used. + * + * @returns VBox status code. + * @param pSrv HTTP server instance to create. + * @param puPort Where to return the TCP port number being used on success. Optional. + */ +int ShClTransferHttpServerCreate(PSHCLHTTPSERVER pSrv, uint16_t *puPort) +{ + AssertPtrReturn(pSrv, VERR_INVALID_POINTER); + /* puPort is optional. */ + + /** @todo Try favorite ports first (e.g. 8080, 8000, ...)? */ + + RTRAND hRand; + int rc = RTRandAdvCreateSystemFaster(&hRand); /* Should be good enough for this task. */ + if (RT_SUCCESS(rc)) + { + uint16_t uPort; + for (int i = 0; i < 32; i++) + { +#ifdef DEBUG_andy + uPort = 8080; /* Make the port predictable, but only for me, mwahaha! :-). */ +#else + uPort = RTRandAdvU32Ex(hRand, 1024, UINT16_MAX); +#endif + rc = ShClTransferHttpServerCreateEx(pSrv, (uint32_t)uPort); + if (RT_SUCCESS(rc)) + { + if (puPort) + *puPort = uPort; + break; + } + } + + RTRandAdvDestroy(hRand); + } + + return rc; +} + +/** + * Destroys a Shared Clipboard HTTP server instance. + * + * @returns VBox status code. + * @param pSrv HTTP server instance to destroy. + */ +int ShClTransferHttpServerDestroy(PSHCLHTTPSERVER pSrv) +{ + AssertPtrReturn(pSrv, VERR_INVALID_POINTER); + + if (pSrv->hHTTPServer == NIL_RTHTTPSERVER) + return VINF_SUCCESS; + + Assert(pSrv->cTransfers == 0); /* Sanity. */ + + int rc = RTHttpServerDestroy(pSrv->hHTTPServer); + if (RT_SUCCESS(rc)) + rc = shClTransferHttpServerDestroyInternal(pSrv); + + if (RT_SUCCESS(rc)) + LogRel2(("Shared Clipboard: HTTP server stopped\n")); + else + LogRel(("Shared Clipboard: HTTP server failed to stop, rc=%Rrc\n", rc)); + + return rc; +} + +/** + * Registers a Shared Clipboard transfer to a HTTP server instance. + * + * @returns VBox status code. + * @param pSrv HTTP server instance to register transfer for. + * @param pTransfer Transfer to register. + */ +int ShClTransferHttpServerRegisterTransfer(PSHCLHTTPSERVER pSrv, PSHCLTRANSFER pTransfer) +{ + AssertPtrReturn(pSrv, VERR_INVALID_POINTER); + AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); + + AssertReturn(pTransfer->State.uID, VERR_INVALID_PARAMETER); /* Paranoia. */ + + shClTransferHttpServerLock(pSrv); + + PSHCLHTTPSERVERTRANSFER pSrvTx = (PSHCLHTTPSERVERTRANSFER)RTMemAllocZ(sizeof(SHCLHTTPSERVERTRANSFER)); + AssertPtrReturn(pSrvTx, VERR_NO_MEMORY); + + RTUUID Uuid; + int rc = RTUuidCreate(&Uuid); + if (RT_SUCCESS(rc)) + { + char szUuid[64]; + rc = RTUuidToStr(&Uuid, szUuid, sizeof(szUuid)); + if (RT_SUCCESS(rc)) + { + rc = RTCritSectInit(&pSrvTx->CritSect); + AssertRC(rc); + + /* Create the virtual HTTP path for the transfer. + * Every transfer has a dedicated HTTP path. */ +#ifdef DEBUG_andy + ssize_t cch = RTStrPrintf2(pSrvTx->szPathVirtual, sizeof(pSrvTx->szPathVirtual), "/d1bbda60-80b7-45dc-a41c-ac4686c1d988/10664"); +#else + ssize_t cch = RTStrPrintf2(pSrvTx->szPathVirtual, sizeof(pSrvTx->szPathVirtual), "%s/%RU16/", szUuid, pTransfer->State.uID); +#endif + AssertReturn(cch, VERR_BUFFER_OVERFLOW); + + pSrvTx->pTransfer = pTransfer; + pSrvTx->pRootList = NULL; + pSrvTx->hObj = SHCLOBJHANDLE_INVALID; + + RTListAppend(&pSrv->lstTransfers, &pSrvTx->Node); + pSrv->cTransfers++; + + LogFunc(("pTransfer=%p, idTransfer=%RU16, szPath=%s -> %RU32 transfers\n", + pSrvTx->pTransfer, pSrvTx->pTransfer->State.uID, pSrvTx->szPathVirtual, pSrv->cTransfers)); + + LogRel2(("Shared Clipboard: Registered HTTP transfer %RU16, now %RU32 HTTP transfers total\n", + pTransfer->State.uID, pSrv->cTransfers)); + } + } + + if (RT_FAILURE(rc)) + RTMemFree(pSrvTx); + + shClTransferHttpServerUnlock(pSrv); + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Unregisters a formerly registered Shared Clipboard transfer. + * + * @returns VBox status code. + * @param pSrv HTTP server instance to unregister transfer from. + * @param pTransfer Transfer to unregister. + */ +int ShClTransferHttpServerUnregisterTransfer(PSHCLHTTPSERVER pSrv, PSHCLTRANSFER pTransfer) +{ + AssertPtrReturn(pSrv, VERR_INVALID_POINTER); + AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); + + shClTransferHttpServerLock(pSrv); + + AssertReturn(pSrv->cTransfers, VERR_WRONG_ORDER); + + int rc = VINF_SUCCESS; + + PSHCLHTTPSERVERTRANSFER pSrvTx; + RTListForEach(&pSrv->lstTransfers, pSrvTx, SHCLHTTPSERVERTRANSFER, Node) + { + AssertPtr(pSrvTx->pTransfer); + if (pSrvTx->pTransfer->State.uID == pTransfer->State.uID) + { + RTListNodeRemove(&pSrvTx->Node); + + Assert(pSrv->cTransfers); + pSrv->cTransfers--; + + LogFunc(("pTransfer=%p, idTransfer=%RU16, szPath=%s -> %RU32 transfers\n", + pSrvTx->pTransfer, pSrvTx->pTransfer->State.uID, pSrvTx->szPathVirtual, pSrv->cTransfers)); + + LogRel2(("Shared Clipboard: Unregistered HTTP transfer %RU16, now %RU32 HTTP transfers total\n", + pTransfer->State.uID, pSrv->cTransfers)); + + rc = RTCritSectDelete(&pSrvTx->CritSect); + AssertRC(rc); + + RTMemFree(pSrvTx); + pSrvTx = NULL; + + rc = VINF_SUCCESS; + break; + } + } + + shClTransferHttpServerUnlock(pSrv); + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Returns whether a specific transfer ID is registered with a HTTP server instance or not. + * + * @returns \c true if the transfer ID is registered, \c false if not. + * @param pSrv HTTP server instance. + * @param idTransfer Transfer ID to check for. + */ +bool ShClTransferHttpServerHasTransfer(PSHCLHTTPSERVER pSrv, SHCLTRANSFERID idTransfer) +{ + AssertPtrReturn(pSrv, false); + + shClTransferHttpServerLock(pSrv); + + const bool fRc = shClTransferHttpServerGetTransferById(pSrv, idTransfer) != NULL; + + shClTransferHttpServerUnlock(pSrv); + + return fRc; +} + +/** + * Returns the used TCP port number of a HTTP server instance. + * + * @returns TCP port number. 0 if not specified yet. + * @param pSrv HTTP server instance to return port for. + */ +uint16_t ShClTransferHttpServerGetPort(PSHCLHTTPSERVER pSrv) +{ + AssertPtrReturn(pSrv, 0); + + shClTransferHttpServerLock(pSrv); + + const uint16_t uPort = pSrv->uPort; + + shClTransferHttpServerUnlock(pSrv); + + return uPort; +} + +/** + * Returns the number of registered HTTP server transfers of a HTTP server instance. + * + * @returns Number of registered transfers. + * @param pSrv HTTP server instance to return registered transfers for. + */ +uint32_t ShClTransferHttpServerGetTransferCount(PSHCLHTTPSERVER pSrv) +{ + AssertPtrReturn(pSrv, 0); + + shClTransferHttpServerLock(pSrv); + + const uint32_t cTransfers = pSrv->cTransfers; + + shClTransferHttpServerUnlock(pSrv); + + return cTransfers; +} + +/** + * Returns the host name (scheme) of a HTTP server instance. + * + * @param pSrv HTTP server instance to return host name (scheme) for. + * + * @returns Host name (scheme). + */ +static const char *shClTransferHttpServerGetHost(PSHCLHTTPSERVER pSrv) +{ + RT_NOREF(pSrv); + return "http://localhost"; /* Hardcoded for now. */ +} + +/** + * Returns an allocated string with a HTTP server instance's address. + * + * @returns Allocated string with a HTTP server instance's address, or NULL on OOM. + * Needs to be free'd by the caller using RTStrFree(). + * @param pSrv HTTP server instance to return address for. + */ +char *ShClTransferHttpServerGetAddressA(PSHCLHTTPSERVER pSrv) +{ + AssertPtrReturn(pSrv, NULL); + + shClTransferHttpServerLock(pSrv); + + char *pszAddress = RTStrAPrintf2("%s:%RU16", shClTransferHttpServerGetHost(pSrv), pSrv->uPort); + AssertPtr(pszAddress); + + shClTransferHttpServerUnlock(pSrv); + + return pszAddress; +} + +/** + * Returns an allocated string with the URL of a given Shared Clipboard transfer ID. + * + * @returns Allocated string with the URL of a given Shared Clipboard transfer ID, or NULL if not found. + * Needs to be free'd by the caller using RTStrFree(). + * @param pSrv HTTP server instance to return URL for. + */ +char *ShClTransferHttpServerGetUrlA(PSHCLHTTPSERVER pSrv, SHCLTRANSFERID idTransfer) +{ + AssertPtrReturn(pSrv, NULL); + AssertReturn(idTransfer != NIL_SHCLTRANSFERID, NULL); + + shClTransferHttpServerLock(pSrv); + + PSHCLHTTPSERVERTRANSFER pSrvTx = shClTransferHttpServerGetTransferById(pSrv, idTransfer); + if (!pSrvTx) + { + AssertFailed(); + shClTransferHttpServerUnlock(pSrv); + return NULL; + } + + AssertReturn(RTStrNLen(pSrvTx->szPathVirtual, RTPATH_MAX), NULL); + char *pszUrl = RTStrAPrintf2("%s:%RU16/%s", shClTransferHttpServerGetHost(pSrv), pSrv->uPort, pSrvTx->szPathVirtual); + AssertPtr(pszUrl); + + shClTransferHttpServerUnlock(pSrv); + + return pszUrl; +} + +/** + * Returns whether a given HTTP server instance is running or not. + * + * @returns \c true if running, or \c false if not. + * @param pSrv HTTP server instance to check running state for. + */ +bool ShClTransferHttpServerIsRunning(PSHCLHTTPSERVER pSrv) +{ + AssertPtrReturn(pSrv, false); + + return (pSrv->hHTTPServer != NIL_RTHTTPSERVER); /* Seems enough for now. */ +} diff --git a/src/VBox/GuestHost/SharedClipboard/clipboard-transfers.cpp b/src/VBox/GuestHost/SharedClipboard/clipboard-transfers.cpp new file mode 100644 index 00000000..d2fd3393 --- /dev/null +++ b/src/VBox/GuestHost/SharedClipboard/clipboard-transfers.cpp @@ -0,0 +1,3132 @@ +/* $Id: clipboard-transfers.cpp $ */ +/** @file + * Shared Clipboard: Common Shared Clipboard transfer handling code. + */ + +/* + * Copyright (C) 2019-2022 Oracle and/or its affiliates. + * + * This file is part of VirtualBox base platform packages, as + * available from https://www.virtualbox.org. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, in version 3 of the + * License. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <https://www.gnu.org/licenses>. + * + * SPDX-License-Identifier: GPL-3.0-only + */ + +#define LOG_GROUP LOG_GROUP_SHARED_CLIPBOARD +#include <VBox/log.h> + +#include <iprt/dir.h> +#include <iprt/file.h> +#include <iprt/list.h> +#include <iprt/path.h> +#include <iprt/rand.h> +#include <iprt/semaphore.h> + +#include <VBox/err.h> +#include <VBox/HostServices/VBoxClipboardSvc.h> +#include <VBox/GuestHost/SharedClipboard-transfers.h> + + +static int shClTransferThreadCreate(PSHCLTRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser); +static int shClTransferThreadDestroy(PSHCLTRANSFER pTransfer, RTMSINTERVAL uTimeoutMs); + +static void shclTransferCtxTransferRemoveAndUnregister(PSHCLTRANSFERCTX pTransferCtx, PSHCLTRANSFER pTransfer); +static PSHCLTRANSFER shClTransferCtxGetTransferByIdInternal(PSHCLTRANSFERCTX pTransferCtx, uint32_t uId); +static PSHCLTRANSFER shClTransferCtxGetTransferByIndexInternal(PSHCLTRANSFERCTX pTransferCtx, uint32_t uIdx); +static int shClConvertFileCreateFlags(uint32_t fShClFlags, uint64_t *pfOpen); +static int shClTransferResolvePathAbs(PSHCLTRANSFER pTransfer, const char *pszPath, uint32_t fFlags, char **ppszResolved); + +/** @todo Split this file up in different modules. */ + +/** + * Allocates a new transfer root list. + * + * @returns Allocated transfer root list on success, or NULL on failure. + */ +PSHCLROOTLIST ShClTransferRootListAlloc(void) +{ + PSHCLROOTLIST pRootList = (PSHCLROOTLIST)RTMemAllocZ(sizeof(SHCLROOTLIST)); + + return pRootList; +} + +/** + * Frees a transfer root list. + * + * @param pRootList transfer root list to free. The pointer will be + * invalid after returning from this function. + */ +void ShClTransferRootListFree(PSHCLROOTLIST pRootList) +{ + if (!pRootList) + return; + + for (uint32_t i = 0; i < pRootList->Hdr.cRoots; i++) + ShClTransferListEntryInit(&pRootList->paEntries[i]); + + RTMemFree(pRootList); + pRootList = NULL; +} + +/** + * Initializes a transfer root list header. + * + * @returns VBox status code. + * @param pRootLstHdr Root list header to initialize. + */ +int ShClTransferRootListHdrInit(PSHCLROOTLISTHDR pRootLstHdr) +{ + AssertPtrReturn(pRootLstHdr, VERR_INVALID_POINTER); + + RT_BZERO(pRootLstHdr, sizeof(SHCLROOTLISTHDR)); + + return VINF_SUCCESS; +} + +/** + * Destroys a transfer root list header. + * + * @param pRootLstHdr Root list header to destroy. + */ +void ShClTransferRootListHdrDestroy(PSHCLROOTLISTHDR pRootLstHdr) +{ + if (!pRootLstHdr) + return; + + pRootLstHdr->fRoots = 0; + pRootLstHdr->cRoots = 0; +} + +/** + * Duplicates a transfer list header. + * + * @returns Duplicated transfer list header on success, or NULL on failure. + * @param pRootLstHdr Root list header to duplicate. + */ +PSHCLROOTLISTHDR ShClTransferRootListHdrDup(PSHCLROOTLISTHDR pRootLstHdr) +{ + AssertPtrReturn(pRootLstHdr, NULL); + + int rc = VINF_SUCCESS; + + PSHCLROOTLISTHDR pRootsDup = (PSHCLROOTLISTHDR)RTMemAllocZ(sizeof(SHCLROOTLISTHDR)); + if (pRootsDup) + { + *pRootsDup = *pRootLstHdr; + } + else + rc = VERR_NO_MEMORY; + + if (RT_FAILURE(rc)) + { + ShClTransferRootListHdrDestroy(pRootsDup); + pRootsDup = NULL; + } + + return pRootsDup; +} + +/** + * (Deep) Copies a clipboard root list entry structure. + * + * @returns VBox status code. + * @param pDst Where to copy the source root list entry to. + * @param pSrc Source root list entry to copy. + */ +int ShClTransferRootListEntryCopy(PSHCLROOTLISTENTRY pDst, PSHCLROOTLISTENTRY pSrc) +{ + return ShClTransferListEntryCopy(pDst, pSrc); +} + +/** + * Initializes a clipboard root list entry structure. + * + * @param pRootListEntry Clipboard root list entry structure to destroy. + */ +int ShClTransferRootListEntryInit(PSHCLROOTLISTENTRY pRootListEntry) +{ + return ShClTransferListEntryInit(pRootListEntry); +} + +/** + * Destroys a clipboard root list entry structure. + * + * @param pRootListEntry Clipboard root list entry structure to destroy. + */ +void ShClTransferRootListEntryDestroy(PSHCLROOTLISTENTRY pRootListEntry) +{ + return ShClTransferListEntryDestroy(pRootListEntry); +} + +/** + * Duplicates (allocates) a clipboard root list entry structure. + * + * @returns Duplicated clipboard root list entry structure on success. + * @param pRootListEntry Clipboard root list entry to duplicate. + */ +PSHCLROOTLISTENTRY ShClTransferRootListEntryDup(PSHCLROOTLISTENTRY pRootListEntry) +{ + return ShClTransferListEntryDup(pRootListEntry); +} + +/** + * Initializes an list handle info structure. + * + * @returns VBox status code. + * @param pInfo List handle info structure to initialize. + */ +int ShClTransferListHandleInfoInit(PSHCLLISTHANDLEINFO pInfo) +{ + AssertPtrReturn(pInfo, VERR_INVALID_POINTER); + + pInfo->hList = SHCLLISTHANDLE_INVALID; + pInfo->enmType = SHCLOBJTYPE_INVALID; + + pInfo->pszPathLocalAbs = NULL; + + RT_ZERO(pInfo->u); + + return VINF_SUCCESS; +} + +/** + * Destroys a list handle info structure. + * + * @param pInfo List handle info structure to destroy. + */ +void ShClTransferListHandleInfoDestroy(PSHCLLISTHANDLEINFO pInfo) +{ + if (!pInfo) + return; + + if (pInfo->pszPathLocalAbs) + { + RTStrFree(pInfo->pszPathLocalAbs); + pInfo->pszPathLocalAbs = NULL; + } +} + +/** + * Allocates a transfer list header structure. + * + * @returns VBox status code. + * @param ppListHdr Where to store the allocated transfer list header structure on success. + */ +int ShClTransferListHdrAlloc(PSHCLLISTHDR *ppListHdr) +{ + int rc; + + PSHCLLISTHDR pListHdr = (PSHCLLISTHDR)RTMemAllocZ(sizeof(SHCLLISTHDR)); + if (pListHdr) + { + *ppListHdr = pListHdr; + rc = VINF_SUCCESS; + } + else + rc = VERR_NO_MEMORY; + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Frees a transfer list header structure. + * + * @param pListEntry Transfer list header structure to free. + */ +void ShClTransferListHdrFree(PSHCLLISTHDR pListHdr) +{ + if (!pListHdr) + return; + + LogFlowFuncEnter(); + + ShClTransferListHdrDestroy(pListHdr); + + RTMemFree(pListHdr); + pListHdr = NULL; +} + +/** + * Duplicates (allocates) a transfer list header structure. + * + * @returns Duplicated transfer list header structure on success. + * @param pListHdr Transfer list header to duplicate. + */ +PSHCLLISTHDR ShClTransferListHdrDup(PSHCLLISTHDR pListHdr) +{ + AssertPtrReturn(pListHdr, NULL); + + PSHCLLISTHDR pListHdrDup = (PSHCLLISTHDR)RTMemAlloc(sizeof(SHCLLISTHDR)); + if (pListHdrDup) + { + *pListHdrDup = *pListHdr; + } + + return pListHdrDup; +} + +/** + * Initializes a transfer list header structure. + * + * @returns VBox status code. + * @param pListHdr Transfer list header struct to initialize. + */ +int ShClTransferListHdrInit(PSHCLLISTHDR pListHdr) +{ + AssertPtrReturn(pListHdr, VERR_INVALID_POINTER); + + LogFlowFuncEnter(); + + ShClTransferListHdrReset(pListHdr); + + return VINF_SUCCESS; +} + +/** + * Destroys a transfer list header structure. + * + * @param pListHdr Transfer list header struct to destroy. + */ +void ShClTransferListHdrDestroy(PSHCLLISTHDR pListHdr) +{ + if (!pListHdr) + return; + + LogFlowFuncEnter(); +} + +/** + * Resets a transfer list header structure. + * + * @returns VBox status code. + * @param pListHdr Transfer list header struct to reset. + */ +void ShClTransferListHdrReset(PSHCLLISTHDR pListHdr) +{ + AssertPtrReturnVoid(pListHdr); + + LogFlowFuncEnter(); + + RT_BZERO(pListHdr, sizeof(SHCLLISTHDR)); +} + +/** + * Returns whether a given transfer list header is valid or not. + * + * @returns \c true if valid, \c false if not. + * @param pListHdr Transfer list header to validate. + */ +bool ShClTransferListHdrIsValid(PSHCLLISTHDR pListHdr) +{ + RT_NOREF(pListHdr); + return true; /** @todo Implement this. */ +} + +int ShClTransferListOpenParmsCopy(PSHCLLISTOPENPARMS pDst, PSHCLLISTOPENPARMS pSrc) +{ + AssertPtrReturn(pDst, VERR_INVALID_POINTER); + AssertPtrReturn(pSrc, VERR_INVALID_POINTER); + + int rc = VINF_SUCCESS; + + if (pSrc->pszFilter) + { + pDst->pszFilter = RTStrDup(pSrc->pszFilter); + if (!pDst->pszFilter) + rc = VERR_NO_MEMORY; + } + + if ( RT_SUCCESS(rc) + && pSrc->pszPath) + { + pDst->pszPath = RTStrDup(pSrc->pszPath); + if (!pDst->pszPath) + rc = VERR_NO_MEMORY; + } + + if (RT_SUCCESS(rc)) + { + pDst->fList = pDst->fList; + pDst->cbFilter = pSrc->cbFilter; + pDst->cbPath = pSrc->cbPath; + } + + return rc; +} + +/** + * Duplicates a transfer list open parameters structure. + * + * @returns Duplicated transfer list open parameters structure on success, or NULL on failure. + * @param pParms Transfer list open parameters structure to duplicate. + */ +PSHCLLISTOPENPARMS ShClTransferListOpenParmsDup(PSHCLLISTOPENPARMS pParms) +{ + AssertPtrReturn(pParms, NULL); + + PSHCLLISTOPENPARMS pParmsDup = (PSHCLLISTOPENPARMS)RTMemAllocZ(sizeof(SHCLLISTOPENPARMS)); + if (!pParmsDup) + return NULL; + + int rc = ShClTransferListOpenParmsCopy(pParmsDup, pParms); + if (RT_FAILURE(rc)) + { + ShClTransferListOpenParmsDestroy(pParmsDup); + + RTMemFree(pParmsDup); + pParmsDup = NULL; + } + + return pParmsDup; +} + +/** + * Initializes a transfer list open parameters structure. + * + * @returns VBox status code. + * @param pParms Transfer list open parameters structure to initialize. + */ +int ShClTransferListOpenParmsInit(PSHCLLISTOPENPARMS pParms) +{ + AssertPtrReturn(pParms, VERR_INVALID_POINTER); + + RT_BZERO(pParms, sizeof(SHCLLISTOPENPARMS)); + + pParms->cbFilter = SHCL_TRANSFER_PATH_MAX; /** @todo Make this dynamic. */ + pParms->pszFilter = RTStrAlloc(pParms->cbFilter); + + pParms->cbPath = SHCL_TRANSFER_PATH_MAX; /** @todo Make this dynamic. */ + pParms->pszPath = RTStrAlloc(pParms->cbPath); + + LogFlowFuncLeave(); + return VINF_SUCCESS; +} + +/** + * Destroys a transfer list open parameters structure. + * + * @param pParms Transfer list open parameters structure to destroy. + */ +void ShClTransferListOpenParmsDestroy(PSHCLLISTOPENPARMS pParms) +{ + if (!pParms) + return; + + if (pParms->pszFilter) + { + RTStrFree(pParms->pszFilter); + pParms->pszFilter = NULL; + } + + if (pParms->pszPath) + { + RTStrFree(pParms->pszPath); + pParms->pszPath = NULL; + } +} + +/** + * Creates (allocates) and initializes a clipboard list entry structure. + * + * @param ppDirData Where to return the created clipboard list entry structure on success. + */ +int ShClTransferListEntryAlloc(PSHCLLISTENTRY *ppListEntry) +{ + PSHCLLISTENTRY pListEntry = (PSHCLLISTENTRY)RTMemAlloc(sizeof(SHCLLISTENTRY)); + if (!pListEntry) + return VERR_NO_MEMORY; + + int rc = ShClTransferListEntryInit(pListEntry); + if (RT_SUCCESS(rc)) + *ppListEntry = pListEntry; + + return rc; +} + +/** + * Frees a clipboard list entry structure. + * + * @param pListEntry Clipboard list entry structure to free. + */ +void ShClTransferListEntryFree(PSHCLLISTENTRY pListEntry) +{ + if (!pListEntry) + return; + + ShClTransferListEntryDestroy(pListEntry); + RTMemFree(pListEntry); +} + +/** + * (Deep) Copies a clipboard list entry structure. + * + * @returns VBox status code. + * @param pListEntry Clipboard list entry to copy. + */ +int ShClTransferListEntryCopy(PSHCLLISTENTRY pDst, PSHCLLISTENTRY pSrc) +{ + AssertPtrReturn(pDst, VERR_INVALID_POINTER); + AssertPtrReturn(pSrc, VERR_INVALID_POINTER); + + int rc = VINF_SUCCESS; + + *pDst = *pSrc; + + if (pSrc->pszName) + { + pDst->pszName = RTStrDup(pSrc->pszName); + if (!pDst->pszName) + rc = VERR_NO_MEMORY; + } + + if ( RT_SUCCESS(rc) + && pSrc->pvInfo) + { + pDst->pvInfo = RTMemDup(pSrc->pvInfo, pSrc->cbInfo); + if (pDst->pvInfo) + { + pDst->cbInfo = pSrc->cbInfo; + } + else + rc = VERR_NO_MEMORY; + } + + if (RT_FAILURE(rc)) + { + if (pDst->pvInfo) + { + RTMemFree(pDst->pvInfo); + pDst->pvInfo = NULL; + pDst->cbInfo = 0; + } + } + + return rc; +} + +/** + * Duplicates (allocates) a clipboard list entry structure. + * + * @returns Duplicated clipboard list entry structure on success. + * @param pListEntry Clipboard list entry to duplicate. + */ +PSHCLLISTENTRY ShClTransferListEntryDup(PSHCLLISTENTRY pListEntry) +{ + AssertPtrReturn(pListEntry, NULL); + + int rc = VINF_SUCCESS; + + PSHCLLISTENTRY pListEntryDup = (PSHCLLISTENTRY)RTMemAllocZ(sizeof(SHCLLISTENTRY)); + if (pListEntryDup) + rc = ShClTransferListEntryCopy(pListEntryDup, pListEntry); + + if (RT_FAILURE(rc)) + { + ShClTransferListEntryDestroy(pListEntryDup); + + RTMemFree(pListEntryDup); + pListEntryDup = NULL; + } + + return pListEntryDup; +} + +/** + * Initializes a clipboard list entry structure. + * + * @returns VBox status code. + * @param pListEntry Clipboard list entry structure to initialize. + */ +int ShClTransferListEntryInit(PSHCLLISTENTRY pListEntry) +{ + AssertPtrReturn(pListEntry, VERR_INVALID_POINTER); + + RT_BZERO(pListEntry, sizeof(SHCLLISTENTRY)); + + pListEntry->pszName = RTStrAlloc(SHCLLISTENTRY_MAX_NAME); + if (!pListEntry->pszName) + return VERR_NO_MEMORY; + + pListEntry->cbName = SHCLLISTENTRY_MAX_NAME; + + pListEntry->pvInfo = (PSHCLFSOBJINFO)RTMemAlloc(sizeof(SHCLFSOBJINFO)); + if (pListEntry->pvInfo) + { + pListEntry->cbInfo = sizeof(SHCLFSOBJINFO); + pListEntry->fInfo = VBOX_SHCL_INFO_FLAG_FSOBJINFO; + + return VINF_SUCCESS; + } + + return VERR_NO_MEMORY; +} + +/** + * Destroys a clipboard list entry structure. + * + * @param pListEntry Clipboard list entry structure to destroy. + */ +void ShClTransferListEntryDestroy(PSHCLLISTENTRY pListEntry) +{ + if (!pListEntry) + return; + + if (pListEntry->pszName) + { + RTStrFree(pListEntry->pszName); + + pListEntry->pszName = NULL; + pListEntry->cbName = 0; + } + + if (pListEntry->pvInfo) + { + RTMemFree(pListEntry->pvInfo); + pListEntry->pvInfo = NULL; + pListEntry->cbInfo = 0; + } +} + +/** + * Returns whether a given clipboard list entry is valid or not. + * + * @returns \c true if valid, \c false if not. + * @param pListEntry Clipboard list entry to validate. + */ +bool ShClTransferListEntryIsValid(PSHCLLISTENTRY pListEntry) +{ + AssertPtrReturn(pListEntry, false); + + if ( !pListEntry->pszName + || !pListEntry->cbName + || strlen(pListEntry->pszName) == 0 + || strlen(pListEntry->pszName) > pListEntry->cbName /* Includes zero termination */ - 1) + { + return false; + } + + if (pListEntry->cbInfo) /* cbInfo / pvInfo is optional. */ + { + if (!pListEntry->pvInfo) + return false; + } + + return true; +} + +/** + * Initializes a transfer object context. + * + * @returns VBox status code. + * @param pObjCtx transfer object context to initialize. + */ +int ShClTransferObjCtxInit(PSHCLCLIENTTRANSFEROBJCTX pObjCtx) +{ + AssertPtrReturn(pObjCtx, VERR_INVALID_POINTER); + + LogFlowFuncEnter(); + + pObjCtx->uHandle = SHCLOBJHANDLE_INVALID; + + return VINF_SUCCESS; +} + +/** + * Destroys a transfer object context. + * + * @param pObjCtx transfer object context to destroy. + */ +void ShClTransferObjCtxDestroy(PSHCLCLIENTTRANSFEROBJCTX pObjCtx) +{ + AssertPtrReturnVoid(pObjCtx); + + LogFlowFuncEnter(); +} + +/** + * Returns if a transfer object context is valid or not. + * + * @returns \c true if valid, \c false if not. + * @param pObjCtx transfer object context to check. + */ +bool ShClTransferObjCtxIsValid(PSHCLCLIENTTRANSFEROBJCTX pObjCtx) +{ + return ( pObjCtx + && pObjCtx->uHandle != SHCLOBJHANDLE_INVALID); +} + +/** + * Initializes an object handle info structure. + * + * @returns VBox status code. + * @param pInfo Object handle info structure to initialize. + */ +int ShClTransferObjHandleInfoInit(PSHCLOBJHANDLEINFO pInfo) +{ + AssertPtrReturn(pInfo, VERR_INVALID_POINTER); + + pInfo->hObj = SHCLOBJHANDLE_INVALID; + pInfo->enmType = SHCLOBJTYPE_INVALID; + + pInfo->pszPathLocalAbs = NULL; + + RT_ZERO(pInfo->u); + + return VINF_SUCCESS; +} + +/** + * Destroys an object handle info structure. + * + * @param pInfo Object handle info structure to destroy. + */ +void ShClTransferObjHandleInfoDestroy(PSHCLOBJHANDLEINFO pInfo) +{ + if (!pInfo) + return; + + if (pInfo->pszPathLocalAbs) + { + RTStrFree(pInfo->pszPathLocalAbs); + pInfo->pszPathLocalAbs = NULL; + } +} + +/** + * Initializes a transfer object open parameters structure. + * + * @returns VBox status code. + * @param pParms transfer object open parameters structure to initialize. + */ +int ShClTransferObjOpenParmsInit(PSHCLOBJOPENCREATEPARMS pParms) +{ + AssertPtrReturn(pParms, VERR_INVALID_POINTER); + + int rc; + + RT_BZERO(pParms, sizeof(SHCLOBJOPENCREATEPARMS)); + + 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 a transfer object open parameters structure from source to destination. + * + * @returns VBox status code. + * @param pParmsDst Where to copy the source transfer object open parameters to. + * @param pParmsSrc Which source transfer object open parameters to copy. + */ +int ShClTransferObjOpenParmsCopy(PSHCLOBJOPENCREATEPARMS pParmsDst, PSHCLOBJOPENCREATEPARMS 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 a transfer object open parameters structure. + * + * @param pParms transfer object open parameters structure to destroy. + */ +void ShClTransferObjOpenParmsDestroy(PSHCLOBJOPENCREATEPARMS pParms) +{ + if (!pParms) + return; + + if (pParms->pszPath) + { + RTStrFree(pParms->pszPath); + pParms->pszPath = NULL; + } +} + +/** + * Returns a specific object handle info of a transfer. + * + * @returns Pointer to object handle info if found, or NULL if not found. + * @param pTransfer Clipboard transfer to get object handle info from. + * @param hObj Object handle of the object to get handle info for. + */ +DECLINLINE(PSHCLOBJHANDLEINFO) shClTransferObjGet(PSHCLTRANSFER pTransfer, SHCLOBJHANDLE hObj) +{ + PSHCLOBJHANDLEINFO pIt; + RTListForEach(&pTransfer->lstObj, pIt, SHCLOBJHANDLEINFO, Node) /** @todo Slooow ...but works for now. */ + { + if (pIt->hObj == hObj) + return pIt; + } + + return NULL; +} + +/** + * Opens a transfer object. + * + * @returns VBox status code. + * @param pTransfer Clipboard transfer to open the object for. + * @param pOpenCreateParms Open / create parameters of transfer object to open / create. + * @param phObj Where to store the handle of transfer object opened on success. + */ +int ShClTransferObjOpen(PSHCLTRANSFER pTransfer, PSHCLOBJOPENCREATEPARMS pOpenCreateParms, PSHCLOBJHANDLE phObj) +{ + AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); + AssertPtrReturn(pOpenCreateParms, VERR_INVALID_POINTER); + AssertPtrReturn(phObj, VERR_INVALID_POINTER); + AssertMsgReturn(pTransfer->pszPathRootAbs, ("Transfer has no root path set\n"), VERR_INVALID_PARAMETER); + AssertMsgReturn(pOpenCreateParms->pszPath, ("No path in open/create params set\n"), VERR_INVALID_PARAMETER); + + if (pTransfer->cObjHandles >= pTransfer->cMaxObjHandles) + return VERR_SHCLPB_MAX_OBJECTS_REACHED; + + LogFlowFunc(("pszPath=%s, fCreate=0x%x\n", pOpenCreateParms->pszPath, pOpenCreateParms->fCreate)); + + int rc; + if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL) + { + PSHCLOBJHANDLEINFO pInfo = (PSHCLOBJHANDLEINFO)RTMemAllocZ(sizeof(SHCLOBJHANDLEINFO)); + if (pInfo) + { + rc = ShClTransferObjHandleInfoInit(pInfo); + if (RT_SUCCESS(rc)) + { + uint64_t fOpen; + rc = shClConvertFileCreateFlags(pOpenCreateParms->fCreate, &fOpen); + if (RT_SUCCESS(rc)) + { + rc = shClTransferResolvePathAbs(pTransfer, pOpenCreateParms->pszPath, 0 /* fFlags */, + &pInfo->pszPathLocalAbs); + if (RT_SUCCESS(rc)) + { + rc = RTFileOpen(&pInfo->u.Local.hFile, pInfo->pszPathLocalAbs, fOpen); + if (RT_SUCCESS(rc)) + LogRel2(("Shared Clipboard: Opened file '%s'\n", pInfo->pszPathLocalAbs)); + else + LogRel(("Shared Clipboard: Error opening file '%s': rc=%Rrc\n", pInfo->pszPathLocalAbs, rc)); + } + } + } + + if (RT_SUCCESS(rc)) + { + pInfo->hObj = pTransfer->uObjHandleNext++; + pInfo->enmType = SHCLOBJTYPE_FILE; + + RTListAppend(&pTransfer->lstObj, &pInfo->Node); + pTransfer->cObjHandles++; + + LogFlowFunc(("cObjHandles=%RU32\n", pTransfer->cObjHandles)); + + *phObj = pInfo->hObj; + } + else + { + ShClTransferObjHandleInfoDestroy(pInfo); + RTMemFree(pInfo); + } + } + else + rc = VERR_NO_MEMORY; + } + else if (pTransfer->State.enmSource == SHCLSOURCE_REMOTE) + { + if (pTransfer->ProviderIface.pfnObjOpen) + rc = pTransfer->ProviderIface.pfnObjOpen(&pTransfer->ProviderCtx, pOpenCreateParms, phObj); + else + rc = VERR_NOT_SUPPORTED; + } + else + AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED); + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Closes a transfer object. + * + * @returns VBox status code. + * @param pTransfer Clipboard transfer that contains the object to close. + * @param hObj Handle of transfer object to close. + */ +int ShClTransferObjClose(PSHCLTRANSFER pTransfer, SHCLOBJHANDLE hObj) +{ + AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); + + int rc = VINF_SUCCESS; + + if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL) + { + PSHCLOBJHANDLEINFO pInfo = shClTransferObjGet(pTransfer, hObj); + if (pInfo) + { + switch (pInfo->enmType) + { + case SHCLOBJTYPE_DIRECTORY: + { + rc = RTDirClose(pInfo->u.Local.hDir); + if (RT_SUCCESS(rc)) + { + pInfo->u.Local.hDir = NIL_RTDIR; + + LogRel2(("Shared Clipboard: Closed directory '%s'\n", pInfo->pszPathLocalAbs)); + } + else + LogRel(("Shared Clipboard: Closing directory '%s' failed with %Rrc\n", pInfo->pszPathLocalAbs, rc)); + break; + } + + case SHCLOBJTYPE_FILE: + { + rc = RTFileClose(pInfo->u.Local.hFile); + if (RT_SUCCESS(rc)) + { + pInfo->u.Local.hFile = NIL_RTFILE; + + LogRel2(("Shared Clipboard: Closed file '%s'\n", pInfo->pszPathLocalAbs)); + } + else + LogRel(("Shared Clipboard: Closing file '%s' failed with %Rrc\n", pInfo->pszPathLocalAbs, rc)); + break; + } + + default: + rc = VERR_NOT_IMPLEMENTED; + break; + } + + RTListNodeRemove(&pInfo->Node); + + Assert(pTransfer->cObjHandles); + pTransfer->cObjHandles--; + + ShClTransferObjHandleInfoDestroy(pInfo); + + RTMemFree(pInfo); + pInfo = NULL; + } + else + rc = VERR_NOT_FOUND; + } + else if (pTransfer->State.enmSource == SHCLSOURCE_REMOTE) + { + if (pTransfer->ProviderIface.pfnObjClose) + { + rc = pTransfer->ProviderIface.pfnObjClose(&pTransfer->ProviderCtx, hObj); + } + else + rc = VERR_NOT_SUPPORTED; + } + else + AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED); + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Reads from a transfer object. + * + * @returns VBox status code. + * @param pTransfer Clipboard transfer that contains the object to read from. + * @param hObj Handle of transfer object to read from. + * @param pvBuf Buffer for where to store the read data. + * @param cbBuf Size (in bytes) of buffer. + * @param fFlags Read flags. Optional. + * @param pcbRead Where to return how much bytes were read on success. Optional. + */ +int ShClTransferObjRead(PSHCLTRANSFER pTransfer, + SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t fFlags, uint32_t *pcbRead) +{ + 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 == SHCLSOURCE_LOCAL) + { + PSHCLOBJHANDLEINFO pInfo = shClTransferObjGet(pTransfer, hObj); + if (pInfo) + { + switch (pInfo->enmType) + { + case SHCLOBJTYPE_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 == SHCLSOURCE_REMOTE) + { + if (pTransfer->ProviderIface.pfnObjRead) + { + rc = pTransfer->ProviderIface.pfnObjRead(&pTransfer->ProviderCtx, hObj, pvBuf, cbBuf, fFlags, pcbRead); + } + else + rc = VERR_NOT_SUPPORTED; + } + else + AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED); + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Writes to a transfer object. + * + * @returns VBox status code. + * @param pTransfer Clipboard transfer that contains the object to write to. + * @param hObj Handle of transfer object to write to. + * @param pvBuf Buffer of data to write. + * @param cbBuf Size (in bytes) of buffer to write. + * @param fFlags Write flags. Optional. + * @param pcbWritten How much bytes were writtenon success. Optional. + */ +int ShClTransferObjWrite(PSHCLTRANSFER pTransfer, + SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t fFlags, uint32_t *pcbWritten) +{ + 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 == SHCLSOURCE_LOCAL) + { + PSHCLOBJHANDLEINFO pInfo = shClTransferObjGet(pTransfer, hObj); + if (pInfo) + { + switch (pInfo->enmType) + { + case SHCLOBJTYPE_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 == SHCLSOURCE_REMOTE) + { + if (pTransfer->ProviderIface.pfnObjWrite) + { + rc = pTransfer->ProviderIface.pfnObjWrite(&pTransfer->ProviderCtx, hObj, pvBuf, cbBuf, fFlags, pcbWritten); + } + else + rc = VERR_NOT_SUPPORTED; + } + else + AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED); + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Duplicates a transfer object data chunk. + * + * @returns Duplicated object data chunk on success, or NULL on failure. + * @param pDataChunk transfer object data chunk to duplicate. + */ +PSHCLOBJDATACHUNK ShClTransferObjDataChunkDup(PSHCLOBJDATACHUNK pDataChunk) +{ + if (!pDataChunk) + return NULL; + + PSHCLOBJDATACHUNK pDataChunkDup = (PSHCLOBJDATACHUNK)RTMemAllocZ(sizeof(SHCLOBJDATACHUNK)); + 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 a transfer object data chunk. + * + * @param pDataChunk transfer object data chunk to destroy. + */ +void ShClTransferObjDataChunkDestroy(PSHCLOBJDATACHUNK pDataChunk) +{ + if (!pDataChunk) + return; + + if (pDataChunk->pvData) + { + Assert(pDataChunk->cbData); + + RTMemFree(pDataChunk->pvData); + + pDataChunk->pvData = NULL; + pDataChunk->cbData = 0; + } + + pDataChunk->uHandle = 0; +} + +/** + * Frees a transfer object data chunk. + * + * @param pDataChunk transfer object data chunk to free. The handed-in pointer will + * be invalid after calling this function. + */ +void ShClTransferObjDataChunkFree(PSHCLOBJDATACHUNK pDataChunk) +{ + if (!pDataChunk) + return; + + ShClTransferObjDataChunkDestroy(pDataChunk); + + RTMemFree(pDataChunk); + pDataChunk = NULL; +} + +/** + * Creates a clipboard transfer. + * + * @returns VBox status code. + * @param ppTransfer Where to return the created Shared Clipboard transfer struct. + * Must be destroyed by ShClTransferDestroy(). + */ +int ShClTransferCreate(PSHCLTRANSFER *ppTransfer) +{ + AssertPtrReturn(ppTransfer, VERR_INVALID_POINTER); + + LogFlowFuncEnter(); + + PSHCLTRANSFER pTransfer = (PSHCLTRANSFER)RTMemAllocZ(sizeof(SHCLTRANSFER)); + AssertPtrReturn(pTransfer, VERR_NO_MEMORY); + + pTransfer->State.uID = 0; + pTransfer->State.enmStatus = SHCLTRANSFERSTATUS_NONE; + pTransfer->State.enmDir = SHCLTRANSFERDIR_UNKNOWN; + pTransfer->State.enmSource = SHCLSOURCE_INVALID; + + pTransfer->Thread.hThread = NIL_RTTHREAD; + pTransfer->Thread.fCancelled = false; + pTransfer->Thread.fStarted = false; + pTransfer->Thread.fStop = false; + + pTransfer->pszPathRootAbs = NULL; + +#ifdef DEBUG_andy + pTransfer->uTimeoutMs = RT_MS_5SEC; +#else + pTransfer->uTimeoutMs = RT_MS_30SEC; +#endif + pTransfer->cbMaxChunkSize = _64K; /** @todo Make this configurable. */ + pTransfer->cMaxListHandles = _4K; /** @todo Ditto. */ + pTransfer->cMaxObjHandles = _4K; /** @todo Ditto. */ + + pTransfer->pvUser = NULL; + pTransfer->cbUser = 0; + + RTListInit(&pTransfer->lstList); + RTListInit(&pTransfer->lstObj); + + pTransfer->cRoots = 0; + RTListInit(&pTransfer->lstRoots); + + int rc = ShClEventSourceCreate(&pTransfer->Events, 0 /* uID */); + if (RT_SUCCESS(rc)) + { + *ppTransfer = pTransfer; + } + else + { + if (pTransfer) + { + ShClTransferDestroy(pTransfer); + RTMemFree(pTransfer); + } + } + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Destroys a clipboard transfer context struct. + * + * @returns VBox status code. + * @param pTransferCtx Clipboard transfer to destroy. + */ +int ShClTransferDestroy(PSHCLTRANSFER pTransfer) +{ + if (!pTransfer) + return VINF_SUCCESS; + + LogFlowFuncEnter(); + + int rc = shClTransferThreadDestroy(pTransfer, 30 * 1000 /* Timeout in ms */); + if (RT_FAILURE(rc)) + return rc; + + ShClTransferReset(pTransfer); + + ShClEventSourceDestroy(&pTransfer->Events); + + LogFlowFuncLeave(); + return VINF_SUCCESS; +} + +/** + * Initializes a Shared Clipboard transfer object. + * + * @returns VBox status code. + * @param pTransfer Transfer to initialize. + * @param enmDir Specifies the transfer direction of this transfer. + * @param enmSource Specifies the data source of the transfer. + */ +int ShClTransferInit(PSHCLTRANSFER pTransfer, SHCLTRANSFERDIR enmDir, SHCLSOURCE enmSource) +{ + pTransfer->State.enmDir = enmDir; + pTransfer->State.enmSource = enmSource; + + LogFlowFunc(("uID=%RU32, enmDir=%RU32, enmSource=%RU32\n", + pTransfer->State.uID, pTransfer->State.enmDir, pTransfer->State.enmSource)); + + pTransfer->State.enmStatus = SHCLTRANSFERSTATUS_INITIALIZED; /* Now we're ready to run. */ + + pTransfer->cListHandles = 0; + pTransfer->uListHandleNext = 1; + + pTransfer->cObjHandles = 0; + pTransfer->uObjHandleNext = 1; + + int rc = VINF_SUCCESS; + + if (pTransfer->Callbacks.pfnOnInitialize) + rc = pTransfer->Callbacks.pfnOnInitialize(&pTransfer->CallbackCtx); + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Returns a specific list handle info of a transfer. + * + * @returns Pointer to list handle info if found, or NULL if not found. + * @param pTransfer Clipboard transfer to get list handle info from. + * @param hList List handle of the list to get handle info for. + */ +DECLINLINE(PSHCLLISTHANDLEINFO) shClTransferListGetByHandle(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList) +{ + PSHCLLISTHANDLEINFO pIt; + RTListForEach(&pTransfer->lstList, pIt, SHCLLISTHANDLEINFO, Node) /** @todo Sloooow ... improve this. */ + { + if (pIt->hList == hList) + return pIt; + } + + return NULL; +} + +/** + * Creates a new list handle (local only). + * + * @returns New List handle on success, or SHCLLISTHANDLE_INVALID on error. + * @param pTransfer Clipboard transfer to create new list handle for. + */ +DECLINLINE(SHCLLISTHANDLE) shClTransferListHandleNew(PSHCLTRANSFER pTransfer) +{ + return pTransfer->uListHandleNext++; /** @todo Good enough for now. Improve this later. */ +} + +/** + * Validates whether a given path matches our set of rules or not. + * + * @returns VBox status code. + * @param pcszPath Path to validate. + * @param fMustExist Whether the path to validate also must exist. + */ +static int shClTransferValidatePath(const char *pcszPath, bool fMustExist) +{ + int rc = VINF_SUCCESS; + + if (!strlen(pcszPath)) + rc = VERR_INVALID_PARAMETER; + + if ( RT_SUCCESS(rc) + && !RTStrIsValidEncoding(pcszPath)) + { + rc = VERR_INVALID_UTF8_ENCODING; + } + + if ( RT_SUCCESS(rc) + && RTStrStr(pcszPath, "..")) + { + rc = VERR_INVALID_PARAMETER; + } + + if ( RT_SUCCESS(rc) + && fMustExist) + { + RTFSOBJINFO objInfo; + rc = RTPathQueryInfo(pcszPath, &objInfo, RTFSOBJATTRADD_NOTHING); + if (RT_SUCCESS(rc)) + { + if (RTFS_IS_DIRECTORY(objInfo.Attr.fMode)) + { + if (!RTDirExists(pcszPath)) /* Path must exist. */ + rc = VERR_PATH_NOT_FOUND; + } + else if (RTFS_IS_FILE(objInfo.Attr.fMode)) + { + if (!RTFileExists(pcszPath)) /* File must exist. */ + rc = VERR_FILE_NOT_FOUND; + } + else /* Everything else (e.g. symbolic links) are not supported. */ + { + LogRel2(("Shared Clipboard: Path '%s' contains a symbolic link or junktion, which are not supported\n", pcszPath)); + rc = VERR_NOT_SUPPORTED; + } + } + } + + if (RT_FAILURE(rc)) + LogRel2(("Shared Clipboard: Validating path '%s' failed: %Rrc\n", pcszPath, rc)); + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Resolves a relative path of a specific transfer to its absolute path. + * + * @returns VBox status code. + * @param pTransfer Clipboard transfer to resolve path for. + * @param pszPath Path to resolve. + * @param fFlags Resolve flags. Currently not used and must be 0. + * @param ppszResolved Where to store the allocated resolved path. Must be free'd by the called using RTStrFree(). + */ +static int shClTransferResolvePathAbs(PSHCLTRANSFER pTransfer, const char *pszPath, uint32_t fFlags, + char **ppszResolved) +{ + AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); + AssertPtrReturn(pszPath, VERR_INVALID_POINTER); + AssertReturn (fFlags == 0, VERR_INVALID_PARAMETER); + + LogFlowFunc(("pszPathRootAbs=%s, pszPath=%s\n", pTransfer->pszPathRootAbs, pszPath)); + + int rc = shClTransferValidatePath(pszPath, false /* fMustExist */); + if (RT_SUCCESS(rc)) + { + char *pszPathAbs = RTPathJoinA(pTransfer->pszPathRootAbs, pszPath); + if (pszPathAbs) + { + char szResolved[RTPATH_MAX]; + size_t cbResolved = sizeof(szResolved); + rc = RTPathAbsEx(pTransfer->pszPathRootAbs, pszPathAbs, RTPATH_STR_F_STYLE_HOST, szResolved, &cbResolved); + + RTStrFree(pszPathAbs); + + if (RT_SUCCESS(rc)) + { + LogFlowFunc(("pszResolved=%s\n", szResolved)); + + rc = VERR_PATH_NOT_FOUND; /* Play safe by default. */ + + /* Make sure the resolved path is part of the set of root entries. */ + PSHCLLISTROOT pListRoot; + RTListForEach(&pTransfer->lstRoots, pListRoot, SHCLLISTROOT, Node) + { + if (RTPathStartsWith(szResolved, pListRoot->pszPathAbs)) + { + rc = VINF_SUCCESS; + break; + } + } + + if (RT_SUCCESS(rc)) + *ppszResolved = RTStrDup(szResolved); + } + } + else + rc = VERR_NO_MEMORY; + } + + if (RT_FAILURE(rc)) + LogRel(("Shared Clipboard: Resolving absolute path '%s' failed, rc=%Rrc\n", pszPath, rc)); + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Opens a list. + * + * @returns VBox status code. + * @param pTransfer Clipboard transfer to handle. + * @param pOpenParms List open parameters to use for opening. + * @param phList Where to store the List handle of opened list on success. + */ +int ShClTransferListOpen(PSHCLTRANSFER pTransfer, PSHCLLISTOPENPARMS pOpenParms, + PSHCLLISTHANDLE phList) +{ + AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); + AssertPtrReturn(pOpenParms, VERR_INVALID_POINTER); + AssertPtrReturn(phList, VERR_INVALID_POINTER); + + int rc; + + if (pTransfer->cListHandles == pTransfer->cMaxListHandles) + return VERR_SHCLPB_MAX_LISTS_REACHED; + + if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL) + { + LogFlowFunc(("pszPath=%s\n", pOpenParms->pszPath)); + + PSHCLLISTHANDLEINFO pInfo + = (PSHCLLISTHANDLEINFO)RTMemAllocZ(sizeof(SHCLLISTHANDLEINFO)); + if (pInfo) + { + rc = ShClTransferListHandleInfoInit(pInfo); + if (RT_SUCCESS(rc)) + { + rc = shClTransferResolvePathAbs(pTransfer, pOpenParms->pszPath, 0 /* fFlags */, &pInfo->pszPathLocalAbs); + if (RT_SUCCESS(rc)) + { + RTFSOBJINFO objInfo; + rc = RTPathQueryInfo(pInfo->pszPathLocalAbs, &objInfo, RTFSOBJATTRADD_NOTHING); + if (RT_SUCCESS(rc)) + { + if (RTFS_IS_DIRECTORY(objInfo.Attr.fMode)) + { + rc = RTDirOpen(&pInfo->u.Local.hDir, pInfo->pszPathLocalAbs); + if (RT_SUCCESS(rc)) + { + pInfo->enmType = SHCLOBJTYPE_DIRECTORY; + + LogRel2(("Shared Clipboard: Opening directory '%s'\n", pInfo->pszPathLocalAbs)); + } + else + LogRel(("Shared Clipboard: Opening directory '%s' failed with %Rrc\n", pInfo->pszPathLocalAbs, rc)); + + } + else if (RTFS_IS_FILE(objInfo.Attr.fMode)) + { + rc = RTFileOpen(&pInfo->u.Local.hFile, pInfo->pszPathLocalAbs, + RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_WRITE); + if (RT_SUCCESS(rc)) + { + pInfo->enmType = SHCLOBJTYPE_FILE; + + LogRel2(("Shared Clipboard: Opening file '%s'\n", pInfo->pszPathLocalAbs)); + } + else + LogRel(("Shared Clipboard: Opening file '%s' failed with %Rrc\n", pInfo->pszPathLocalAbs, rc)); + } + else + rc = VERR_NOT_SUPPORTED; + + if (RT_SUCCESS(rc)) + { + pInfo->hList = shClTransferListHandleNew(pTransfer); + + RTListAppend(&pTransfer->lstList, &pInfo->Node); + pTransfer->cListHandles++; + + if (phList) + *phList = pInfo->hList; + + LogFlowFunc(("pszPathLocalAbs=%s, hList=%RU64, cListHandles=%RU32\n", + pInfo->pszPathLocalAbs, pInfo->hList, pTransfer->cListHandles)); + } + else + { + if (RTFS_IS_DIRECTORY(objInfo.Attr.fMode)) + { + if (RTDirIsValid(pInfo->u.Local.hDir)) + RTDirClose(pInfo->u.Local.hDir); + } + else if (RTFS_IS_FILE(objInfo.Attr.fMode)) + { + if (RTFileIsValid(pInfo->u.Local.hFile)) + RTFileClose(pInfo->u.Local.hFile); + } + } + } + } + } + + if (RT_FAILURE(rc)) + { + ShClTransferListHandleInfoDestroy(pInfo); + + RTMemFree(pInfo); + pInfo = NULL; + } + } + else + rc = VERR_NO_MEMORY; + } + else if (pTransfer->State.enmSource == SHCLSOURCE_REMOTE) + { + if (pTransfer->ProviderIface.pfnListOpen) + { + rc = pTransfer->ProviderIface.pfnListOpen(&pTransfer->ProviderCtx, pOpenParms, phList); + } + else + rc = VERR_NOT_SUPPORTED; + } + else + AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED); + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Closes a list. + * + * @returns VBox status code. + * @param pTransfer Clipboard transfer to handle. + * @param hList Handle of list to close. + */ +int ShClTransferListClose(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList) +{ + AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); + + if (hList == SHCLLISTHANDLE_INVALID) + return VINF_SUCCESS; + + int rc = VINF_SUCCESS; + + if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL) + { + PSHCLLISTHANDLEINFO pInfo = shClTransferListGetByHandle(pTransfer, hList); + if (pInfo) + { + switch (pInfo->enmType) + { + case SHCLOBJTYPE_DIRECTORY: + { + if (RTDirIsValid(pInfo->u.Local.hDir)) + { + RTDirClose(pInfo->u.Local.hDir); + pInfo->u.Local.hDir = NIL_RTDIR; + } + break; + } + + default: + rc = VERR_NOT_SUPPORTED; + break; + } + + RTListNodeRemove(&pInfo->Node); + + Assert(pTransfer->cListHandles); + pTransfer->cListHandles--; + + RTMemFree(pInfo); + } + else + rc = VERR_NOT_FOUND; + } + else if (pTransfer->State.enmSource == SHCLSOURCE_REMOTE) + { + if (pTransfer->ProviderIface.pfnListClose) + { + rc = pTransfer->ProviderIface.pfnListClose(&pTransfer->ProviderCtx, hList); + } + else + rc = VERR_NOT_SUPPORTED; + } + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Adds a file to a list heaer. + * + * @returns VBox status code. + * @param pHdr List header to add file to. + * @param pszPath Path of file to add. + */ +static int shclTransferListHdrAddFile(PSHCLLISTHDR pHdr, const char *pszPath) +{ + uint64_t cbSize = 0; + int rc = RTFileQuerySizeByPath(pszPath, &cbSize); + if (RT_SUCCESS(rc)) + { + pHdr->cbTotalSize += cbSize; + pHdr->cTotalObjects++; + } + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Builds a list header, internal version. + * + * @returns VBox status code. + * @param pHdr Where to store the build list header. + * @param pcszSrcPath Source path of list. + * @param pcszDstPath Destination path of list. + * @param pcszDstBase Destination base path. + * @param cchDstBase Number of charaters of destination base path. + */ +static int shclTransferListHdrFromDir(PSHCLLISTHDR pHdr, const char *pcszPathAbs) +{ + AssertPtrReturn(pcszPathAbs, VERR_INVALID_POINTER); + + LogFlowFunc(("pcszPathAbs=%s\n", pcszPathAbs)); + + RTFSOBJINFO objInfo; + int rc = RTPathQueryInfo(pcszPathAbs, &objInfo, RTFSOBJATTRADD_NOTHING); + if (RT_SUCCESS(rc)) + { + if (RTFS_IS_DIRECTORY(objInfo.Attr.fMode)) + { + RTDIR hDir; + rc = RTDirOpen(&hDir, pcszPathAbs); + if (RT_SUCCESS(rc)) + { + size_t cbDirEntry = 0; + PRTDIRENTRYEX pDirEntry = NULL; + do + { + /* Retrieve the next directory entry. */ + rc = RTDirReadExA(hDir, &pDirEntry, &cbDirEntry, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK); + if (RT_FAILURE(rc)) + { + if (rc == VERR_NO_MORE_FILES) + rc = VINF_SUCCESS; + break; + } + + switch (pDirEntry->Info.Attr.fMode & RTFS_TYPE_MASK) + { + case RTFS_TYPE_DIRECTORY: + { + /* Skip "." and ".." entries. */ + if (RTDirEntryExIsStdDotLink(pDirEntry)) + break; + + pHdr->cTotalObjects++; + break; + } + case RTFS_TYPE_FILE: + { + char *pszSrc = RTPathJoinA(pcszPathAbs, pDirEntry->szName); + if (pszSrc) + { + rc = shclTransferListHdrAddFile(pHdr, pszSrc); + RTStrFree(pszSrc); + } + else + rc = VERR_NO_MEMORY; + break; + } + case RTFS_TYPE_SYMLINK: + { + /** @todo Not implemented yet. */ + } + + default: + break; + } + + } while (RT_SUCCESS(rc)); + + RTDirReadExAFree(&pDirEntry, &cbDirEntry); + RTDirClose(hDir); + } + } + else if (RTFS_IS_FILE(objInfo.Attr.fMode)) + { + rc = shclTransferListHdrAddFile(pHdr, pcszPathAbs); + } + else if (RTFS_IS_SYMLINK(objInfo.Attr.fMode)) + { + /** @todo Not implemented yet. */ + } + else + rc = VERR_NOT_SUPPORTED; + } + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Retrieves the header of a Shared Clipboard list. + * + * @returns VBox status code. + * @param pTransfer Clipboard transfer to handle. + * @param hList Handle of list to get header for. + * @param pHdr Where to store the returned list header information. + */ +int ShClTransferListGetHeader(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList, + PSHCLLISTHDR pHdr) +{ + AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); + AssertPtrReturn(pHdr, VERR_INVALID_POINTER); + + int rc; + + LogFlowFunc(("hList=%RU64\n", hList)); + + if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL) + { + PSHCLLISTHANDLEINFO pInfo = shClTransferListGetByHandle(pTransfer, hList); + if (pInfo) + { + rc = ShClTransferListHdrInit(pHdr); + if (RT_SUCCESS(rc)) + { + switch (pInfo->enmType) + { + case SHCLOBJTYPE_DIRECTORY: + { + LogFlowFunc(("DirAbs: %s\n", pInfo->pszPathLocalAbs)); + + rc = shclTransferListHdrFromDir(pHdr, pInfo->pszPathLocalAbs); + break; + } + + case SHCLOBJTYPE_FILE: + { + LogFlowFunc(("FileAbs: %s\n", pInfo->pszPathLocalAbs)); + + 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; + } + } + + LogFlowFunc(("cTotalObj=%RU64, cbTotalSize=%RU64\n", pHdr->cTotalObjects, pHdr->cbTotalSize)); + } + else + rc = VERR_NOT_FOUND; + } + else if (pTransfer->State.enmSource == SHCLSOURCE_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 transfer object for a Shared Clipboard transfer list. + * + * Currently not implemented and wil return NULL. + * + * @returns Pointer to transfer object, or NULL if not found / invalid. + * @param pTransfer Clipboard transfer to return transfer object for. + * @param hList Handle of Shared Clipboard transfer list to get object for. + * @param uIdx Index of object to get. + */ +PSHCLTRANSFEROBJ ShClTransferListGetObj(PSHCLTRANSFER pTransfer, + SHCLLISTHANDLE 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 Clipboard transfer to handle. + * @param hList List handle of list to read from. + * @param pEntry Where to store the read information. + */ +int ShClTransferListRead(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList, + PSHCLLISTENTRY pEntry) +{ + AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); + AssertPtrReturn(pEntry, VERR_INVALID_POINTER); + + int rc = VINF_SUCCESS; + + LogFlowFunc(("hList=%RU64\n", hList)); + + if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL) + { + PSHCLLISTHANDLEINFO pInfo = shClTransferListGetByHandle(pTransfer, hList); + if (pInfo) + { + switch (pInfo->enmType) + { + case SHCLOBJTYPE_DIRECTORY: + { + 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) + { + rc = RTStrCopy(pEntry->pszName, pEntry->cbName, pDirEntry->szName); + if (RT_SUCCESS(rc)) + { + pEntry->cbName = (uint32_t)strlen(pEntry->pszName) + 1; /* Include termination. */ + + AssertPtr(pEntry->pvInfo); + Assert (pEntry->cbInfo == sizeof(SHCLFSOBJINFO)); + + ShClFsObjFromIPRT(PSHCLFSOBJINFO(pEntry->pvInfo), &pDirEntry->Info); + + LogFlowFunc(("Entry pszName=%s, pvInfo=%p, cbInfo=%RU32\n", + pEntry->pszName, pEntry->pvInfo, pEntry->cbInfo)); + } + } + + RTDirReadExAFree(&pDirEntry, &cbDirEntry); + } + + if ( !fSkipEntry /* Do we have a valid entry? Bail out. */ + || RT_FAILURE(rc)) + { + break; + } + } + + break; + } + + case SHCLOBJTYPE_FILE: + { + LogFlowFunc(("\tSingle file: %s\n", pInfo->pszPathLocalAbs)); + + RTFSOBJINFO objInfo; + rc = RTFileQueryInfo(pInfo->u.Local.hFile, &objInfo, RTFSOBJATTRADD_NOTHING); + if (RT_SUCCESS(rc)) + { + pEntry->pvInfo = (PSHCLFSOBJINFO)RTMemAlloc(sizeof(SHCLFSOBJINFO)); + if (pEntry->pvInfo) + { + rc = RTStrCopy(pEntry->pszName, pEntry->cbName, pInfo->pszPathLocalAbs); + if (RT_SUCCESS(rc)) + { + ShClFsObjFromIPRT(PSHCLFSOBJINFO(pEntry->pvInfo), &objInfo); + + pEntry->cbInfo = sizeof(SHCLFSOBJINFO); + pEntry->fInfo = VBOX_SHCL_INFO_FLAG_FSOBJINFO; + } + } + else + rc = VERR_NO_MEMORY; + } + + break; + } + + default: + rc = VERR_NOT_SUPPORTED; + break; + } + } + else + rc = VERR_NOT_FOUND; + } + else if (pTransfer->State.enmSource == SHCLSOURCE_REMOTE) + { + if (pTransfer->ProviderIface.pfnListEntryRead) + rc = pTransfer->ProviderIface.pfnListEntryRead(&pTransfer->ProviderCtx, hList, pEntry); + else + rc = VERR_NOT_SUPPORTED; + } + else + AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED); + + LogFlowFuncLeaveRC(rc); + return rc; +} + +int ShClTransferListWrite(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList, + PSHCLLISTENTRY pEntry) +{ + RT_NOREF(pTransfer, hList, pEntry); + + int rc = VINF_SUCCESS; + +#if 0 + if (pTransfer->ProviderIface.pfnListEntryWrite) + rc = pTransfer->ProviderIface.pfnListEntryWrite(&pTransfer->ProviderCtx, hList, pEntry); +#endif + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Returns whether a given list handle is valid or not. + * + * @returns \c true if list handle is valid, \c false if not. + * @param pTransfer Clipboard transfer to handle. + * @param hList List handle to check. + */ +bool ShClTransferListHandleIsValid(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList) +{ + bool fIsValid = false; + + if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL) + { + fIsValid = shClTransferListGetByHandle(pTransfer, hList) != NULL; + } + else if (pTransfer->State.enmSource == SHCLSOURCE_REMOTE) + { + AssertFailed(); /** @todo Implement. */ + } + else + AssertFailedStmt(fIsValid = false); + + return fIsValid; +} + +/** + * Copies a transfer callback table from source to destination. + * + * @param pCallbacksDst Callback destination. + * @param pCallbacksSrc Callback source. If set to NULL, the + * destination callback table will be unset. + */ +void ShClTransferCopyCallbacks(PSHCLTRANSFERCALLBACKTABLE pCallbacksDst, + PSHCLTRANSFERCALLBACKTABLE pCallbacksSrc) +{ + AssertPtrReturnVoid(pCallbacksDst); + + if (pCallbacksSrc) /* Set */ + { +#define SET_CALLBACK(a_pfnCallback) \ + if (pCallbacksSrc->a_pfnCallback) \ + pCallbacksDst->a_pfnCallback = pCallbacksSrc->a_pfnCallback + + SET_CALLBACK(pfnOnInitialize); + SET_CALLBACK(pfnOnStart); + SET_CALLBACK(pfnOnCompleted); + SET_CALLBACK(pfnOnError); + SET_CALLBACK(pfnOnRegistered); + SET_CALLBACK(pfnOnUnregistered); + +#undef SET_CALLBACK + + pCallbacksDst->pvUser = pCallbacksSrc->pvUser; + pCallbacksDst->cbUser = pCallbacksSrc->cbUser; + } + else /* Unset */ + RT_BZERO(pCallbacksDst, sizeof(SHCLTRANSFERCALLBACKTABLE)); +} + +/** + * Sets or unsets the callback table to be used for a Shared Clipboard transfer. + * + * @returns VBox status code. + * @param pTransfer Clipboard transfer to set callbacks for. + * @param pCallbacks Pointer to callback table to set. If set to NULL, + * existing callbacks for this transfer will be unset. + */ +void ShClTransferSetCallbacks(PSHCLTRANSFER pTransfer, + PSHCLTRANSFERCALLBACKTABLE pCallbacks) +{ + AssertPtrReturnVoid(pTransfer); + /* pCallbacks can be NULL. */ + + ShClTransferCopyCallbacks(&pTransfer->Callbacks, pCallbacks); +} + +/** + * Sets the transfer provider interface for a given transfer. + * + * @returns VBox status code. + * @param pTransfer Transfer to create transfer provider for. + * @param pCreationCtx Provider creation context to use for provider creation. + */ +int ShClTransferSetProviderIface(PSHCLTRANSFER pTransfer, + PSHCLTXPROVIDERCREATIONCTX pCreationCtx) +{ + AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); + AssertPtrReturn(pCreationCtx, VERR_INVALID_POINTER); + + LogFlowFuncEnter(); + + int rc = VINF_SUCCESS; + + pTransfer->ProviderIface = pCreationCtx->Interface; + pTransfer->ProviderCtx.pTransfer = pTransfer; + pTransfer->ProviderCtx.pvUser = pCreationCtx->pvUser; + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Clears (resets) the root list of a Shared Clipboard transfer. + * + * @param pTransfer Transfer to clear transfer root list for. + */ +static void shClTransferListRootsClear(PSHCLTRANSFER pTransfer) +{ + AssertPtrReturnVoid(pTransfer); + + if (pTransfer->pszPathRootAbs) + { + RTStrFree(pTransfer->pszPathRootAbs); + pTransfer->pszPathRootAbs = NULL; + } + + PSHCLLISTROOT pListRoot, pListRootNext; + RTListForEachSafe(&pTransfer->lstRoots, pListRoot, pListRootNext, SHCLLISTROOT, Node) + { + RTStrFree(pListRoot->pszPathAbs); + + RTListNodeRemove(&pListRoot->Node); + + RTMemFree(pListRoot); + pListRoot = NULL; + } + + pTransfer->cRoots = 0; +} + +/** + * Resets a Shared Clipboard transfer. + * + * @param pTransfer Clipboard transfer to reset. + */ +void ShClTransferReset(PSHCLTRANSFER pTransfer) +{ + AssertPtrReturnVoid(pTransfer); + + LogFlowFuncEnter(); + + shClTransferListRootsClear(pTransfer); + + PSHCLLISTHANDLEINFO pItList, pItListNext; + RTListForEachSafe(&pTransfer->lstList, pItList, pItListNext, SHCLLISTHANDLEINFO, Node) + { + ShClTransferListHandleInfoDestroy(pItList); + + RTListNodeRemove(&pItList->Node); + + RTMemFree(pItList); + } + + PSHCLOBJHANDLEINFO pItObj, pItObjNext; + RTListForEachSafe(&pTransfer->lstObj, pItObj, pItObjNext, SHCLOBJHANDLEINFO, Node) + { + ShClTransferObjHandleInfoDestroy(pItObj); + + RTListNodeRemove(&pItObj->Node); + + RTMemFree(pItObj); + } +} + +/** + * Returns the number of transfer root list entries. + * + * @returns Root list entry count. + * @param pTransfer Clipboard transfer to return root entry count for. + */ +uint32_t ShClTransferRootsCount(PSHCLTRANSFER pTransfer) +{ + AssertPtrReturn(pTransfer, 0); + + LogFlowFunc(("[Transfer %RU32] cRoots=%RU64\n", pTransfer->State.uID, pTransfer->cRoots)); + return (uint32_t)pTransfer->cRoots; +} + +/** + * Returns a specific root list entry of a transfer. + * + * @returns Pointer to root list entry if found, or NULL if not found. + * @param pTransfer Clipboard transfer to get root list entry from. + * @param uIdx Index of root list entry to return. + */ +DECLINLINE(PSHCLLISTROOT) shClTransferRootsGetInternal(PSHCLTRANSFER pTransfer, uint32_t uIdx) +{ + if (uIdx >= pTransfer->cRoots) + return NULL; + + PSHCLLISTROOT pIt = RTListGetFirst(&pTransfer->lstRoots, SHCLLISTROOT, Node); + while (uIdx--) /** @todo Slow, but works for now. */ + pIt = RTListGetNext(&pTransfer->lstRoots, pIt, SHCLLISTROOT, Node); + + return pIt; +} + +/** + * Get a specific root list entry. + * + * @returns VBox status code. + * @param pTransfer Clipboard transfer to get root list entry of. + * @param uIndex Index (zero-based) of entry to get. + * @param pEntry Where to store the returned entry on success. + */ +int ShClTransferRootsEntry(PSHCLTRANSFER pTransfer, + uint64_t uIndex, PSHCLROOTLISTENTRY pEntry) +{ + AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); + AssertPtrReturn(pEntry, VERR_INVALID_POINTER); + + if (uIndex >= pTransfer->cRoots) + return VERR_INVALID_PARAMETER; + + int rc; + + PSHCLLISTROOT pRoot = shClTransferRootsGetInternal(pTransfer, uIndex); + AssertPtrReturn(pRoot, VERR_INVALID_PARAMETER); + + /* Make sure that we only advertise relative source paths, not absolute ones. */ + const char *pcszSrcPath = pRoot->pszPathAbs; + + char *pszFileName = RTPathFilename(pcszSrcPath); + if (pszFileName) + { + Assert(pszFileName >= pcszSrcPath); + size_t cchDstBase = pszFileName - pcszSrcPath; + const char *pszDstPath = &pcszSrcPath[cchDstBase]; + + LogFlowFunc(("pcszSrcPath=%s, pszDstPath=%s\n", pcszSrcPath, pszDstPath)); + + rc = ShClTransferListEntryInit(pEntry); + if (RT_SUCCESS(rc)) + { + rc = RTStrCopy(pEntry->pszName, pEntry->cbName, pszDstPath); + if (RT_SUCCESS(rc)) + { + pEntry->cbInfo = sizeof(SHCLFSOBJINFO); + pEntry->pvInfo = (PSHCLFSOBJINFO)RTMemAlloc(pEntry->cbInfo); + if (pEntry->pvInfo) + { + RTFSOBJINFO fsObjInfo; + rc = RTPathQueryInfo(pcszSrcPath, &fsObjInfo, RTFSOBJATTRADD_NOTHING); + if (RT_SUCCESS(rc)) + { + ShClFsObjFromIPRT(PSHCLFSOBJINFO(pEntry->pvInfo), &fsObjInfo); + + pEntry->fInfo = VBOX_SHCL_INFO_FLAG_FSOBJINFO; + } + } + else + rc = VERR_NO_MEMORY; + } + } + } + else + rc = VERR_INVALID_POINTER; + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Returns the root entries of a Shared Clipboard transfer. + * + * @returns VBox status code. + * @param pTransfer Clipboard transfer to return root entries for. + * @param ppRootList Where to store the root list on success. + */ +int ShClTransferRootsGet(PSHCLTRANSFER pTransfer, PSHCLROOTLIST *ppRootList) +{ + AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); + AssertPtrReturn(ppRootList, VERR_INVALID_POINTER); + + LogFlowFuncEnter(); + + int rc = VINF_SUCCESS; + + if (pTransfer->State.enmSource == SHCLSOURCE_LOCAL) + { + PSHCLROOTLIST pRootList = ShClTransferRootListAlloc(); + if (!pRootList) + return VERR_NO_MEMORY; + + const uint64_t cRoots = (uint32_t)pTransfer->cRoots; + + LogFlowFunc(("cRoots=%RU64\n", cRoots)); + + if (cRoots) + { + PSHCLROOTLISTENTRY paRootListEntries + = (PSHCLROOTLISTENTRY)RTMemAllocZ(cRoots * sizeof(SHCLROOTLISTENTRY)); + if (paRootListEntries) + { + for (uint64_t i = 0; i < cRoots; ++i) + { + rc = ShClTransferRootsEntry(pTransfer, i, &paRootListEntries[i]); + if (RT_FAILURE(rc)) + break; + } + + if (RT_SUCCESS(rc)) + pRootList->paEntries = paRootListEntries; + } + else + rc = VERR_NO_MEMORY; + } + else + rc = VERR_NOT_FOUND; + + if (RT_SUCCESS(rc)) + { + pRootList->Hdr.cRoots = cRoots; + pRootList->Hdr.fRoots = 0; /** @todo Implement this. */ + + *ppRootList = pRootList; + } + } + else if (pTransfer->State.enmSource == SHCLSOURCE_REMOTE) + { + if (pTransfer->ProviderIface.pfnRootsGet) + rc = pTransfer->ProviderIface.pfnRootsGet(&pTransfer->ProviderCtx, ppRootList); + else + rc = VERR_NOT_SUPPORTED; + } + else + AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED); + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Sets transfer root list entries for a given transfer. + * + * @returns VBox status code. + * @param pTransfer Transfer to set transfer 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 ShClTransferRootsSet(PSHCLTRANSFER pTransfer, const char *pszRoots, size_t cbRoots) +{ + AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); + AssertPtrReturn(pszRoots, VERR_INVALID_POINTER); + AssertReturn(cbRoots, VERR_INVALID_PARAMETER); + + if (!RTStrIsValidEncoding(pszRoots)) + return VERR_INVALID_UTF8_ENCODING; + + int rc = VINF_SUCCESS; + + shClTransferListRootsClear(pTransfer); + + char *pszPathRootAbs = NULL; + + RTCList<RTCString> lstRootEntries = RTCString(pszRoots, cbRoots - 1).split("\r\n"); + for (size_t i = 0; i < lstRootEntries.size(); ++i) + { + PSHCLLISTROOT pListRoot = (PSHCLLISTROOT)RTMemAlloc(sizeof(SHCLLISTROOT)); + AssertPtrBreakStmt(pListRoot, rc = VERR_NO_MEMORY); + + const char *pszPathCur = RTStrDup(lstRootEntries.at(i).c_str()); + + LogFlowFunc(("pszPathCur=%s\n", pszPathCur)); + + /* No root path determined yet? */ + if (!pszPathRootAbs) + { + pszPathRootAbs = RTStrDup(pszPathCur); + if (pszPathRootAbs) + { + RTPathStripFilename(pszPathRootAbs); + + LogFlowFunc(("pszPathRootAbs=%s\n", pszPathRootAbs)); + + /* We don't want to have a relative directory here. */ + if (RTPathStartsWithRoot(pszPathRootAbs)) + { + rc = shClTransferValidatePath(pszPathRootAbs, true /* Path must exist */); + } + else + rc = VERR_INVALID_PARAMETER; + } + else + rc = VERR_NO_MEMORY; + } + + if (RT_FAILURE(rc)) + break; + + pListRoot->pszPathAbs = RTStrDup(pszPathCur); + if (!pListRoot->pszPathAbs) + { + rc = VERR_NO_MEMORY; + break; + } + + RTListAppend(&pTransfer->lstRoots, &pListRoot->Node); + + pTransfer->cRoots++; + } + + /* No (valid) root directory found? Bail out early. */ + if (!pszPathRootAbs) + rc = VERR_PATH_NOT_FOUND; + + if (RT_SUCCESS(rc)) + { + /* + * Step 2: + * Go through the created list and make sure all entries have the same root path. + */ + PSHCLLISTROOT pListRoot; + RTListForEach(&pTransfer->lstRoots, pListRoot, SHCLLISTROOT, Node) + { + if (!RTStrStartsWith(pListRoot->pszPathAbs, pszPathRootAbs)) + { + rc = VERR_INVALID_PARAMETER; + break; + } + + rc = shClTransferValidatePath(pListRoot->pszPathAbs, true /* Path must exist */); + if (RT_FAILURE(rc)) + break; + } + } + + /** @todo Entry rollback on failure? */ + + if (RT_SUCCESS(rc)) + { + pTransfer->pszPathRootAbs = pszPathRootAbs; + LogFlowFunc(("pszPathRootAbs=%s, cRoots=%zu\n", pTransfer->pszPathRootAbs, pTransfer->cRoots)); + + LogRel2(("Shared Clipboard: Transfer uses root '%s'\n", pTransfer->pszPathRootAbs)); + } + else + { + LogRel(("Shared Clipboard: Unable to set roots for transfer, rc=%Rrc\n", rc)); + RTStrFree(pszPathRootAbs); + } + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Returns the transfer's ID. + * + * @returns The transfer's ID. + * @param pTransfer Clipboard transfer to return ID for. + */ +SHCLTRANSFERID ShClTransferGetID(PSHCLTRANSFER pTransfer) +{ + AssertPtrReturn(pTransfer, 0); + + return pTransfer->State.uID; +} + +/** + * Returns the transfer's direction. + * + * @returns The transfer's direction. + * @param pTransfer Clipboard transfer to return direction for. + */ +SHCLTRANSFERDIR ShClTransferGetDir(PSHCLTRANSFER pTransfer) +{ + AssertPtrReturn(pTransfer, SHCLTRANSFERDIR_UNKNOWN); + + LogFlowFunc(("[Transfer %RU32] enmDir=%RU32\n", pTransfer->State.uID, pTransfer->State.enmDir)); + return pTransfer->State.enmDir; +} + +/** + * Returns the transfer's source. + * + * @returns The transfer's source. + * @param pTransfer Clipboard transfer to return source for. + */ +SHCLSOURCE ShClTransferGetSource(PSHCLTRANSFER pTransfer) +{ + AssertPtrReturn(pTransfer, SHCLSOURCE_INVALID); + + LogFlowFunc(("[Transfer %RU32] enmSource=%RU32\n", pTransfer->State.uID, pTransfer->State.enmSource)); + return pTransfer->State.enmSource; +} + +/** + * Returns the current transfer status. + * + * @returns Current transfer status. + * @param pTransfer Clipboard transfer to return status for. + */ +SHCLTRANSFERSTATUS ShClTransferGetStatus(PSHCLTRANSFER pTransfer) +{ + AssertPtrReturn(pTransfer, SHCLTRANSFERSTATUS_NONE); + + LogFlowFunc(("[Transfer %RU32] enmStatus=%RU32\n", pTransfer->State.uID, pTransfer->State.enmStatus)); + return pTransfer->State.enmStatus; +} + +/** + * Runs a started Shared Clipboard transfer in a dedicated thread. + * + * @returns VBox status code. + * @param pTransfer Clipboard transfer to run. + * @param pfnThreadFunc Pointer to thread function to use. + * @param pvUser Pointer to user-provided data. Optional. + */ +int ShClTransferRun(PSHCLTRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser) +{ + AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); + AssertPtrReturn(pfnThreadFunc, VERR_INVALID_POINTER); + /* pvUser is optional. */ + + AssertMsgReturn(pTransfer->State.enmStatus == SHCLTRANSFERSTATUS_STARTED, + ("Wrong status (currently is %s)\n", ShClTransferStatusToStr(pTransfer->State.enmStatus)), + VERR_WRONG_ORDER); + + int rc = shClTransferThreadCreate(pTransfer, pfnThreadFunc, pvUser); + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Starts an initialized transfer. + * + * @returns VBox status code. + * @param pTransfer Clipboard transfer to start. + */ +int ShClTransferStart(PSHCLTRANSFER pTransfer) +{ + AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); + + LogFlowFuncEnter(); + + /* Ready to start? */ + AssertMsgReturn(pTransfer->State.enmStatus == SHCLTRANSFERSTATUS_INITIALIZED, + ("Wrong status (currently is %s)\n", ShClTransferStatusToStr(pTransfer->State.enmStatus)), + VERR_WRONG_ORDER); + + int rc; + + if (pTransfer->Callbacks.pfnOnStart) + { + rc = pTransfer->Callbacks.pfnOnStart(&pTransfer->CallbackCtx); + } + else + rc = VINF_SUCCESS; + + if (RT_SUCCESS(rc)) + { + pTransfer->State.enmStatus = SHCLTRANSFERSTATUS_STARTED; + } + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Creates a thread for a Shared Clipboard transfer. + * + * @returns VBox status code. + * @param pTransfer Clipboard transfer to create thread for. + * @param pfnThreadFunc Thread function to use for this transfer. + * @param pvUser Pointer to user-provided data. + */ +static int shClTransferThreadCreate(PSHCLTRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser) + +{ + AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); + + /* Already marked for stopping? */ + AssertMsgReturn(pTransfer->Thread.fStop == false, + ("Transfer thread already marked for stopping"), VERR_WRONG_ORDER); + /* Already started? */ + AssertMsgReturn(pTransfer->Thread.fStarted == false, + ("Transfer thread already started"), VERR_WRONG_ORDER); + + /* Spawn a worker thread, so that we don't block the window thread for too long. */ + int rc = RTThreadCreate(&pTransfer->Thread.hThread, pfnThreadFunc, + pvUser, 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, + "shclp"); + if (RT_SUCCESS(rc)) + { + int rc2 = RTThreadUserWait(pTransfer->Thread.hThread, 30 * 1000 /* Timeout in ms */); + AssertRC(rc2); + + if (pTransfer->Thread.fStarted) /* Did the thread indicate that it started correctly? */ + { + /* Nothing to do in here. */ + } + else + rc = VERR_GENERAL_FAILURE; /** @todo Find a better rc. */ + } + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Destroys a thread of a Shared Clipboard transfer. + * + * @returns VBox status code. + * @param pTransfer Clipboard transfer to destroy thread for. + * @param uTimeoutMs Timeout (in ms) to wait for thread creation. + */ +static int shClTransferThreadDestroy(PSHCLTRANSFER pTransfer, RTMSINTERVAL uTimeoutMs) +{ + AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); + + if (pTransfer->Thread.hThread == NIL_RTTHREAD) + return VINF_SUCCESS; + + LogFlowFuncEnter(); + + /* Set stop indicator. */ + pTransfer->Thread.fStop = true; + + int rcThread = VERR_WRONG_ORDER; + int rc = RTThreadWait(pTransfer->Thread.hThread, uTimeoutMs, &rcThread); + + LogFlowFunc(("Waiting for thread resulted in %Rrc (thread exited with %Rrc)\n", rc, rcThread)); + + return rc; +} + +/** + * Initializes a Shared Clipboard transfer context. + * + * @returns VBox status code. + * @param pTransferCtx Transfer context to initialize. + */ +int ShClTransferCtxInit(PSHCLTRANSFERCTX pTransferCtx) +{ + AssertPtrReturn(pTransferCtx, VERR_INVALID_POINTER); + + LogFlowFunc(("pTransferCtx=%p\n", pTransferCtx)); + + int rc = RTCritSectInit(&pTransferCtx->CritSect); + if (RT_SUCCESS(rc)) + { + RTListInit(&pTransferCtx->List); + + pTransferCtx->cTransfers = 0; + pTransferCtx->cRunning = 0; + pTransferCtx->cMaxRunning = 64; /** @todo Make this configurable? */ + + RT_ZERO(pTransferCtx->bmTransferIds); + +#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS_HTTP + ShClTransferHttpServerInit(&pTransferCtx->HttpServer); +#endif + ShClTransferCtxReset(pTransferCtx); + } + + return VINF_SUCCESS; +} + +/** + * Destroys a Shared Clipboard transfer context struct. + * + * @param pTransferCtx Transfer context to destroy. + */ +void ShClTransferCtxDestroy(PSHCLTRANSFERCTX pTransferCtx) +{ + if (!pTransferCtx) + return; + + LogFlowFunc(("pTransferCtx=%p\n", pTransferCtx)); + + if (RTCritSectIsInitialized(&pTransferCtx->CritSect)) + RTCritSectDelete(&pTransferCtx->CritSect); + + PSHCLTRANSFER pTransfer, pTransferNext; + RTListForEachSafe(&pTransferCtx->List, pTransfer, pTransferNext, SHCLTRANSFER, Node) + { + ShClTransferDestroy(pTransfer); + + shclTransferCtxTransferRemoveAndUnregister(pTransferCtx, pTransfer); + + RTMemFree(pTransfer); + pTransfer = NULL; + } + + pTransferCtx->cRunning = 0; + pTransferCtx->cTransfers = 0; +} + +/** + * Resets a Shared Clipboard transfer. + * + * @param pTransferCtx Transfer context to reset. + */ +void ShClTransferCtxReset(PSHCLTRANSFERCTX pTransferCtx) +{ + AssertPtrReturnVoid(pTransferCtx); + + LogFlowFuncEnter(); + + PSHCLTRANSFER pTransfer; + RTListForEach(&pTransferCtx->List, pTransfer, SHCLTRANSFER, Node) + ShClTransferReset(pTransfer); + +#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS_HTTP + /** @todo Anything to do here? */ +#endif +} + +/** + * Returns a specific Shared Clipboard transfer, internal version. + * + * @returns Shared Clipboard transfer, or NULL if not found. + * @param pTransferCtx Transfer context to return transfer for. + * @param uID ID of the transfer to return. + */ +static PSHCLTRANSFER shClTransferCtxGetTransferByIdInternal(PSHCLTRANSFERCTX pTransferCtx, uint32_t uID) +{ + PSHCLTRANSFER pTransfer; + RTListForEach(&pTransferCtx->List, pTransfer, SHCLTRANSFER, Node) /** @todo Slow, but works for now. */ + { + if (pTransfer->State.uID == uID) + return pTransfer; + } + + return NULL; +} + +/** + * Returns a specific Shared Clipboard transfer by index, internal version. + * + * @returns Shared Clipboard transfer, or NULL if not found. + * @param pTransferCtx Transfer context to return transfer for. + * @param uIdx Index of the transfer to return. + */ +static PSHCLTRANSFER shClTransferCtxGetTransferByIndexInternal(PSHCLTRANSFERCTX pTransferCtx, uint32_t uIdx) +{ + uint32_t idx = 0; + + PSHCLTRANSFER pTransfer; + RTListForEach(&pTransferCtx->List, pTransfer, SHCLTRANSFER, Node) /** @todo Slow, but works for now. */ + { + if (uIdx == idx) + return pTransfer; + idx++; + } + + return NULL; +} + +/** + * Returns a Shared Clipboard transfer for a specific transfer ID. + * + * @returns Shared Clipboard transfer, or NULL if not found. + * @param pTransferCtx Transfer context to return transfer for. + * @param uID ID of the transfer to return. + */ +PSHCLTRANSFER ShClTransferCtxGetTransferById(PSHCLTRANSFERCTX pTransferCtx, uint32_t uID) +{ + return shClTransferCtxGetTransferByIdInternal(pTransferCtx, uID); +} + +/** + * Returns a Shared Clipboard transfer for a specific list index. + * + * @returns Shared Clipboard transfer, or NULL if not found. + * @param pTransferCtx Transfer context to return transfer for. + * @param uIdx List index of the transfer to return. + */ +PSHCLTRANSFER ShClTransferCtxGetTransferByIndex(PSHCLTRANSFERCTX pTransferCtx, uint32_t uIdx) +{ + return shClTransferCtxGetTransferByIndexInternal(pTransferCtx, uIdx); +} + +/** + * Returns the number of running Shared Clipboard transfers. + * + * @returns Number of running transfers. + * @param pTransferCtx Transfer context to return number for. + */ +uint32_t ShClTransferCtxGetRunningTransfers(PSHCLTRANSFERCTX pTransferCtx) +{ + AssertPtrReturn(pTransferCtx, 0); + return pTransferCtx->cRunning; +} + +/** + * Returns the number of total Shared Clipboard transfers. + * + * @returns Number of total transfers. + * @param pTransferCtx Transfer context to return number for. + */ +uint32_t ShClTransferCtxGetTotalTransfers(PSHCLTRANSFERCTX pTransferCtx) +{ + AssertPtrReturn(pTransferCtx, 0); + return pTransferCtx->cTransfers; +} + +/** + * Registers a Shared Clipboard transfer with a transfer context, i.e. allocates a transfer ID. + * + * @return VBox status code. + * @retval VERR_SHCLPB_MAX_TRANSFERS_REACHED if the maximum of concurrent transfers + * is reached. + * @param pTransferCtx Transfer context to register transfer to. + * @param pTransfer Transfer to register. + * @param pidTransfer Where to return the transfer ID on success. Optional. + */ +int ShClTransferCtxTransferRegister(PSHCLTRANSFERCTX pTransferCtx, PSHCLTRANSFER pTransfer, SHCLTRANSFERID *pidTransfer) +{ + AssertPtrReturn(pTransferCtx, VERR_INVALID_POINTER); + AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); + /* pidTransfer is optional. */ + + /* + * Pick a random bit as starting point. If it's in use, search forward + * for a free one, wrapping around. We've reserved both the zero'th and + * max-1 IDs. + */ + SHCLTRANSFERID idTransfer = RTRandU32Ex(1, VBOX_SHCL_MAX_TRANSFERS - 2); + + if (!ASMBitTestAndSet(&pTransferCtx->bmTransferIds[0], idTransfer)) + { /* likely */ } + else if (pTransferCtx->cTransfers < VBOX_SHCL_MAX_TRANSFERS - 2 /* First and last are not used */) + { + /* Forward search. */ + int iHit = ASMBitNextClear(&pTransferCtx->bmTransferIds[0], VBOX_SHCL_MAX_TRANSFERS, idTransfer); + if (iHit < 0) + iHit = ASMBitFirstClear(&pTransferCtx->bmTransferIds[0], VBOX_SHCL_MAX_TRANSFERS); + AssertLogRelMsgReturn(iHit >= 0, ("Transfer count: %RU16\n", pTransferCtx->cTransfers), VERR_SHCLPB_MAX_TRANSFERS_REACHED); + idTransfer = iHit; + AssertLogRelMsgReturn(!ASMBitTestAndSet(&pTransferCtx->bmTransferIds[0], idTransfer), ("idObject=%#x\n", idTransfer), VERR_INTERNAL_ERROR_2); + } + else + { + LogFunc(("Maximum number of transfers reached (%RU16 transfers)\n", pTransferCtx->cTransfers)); + return VERR_SHCLPB_MAX_TRANSFERS_REACHED; + } + + Log2Func(("pTransfer=%p, idTransfer=%RU32 (%RU16 transfers)\n", pTransfer, idTransfer, pTransferCtx->cTransfers)); + + pTransfer->State.uID = idTransfer; + + RTListAppend(&pTransferCtx->List, &pTransfer->Node); + + pTransferCtx->cTransfers++; + + if (pTransfer->Callbacks.pfnOnRegistered) + pTransfer->Callbacks.pfnOnRegistered(&pTransfer->CallbackCtx, pTransferCtx); + + if (pidTransfer) + *pidTransfer = idTransfer; + + LogFlowFuncLeaveRC(VINF_SUCCESS); + return VINF_SUCCESS; +} + +/** + * Registers a Shared Clipboard transfer with a transfer context by specifying an ID for the transfer. + * + * @return VBox status code. + * @retval VERR_ALREADY_EXISTS if a transfer with the given ID already exists. + * @retval VERR_SHCLPB_MAX_TRANSFERS_REACHED if the maximum of concurrent transfers for this context has been reached. + * @param pTransferCtx Transfer context to register transfer to. + * @param pTransfer Transfer to register. + * @param idTransfer Transfer ID to use for registration. + */ +int ShClTransferCtxTransferRegisterById(PSHCLTRANSFERCTX pTransferCtx, PSHCLTRANSFER pTransfer, SHCLTRANSFERID idTransfer) +{ + LogFlowFunc(("cTransfers=%RU16, idTransfer=%RU32\n", pTransferCtx->cTransfers, idTransfer)); + + if (pTransferCtx->cTransfers < VBOX_SHCL_MAX_TRANSFERS - 2 /* First and last are not used */) + { + if (!ASMBitTestAndSet(&pTransferCtx->bmTransferIds[0], idTransfer)) + { + RTListAppend(&pTransferCtx->List, &pTransfer->Node); + + pTransfer->State.uID = idTransfer; + + if (pTransfer->Callbacks.pfnOnRegistered) + pTransfer->Callbacks.pfnOnRegistered(&pTransfer->CallbackCtx, pTransferCtx); + + pTransferCtx->cTransfers++; + return VINF_SUCCESS; + } + + return VERR_ALREADY_EXISTS; + } + + LogFunc(("Maximum number of transfers reached (%RU16 transfers)\n", pTransferCtx->cTransfers)); + return VERR_SHCLPB_MAX_TRANSFERS_REACHED; +} + +/** + * Removes and unregisters a transfer from a transfer context. + * + * @param pTransferCtx Transfer context to remove transfer from. + * @param pTransfer Transfer to remove. + */ +static void shclTransferCtxTransferRemoveAndUnregister(PSHCLTRANSFERCTX pTransferCtx, PSHCLTRANSFER pTransfer) +{ + RTListNodeRemove(&pTransfer->Node); + + Assert(pTransferCtx->cTransfers); + pTransferCtx->cTransfers--; + + Assert(pTransferCtx->cTransfers >= pTransferCtx->cRunning); + + if (pTransfer->Callbacks.pfnOnUnregistered) + pTransfer->Callbacks.pfnOnUnregistered(&pTransfer->CallbackCtx, pTransferCtx); + + LogFlowFunc(("Now %RU32 transfers left\n", pTransferCtx->cTransfers)); +} + +/** + * Unregisters a transfer from an Transfer context. + * + * @retval VINF_SUCCESS on success. + * @retval VERR_NOT_FOUND if the transfer ID was not found. + * @param pTransferCtx Transfer context to unregister transfer from. + * @param idTransfer Transfer ID to unregister. + */ +int ShClTransferCtxTransferUnregister(PSHCLTRANSFERCTX pTransferCtx, SHCLTRANSFERID idTransfer) +{ + int rc = VINF_SUCCESS; + AssertMsgStmt(ASMBitTestAndClear(&pTransferCtx->bmTransferIds, idTransfer), ("idTransfer=%#x\n", idTransfer), rc = VERR_NOT_FOUND); + + LogFlowFunc(("idTransfer=%RU32\n", idTransfer)); + + PSHCLTRANSFER pTransfer = shClTransferCtxGetTransferByIdInternal(pTransferCtx, idTransfer); + if (pTransfer) + { + shclTransferCtxTransferRemoveAndUnregister(pTransferCtx, pTransfer); + } + else + rc = VERR_NOT_FOUND; + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Cleans up all associated transfers which are not needed (anymore). + * This can be due to transfers which only have been announced but not / never being run. + * + * @param pTransferCtx Transfer context to cleanup transfers for. + */ +void ShClTransferCtxCleanup(PSHCLTRANSFERCTX pTransferCtx) +{ + AssertPtrReturnVoid(pTransferCtx); + + LogFlowFunc(("pTransferCtx=%p, cTransfers=%RU16 cRunning=%RU16\n", + pTransferCtx, pTransferCtx->cTransfers, pTransferCtx->cRunning)); + + if (pTransferCtx->cTransfers == 0) + return; + + /* Remove all transfers which are not in a running state (e.g. only announced). */ + PSHCLTRANSFER pTransfer, pTransferNext; + RTListForEachSafe(&pTransferCtx->List, pTransfer, pTransferNext, SHCLTRANSFER, Node) + { + if (ShClTransferGetStatus(pTransfer) != SHCLTRANSFERSTATUS_STARTED) + { + shclTransferCtxTransferRemoveAndUnregister(pTransferCtx, pTransfer); + + ShClTransferDestroy(pTransfer); + + RTMemFree(pTransfer); + pTransfer = NULL; + } + } +} + +/** + * Returns whether the maximum of concurrent transfers of a specific transfer contexthas been reached or not. + * + * @returns \c if maximum has been reached, \c false if not. + * @param pTransferCtx Transfer context to determine value for. + */ +bool ShClTransferCtxTransfersMaximumReached(PSHCLTRANSFERCTX pTransferCtx) +{ + AssertPtrReturn(pTransferCtx, true); + + LogFlowFunc(("cRunning=%RU32, cMaxRunning=%RU32\n", pTransferCtx->cRunning, pTransferCtx->cMaxRunning)); + + Assert(pTransferCtx->cRunning <= pTransferCtx->cMaxRunning); + return pTransferCtx->cRunning == pTransferCtx->cMaxRunning; +} + +/** + * Copies file system objinfo from IPRT to Shared Clipboard format. + * + * @param pDst The Shared Clipboard structure to convert data to. + * @param pSrc The IPRT structure to convert data from. + */ +void ShClFsObjFromIPRT(PSHCLFSOBJINFO pDst, PCRTFSOBJINFO pSrc) +{ + pDst->cbObject = pSrc->cbObject; + pDst->cbAllocated = pSrc->cbAllocated; + pDst->AccessTime = pSrc->AccessTime; + pDst->ModificationTime = pSrc->ModificationTime; + pDst->ChangeTime = pSrc->ChangeTime; + pDst->BirthTime = pSrc->BirthTime; + pDst->Attr.fMode = pSrc->Attr.fMode; + /* Clear bits which we don't pass through for security reasons. */ + pDst->Attr.fMode &= ~(RTFS_UNIX_ISUID | RTFS_UNIX_ISGID | RTFS_UNIX_ISTXT); + RT_ZERO(pDst->Attr.u); + switch (pSrc->Attr.enmAdditional) + { + default: + case RTFSOBJATTRADD_NOTHING: + pDst->Attr.enmAdditional = SHCLFSOBJATTRADD_NOTHING; + break; + + case RTFSOBJATTRADD_UNIX: + pDst->Attr.enmAdditional = SHCLFSOBJATTRADD_UNIX; + pDst->Attr.u.Unix.uid = pSrc->Attr.u.Unix.uid; + pDst->Attr.u.Unix.gid = pSrc->Attr.u.Unix.gid; + pDst->Attr.u.Unix.cHardlinks = pSrc->Attr.u.Unix.cHardlinks; + pDst->Attr.u.Unix.INodeIdDevice = pSrc->Attr.u.Unix.INodeIdDevice; + pDst->Attr.u.Unix.INodeId = pSrc->Attr.u.Unix.INodeId; + pDst->Attr.u.Unix.fFlags = pSrc->Attr.u.Unix.fFlags; + pDst->Attr.u.Unix.GenerationId = pSrc->Attr.u.Unix.GenerationId; + pDst->Attr.u.Unix.Device = pSrc->Attr.u.Unix.Device; + break; + + case RTFSOBJATTRADD_EASIZE: + pDst->Attr.enmAdditional = SHCLFSOBJATTRADD_EASIZE; + pDst->Attr.u.EASize.cb = pSrc->Attr.u.EASize.cb; + break; + } +} + +/** + * Converts Shared Clipboard create flags (see SharedClipboard-transfers.h) into IPRT create flags. + * + * @returns IPRT status code. + * @param fShClFlags Shared clipboard create flags. + * @param[out] pfOpen Where to store the RTFILE_O_XXX flags for + * RTFileOpen. + * + * @sa Initially taken from vbsfConvertFileOpenFlags(). + */ +static int shClConvertFileCreateFlags(uint32_t fShClFlags, uint64_t *pfOpen) +{ + AssertMsgReturnStmt(!(fShClFlags & ~SHCL_OBJ_CF_VALID_MASK), ("%#x4\n", fShClFlags), *pfOpen = 0, VERR_INVALID_FLAGS); + + uint64_t fOpen = 0; + + switch (fShClFlags & SHCL_OBJ_CF_ACCESS_MASK_RW) + { + case SHCL_OBJ_CF_ACCESS_NONE: + { +#ifdef RT_OS_WINDOWS + if ((fShClFlags & SHCL_OBJ_CF_ACCESS_MASK_ATTR) != SHCL_OBJ_CF_ACCESS_ATTR_NONE) + fOpen |= RTFILE_O_OPEN | RTFILE_O_ATTR_ONLY; + else +#endif + fOpen |= RTFILE_O_OPEN | RTFILE_O_READ; + LogFlowFunc(("SHCL_OBJ_CF_ACCESS_NONE\n")); + break; + } + + case SHCL_OBJ_CF_ACCESS_READ: + { + fOpen |= RTFILE_O_OPEN | RTFILE_O_READ; + LogFlowFunc(("SHCL_OBJ_CF_ACCESS_READ\n")); + break; + } + + default: + AssertFailedReturn(VERR_IPE_NOT_REACHED_DEFAULT_CASE); + } + + switch (fShClFlags & SHCL_OBJ_CF_ACCESS_MASK_ATTR) + { + case SHCL_OBJ_CF_ACCESS_ATTR_NONE: + { + fOpen |= RTFILE_O_ACCESS_ATTR_DEFAULT; + LogFlowFunc(("SHCL_OBJ_CF_ACCESS_ATTR_NONE\n")); + break; + } + + case SHCL_OBJ_CF_ACCESS_ATTR_READ: + { + fOpen |= RTFILE_O_ACCESS_ATTR_READ; + LogFlowFunc(("SHCL_OBJ_CF_ACCESS_ATTR_READ\n")); + break; + } + + default: + AssertFailedReturn(VERR_IPE_NOT_REACHED_DEFAULT_CASE); + } + + /* Sharing mask */ + switch (fShClFlags & SHCL_OBJ_CF_ACCESS_MASK_DENY) + { + case SHCL_OBJ_CF_ACCESS_DENYNONE: + fOpen |= RTFILE_O_DENY_NONE; + LogFlowFunc(("SHCL_OBJ_CF_ACCESS_DENYNONE\n")); + break; + + case SHCL_OBJ_CF_ACCESS_DENYWRITE: + fOpen |= RTFILE_O_DENY_WRITE; + LogFlowFunc(("SHCL_OBJ_CF_ACCESS_DENYWRITE\n")); + break; + + default: + AssertFailedReturn(VERR_IPE_NOT_REACHED_DEFAULT_CASE); + } + + *pfOpen = fOpen; + + LogFlowFuncLeaveRC(VINF_SUCCESS); + return VINF_SUCCESS; +} + +/** + * Translates a Shared Clipboard transfer status (SHCLTRANSFERSTATUS_XXX) into a string. + * + * @returns Transfer status string name. + * @param enmStatus The transfer status to translate. + */ +const char *ShClTransferStatusToStr(SHCLTRANSFERSTATUS enmStatus) +{ + switch (enmStatus) + { + RT_CASE_RET_STR(SHCLTRANSFERSTATUS_NONE); + RT_CASE_RET_STR(SHCLTRANSFERSTATUS_INITIALIZED); + RT_CASE_RET_STR(SHCLTRANSFERSTATUS_STARTED); + RT_CASE_RET_STR(SHCLTRANSFERSTATUS_STOPPED); + RT_CASE_RET_STR(SHCLTRANSFERSTATUS_CANCELED); + RT_CASE_RET_STR(SHCLTRANSFERSTATUS_KILLED); + RT_CASE_RET_STR(SHCLTRANSFERSTATUS_ERROR); + } + return "Unknown"; +} diff --git a/src/VBox/GuestHost/SharedClipboard/clipboard-win.cpp b/src/VBox/GuestHost/SharedClipboard/clipboard-win.cpp new file mode 100644 index 00000000..cc94eb28 --- /dev/null +++ b/src/VBox/GuestHost/SharedClipboard/clipboard-win.cpp @@ -0,0 +1,1322 @@ +/* $Id: clipboard-win.cpp $ */ +/** @file + * Shared Clipboard: Windows-specific functions for clipboard handling. + */ + +/* + * Copyright (C) 2006-2022 Oracle and/or its affiliates. + * + * This file is part of VirtualBox base platform packages, as + * available from https://www.virtualbox.org. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, in version 3 of the + * License. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <https://www.gnu.org/licenses>. + * + * SPDX-License-Identifier: GPL-3.0-only + */ + +#define LOG_GROUP LOG_GROUP_SHARED_CLIPBOARD +#include <VBox/GuestHost/SharedClipboard.h> + +#include <iprt/assert.h> +#include <iprt/errcore.h> +#include <iprt/ldr.h> +#include <iprt/mem.h> +#include <iprt/thread.h> +#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS +# include <iprt/win/windows.h> +# include <iprt/win/shlobj.h> /* For CFSTR_FILEDESCRIPTORXXX + CFSTR_FILECONTENTS. */ +# include <iprt/utf16.h> +#endif + +#include <VBox/log.h> + +#include <VBox/HostServices/VBoxClipboardSvc.h> +#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS +# include <VBox/GuestHost/SharedClipboard-transfers.h> +#endif +#include <VBox/GuestHost/SharedClipboard-win.h> +#include <VBox/GuestHost/clipboard-helper.h> + + +/** + * Opens the clipboard of a specific window. + * + * @returns VBox status code. + * @param hWnd Handle of window to open clipboard for. + */ +int SharedClipboardWinOpen(HWND hWnd) +{ + /* "OpenClipboard fails if another window has the clipboard open." + * So try a few times and wait up to 1 second. + */ + BOOL fOpened = FALSE; + + LogFlowFunc(("hWnd=%p\n", hWnd)); + + int i = 0; + for (;;) + { + if (OpenClipboard(hWnd)) + { + fOpened = TRUE; + break; + } + + if (i >= 10) /* sleep interval = [1..512] ms */ + break; + + RTThreadSleep(1 << i); + ++i; + } + +#ifdef LOG_ENABLED + if (i > 0) + LogFlowFunc(("%d times tried to open clipboard\n", i + 1)); +#endif + + int rc; + if (fOpened) + rc = VINF_SUCCESS; + else + { + const DWORD dwLastErr = GetLastError(); + rc = RTErrConvertFromWin32(dwLastErr); + LogRel(("Failed to open clipboard, rc=%Rrc (0x%x)\n", rc, dwLastErr)); + } + + return rc; +} + +/** + * Closes the clipboard for the current thread. + * + * @returns VBox status code. + */ +int SharedClipboardWinClose(void) +{ + int rc; + + const BOOL fRc = CloseClipboard(); + if (RT_UNLIKELY(!fRc)) + { + const DWORD dwLastErr = GetLastError(); + if (dwLastErr == ERROR_CLIPBOARD_NOT_OPEN) + { + rc = VINF_SUCCESS; /* Not important, so just report success instead. */ + } + else + { + rc = RTErrConvertFromWin32(dwLastErr); + LogFunc(("Failed with %Rrc (0x%x)\n", rc, dwLastErr)); + } + } + else + rc = VINF_SUCCESS; + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Clears the clipboard for the current thread. + * + * @returns VBox status code. + */ +int SharedClipboardWinClear(void) +{ + LogFlowFuncEnter(); + if (EmptyClipboard()) + return VINF_SUCCESS; + + const DWORD dwLastErr = GetLastError(); + AssertReturn(dwLastErr != ERROR_CLIPBOARD_NOT_OPEN, VERR_INVALID_STATE); + + int rc = RTErrConvertFromWin32(dwLastErr); + LogFunc(("Failed with %Rrc (0x%x)\n", rc, dwLastErr)); + return rc; +} + +/** + * Initializes a Shared Clipboard Windows context. + * + * @returns VBox status code. + * @param pWinCtx Shared Clipboard Windows context to initialize. + */ +int SharedClipboardWinCtxInit(PSHCLWINCTX pWinCtx) +{ + int rc = RTCritSectInit(&pWinCtx->CritSect); + if (RT_SUCCESS(rc)) + { + /* Check that new Clipboard API is available. */ + SharedClipboardWinCheckAndInitNewAPI(&pWinCtx->newAPI); + /* Do *not* check the rc, as the call might return VERR_SYMBOL_NOT_FOUND is the new API isn't available. */ + + pWinCtx->hWnd = NULL; + pWinCtx->hWndClipboardOwnerUs = NULL; + pWinCtx->hWndNextInChain = NULL; + } + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Destroys a Shared Clipboard Windows context. + * + * @param pWinCtx Shared Clipboard Windows context to destroy. + */ +void SharedClipboardWinCtxDestroy(PSHCLWINCTX pWinCtx) +{ + if (!pWinCtx) + return; + + LogFlowFuncEnter(); + + if (RTCritSectIsInitialized(&pWinCtx->CritSect)) + { + int rc2 = RTCritSectDelete(&pWinCtx->CritSect); + AssertRC(rc2); + } +} + +/** + * Checks and initializes function pointer which are required for using + * the new clipboard API. + * + * @returns VBox status code, or VERR_SYMBOL_NOT_FOUND if the new API is not available. + * @param pAPI Where to store the retrieved function pointers. + * Will be set to NULL if the new API is not available. + */ +int SharedClipboardWinCheckAndInitNewAPI(PSHCLWINAPINEW pAPI) +{ + RTLDRMOD hUser32 = NIL_RTLDRMOD; + int rc = RTLdrLoadSystem("User32.dll", /* fNoUnload = */ true, &hUser32); + if (RT_SUCCESS(rc)) + { + rc = RTLdrGetSymbol(hUser32, "AddClipboardFormatListener", (void **)&pAPI->pfnAddClipboardFormatListener); + if (RT_SUCCESS(rc)) + { + rc = RTLdrGetSymbol(hUser32, "RemoveClipboardFormatListener", (void **)&pAPI->pfnRemoveClipboardFormatListener); + } + + RTLdrClose(hUser32); + } + + if (RT_SUCCESS(rc)) + { + LogRel(("Shared Clipboard: New Clipboard API enabled\n")); + } + else + { + RT_BZERO(pAPI, sizeof(SHCLWINAPINEW)); + LogRel(("Shared Clipboard: New Clipboard API not available (%Rrc)\n", rc)); + } + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Returns if the new clipboard API is available or not. + * + * @returns @c true if the new API is available, or @c false if not. + * @param pAPI Structure used for checking if the new clipboard API is available or not. + */ +bool SharedClipboardWinIsNewAPI(PSHCLWINAPINEW pAPI) +{ + if (!pAPI) + return false; + return pAPI->pfnAddClipboardFormatListener != NULL; +} + +/** + * Adds ourselves into the chain of cliboard listeners. + * + * @returns VBox status code. + * @param pCtx Windows clipboard context to use to add ourselves. + */ +int SharedClipboardWinChainAdd(PSHCLWINCTX pCtx) +{ + const PSHCLWINAPINEW pAPI = &pCtx->newAPI; + + BOOL fRc; + if (SharedClipboardWinIsNewAPI(pAPI)) + fRc = pAPI->pfnAddClipboardFormatListener(pCtx->hWnd); + else + { + SetLastError(NO_ERROR); + pCtx->hWndNextInChain = SetClipboardViewer(pCtx->hWnd); + fRc = pCtx->hWndNextInChain != NULL || GetLastError() == NO_ERROR; + } + + int rc = VINF_SUCCESS; + + if (!fRc) + { + const DWORD dwLastErr = GetLastError(); + rc = RTErrConvertFromWin32(dwLastErr); + LogFunc(("Failed with %Rrc (0x%x)\n", rc, dwLastErr)); + } + + return rc; +} + +/** + * Remove ourselves from the chain of cliboard listeners + * + * @returns VBox status code. + * @param pCtx Windows clipboard context to use to remove ourselves. + */ +int SharedClipboardWinChainRemove(PSHCLWINCTX pCtx) +{ + if (!pCtx->hWnd) + return VINF_SUCCESS; + + const PSHCLWINAPINEW pAPI = &pCtx->newAPI; + + BOOL fRc; + if (SharedClipboardWinIsNewAPI(pAPI)) + { + fRc = pAPI->pfnRemoveClipboardFormatListener(pCtx->hWnd); + } + else + { + fRc = ChangeClipboardChain(pCtx->hWnd, pCtx->hWndNextInChain); + if (fRc) + pCtx->hWndNextInChain = NULL; + } + + int rc = VINF_SUCCESS; + + if (!fRc) + { + const DWORD dwLastErr = GetLastError(); + rc = RTErrConvertFromWin32(dwLastErr); + LogFunc(("Failed with %Rrc (0x%x)\n", rc, dwLastErr)); + } + + return rc; +} + +/** + * Callback which is invoked when we have successfully pinged ourselves down the + * clipboard chain. We simply unset a boolean flag to say that we are responding. + * There is a race if a ping returns after the next one is initiated, but nothing + * very bad is likely to happen. + * + * @param hWnd Window handle to use for this callback. Not used currently. + * @param uMsg Message to handle. Not used currently. + * @param dwData Pointer to user-provided data. Contains our Windows clipboard context. + * @param lResult Additional data to pass. Not used currently. + */ +VOID CALLBACK SharedClipboardWinChainPingProc(HWND hWnd, UINT uMsg, ULONG_PTR dwData, LRESULT lResult) RT_NOTHROW_DEF +{ + RT_NOREF(hWnd); + RT_NOREF(uMsg); + RT_NOREF(lResult); + + /** @todo r=andy Why not using SetWindowLongPtr for keeping the context? */ + PSHCLWINCTX pCtx = (PSHCLWINCTX)dwData; + AssertPtrReturnVoid(pCtx); + + pCtx->oldAPI.fCBChainPingInProcess = FALSE; +} + +/** + * Passes a window message to the next window in the clipboard chain. + * + * @returns LRESULT + * @param pWinCtx Window context to use. + * @param msg Window message to pass. + * @param wParam WPARAM to pass. + * @param lParam LPARAM to pass. + */ +LRESULT SharedClipboardWinChainPassToNext(PSHCLWINCTX pWinCtx, + UINT msg, WPARAM wParam, LPARAM lParam) +{ + LogFlowFuncEnter(); + + LRESULT lresultRc = 0; + + if (pWinCtx->hWndNextInChain) + { + LogFunc(("hWndNextInChain=%p\n", pWinCtx->hWndNextInChain)); + + /* Pass the message to next window in the clipboard chain. */ + DWORD_PTR dwResult; + lresultRc = SendMessageTimeout(pWinCtx->hWndNextInChain, msg, wParam, lParam, 0, + SHCL_WIN_CBCHAIN_TIMEOUT_MS, &dwResult); + if (!lresultRc) + lresultRc = dwResult; + } + + LogFlowFunc(("lresultRc=%ld\n", lresultRc)); + return lresultRc; +} + +/** + * Converts a (registered or standard) Windows clipboard format to a VBox clipboard format. + * + * @returns Converted VBox clipboard format, or VBOX_SHCL_FMT_NONE if not found. + * @param uFormat Windows clipboard format to convert. + */ +SHCLFORMAT SharedClipboardWinClipboardFormatToVBox(UINT uFormat) +{ + /* Insert the requested clipboard format data into the clipboard. */ + SHCLFORMAT vboxFormat = VBOX_SHCL_FMT_NONE; + + switch (uFormat) + { + case CF_UNICODETEXT: + vboxFormat = VBOX_SHCL_FMT_UNICODETEXT; + break; + + case CF_DIB: + vboxFormat = VBOX_SHCL_FMT_BITMAP; + break; + +#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS + /* CF_HDROP handles file system entries which are locally present + * on source for transferring to the target. + * + * This does *not* invoke any IDataObject / IStream implementations! */ + case CF_HDROP: + vboxFormat = VBOX_SHCL_FMT_URI_LIST; + break; +#endif + + default: + if (uFormat >= 0xC000) /** Formats registered with RegisterClipboardFormat() start at this index. */ + { + TCHAR szFormatName[256]; /** @todo r=andy Do we need Unicode support here as well? */ + int cActual = GetClipboardFormatName(uFormat, szFormatName, sizeof(szFormatName) / sizeof(TCHAR)); + if (cActual) + { + LogFlowFunc(("uFormat=%u -> szFormatName=%s\n", uFormat, szFormatName)); + + if (RTStrCmp(szFormatName, SHCL_WIN_REGFMT_HTML) == 0) + vboxFormat = VBOX_SHCL_FMT_HTML; +#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS + /* These types invoke our IDataObject / IStream implementations. */ + else if ( (RTStrCmp(szFormatName, CFSTR_FILEDESCRIPTORA) == 0) + || (RTStrCmp(szFormatName, CFSTR_FILECONTENTS) == 0)) + vboxFormat = VBOX_SHCL_FMT_URI_LIST; + /** @todo Do we need to handle CFSTR_FILEDESCRIPTORW here as well? */ +#endif + } + } + break; + } + + LogFlowFunc(("uFormat=%u -> vboxFormat=0x%x\n", uFormat, vboxFormat)); + return vboxFormat; +} + +/** + * Retrieves all supported clipboard formats of a specific clipboard. + * + * @returns VBox status code. + * @param pCtx Windows clipboard context to retrieve formats for. + * @param pfFormats Where to store the retrieved formats. + */ +int SharedClipboardWinGetFormats(PSHCLWINCTX pCtx, PSHCLFORMATS pfFormats) +{ + AssertPtrReturn(pCtx, VERR_INVALID_POINTER); + AssertPtrReturn(pfFormats, VERR_INVALID_POINTER); + + SHCLFORMATS fFormats = VBOX_SHCL_FMT_NONE; + + /* Query list of available formats and report to host. */ + int rc = SharedClipboardWinOpen(pCtx->hWnd); + if (RT_SUCCESS(rc)) + { + UINT uCurFormat = 0; /* Must be set to zero for EnumClipboardFormats(). */ + while ((uCurFormat = EnumClipboardFormats(uCurFormat)) != 0) + fFormats |= SharedClipboardWinClipboardFormatToVBox(uCurFormat); + + int rc2 = SharedClipboardWinClose(); + AssertRC(rc2); + LogFlowFunc(("fFormats=%#x\n", fFormats)); + } + else + LogFunc(("Failed with rc=%Rrc (fFormats=%#x)\n", rc, fFormats)); + + *pfFormats = fFormats; + return rc; +} + +/** + * Extracts a field value from CF_HTML data. + * + * @returns VBox status code. + * @param pszSrc source in CF_HTML format. + * @param pszOption Name of CF_HTML field. + * @param puValue Where to return extracted value of CF_HTML field. + */ +int SharedClipboardWinGetCFHTMLHeaderValue(const char *pszSrc, const char *pszOption, uint32_t *puValue) +{ + AssertPtrReturn(pszSrc, VERR_INVALID_POINTER); + AssertPtrReturn(pszOption, VERR_INVALID_POINTER); + + int rc = VERR_INVALID_PARAMETER; + + const char *pszOptionValue = RTStrStr(pszSrc, pszOption); + if (pszOptionValue) + { + size_t cchOption = strlen(pszOption); + Assert(cchOption); + + rc = RTStrToUInt32Ex(pszOptionValue + cchOption, NULL, 10, puValue); + } + return rc; +} + +/** + * Check that the source string contains CF_HTML struct. + * + * @returns @c true if the @a pszSource string is in CF_HTML format. + * @param pszSource Source string to check. + */ +bool SharedClipboardWinIsCFHTML(const char *pszSource) +{ + return RTStrStr(pszSource, "Version:") != NULL + && RTStrStr(pszSource, "StartHTML:") != NULL; +} + +/** + * Converts clipboard data from CF_HTML format to MIME clipboard format. + * + * Returns allocated buffer that contains html converted to text/html mime type + * + * @returns VBox status code. + * @param pszSource The input. + * @param cch The length of the input. + * @param ppszOutput Where to return the result. Free using RTMemFree. + * @param pcbOutput Where to the return length of the result (bytes/chars). + */ +int SharedClipboardWinConvertCFHTMLToMIME(const char *pszSource, const uint32_t cch, char **ppszOutput, uint32_t *pcbOutput) +{ + Assert(pszSource); + Assert(cch); + Assert(ppszOutput); + Assert(pcbOutput); + + uint32_t offStart; + int rc = SharedClipboardWinGetCFHTMLHeaderValue(pszSource, "StartFragment:", &offStart); + if (RT_SUCCESS(rc)) + { + uint32_t offEnd; + rc = SharedClipboardWinGetCFHTMLHeaderValue(pszSource, "EndFragment:", &offEnd); + if (RT_SUCCESS(rc)) + { + if ( offStart > 0 + && offEnd > 0 + && offEnd >= offStart + && offEnd <= cch) + { + uint32_t cchSubStr = offEnd - offStart; + char *pszResult = (char *)RTMemAlloc(cchSubStr + 1); + if (pszResult) + { + rc = RTStrCopyEx(pszResult, cchSubStr + 1, pszSource + offStart, cchSubStr); + if (RT_SUCCESS(rc)) + { + *ppszOutput = pszResult; + *pcbOutput = (uint32_t)(cchSubStr + 1); + rc = VINF_SUCCESS; + } + else + { + LogRelFlowFunc(("Error: Unknown CF_HTML format. Expected EndFragment. rc = %Rrc\n", rc)); + RTMemFree(pszResult); + } + } + else + { + LogRelFlowFunc(("Error: Unknown CF_HTML format. Expected EndFragment\n")); + rc = VERR_NO_MEMORY; + } + } + else + { + LogRelFlowFunc(("Error: CF_HTML out of bounds - offStart=%#x offEnd=%#x cch=%#x\n", offStart, offEnd, cch)); + rc = VERR_INVALID_PARAMETER; + } + } + else + { + LogRelFlowFunc(("Error: Unknown CF_HTML format. Expected EndFragment. rc = %Rrc\n", rc)); + rc = VERR_INVALID_PARAMETER; + } + } + else + { + LogRelFlowFunc(("Error: Unknown CF_HTML format. Expected StartFragment. rc = %Rrc\n", rc)); + rc = VERR_INVALID_PARAMETER; + } + + return rc; +} + +/** + * Converts source UTF-8 MIME HTML clipboard data to UTF-8 CF_HTML format. + * + * This is just encapsulation work, slapping a header on the data. + * + * It allocates [..] + * + * Calculations: + * Header length = format Length + (2*(10 - 5('%010d'))('digits')) - 2('%s') = format length + 8 + * EndHtml = Header length + fragment length + * StartHtml = 105(constant) + * StartFragment = 141(constant) may vary if the header html content will be extended + * EndFragment = Header length + fragment length - 38(ending length) + * + * For more format details, check out: + * https://docs.microsoft.com/en-us/previous-versions/windows/internet-explorer/ie-developer/platform-apis/aa767917(v=vs.85) + * + * @returns VBox status code. + * @param pszSource Source buffer that contains utf-16 string in mime html format + * @param cb Size of source buffer in bytes + * @param ppszOutput Where to return the allocated output buffer to put converted UTF-8 + * CF_HTML clipboard data. This function allocates memory for this. + * @param pcbOutput Where to return the size of allocated result buffer in bytes/chars, including zero terminator + * + * @note output buffer should be free using RTMemFree() + * @note Everything inside of fragment can be UTF8. Windows allows it. Everything in header should be Latin1. + */ +int SharedClipboardWinConvertMIMEToCFHTML(const char *pszSource, size_t cb, char **ppszOutput, uint32_t *pcbOutput) +{ + Assert(ppszOutput); + Assert(pcbOutput); + Assert(pszSource); + Assert(cb); + + /* + * Check that input UTF-8 and properly zero terminated. + * Note! The zero termination may come earlier than 'cb' - 1, that's fine. + */ + int rc = RTStrValidateEncodingEx(pszSource, cb, RTSTR_VALIDATE_ENCODING_ZERO_TERMINATED); + if (RT_SUCCESS(rc)) + { /* likely */ } + else + { + LogRelFlowFunc(("Error: invalid source fragment. rc = %Rrc\n", rc)); + return rc; + } + size_t const cchFragment = strlen(pszSource); /* Unfortunately the validator doesn't return the length. */ + + /* + * @StartHtml - Absolute offset of <html> + * @EndHtml - Size of the whole resulting text (excluding ending zero char) + * @StartFragment - Absolute position after <!--StartFragment--> + * @EndFragment - Absolute position of <!--EndFragment--> + * + * Note! The offset are zero padded to max width so we don't have any variations due to those. + * Note! All values includes CRLFs inserted into text. + * + * Calculations: + * Header length = Format sample length - 2 ('%s') + * EndHtml = Header length + fragment length + * StartHtml = 101(constant) + * StartFragment = 137(constant) + * EndFragment = Header length + fragment length - 38 (ending length) + */ + static const char s_szFormatSample[] = + /* 0: */ "Version:1.0\r\n" + /* 13: */ "StartHTML:000000101\r\n" + /* 34: */ "EndHTML:%0000009u\r\n" // END HTML = Header length + fragment length + /* 53: */ "StartFragment:000000137\r\n" + /* 78: */ "EndFragment:%0000009u\r\n" + /* 101: */ "<html>\r\n" + /* 109: */ "<body>\r\n" + /* 117: */ "<!--StartFragment-->" + /* 137: */ "%s" + /* 137+2: */ "<!--EndFragment-->\r\n" + /* 157+2: */ "</body>\r\n" + /* 166+2: */ "</html>\r\n" + /* 175+2: */ ; + AssertCompile(sizeof(s_szFormatSample) == 175 + 2 + 1); + + /* Calculate parameters of the CF_HTML header */ + size_t const cchHeader = sizeof(s_szFormatSample) - 2 /*%s*/ - 1 /*'\0'*/; + size_t const offEndHtml = cchHeader + cchFragment; + size_t const offEndFragment = cchHeader + cchFragment - 38; /* 175-137 = 38 */ + char *pszResult = (char *)RTMemAlloc(offEndHtml + 1); + AssertLogRelReturn(pszResult, VERR_NO_MEMORY); + + /* Format resulting CF_HTML string: */ + size_t cchFormatted = RTStrPrintf(pszResult, offEndHtml + 1, s_szFormatSample, offEndHtml, offEndFragment, pszSource); + Assert(offEndHtml == cchFormatted); + +#ifdef VBOX_STRICT + /* + * Check the calculations. + */ + + /* check 'StartFragment:' value */ + static const char s_szStartFragment[] = "<!--StartFragment-->"; + const char *pszRealStartFragment = RTStrStr(pszResult, s_szStartFragment); + Assert(&pszRealStartFragment[sizeof(s_szStartFragment) - 1] - pszResult == 137); + + /* check 'EndFragment:' value */ + static const char s_szEndFragment[] = "<!--EndFragment-->"; + const char *pszRealEndFragment = RTStrStr(pszResult, s_szEndFragment); + Assert((size_t)(pszRealEndFragment - pszResult) == offEndFragment); +#endif + + *ppszOutput = pszResult; + *pcbOutput = (uint32_t)cchFormatted + 1; + Assert(*pcbOutput == cchFormatted + 1); + + return VINF_SUCCESS; +} + +/** + * Handles the WM_CHANGECBCHAIN code. + * + * @returns LRESULT + * @param pWinCtx Windows context to use. + * @param hWnd Window handle to use. + * @param msg Message ID to pass on. + * @param wParam wParam to pass on + * @param lParam lParam to pass on. + */ +LRESULT SharedClipboardWinHandleWMChangeCBChain(PSHCLWINCTX pWinCtx, + HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) +{ + LRESULT lresultRc = 0; + + LogFlowFuncEnter(); + + if (SharedClipboardWinIsNewAPI(&pWinCtx->newAPI)) + { + lresultRc = DefWindowProc(hWnd, msg, wParam, lParam); + } + else /* Old API */ + { + HWND hwndRemoved = (HWND)wParam; + HWND hwndNext = (HWND)lParam; + + if (hwndRemoved == pWinCtx->hWndNextInChain) + { + /* The window that was next to our in the chain is being removed. + * Relink to the new next window. + */ + pWinCtx->hWndNextInChain = hwndNext; + } + else + { + if (pWinCtx->hWndNextInChain) + { + /* Pass the message further. */ + DWORD_PTR dwResult; + lresultRc = SendMessageTimeout(pWinCtx->hWndNextInChain, WM_CHANGECBCHAIN, wParam, lParam, 0, + SHCL_WIN_CBCHAIN_TIMEOUT_MS, + &dwResult); + if (!lresultRc) + lresultRc = (LRESULT)dwResult; + } + } + } + + LogFlowFunc(("lresultRc=%ld\n", lresultRc)); + return lresultRc; +} + +/** + * Handles the WM_DESTROY code. + * + * @returns VBox status code. + * @param pWinCtx Windows context to use. + */ +int SharedClipboardWinHandleWMDestroy(PSHCLWINCTX pWinCtx) +{ + LogFlowFuncEnter(); + + int rc = VINF_SUCCESS; + + /* MS recommends to remove from Clipboard chain in this callback. */ + SharedClipboardWinChainRemove(pWinCtx); + + if (pWinCtx->oldAPI.timerRefresh) + { + Assert(pWinCtx->hWnd); + KillTimer(pWinCtx->hWnd, 0); + } + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Handles the WM_RENDERALLFORMATS message. + * + * @returns VBox status code. + * @param pWinCtx Windows context to use. + * @param hWnd Window handle to use. + */ +int SharedClipboardWinHandleWMRenderAllFormats(PSHCLWINCTX pWinCtx, HWND hWnd) +{ + RT_NOREF(pWinCtx); + + LogFlowFuncEnter(); + + /* Do nothing. The clipboard formats will be unavailable now, because the + * windows is to be destroyed and therefore the guest side becomes inactive. + */ + int rc = SharedClipboardWinOpen(hWnd); + if (RT_SUCCESS(rc)) + { + SharedClipboardWinClear(); + SharedClipboardWinClose(); + } + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Handles the WM_TIMER code, which is needed if we're running with the so-called "old" Windows clipboard API. + * Does nothing if we're running with the "new" Windows API. + * + * @returns VBox status code. + * @param pWinCtx Windows context to use. + */ +int SharedClipboardWinHandleWMTimer(PSHCLWINCTX pWinCtx) +{ + int rc = VINF_SUCCESS; + + if (!SharedClipboardWinIsNewAPI(&pWinCtx->newAPI)) /* Only run when using the "old" Windows API. */ + { + LogFlowFuncEnter(); + + HWND hViewer = GetClipboardViewer(); + + /* Re-register ourselves in the clipboard chain if our last ping + * timed out or there seems to be no valid chain. */ + if (!hViewer || pWinCtx->oldAPI.fCBChainPingInProcess) + { + SharedClipboardWinChainRemove(pWinCtx); + SharedClipboardWinChainAdd(pWinCtx); + } + + /* Start a new ping by passing a dummy WM_CHANGECBCHAIN to be + * processed by ourselves to the chain. */ + pWinCtx->oldAPI.fCBChainPingInProcess = TRUE; + + hViewer = GetClipboardViewer(); + if (hViewer) + SendMessageCallback(hViewer, WM_CHANGECBCHAIN, (WPARAM)pWinCtx->hWndNextInChain, (LPARAM)pWinCtx->hWndNextInChain, + SharedClipboardWinChainPingProc, (ULONG_PTR)pWinCtx); + } + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Announces a clipboard format to the Windows clipboard. + * + * The actual rendering (setting) of the clipboard data will be done later with + * a separate WM_RENDERFORMAT message. + * + * @returns VBox status code. VERR_NOT_SUPPORTED if the format is not supported / handled. + * @param pWinCtx Windows context to use. + * @param fFormats Clipboard format(s) to announce. + */ +static int sharedClipboardWinAnnounceFormats(PSHCLWINCTX pWinCtx, SHCLFORMATS fFormats) +{ + LogFunc(("fFormats=0x%x\n", fFormats)); + + /* + * Set the clipboard formats. + */ + static struct + { + uint32_t fVBoxFormat; + UINT uWinFormat; + const char *pszWinFormat; + const char *pszLog; + } s_aFormats[] = + { + { VBOX_SHCL_FMT_UNICODETEXT, CF_UNICODETEXT, NULL, "CF_UNICODETEXT" }, + { VBOX_SHCL_FMT_BITMAP, CF_DIB, NULL, "CF_DIB" }, + { VBOX_SHCL_FMT_HTML, 0, SHCL_WIN_REGFMT_HTML, "SHCL_WIN_REGFMT_HTML" }, + }; + unsigned cSuccessfullySet = 0; + SHCLFORMATS fFormatsLeft = fFormats; + int rc = VINF_SUCCESS; + for (uintptr_t i = 0; i < RT_ELEMENTS(s_aFormats) && fFormatsLeft != 0; i++) + { + if (fFormatsLeft & s_aFormats[i].fVBoxFormat) + { + LogFunc(("%s\n", s_aFormats[i].pszLog)); + fFormatsLeft &= ~s_aFormats[i].fVBoxFormat; + + /* Reg format if needed: */ + UINT uWinFormat = s_aFormats[i].uWinFormat; + if (!uWinFormat) + { + uWinFormat = RegisterClipboardFormat(s_aFormats[i].pszWinFormat); + AssertContinue(uWinFormat != 0); + } + + /* Tell the clipboard we've got data upon a request. We check the + last error here as hClip will be NULL even on success (despite + what MSDN says). */ + SetLastError(NO_ERROR); + HANDLE hClip = SetClipboardData(uWinFormat, NULL); + DWORD dwErr = GetLastError(); + if (dwErr == NO_ERROR || hClip != NULL) + cSuccessfullySet++; + else + { + AssertMsgFailed(("%s/%u: %u\n", s_aFormats[i].pszLog, uWinFormat, dwErr)); + rc = RTErrConvertFromWin32(dwErr); + } + } + } + + /* + * Consider setting anything a success, converting any error into + * informational status. Unsupport error only happens if all formats + * were unsupported. + */ + if (cSuccessfullySet > 0) + { + pWinCtx->hWndClipboardOwnerUs = GetClipboardOwner(); + if (RT_FAILURE(rc)) + rc = -rc; + } + else if (RT_SUCCESS(rc) && fFormatsLeft != 0) + { + LogFunc(("Unsupported formats: %#x (%#x)\n", fFormatsLeft, fFormats)); + rc = VERR_NOT_SUPPORTED; + } + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Opens the clipboard, clears it, announces @a fFormats and closes it. + * + * The actual rendering (setting) of the clipboard data will be done later with + * a separate WM_RENDERFORMAT message. + * + * @returns VBox status code. VERR_NOT_SUPPORTED if the format is not supported / handled. + * @param pWinCtx Windows context to use. + * @param fFormats Clipboard format(s) to announce. + * @param hWnd The window handle to use as owner. + */ +int SharedClipboardWinClearAndAnnounceFormats(PSHCLWINCTX pWinCtx, SHCLFORMATS fFormats, HWND hWnd) +{ + int rc = SharedClipboardWinOpen(hWnd); + if (RT_SUCCESS(rc)) + { + SharedClipboardWinClear(); + + rc = sharedClipboardWinAnnounceFormats(pWinCtx, fFormats); + Assert(pWinCtx->hWndClipboardOwnerUs == hWnd || pWinCtx->hWndClipboardOwnerUs == NULL); + + SharedClipboardWinClose(); + } + return rc; +} + +/** + * Writes (places) clipboard data into the Windows clipboard. + * + * @returns VBox status code. + * @param cfFormat Windows clipboard format to write data for. + * @param pvData Pointer to actual clipboard data to write. + * @param cbData Size (in bytes) of actual clipboard data to write. + * + * @note ASSUMES that the clipboard has already been opened. + */ +int SharedClipboardWinDataWrite(UINT cfFormat, void *pvData, uint32_t cbData) +{ + AssertPtrReturn(pvData, VERR_INVALID_POINTER); + AssertReturn (cbData, VERR_INVALID_PARAMETER); + + int rc = VINF_SUCCESS; + + HANDLE hMem = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, cbData); + + LogFlowFunc(("hMem=%p\n", hMem)); + + if (hMem) + { + void *pMem = GlobalLock(hMem); + + LogFlowFunc(("pMem=%p, GlobalSize=%zu\n", pMem, GlobalSize(hMem))); + + if (pMem) + { + LogFlowFunc(("Setting data\n")); + + memcpy(pMem, pvData, cbData); + + /* The memory must be unlocked before inserting to the Clipboard. */ + GlobalUnlock(hMem); + + /* 'hMem' contains the host clipboard data. + * size is 'cb' and format is 'format'. + */ + HANDLE hClip = SetClipboardData(cfFormat, hMem); + + LogFlowFunc(("hClip=%p\n", hClip)); + + if (hClip) + { + /* The hMem ownership has gone to the system. Nothing to do. */ + } + else + rc = RTErrConvertFromWin32(GetLastError()); + } + else + rc = VERR_ACCESS_DENIED; + + GlobalFree(hMem); + } + else + rc = RTErrConvertFromWin32(GetLastError()); + + if (RT_FAILURE(rc)) + LogFunc(("Setting clipboard data failed with %Rrc\n", rc)); + + LogFlowFuncLeaveRC(rc); + return rc; +} + +#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS + +/** + * Creates an Shared Clipboard transfer by announcing transfer data (via IDataObject) to Windows. + * + * This creates the necessary IDataObject + IStream implementations and initiates the actual transfers required for getting + * the meta data. Whether or not the actual (file++) transfer(s) are happening is up to the user (at some point) later then. + * + * @returns VBox status code. + * @param pWinCtx Windows context to use. + * @param pTransferCtxCtx Transfer contextto use. + * @param pTransfer Shared Clipboard transfer to use. + */ +int SharedClipboardWinTransferCreate(PSHCLWINCTX pWinCtx, PSHCLTRANSFER pTransfer) +{ + AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); + + LogFlowFunc(("pWinCtx=%p\n", pWinCtx)); + + AssertReturn(pTransfer->pvUser == NULL, VERR_WRONG_ORDER); + + /* Make sure to enter the critical section before setting the clipboard data, as otherwise WM_CLIPBOARDUPDATE + * might get called *before* we had the opportunity to set pWinCtx->hWndClipboardOwnerUs below. */ + int rc = RTCritSectEnter(&pWinCtx->CritSect); + if (RT_SUCCESS(rc)) + { + SharedClipboardWinTransferCtx *pWinURITransferCtx = new SharedClipboardWinTransferCtx(); + if (pWinURITransferCtx) + { + pTransfer->pvUser = pWinURITransferCtx; + pTransfer->cbUser = sizeof(SharedClipboardWinTransferCtx); + + pWinURITransferCtx->pDataObj = new SharedClipboardWinDataObject(pTransfer); + if (pWinURITransferCtx->pDataObj) + { + rc = pWinURITransferCtx->pDataObj->Init(); + if (RT_SUCCESS(rc)) + { + SharedClipboardWinClose(); + /* Note: Clipboard must be closed first before calling OleSetClipboard(). */ + + /** @todo There is a potential race between SharedClipboardWinClose() and OleSetClipboard(), + * where another application could own the clipboard (open), and thus the call to + * OleSetClipboard() will fail. Needs (better) fixing. */ + HRESULT hr = S_OK; + + for (unsigned uTries = 0; uTries < 3; uTries++) + { + hr = OleSetClipboard(pWinURITransferCtx->pDataObj); + if (SUCCEEDED(hr)) + { + Assert(OleIsCurrentClipboard(pWinURITransferCtx->pDataObj) == S_OK); /* Sanity. */ + + /* + * Calling OleSetClipboard() changed the clipboard owner, which in turn will let us receive + * a WM_CLIPBOARDUPDATE message. To not confuse ourselves with our own clipboard owner changes, + * save a new window handle and deal with it in WM_CLIPBOARDUPDATE. + */ + pWinCtx->hWndClipboardOwnerUs = GetClipboardOwner(); + + LogFlowFunc(("hWndClipboardOwnerUs=%p\n", pWinCtx->hWndClipboardOwnerUs)); + break; + } + + LogFlowFunc(("Failed with %Rhrc (try %u/3)\n", hr, uTries + 1)); + RTThreadSleep(500); /* Wait a bit. */ + } + + if (FAILED(hr)) + { + rc = VERR_ACCESS_DENIED; /** @todo Fudge; fix this. */ + LogRel(("Shared Clipboard: Failed with %Rhrc when setting data object to clipboard\n", hr)); + } + } + } + else + rc = VERR_NO_MEMORY; + } + else + rc = VERR_NO_MEMORY; + + int rc2 = RTCritSectLeave(&pWinCtx->CritSect); + AssertRC(rc2); + } + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Destroys implementation-specific data for an Shared Clipboard transfer. + * + * @param pWinCtx Windows context to use. + * @param pTransfer Shared Clipboard transfer to create implementation-specific data for. + */ +void SharedClipboardWinTransferDestroy(PSHCLWINCTX pWinCtx, PSHCLTRANSFER pTransfer) +{ + RT_NOREF(pWinCtx); + + if (!pTransfer) + return; + + LogFlowFuncEnter(); + + if (pTransfer->pvUser) + { + Assert(pTransfer->cbUser == sizeof(SharedClipboardWinTransferCtx)); + SharedClipboardWinTransferCtx *pWinURITransferCtx = (SharedClipboardWinTransferCtx *)pTransfer->pvUser; + Assert(pWinURITransferCtx); + + if (pWinURITransferCtx->pDataObj) + { + delete pWinURITransferCtx->pDataObj; + pWinURITransferCtx->pDataObj = NULL; + } + + delete pWinURITransferCtx; + + pTransfer->pvUser = NULL; + pTransfer->cbUser = 0; + } +} + +/** + * Retrieves the roots for a transfer by opening the clipboard and getting the clipboard data + * as string list (CF_HDROP), assigning it to the transfer as roots then. + * + * @returns VBox status code. + * @param pWinCtx Windows context to use. + * @param pTransfer Transfer to get roots for. + */ +int SharedClipboardWinGetRoots(PSHCLWINCTX pWinCtx, PSHCLTRANSFER pTransfer) +{ + AssertPtrReturn(pWinCtx, VERR_INVALID_POINTER); + AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); + + Assert(ShClTransferGetSource(pTransfer) == SHCLSOURCE_LOCAL); /* Sanity. */ + + int rc = SharedClipboardWinOpen(pWinCtx->hWnd); + if (RT_SUCCESS(rc)) + { + /* The data data in CF_HDROP format, as the files are locally present and don't need to be + * presented as a IDataObject or IStream. */ + HANDLE hClip = hClip = GetClipboardData(CF_HDROP); + if (hClip) + { + HDROP hDrop = (HDROP)GlobalLock(hClip); + if (hDrop) + { + char *papszList = NULL; + uint32_t cbList; + rc = SharedClipboardWinDropFilesToStringList((DROPFILES *)hDrop, &papszList, &cbList); + + GlobalUnlock(hClip); + + if (RT_SUCCESS(rc)) + { + rc = ShClTransferRootsSet(pTransfer, + papszList, cbList + 1 /* Include termination */); + RTStrFree(papszList); + } + } + else + LogRel(("Shared Clipboard: Unable to lock clipboard data, last error: %ld\n", GetLastError())); + } + else + LogRel(("Shared Clipboard: Unable to retrieve clipboard data from clipboard (CF_HDROP), last error: %ld\n", + GetLastError())); + + SharedClipboardWinClose(); + } + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Converts a DROPFILES (HDROP) structure to a string list, separated by \r\n. + * Does not do any locking on the input data. + * + * @returns VBox status code. + * @param pDropFiles Pointer to DROPFILES structure to convert. + * @param papszList Where to store the allocated string list. + * @param pcbList Where to store the size (in bytes) of the allocated string list. + */ +int SharedClipboardWinDropFilesToStringList(DROPFILES *pDropFiles, char **papszList, uint32_t *pcbList) +{ + AssertPtrReturn(pDropFiles, VERR_INVALID_POINTER); + AssertPtrReturn(papszList, VERR_INVALID_POINTER); + AssertPtrReturn(pcbList, VERR_INVALID_POINTER); + + /* Do we need to do Unicode stuff? */ + const bool fUnicode = RT_BOOL(pDropFiles->fWide); + + /* Get the offset of the file list. */ + Assert(pDropFiles->pFiles >= sizeof(DROPFILES)); + + /* Note: This is *not* pDropFiles->pFiles! DragQueryFile only + * will work with the plain storage medium pointer! */ + HDROP hDrop = (HDROP)(pDropFiles); + + int rc = VINF_SUCCESS; + + /* First, get the file count. */ + /** @todo Does this work on Windows 2000 / NT4? */ + char *pszFiles = NULL; + uint32_t cchFiles = 0; + UINT cFiles = DragQueryFile(hDrop, UINT32_MAX /* iFile */, NULL /* lpszFile */, 0 /* cchFile */); + + LogFlowFunc(("Got %RU16 file(s), fUnicode=%RTbool\n", cFiles, fUnicode)); + + for (UINT i = 0; i < cFiles; i++) + { + UINT cchFile = DragQueryFile(hDrop, i /* File index */, NULL /* Query size first */, 0 /* cchFile */); + Assert(cchFile); + + if (RT_FAILURE(rc)) + break; + + char *pszFileUtf8 = NULL; /* UTF-8 version. */ + UINT cchFileUtf8 = 0; + if (fUnicode) + { + /* Allocate enough space (including terminator). */ + WCHAR *pwszFile = (WCHAR *)RTMemAlloc((cchFile + 1) * sizeof(WCHAR)); + if (pwszFile) + { + const UINT cwcFileUtf16 = DragQueryFileW(hDrop, i /* File index */, + pwszFile, cchFile + 1 /* Include terminator */); + + AssertMsg(cwcFileUtf16 == cchFile, ("cchFileUtf16 (%RU16) does not match cchFile (%RU16)\n", + cwcFileUtf16, cchFile)); + RT_NOREF(cwcFileUtf16); + + rc = RTUtf16ToUtf8(pwszFile, &pszFileUtf8); + if (RT_SUCCESS(rc)) + { + cchFileUtf8 = (UINT)strlen(pszFileUtf8); + Assert(cchFileUtf8); + } + + RTMemFree(pwszFile); + } + else + rc = VERR_NO_MEMORY; + } + else /* ANSI */ + { + /* Allocate enough space (including terminator). */ + char *pszFileANSI = (char *)RTMemAlloc((cchFile + 1) * sizeof(char)); + UINT cchFileANSI = 0; + if (pszFileANSI) + { + cchFileANSI = DragQueryFileA(hDrop, i /* File index */, + pszFileANSI, cchFile + 1 /* Include terminator */); + + AssertMsg(cchFileANSI == cchFile, ("cchFileANSI (%RU16) does not match cchFile (%RU16)\n", + cchFileANSI, cchFile)); + + /* Convert the ANSI codepage to UTF-8. */ + rc = RTStrCurrentCPToUtf8(&pszFileUtf8, pszFileANSI); + if (RT_SUCCESS(rc)) + { + cchFileUtf8 = (UINT)strlen(pszFileUtf8); + } + } + else + rc = VERR_NO_MEMORY; + } + + if (RT_SUCCESS(rc)) + { + LogFlowFunc(("\tFile: %s (cchFile=%RU16)\n", pszFileUtf8, cchFileUtf8)); + + LogRel2(("Shared Clipboard: Adding file '%s' to transfer\n", pszFileUtf8)); + + rc = RTStrAAppendExN(&pszFiles, 1 /* cPairs */, pszFileUtf8, strlen(pszFileUtf8)); + cchFiles += (uint32_t)strlen(pszFileUtf8); + } + + if (pszFileUtf8) + RTStrFree(pszFileUtf8); + + if (RT_FAILURE(rc)) + { + LogFunc(("Error handling file entry #%u, rc=%Rrc\n", i, rc)); + break; + } + + /* Add separation between filenames. + * Note: Also do this for the last element of the list. */ + rc = RTStrAAppendExN(&pszFiles, 1 /* cPairs */, "\r\n", 2 /* Bytes */); + if (RT_SUCCESS(rc)) + cchFiles += 2; /* Include \r\n */ + } + + if (RT_SUCCESS(rc)) + { + cchFiles += 1; /* Add string termination. */ + uint32_t cbFiles = cchFiles * sizeof(char); /* UTF-8. */ + + LogFlowFunc(("cFiles=%u, cchFiles=%RU32, cbFiles=%RU32, pszFiles=0x%p\n", + cFiles, cchFiles, cbFiles, pszFiles)); + + *papszList = pszFiles; + *pcbList = cbFiles; + } + else + { + if (pszFiles) + RTStrFree(pszFiles); + } + + LogFlowFuncLeaveRC(rc); + return rc; +} + +#endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */ + diff --git a/src/VBox/GuestHost/SharedClipboard/clipboard-x11.cpp b/src/VBox/GuestHost/SharedClipboard/clipboard-x11.cpp new file mode 100644 index 00000000..8e1bc162 --- /dev/null +++ b/src/VBox/GuestHost/SharedClipboard/clipboard-x11.cpp @@ -0,0 +1,2428 @@ +/** @file + * Shared Clipboard: Common X11 code. + */ + +/* + * Copyright (C) 2006-2022 Oracle and/or its affiliates. + * + * This file is part of VirtualBox base platform packages, as + * available from https://www.virtualbox.org. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, in version 3 of the + * License. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <https://www.gnu.org/licenses>. + * + * SPDX-License-Identifier: GPL-3.0-only + */ + +/* Note: to automatically run regression tests on the Shared Clipboard, + * execute the tstClipboardGH-X11 testcase. If you often make changes to the + * clipboard code, adding the line + * + * OTHERS += $(PATH_tstClipboardGH-X11)/tstClipboardGH-X11.run + * + * to LocalConfig.kmk will cause the tests to be run every time the code is + * changed. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP LOG_GROUP_SHARED_CLIPBOARD + +#include <errno.h> + +#include <dlfcn.h> +#include <fcntl.h> +#include <unistd.h> + +#ifdef RT_OS_SOLARIS +#include <tsol/label.h> +#endif + +#include <X11/Xlib.h> +#include <X11/Xatom.h> +#include <X11/Intrinsic.h> +#include <X11/Shell.h> +#include <X11/Xproto.h> +#include <X11/StringDefs.h> + +#include <iprt/assert.h> +#include <iprt/types.h> +#include <iprt/mem.h> +#include <iprt/semaphore.h> +#include <iprt/thread.h> +#include <iprt/utf16.h> +#include <iprt/uri.h> + +#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS +# include <iprt/cpp/list.h> +# include <iprt/cpp/ministring.h> +# include <VBox/GuestHost/SharedClipboard-transfers.h> +#endif + +#include <VBox/log.h> +#include <VBox/version.h> + +#include <VBox/GuestHost/SharedClipboard.h> +#include <VBox/GuestHost/SharedClipboard-x11.h> +#include <VBox/GuestHost/clipboard-helper.h> +#include <VBox/HostServices/VBoxClipboardSvc.h> + +/** Own macro for declaring function visibility / linkage based on whether this + * code runs as part of test cases or not. */ +#ifdef TESTCASE +# define SHCL_X11_DECL(x) x +#else +# define SHCL_X11_DECL(x) static x +#endif + + +/********************************************************************************************************************************* +* Externals * +*********************************************************************************************************************************/ +#ifdef TESTCASE +extern void tstThreadScheduleCall(void (*proc)(void *, void *), void *client_data); +extern void tstClipRequestData(SHCLX11CTX* pCtx, SHCLX11FMTIDX target, void *closure); +extern void tstRequestTargets(SHCLX11CTX* pCtx); +#endif + + +/********************************************************************************************************************************* +* Prototypes * +*********************************************************************************************************************************/ +class formats; +SHCL_X11_DECL(Atom) clipGetAtom(PSHCLX11CTX pCtx, const char *pszName); +SHCL_X11_DECL(void) clipQueryX11Targets(PSHCLX11CTX pCtx); + +static int clipInitInternal(PSHCLX11CTX pCtx); +static void clipUninitInternal(PSHCLX11CTX pCtx); + + +/********************************************************************************************************************************* +* Global Variables * +*********************************************************************************************************************************/ + +/** + * The table maps X11 names to data formats + * and to the corresponding VBox clipboard formats. + */ +SHCL_X11_DECL(SHCLX11FMTTABLE) g_aFormats[] = +{ + { "INVALID", SHCLX11FMT_INVALID, VBOX_SHCL_FMT_NONE }, + + { "UTF8_STRING", SHCLX11FMT_UTF8, VBOX_SHCL_FMT_UNICODETEXT }, + { "text/plain;charset=UTF-8", SHCLX11FMT_UTF8, VBOX_SHCL_FMT_UNICODETEXT }, + { "text/plain;charset=utf-8", SHCLX11FMT_UTF8, VBOX_SHCL_FMT_UNICODETEXT }, + { "STRING", SHCLX11FMT_TEXT, VBOX_SHCL_FMT_UNICODETEXT }, + { "TEXT", SHCLX11FMT_TEXT, VBOX_SHCL_FMT_UNICODETEXT }, + { "text/plain", SHCLX11FMT_TEXT, VBOX_SHCL_FMT_UNICODETEXT }, + + { "text/html", SHCLX11FMT_HTML, VBOX_SHCL_FMT_HTML }, + { "text/html;charset=utf-8", SHCLX11FMT_HTML, VBOX_SHCL_FMT_HTML }, + { "application/x-moz-nativehtml", SHCLX11FMT_HTML, VBOX_SHCL_FMT_HTML }, + + { "image/bmp", SHCLX11FMT_BMP, VBOX_SHCL_FMT_BITMAP }, + { "image/x-bmp", SHCLX11FMT_BMP, VBOX_SHCL_FMT_BITMAP }, + { "image/x-MS-bmp", SHCLX11FMT_BMP, VBOX_SHCL_FMT_BITMAP }, + /** @todo Inkscape exports image/png but not bmp... */ + +#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS + { "text/uri-list", SHCLX11FMT_URI_LIST, VBOX_SHCL_FMT_URI_LIST }, + { "x-special/gnome-copied-files", SHCLX11FMT_URI_LIST, VBOX_SHCL_FMT_URI_LIST }, + { "x-special/nautilus-clipboard", SHCLX11FMT_URI_LIST, VBOX_SHCL_FMT_URI_LIST }, + { "application/x-kde-cutselection", SHCLX11FMT_URI_LIST, VBOX_SHCL_FMT_URI_LIST }, + /** @todo Anything else we need to add here? */ + /** @todo Add Wayland / Weston support. */ +#endif +}; + + +#ifdef TESTCASE +# ifdef RT_OS_SOLARIS_10 +char XtStrings [] = ""; +WidgetClassRec* applicationShellWidgetClass; +char XtShellStrings [] = ""; +int XmbTextPropertyToTextList( + Display* /* display */, + XTextProperty* /* text_prop */, + char*** /* list_return */, + int* /* count_return */ +) +{ + return 0; +} +# else +const char XtStrings [] = ""; +_WidgetClassRec* applicationShellWidgetClass; +const char XtShellStrings [] = ""; +# endif /* RT_OS_SOLARIS_10 */ +#endif /* TESTCASE */ + + +/********************************************************************************************************************************* +* Defines * +*********************************************************************************************************************************/ + +#define SHCL_MAX_X11_FORMATS RT_ELEMENTS(g_aFormats) + + +/********************************************************************************************************************************* +* Internal structures * +*********************************************************************************************************************************/ + +/** + * A structure containing information about where to store a request + * for the X11 clipboard contents. + */ +typedef struct _CLIPREADX11CBREQ +{ + /** The format VBox would like the data in. */ + SHCLFORMAT uFmtVBox; + /** The format we requested from X11. */ + SHCLX11FMTIDX idxFmtX11; + /** The clipboard context this request is associated with. */ + SHCLX11CTX *pCtx; + /** The request structure passed in from the backend. */ + CLIPREADCBREQ *pReq; +} CLIPREADX11CBREQ; + + + +#ifdef TESTCASE +/** + * Return the max. number of elements in the X11 format table. + * Used by the testing code in tstClipboardGH-X11.cpp + * which cannot use RT_ELEMENTS(g_aFormats) directly. + * + * @return size_t The number of elements in the g_aFormats array. + */ +SHCL_X11_DECL(size_t) clipReportMaxX11Formats(void) +{ + return (RT_ELEMENTS(g_aFormats)); +} +#endif + +/** + * Returns the atom corresponding to a supported X11 format. + * + * @returns Found atom to the corresponding X11 format. + * @param pCtx The X11 clipboard context to use. + * @param uFmtIdx Format index to look up atom for. + */ +static Atom clipAtomForX11Format(PSHCLX11CTX pCtx, SHCLX11FMTIDX uFmtIdx) +{ + AssertReturn(uFmtIdx < RT_ELEMENTS(g_aFormats), 0); + return clipGetAtom(pCtx, g_aFormats[uFmtIdx].pcszAtom); +} + +/** + * Returns the SHCLX11FMT corresponding to a supported X11 format. + * + * @return SHCLX11FMT for a specific format index. + * @param uFmtIdx Format index to look up SHCLX11CLIPFMT for. + */ +SHCL_X11_DECL(SHCLX11FMT) clipRealFormatForX11Format(SHCLX11FMTIDX uFmtIdx) +{ + AssertReturn(uFmtIdx < RT_ELEMENTS(g_aFormats), SHCLX11FMT_INVALID); + return g_aFormats[uFmtIdx].enmFmtX11; +} + +/** + * Returns the VBox format corresponding to a supported X11 format. + * + * @return SHCLFORMAT for a specific format index. + * @param uFmtIdx Format index to look up VBox format for. + */ +static SHCLFORMAT clipVBoxFormatForX11Format(SHCLX11FMTIDX uFmtIdx) +{ + AssertReturn(uFmtIdx < RT_ELEMENTS(g_aFormats), VBOX_SHCL_FMT_NONE); + return g_aFormats[uFmtIdx].uFmtVBox; +} + +/** + * Looks up the X11 format matching a given X11 atom. + * + * @returns The format on success, NIL_CLIPX11FORMAT on failure. + * @param pCtx The X11 clipboard context to use. + * @param atomFormat Atom to look up X11 format for. + */ +static SHCLX11FMTIDX clipFindX11FormatByAtom(PSHCLX11CTX pCtx, Atom atomFormat) +{ + for (unsigned i = 0; i < RT_ELEMENTS(g_aFormats); ++i) + if (clipAtomForX11Format(pCtx, i) == atomFormat) + { + LogFlowFunc(("Returning index %u for atom '%s'\n", i, g_aFormats[i].pcszAtom)); + return i; + } + return NIL_CLIPX11FORMAT; +} + +/** + * Enumerates supported X11 clipboard formats corresponding to given VBox formats. + * + * @returns The next matching X11 format index in the list, or NIL_CLIPX11FORMAT if there are no more. + * @param uFormatsVBox VBox formats to enumerate supported X11 clipboard formats for. + * @param lastFmtIdx The value returned from the last call of this function. + * Use NIL_CLIPX11FORMAT to start the enumeration. + */ +static SHCLX11FMTIDX clipEnumX11Formats(SHCLFORMATS uFormatsVBox, + SHCLX11FMTIDX lastFmtIdx) +{ + for (unsigned i = lastFmtIdx + 1; i < RT_ELEMENTS(g_aFormats); ++i) + { + if (uFormatsVBox & clipVBoxFormatForX11Format(i)) + return i; + } + + return NIL_CLIPX11FORMAT; +} + +/** + * Array of structures for mapping Xt widgets to context pointers. We + * need this because the widget clipboard callbacks do not pass user data. + */ +static struct +{ + /** Pointer to widget we want to associate the context with. */ + Widget pWidget; + /** Pointer to X11 context associated with the widget. */ + PSHCLX11CTX pCtx; +} g_aContexts[VBOX_SHARED_CLIPBOARD_X11_CONNECTIONS_MAX]; + +/** + * Registers a new X11 clipboard context. + * + * @returns VBox status code. + * @param pCtx The X11 clipboard context to use. + */ +static int clipRegisterContext(PSHCLX11CTX pCtx) +{ + AssertPtrReturn(pCtx, VERR_INVALID_PARAMETER); + + bool fFound = false; + + Widget pWidget = pCtx->pWidget; + AssertReturn(pWidget != NULL, VERR_INVALID_PARAMETER); + + for (unsigned i = 0; i < RT_ELEMENTS(g_aContexts); ++i) + { + AssertReturn( (g_aContexts[i].pWidget != pWidget) + && (g_aContexts[i].pCtx != pCtx), VERR_WRONG_ORDER); + if (g_aContexts[i].pWidget == NULL && !fFound) + { + AssertReturn(g_aContexts[i].pCtx == NULL, VERR_INTERNAL_ERROR); + g_aContexts[i].pWidget = pWidget; + g_aContexts[i].pCtx = pCtx; + fFound = true; + } + } + + return fFound ? VINF_SUCCESS : VERR_OUT_OF_RESOURCES; +} + +/** + * Unregister an X11 clipboard context. + * + * @param pCtx The X11 clipboard context to use. + */ +static void clipUnregisterContext(PSHCLX11CTX pCtx) +{ + AssertPtrReturnVoid(pCtx); + + Widget pWidget = pCtx->pWidget; + AssertPtrReturnVoid(pWidget); + + bool fFound = false; + for (unsigned i = 0; i < RT_ELEMENTS(g_aContexts); ++i) + { + Assert(!fFound || g_aContexts[i].pWidget != pWidget); + if (g_aContexts[i].pWidget == pWidget) + { + Assert(g_aContexts[i].pCtx != NULL); + g_aContexts[i].pWidget = NULL; + g_aContexts[i].pCtx = NULL; + fFound = true; + } + } +} + +/** + * Finds a X11 clipboard context for a specific X11 widget. + * + * @returns Pointer to associated X11 clipboard context if found, or NULL if not found. + * @param pWidget X11 widget to return X11 clipboard context for. + */ +static PSHCLX11CTX clipLookupContext(Widget pWidget) +{ + AssertPtrReturn(pWidget, NULL); + + for (unsigned i = 0; i < RT_ELEMENTS(g_aContexts); ++i) + { + if (g_aContexts[i].pWidget == pWidget) + { + Assert(g_aContexts[i].pCtx != NULL); + return g_aContexts[i].pCtx; + } + } + + return NULL; +} + +/** + * Converts an atom name string to an X11 atom, looking it up in a cache before asking the server. + * + * @returns Found X11 atom. + * @param pCtx The X11 clipboard context to use. + * @param pcszName Name of atom to return atom for. + */ +SHCL_X11_DECL(Atom) clipGetAtom(PSHCLX11CTX pCtx, const char *pcszName) +{ + AssertPtrReturn(pcszName, None); + return XInternAtom(XtDisplay(pCtx->pWidget), pcszName, False); +} + +/** String written to the wakeup pipe. */ +#define WAKE_UP_STRING "WakeUp!" +/** Length of the string written. */ +#define WAKE_UP_STRING_LEN ( sizeof(WAKE_UP_STRING) - 1 ) + +/** + * Schedules a function call to run on the Xt event thread by passing it to + * the application context as a 0ms timeout and waking up the event loop by + * writing to the wakeup pipe which it monitors. + */ +static int clipThreadScheduleCall(PSHCLX11CTX pCtx, + void (*proc)(void *, void *), + void *client_data) +{ + LogFlowFunc(("proc=%p, client_data=%p\n", proc, client_data)); + +#ifndef TESTCASE + AssertReturn(pCtx, VERR_INVALID_POINTER); + AssertReturn(pCtx->pAppContext, VERR_INVALID_POINTER); + + XtAppAddTimeOut(pCtx->pAppContext, 0, (XtTimerCallbackProc)proc, + (XtPointer)client_data); + ssize_t cbWritten = write(pCtx->wakeupPipeWrite, WAKE_UP_STRING, WAKE_UP_STRING_LEN); + Assert(cbWritten == WAKE_UP_STRING_LEN); + RT_NOREF(cbWritten); +#else + RT_NOREF(pCtx); + tstThreadScheduleCall(proc, client_data); +#endif + + LogFlowFuncLeaveRC(VINF_SUCCESS); + return VINF_SUCCESS; +} + +/** + * Reports the formats currently supported by the X11 clipboard to VBox. + * + * @note Runs in Xt event thread. + * + * @param pCtx The X11 clipboard context to use. + */ +static void clipReportFormatsToVBox(PSHCLX11CTX pCtx) +{ + SHCLFORMATS vboxFmt = clipVBoxFormatForX11Format(pCtx->idxFmtText); + vboxFmt |= clipVBoxFormatForX11Format(pCtx->idxFmtBmp); + vboxFmt |= clipVBoxFormatForX11Format(pCtx->idxFmtHTML); +#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS + vboxFmt |= clipVBoxFormatForX11Format(pCtx->idxFmtURI); +#endif + + LogFlowFunc(("idxFmtText=%u ('%s'), idxFmtBmp=%u ('%s'), idxFmtHTML=%u ('%s')", + pCtx->idxFmtText, g_aFormats[pCtx->idxFmtText].pcszAtom, + pCtx->idxFmtBmp, g_aFormats[pCtx->idxFmtBmp].pcszAtom, + pCtx->idxFmtHTML, g_aFormats[pCtx->idxFmtHTML].pcszAtom)); +#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS + LogFlowFunc((", idxFmtURI=%u ('%s')", pCtx->idxFmtURI, g_aFormats[pCtx->idxFmtURI].pcszAtom)); +#endif + LogFlow((" -> vboxFmt=%#x\n", vboxFmt)); + +#ifdef LOG_ENABLED + char *pszFmts = ShClFormatsToStrA(vboxFmt); + AssertPtrReturnVoid(pszFmts); + LogRel2(("Shared Clipboard: X11 reported available VBox formats '%s'\n", pszFmts)); + RTStrFree(pszFmts); +#endif + + pCtx->Callbacks.pfnReportFormats(pCtx->pFrontend, vboxFmt, NULL /* pvUser */); +} + +/** + * Forgets which formats were previously in the X11 clipboard. Called when we + * grab the clipboard. + * + * @param pCtx The X11 clipboard context to use. + */ +static void clipResetX11Formats(PSHCLX11CTX pCtx) +{ + LogFlowFuncEnter(); + + pCtx->idxFmtText = 0; + pCtx->idxFmtBmp = 0; + pCtx->idxFmtHTML = 0; +#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS + pCtx->idxFmtURI = 0; +#endif +} + +/** + * Tells VBox that X11 currently has nothing in its clipboard. + * + * @param pCtx The X11 clipboard context to use. + */ +SHCL_X11_DECL(void) clipReportEmpty(PSHCLX11CTX pCtx) +{ + clipResetX11Formats(pCtx); + clipReportFormatsToVBox(pCtx); +} + +/** + * Go through an array of X11 clipboard targets to see if they contain a text + * format we can support, and if so choose the ones we prefer (e.g. we like + * UTF-8 better than plain text). + * + * @return Index to supported X clipboard format. + * @param pCtx The X11 clipboard context to use. + * @param paIdxFmtTargets The list of targets. + * @param cTargets The size of the list in @a pTargets. + */ +SHCL_X11_DECL(SHCLX11FMTIDX) clipGetTextFormatFromTargets(PSHCLX11CTX pCtx, + SHCLX11FMTIDX *paIdxFmtTargets, + size_t cTargets) +{ + AssertPtrReturn(pCtx, NIL_CLIPX11FORMAT); + AssertReturn(RT_VALID_PTR(paIdxFmtTargets) || cTargets == 0, NIL_CLIPX11FORMAT); + + SHCLX11FMTIDX idxFmtText = NIL_CLIPX11FORMAT; + SHCLX11FMT fmtTextX11 = SHCLX11FMT_INVALID; + for (unsigned i = 0; i < cTargets; ++i) + { + SHCLX11FMTIDX idxFmt = paIdxFmtTargets[i]; + if (idxFmt != NIL_CLIPX11FORMAT) + { + if ( (clipVBoxFormatForX11Format(idxFmt) == VBOX_SHCL_FMT_UNICODETEXT) + && fmtTextX11 < clipRealFormatForX11Format(idxFmt)) + { + fmtTextX11 = clipRealFormatForX11Format(idxFmt); + idxFmtText = idxFmt; + } + } + } + return idxFmtText; +} + +/** + * Goes through an array of X11 clipboard targets to see if they contain a bitmap + * format we can support, and if so choose the ones we prefer (e.g. we like + * BMP better than PNG because we don't have to convert). + * + * @return Supported X clipboard format. + * @param pCtx The X11 clipboard context to use. + * @param paIdxFmtTargets The list of targets. + * @param cTargets The size of the list in @a pTargets. + */ +static SHCLX11FMTIDX clipGetBitmapFormatFromTargets(PSHCLX11CTX pCtx, + SHCLX11FMTIDX *paIdxFmtTargets, + size_t cTargets) +{ + AssertPtrReturn(pCtx, NIL_CLIPX11FORMAT); + AssertReturn(RT_VALID_PTR(paIdxFmtTargets) || cTargets == 0, NIL_CLIPX11FORMAT); + + SHCLX11FMTIDX idxFmtBmp = NIL_CLIPX11FORMAT; + SHCLX11FMT fmtBmpX11 = SHCLX11FMT_INVALID; + for (unsigned i = 0; i < cTargets; ++i) + { + SHCLX11FMTIDX idxFmt = paIdxFmtTargets[i]; + if (idxFmt != NIL_CLIPX11FORMAT) + { + if ( (clipVBoxFormatForX11Format(idxFmt) == VBOX_SHCL_FMT_BITMAP) + && fmtBmpX11 < clipRealFormatForX11Format(idxFmt)) + { + fmtBmpX11 = clipRealFormatForX11Format(idxFmt); + idxFmtBmp = idxFmt; + } + } + } + return idxFmtBmp; +} + +/** + * Goes through an array of X11 clipboard targets to see if they contain a HTML + * format we can support, and if so choose the ones we prefer. + * + * @return Supported X clipboard format. + * @param pCtx The X11 clipboard context to use. + * @param paIdxFmtTargets The list of targets. + * @param cTargets The size of the list in @a pTargets. + */ +static SHCLX11FMTIDX clipGetHtmlFormatFromTargets(PSHCLX11CTX pCtx, + SHCLX11FMTIDX *paIdxFmtTargets, + size_t cTargets) +{ + AssertPtrReturn(pCtx, NIL_CLIPX11FORMAT); + AssertReturn(RT_VALID_PTR(paIdxFmtTargets) || cTargets == 0, NIL_CLIPX11FORMAT); + + SHCLX11FMTIDX idxFmtHTML = NIL_CLIPX11FORMAT; + SHCLX11FMT fmxHTMLX11 = SHCLX11FMT_INVALID; + for (unsigned i = 0; i < cTargets; ++i) + { + SHCLX11FMTIDX idxFmt = paIdxFmtTargets[i]; + if (idxFmt != NIL_CLIPX11FORMAT) + { + if ( (clipVBoxFormatForX11Format(idxFmt) == VBOX_SHCL_FMT_HTML) + && fmxHTMLX11 < clipRealFormatForX11Format(idxFmt)) + { + fmxHTMLX11 = clipRealFormatForX11Format(idxFmt); + idxFmtHTML = idxFmt; + } + } + } + return idxFmtHTML; +} + +# ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS +/** + * Goes through an array of X11 clipboard targets to see if they contain an URI list + * format we can support, and if so choose the ones we prefer. + * + * @return Supported X clipboard format. + * @param pCtx The X11 clipboard context to use. + * @param paIdxFmtTargets The list of targets. + * @param cTargets The size of the list in @a pTargets. + */ +static SHCLX11FMTIDX clipGetURIListFormatFromTargets(PSHCLX11CTX pCtx, + SHCLX11FMTIDX *paIdxFmtTargets, + size_t cTargets) +{ + AssertPtrReturn(pCtx, NIL_CLIPX11FORMAT); + AssertReturn(RT_VALID_PTR(paIdxFmtTargets) || cTargets == 0, NIL_CLIPX11FORMAT); + + SHCLX11FMTIDX idxFmtURI = NIL_CLIPX11FORMAT; + SHCLX11FMT fmtURIX11 = SHCLX11FMT_INVALID; + for (unsigned i = 0; i < cTargets; ++i) + { + SHCLX11FMTIDX idxFmt = paIdxFmtTargets[i]; + if (idxFmt != NIL_CLIPX11FORMAT) + { + if ( (clipVBoxFormatForX11Format(idxFmt) == VBOX_SHCL_FMT_URI_LIST) + && fmtURIX11 < clipRealFormatForX11Format(idxFmt)) + { + fmtURIX11 = clipRealFormatForX11Format(idxFmt); + idxFmtURI = idxFmt; + } + } + } + return idxFmtURI; +} +# endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */ + +/** + * Goes through an array of X11 clipboard targets to see if we can support any + * of them and if relevant to choose the ones we prefer (e.g. we like Utf8 + * better than plain text). + * + * @param pCtx The X11 clipboard context to use. + * @param paIdxFmtTargets The list of targets. + * @param cTargets The size of the list in @a pTargets. + */ +static void clipGetFormatsFromTargets(PSHCLX11CTX pCtx, + SHCLX11FMTIDX *paIdxFmtTargets, size_t cTargets) +{ + AssertPtrReturnVoid(pCtx); + AssertPtrReturnVoid(paIdxFmtTargets); + + SHCLX11FMTIDX idxFmtText = clipGetTextFormatFromTargets(pCtx, paIdxFmtTargets, cTargets); + if (pCtx->idxFmtText != idxFmtText) + pCtx->idxFmtText = idxFmtText; + + pCtx->idxFmtBmp = SHCLX11FMT_INVALID; /* not yet supported */ /** @todo r=andy Check this. */ + SHCLX11FMTIDX idxFmtBmp = clipGetBitmapFormatFromTargets(pCtx, paIdxFmtTargets, cTargets); + if (pCtx->idxFmtBmp != idxFmtBmp) + pCtx->idxFmtBmp = idxFmtBmp; + + SHCLX11FMTIDX idxFmtHTML = clipGetHtmlFormatFromTargets(pCtx, paIdxFmtTargets, cTargets); + if (pCtx->idxFmtHTML != idxFmtHTML) + pCtx->idxFmtHTML = idxFmtHTML; + +#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS + SHCLX11FMTIDX idxFmtURI = clipGetURIListFormatFromTargets(pCtx, paIdxFmtTargets, cTargets); + if (pCtx->idxFmtURI != idxFmtURI) + pCtx->idxFmtURI = idxFmtURI; +#endif +} + +#ifdef VBOX_WITH_SHARED_CLIPBOARD_XT_BUSY +DECLINLINE(bool) clipGetXtBusy(PSHCLX11CTX pCtx) +{ + LogFlowFunc(("fXtBusy=%RTbool, fXtNeedsUpdate=%RTbool\n", pCtx->fXtBusy, pCtx->fXtNeedsUpdate)); + return pCtx->fXtBusy; +} + +DECLINLINE(bool) clipGetXtNeedsUpdate(PSHCLX11CTX pCtx) +{ + LogFlowFunc(("fXtBusy=%RTbool, fXtNeedsUpdate=%RTbool\n", pCtx->fXtBusy, pCtx->fXtNeedsUpdate)); + return pCtx->fXtNeedsUpdate; +} + +DECLINLINE(bool) clipSetXtBusy(PSHCLX11CTX pCtx, bool fBusy) +{ + pCtx->fXtBusy = fBusy; + LogFlowFunc(("fXtBusy=%RTbool, fXtNeedsUpdate=%RTbool\n", pCtx->fXtBusy, pCtx->fXtNeedsUpdate)); + return pCtx->fXtBusy; +} + +DECLINLINE(bool) clipSetXtNeedsUpdate(PSHCLX11CTX pCtx, bool fNeedsUpdate) +{ + pCtx->fXtNeedsUpdate = fNeedsUpdate; + LogFlowFunc(("fXtBusy=%RTbool, fXtNeedsUpdate=%RTbool\n", pCtx->fXtBusy, pCtx->fXtNeedsUpdate)); + return pCtx->fXtNeedsUpdate; +} +#endif /* VBOX_WITH_SHARED_CLIPBOARD_XT_BUSY */ + +/** + * Updates the context's information about targets currently supported by X11, + * based on an array of X11 atoms. + * + * @param pCtx The X11 clipboard context to use. + * @param pTargets The array of atoms describing the targets supported. + * @param cTargets The size of the array @a pTargets. + */ +SHCL_X11_DECL(void) clipUpdateX11Targets(PSHCLX11CTX pCtx, SHCLX11FMTIDX *paIdxFmtTargets, size_t cTargets) +{ + LogFlowFuncEnter(); + +#ifdef VBOX_WITH_SHARED_CLIPBOARD_XT_BUSY + clipSetXtBusy(pCtx, false); + if (clipGetXtNeedsUpdate(pCtx)) + { + /* We may already be out of date. */ + clipSetXtNeedsUpdate(pCtx, false); + clipQueryX11Targets(pCtx); + return; + } +#endif + + if (paIdxFmtTargets == NULL) + { + /* No data available */ + clipReportEmpty(pCtx); + return; + } + + clipGetFormatsFromTargets(pCtx, paIdxFmtTargets, cTargets); + clipReportFormatsToVBox(pCtx); +} + +/** + * Notifies the VBox clipboard about available data formats ("targets" on X11), + * based on the information obtained from the X11 clipboard. + * + * @note Callback installed by clipQueryX11Targets() for XtGetSelectionValue(). + * @note This function is treated as API glue, and as such is not part of any + * unit test. So keep it simple, be paranoid and log everything. + */ +SHCL_X11_DECL(void) clipQueryX11TargetsCallback(Widget widget, XtPointer pClient, + Atom * /* selection */, Atom *atomType, + XtPointer pValue, long unsigned int *pcLen, + int *piFormat) +{ + RT_NOREF(piFormat); + + PSHCLX11CTX pCtx = reinterpret_cast<SHCLX11CTX *>(pClient); + + LogFlowFunc(("pValue=%p, *pcLen=%u, *atomType=%d%s\n", + pValue, *pcLen, *atomType, *atomType == XT_CONVERT_FAIL ? " (XT_CONVERT_FAIL)" : "")); + + Atom *pAtoms = (Atom *)pValue; + + unsigned cFormats = *pcLen; + + LogRel2(("Shared Clipboard: Querying X11 formats ...\n")); + LogRel2(("Shared Clipboard: %u X11 formats were found\n", cFormats)); + + SHCLX11FMTIDX *paIdxFmt = NULL; + if ( cFormats + && pValue + && (*atomType != XT_CONVERT_FAIL /* time out */)) + { + /* Allocated array to hold the format indices. */ + paIdxFmt = (SHCLX11FMTIDX *)RTMemAllocZ(cFormats * sizeof(SHCLX11FMTIDX)); + } + +#if !defined(TESTCASE) + if (pValue) + { + for (unsigned i = 0; i < cFormats; ++i) + { + if (pAtoms[i]) + { + char *pszName = XGetAtomName(XtDisplay(widget), pAtoms[i]); + LogRel2(("Shared Clipboard: Found X11 format '%s'\n", pszName)); + XFree(pszName); + } + else + LogFunc(("Found empty target\n")); + } + } +#endif + + if (paIdxFmt) + { + for (unsigned i = 0; i < cFormats; ++i) + { + for (unsigned j = 0; j < RT_ELEMENTS(g_aFormats); ++j) + { + Atom target = XInternAtom(XtDisplay(widget), + g_aFormats[j].pcszAtom, False); + if (*(pAtoms + i) == target) + paIdxFmt[i] = j; + } +#if !defined(TESTCASE) + if (paIdxFmt[i] != SHCLX11FMT_INVALID) + LogRel2(("Shared Clipboard: Reporting X11 format '%s'\n", g_aFormats[paIdxFmt[i]].pcszAtom)); +#endif + } + } + else + LogFunc(("Reporting empty targets (none reported or allocation failure)\n")); + + clipUpdateX11Targets(pCtx, paIdxFmt, cFormats); + RTMemFree(paIdxFmt); + + XtFree(reinterpret_cast<char *>(pValue)); +} + +/** + * Queries the current formats ("targets") of the X11 clipboard ("CLIPBOARD"). + * + * @param pCtx The X11 clipboard context to use. + */ +SHCL_X11_DECL(void) clipQueryX11Targets(PSHCLX11CTX pCtx) +{ +#ifndef TESTCASE + +# ifdef VBOX_WITH_SHARED_CLIPBOARD_XT_BUSY + if (clipGetXtBusy(pCtx)) + { + clipSetXtNeedsUpdate(pCtx, true); + return; + } + clipSetXtBusy(pCtx, true); +# endif + + XtGetSelectionValue(pCtx->pWidget, + clipGetAtom(pCtx, "CLIPBOARD"), + clipGetAtom(pCtx, "TARGETS"), + clipQueryX11TargetsCallback, pCtx, + CurrentTime); +#else + tstRequestTargets(pCtx); +#endif +} + +typedef struct +{ + int type; /* event base */ + unsigned long serial; + Bool send_event; + Display *display; + Window window; + int subtype; + Window owner; + Atom selection; + Time timestamp; + Time selection_timestamp; +} XFixesSelectionNotifyEvent; + +#ifndef TESTCASE +/** + * Waits until an event arrives and handle it if it is an XFIXES selection + * event, which Xt doesn't know about. + * + * @param pCtx The X11 clipboard context to use. + */ +static void clipPeekEventAndDoXFixesHandling(PSHCLX11CTX pCtx) +{ + union + { + XEvent event; + XFixesSelectionNotifyEvent fixes; + } event = { { 0 } }; + + if (XtAppPeekEvent(pCtx->pAppContext, &event.event)) + { + if ( (event.event.type == pCtx->fixesEventBase) + && (event.fixes.owner != XtWindow(pCtx->pWidget))) + { + if ( (event.fixes.subtype == 0 /* XFixesSetSelectionOwnerNotify */) + && (event.fixes.owner != 0)) + clipQueryX11Targets(pCtx); + else + clipReportEmpty(pCtx); + } + } +} + +/** + * The main loop of our X11 event thread. + * + * @returns VBox status code. + * @param hThreadSelf Associated thread handle. + * @param pvUser Pointer to the X11 clipboard context to use. + */ +static DECLCALLBACK(int) clipThreadMain(RTTHREAD hThreadSelf, void *pvUser) +{ + PSHCLX11CTX pCtx = (PSHCLX11CTX)pvUser; + AssertPtr(pCtx); + + LogFlowFunc(("pCtx=%p\n", pCtx)); + + bool fSignalled = false; /* Whether we have signalled the parent already or not. */ + + int rc = clipInitInternal(pCtx); + if (RT_SUCCESS(rc)) + { + rc = clipRegisterContext(pCtx); + if (RT_SUCCESS(rc)) + { + if (pCtx->fGrabClipboardOnStart) + clipQueryX11Targets(pCtx); + + pCtx->fThreadStarted = true; + + /* We're now ready to run, tell parent. */ + int rc2 = RTThreadUserSignal(hThreadSelf); + AssertRC(rc2); + + fSignalled = true; + + while (XtAppGetExitFlag(pCtx->pAppContext) == FALSE) + { + clipPeekEventAndDoXFixesHandling(pCtx); + XtAppProcessEvent(pCtx->pAppContext, XtIMAll); + } + + LogRel(("Shared Clipboard: X11 event thread exiting\n")); + + clipUnregisterContext(pCtx); + } + else + { + LogRel(("Shared Clipboard: unable to register clip context: %Rrc\n", rc)); + } + + clipUninitInternal(pCtx); + } + + if (!fSignalled) /* Signal parent if we didn't do so yet. */ + { + int rc2 = RTThreadUserSignal(hThreadSelf); + AssertRC(rc2); + } + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Worker function for stopping the clipboard which runs on the event + * thread. + * + * @param pvUserData Pointer to the X11 clipboard context to use. + */ +static void clipThreadSignalStop(void *pvUserData, void *) +{ + PSHCLX11CTX pCtx = (PSHCLX11CTX)pvUserData; + + /* This might mean that we are getting stopped twice. */ + Assert(pCtx->pWidget != NULL); + + /* Set the termination flag to tell the Xt event loop to exit. We + * reiterate that any outstanding requests from the X11 event loop to + * the VBox part *must* have returned before we do this. */ + XtAppSetExitFlag(pCtx->pAppContext); +} + +/** + * Sets up the XFixes library and load the XFixesSelectSelectionInput symbol. + */ +static int clipLoadXFixes(Display *pDisplay, PSHCLX11CTX pCtx) +{ + int rc; + + void *hFixesLib = dlopen("libXfixes.so.1", RTLD_LAZY); + if (!hFixesLib) + hFixesLib = dlopen("libXfixes.so.2", RTLD_LAZY); + if (!hFixesLib) + hFixesLib = dlopen("libXfixes.so.3", RTLD_LAZY); + if (!hFixesLib) + hFixesLib = dlopen("libXfixes.so.4", RTLD_LAZY); + if (hFixesLib) + { + /* For us, a NULL function pointer is a failure */ + pCtx->fixesSelectInput = (void (*)(Display *, Window, Atom, long unsigned int)) + (uintptr_t)dlsym(hFixesLib, "XFixesSelectSelectionInput"); + if (pCtx->fixesSelectInput) + { + int dummy1 = 0; + int dummy2 = 0; + if (XQueryExtension(pDisplay, "XFIXES", &dummy1, &pCtx->fixesEventBase, &dummy2) != 0) + { + if (pCtx->fixesEventBase >= 0) + { + rc = VINF_SUCCESS; + } + else + { + LogRel(("Shared Clipboard: fixesEventBase is less than zero: %d\n", pCtx->fixesEventBase)); + rc = VERR_NOT_SUPPORTED; + } + } + else + { + LogRel(("Shared Clipboard: XQueryExtension failed\n")); + rc = VERR_NOT_SUPPORTED; + } + } + else + { + LogRel(("Shared Clipboard: Symbol XFixesSelectSelectionInput not found!\n")); + rc = VERR_NOT_SUPPORTED; + } + } + else + { + LogRel(("Shared Clipboard: libxFixes.so.* not found!\n")); + rc = VERR_NOT_SUPPORTED; + } + return rc; +} + +/** + * This is the callback which is scheduled when data is available on the + * wakeup pipe. It simply reads all data from the pipe. + * + * @param pvUserData Pointer to the X11 clipboard context to use. + */ +static void clipThreadDrainWakeupPipe(XtPointer pvUserData, int *, XtInputId *) +{ + LogFlowFuncEnter(); + + PSHCLX11CTX pCtx = (PSHCLX11CTX)pvUserData; + char acBuf[WAKE_UP_STRING_LEN]; + + while (read(pCtx->wakeupPipeRead, acBuf, sizeof(acBuf)) > 0) {} +} +#endif /* !TESTCASE */ + +/** + * X11-specific initialisation for the Shared Clipboard. + * + * Note: Must be called from the thread serving the Xt stuff. + * + * @returns VBox status code. + * @param pCtx The X11 clipboard context to init. + */ +static int clipInitInternal(PSHCLX11CTX pCtx) +{ + LogFlowFunc(("pCtx=%p\n", pCtx)); + + /* Make sure we are thread safe. */ + XtToolkitThreadInitialize(); + + /* + * Set up the Clipboard application context and main window. We call all + * these functions directly instead of calling XtOpenApplication() so + * that we can fail gracefully if we can't get an X11 display. + */ + XtToolkitInitialize(); + + int rc = VINF_SUCCESS; + + Assert(pCtx->pAppContext == NULL); /* No nested initialization. */ + pCtx->pAppContext = XtCreateApplicationContext(); + if (pCtx->pAppContext == NULL) + { + LogRel(("Shared Clipboard: Failed to create Xt application context\n")); + return VERR_NOT_SUPPORTED; /** @todo Fudge! */ + } + + /* Create a window and make it a clipboard viewer. */ + int cArgc = 0; + char *pcArgv = 0; + Display *pDisplay = XtOpenDisplay(pCtx->pAppContext, 0, 0, "VBoxShCl", 0, 0, &cArgc, &pcArgv); + if (pDisplay == NULL) + { + LogRel(("Shared Clipboard: Failed to connect to the X11 clipboard - the window system may not be running\n")); + rc = VERR_NOT_SUPPORTED; + } + +#ifndef TESTCASE + if (RT_SUCCESS(rc)) + { + rc = clipLoadXFixes(pDisplay, pCtx); + if (RT_FAILURE(rc)) + LogRel(("Shared Clipboard: Failed to load the XFIXES extension\n")); + } +#endif + + if (RT_SUCCESS(rc)) + { + pCtx->pWidget = XtVaAppCreateShell(0, "VBoxShCl", + applicationShellWidgetClass, + pDisplay, XtNwidth, 1, XtNheight, + 1, NULL); + if (pCtx->pWidget == NULL) + { + LogRel(("Shared Clipboard: Failed to create Xt app shell\n")); + rc = VERR_NO_MEMORY; /** @todo r=andy Improve this. */ + } + else + { +#ifndef TESTCASE + if (!XtAppAddInput(pCtx->pAppContext, pCtx->wakeupPipeRead, + (XtPointer) XtInputReadMask, + clipThreadDrainWakeupPipe, (XtPointer) pCtx)) + { + LogRel(("Shared Clipboard: Failed to add input to Xt app context\n")); + rc = VERR_ACCESS_DENIED; /** @todo r=andy Improve this. */ + } +#endif + } + } + + if (RT_SUCCESS(rc)) + { + XtSetMappedWhenManaged(pCtx->pWidget, false); + XtRealizeWidget(pCtx->pWidget); + +#ifndef TESTCASE + /* Enable clipboard update notification. */ + pCtx->fixesSelectInput(pDisplay, XtWindow(pCtx->pWidget), + clipGetAtom(pCtx, "CLIPBOARD"), + 7 /* All XFixes*Selection*NotifyMask flags */); +#endif + } + + if (RT_FAILURE(rc)) + { + LogRel(("Shared Clipboard: Initialisation failed: %Rrc\n", rc)); + clipUninitInternal(pCtx); + } + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * X11-specific uninitialisation for the Shared Clipboard. + * + * Note: Must be called from the thread serving the Xt stuff. + * + * @param pCtx The X11 clipboard context to uninit. + */ +static void clipUninitInternal(PSHCLX11CTX pCtx) +{ + AssertPtrReturnVoid(pCtx); + + LogFlowFunc(("pCtx=%p\n", pCtx)); + + if (pCtx->pWidget) + { + /* Valid widget + invalid appcontext = bug. But don't return yet. */ + AssertPtr(pCtx->pAppContext); + + XtDestroyWidget(pCtx->pWidget); + pCtx->pWidget = NULL; + } + + if (pCtx->pAppContext) + { + XtDestroyApplicationContext(pCtx->pAppContext); + pCtx->pAppContext = NULL; + } + + LogFlowFuncLeaveRC(VINF_SUCCESS); +} + +/** + * Sets the callback table, internal version. + * + * @param pCtx The clipboard context. + * @param pCallbacks Callback table to set. If NULL, the current callback table will be cleared. + */ +static void shClX11SetCallbacksInternal(PSHCLX11CTX pCtx, PSHCLCALLBACKS pCallbacks) +{ + if (pCallbacks) + { + memcpy(&pCtx->Callbacks, pCallbacks, sizeof(SHCLCALLBACKS)); + } + else + RT_ZERO(pCtx->Callbacks); +} + +/** + * Sets the callback table. + * + * @param pCtx The clipboard context. + * @param pCallbacks Callback table to set. If NULL, the current callback table will be cleared. + */ +void ShClX11SetCallbacks(PSHCLX11CTX pCtx, PSHCLCALLBACKS pCallbacks) +{ + shClX11SetCallbacksInternal(pCtx, pCallbacks); +} + +/** + * Initializes a X11 context of the Shared Clipboard. + * + * @returns VBox status code. + * @param pCtx The clipboard context to initialize. + * @param pCallbacks Callback table to use. + * @param pParent Parent context to use. + * @param fHeadless Whether the code runs in a headless environment or not. + */ +int ShClX11Init(PSHCLX11CTX pCtx, PSHCLCALLBACKS pCallbacks, PSHCLCONTEXT pParent, bool fHeadless) +{ + AssertPtrReturn(pCtx, VERR_INVALID_POINTER); + + LogFlowFunc(("pCtx=%p\n", pCtx)); + + int rc = VINF_SUCCESS; + + RT_BZERO(pCtx, sizeof(SHCLX11CTX)); + + if (fHeadless) + { + /* + * If we don't find the DISPLAY environment variable we assume that + * we are not connected to an X11 server. Don't actually try to do + * this then, just fail silently and report success on every call. + * This is important for VBoxHeadless. + */ + LogRel(("Shared Clipboard: X11 DISPLAY variable not set -- disabling clipboard sharing\n")); + } + + /* Install given callbacks. */ + shClX11SetCallbacksInternal(pCtx, pCallbacks); + + pCtx->fHaveX11 = !fHeadless; + pCtx->pFrontend = pParent; + +#ifdef VBOX_WITH_SHARED_CLIPBOARD_XT_BUSY + pCtx->fXtBusy = false; + pCtx->fXtNeedsUpdate = false; +#endif + +#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS_HTTP + ShClTransferHttpServerInit(&pCtx->HttpCtx.HttpServer); +#endif + +#ifdef TESTCASE + if (RT_SUCCESS(rc)) + { + /** @todo The testcases currently do not utilize the threading code. So init stuff here. */ + rc = clipInitInternal(pCtx); + if (RT_SUCCESS(rc)) + rc = clipRegisterContext(pCtx); + } +#endif + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Destroys a Shared Clipboard X11 context. + * + * @param pCtx The X11 clipboard context to destroy. + */ +void ShClX11Destroy(PSHCLX11CTX pCtx) +{ + if (!pCtx) + return; + + LogFlowFunc(("pCtx=%p\n", pCtx)); + +#ifdef TESTCASE + /** @todo The testcases currently do not utilize the threading code. So uninit stuff here. */ + clipUnregisterContext(pCtx); + clipUninitInternal(pCtx); +#endif + + if (pCtx->fHaveX11) + { + /* We set this to NULL when the event thread exits. It really should + * have exited at this point, when we are about to unload the code from + * memory. */ + Assert(pCtx->pWidget == NULL); + } +} + +#ifndef TESTCASE +/** + * Starts our own Xt even thread for handling Shared Clipboard messages, extended version. + * + * @returns VBox status code. + * @param pCtx The X11 clipboard context to use. + * @param pszName Thread name to use. + * @param fGrab Whether we should try to grab the shared clipboard at once. + */ +int ShClX11ThreadStartEx(PSHCLX11CTX pCtx, const char *pszName, bool fGrab) +{ + AssertPtrReturn(pCtx, VERR_INVALID_POINTER); + + /* + * Immediately return if we are not connected to the X server. + */ + if (!pCtx->fHaveX11) + return VINF_SUCCESS; + + pCtx->fGrabClipboardOnStart = fGrab; + + clipResetX11Formats(pCtx); + + int rc; + + /* + * Create the pipes. + ** @todo r=andy Replace this with RTPipe API. + */ + int pipes[2]; + if (!pipe(pipes)) + { + pCtx->wakeupPipeRead = pipes[0]; + pCtx->wakeupPipeWrite = pipes[1]; + + if (!fcntl(pCtx->wakeupPipeRead, F_SETFL, O_NONBLOCK)) + { + rc = VINF_SUCCESS; + } + else + rc = RTErrConvertFromErrno(errno); + } + else + rc = RTErrConvertFromErrno(errno); + + if (RT_SUCCESS(rc)) + { + LogRel2(("Shared Clipboard: Starting X11 event thread ...\n")); + + rc = RTThreadCreate(&pCtx->Thread, clipThreadMain, pCtx, 0, + RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, pszName); + if (RT_SUCCESS(rc)) + rc = RTThreadUserWait(pCtx->Thread, RT_MS_30SEC /* msTimeout */); + + if (RT_FAILURE(rc)) + { + LogRel(("Shared Clipboard: Failed to start the X11 event thread with %Rrc\n", rc)); + clipUninitInternal(pCtx); + } + else + { + if (!pCtx->fThreadStarted) + { + LogRel(("Shared Clipboard: X11 event thread reported an error while starting\n")); + } + else + LogRel2(("Shared Clipboard: X11 event thread started\n")); + } + } + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Starts our own Xt even thread for handling Shared Clipboard messages. + * + * @returns VBox status code. + * @param pCtx The X11 clipboard context to use. + * @param fGrab Whether we should try to grab the shared clipboard at once. + */ +int ShClX11ThreadStart(PSHCLX11CTX pCtx, bool fGrab) +{ + return ShClX11ThreadStartEx(pCtx, "SHCLX11", fGrab); +} + +/** + * Stops the Shared Clipboard Xt even thread. + * + * @note Any requests from this object to get clipboard data from VBox + * *must* have completed or aborted before we are called, as + * otherwise the X11 event loop will still be waiting for the request + * to return and will not be able to terminate. + * + * @returns VBox status code. + * @param pCtx The X11 clipboard context to use. + */ +int ShClX11ThreadStop(PSHCLX11CTX pCtx) +{ + int rc; + /* + * Immediately return if we are not connected to the X server. + */ + if (!pCtx->fHaveX11) + return VINF_SUCCESS; + + LogRel2(("Shared Clipboard: Signalling the X11 event thread to stop\n")); + + /* Write to the "stop" pipe. */ + rc = clipThreadScheduleCall(pCtx, clipThreadSignalStop, (XtPointer)pCtx); + if (RT_FAILURE(rc)) + { + LogRel(("Shared Clipboard: cannot notify X11 event thread on shutdown with %Rrc\n", rc)); + return rc; + } + + LogRel2(("Shared Clipboard: Waiting for X11 event thread to stop ...\n")); + + int rcThread; + rc = RTThreadWait(pCtx->Thread, RT_MS_30SEC /* msTimeout */, &rcThread); + if (RT_SUCCESS(rc)) + rc = rcThread; + if (RT_SUCCESS(rc)) + { + if (pCtx->wakeupPipeRead != 0) + { + close(pCtx->wakeupPipeRead); + pCtx->wakeupPipeRead = 0; + } + + if (pCtx->wakeupPipeWrite != 0) + { + close(pCtx->wakeupPipeWrite); + pCtx->wakeupPipeWrite = 0; + } + } + + if (RT_SUCCESS(rc)) + { + LogRel2(("Shared Clipboard: X11 event thread stopped successfully\n")); + } + else + LogRel(("Shared Clipboard: Stopping X11 event thread failed with %Rrc\n", rc)); + + LogFlowFuncLeaveRC(rc); + return rc; +} +#endif /* !TESTCASE */ + +/** + * Returns the targets supported by VBox. + * + * This will return a list of atoms which tells the caller + * what kind of clipboard formats we support. + * + * @returns VBox status code. + * @param pCtx The X11 clipboard context to use. + * @param atomTypeReturn The type of the data we are returning. + * @param pValReturn A pointer to the data we are returning. This + * should be set to memory allocated by XtMalloc, + * which will be freed later by the Xt toolkit. + * @param pcLenReturn The length of the data we are returning. + * @param piFormatReturn The format (8bit, 16bit, 32bit) of the data we are + * returning. + * @note X11 backend code, called by the XtOwnSelection callback. + */ +static int clipCreateX11Targets(PSHCLX11CTX pCtx, Atom *atomTypeReturn, + XtPointer *pValReturn, + unsigned long *pcLenReturn, + int *piFormatReturn) +{ + const unsigned cFixedTargets = 3; /* See below. */ + + Atom *pAtomTargets = (Atom *)XtMalloc((SHCL_MAX_X11_FORMATS + cFixedTargets) * sizeof(Atom)); + if (!pAtomTargets) + return VERR_NO_MEMORY; + + unsigned cTargets = 0; + SHCLX11FMTIDX idxFmt = NIL_CLIPX11FORMAT; + do + { + idxFmt = clipEnumX11Formats(pCtx->vboxFormats, idxFmt); + if (idxFmt != NIL_CLIPX11FORMAT) + { + pAtomTargets[cTargets] = clipAtomForX11Format(pCtx, idxFmt); + ++cTargets; + } + } while (idxFmt != NIL_CLIPX11FORMAT); + + /* We always offer these fixed targets. */ + pAtomTargets[cTargets] = clipGetAtom(pCtx, "TARGETS"); + pAtomTargets[cTargets + 1] = clipGetAtom(pCtx, "MULTIPLE"); + pAtomTargets[cTargets + 2] = clipGetAtom(pCtx, "TIMESTAMP"); + + *atomTypeReturn = XA_ATOM; + *pValReturn = (XtPointer)pAtomTargets; + *pcLenReturn = cTargets + cFixedTargets; + *piFormatReturn = 32; + + LogFlowFunc(("cTargets=%u\n", cTargets + cFixedTargets)); + + return VINF_SUCCESS; +} + +/** + * Helper for ShClX11RequestDataForX11Callback() that will cache the data returned. + * + * @returns VBox status code. VERR_NO_DATA if no data available. + * @param pCtx The X11 clipboard context to use. + * @param uFmt Clipboard format to read data in. + * @param ppv Returns an allocated buffer with data read on success. + * Needs to be free'd with RTMemFree() by the caller. + * @param pcb Returns the amount of data read (in bytes) on success. + */ +static int shClX11RequestDataForX11CallbackHelper(PSHCLX11CTX pCtx, SHCLFORMAT uFmt, + void **ppv, uint32_t *pcb) +{ + AssertPtrReturn(pCtx, VERR_INVALID_POINTER); + AssertPtrReturn(ppv, VERR_INVALID_POINTER); + AssertPtrReturn(pcb, VERR_INVALID_POINTER); + + LogFlowFunc(("pCtx=%p, uFmt=%#x\n", pCtx, uFmt)); + + int rc = VINF_SUCCESS; + + void *pv = NULL; + uint32_t cb = 0; + + if (uFmt == VBOX_SHCL_FMT_UNICODETEXT) + { + if (pCtx->pvUnicodeCache == NULL) /** @todo r=andy Using string cache here? */ + rc = pCtx->Callbacks.pfnOnRequestDataFromSource(pCtx->pFrontend, uFmt, &pCtx->pvUnicodeCache, &pCtx->cbUnicodeCache, + NULL /* pvUser */); + if ( RT_SUCCESS(rc) + /* Catch misbehaving callbacks. */ + && pCtx->pvUnicodeCache + && pCtx->cbUnicodeCache) + { + pv = RTMemDup(pCtx->pvUnicodeCache, pCtx->cbUnicodeCache); + if (pv) + cb = pCtx->cbUnicodeCache; + else + rc = VERR_NO_MEMORY; + } + } + else + rc = pCtx->Callbacks.pfnOnRequestDataFromSource(pCtx->pFrontend, uFmt, &pv, &cb, NULL /* pvUser */); + + + /* Safey net in case the callbacks above misbehave + * (must return VERR_NO_DATA if no data available). */ + if ( RT_SUCCESS(rc) + && (pv == NULL || cb == 0)) + rc = VERR_NO_DATA; + + if (RT_SUCCESS(rc)) + { + *ppv = pv; + *pcb = cb; + } + + LogFlowFunc(("Returning pv=%p, cb=%RU32, rc=%Rrc\n", pv, cb, rc)); + return rc; +} + +/** + * Satisfies a request from X11 to convert the clipboard text to UTF-8 LF. + * + * @returns VBox status code. VERR_NO_DATA if no data was converted. + * @param pDisplay An X11 display structure, needed for conversions + * performed by Xlib. + * @param pv The text to be converted (UCS-2 with Windows EOLs). + * @param cb The length of the text in @cb in bytes. + * @param atomTypeReturn Where to store the atom for the type of the data + * we are returning. + * @param pValReturn Where to store the pointer to the data we are + * returning. This should be to memory allocated by + * XtMalloc, which will be freed by the Xt toolkit + * later. + * @param pcLenReturn Where to store the length of the data we are + * returning. + * @param piFormatReturn Where to store the bit width (8, 16, 32) of the + * data we are returning. + */ +static int clipConvertUtf16ToX11Data(Display *pDisplay, PRTUTF16 pwszSrc, + size_t cbSrc, Atom *atomTarget, + Atom *atomTypeReturn, + XtPointer *pValReturn, + unsigned long *pcLenReturn, + int *piFormatReturn) +{ + RT_NOREF(pDisplay); + AssertReturn(cbSrc % sizeof(RTUTF16) == 0, VERR_INVALID_PARAMETER); + + const size_t cwcSrc = cbSrc / sizeof(RTUTF16); + if (!cwcSrc) + return VERR_NO_DATA; + + /* This may slightly overestimate the space needed. */ + size_t chDst = 0; + int rc = ShClUtf16LenUtf8(pwszSrc, cwcSrc, &chDst); + if (RT_SUCCESS(rc)) + { + chDst++; /* Add space for terminator. */ + + char *pszDst = (char *)XtMalloc(chDst); + if (pszDst) + { + size_t cbActual = 0; + rc = ShClConvUtf16CRLFToUtf8LF(pwszSrc, cwcSrc, pszDst, chDst, &cbActual); + if (RT_SUCCESS(rc)) + { + *atomTypeReturn = *atomTarget; + *pValReturn = (XtPointer)pszDst; + *pcLenReturn = cbActual + 1 /* Include terminator */; + *piFormatReturn = 8; + } + } + else + rc = VERR_NO_MEMORY; + } + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Satisfies a request from X11 to convert the clipboard HTML fragment to UTF-8. We + * return null-terminated text, but can cope with non-null-terminated input. + * + * @returns VBox status code. + * @param pDisplay An X11 display structure, needed for conversions + * performed by Xlib. + * @param pv The text to be converted (UTF8 with Windows EOLs). + * @param cb The length of the text in @cb in bytes. + * @param atomTypeReturn Where to store the atom for the type of the data + * we are returning. + * @param pValReturn Where to store the pointer to the data we are + * returning. This should be to memory allocated by + * XtMalloc, which will be freed by the Xt toolkit later. + * @param pcLenReturn Where to store the length of the data we are returning. + * @param piFormatReturn Where to store the bit width (8, 16, 32) of the + * data we are returning. + */ +static int clipConvertHtmlToX11Data(Display *pDisplay, const char *pszSrc, + size_t cbSrc, Atom *atomTarget, + Atom *atomTypeReturn, + XtPointer *pValReturn, + unsigned long *pcLenReturn, + int *piFormatReturn) +{ + RT_NOREF(pDisplay, pValReturn); + + /* This may slightly overestimate the space needed. */ + LogFlowFunc(("Source: %s", pszSrc)); + + char *pszDest = (char *)XtMalloc(cbSrc); + if (pszDest == NULL) + return VERR_NO_MEMORY; + + memcpy(pszDest, pszSrc, cbSrc); + + *atomTypeReturn = *atomTarget; + *pValReturn = (XtPointer)pszDest; + *pcLenReturn = cbSrc; + *piFormatReturn = 8; + + return VINF_SUCCESS; +} + + +/** + * Does this atom correspond to one of the two selection types we support? + * + * @param pCtx The X11 clipboard context to use. + * @param selType The atom in question. + */ +static bool clipIsSupportedSelectionType(PSHCLX11CTX pCtx, Atom selType) +{ + return( (selType == clipGetAtom(pCtx, "CLIPBOARD")) + || (selType == clipGetAtom(pCtx, "PRIMARY"))); +} + +/** + * Removes a trailing nul character from a string by adjusting the string + * length. Some X11 applications don't like zero-terminated text... + * + * @param pText The text in question. + * @param pcText The length of the text, adjusted on return. + * @param format The format of the text. + */ +static void clipTrimTrailingNul(XtPointer pText, unsigned long *pcText, + SHCLX11FMT format) +{ + AssertPtrReturnVoid(pText); + AssertPtrReturnVoid(pcText); + AssertReturnVoid((format == SHCLX11FMT_UTF8) || (format == SHCLX11FMT_TEXT) || (format == SHCLX11FMT_HTML)); + + if (((char *)pText)[*pcText - 1] == '\0') + --(*pcText); +} + +static int clipConvertToX11Data(PSHCLX11CTX pCtx, Atom *atomTarget, + Atom *atomTypeReturn, + XtPointer *pValReturn, + unsigned long *pcLenReturn, + int *piFormatReturn) +{ + int rc = VERR_NOT_SUPPORTED; /* Play safe by default. */ + + SHCLX11FMTIDX idxFmtX11 = clipFindX11FormatByAtom(pCtx, *atomTarget); + SHCLX11FMT fmtX11 = clipRealFormatForX11Format(idxFmtX11); + + LogFlowFunc(("vboxFormats=0x%x, idxFmtX11=%u ('%s'), fmtX11=%u\n", + pCtx->vboxFormats, idxFmtX11, g_aFormats[idxFmtX11].pcszAtom, fmtX11)); + +#ifdef LOG_ENABLED + char *pszFmts = ShClFormatsToStrA(pCtx->vboxFormats); + AssertPtrReturn(pszFmts, VERR_NO_MEMORY); + LogRel2(("Shared Clipboard: Converting VBox formats '%s' to '%s' for X11\n", + pszFmts, g_aFormats[idxFmtX11].pcszAtom)); + RTStrFree(pszFmts); +#endif + + void *pv = NULL; + uint32_t cb = 0; + + if ( ( (fmtX11 == SHCLX11FMT_UTF8) + || (fmtX11 == SHCLX11FMT_TEXT) + ) + && (pCtx->vboxFormats & VBOX_SHCL_FMT_UNICODETEXT)) + { + rc = shClX11RequestDataForX11CallbackHelper(pCtx, VBOX_SHCL_FMT_UNICODETEXT, &pv, &cb); + if ( RT_SUCCESS(rc) + && ( (fmtX11 == SHCLX11FMT_UTF8) + || (fmtX11 == SHCLX11FMT_TEXT))) + { + rc = clipConvertUtf16ToX11Data(XtDisplay(pCtx->pWidget), + (PRTUTF16)pv, cb, atomTarget, + atomTypeReturn, pValReturn, + pcLenReturn, piFormatReturn); + } + + if (RT_SUCCESS(rc)) + clipTrimTrailingNul(*(XtPointer *)pValReturn, pcLenReturn, fmtX11); + + RTMemFree(pv); + } + else if ( (fmtX11 == SHCLX11FMT_BMP) + && (pCtx->vboxFormats & VBOX_SHCL_FMT_BITMAP)) + { + rc = shClX11RequestDataForX11CallbackHelper(pCtx, VBOX_SHCL_FMT_BITMAP, &pv, &cb); + if ( RT_SUCCESS(rc) + && (fmtX11 == SHCLX11FMT_BMP)) + { + /* Create a full BMP from it. */ + rc = ShClDibToBmp(pv, cb, (void **)pValReturn, + (size_t *)pcLenReturn); + } + + if (RT_SUCCESS(rc)) + { + *atomTypeReturn = *atomTarget; + *piFormatReturn = 8; + } + + RTMemFree(pv); + } + else if ( (fmtX11 == SHCLX11FMT_HTML) + && (pCtx->vboxFormats & VBOX_SHCL_FMT_HTML)) + { + rc = shClX11RequestDataForX11CallbackHelper(pCtx, VBOX_SHCL_FMT_HTML, &pv, &cb); + if (RT_SUCCESS(rc)) + { + /** + * The common VBox HTML encoding will be UTF-8. + * Before sending it to the X11 clipboard we have to convert it to UTF-8 first. + * + * Strange that we get UTF-16 from the X11 clipboard, but + * in same time we send UTF-8 to X11 clipboard and it works. + ** @todo r=andy Verify this. + */ + rc = clipConvertHtmlToX11Data(XtDisplay(pCtx->pWidget), + (const char*)pv, cb, atomTarget, + atomTypeReturn, pValReturn, + pcLenReturn, piFormatReturn); + if (RT_SUCCESS(rc)) + clipTrimTrailingNul(*(XtPointer *)pValReturn, pcLenReturn, fmtX11); + + RTMemFree(pv); + } + } +#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS + else if (fmtX11 == SHCLX11FMT_URI_LIST) + { + if (pCtx->vboxFormats & VBOX_SHCL_FMT_URI_LIST) + { + rc = shClX11RequestDataForX11CallbackHelper(pCtx, VBOX_SHCL_FMT_URI_LIST, &pv, &cb); + if (RT_SUCCESS(rc)) + { + void *pvDst = (void *)XtMalloc(cb); + if (pvDst) + { + memcpy(pvDst, pv, cb); + + *atomTypeReturn = *atomTarget; + *pValReturn = (XtPointer)pvDst; + *pcLenReturn = cb; + *piFormatReturn = 8; + } + else + rc = VERR_NO_MEMORY; + } + } + /* else not supported yet. */ + } +#endif + else + { + *atomTypeReturn = XT_CONVERT_FAIL; + *pValReturn = (XtPointer)NULL; + *pcLenReturn = 0; + *piFormatReturn = 0; + } + + if (RT_FAILURE(rc)) + { + char *pszFmts2 = ShClFormatsToStrA(pCtx->vboxFormats); + char *pszAtomName = XGetAtomName(XtDisplay(pCtx->pWidget), *atomTarget); + + LogRel(("Shared Clipboard: Converting VBox formats '%s' to '%s' for X11 (idxFmtX11=%u, fmtX11=%u, atomTarget='%s') failed, rc=%Rrc\n", + pszFmts2 ? pszFmts2 : "unknown", g_aFormats[idxFmtX11].pcszAtom, idxFmtX11, fmtX11, pszAtomName ? pszAtomName : "unknown", rc)); + + if (pszFmts2) + RTStrFree(pszFmts2); + if (pszAtomName) + XFree(pszAtomName); + } + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Returns VBox's clipboard data for an X11 client. + * + * @note Callback for XtOwnSelection. + */ +static Boolean clipXtConvertSelectionProc(Widget widget, Atom *atomSelection, + Atom *atomTarget, + Atom *atomTypeReturn, + XtPointer *pValReturn, + unsigned long *pcLenReturn, + int *piFormatReturn) +{ + LogFlowFuncEnter(); + + PSHCLX11CTX pCtx = clipLookupContext(widget); + if (!pCtx) + return False; + + /* Is this the rigt selection (clipboard) we were asked for? */ + if (!clipIsSupportedSelectionType(pCtx, *atomSelection)) + return False; + + int rc; + if (*atomTarget == clipGetAtom(pCtx, "TARGETS")) + rc = clipCreateX11Targets(pCtx, atomTypeReturn, pValReturn, + pcLenReturn, piFormatReturn); + else + rc = clipConvertToX11Data(pCtx, atomTarget, atomTypeReturn, + pValReturn, pcLenReturn, piFormatReturn); + +#if 0 /** @todo Disabled -- crashes when running with tstClipboardGH-X11. */ + XSelectionRequestEvent* pReq = + XtGetSelectionRequest(widget, *atomSelection, (XtRequestId)NULL); + LogFlowFunc(("returning pVBoxWnd=%#x, ownerWnd=%#x, reqWnd=%#x, %RTbool, rc=%Rrc\n", + XtWindow(pCtx->pWidget), pReq->owner, pReq->requestor, RT_SUCCESS(rc), rc)); +#endif + return RT_SUCCESS(rc) ? True : False; +} + +static void clipXtConvertSelectionProcLose(Widget widget, Atom *atomSelection) +{ + RT_NOREF(widget, atomSelection); + LogFlowFuncEnter(); +} + +static void clipXtConvertSelectionProcDone(Widget widget, Atom *atomSelection, Atom *atomTarget) +{ + RT_NOREF(widget, atomSelection, atomTarget); + LogFlowFuncEnter(); +} + +/** + * Structure used to pass information about formats that VBox supports. + */ +typedef struct _CLIPNEWVBOXFORMATS +{ + /** Context information for the X11 clipboard. */ + PSHCLX11CTX pCtx; + /** Formats supported by VBox. */ + SHCLFORMATS Formats; +} CLIPNEWVBOXFORMATS, *PCLIPNEWVBOXFORMATS; + + + +/** + * Invalidates the local cache of the data in the VBox clipboard. + * + * @param pCtx The X11 clipboard context to use. + */ +static void clipInvalidateClipboardCache(PSHCLX11CTX pCtx) +{ + if (pCtx->pvUnicodeCache != NULL) + { + RTMemFree(pCtx->pvUnicodeCache); + pCtx->pvUnicodeCache = NULL; + } +} + +/** + * Takes possession of the X11 clipboard (and middle-button selection). + * + * @param pCtx The X11 clipboard context to use. + * @param uFormats Clipboard formats to set. + */ +static void clipGrabX11Clipboard(PSHCLX11CTX pCtx, SHCLFORMATS uFormats) +{ + LogFlowFuncEnter(); + + /** @ŧodo r=andy The docs say: "the value CurrentTime is not acceptable" here!? */ + if (XtOwnSelection(pCtx->pWidget, clipGetAtom(pCtx, "CLIPBOARD"), + CurrentTime, + clipXtConvertSelectionProc, clipXtConvertSelectionProcLose, clipXtConvertSelectionProcDone)) + { + pCtx->vboxFormats = uFormats; + + /* Grab the middle-button paste selection too. */ + XtOwnSelection(pCtx->pWidget, clipGetAtom(pCtx, "PRIMARY"), + CurrentTime, clipXtConvertSelectionProc, NULL, 0); +#ifndef TESTCASE + /* Xt suppresses these if we already own the clipboard, so send them + * ourselves. */ + XSetSelectionOwner(XtDisplay(pCtx->pWidget), + clipGetAtom(pCtx, "CLIPBOARD"), + XtWindow(pCtx->pWidget), CurrentTime); + XSetSelectionOwner(XtDisplay(pCtx->pWidget), + clipGetAtom(pCtx, "PRIMARY"), + XtWindow(pCtx->pWidget), CurrentTime); +#endif + } +} + +/** + * Worker function for ShClX11ReportFormatsToX11 which runs on the + * event thread. + * + * @param pvUserData Pointer to a CLIPNEWVBOXFORMATS structure containing + * information about the VBox formats available and the + * clipboard context data. Must be freed by the worker. + */ +static void ShClX11ReportFormatsToX11Worker(void *pvUserData, void * /* interval */) +{ + AssertPtrReturnVoid(pvUserData); + + CLIPNEWVBOXFORMATS *pFormats = (CLIPNEWVBOXFORMATS *)pvUserData; + + PSHCLX11CTX pCtx = pFormats->pCtx; + SHCLFORMATS fFormats = pFormats->Formats; + + RTMemFree(pFormats); + +#ifdef LOG_ENABLED + char *pszFmts = ShClFormatsToStrA(fFormats); + AssertPtrReturnVoid(pszFmts); + LogRel2(("Shared Clipboard: Reported available VBox formats %s to X11\n", pszFmts)); + RTStrFree(pszFmts); +#endif + + clipInvalidateClipboardCache(pCtx); + clipGrabX11Clipboard(pCtx, fFormats); + clipResetX11Formats(pCtx); + + LogFlowFuncLeave(); +} + +/** + * Announces new clipboard formats to the X11 clipboard. + * + * @returns VBox status code. + * @param pCtx Context data for the clipboard backend. + * @param uFormats Clipboard formats offered. + */ +int ShClX11ReportFormatsToX11(PSHCLX11CTX pCtx, SHCLFORMATS uFormats) +{ + /* + * Immediately return if we are not connected to the X server. + */ + if (!pCtx->fHaveX11) + return VINF_SUCCESS; + + int rc; + + /* This must be free'd by the worker callback. */ + PCLIPNEWVBOXFORMATS pFormats = (PCLIPNEWVBOXFORMATS)RTMemAlloc(sizeof(CLIPNEWVBOXFORMATS)); + if (pFormats) + { + pFormats->pCtx = pCtx; + pFormats->Formats = uFormats; + rc = clipThreadScheduleCall(pCtx, ShClX11ReportFormatsToX11Worker, + (XtPointer)pFormats); + if (RT_FAILURE(rc)) + RTMemFree(pFormats); + } + else + rc = VERR_NO_MEMORY; + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Converts the data obtained from the X11 clipboard to the required format, + * place it in the buffer supplied and signal that data has arrived. + * + * Converts the text obtained UTF-16LE with Windows EOLs. + * Converts full BMP data to DIB format. + */ +SHCL_X11_DECL(void) clipConvertDataFromX11Worker(void *pClient, void *pvSrc, unsigned cbSrc) +{ + CLIPREADX11CBREQ *pReq = (CLIPREADX11CBREQ *)pClient; + AssertPtrReturnVoid(pReq); + + LogFlowFunc(("pReq->uFmtVBox=%#x, pReq->idxFmtX11=%u, pReq->pCtx=%p\n", pReq->uFmtVBox, pReq->idxFmtX11, pReq->pCtx)); + + LogRel2(("Shared Clipboard: Converting X11 format '%s' to VBox format %#x\n", + g_aFormats[pReq->idxFmtX11].pcszAtom, pReq->uFmtVBox)); + + AssertPtr(pReq->pCtx); + Assert(pReq->uFmtVBox != VBOX_SHCL_FMT_NONE); /* Sanity. */ + + int rc = VINF_SUCCESS; + + void *pvDst = NULL; + size_t cbDst = 0; + +#ifdef VBOX_WITH_SHARED_CLIPBOARD_XT_BUSY + PSHCLX11CTX pCtx = pReq->pCtx; + AssertPtr(pReq->pCtx); + clipSetXtBusy(pCtx, false); + if (clipGetXtNeedsUpdate(pCtx)) + clipQueryX11Targets(pCtx); +#endif + + /* If X11 clipboard buffer has no data, libXt can pass to XtGetSelectionValue() + * callback an empty string, in this case cbSrc is 0. */ + if (pvSrc == NULL || cbSrc == 0) + { + /* The clipboard selection may have changed before we could get it. */ + rc = VERR_NO_DATA; + } + else if (pReq->uFmtVBox == VBOX_SHCL_FMT_UNICODETEXT) + { + /* In which format is the clipboard data? */ + switch (clipRealFormatForX11Format(pReq->idxFmtX11)) + { + case SHCLX11FMT_UTF8: + RT_FALL_THROUGH(); + case SHCLX11FMT_TEXT: + { + size_t cwDst; + /* If we are given broken UTF-8, we treat it as Latin1. */ /** @todo BUGBUG Is this acceptable? */ + if (RT_SUCCESS(RTStrValidateEncodingEx((char *)pvSrc, cbSrc, 0))) + rc = ShClConvUtf8LFToUtf16CRLF((const char *)pvSrc, cbSrc, + (PRTUTF16 *)&pvDst, &cwDst); + else + rc = ShClConvLatin1LFToUtf16CRLF((char *)pvSrc, cbSrc, + (PRTUTF16 *)&pvDst, &cwDst); + if (RT_SUCCESS(rc)) + { + cwDst += 1 /* Include terminator */; + cbDst = cwDst * sizeof(RTUTF16); /* Convert RTUTF16 units to bytes. */ + } + break; + } + + default: + { + rc = VERR_INVALID_PARAMETER; + break; + } + } + } + else if (pReq->uFmtVBox == VBOX_SHCL_FMT_BITMAP) + { + /* In which format is the clipboard data? */ + switch (clipRealFormatForX11Format(pReq->idxFmtX11)) + { + case SHCLX11FMT_BMP: + { + const void *pDib; + size_t cbDibSize; + rc = ShClBmpGetDib((const void *)pvSrc, cbSrc, + &pDib, &cbDibSize); + if (RT_SUCCESS(rc)) + { + pvDst = RTMemAlloc(cbDibSize); + if (!pvDst) + rc = VERR_NO_MEMORY; + else + { + memcpy(pvDst, pDib, cbDibSize); + cbDst = cbDibSize; + } + } + break; + } + + default: + { + rc = VERR_INVALID_PARAMETER; + break; + } + } + } + else if (pReq->uFmtVBox == VBOX_SHCL_FMT_HTML) + { + /* In which format is the clipboard data? */ + switch (clipRealFormatForX11Format(pReq->idxFmtX11)) + { + case SHCLX11FMT_HTML: + { + /* + * The common VBox HTML encoding will be - UTF-8 + * because it more general for HTML formats then UTF-16 + * X11 clipboard returns UTF-16, so before sending it we should + * convert it to UTF-8. + */ + pvDst = NULL; + cbDst = 0; + + /* + * Some applications sends data in UTF-16, some in UTF-8, + * without indication it in MIME. + * + * In case of UTF-16, at least [Open|Libre] Office adds an byte order mark (0xfeff) + * at the start of the clipboard data. + */ + if ( cbSrc >= sizeof(RTUTF16) + && *(PRTUTF16)pvSrc == VBOX_SHCL_UTF16LEMARKER) + { + rc = ShClConvUtf16ToUtf8HTML((PRTUTF16)pvSrc, cbSrc / sizeof(RTUTF16), (char**)&pvDst, &cbDst); + if (RT_SUCCESS(rc)) + { + LogFlowFunc(("UTF-16 Unicode source (%u bytes):\n%ls\n\n", cbSrc, pvSrc)); + LogFlowFunc(("Byte Order Mark = %hx", ((PRTUTF16)pvSrc)[0])); + LogFlowFunc(("UTF-8 Unicode dest (%u bytes):\n%s\n\n", cbDst, pvDst)); + } + else + LogRel(("Shared Clipboard: Converting UTF-16 Unicode failed with %Rrc\n", rc)); + } + else /* Raw data. */ + { + pvDst = RTMemAllocZ(cbSrc + 1 /* '\0' */); + if(pvDst) + { + memcpy(pvDst, pvSrc, cbSrc); + cbDst = cbSrc + 1 /* '\0' */; + } + else + { + rc = VERR_NO_MEMORY; + break; + } + } + + rc = VINF_SUCCESS; + break; + } + + default: + { + rc = VERR_INVALID_PARAMETER; + break; + } + } + } +# ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS + else if (pReq->uFmtVBox == VBOX_SHCL_FMT_URI_LIST) + { + /* In which format is the clipboard data? */ + switch (clipRealFormatForX11Format(pReq->idxFmtX11)) + { + case SHCLX11FMT_URI_LIST: + { + /* For URI lists we only accept valid UTF-8 encodings. */ + if (RT_SUCCESS(RTStrValidateEncodingEx((char *)pvSrc, cbSrc, 0))) + { + /* URI lists on X are strings separated with "\r\n". */ + RTCList<RTCString> lstRootEntries = RTCString((char *)pvSrc, cbSrc).split("\r\n"); + for (size_t i = 0; i < lstRootEntries.size(); ++i) + { + char *pszEntry = RTUriFilePath(lstRootEntries.at(i).c_str()); + AssertPtrBreakStmt(pszEntry, VERR_INVALID_PARAMETER); + + rc = RTStrAAppend((char **)&pvDst, "http://localhost"); + AssertRCBreakStmt(rc, VERR_NO_MEMORY); + cbDst += (uint32_t)strlen(pszEntry); + + + + /** @todo BUGBUG Fix port! */ + /** @todo Add port + UUID (virtual path). */ + + rc = RTStrAAppend((char **)&pvDst, pszEntry); + AssertRCBreakStmt(rc, VERR_NO_MEMORY); + cbDst += (uint32_t)strlen(pszEntry); + + LogFlowFunc(("URI list entry '%s'\n", (char *)pvDst)); + + rc = RTStrAAppend((char **)&pvDst, "\r\n"); + AssertRCBreakStmt(rc, VERR_NO_MEMORY); + cbDst += (uint32_t)strlen("\r\n"); + + RTStrFree(pszEntry); + } + + if (cbDst) + cbDst++; /* Include final (zero) termination. */ + + LogFlowFunc(("URI list: cbDst=%RU32\n", cbDst)); + } + else + rc = VERR_INVALID_PARAMETER; + break; + } + + default: + { + rc = VERR_INVALID_PARAMETER; + break; + } + } + } +# endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */ + else + rc = VERR_NOT_SUPPORTED; + + if (RT_FAILURE(rc)) + LogRel(("Shared Clipboard: Converting X11 format '%s' (idxFmtX11=%u) to VBox format %#x failed, rc=%Rrc\n", + g_aFormats[pReq->idxFmtX11].pcszAtom, pReq->idxFmtX11, pReq->uFmtVBox, rc)); + + SHCLX11READDATAREQ SendData; + RT_ZERO(SendData); + SendData.pReq = pReq->pReq; + SendData.rcCompletion = rc; + + pCtx->Callbacks.pfnOnSendDataToDest(pReq->pCtx->pFrontend, pvDst, cbDst, &SendData); + + RTMemFree(pvDst); + RTMemFree(pReq); + + LogFlowFuncLeaveRC(rc); +} + +/** + * Converts the data obtained from the X11 clipboard to the required format, + * place it in the buffer supplied and signal that data has arrived. + * + * Converts the text obtained UTF-16LE with Windows EOLs. + * Converts full BMP data to DIB format. + */ +SHCL_X11_DECL(void) clipConvertDataFromX11(Widget widget, XtPointer pClient, + Atom * /* selection */, Atom *atomType, + XtPointer pvSrc, long unsigned int *pcLen, + int *piFormat) +{ + RT_NOREF(widget); + if (*atomType == XT_CONVERT_FAIL) /* Xt timeout */ + clipConvertDataFromX11Worker(pClient, NULL, 0); + else + { + CLIPREADX11CBREQ *pReq = (CLIPREADX11CBREQ *)pClient; + if (pReq->pCtx->Callbacks.pfnOnClipboardRead) + { + void *pvData = NULL; + size_t cbData = 0; + int rc = pReq->pCtx->Callbacks.pfnOnClipboardRead(pReq->pCtx->pFrontend, pReq->uFmtVBox, &pvData, &cbData, NULL); + if (RT_SUCCESS(rc)) + { + /* Feed to conversion worker. */ + clipConvertDataFromX11Worker(pClient, pvData, cbData); + RTMemFree(pvData); + } + else + clipConvertDataFromX11Worker(pClient, NULL, 0); + } + else /* Call with current data provided by X (default). */ + clipConvertDataFromX11Worker(pClient, pvSrc, (*pcLen) * (*piFormat) / 8); + } + + XtFree((char *)pvSrc); +} + +static int clipGetSelectionValue(PSHCLX11CTX pCtx, SHCLX11FMTIDX idxFmt, + CLIPREADX11CBREQ *pReq) +{ +#ifndef TESTCASE + XtGetSelectionValue(pCtx->pWidget, clipGetAtom(pCtx, "CLIPBOARD"), + clipAtomForX11Format(pCtx, idxFmt), + clipConvertDataFromX11, + reinterpret_cast<XtPointer>(pReq), + CurrentTime); +#else + tstClipRequestData(pCtx, idxFmt, (void *)pReq); +#endif + + return VINF_SUCCESS; /** @todo Return real rc. */ +} + +/** + * Worker function for ShClX11ReadDataFromX11 which runs on the event thread. + * + * @param pvUserData Pointer to a CLIPREADX11CBREQ structure containing + * information about the clipboard read request. + * Must be free'd by the worker. + */ +static void ShClX11ReadDataFromX11Worker(void *pvUserData, void * /* interval */) +{ + AssertPtrReturnVoid(pvUserData); + + CLIPREADX11CBREQ *pReq = (CLIPREADX11CBREQ *)pvUserData; + SHCLX11CTX *pCtx = pReq->pCtx; + AssertPtrReturnVoid(pCtx); + + LogFlowFunc(("pReq->uFmtVBox=%#x, idxFmtX11=%#x\n", pReq->uFmtVBox, pReq->idxFmtX11)); + + int rc = VERR_NO_DATA; /* VBox thinks we have data and we don't. */ + +#ifdef VBOX_WITH_SHARED_CLIPBOARD_XT_BUSY + const bool fXtBusy = clipGetXtBusy(pCtx); + clipSetXtBusy(pCtx, true); + if (fXtBusy) + { + /* If the clipboard is busy just fend off the request. */ + rc = VERR_TRY_AGAIN; + } + else +#endif + if (pReq->uFmtVBox & VBOX_SHCL_FMT_UNICODETEXT) + { + pReq->idxFmtX11 = pCtx->idxFmtText; + if (pReq->idxFmtX11 != SHCLX11FMT_INVALID) + { + /* Send out a request for the data to the current clipboard owner. */ + rc = clipGetSelectionValue(pCtx, pCtx->idxFmtText, pReq); + } + } + else if (pReq->uFmtVBox & VBOX_SHCL_FMT_BITMAP) + { + pReq->idxFmtX11 = pCtx->idxFmtBmp; + if (pReq->idxFmtX11 != SHCLX11FMT_INVALID) + { + /* Send out a request for the data to the current clipboard owner. */ + rc = clipGetSelectionValue(pCtx, pCtx->idxFmtBmp, pReq); + } + } + else if (pReq->uFmtVBox & VBOX_SHCL_FMT_HTML) + { + pReq->idxFmtX11 = pCtx->idxFmtHTML; + if (pReq->idxFmtX11 != SHCLX11FMT_INVALID) + { + /* Send out a request for the data to the current clipboard owner. */ + rc = clipGetSelectionValue(pCtx, pCtx->idxFmtHTML, pReq); + } + } +#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS + else if (pReq->uFmtVBox & VBOX_SHCL_FMT_URI_LIST) + { + pReq->idxFmtX11 = pCtx->idxFmtURI; + if (pReq->idxFmtX11 != SHCLX11FMT_INVALID) + { + /* Send out a request for the data to the current clipboard owner. */ + rc = clipGetSelectionValue(pCtx, pCtx->idxFmtURI, pReq); + } + } +#endif + else + { +#ifdef VBOX_WITH_SHARED_CLIPBOARD_XT_BUSY + clipSetXtBusy(pCtx, false); +#endif + rc = VERR_NOT_IMPLEMENTED; + } + + if (RT_FAILURE(rc)) + { + /* The clipboard callback was never scheduled, so we must signal + * that the request processing is finished and clean up ourselves. */ + SHCLX11READDATAREQ SendData; + RT_ZERO(SendData); + SendData.pReq = pReq->pReq; + SendData.rcCompletion = rc; + + pCtx->Callbacks.pfnOnSendDataToDest(pReq->pCtx->pFrontend, NULL /* pv */ ,0 /* cb */, &SendData); + RTMemFree(pReq); + } + + LogFlowFuncLeaveRC(rc); +} + +/** + * Called when VBox wants to read the X11 clipboard. + * + * @returns VBox status code. + * @retval VERR_NO_DATA if format is supported but no data is available currently. + * @retval VERR_NOT_IMPLEMENTED if the format is not implemented. + * @param pCtx Context data for the clipboard backend. + * @param uFmt The format that the VBox would like to receive the data in. + * @param pReq Read callback request to use. Will be free'd in the callback on success. + * Otherwise the caller has to free this again on error. + * + * @note We allocate a request structure which must be freed by the worker. + */ +int ShClX11ReadDataFromX11(PSHCLX11CTX pCtx, SHCLFORMAT uFmt, CLIPREADCBREQ *pReq) +{ + AssertPtrReturn(pReq, VERR_INVALID_POINTER); + /* + * Immediately return if we are not connected to the X server. + */ + if (!pCtx->fHaveX11) + return VERR_NO_DATA; + + int rc = VINF_SUCCESS; + + CLIPREADX11CBREQ *pX11Req = (CLIPREADX11CBREQ *)RTMemAllocZ(sizeof(CLIPREADX11CBREQ)); + if (pX11Req) + { + pX11Req->pCtx = pCtx; + pX11Req->uFmtVBox = uFmt; + pX11Req->pReq = pReq; + + /* We use this to schedule a worker function on the event thread. */ + rc = clipThreadScheduleCall(pCtx, ShClX11ReadDataFromX11Worker, (XtPointer)pX11Req); + if (RT_FAILURE(rc)) + RTMemFree(pX11Req); + } + else + rc = VERR_NO_MEMORY; + + LogFlowFuncLeaveRC(rc); + return rc; +} diff --git a/src/VBox/GuestHost/SharedClipboard/testcase/Makefile.kmk b/src/VBox/GuestHost/SharedClipboard/testcase/Makefile.kmk new file mode 100644 index 00000000..b91f356d --- /dev/null +++ b/src/VBox/GuestHost/SharedClipboard/testcase/Makefile.kmk @@ -0,0 +1,76 @@ +# $Id: Makefile.kmk $ +## @file +# Sub-Makefile for the Shared Clipboard Guest/Host testcases. +# + +# +# Copyright (C) 2011-2022 Oracle and/or its affiliates. +# +# This file is part of VirtualBox base platform packages, as +# available from https://www.virtualbox.org. +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation, in version 3 of the +# License. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, see <https://www.gnu.org/licenses>. +# +# SPDX-License-Identifier: GPL-3.0-only +# + +SUB_DEPTH = ../../../../.. +include $(KBUILD_PATH)/subheader.kmk + +if defined(VBOX_WITH_TESTCASES) && !defined(VBOX_ONLY_ADDITIONS) && !defined(VBOX_ONLY_SDK) + if1of ($(KBUILD_TARGET), freebsd linux netbsd openbsd solaris) + + PROGRAMS += tstClipboardGH-X11 tstClipboardGH-X11Smoke + TESTING += \ + $(tstClipboardGH-X11_0_OUTDIR)/tstClipboardGH-X11.run \ + $(tstClipboardGH-X11_0_OUTDIR)/tstClipboardGH-X11Smoke.run + + tstClipboardGH-X11_TEMPLATE = VBOXR3TSTEXE + tstClipboardGH-X11_DEFS = VBOX_WITH_HGCM UNIT_TEST TESTCASE + tstClipboardGH-X11_SOURCES = \ + tstClipboardGH-X11.cpp \ + ../clipboard-x11.cpp \ + ../clipboard-common.cpp + tstClipboardGH-X11_CXXFLAGS += -Wno-array-bounds + tstClipboardGH-X11_LIBS = X11 Xt + tstClipboardGH-X11_CLEAN = $(tstClipboardGH-X11_0_OUTDIR)/tstClipboardGH-X11.run + + tstClipboardGH-X11Smoke_TEMPLATE = VBOXR3TSTEXE + tstClipboardGH-X11Smoke_DEFS = VBOX_WITH_HGCM SMOKETEST + tstClipboardGH-X11Smoke_SOURCES = \ + tstClipboardGH-X11Smoke.cpp \ + ../clipboard-x11.cpp \ + ../clipboard-common.cpp + tstClipboardGH-X11Smoke_LIBPATH = $(VBOX_LIBPATH_X11) + tstClipboardGH-X11Smoke_LIBS = X11 Xt + tstClipboardGH-X11Smoke_CLEAN = $(tstClipboardGH-X11Smoke_0_OUTDIR)/tstClipboardGH-X11Smoke.run + + $$(tstClipboardGH-X11_0_OUTDIR)/tstClipboardGH-X11.run: $$(tstClipboardGH-X11_1_STAGE_TARGET) + export VBOX_LOG_DEST=nofile; $(tstClipboardGH-X11_1_STAGE_TARGET) quiet + $(QUIET)$(APPEND) -t "$@" "done" + + $$(tstClipboardGH-X11Smoke_0_OUTDIR)/tstClipboardGH-X11Smoke.run: $$(tstClipboardGH-X11Smoke_1_STAGE_TARGET) + export VBOX_LOG_DEST=nofile; $(tstClipboardGH-X11Smoke_1_STAGE_TARGET) quiet + $(QUIET)$(APPEND) -t "$@" "done" + + if defined(VBOX_WITH_QTGUI) + include $(PATH_SUB_CURRENT)/tstClipboardQt/Makefile.kmk + endif + + + endif +endif + +include $(FILE_KBUILD_SUB_FOOTER) + diff --git a/src/VBox/GuestHost/SharedClipboard/testcase/tstClipboardGH-X11.cpp b/src/VBox/GuestHost/SharedClipboard/testcase/tstClipboardGH-X11.cpp new file mode 100644 index 00000000..10dcfa6e --- /dev/null +++ b/src/VBox/GuestHost/SharedClipboard/testcase/tstClipboardGH-X11.cpp @@ -0,0 +1,941 @@ +/* $Id: tstClipboardGH-X11.cpp $ */ +/** @file + * Shared Clipboard guest/host X11 code test cases. + */ + +/* + * Copyright (C) 2011-2022 Oracle and/or its affiliates. + * + * This file is part of VirtualBox base platform packages, as + * available from https://www.virtualbox.org. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, in version 3 of the + * License. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <https://www.gnu.org/licenses>. + * + * SPDX-License-Identifier: GPL-3.0-only + */ + +#include <VBox/GuestHost/SharedClipboard.h> +#include <VBox/GuestHost/SharedClipboard-x11.h> +#include <VBox/GuestHost/clipboard-helper.h> +#include <VBox/HostServices/VBoxClipboardSvc.h> + +#include <iprt/assert.h> +#include <iprt/string.h> +#include <iprt/test.h> +#include <iprt/utf16.h> + +#include <poll.h> +#include <X11/Xatom.h> + + +/********************************************************************************************************************************* +* Externals * +*********************************************************************************************************************************/ +extern SHCLX11FMTTABLE g_aFormats[]; + +extern void clipUpdateX11Targets(PSHCLX11CTX pCtx, SHCLX11FMTIDX *pTargets, size_t cTargets); +extern void clipReportEmpty(PSHCLX11CTX pCtx); +extern void clipConvertDataFromX11Worker(void *pClient, void *pvSrc, unsigned cbSrc); +extern SHCLX11FMTIDX clipGetTextFormatFromTargets(PSHCLX11CTX pCtx, SHCLX11FMTIDX *pTargets, size_t cTargets); +extern SHCLX11FMT clipRealFormatForX11Format(SHCLX11FMTIDX uFmtIdx); +extern Atom clipGetAtom(PSHCLX11CTX pCtx, const char *pcszName); +extern void clipQueryX11Targets(PSHCLX11CTX pCtx); +extern size_t clipReportMaxX11Formats(void); + + +/********************************************************************************************************************************* +* Internal prototypes * +*********************************************************************************************************************************/ +static SHCLX11FMTIDX tstClipFindX11FormatByAtomText(const char *pcszAtom); + + +/********************************************************************************************************************************* +* Prototypes, used for testcases by clipboard-x11.cpp * +*********************************************************************************************************************************/ +void tstRequestTargets(SHCLX11CTX* pCtx); +void tstClipRequestData(PSHCLX11CTX pCtx, SHCLX11FMTIDX target, void *closure); +void tstThreadScheduleCall(void (*proc)(void *, void *), void *client_data); + + +/********************************************************************************************************************************* +* Own callback implementations * +*********************************************************************************************************************************/ +extern DECLCALLBACK(void) clipQueryX11TargetsCallback(Widget widget, XtPointer pClient, + Atom * /* selection */, Atom *atomType, + XtPointer pValue, long unsigned int *pcLen, + int *piFormat); + + +/********************************************************************************************************************************* +* Defines * +*********************************************************************************************************************************/ +#define TESTCASE_WIDGET_ID (Widget)0xffff + + +/* For the purpose of the test case, we just execute the procedure to be + * scheduled, as we are running single threaded. */ +void tstThreadScheduleCall(void (*proc)(void *, void *), void *client_data) +{ + proc(client_data, NULL); +} + +/* The data in the simulated VBox clipboard. */ +static int g_tst_rcDataVBox = VINF_SUCCESS; +static void *g_tst_pvDataVBox = NULL; +static uint32_t g_tst_cbDataVBox = 0; + +/* Set empty data in the simulated VBox clipboard. */ +static void tstClipEmptyVBox(PSHCLX11CTX pCtx, int retval) +{ + g_tst_rcDataVBox = retval; + RTMemFree(g_tst_pvDataVBox); + g_tst_pvDataVBox = NULL; + g_tst_cbDataVBox = 0; + ShClX11ReportFormatsToX11(pCtx, 0); +} + +/* Set the data in the simulated VBox clipboard. */ +static int tstClipSetVBoxUtf16(PSHCLX11CTX pCtx, int retval, + const char *pcszData, size_t cb) +{ + PRTUTF16 pwszData = NULL; + size_t cwData = 0; + int rc = RTStrToUtf16Ex(pcszData, RTSTR_MAX, &pwszData, 0, &cwData); + if (RT_FAILURE(rc)) + return rc; + AssertReturn(cb <= cwData * 2 + 2, VERR_BUFFER_OVERFLOW); + void *pv = RTMemDup(pwszData, cb); + RTUtf16Free(pwszData); + if (pv == NULL) + return VERR_NO_MEMORY; + if (g_tst_pvDataVBox) + RTMemFree(g_tst_pvDataVBox); + g_tst_rcDataVBox = retval; + g_tst_pvDataVBox = pv; + g_tst_cbDataVBox = cb; + ShClX11ReportFormatsToX11(pCtx, VBOX_SHCL_FMT_UNICODETEXT); + return VINF_SUCCESS; +} + +Display *XtDisplay(Widget w) { NOREF(w); return (Display *) 0xffff; } + +void XtAppSetExitFlag(XtAppContext app_context) { NOREF(app_context); } + +void XtDestroyWidget(Widget w) { NOREF(w); } + +XtAppContext XtCreateApplicationContext(void) { return (XtAppContext)0xffff; } + +void XtDestroyApplicationContext(XtAppContext app_context) { NOREF(app_context); } + +void XtToolkitInitialize(void) {} + +Boolean XtToolkitThreadInitialize(void) { return True; } + +Display *XtOpenDisplay(XtAppContext app_context, + _Xconst _XtString display_string, + _Xconst _XtString application_name, + _Xconst _XtString application_class, + XrmOptionDescRec *options, Cardinal num_options, + int *argc, char **argv) +{ + RT_NOREF8(app_context, display_string, application_name, application_class, options, num_options, argc, argv); + return (Display *)0xffff; +} + +Widget XtVaAppCreateShell(_Xconst _XtString application_name, _Xconst _XtString application_class, + WidgetClass widget_class, Display *display, ...) +{ + RT_NOREF(application_name, application_class, widget_class, display); + return TESTCASE_WIDGET_ID; +} + +void XtSetMappedWhenManaged(Widget widget, _XtBoolean mapped_when_managed) { RT_NOREF(widget, mapped_when_managed); } + +void XtRealizeWidget(Widget widget) { NOREF(widget); } + +XtInputId XtAppAddInput(XtAppContext app_context, int source, XtPointer condition, XtInputCallbackProc proc, XtPointer closure) +{ + RT_NOREF(app_context, source, condition, proc, closure); + return 0xffff; +} + +/* Atoms we need other than the formats we support. */ +static const char *g_tst_apszSupAtoms[] = +{ + "PRIMARY", "CLIPBOARD", "TARGETS", "MULTIPLE", "TIMESTAMP" +}; + +/* This just looks for the atom names in a couple of tables and returns an + * index with an offset added. */ +Atom XInternAtom(Display *, const char *pcsz, int) +{ + Atom atom = 0; + size_t const cFormats = clipReportMaxX11Formats(); + size_t i; + for (i = 0; i < cFormats; ++i) + { + if (!strcmp(pcsz, g_aFormats[i].pcszAtom)) + atom = (Atom) (i + 0x1000); + } + for (i = 0; i < RT_ELEMENTS(g_tst_apszSupAtoms); ++i) + if (!strcmp(pcsz, g_tst_apszSupAtoms[i])) + atom = (Atom) (i + 0x2000); + Assert(atom); /* Have we missed any atoms? */ + return atom; +} + +/* Take a request for the targets we are currently offering. */ +static SHCLX11FMTIDX g_tst_aSelTargetsIdx[10] = { 0 }; +static size_t g_tst_cTargets = 0; + +void tstRequestTargets(SHCLX11CTX* pCtx) +{ + clipUpdateX11Targets(pCtx, g_tst_aSelTargetsIdx, g_tst_cTargets); +} + +/* The current values of the X selection, which will be returned to the + * XtGetSelectionValue callback. */ +static Atom g_tst_atmSelType = 0; +static const void *g_tst_pSelData = NULL; +static unsigned long g_tst_cSelData = 0; +static int g_tst_selFormat = 0; + +void tstClipRequestData(PSHCLX11CTX pCtx, SHCLX11FMTIDX target, void *closure) +{ + RT_NOREF(pCtx); + unsigned long count = 0; + int format = 0; + if (target != g_tst_aSelTargetsIdx[0]) + { + clipConvertDataFromX11Worker(closure, NULL, 0); /* Could not convert to target. */ + return; + } + void *pValue = NULL; + pValue = g_tst_pSelData ? RTMemDup(g_tst_pSelData, g_tst_cSelData) : NULL; + count = g_tst_pSelData ? g_tst_cSelData : 0; + format = g_tst_selFormat; + if (!pValue) + { + count = 0; + format = 0; + } + clipConvertDataFromX11Worker(closure, pValue, count * format / 8); + if (pValue) + RTMemFree(pValue); +} + +/* The formats currently on offer from X11 via the shared clipboard. */ +static uint32_t g_tst_uX11Formats = 0; + +static uint32_t tstClipQueryFormats(void) +{ + return g_tst_uX11Formats; +} + +static void tstClipInvalidateFormats(void) +{ + g_tst_uX11Formats = ~0; +} + +/* Does our clipboard code currently own the selection? */ +static bool g_tst_fOwnsSel = false; +/* The procedure that is called when we should convert the selection to a + * given format. */ +static XtConvertSelectionProc g_tst_pfnSelConvert = NULL; +/* The procedure which is called when we lose the selection. */ +static XtLoseSelectionProc g_tst_pfnSelLose = NULL; +/* The procedure which is called when the selection transfer has completed. */ +static XtSelectionDoneProc g_tst_pfnSelDone = NULL; + +Boolean XtOwnSelection(Widget widget, Atom selection, Time time, + XtConvertSelectionProc convert, + XtLoseSelectionProc lose, + XtSelectionDoneProc done) +{ + RT_NOREF(widget, time); + if (selection != XInternAtom(NULL, "CLIPBOARD", 0)) + return True; /* We don't really care about this. */ + g_tst_fOwnsSel = true; /* Always succeed. */ + g_tst_pfnSelConvert = convert; + g_tst_pfnSelLose = lose; + g_tst_pfnSelDone = done; + return True; +} + +void XtDisownSelection(Widget widget, Atom selection, Time time) +{ + RT_NOREF(widget, time, selection); + g_tst_fOwnsSel = false; + g_tst_pfnSelConvert = NULL; + g_tst_pfnSelLose = NULL; + g_tst_pfnSelDone = NULL; +} + +/* Request the shared clipboard to convert its data to a given format. */ +static bool tstClipConvertSelection(const char *pcszTarget, Atom *type, + XtPointer *value, unsigned long *length, + int *format) +{ + Atom target = XInternAtom(NULL, pcszTarget, 0); + if (target == 0) + return false; + /* Initialise all return values in case we make a quick exit. */ + *type = XA_STRING; + *value = NULL; + *length = 0; + *format = 0; + if (!g_tst_fOwnsSel) + return false; + if (!g_tst_pfnSelConvert) + return false; + Atom clipAtom = XInternAtom(NULL, "CLIPBOARD", 0); + if (!g_tst_pfnSelConvert(TESTCASE_WIDGET_ID, &clipAtom, &target, type, + value, length, format)) + return false; + if (g_tst_pfnSelDone) + g_tst_pfnSelDone(TESTCASE_WIDGET_ID, &clipAtom, &target); + return true; +} + +/* Set the current X selection data */ +static void tstClipSetSelectionValues(const char *pcszTarget, Atom type, + const void *data, + unsigned long count, int format) +{ + Atom clipAtom = XInternAtom(NULL, "CLIPBOARD", 0); + g_tst_aSelTargetsIdx[0] = tstClipFindX11FormatByAtomText(pcszTarget); + g_tst_cTargets = 1; + g_tst_atmSelType = type; + g_tst_pSelData = data; + g_tst_cSelData = count; + g_tst_selFormat = format; + if (g_tst_pfnSelLose) + g_tst_pfnSelLose(TESTCASE_WIDGET_ID, &clipAtom); + g_tst_fOwnsSel = false; +} + +static void tstClipSendTargetUpdate(PSHCLX11CTX pCtx) +{ + clipQueryX11Targets(pCtx); +} + +/* Configure if and how the X11 TARGETS clipboard target will fail. */ +static void tstClipSetTargetsFailure(void) +{ + g_tst_cTargets = 0; +} + +char *XtMalloc(Cardinal size) +{ + return (char *) RTMemAlloc(size); +} + +void XtFree(char *ptr) +{ + RTMemFree((void *)ptr); +} + +char *XGetAtomName(Display *display, Atom atom) +{ + RT_NOREF(display); + const char *pcszName = NULL; + if (atom < 0x1000) + return NULL; + if (0x1000 <= atom && atom < 0x2000) + { + unsigned index = atom - 0x1000; + AssertReturn(index < clipReportMaxX11Formats(), NULL); + pcszName = g_aFormats[index].pcszAtom; + } + else + { + unsigned index = atom - 0x2000; + AssertReturn(index < RT_ELEMENTS(g_tst_apszSupAtoms), NULL); + pcszName = g_tst_apszSupAtoms[index]; + } + return (char *)RTMemDup(pcszName, sizeof(pcszName) + 1); +} + +int XFree(void *data) +{ + RTMemFree(data); + return 0; +} + +void XFreeStringList(char **list) +{ + if (list) + RTMemFree(*list); + RTMemFree(list); +} + +#define TESTCASE_MAX_BUF_SIZE 256 + +static int g_tst_rcCompleted = VINF_SUCCESS; +static int g_tst_cbCompleted = 0; +static CLIPREADCBREQ *g_tst_pCompletedReq = NULL; +static char g_tst_abCompletedBuf[TESTCASE_MAX_BUF_SIZE]; + +static DECLCALLBACK(int) tstShClReportFormatsCallback(PSHCLCONTEXT pCtx, uint32_t fFormats, void *pvUser) +{ + RT_NOREF(pCtx, pvUser); + g_tst_uX11Formats = fFormats; + return VINF_SUCCESS; +} + +static DECLCALLBACK(int) tstShClOnRequestDataFromSourceCallback(PSHCLCONTEXT pCtx, SHCLFORMAT uFmt, void **ppv, uint32_t *pcb, void *pvUser) +{ + RT_NOREF(pCtx, uFmt, pvUser); + *pcb = g_tst_cbDataVBox; + if (g_tst_pvDataVBox != NULL) + { + void *pv = RTMemDup(g_tst_pvDataVBox, g_tst_cbDataVBox); + *ppv = pv; + return pv != NULL ? g_tst_rcDataVBox : VERR_NO_MEMORY; + } + *ppv = NULL; + return g_tst_rcDataVBox; +} + +static DECLCALLBACK(int) tstShClOnSendDataToDestCallback(PSHCLCONTEXT pCtx, void *pv, uint32_t cb, void *pvUser) +{ + RT_NOREF(pCtx); + + PSHCLX11READDATAREQ pData = (PSHCLX11READDATAREQ)pvUser; + + if (cb <= TESTCASE_MAX_BUF_SIZE) + { + g_tst_rcCompleted = pData->rcCompletion; + if (cb != 0) + memcpy(g_tst_abCompletedBuf, pv, cb); + } + else + g_tst_rcCompleted = VERR_BUFFER_OVERFLOW; + g_tst_cbCompleted = cb; + g_tst_pCompletedReq = pData->pReq; + + return VINF_SUCCESS; +} + +/** + * Looks up the X11 format matching a given X11 atom text. + * + * @returns the format on success, NIL_CLIPX11FORMAT on failure + * @param pcszAtom Atom text to look up format for. + */ +static SHCLX11FMTIDX tstClipFindX11FormatByAtomText(const char *pcszAtom) +{ + const size_t j = clipReportMaxX11Formats(); + + for (unsigned i = 0; i < j; ++i) + { + if (!strcmp(g_aFormats[i].pcszAtom, pcszAtom)) + return i; + } + return NIL_CLIPX11FORMAT; +} + +static bool tstClipTextFormatConversion(PSHCLX11CTX pCtx) +{ + bool fSuccess = true; + SHCLX11FMTIDX targets[2]; + SHCLX11FMTIDX x11Format; + targets[0] = tstClipFindX11FormatByAtomText("text/plain"); + targets[1] = tstClipFindX11FormatByAtomText("image/bmp"); + x11Format = clipGetTextFormatFromTargets(pCtx, targets, 2); + if (clipRealFormatForX11Format(x11Format) != SHCLX11FMT_TEXT) + fSuccess = false; + targets[0] = tstClipFindX11FormatByAtomText("UTF8_STRING"); + targets[1] = tstClipFindX11FormatByAtomText("text/plain"); + x11Format = clipGetTextFormatFromTargets(pCtx, targets, 2); + if (clipRealFormatForX11Format(x11Format) != SHCLX11FMT_UTF8) + fSuccess = false; + return fSuccess; +} + +static void tstClipGetCompletedRequest(int *prc, char ** ppc, uint32_t *pcb, CLIPREADCBREQ **ppReq) +{ + *prc = g_tst_rcCompleted; + *ppc = g_tst_abCompletedBuf; + *pcb = g_tst_cbCompleted; + *ppReq = g_tst_pCompletedReq; +} + +static void tstStringFromX11(RTTEST hTest, PSHCLX11CTX pCtx, + const char *pcszExp, int rcExp) +{ + bool retval = true; + tstClipSendTargetUpdate(pCtx); + if (tstClipQueryFormats() != VBOX_SHCL_FMT_UNICODETEXT) + { + RTTestFailed(hTest, "Wrong targets reported: %02X\n", tstClipQueryFormats()); + } + else + { + char *pc; + CLIPREADCBREQ *pReq = (CLIPREADCBREQ *)&pReq, *pReqRet = NULL; + ShClX11ReadDataFromX11(pCtx, VBOX_SHCL_FMT_UNICODETEXT, pReq); + int rc = VINF_SUCCESS; + uint32_t cbActual = 0; + tstClipGetCompletedRequest(&rc, &pc, &cbActual, &pReqRet); + if (rc != rcExp) + RTTestFailed(hTest, "Wrong return code, expected %Rrc, got %Rrc\n", + rcExp, rc); + else if (pReqRet != pReq) + RTTestFailed(hTest, "Wrong returned request data, expected %p, got %p\n", + pReq, pReqRet); + else if (RT_FAILURE(rcExp)) + retval = true; + else + { + RTUTF16 wcExp[TESTCASE_MAX_BUF_SIZE / 2]; + RTUTF16 *pwcExp = wcExp; + size_t cwc = 0; + rc = RTStrToUtf16Ex(pcszExp, RTSTR_MAX, &pwcExp, + RT_ELEMENTS(wcExp), &cwc); + size_t cbExp = cwc * 2 + 2; + AssertRC(rc); + if (RT_SUCCESS(rc)) + { + if (cbActual != cbExp) + { + RTTestFailed(hTest, "Returned string is the wrong size, string \"%.*ls\", size %u, expected \"%s\", size %u\n", + RT_MIN(TESTCASE_MAX_BUF_SIZE, cbActual), pc, cbActual, + pcszExp, cbExp); + } + else + { + if (memcmp(pc, wcExp, cbExp) == 0) + retval = true; + else + RTTestFailed(hTest, "Returned string \"%.*ls\" does not match expected string \"%s\"\n", + TESTCASE_MAX_BUF_SIZE, pc, pcszExp); + } + } + } + } + if (!retval) + RTTestFailureDetails(hTest, "Expected: string \"%s\", rc %Rrc\n", + pcszExp, rcExp); +} + +static void tstLatin1FromX11(RTTEST hTest, PSHCLX11CTX pCtx, + const char *pcszExp, int rcExp) +{ + bool retval = false; + tstClipSendTargetUpdate(pCtx); + if (tstClipQueryFormats() != VBOX_SHCL_FMT_UNICODETEXT) + RTTestFailed(hTest, "Wrong targets reported: %02X\n", + tstClipQueryFormats()); + else + { + char *pc; + CLIPREADCBREQ *pReq = (CLIPREADCBREQ *)&pReq, *pReqRet = NULL; + ShClX11ReadDataFromX11(pCtx, VBOX_SHCL_FMT_UNICODETEXT, pReq); + int rc = VINF_SUCCESS; + uint32_t cbActual = 0; + tstClipGetCompletedRequest(&rc, &pc, &cbActual, &pReqRet); + if (rc != rcExp) + RTTestFailed(hTest, "Wrong return code, expected %Rrc, got %Rrc\n", + rcExp, rc); + else if (pReqRet != pReq) + RTTestFailed(hTest, "Wrong returned request data, expected %p, got %p\n", + pReq, pReqRet); + else if (RT_FAILURE(rcExp)) + retval = true; + else + { + RTUTF16 wcExp[TESTCASE_MAX_BUF_SIZE / 2]; + //RTUTF16 *pwcExp = wcExp; - unused + size_t cwc; + for (cwc = 0; cwc == 0 || pcszExp[cwc - 1] != '\0'; ++cwc) + wcExp[cwc] = pcszExp[cwc]; + size_t cbExp = cwc * 2; + if (cbActual != cbExp) + { + RTTestFailed(hTest, "Returned string is the wrong size, string \"%.*ls\", size %u, expected \"%s\", size %u\n", + RT_MIN(TESTCASE_MAX_BUF_SIZE, cbActual), pc, cbActual, + pcszExp, cbExp); + } + else + { + if (memcmp(pc, wcExp, cbExp) == 0) + retval = true; + else + RTTestFailed(hTest, "Returned string \"%.*ls\" does not match expected string \"%s\"\n", + TESTCASE_MAX_BUF_SIZE, pc, pcszExp); + } + } + } + if (!retval) + RTTestFailureDetails(hTest, "Expected: string \"%s\", rc %Rrc\n", + pcszExp, rcExp); +} + +static void tstStringFromVBox(RTTEST hTest, PSHCLX11CTX pCtx, const char *pcszTarget, Atom typeExp, const char *valueExp) +{ + RT_NOREF(pCtx); + bool retval = false; + Atom type; + XtPointer value = NULL; + unsigned long length; + int format; + size_t lenExp = strlen(valueExp); + if (tstClipConvertSelection(pcszTarget, &type, &value, &length, &format)) + { + if ( type != typeExp + || length != lenExp + || format != 8 + || memcmp((const void *) value, (const void *)valueExp, + lenExp)) + { + RTTestFailed(hTest, "Bad data: type %d, (expected %d), length %u, (expected %u), format %d (expected %d), value \"%.*s\" (expected \"%.*s\")\n", + type, typeExp, length, lenExp, format, 8, + RT_MIN(length, 20), value, RT_MIN(lenExp, 20), valueExp); + } + else + retval = true; + } + else + RTTestFailed(hTest, "Conversion failed\n"); + XtFree((char *)value); + if (!retval) + RTTestFailureDetails(hTest, "Conversion to %s, expected \"%s\"\n", + pcszTarget, valueExp); +} + +static void tstNoX11(PSHCLX11CTX pCtx, const char *pcszTestCtx) +{ + CLIPREADCBREQ *pReq = (CLIPREADCBREQ *)&pReq; + int rc = ShClX11ReadDataFromX11(pCtx, VBOX_SHCL_FMT_UNICODETEXT, pReq); + RTTESTI_CHECK_MSG(rc == VERR_NO_DATA, ("context: %s\n", pcszTestCtx)); +} + +static void tstStringFromVBoxFailed(RTTEST hTest, PSHCLX11CTX pCtx, const char *pcszTarget) +{ + RT_NOREF(pCtx); + Atom type; + XtPointer value = NULL; + unsigned long length; + int format; + RTTEST_CHECK_MSG(hTest, !tstClipConvertSelection(pcszTarget, &type, &value, + &length, &format), + (hTest, "Conversion to target %s, should have failed but didn't, returned type %d, length %u, format %d, value \"%.*s\"\n", + pcszTarget, type, length, format, RT_MIN(length, 20), + value)); + XtFree((char *)value); +} + +static void tstNoSelectionOwnership(PSHCLX11CTX pCtx, const char *pcszTestCtx) +{ + RT_NOREF(pCtx); + RTTESTI_CHECK_MSG(!g_tst_fOwnsSel, ("context: %s\n", pcszTestCtx)); +} + +static void tstBadFormatRequestFromHost(RTTEST hTest, PSHCLX11CTX pCtx) +{ + tstClipSetSelectionValues("UTF8_STRING", XA_STRING, "hello world", + sizeof("hello world"), 8); + tstClipSendTargetUpdate(pCtx); + if (tstClipQueryFormats() != VBOX_SHCL_FMT_UNICODETEXT) + RTTestFailed(hTest, "Wrong targets reported: %02X\n", + tstClipQueryFormats()); + else + { + char *pc; + CLIPREADCBREQ *pReq = (CLIPREADCBREQ *)&pReq, *pReqRet = NULL; + ShClX11ReadDataFromX11(pCtx, 0xF000 /* vboxFormat */, pReq); /* Bad format. */ + int rc = VINF_SUCCESS; + uint32_t cbActual = 0; + tstClipGetCompletedRequest(&rc, &pc, &cbActual, &pReqRet); + if (rc != VERR_NOT_IMPLEMENTED) + RTTestFailed(hTest, "Wrong return code, expected VERR_NOT_IMPLEMENTED, got %Rrc\n", + rc); + tstClipSetSelectionValues("", XA_STRING, "", sizeof(""), 8); + tstClipSendTargetUpdate(pCtx); + if (tstClipQueryFormats() == VBOX_SHCL_FMT_UNICODETEXT) + RTTestFailed(hTest, "Failed to report targets after bad host request.\n"); + } +} + +int main() +{ + /* + * Init the runtime, test and say hello. + */ + RTTEST hTest; + int rc = RTTestInitAndCreate("tstClipboardGH-X11", &hTest); + if (RT_FAILURE(rc)) + return RTEXITCODE_FAILURE; + RTTestBanner(hTest); + + /* + * Run the tests. + */ + SHCLCALLBACKS Callbacks; + RT_ZERO(Callbacks); + Callbacks.pfnReportFormats = tstShClReportFormatsCallback; + Callbacks.pfnOnRequestDataFromSource = tstShClOnRequestDataFromSourceCallback; + Callbacks.pfnOnSendDataToDest = tstShClOnSendDataToDestCallback; + + SHCLX11CTX X11Ctx; + rc = ShClX11Init(&X11Ctx, &Callbacks, NULL /* pParent */, false /* fHeadless */); + AssertRCReturn(rc, RTEXITCODE_FAILURE); + + char *pc; + uint32_t cbActual; + CLIPREADCBREQ *pReq = (CLIPREADCBREQ *)&pReq, *pReqRet = NULL; + + /* UTF-8 from X11 */ + RTTestSub(hTest, "reading UTF-8 from X11"); + /* Simple test */ + tstClipSetSelectionValues("UTF8_STRING", XA_STRING, "hello world", + sizeof("hello world"), 8); + tstStringFromX11(hTest, &X11Ctx, "hello world", VINF_SUCCESS); + /* With an embedded carriage return */ + tstClipSetSelectionValues("text/plain;charset=UTF-8", XA_STRING, + "hello\nworld", sizeof("hello\nworld"), 8); + tstStringFromX11(hTest, &X11Ctx, "hello\r\nworld", VINF_SUCCESS); + /* With an embedded CRLF */ + tstClipSetSelectionValues("text/plain;charset=UTF-8", XA_STRING, + "hello\r\nworld", sizeof("hello\r\nworld"), 8); + tstStringFromX11(hTest, &X11Ctx, "hello\r\r\nworld", VINF_SUCCESS); + /* With an embedded LFCR */ + tstClipSetSelectionValues("text/plain;charset=UTF-8", XA_STRING, + "hello\n\rworld", sizeof("hello\n\rworld"), 8); + tstStringFromX11(hTest, &X11Ctx, "hello\r\n\rworld", VINF_SUCCESS); + /* An empty string */ + tstClipSetSelectionValues("text/plain;charset=utf-8", XA_STRING, "", + sizeof(""), 8); + tstStringFromX11(hTest, &X11Ctx, "", VINF_SUCCESS); + /* With an embedded UTF-8 character. */ + tstClipSetSelectionValues("STRING", XA_STRING, + "100\xE2\x82\xAC" /* 100 Euro */, + sizeof("100\xE2\x82\xAC"), 8); + tstStringFromX11(hTest, &X11Ctx, "100\xE2\x82\xAC", VINF_SUCCESS); + /* A non-zero-terminated string */ + tstClipSetSelectionValues("TEXT", XA_STRING, + "hello world", sizeof("hello world") - 1, 8); + tstStringFromX11(hTest, &X11Ctx, "hello world", VINF_SUCCESS); + + /* Latin1 from X11 */ + RTTestSub(hTest, "reading Latin1 from X11"); + /* Simple test */ + tstClipSetSelectionValues("STRING", XA_STRING, "Georges Dupr\xEA", + sizeof("Georges Dupr\xEA"), 8); + tstLatin1FromX11(hTest, &X11Ctx, "Georges Dupr\xEA", VINF_SUCCESS); + /* With an embedded carriage return */ + tstClipSetSelectionValues("TEXT", XA_STRING, "Georges\nDupr\xEA", + sizeof("Georges\nDupr\xEA"), 8); + tstLatin1FromX11(hTest, &X11Ctx, "Georges\r\nDupr\xEA", VINF_SUCCESS); + /* With an embedded CRLF */ + tstClipSetSelectionValues("TEXT", XA_STRING, "Georges\r\nDupr\xEA", + sizeof("Georges\r\nDupr\xEA"), 8); + tstLatin1FromX11(hTest, &X11Ctx, "Georges\r\r\nDupr\xEA", VINF_SUCCESS); + /* With an embedded LFCR */ + tstClipSetSelectionValues("TEXT", XA_STRING, "Georges\n\rDupr\xEA", + sizeof("Georges\n\rDupr\xEA"), 8); + tstLatin1FromX11(hTest, &X11Ctx, "Georges\r\n\rDupr\xEA", VINF_SUCCESS); + /* A non-zero-terminated string */ + tstClipSetSelectionValues("text/plain", XA_STRING, + "Georges Dupr\xEA!", + sizeof("Georges Dupr\xEA!") - 1, 8); + tstLatin1FromX11(hTest, &X11Ctx, "Georges Dupr\xEA!", VINF_SUCCESS); + + /* + * Unknown X11 format + */ + RTTestSub(hTest, "handling of an unknown X11 format"); + tstClipInvalidateFormats(); + tstClipSetSelectionValues("CLIPBOARD", XA_STRING, "Test", + sizeof("Test"), 8); + tstClipSendTargetUpdate(&X11Ctx); + RTTEST_CHECK_MSG(hTest, tstClipQueryFormats() == 0, + (hTest, "Failed to send a format update notification\n")); + + /* + * Timeout from X11 + */ + RTTestSub(hTest, "X11 timeout"); + tstClipSetSelectionValues("UTF8_STRING", XT_CONVERT_FAIL, NULL,0, 8); + tstStringFromX11(hTest, &X11Ctx, "", VERR_NO_DATA); + + /* + * No data in X11 clipboard + */ + RTTestSub(hTest, "a data request from an empty X11 clipboard"); + tstClipSetSelectionValues("UTF8_STRING", XA_STRING, NULL, + 0, 8); + ShClX11ReadDataFromX11(&X11Ctx, VBOX_SHCL_FMT_UNICODETEXT, pReq); + tstClipGetCompletedRequest(&rc, &pc, &cbActual, &pReqRet); + RTTEST_CHECK_MSG(hTest, rc == VERR_NO_DATA, + (hTest, "Returned %Rrc instead of VERR_NO_DATA\n", + rc)); + RTTEST_CHECK_MSG(hTest, pReqRet == pReq, + (hTest, "Wrong returned request data, expected %p, got %p\n", + pReq, pReqRet)); + + /* + * Ensure that VBox is notified when we return the CB to X11 + */ + RTTestSub(hTest, "notification of switch to X11 clipboard"); + tstClipInvalidateFormats(); + clipReportEmpty(&X11Ctx); + RTTEST_CHECK_MSG(hTest, tstClipQueryFormats() == 0, + (hTest, "Failed to send a format update (release) notification\n")); + + /* + * Request for an invalid VBox format from X11 + */ + RTTestSub(hTest, "a request for an invalid VBox format from X11"); + /* Testing for 0xffff will go into handling VBOX_SHCL_FMT_UNICODETEXT, where we don't have + * have any data at the moment so far, so this will return VERR_NO_DATA. */ + ShClX11ReadDataFromX11(&X11Ctx, 0xffff /* vboxFormat */, pReq); + tstClipGetCompletedRequest(&rc, &pc, &cbActual, &pReqRet); + RTTEST_CHECK_MSG(hTest, rc == VERR_NO_DATA, + (hTest, "Returned %Rrc instead of VERR_NO_DATA\n", + rc)); + RTTEST_CHECK_MSG(hTest, pReqRet == pReq, + (hTest, "Wrong returned request data, expected %p, got %p\n", + pReq, pReqRet)); + + /* + * Targets failure from X11 + */ + RTTestSub(hTest, "X11 targets conversion failure"); + tstClipSetSelectionValues("UTF8_STRING", XA_STRING, "hello world", + sizeof("hello world"), 8); + tstClipSetTargetsFailure(); + Atom atom = XA_STRING; + long unsigned int cLen = 0; + int format = 8; + clipQueryX11TargetsCallback(NULL, (XtPointer) &X11Ctx, NULL, &atom, NULL, &cLen, + &format); + RTTEST_CHECK_MSG(hTest, tstClipQueryFormats() == 0, + (hTest, "Wrong targets reported: %02X\n", + tstClipQueryFormats())); + + /* + * X11 text format conversion + */ + RTTestSub(hTest, "handling of X11 selection targets"); + RTTEST_CHECK_MSG(hTest, tstClipTextFormatConversion(&X11Ctx), + (hTest, "failed to select the right X11 text formats\n")); + /* + * UTF-8 from VBox + */ + RTTestSub(hTest, "reading UTF-8 from VBox"); + /* Simple test */ + tstClipSetVBoxUtf16(&X11Ctx, VINF_SUCCESS, "hello world", + sizeof("hello world") * 2); + tstStringFromVBox(hTest, &X11Ctx, "UTF8_STRING", + clipGetAtom(&X11Ctx, "UTF8_STRING"), "hello world"); + /* With an embedded carriage return */ + tstClipSetVBoxUtf16(&X11Ctx, VINF_SUCCESS, "hello\r\nworld", + sizeof("hello\r\nworld") * 2); + tstStringFromVBox(hTest, &X11Ctx, "text/plain;charset=UTF-8", + clipGetAtom(&X11Ctx, "text/plain;charset=UTF-8"), + "hello\nworld"); + /* With an embedded CRCRLF */ + tstClipSetVBoxUtf16(&X11Ctx, VINF_SUCCESS, "hello\r\r\nworld", + sizeof("hello\r\r\nworld") * 2); + tstStringFromVBox(hTest, &X11Ctx, "text/plain;charset=UTF-8", + clipGetAtom(&X11Ctx, "text/plain;charset=UTF-8"), + "hello\r\nworld"); + /* With an embedded CRLFCR */ + tstClipSetVBoxUtf16(&X11Ctx, VINF_SUCCESS, "hello\r\n\rworld", + sizeof("hello\r\n\rworld") * 2); + tstStringFromVBox(hTest, &X11Ctx, "text/plain;charset=UTF-8", + clipGetAtom(&X11Ctx, "text/plain;charset=UTF-8"), + "hello\n\rworld"); + /* An empty string */ + tstClipSetVBoxUtf16(&X11Ctx, VINF_SUCCESS, "", 2); + tstStringFromVBox(hTest, &X11Ctx, "text/plain;charset=utf-8", + clipGetAtom(&X11Ctx, "text/plain;charset=utf-8"), ""); + /* With an embedded UTF-8 character. */ + tstClipSetVBoxUtf16(&X11Ctx, VINF_SUCCESS, "100\xE2\x82\xAC" /* 100 Euro */, + 10); + tstStringFromVBox(hTest, &X11Ctx, "STRING", + clipGetAtom(&X11Ctx, "STRING"), "100\xE2\x82\xAC"); + /* A non-zero-terminated string */ + tstClipSetVBoxUtf16(&X11Ctx, VINF_SUCCESS, "hello world", + sizeof("hello world") * 2 - 2); + tstStringFromVBox(hTest, &X11Ctx, "TEXT", clipGetAtom(&X11Ctx, "TEXT"), + "hello world"); + + /* + * Timeout from VBox + */ + RTTestSub(hTest, "reading from VBox with timeout"); + tstClipEmptyVBox(&X11Ctx, VERR_TIMEOUT); + tstStringFromVBoxFailed(hTest, &X11Ctx, "UTF8_STRING"); + + /* + * No data in VBox clipboard + */ + RTTestSub(hTest, "an empty VBox clipboard"); + tstClipSetSelectionValues("TEXT", XA_STRING, "", sizeof(""), 8); + tstClipEmptyVBox(&X11Ctx, VINF_SUCCESS); + RTTEST_CHECK_MSG(hTest, g_tst_fOwnsSel, + (hTest, "VBox grabbed the clipboard with no data and we ignored it\n")); + tstStringFromVBoxFailed(hTest, &X11Ctx, "UTF8_STRING"); + + /* + * An unknown VBox format + */ + RTTestSub(hTest, "reading an unknown VBox format"); + tstClipSetSelectionValues("TEXT", XA_STRING, "", sizeof(""), 8); + tstClipSetVBoxUtf16(&X11Ctx, VINF_SUCCESS, "", 2); + ShClX11ReportFormatsToX11(&X11Ctx, 0xa0000); + RTTEST_CHECK_MSG(hTest, g_tst_fOwnsSel, + (hTest, "VBox grabbed the clipboard with unknown data and we ignored it\n")); + tstStringFromVBoxFailed(hTest, &X11Ctx, "UTF8_STRING"); + + /* + * VBox requests a bad format + */ + RTTestSub(hTest, "recovery from a bad format request"); + tstBadFormatRequestFromHost(hTest, &X11Ctx); + + ShClX11Destroy(&X11Ctx); + + /* + * Headless clipboard tests + */ + rc = ShClX11Init(&X11Ctx, &Callbacks, NULL /* pParent */, true /* fHeadless */); + AssertRCReturn(rc, RTEXITCODE_FAILURE); + + /* Read from X11 */ + RTTestSub(hTest, "reading from X11, headless clipboard"); + /* Simple test */ + tstClipSetVBoxUtf16(&X11Ctx, VINF_SUCCESS, "", + sizeof("") * 2); + tstClipSetSelectionValues("UTF8_STRING", XA_STRING, "hello world", + sizeof("hello world"), 8); + tstNoX11(&X11Ctx, "reading from X11, headless clipboard"); + + /* Read from VBox */ + RTTestSub(hTest, "reading from VBox, headless clipboard"); + /* Simple test */ + tstClipEmptyVBox(&X11Ctx, VERR_WRONG_ORDER); + tstClipSetSelectionValues("TEXT", XA_STRING, "", sizeof(""), 8); + tstClipSetVBoxUtf16(&X11Ctx, VINF_SUCCESS, "hello world", + sizeof("hello world") * 2); + tstNoSelectionOwnership(&X11Ctx, "reading from VBox, headless clipboard"); + + ShClX11Destroy(&X11Ctx); + + return RTTestSummaryAndDestroy(hTest); +} + diff --git a/src/VBox/GuestHost/SharedClipboard/testcase/tstClipboardGH-X11Smoke.cpp b/src/VBox/GuestHost/SharedClipboard/testcase/tstClipboardGH-X11Smoke.cpp new file mode 100644 index 00000000..7cdf1692 --- /dev/null +++ b/src/VBox/GuestHost/SharedClipboard/testcase/tstClipboardGH-X11Smoke.cpp @@ -0,0 +1,103 @@ +/* $Id: tstClipboardGH-X11Smoke.cpp $ */ +/** @file + * Shared Clipboard guest/host X11 code smoke tests. + */ + +/* + * Copyright (C) 2011-2022 Oracle and/or its affiliates. + * + * This file is part of VirtualBox base platform packages, as + * available from https://www.virtualbox.org. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, in version 3 of the + * License. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <https://www.gnu.org/licenses>. + * + * SPDX-License-Identifier: GPL-3.0-only + */ + +/* This is a simple test case that just starts a copy of the X11 clipboard + * backend, checks the X11 clipboard and exits. If ever needed I will add an + * interactive mode in which the user can read and copy to the clipboard from + * the command line. */ + +#include <iprt/assert.h> +#include <iprt/env.h> +#include <iprt/err.h> +#include <iprt/test.h> + +#include <VBox/GuestHost/SharedClipboard.h> +#include <VBox/GuestHost/SharedClipboard-x11.h> +#include <VBox/GuestHost/clipboard-helper.h> + + +static DECLCALLBACK(int) tstShClReportFormatsCallback(PSHCLCONTEXT pCtx, uint32_t fFormats, void *pvUser) +{ + RT_NOREF(pCtx, fFormats, pvUser); + return VINF_SUCCESS; +} + +static DECLCALLBACK(int) tstShClOnRequestDataFromSourceCallback(PSHCLCONTEXT pCtx, SHCLFORMAT uFmt, void **ppv, uint32_t *pcb, void *pvUser) +{ + RT_NOREF(pCtx, uFmt, ppv, pcb, pvUser); + return VERR_NO_DATA; +} + +static DECLCALLBACK(int) tstShClOnSendDataToDest(PSHCLCONTEXT pCtx, void *pv, uint32_t cb, void *pvUser) +{ + RT_NOREF(pCtx, pv, cb, pvUser); + return VINF_SUCCESS; +} + +int main() +{ + /* + * Init the runtime, test and say hello. + */ + RTTEST hTest; + int rc = RTTestInitAndCreate("tstClipboardGH-X11Smoke", &hTest); + if (rc) + return rc; + RTTestBanner(hTest); + + /* + * Run the test. + */ + rc = VINF_SUCCESS; + /* We can't test anything without an X session, so just return success + * in that case. */ + if (!RTEnvExist("DISPLAY")) + { + RTTestPrintf(hTest, RTTESTLVL_INFO, + "X11 not available, not running test\n"); + return RTTestSummaryAndDestroy(hTest); + } + + SHCLCALLBACKS Callbacks; + RT_ZERO(Callbacks); + Callbacks.pfnReportFormats = tstShClReportFormatsCallback; + Callbacks.pfnOnRequestDataFromSource = tstShClOnRequestDataFromSourceCallback; + Callbacks.pfnOnSendDataToDest = tstShClOnSendDataToDest; + + SHCLX11CTX X11Ctx; + rc = ShClX11Init(&X11Ctx, &Callbacks, NULL /* pParent */, false); + AssertRCReturn(rc, 1); + rc = ShClX11ThreadStart(&X11Ctx, false /* fGrab */); + AssertRCReturn(rc, 1); + /* Give the clipboard time to synchronise. */ + RTThreadSleep(500); + rc = ShClX11ThreadStop(&X11Ctx); + AssertRCReturn(rc, 1); + ShClX11Destroy(&X11Ctx); + return RTTestSummaryAndDestroy(hTest); +} + diff --git a/src/VBox/GuestHost/SharedClipboard/testcase/tstClipboardQt/Makefile.kmk b/src/VBox/GuestHost/SharedClipboard/testcase/tstClipboardQt/Makefile.kmk new file mode 100644 index 00000000..4fad271d --- /dev/null +++ b/src/VBox/GuestHost/SharedClipboard/testcase/tstClipboardQt/Makefile.kmk @@ -0,0 +1,52 @@ +# $Id: Makefile.kmk $ +## @file +# Sub-Makefile for tstClipboardQt. +# + +# +# Copyright (C) 2011-2022 Oracle and/or its affiliates. +# +# This file is part of VirtualBox base platform packages, as +# available from https://www.virtualbox.org. +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation, in version 3 of the +# License. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, see <https://www.gnu.org/licenses>. +# +# SPDX-License-Identifier: GPL-3.0-only +# + +SUB_DEPTH = ../../../../../.. +include $(KBUILD_PATH)/subheader.kmk + +# +# Targets and units. +# +USES += qt5 +PROGRAMS += tstClipboardQt + +# +# tstClipboardQt +# +tstClipboardQt_TEMPLATE = VBOXQTGUIEXE +tstClipboardQt_NAME = tstClipboardQt +tstClipboardQt_CXXFLAGS = \ + $(VBOX_GCC_Wno-implicit-fallthrough) \ + $(VBOX_GCC_Wno-deprecated-declarations) + +tstClipboardQt_SOURCES = \ + tstClipboardQt.cpp + +# The Qt modules we're using. +tstClipboardQt_QT_MODULES = Core Gui Widgets PrintSupport + +include $(FILE_KBUILD_SUB_FOOTER) diff --git a/src/VBox/GuestHost/SharedClipboard/testcase/tstClipboardQt/tstClipboardQt.cpp b/src/VBox/GuestHost/SharedClipboard/testcase/tstClipboardQt/tstClipboardQt.cpp new file mode 100644 index 00000000..a42c9ebf --- /dev/null +++ b/src/VBox/GuestHost/SharedClipboard/testcase/tstClipboardQt/tstClipboardQt.cpp @@ -0,0 +1,47 @@ +/* $Id: tstClipboardQt.cpp $ */ +/** @file + * Shared Clipboard guest/host Qt code test cases. + */ + +/* + * Copyright (C) 2011-2022 Oracle and/or its affiliates. + * + * This file is part of VirtualBox base platform packages, as + * available from https://www.virtualbox.org. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, in version 3 of the + * License. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <https://www.gnu.org/licenses>. + * + * SPDX-License-Identifier: GPL-3.0-only + */ + +#include <QApplication> +#include <QMainWindow> +#include <QTextEdit> +#include <QHBoxLayout> +int main(int argc, char *argv[]) +{ + QApplication app(argc, argv); + QMainWindow window; + QWidget *pWidget = new QWidget; + window.setCentralWidget(pWidget); + QHBoxLayout *pLayout = new QHBoxLayout(pWidget); + + QTextEdit *pTextEdit = new QTextEdit; + pLayout->addWidget(pTextEdit); + + + window.show(); + + app.exec(); +} |