Changeset 79120 in vbox for trunk/src/VBox/GuestHost/SharedClipboard/ClipboardProvider-HostService.cpp

Timestamp:

Jun 13, 2019 10:08:33 AM (6 years ago)

Author:

vboxsync

Message:

Shared Clipboard/URI: Update.

File:

• trunk/src/VBox/GuestHost/SharedClipboard/ClipboardProvider-HostService.cpp (modified) (5 diffs)

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

@@ -27 +27 @@
 #include <iprt/dir.h>
 #include <iprt/errcore.h>
+#include <iprt/semaphore.h>
 #include <iprt/file.h>
 #include <iprt/path.h>
@@ -34 +35 @@
 
 
+
+SharedClipboardProviderHostService::Event::Event(uint32_t uMsg)
+    : mMsg(uMsg)
+    , mpvData(NULL)
+    , mcbData(0)
+{
+    int rc2 = RTSemEventCreate(&mEvent);
+    AssertRC(rc2);
+}
+
+SharedClipboardProviderHostService::Event::~Event()
+{
+    if (mpvData)
+    {
+        Assert(mcbData);
+
+        RTMemFree(mpvData);
+        mpvData = NULL;
+    }
+
+    int rc2 = RTSemEventDestroy(mEvent);
+    AssertRC(rc2);
+}
+
+/**
+ * Sets user data associated to an event.
+ *
+ * @returns VBox status code.
+ * @param   pvData              Pointer to user data to set.
+ * @param   cbData              Size (in bytes) of user data to set.
+ */
+int SharedClipboardProviderHostService::Event::SetData(const void *pvData, uint32_t cbData)
+{
+    Assert(mpvData == NULL);
+    Assert(mcbData == 0);
+
+    if (!cbData)
+        return VINF_SUCCESS;
+
+    mpvData = RTMemDup(pvData, cbData);
+    if (!mpvData)
+        return VERR_NO_MEMORY;
+
+    mcbData = cbData;
+
+    return VINF_SUCCESS;
+}
+
+/**
+ * Waits for an event to get signalled.
+ * Will return VERR_NOT_FOUND if no event has been found.
+ *
+ * @returns VBox status code.
+ * @param   uTimeoutMs          Timeout (in ms) to wait.
+ */
+int SharedClipboardProviderHostService::Event::Wait(RTMSINTERVAL uTimeoutMs)
+{
+    LogFlowFuncEnter();
+
+    int rc = RTSemEventWait(mEvent, uTimeoutMs);
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+void *SharedClipboardProviderHostService::Event::DataRaw()
+{
+    return mpvData;
+}
+
+uint32_t SharedClipboardProviderHostService::Event::DataSize()
+{
+    return mcbData;
+}
+
 SharedClipboardProviderHostService::SharedClipboardProviderHostService(void)
+    : m_uTimeoutMs(30 * 1000 /* 30s timeout by default */)
 {
     LogFlowFuncEnter();
@@ -41 +118 @@
 SharedClipboardProviderHostService::~SharedClipboardProviderHostService(void)
 {
+    Reset();
 }
 
 int SharedClipboardProviderHostService::ReadDataHdr(PVBOXCLIPBOARDDATAHDR pDataHdr)
+{
+    int rc;
+
+    Event *pEvent = eventGet(VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DATA_HDR);
+    if (pEvent)
+    {
+        rc = pEvent->Wait(m_uTimeoutMs);
+        if (RT_SUCCESS(rc))
+            memcpy(pDataHdr, pEvent->DataRaw(), pEvent->DataSize());
+    }
+    else
+        rc = VERR_NOT_FOUND;
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+int SharedClipboardProviderHostService::WriteDataHdr(const PVBOXCLIPBOARDDATAHDR pDataHdr)
 {
     RT_NOREF(pDataHdr);
@@ -49 +145 @@
 }
 
-int SharedClipboardProviderHostService::WriteDataHdr(const PVBOXCLIPBOARDDATAHDR pDataHdr)
-{
-    RT_NOREF(pDataHdr);
+int SharedClipboardProviderHostService::ReaaDataChunk(const PVBOXCLIPBOARDDATAHDR pDataHdr, void *pvChunk, uint32_t cbChunk,
+                                                      uint32_t *pcbRead, uint32_t fFlags /* = 0 */)
+{
+    RT_NOREF(pDataHdr, pvChunk, cbChunk, pcbRead, fFlags);
     return VERR_NOT_IMPLEMENTED;
 }
 
-int SharedClipboardProviderHostService::ReadMetaData(const PVBOXCLIPBOARDDATAHDR pDataHdr, void *pvMeta, uint32_t cbMeta,
-                                                     uint32_t *pcbRead, uint32_t fFlags /* = 0 */)
-{
-    RT_NOREF(pDataHdr, pvMeta, cbMeta, pcbRead, fFlags);
-    return VERR_NOT_IMPLEMENTED;
-}
-
-int SharedClipboardProviderHostService::WriteMetaData(const PVBOXCLIPBOARDDATAHDR pDataHdr, const void *pvMeta, uint32_t cbMeta,
-                                                      uint32_t *pcbWritten, uint32_t fFlags /* = 0 */)
+int SharedClipboardProviderHostService::WriteDataChunk(const PVBOXCLIPBOARDDATAHDR pDataHdr, const void *pvMeta, uint32_t cbMeta,
+                                                       uint32_t *pcbWritten, uint32_t fFlags /* = 0 */)
 {
     RT_NOREF(pDataHdr, pvMeta, cbMeta, pcbWritten, fFlags);
@@ -143 +233 @@
 void SharedClipboardProviderHostService::Reset(void)
 {
-}
-
+    LogFlowFuncEnter();
+
+    EventMap::const_iterator itEvent = m_mapEvents.begin();
+    while (itEvent != m_mapEvents.end())
+    {
+        delete itEvent->second;
+        m_mapEvents.erase(itEvent);
+
+        itEvent = m_mapEvents.begin();
+    }
+
+    int rc2 = eventRegister(VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DATA_HDR);
+    AssertRC(rc2);
+}
+
+int SharedClipboardProviderHostService::OnRead(PSHAREDCLIPBOARDPROVIDERREADPARMS pParms)
+{
+    RT_NOREF(pParms);
+
+    LogFlowFuncEnter();
+
+    int rc = VERR_NOT_IMPLEMENTED;
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+int SharedClipboardProviderHostService::OnWrite(PSHAREDCLIPBOARDPROVIDERWRITEPARMS pParms)
+{
+    LogFlowFuncEnter();
+
+    int rc = VINF_SUCCESS;
+
+    switch (pParms->u.HostService.uMsg)
+    {
+        case VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DATA_HDR:
+        {
+            VBOXCLIPBOARDDATAHDR dataHdr;
+            rc = VBoxSvcClipboardURIReadDataHdr(pParms->u.HostService.cParms, pParms->u.HostService.paParms,
+                                                &dataHdr);
+            if (RT_SUCCESS(rc))
+            {
+                Event *pEvent = eventGet(pParms->u.HostService.uMsg);
+                if (pEvent)
+                {
+                    rc = pEvent->SetData(&dataHdr, sizeof(dataHdr));
+                }
+            }
+            break;
+        }
+        case VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DATA_CHUNK:
+        {
+            break;
+        }
+        case VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_DIR:
+            RT_FALL_THROUGH();
+        case VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_FILE_HDR:
+            RT_FALL_THROUGH();
+        case VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_FILE_DATA:
+            RT_FALL_THROUGH();
+        case VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_CANCEL:
+            RT_FALL_THROUGH();
+        case VBOX_SHARED_CLIPBOARD_GUEST_FN_WRITE_ERROR:
+        {
+
+        }
+
+        default:
+            rc = VERR_NOT_IMPLEMENTED;
+            break;
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        rc = eventSignal(pParms->u.HostService.uMsg);
+        if (rc == VERR_NOT_FOUND) /* Having an event is optional, so don't fail here. */
+            rc = VINF_SUCCESS;
+    }
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+/**
+ * Registers a new event.
+ * Will fail if an event with the same message ID already exists.
+ *
+ * @returns VBox status code.
+ * @param   uMsg                Message ID to register event for.
+ */
+int SharedClipboardProviderHostService::eventRegister(uint32_t uMsg)
+{
+    LogFlowFuncEnter();
+
+    int rc;
+
+    EventMap::const_iterator itEvent = m_mapEvents.find(uMsg);
+    if (itEvent == m_mapEvents.end())
+    {
+        SharedClipboardProviderHostService::Event *pEvent = new SharedClipboardProviderHostService::Event(uMsg);
+        if (pEvent) /** @todo Can this throw? */
+        {
+            rc = VINF_SUCCESS;
+        }
+        else
+            rc = VERR_NO_MEMORY;
+    }
+    else
+        rc = VERR_ALREADY_EXISTS;
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+/**
+ * Unregisters an existing event.
+ * Will return VERR_NOT_FOUND if no event has been found.
+ *
+ * @returns VBox status code.
+ * @param   uMsg                Message ID to unregister event for.
+ */
+int SharedClipboardProviderHostService::eventUnregister(uint32_t uMsg)
+{
+    LogFlowFuncEnter();
+
+    int rc;
+
+    EventMap::const_iterator itEvent = m_mapEvents.find(uMsg);
+    if (itEvent != m_mapEvents.end())
+    {
+        delete itEvent->second;
+        m_mapEvents.erase(itEvent);
+
+        rc = VINF_SUCCESS;
+    }
+    else
+        rc = VERR_NOT_FOUND;
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+/**
+ * Signals an event.
+ * Will return VERR_NOT_FOUND if no event has been found.
+ *
+ * @returns VBox status code.
+ * @param   uMsg                Message ID of event to signal.
+ */
+int SharedClipboardProviderHostService::eventSignal(uint32_t uMsg)
+{
+    LogFlowFuncEnter();
+
+    int rc;
+
+    EventMap::const_iterator itEvent = m_mapEvents.find(uMsg);
+    if (itEvent != m_mapEvents.end())
+    {
+        rc = RTSemEventSignal(itEvent->second->mEvent);
+    }
+    else
+        rc = VERR_NOT_FOUND;
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+/**
+ * Returns the event for a specific message ID.
+ *
+ * @returns Pointer to event if found, or NULL if no event has been found
+ * @param   uMsg                Messagae ID to return event for.
+ */
+SharedClipboardProviderHostService::Event *SharedClipboardProviderHostService::eventGet(uint32_t uMsg)
+{
+    LogFlowFuncEnter();
+
+    EventMap::const_iterator itEvent = m_mapEvents.find(uMsg);
+    if (itEvent != m_mapEvents.end())
+        return itEvent->second;
+
+    return NULL;
+}
+