Changeset 78618 in vbox for trunk/src/VBox

Timestamp:

May 21, 2019 8:36:42 AM (6 years ago)

Author:

vboxsync

Message:

Shared Clipboard/URI: Update.

Location:

trunk/src/VBox

Files:

• Additions/common/VBoxGuest/lib/Makefile.kmk (modified) (4 diffs)
• GuestHost/SharedClipboard/ClipboardCache.cpp (modified) (1 diff)
• HostServices/SharedClipboard/VBoxSharedClipboardSvc-darwin.cpp (modified) (13 diffs)
• HostServices/SharedClipboard/VBoxSharedClipboardSvc-internal.h (moved) (moved from trunk/src/VBox/HostServices/SharedClipboard/VBoxClipboard.h ) (5 diffs)
• HostServices/SharedClipboard/VBoxSharedClipboardSvc-uri.cpp (modified) (3 diffs)
• HostServices/SharedClipboard/VBoxSharedClipboardSvc-uri.h (modified) (1 diff)
• HostServices/SharedClipboard/VBoxSharedClipboardSvc-win.cpp (modified) (17 diffs)
• HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11-stubs.cpp (modified) (6 diffs)
• HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11.cpp (modified) (22 diffs)
• HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp (modified) (42 diffs)
• HostServices/SharedClipboard/testcase/tstClipboardServiceHost.cpp (modified) (2 diffs)

trunk/src/VBox/Additions/common/VBoxGuest/lib/Makefile.kmk

@@ -111 +111 @@
         $(if $(VBOX_WITH_GUEST_PROPS),VBOX_WITH_GUEST_PROPS,) \
         $(if $(VBOX_WITH_SHARED_CLIPBOARD),VBOX_WITH_SHARED_CLIPBOARD,) \
+    $(if $(VBOX_WITH_SHARED_CLIPBOARD_URI_LIST),VBOX_WITH_SHARED_CLIPBOARD_URI_LIST,) \
         $(if $(VBOX_WITH_SHARED_FOLDERS),VBOX_WITH_SHARED_FOLDERS,) \
         $(if $(VBOX_WITH_GUEST_CONTROL),VBOX_WITH_GUEST_CONTROL,)
@@ -118 +119 @@
         VBoxGuestR3LibAutoLogon.cpp \
         VBoxGuestR3LibBalloon.cpp \
-        VBoxGuestR3LibClipboard.cpp \
         VBoxGuestR3LibCoreDump.cpp \
         VBoxGuestR3LibCpuHotPlug.cpp \
@@ -146 +146 @@
         VBoxGuestR3LibHostVersion.cpp
 endif
+ifdef VBOX_WITH_SHARED_CLIPBOARD
+ VBoxGuestR3Lib_SOURCES   += \
+        VBoxGuestR3LibClipboard.cpp
+endif
 ifdef VBOX_WITH_SHARED_FOLDERS
  VBoxGuestR3Lib_SOURCES   += \
@@ -160 +164 @@
  VBoxGuestR3Lib_SOURCES   += \
         VBoxGuestR3LibDragAndDrop.cpp
-endif
-ifdef VBOX_WITH_SHARED_CLIPBOARD
- VBoxGuestR3Lib_DEFS      += \
-        $(if $(VBOX_WITH_SHARED_CLIPBOARD_URI_LIST),VBOX_WITH_SHARED_CLIPBOARD_URI_LIST,)
 endif
 

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

@@ -252 +252 @@
 }
 
-int SharedClipboardCache::Reset(bool fRemoveDropDir)
+int SharedClipboardCache::Reset(bool fDeleteContent)
 {
     int rc = closeInternal();
     if (RT_SUCCESS(rc))
     {
-        if (fRemoveDropDir)
+        if (fDeleteContent)
         {
             rc = Rollback();

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

@@ -44 +44 @@
     PasteboardRef pasteboard;
 
-    PVBOXCLIPBOARDSVCCTX pSvcCtx;
+    PVBOXCLIPBOARDCLIENTDATA pClientData;
 };
 
@@ -63 +63 @@
 static int vboxClipboardChanged(VBOXCLIPBOARDCONTEXT *pCtx)
 {
-    if (pCtx->pSvcCtx == NULL)
+    if (pCtx->pClientData == NULL)
         return VINF_SUCCESS;
 
@@ -72 +72 @@
     if (RT_SUCCESS(rc) && fChanged)
     {
-        vboxSvcClipboardReportMsg(pCtx->pSvcCtx, VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS, fFormats);
+        vboxSvcClipboardReportMsg(pCtx->pClientData, VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS, fFormats);
         Log(("vboxClipboardChanged fFormats %02X\n", fFormats));
     }
@@ -157 +157 @@
     destroyPasteboard(&g_ctx.pasteboard);
     g_ctx.thread = NIL_RTTHREAD;
-    g_ctx.pSvcCtx = NULL;
+    g_ctx.pClientData = NULL;
 }
 
@@ -163 +163 @@
  * Enable the shared clipboard - called by the hgcm clipboard subsystem.
  *
- * @param   pSvcCtx Structure containing context information about the guest system
- * @param   fHeadless Whether headless.
+ * @param   pClientData Structure containing context information about the guest system
+ * @param   fHeadless   Whether headless.
  * @returns RT status code
  */
-int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDSVCCTX pSvcCtx, bool fHeadless)
+int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDCLIENTDATA pClientData, bool fHeadless)
 {
     NOREF(fHeadless);
-    if (g_ctx.pSvcCtx != NULL)
+    if (g_ctx.pClientData != NULL)
     {
         /* One client only. */
@@ -178 +178 @@
     VBoxSvcClipboardLock();
 
-    pSvcCtx->pCtx = &g_ctx;
-    pSvcCtx->pCtx->pSvcCtx = pSvcCtx;
+    pClientData->State.pCtx = &g_ctx;
+    pClientData->State.pCtx->pClientData = pClientData;
 
     /* Initially sync the host clipboard content with the client. */
-    int rc = VBoxClipboardSvcImplSync(pSvcCtx);
+    int rc = VBoxClipboardSvcImplSync(pClientData);
 
     VBoxSvcClipboardUnlock();
@@ -192 +192 @@
  * after a save and restore of the guest.
  */
-int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDSVCCTX pSvcCtx)
+int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDCLIENTDATA pClientData)
 {
     /* Sync the host clipboard content with the client. */
     VBoxSvcClipboardLock();
-    int rc = vboxClipboardChanged(pSvcCtx->pCtx);
+    int rc = vboxClipboardChanged(pClientData->State.pCtx);
     VBoxSvcClipboardUnlock();
 
@@ -205 +205 @@
  * Shut down the shared clipboard subsystem and "disconnect" the guest.
  */
-void VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDSVCCTX pSvcCtx)
+void VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDCLIENTDATA pClientData)
 {
     Log(("vboxClipboardDisconnect\n"));
 
     VBoxSvcClipboardLock();
-    pSvcCtx->pCtx->pSvcCtx = NULL;
+    pClientData->State.pCtx->pClientData = NULL;
     VBoxSvcClipboardUnlock();
 }
@@ -218 +218 @@
  * subsystem.
  *
- * @param pSvcCtx    Context data for the guest system
- * @param u32Formats Clipboard formats the guest is offering
- */
-void VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDSVCCTX pSvcCtx, uint32_t u32Formats)
+ * @param pClientData    Context data for the guest system
+ * @param u32Formats     Clipboard formats the guest is offering
+ */
+void VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t u32Formats)
 {
     Log(("vboxClipboardFormatAnnounce u32Formats %02X\n", u32Formats));
@@ -230 +230 @@
     }
 
-    vboxSvcClipboardReportMsg(pSvcCtx, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, u32Formats);
+    vboxSvcClipboardReportMsg(pClientData, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, u32Formats);
 }
 
@@ -236 +236 @@
  * Called by the HGCM clipboard subsystem when the guest wants to read the host clipboard.
  *
- * @param pSvcCtx   Context information about the guest VM
- * @param u32Format The format that the guest would like to receive the data in
- * @param pv        Where to write the data to
- * @param cb        The size of the buffer to write the data to
- * @param pcbActual Where to write the actual size of the written data
- */
-int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDSVCCTX pSvcCtx, uint32_t u32Format,
+ * @param pClientData   Context information about the guest VM
+ * @param u32Format     The format that the guest would like to receive the data in
+ * @param pv            Where to write the data to
+ * @param cb            The size of the buffer to write the data to
+ * @param pcbActual     Where to write the actual size of the written data
+ */
+int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t u32Format,
                           void *pv, uint32_t cb, uint32_t *pcbActual)
 {
@@ -249 +249 @@
     /* Default to no data available. */
     *pcbActual = 0;
-    int rc = readFromPasteboard(pSvcCtx->pCtx->pasteboard, u32Format, pv, cb, pcbActual);
+    int rc = readFromPasteboard(pClientData->State.pCtx->pasteboard, u32Format, pv, cb, pcbActual);
 
     VBoxSvcClipboardUnlock();
@@ -258 +258 @@
  * Called by the HGCM clipboard subsystem when we have requested data and that data arrives.
  *
- * @param pSvcCtx   Context information about the guest VM
- * @param pv        Buffer to which the data was written
- * @param cb        The size of the data written
- * @param u32Format The format of the data written
- */
-void VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDSVCCTX pSvcCtx, void *pv, uint32_t cb, uint32_t u32Format)
-{
-    VBoxSvcClipboardLock();
-
-    writeToPasteboard(pSvcCtx->pCtx->pasteboard, pv, cb, u32Format);
-
-    VBoxSvcClipboardUnlock();
-}
+ * @param pClientData   Context information about the guest VM
+ * @param pv            Buffer to which the data was written
+ * @param cb            The size of the data written
+ * @param u32Format     The format of the data written
+ */
+void VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDCLIENTDATA pClientData, void *pv, uint32_t cb, uint32_t u32Format)
+{
+    VBoxSvcClipboardLock();
+
+    writeToPasteboard(pClientData->State.pCtx->pasteboard, pv, cb, u32Format);
+
+    VBoxSvcClipboardUnlock();
+}

trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-internal.h

@@ -16 +16 @@
  */
 
-#ifndef VBOX_INCLUDED_SRC_SharedClipboard_VBoxClipboard_h
-#define VBOX_INCLUDED_SRC_SharedClipboard_VBoxClipboard_h
+#ifndef VBOX_INCLUDED_SRC_SharedClipboard_VBoxSharedClipboardSvc_internal_h
+#define VBOX_INCLUDED_SRC_SharedClipboard_VBoxSharedClipboardSvc_internal_h
 #ifndef RT_WITHOUT_PRAGMA_ONCE
 # pragma once
@@ -26 +26 @@
 
 #include <VBox/GuestHost/SharedClipboard.h>
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
+# include <VBox/GuestHost/SharedClipboard-uri.h>
+#endif
 
-typedef struct _VBOXCLIPBOARDSVCCTX
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
+typedef struct _VBOXCLIPBOARDCLIENTURIDATA
 {
-    struct _VBOXCLIPBOARDSVCCTX *pNext;
-    struct _VBOXCLIPBOARDSVCCTX *pPrev;
+    SharedClipboardCache        Cache;
+} VBOXCLIPBOARDCLIENTURIDATA, *PVBOXCLIPBOARDCLIENTURIDATA;
+#endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */
+
+/**
+ * Structure for keeping generic client state data within the Shared Clipboard host service.
+ * This structure needs to be serializable by SSM.
+ */
+typedef struct _VBOXCLIPBOARDCLIENTSTATE
+{
+    struct _VBOXCLIPBOARDCLIENTSTATE *pNext;
+    struct _VBOXCLIPBOARDCLIENTSTATE *pPrev;
 
     VBOXCLIPBOARDCONTEXT *pCtx;
@@ -65 +79 @@
     uint32_t u32AvailableFormats;
     uint32_t u32RequestedFormat;
+} VBOXCLIPBOARDCLIENTSTATE, *PVBOXCLIPBOARDCLIENTSTATE;
 
-} VBOXCLIPBOARDSVCCTX, *PVBOXCLIPBOARDSVCCTX;
+/**
+ * Structure for keeping a HGCM client state within the Shared Clipboard host service.
+ */
+typedef struct _VBOXCLIPBOARDCLIENTDATA
+{
+    /** General client state data. */
+    VBOXCLIPBOARDCLIENTSTATE   State;
+#ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
+    /** Data related to URI handling. */
+    VBOXCLIPBOARDCLIENTURIDATA URI;
+#endif
+} VBOXCLIPBOARDCLIENTDATA, *PVBOXCLIPBOARDCLIENTDATA;
 
 /*
  * The service functions. Locking is between the service thread and the platform dependent windows thread.
  */
-void vboxSvcClipboardReportMsg(PVBOXCLIPBOARDSVCCTX pSvcCtx, uint32_t u32Msg, uint32_t u32Formats);
-void vboxSvcClipboardCompleteReadData(PVBOXCLIPBOARDSVCCTX pSvcCtx, int rc, uint32_t cbActual);
+uint32_t vboxSvcClipboardGetMode(void);
+void vboxSvcClipboardReportMsg(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t u32Msg, uint32_t u32Formats);
+void vboxSvcClipboardCompleteReadData(PVBOXCLIPBOARDCLIENTDATA pClientData, int rc, uint32_t cbActual);
 
 /*
@@ -80 +107 @@
 void VBoxClipboardSvcImplDestroy(void);
 
-int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDSVCCTX pSvcCtx, bool fHeadless);
-void VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDSVCCTX pSvcCtx);
-void VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDSVCCTX pSvcCtx, uint32_t u32Formats);
-int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDSVCCTX pSvcCtx, uint32_t u32Format, void *pv, uint32_t cb, uint32_t *pcbActual);
-void VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDSVCCTX pSvcCtx, void *pv, uint32_t cb, uint32_t u32Format);
-int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDSVCCTX pSvcCtx);
+int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDCLIENTDATA pClientData, bool fHeadless);
+void VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDCLIENTDATA pClientData);
+void VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t u32Formats);
+int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t u32Format, void *pv, uint32_t cb, uint32_t *pcbActual);
+void VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDCLIENTDATA pClientData, void *pv, uint32_t cb, uint32_t u32Format);
+int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDCLIENTDATA pClientData);
 
 /* Host unit testing interface */
@@ -92 +119 @@
 #endif
 
-#endif /* !VBOX_INCLUDED_SRC_SharedClipboard_VBoxClipboard_h */
+#endif /* !VBOX_INCLUDED_SRC_SharedClipboard_VBoxSharedClipboardSvc_internal_h */
 

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

@@ -23 +23 @@
 #include <VBox/HostServices/VBoxClipboardSvc.h>
 
+#include "VBoxSharedClipboardSvc-internal.h"
 #include "VBoxSharedClipboardSvc-uri.h"
 
+
+int vboxClipboardSvcURICreate(PVBOXCLIPBOARDCLIENTURIDATA pURIData, uint32_t uClientID)
+{
+    RT_NOREF(pURIData, uClientID);
+
+    int rc = pURIData->Cache.OpenTemp(SHAREDCLIPBOARDCACHE_FLAGS_NONE);
+    if (RT_SUCCESS(rc))
+    {
+    }
+
+    return rc;
+}
+
+void vboxClipboardSvcURIDestroy(PVBOXCLIPBOARDCLIENTURIDATA pURIData)
+{
+    int rc = pURIData->Cache.Rollback();
+    if (RT_SUCCESS(rc))
+        rc = pURIData->Cache.Close();
+}
 
 int vboxClipboardSvcURIHandler(uint32_t u32ClientID,
@@ -34 +54 @@
                                bool *pfAsync)
 {
-    RT_NOREF(u32ClientID, pvClient, u32Function, cParms, paParms, tsArrival, pfAsync);
-
-    return VINF_SUCCESS;
+    RT_NOREF(u32ClientID, pvClient, paParms, tsArrival, pfAsync);
+
+    PVBOXCLIPBOARDCLIENTDATA pClientData = (PVBOXCLIPBOARDCLIENTDATA)pvClient;
+    RT_NOREF(pClientData);
+
+    /* Check if we've the right mode set. */
+    int rc = VERR_ACCESS_DENIED; /* Play safe. */
+
+    switch (u32Function)
+    {
+        case VBOX_SHARED_CLIPBOARD_FN_READ_DATA_HDR:
+            RT_FALL_THROUGH();
+        case VBOX_SHARED_CLIPBOARD_FN_READ_DIR:
+            RT_FALL_THROUGH();
+        case VBOX_SHARED_CLIPBOARD_FN_READ_FILE_HDR:
+            RT_FALL_THROUGH();
+        case VBOX_SHARED_CLIPBOARD_FN_READ_FILE_DATA:
+        {
+            if (   vboxSvcClipboardGetMode() == VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST
+                || vboxSvcClipboardGetMode() == VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
+            {
+                rc = VINF_SUCCESS;
+            }
+
+            if (RT_FAILURE(rc))
+                LogFunc(("Guest -> Host Shared Clipboard mode disabled, ignoring request\n"));
+            break;
+        }
+
+        case VBOX_SHARED_CLIPBOARD_FN_WRITE_DATA_HDR:
+            RT_FALL_THROUGH();
+        case VBOX_SHARED_CLIPBOARD_FN_WRITE_FILE_HDR:
+            RT_FALL_THROUGH();
+        case VBOX_SHARED_CLIPBOARD_FN_WRITE_FILE_DATA:
+            RT_FALL_THROUGH();
+        case VBOX_SHARED_CLIPBOARD_FN_WRITE_CANCEL:
+            RT_FALL_THROUGH();
+        case VBOX_SHARED_CLIPBOARD_FN_WRITE_ERROR:
+        {
+            if (   vboxSvcClipboardGetMode() == VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST
+                || vboxSvcClipboardGetMode() == VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
+            {
+                rc = VINF_SUCCESS;
+            }
+
+            if (RT_FAILURE(rc))
+                LogFunc(("Clipboard: Host -> Guest Shared Clipboard mode disabled, ignoring request\n"));
+            break;
+        }
+
+        default:
+            break;
+    }
+
+    if (RT_FAILURE(rc))
+        return rc;
+
+    rc = VERR_INVALID_PARAMETER; /* Play safe. */
+
+    switch (u32Function)
+    {
+        case VBOX_SHARED_CLIPBOARD_FN_READ_DATA_HDR:
+        {
+            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_READ_DATA_HDR\n"));
+            AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED);
+            break;
+        }
+
+        case VBOX_SHARED_CLIPBOARD_FN_WRITE_DATA_HDR:
+        {
+            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_WRITE_DATA_HDR\n"));
+            if (cParms == 12)
+            {
+                VBOXCLIPBOARDCBWRITEDATAHDRDATA data;
+                RT_ZERO(data);
+                data.hdr.uMagic = CB_MAGIC_CLIPBOARD_WRITE_DATA_HDR;
+                rc = HGCMSvcGetU32(&paParms[0], &data.hdr.uContextID);
+                if (RT_SUCCESS(rc))
+                    rc = HGCMSvcGetU32(&paParms[1], &data.data.uFlags);
+                if (RT_SUCCESS(rc))
+                    rc = HGCMSvcGetU32(&paParms[2], &data.data.uScreenId);
+                if (RT_SUCCESS(rc))
+                    rc = HGCMSvcGetU64(&paParms[3], &data.data.cbTotal);
+                if (RT_SUCCESS(rc))
+                    rc = HGCMSvcGetU32(&paParms[4], &data.data.cbMeta);
+                if (RT_SUCCESS(rc))
+                    rc = HGCMSvcGetPv(&paParms[5], &data.data.pvMetaFmt, &data.data.cbMetaFmt);
+                if (RT_SUCCESS(rc))
+                    rc = HGCMSvcGetU32(&paParms[6], &data.data.cbMetaFmt);
+                if (RT_SUCCESS(rc))
+                    rc = HGCMSvcGetU64(&paParms[7], &data.data.cObjects);
+                if (RT_SUCCESS(rc))
+                    rc = HGCMSvcGetU32(&paParms[8], &data.data.enmCompression);
+                if (RT_SUCCESS(rc))
+                    rc = HGCMSvcGetU32(&paParms[9], (uint32_t *)&data.data.enmChecksumType);
+                if (RT_SUCCESS(rc))
+                    rc = HGCMSvcGetPv(&paParms[10], &data.data.pvChecksum, &data.data.cbChecksum);
+                if (RT_SUCCESS(rc))
+                    rc = HGCMSvcGetU32(&paParms[11], &data.data.cbChecksum);
+
+                LogFlowFunc(("fFlags=0x%x, cbTotalSize=%RU64, cObj=%RU64\n",
+                             data.data.uFlags, data.data.cbTotal, data.data.cObjects));
+            }
+
+            break;
+        }
+
+        case VBOX_SHARED_CLIPBOARD_FN_WRITE_DATA_CHUNK:
+        {
+            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_WRITE_DATA_CHUNK\n"));
+            if (cParms == 5)
+            {
+                VBOXCLIPBOARDCBDATADATA data;
+                RT_ZERO(data);
+                data.hdr.uMagic = CB_MAGIC_CLIPBOARD_WRITE_DATA_CHUNK;
+                rc = HGCMSvcGetU32(&paParms[0], &data.hdr.uContextID);
+                if (RT_SUCCESS(rc))
+                    rc = HGCMSvcGetPv(&paParms[1], (void**)&data.data.pvData, &data.data.cbData);
+                if (RT_SUCCESS(rc))
+                    rc = HGCMSvcGetU32(&paParms[2], &data.data.cbData);
+                if (RT_SUCCESS(rc))
+                    rc = HGCMSvcGetPv(&paParms[3], (void**)&data.data.pvChecksum, &data.data.cbChecksum);
+                if (RT_SUCCESS(rc))
+                    rc = HGCMSvcGetU32(&paParms[4], &data.data.cbChecksum);
+            }
+            break;
+        }
+
+        case VBOX_SHARED_CLIPBOARD_FN_READ_DIR:
+        {
+            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_READ_DIR\n"));
+            AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED);
+            break;
+        }
+
+        case VBOX_SHARED_CLIPBOARD_FN_WRITE_DIR:
+        {
+            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_WRITE_DIR\n"));
+            if (cParms == 4)
+            {
+                VBOXCLIPBOARDCBWRITEDIRDATA data;
+                RT_ZERO(data);
+                data.hdr.uMagic = CB_MAGIC_CLIPBOARD_WRITE_DIR;
+
+                rc = HGCMSvcGetU32(&paParms[0], &data.hdr.uContextID);
+                if (RT_SUCCESS(rc))
+                    rc = HGCMSvcGetPv(&paParms[1], (void**)&data.pszPath, &data.cbPath);
+                if (RT_SUCCESS(rc))
+                    rc = HGCMSvcGetU32(&paParms[2], &data.cbPath);
+                if (RT_SUCCESS(rc))
+                    rc = HGCMSvcGetU32(&paParms[3], &data.fMode);
+            }
+            break;
+        }
+
+        case VBOX_SHARED_CLIPBOARD_FN_READ_FILE_HDR:
+        {
+            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_READ_FILE_HDR\n"));
+            AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED);
+            break;
+        }
+
+        case VBOX_SHARED_CLIPBOARD_FN_WRITE_FILE_HDR:
+        {
+            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_WRITE_FILE_HDR\n"));
+            if (cParms == 6)
+            {
+                VBOXCLIPBOARDCBWRITEFILEHDRDATA data;
+                RT_ZERO(data);
+                data.hdr.uMagic = CB_MAGIC_CLIPBOARD_WRITE_FILE_HDR;
+
+                rc = HGCMSvcGetU32(&paParms[0], &data.hdr.uContextID);
+                if (RT_SUCCESS(rc))
+                    rc = HGCMSvcGetPv(&paParms[1], (void**)&data.pszFilePath, &data.cbFilePath);
+                if (RT_SUCCESS(rc))
+                    rc = HGCMSvcGetU32(&paParms[2], &data.cbFilePath);
+                if (RT_SUCCESS(rc))
+                    rc = HGCMSvcGetU32(&paParms[3], &data.fFlags);
+                if (RT_SUCCESS(rc))
+                    rc = HGCMSvcGetU32(&paParms[4], &data.fMode);
+                if (RT_SUCCESS(rc))
+                    rc = HGCMSvcGetU64(&paParms[5], &data.cbSize);
+
+                LogFlowFunc(("pszPath=%s, cbPath=%RU32, fMode=0x%x, cbSize=%RU64\n",
+                             data.pszFilePath, data.cbFilePath, data.fMode, data.cbSize));
+            }
+            break;
+        }
+
+        case VBOX_SHARED_CLIPBOARD_FN_READ_FILE_DATA:
+        {
+            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_READ_FILE_DATA\n"));
+            AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED);
+            break;
+        }
+
+        case VBOX_SHARED_CLIPBOARD_FN_WRITE_FILE_DATA:
+        {
+            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_WRITE_FILE_DATA\n"));
+            if (cParms == 5)
+            {
+                VBOXCLIPBOARDCBWRITEFILEDATADATA data;
+                RT_ZERO(data);
+                data.hdr.uMagic = CB_MAGIC_CLIPBOARD_WRITE_FILE_DATA;
+
+                rc = HGCMSvcGetU32(&paParms[0], &data.hdr.uContextID);
+                if (RT_SUCCESS(rc))
+                    rc = HGCMSvcGetPv(&paParms[1], (void**)&data.pvData, &data.cbData);
+                if (RT_SUCCESS(rc))
+                    rc = HGCMSvcGetU32(&paParms[2], &data.cbData);
+                if (RT_SUCCESS(rc))
+                    rc = HGCMSvcGetPv(&paParms[3], (void**)&data.pvChecksum, &data.cbChecksum);
+                if (RT_SUCCESS(rc))
+                    rc = HGCMSvcGetU32(&paParms[4], &data.cbChecksum);
+
+                LogFlowFunc(("pvData=0x%p, cbData=%RU32\n", data.pvData, data.cbData));
+            }
+            break;
+        }
+
+        case VBOX_SHARED_CLIPBOARD_FN_WRITE_CANCEL:
+            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_WRITE_CANCEL\n"));
+            AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED);
+            break;
+
+        case VBOX_SHARED_CLIPBOARD_FN_WRITE_ERROR:
+            LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_WRITE_ERROR\n"));
+            AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED);
+            break;
+
+        default:
+            AssertMsgFailed(("Not implemented\n"));
+            break;
+    }
+
+    return rc;
 }
 
@@ -43 +296 @@
                                    VBOXHGCMSVCPARM paParms[])
 {
-    RT_NOREF(u32Function, cParms, paParms);
-
-    return VINF_SUCCESS;
+    RT_NOREF(cParms, paParms);
+
+    int rc = VERR_INVALID_PARAMETER; /* Play safe. */
+
+    switch (u32Function)
+    {
+        case VBOX_SHARED_CLIPBOARD_HOST_FN_CANCEL:
+            break;
+
+        case VBOX_SHARED_CLIPBOARD_HOST_FN_ERROR:
+            break;
+
+        default:
+            AssertMsgFailed(("Not implemented\n"));
+            break;
+
+    }
+
+    return rc;
 }
 

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

@@ -22 +22 @@
 #endif
 
-int vboxClipboardSvcURIHandler(uint32_t u32ClientID,
-                               void *pvClient,
-                               uint32_t u32Function,
-                                uint32_t cParms,
-                               VBOXHGCMSVCPARM paParms[],
-                               uint64_t tsArrival,
-                               bool *pfAsync);
-
-int vboxClipboardSvcURIHostHandler(uint32_t u32Function,
-                                   uint32_t cParms,
-                                   VBOXHGCMSVCPARM paParms[]);
+int vboxClipboardSvcURICreate(PVBOXCLIPBOARDCLIENTURIDATA pURIData);
+void vboxClipboardSvcURIDestroy(PVBOXCLIPBOARDCLIENTURIDATA pURIData);
+int vboxClipboardSvcURIHandler(uint32_t u32ClientID, void *pvClient, uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[], uint64_t tsArrival, bool *pfAsync);
+int vboxClipboardSvcURIHostHandler(uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
 
 #endif /* !VBOX_INCLUDED_SRC_SharedClipboard_VBoxSharedClipboardSvc_uri_h */

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

@@ -61 +61 @@
     RTSEMEVENT               hRenderEvent;
     /** Structure for keeping and communicating with client data (from the guest). */
-    PVBOXCLIPBOARDSVCCTX     pSvcCtx;
+    PVBOXCLIPBOARDCLIENTDATA pClientData;
     /** Windows-specific context data. */
     VBOXCLIPBOARDWINCTX      Win;
@@ -160 +160 @@
 static int vboxClipboardReadDataFromClient(VBOXCLIPBOARDCONTEXT *pCtx, VBOXCLIPBOARDFORMAT fFormat)
 {
-    Assert(pCtx->pSvcCtx);
+    Assert(pCtx->pClientData);
     Assert(pCtx->hRenderEvent);
-    Assert(pCtx->pSvcCtx->data.pv == NULL && pCtx->pSvcCtx->data.cb == 0 && pCtx->pSvcCtx->data.u32Format == 0);
+    Assert(pCtx->pClientData->data.pv == NULL && pCtx->pClientData->data.cb == 0 && pCtx->pClientData->data.u32Format == 0);
 
     LogFlowFunc(("fFormat=%02X\n", fFormat));
 
-    vboxSvcClipboardReportMsg(pCtx->pSvcCtx, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, fFormat);
+    vboxSvcClipboardReportMsg(pCtx->pClientData, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, fFormat);
 
     return RTSemEventWait(pCtx->hRenderEvent, 30 * 1000 /* Timeout in ms */);
@@ -289 +289 @@
 
             if (   fFormat       == VBOX_SHARED_CLIPBOARD_FMT_NONE
-                || pCtx->pSvcCtx == NULL)
+                || pCtx->pClientData == NULL)
             {
                 /* Unsupported clipboard format is requested. */
@@ -300 +300 @@
 
                 LogFunc(("vboxClipboardReadDataFromClient rc = %Rrc, pv %p, cb %d, u32Format %d\n",
-                          rc, pCtx->pSvcCtx->data.pv, pCtx->pSvcCtx->data.cb, pCtx->pSvcCtx->data.u32Format));
+                          rc, pCtx->pClientData->data.pv, pCtx->pClientData->data.cb, pCtx->pClientData->data.u32Format));
 
                 if (   RT_SUCCESS (rc)
-                    && pCtx->pSvcCtx->data.pv != NULL
-                    && pCtx->pSvcCtx->data.cb > 0
-                    && pCtx->pSvcCtx->data.u32Format == fFormat)
-                {
-                    HANDLE hMem = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, pCtx->pSvcCtx->data.cb);
+                    && pCtx->pClientData->data.pv != NULL
+                    && pCtx->pClientData->data.cb > 0
+                    && pCtx->pClientData->data.u32Format == fFormat)
+                {
+                    HANDLE hMem = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, pCtx->pClientData->data.cb);
 
                     LogFunc(("hMem %p\n", hMem));
@@ -321 +321 @@
                             LogFunc(("WM_RENDERFORMAT setting data\n"));
 
-                            if (pCtx->pSvcCtx->data.pv)
+                            if (pCtx->pClientData->data.pv)
                             {
-                                memcpy(pMem, pCtx->pSvcCtx->data.pv, pCtx->pSvcCtx->data.cb);
-
-                                RTMemFree(pCtx->pSvcCtx->data.pv);
-                                pCtx->pSvcCtx->data.pv        = NULL;
+                                memcpy(pMem, pCtx->pClientData->data.pv, pCtx->pClientData->data.cb);
+
+                                RTMemFree(pCtx->pClientData->data.pv);
+                                pCtx->pClientData->data.pv        = NULL;
                             }
 
-                            pCtx->pSvcCtx->data.cb        = 0;
-                            pCtx->pSvcCtx->data.u32Format = 0;
+                            pCtx->pClientData->data.cb        = 0;
+                            pCtx->pClientData->data.u32Format = 0;
 
                             /* The memory must be unlocked before inserting to the Clipboard. */
@@ -353 +353 @@
                 }
 
-                RTMemFree(pCtx->pSvcCtx->data.pv);
-                pCtx->pSvcCtx->data.pv        = NULL;
-                pCtx->pSvcCtx->data.cb        = 0;
-                pCtx->pSvcCtx->data.u32Format = 0;
+                RTMemFree(pCtx->pClientData->data.pv);
+                pCtx->pClientData->data.pv        = NULL;
+                pCtx->pClientData->data.cb        = 0;
+                pCtx->pClientData->data.u32Format = 0;
 
                 /* Something went wrong. */
@@ -380 +380 @@
         case VBOX_CLIPBOARD_WM_SET_FORMATS:
         {
-            if (   pCtx->pSvcCtx == NULL
-                || pCtx->pSvcCtx->fHostMsgFormats)
+            if (   pCtx->pClientData == NULL
+                || pCtx->pClientData->State.fHostMsgFormats)
             {
                 /* Host has pending formats message. Ignore the guest announcement,
@@ -545 +545 @@
     int rc;
 
-    if (pCtx->pSvcCtx)
+    if (pCtx->pClientData)
     {
         uint32_t uFormats;
         rc = VBoxClipboardWinGetFormats(&pCtx->Win, &uFormats);
         if (RT_SUCCESS(rc))
-            vboxSvcClipboardReportMsg(pCtx->pSvcCtx, VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS, uFormats);
+            vboxSvcClipboardReportMsg(pCtx->pClientData, VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS, uFormats);
     }
     else /* If we don't have any client data (yet), bail out. */
@@ -602 +602 @@
 }
 
-int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDSVCCTX pSvcCtx, bool fHeadless)
+int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDCLIENTDATA pClientData, bool fHeadless)
 {
     RT_NOREF(fHeadless);
@@ -608 +608 @@
     LogFlowFuncEnter();
 
-    if (g_ctx.pSvcCtx != NULL)
+    if (g_ctx.pClientData != NULL)
     {
         /* One client only. */
@@ -614 +614 @@
     }
 
-    pSvcCtx->pCtx = &g_ctx;
-
-    pSvcCtx->pCtx->pSvcCtx = pSvcCtx;
+    pClientData->State.pCtx = &g_ctx;
+
+    pClientData->State.pCtx->pClientData = pClientData;
 
     /* Sync the host clipboard content with the client. */
-    VBoxClipboardSvcImplSync(pSvcCtx);
+    VBoxClipboardSvcImplSync(pClientData);
 
     return VINF_SUCCESS;
 }
 
-int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDSVCCTX pSvcCtx)
+int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDCLIENTDATA pClientData)
 {
     /* Sync the host clipboard content with the client. */
-    return vboxClipboardWinSyncInternal(pSvcCtx->pCtx);
-}
-
-void VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDSVCCTX pSvcCtx)
-{
-    RT_NOREF(pSvcCtx);
+    return vboxClipboardWinSyncInternal(pClientData->State.pCtx);
+}
+
+void VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDCLIENTDATA pClientData)
+{
+    RT_NOREF(pClientData);
 
     LogFlowFuncEnter();
 
-    g_ctx.pSvcCtx = NULL;
-}
-
-void VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDSVCCTX pSvcCtx, uint32_t u32Formats)
-{
-    AssertPtrReturnVoid(pSvcCtx);
-    AssertPtrReturnVoid(pSvcCtx->pCtx);
+    g_ctx.pClientData = NULL;
+}
+
+void VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t u32Formats)
+{
+    AssertPtrReturnVoid(pClientData);
+    AssertPtrReturnVoid(pClientData->State.pCtx);
 
     /*
      * The guest announces formats. Forward to the window thread.
      */
-    PostMessage(pSvcCtx->pCtx->Win.hWnd, WM_USER, 0, u32Formats);
+    PostMessage(pClientData->State.pCtx->Win.hWnd, WM_USER, 0, u32Formats);
 }
 
@@ -682 +682 @@
 #endif
 
-int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDSVCCTX pSvcCtx, uint32_t u32Format, void *pv, uint32_t cb, uint32_t *pcbActual)
-{
-    AssertPtrReturn(pSvcCtx,       VERR_INVALID_POINTER);
-    AssertPtrReturn(pSvcCtx->pCtx, VERR_INVALID_POINTER);
+int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t u32Format, void *pv, uint32_t cb, uint32_t *pcbActual)
+{
+    AssertPtrReturn(pClientData,       VERR_INVALID_POINTER);
+    AssertPtrReturn(pClientData->State.pCtx, VERR_INVALID_POINTER);
 
     LogFlowFunc(("u32Format=%02X\n", u32Format));
@@ -691 +691 @@
     HANDLE hClip = NULL;
 
-    const PVBOXCLIPBOARDWINCTX pWinCtx = &pSvcCtx->pCtx->Win;
+    const PVBOXCLIPBOARDWINCTX pWinCtx = &pClientData->State.pCtx->Win;
 
     /*
@@ -816 +816 @@
 }
 
-void VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDSVCCTX pSvcCtx, void *pv, uint32_t cb, uint32_t u32Format)
+void VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDCLIENTDATA pClientData, void *pv, uint32_t cb, uint32_t u32Format)
 {
     LogFlowFuncEnter();
@@ -823 +823 @@
      * The guest returns data that was requested in the WM_RENDERFORMAT handler.
      */
-    Assert(pSvcCtx->data.pv == NULL && pSvcCtx->data.cb == 0 && pSvcCtx->data.u32Format == 0);
+    Assert(pClientData->data.pv == NULL && pClientData->data.cb == 0 && pClientData->data.u32Format == 0);
 
     vboxClipboardDump(pv, cb, u32Format);
@@ -841 +841 @@
                 if (pszResult != NULL && cbResult != 0)
                 {
-                    pSvcCtx->data.pv        = pszResult;
-                    pSvcCtx->data.cb        = cbResult;
-                    pSvcCtx->data.u32Format = u32Format;
+                    pClientData->data.pv        = pszResult;
+                    pClientData->data.cb        = cbResult;
+                    pClientData->data.u32Format = u32Format;
                 }
             }
@@ -849 +849 @@
         else
         {
-            pSvcCtx->data.pv = RTMemDup(pv, cb);
-            if (pSvcCtx->data.pv)
-            {
-                pSvcCtx->data.cb = cb;
-                pSvcCtx->data.u32Format = u32Format;
-            }
-        }
-    }
-
-    AssertPtr(pSvcCtx->pCtx);
-    int rc = RTSemEventSignal(pSvcCtx->pCtx->hRenderEvent);
+            pClientData->data.pv = RTMemDup(pv, cb);
+            if (pClientData->data.pv)
+            {
+                pClientData->data.cb = cb;
+                pClientData->data.u32Format = u32Format;
+            }
+        }
+    }
+
+    AssertPtr(pClientData->State.pCtx);
+    int rc = RTSemEventSignal(pClientData->State.pCtx->hRenderEvent);
     AssertRC(rc);
 

trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11-stubs.cpp

@@ -55 +55 @@
   * Enable the shared clipboard - called by the hgcm clipboard subsystem.
   *
-  * @param   pSvcCtx    Structure containing context information about the guest system
-  * @param   fHeadless  Whether headless.
+  * @param   pClientData    Structure containing context information about the guest system
+  * @param   fHeadless      Whether headless.
   * @returns RT status code
   */
-int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDSVCCTX pSvcCtx, bool fHeadless)
+int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDCLIENTDATA pClientData, bool fHeadless)
 {
-    RT_NOREF(pSvcCtx, fHeadless);
+    RT_NOREF(pClientData, fHeadless);
     LogFlowFunc(("called, returning VINF_SUCCESS.\n"));
     return VINF_SUCCESS;
@@ -70 +70 @@
  * after a save and restore of the guest.
  */
-int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDSVCCTX /* pSvcCtx */)
+int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDCLIENTDATA /* pClientData */)
 {
     LogFlowFunc(("called, returning VINF_SUCCESS.\n"));
@@ -79 +79 @@
  * Shut down the shared clipboard subsystem and "disconnect" the guest.
  *
- * @param   pSvcCtx    Structure containing context information about the guest system
+ * @param   pClientData    Structure containing context information about the guest system
  */
-void VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDSVCCTX pSvcCtx)
+void VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDCLIENTDATA pClientData)
 {
-    RT_NOREF(pSvcCtx);
+    RT_NOREF(pClientData);
     LogFlowFunc(("called, returning.\n"));
 }
@@ -91 +91 @@
  * subsystem.
  *
- * @param pSvcCtx    Context data for the guest system
+ * @param pClientData    Context data for the guest system
  * @param u32Formats Clipboard formats the guest is offering
  */
-void VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDSVCCTX pSvcCtx, uint32_t u32Formats)
+void VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t u32Formats)
 {
-    RT_NOREF(pSvcCtx, u32Formats);
+    RT_NOREF(pClientData, u32Formats);
     LogFlowFunc(("called, returning.\n"));
 }
@@ -103 +103 @@
  * Called by the HGCM clipboard subsystem when the guest wants to read the host clipboard.
  *
- * @param pSvcCtx   Context information about the guest VM
- * @param u32Format The format that the guest would like to receive the data in
- * @param pv        Where to write the data to
- * @param cb        The size of the buffer to write the data to
- * @param pcbActual Where to write the actual size of the written data
+ * @param pClientData   Context information about the guest VM
+ * @param u32Format     The format that the guest would like to receive the data in
+ * @param pv            Where to write the data to
+ * @param cb            The size of the buffer to write the data to
+ * @param pcbActual     Where to write the actual size of the written data
  */
-int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDSVCCTX pSvcCtx, uint32_t u32Format,
+int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t u32Format,
                           void *pv, uint32_t cb, uint32_t *pcbActual)
 {
-    RT_NOREF(pSvcCtx, u32Format, pv, cb);
+    RT_NOREF(pClientData, u32Format, pv, cb);
     LogFlowFunc(("called, returning VINF_SUCCESS.\n"));
     /* No data available. */
@@ -122 +122 @@
  * Called by the HGCM clipboard subsystem when we have requested data and that data arrives.
  *
- * @param pSvcCtx   Context information about the guest VM
- * @param pv        Buffer to which the data was written
- * @param cb        The size of the data written
- * @param u32Format The format of the data written
+ * @param pClientData   Context information about the guest VM
+ * @param pv            Buffer to which the data was written
+ * @param cb            The size of the data written
+ * @param u32Format     The format of the data written
  */
-void VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDSVCCTX pSvcCtx, void *pv, uint32_t cb,
+void VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDCLIENTDATA pClientData, void *pv, uint32_t cb,
                             uint32_t u32Format)
 {
-    RT_NOREF(pSvcCtx, pv, cb, u32Format);
+    RT_NOREF(pClientData, pv, cb, u32Format);
     LogFlowFunc(("called, returning.\n"));
 }

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

@@ -32 +32 @@
 #include <VBox/err.h>
 
-#include "VBoxClipboard.h"
+#include "VBoxSharedClipboardSvc-internal.h"
 
 
@@ -59 +59 @@
     CLIPBACKEND *pBackend;
     /** Pointer to the VBox host client data structure. */
-    PVBOXCLIPBOARDSVCCTX pSvcCtx;
+    PVBOXCLIPBOARDCLIENTDATA pClientData;
     /** We set this when we start shutting down as a hint not to post any new
      * requests. */
@@ -75 +75 @@
 void ClipReportX11Formats(VBOXCLIPBOARDCONTEXT *pCtx, uint32_t u32Formats)
 {
-    LogRelFlowFunc(("called.  pCtx=%p, u32Formats=%02X\n", pCtx, u32Formats));
-    vboxSvcClipboardReportMsg(pCtx->pSvcCtx,
-                              VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS,
-                              u32Formats);
+    LogFlowFunc(("pCtx=%p, u32Formats=%02X\n", pCtx, u32Formats));
+
+    vboxSvcClipboardReportMsg(pCtx->pClientData, VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS, u32Formats);
 }
 
@@ -105 +104 @@
  *        the clipboard and leave ownership to X11.
  */
-int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDSVCCTX pSvcCtx, bool fHeadless)
+int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDCLIENTDATA pClientData, bool fHeadless)
 {
     int rc = VINF_SUCCESS;
-    CLIPBACKEND *pBackend = NULL;
 
     LogRel(("Starting host clipboard service\n"));
-    VBOXCLIPBOARDCONTEXT *pCtx = (VBOXCLIPBOARDCONTEXT *)RTMemAllocZ(sizeof(VBOXCLIPBOARDCONTEXT));
+
+    PVBOXCLIPBOARDCONTEXT pCtx = (PVBOXCLIPBOARDCONTEXT)RTMemAllocZ(sizeof(VBOXCLIPBOARDCONTEXT));
     if (!pCtx)
+    {
         rc = VERR_NO_MEMORY;
+    }
     else
     {
         RTCritSectInit(&pCtx->clipboardMutex);
-        pBackend = ClipConstructX11(pCtx, fHeadless);
-        if (pBackend == NULL)
+        CLIPBACKEND *pBackend = ClipConstructX11(pCtx, fHeadless);
+        if (!pBackend)
+        {
             rc = VERR_NO_MEMORY;
+        }
         else
         {
             pCtx->pBackend = pBackend;
-            pSvcCtx->pCtx = pCtx;
-            pCtx->pSvcCtx = pSvcCtx;
+            pClientData->State.pCtx = pCtx;
+            pCtx->pClientData = pClientData;
+
             rc = ClipStartX11(pBackend, true /* grab shared clipboard */);
+            if (RT_FAILURE(rc))
+                ClipDestructX11(pBackend);
         }
+
         if (RT_FAILURE(rc))
+        {
             RTCritSectDelete(&pCtx->clipboardMutex);
-    }
+            RTMemFree(pCtx);
+        }
+    }
+
     if (RT_FAILURE(rc))
-    {
-        RTMemFree(pCtx);
-        LogRel(("Failed to initialise the shared clipboard\n"));
-    }
-    LogRelFlowFunc(("returning %Rrc\n", rc));
+        LogRel(("Failed to initialize the Shared Clipboard host service, rc=%Rrc\n", rc));
+
+    LogFlowFunc(("returning %Rrc\n", rc));
     return rc;
 }
@@ -144 +153 @@
  * @note  Host glue code
  */
-int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDSVCCTX pSvcCtx)
+int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDCLIENTDATA pClientData)
 {
     /* Tell the guest we have no data in case X11 is not available.  If
      * there is data in the host clipboard it will automatically be sent to
      * the guest when the clipboard starts up. */
-    vboxSvcClipboardReportMsg(pSvcCtx, VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS, 0);
-    /** @todo r=andy Check rc code. */
-    return VINF_SUCCESS;
+    vboxSvcClipboardReportMsg(pClientData, VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS, 0);
+
+    return VINF_SUCCESS; /** @todo r=andy Check rc code. */
 }
 
@@ -158 +167 @@
  * @note  Host glue code
  */
-void VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDSVCCTX pSvcCtx)
-{
-    LogRelFlow(("vboxClipboardDisconnect\n"));
+void VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDCLIENTDATA pClientData)
+{
+    LogFlowFuncEnter();
 
     LogRel(("Stopping the host clipboard service\n"));
-    VBOXCLIPBOARDCONTEXT *pCtx = pSvcCtx->pCtx;
+
+    PVBOXCLIPBOARDCONTEXT pCtx = pClientData->State.pCtx;
+
     /* Drop the reference to the client, in case it is still there.  This
      * will cause any outstanding clipboard data requests from X11 to fail
      * immediately. */
     pCtx->fShuttingDown = true;
+
     /* If there is a currently pending request, release it immediately. */
-    VBoxClipboardSvcImplWriteData(pSvcCtx, NULL, 0, 0);
+    VBoxClipboardSvcImplWriteData(pClientData, NULL, 0, 0);
+
     int rc = ClipStopX11(pCtx->pBackend);
     /** @todo handle this slightly more reasonably, or be really sure
      *        it won't go wrong. */
     AssertRC(rc);
+
     if (RT_SUCCESS(rc))  /* And if not? */
     {
@@ -185 +199 @@
  * VBox is taking possession of the shared clipboard.
  *
- * @param pSvcCtx    Context data for the guest system
+ * @param pClientData    Context data for the guest system
  * @param u32Formats Clipboard formats the guest is offering
  * @note  Host glue code
  */
-void VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDSVCCTX pSvcCtx, uint32_t u32Formats)
-{
-    LogRelFlowFunc(("called.  pSvcCtx=%p, u32Formats=%02X\n", pSvcCtx, u32Formats));
-
-    ClipAnnounceFormatToX11(pSvcCtx->pCtx->pBackend, u32Formats);
+void VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t u32Formats)
+{
+    LogFlowFunc(("pClientData=%p, u32Formats=%02X\n", pClientData, u32Formats));
+
+    ClipAnnounceFormatToX11(pClientData->State.pCtx->pBackend, u32Formats);
 }
 
@@ -214 +228 @@
  *          asynchronously
  * @returns iprt status code on failure
- * @param  pSvcCtx   Context information about the guest VM
- * @param  u32Format The format that the guest would like to receive the data in
- * @param  pv        Where to write the data to
- * @param  cb        The size of the buffer to write the data to
+ * @param  pClientData   Context information about the guest VM
+ * @param  u32Format     The format that the guest would like to receive the data in
+ * @param  pv            Where to write the data to
+ * @param  cb            The size of the buffer to write the data to
  * @param  pcbActual Where to write the actual size of the written data
+ *
  * @note   We always fail or complete asynchronously
  * @note   On success allocates a CLIPREADCBREQ structure which must be
@@ -225 +240 @@
  *
  */
-int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDSVCCTX pSvcCtx,
-                          uint32_t u32Format, void *pv, uint32_t cb,
-                          uint32_t *pcbActual)
-{
-    LogRelFlowFunc(("pSvcCtx=%p, u32Format=%02X, pv=%p, cb=%u, pcbActual=%p",
-                    pSvcCtx, u32Format, pv, cb, pcbActual));
+int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDCLIENTDATA pClientData,
+                          uint32_t u32Format, void *pv, uint32_t cb, uint32_t *pcbActual)
+{
+    LogFlowFunc(("pClientData=%p, u32Format=%02X, pv=%p, cb=%u, pcbActual=%p\n",
+                 pClientData, u32Format, pv, cb, pcbActual));
 
     int rc = VINF_SUCCESS;
     CLIPREADCBREQ *pReq = (CLIPREADCBREQ *)RTMemAlloc(sizeof(CLIPREADCBREQ));
     if (!pReq)
+    {
         rc = VERR_NO_MEMORY;
+    }
     else
     {
@@ -241 +257 @@
         pReq->cb = cb;
         pReq->pcbActual = pcbActual;
-        rc = ClipRequestDataFromX11(pSvcCtx->pCtx->pBackend, u32Format, pReq);
+        rc = ClipRequestDataFromX11(pClientData->State.pCtx->pBackend, u32Format, pReq);
         if (RT_SUCCESS(rc))
             rc = VINF_HGCM_ASYNC_EXECUTE;
     }
-    LogRelFlowFunc(("returning %Rrc\n", rc));
+
+    LogFlowFuncLeaveRC(rc);
     return rc;
 }
@@ -269 +286 @@
     RTMemFree(pReq);
 
-    vboxSvcClipboardCompleteReadData(pCtx->pSvcCtx, rc, cb);
+    vboxSvcClipboardCompleteReadData(pCtx->pClientData, rc, cb);
 }
 
@@ -292 +309 @@
     int rc = VINF_SUCCESS;
 
-    LogRelFlowFunc(("pCtx=%p, pReq=%p, u32Format=%02X\n", pCtx, pReq, u32Format));
+    LogFlowFunc(("pCtx=%p, pReq=%p, u32Format=%02X\n", pCtx, pReq, u32Format));
 
     /* Request data from VBox */
-    vboxSvcClipboardReportMsg(pCtx->pSvcCtx,
+    vboxSvcClipboardReportMsg(pCtx->pClientData,
                               VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
                               u32Format);
@@ -302 +319 @@
      */
     rc = RTSemEventWait(pReq->finished, CLIPBOARD_TIMEOUT);
+
     /* If the request hasn't yet completed then we cancel it.  We use
      * the critical section to prevent these operations colliding. */
     RTCritSectEnter(&pCtx->clipboardMutex);
+
     /* The data may have arrived between the semaphore timing out and
      * our grabbing the mutex. */
@@ -312 +331 @@
         pCtx->pReq = NULL;
     Assert(pCtx->pReq == NULL);
+
     RTCritSectLeave(&pCtx->clipboardMutex);
+
     if (RT_SUCCESS(rc) && (pReq->pv == NULL))
         rc = VERR_NO_DATA;
-    LogRelFlowFunc(("returning %Rrc\n", rc));
+
+    LogFlowFuncLeaveRC(rc);
     return rc;
 }
@@ -325 +347 @@
     int rc = VINF_SUCCESS;
 
-    LogRelFlowFunc(("pCtx=%p, pReq=%p, u32Format=%02X\n", pCtx, pReq, u32Format));
+    LogFlowFunc(("pCtx=%p, pReq=%p, u32Format=%02X\n", pCtx, pReq, u32Format));
 
     /* Start by "posting" the request for the next invocation of
      * vboxClipboardWriteData. */
     RTCritSectEnter(&pCtx->clipboardMutex);
+
     if (pCtx->pReq != NULL)
     {
@@ -339 +362 @@
     else
         pCtx->pReq = pReq;
+
     RTCritSectLeave(&pCtx->clipboardMutex);
+
     if (RT_SUCCESS(rc))
         rc = clipWaitForDataFromVBox(pCtx, pReq, u32Format);
-    LogRelFlowFunc(("returning %Rrc\n", rc));
+
+    LogFlowFuncLeaveRC(rc);
     return rc;
 }
@@ -361 +387 @@
     VBOXCLIPBOARDREQFROMVBOX request = { NULL, 0, 0, NIL_RTSEMEVENT };
 
-    LogRelFlowFunc(("pCtx=%p, u32Format=%02X, ppv=%p, pcb=%p\n", pCtx, u32Format, ppv, pcb));
+    LogFlowFunc(("pCtx=%p, u32Format=%02X, ppv=%p, pcb=%p\n", pCtx, u32Format, ppv, pcb));
 
     if (pCtx->fShuttingDown)
     {
         /* The shared clipboard is disconnecting. */
-        LogRelFunc(("host requested guest clipboard data after guest had disconnected.\n"));
+        LogRel(("Clipboard: Host requested guest clipboard data after guest had disconnected\n"));
         return VERR_WRONG_ORDER;
     }
+
     int rc = RTSemEventCreate(&request.finished);
     if (RT_SUCCESS(rc))
@@ -382 +409 @@
     }
 
-    LogRelFlowFunc(("returning %Rrc\n", rc));
-
-    if (RT_SUCCESS(rc))
-        LogRelFlowFunc(("*ppv=%.*ls, *pcb=%u\n",*pcb / 2,*ppv,*pcb));
-
+    LogFlowFuncLeaveRC(rc);
     return rc;
 }
@@ -393 +416 @@
  * Called when we have requested data from VBox and that data has arrived.
  *
- * @param  pSvcCtx   Context information about the guest VM
- * @param  pv        Buffer to which the data was written
- * @param  cb        The size of the data written
- * @param  u32Format The format of the data written
+ * @param  pClientData   Context information about the guest VM
+ * @param  pv            Buffer to which the data was written
+ * @param  cb            The size of the data written
+ * @param  u32Format     The format of the data written
  * @note   Host glue code
  */
-void VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDSVCCTX pSvcCtx,
-                            void *pv, uint32_t cb, uint32_t u32Format)
-{
-    LogRelFlowFunc(("called.  pSvcCtx=%p, pv=%p (%.*ls), cb=%u, u32Format=%02X\n",
-                    pSvcCtx, pv, cb / 2, pv, cb, u32Format));
-
-    VBOXCLIPBOARDCONTEXT *pCtx = pSvcCtx->pCtx;
+void VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDCLIENTDATA pClientData,
+                                   void *pv, uint32_t cb, uint32_t u32Format)
+{
+    LogFlowFunc(("pClientData=%p, pv=%p (%.*ls), cb=%u, u32Format=%02X\n", pClientData, pv, cb / 2, pv, cb, u32Format));
+
+    VBOXCLIPBOARDCONTEXT *pCtx = pClientData->State.pCtx;
 
     /* Grab the mutex and check whether there is a pending request for data. */
@@ -463 +485 @@
 };
 
-void vboxSvcClipboardReportMsg(PVBOXCLIPBOARDSVCCTX pSvcCtx, uint32_t u32Msg, uint32_t u32Formats)
+void vboxSvcClipboardReportMsg(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t u32Msg, uint32_t u32Formats)
 {
     RT_NOREF(u32Formats);
-    CLIPBACKEND *pBackend = pSvcCtx->pCtx->pBackend;
+    CLIPBACKEND *pBackend = pClientData->State.pCtx->pBackend;
 
     if ((u32Msg == VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA)
         && !pBackend->writeData.timeout)
-        VBoxClipboardSvcImplWriteData(pSvcCtx, pBackend->writeData.pv,
+        VBoxClipboardSvcImplWriteData(pClientData, pBackend->writeData.pv,
                                pBackend->writeData.cb,
                                pBackend->writeData.format);
@@ -477 +499 @@
 }
 
-void vboxSvcClipboardCompleteReadData(PVBOXCLIPBOARDSVCCTX pSvcCtx, int rc, uint32_t cbActual)
-{
-    CLIPBACKEND *pBackend = pSvcCtx->pCtx->pBackend;
+void vboxSvcClipboardCompleteReadData(PVBOXCLIPBOARDCLIENTDATA pClientData, int rc, uint32_t cbActual)
+{
+    CLIPBACKEND *pBackend = pClientData->State.pCtx->pBackend;
     pBackend->completeRead.rc = rc;
     pBackend->completeRead.cbActual = cbActual;
@@ -523 +545 @@
 int main()
 {
-    VBOXCLIPBOARDSVCCTX client;
+    VBOXCLIPBOARDCLIENTDATA client;
     unsigned cErrors = 0;
     int rc = RTR3InitExeNoArguments(0);

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

@@ -85 +85 @@
 #include <VBox/vmm/ssm.h>
 
-#include "VBoxClipboard.h"
+#include "VBoxSharedClipboardSvc-internal.h"
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
 # include "VBoxSharedClipboardSvc-uri.h"
@@ -96 +96 @@
 static PVBOXHGCMSVCHELPERS g_pHelpers;
 
-static RTCRITSECT critsect;
-static uint32_t g_u32Mode;
+static RTCRITSECT g_CritSect;
+static uint32_t g_uMode;
 
 static PFNHGCMSVCEXT g_pfnExtension;
 static void *g_pvExtension;
 
-static PVBOXCLIPBOARDSVCCTX g_pSvcCtx;
+static PVBOXCLIPBOARDCLIENTDATA g_pClientData;
 
 /* Serialization of data reading and format announcements from the RDP client. */
@@ -151 +151 @@
 }
 
-
-static uint32_t vboxSvcClipboardMode(void)
-{
-    return g_u32Mode;
+uint32_t vboxSvcClipboardGetMode(void)
+{
+    return g_uMode;
 }
 
@@ -161 +160 @@
 uint32_t TestClipSvcGetMode(void)
 {
-    return vboxSvcClipboardMode();
+    return vboxSvcClipboardGetMode();
 }
 #endif
@@ -179 +178 @@
         case VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST:
         case VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL:
-            g_u32Mode = u32Mode;
+            g_uMode = u32Mode;
             break;
 
         default:
-            g_u32Mode = VBOX_SHARED_CLIPBOARD_MODE_OFF;
+            g_uMode = VBOX_SHARED_CLIPBOARD_MODE_OFF;
     }
 }
@@ -189 +188 @@
 bool VBoxSvcClipboardLock(void)
 {
-    return RT_SUCCESS(RTCritSectEnter(&critsect));
+    return RT_SUCCESS(RTCritSectEnter(&g_CritSect));
 }
 
 void VBoxSvcClipboardUnlock(void)
 {
-    RTCritSectLeave(&critsect);
+    int rc2 = RTCritSectLeave(&g_CritSect);
+    AssertRC(rc2);
 }
 
@@ -200 +200 @@
  * Executed under the clipboard lock.
  */
-static bool vboxSvcClipboardReturnMsg(PVBOXCLIPBOARDSVCCTX pSvcCtx, VBOXHGCMSVCPARM paParms[])
+static bool vboxSvcClipboardReturnMsg(PVBOXCLIPBOARDCLIENTDATA pClientData, VBOXHGCMSVCPARM paParms[])
 {
     /* Message priority is taken into account. */
-    if (pSvcCtx->fHostMsgQuit)
+    if (pClientData->State.fHostMsgQuit)
     {
         LogFlowFunc(("vboxSvcClipboardReturnMsg: Quit\n"));
         VBoxHGCMParmUInt32Set(&paParms[0], VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT);
         VBoxHGCMParmUInt32Set(&paParms[1], 0);
-        pSvcCtx->fHostMsgQuit = false;
-    }
-    else if (pSvcCtx->fHostMsgReadData)
+        pClientData->State.fHostMsgQuit = false;
+    }
+    else if (pClientData->State.fHostMsgReadData)
     {
         uint32_t fFormat = 0;
 
-        LogFlowFunc(("vboxSvcClipboardReturnMsg: ReadData %02X\n", pSvcCtx->u32RequestedFormat));
-        if (pSvcCtx->u32RequestedFormat & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
+        LogFlowFunc(("vboxSvcClipboardReturnMsg: ReadData %02X\n", pClientData->State.u32RequestedFormat));
+        if (pClientData->State.u32RequestedFormat & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
             fFormat = VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT;
-        else if (pSvcCtx->u32RequestedFormat & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
+        else if (pClientData->State.u32RequestedFormat & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
             fFormat = VBOX_SHARED_CLIPBOARD_FMT_BITMAP;
-        else if (pSvcCtx->u32RequestedFormat & VBOX_SHARED_CLIPBOARD_FMT_HTML)
+        else if (pClientData->State.u32RequestedFormat & VBOX_SHARED_CLIPBOARD_FMT_HTML)
             fFormat = VBOX_SHARED_CLIPBOARD_FMT_HTML;
 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
-        else if (pSvcCtx->u32RequestedFormat & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
+        else if (pClientData->State.u32RequestedFormat & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)
             fFormat = VBOX_SHARED_CLIPBOARD_FMT_URI_LIST;
 #endif
@@ -228 +228 @@
         {
             LogRel2(("Clipboard: Unsupported format from guest (0x%x), skipping\n", fFormat));
-            pSvcCtx->u32RequestedFormat = 0;
+            pClientData->State.u32RequestedFormat = 0;
         }
-        pSvcCtx->u32RequestedFormat &= ~fFormat;
+        pClientData->State.u32RequestedFormat &= ~fFormat;
         VBoxHGCMParmUInt32Set(&paParms[0], VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
         VBoxHGCMParmUInt32Set(&paParms[1], fFormat);
-        if (pSvcCtx->u32RequestedFormat == 0)
-            pSvcCtx->fHostMsgReadData = false;
-    }
-    else if (pSvcCtx->fHostMsgFormats)
-    {
-        LogFlowFunc(("vboxSvcClipboardReturnMsg: Formats %02X\n", pSvcCtx->u32AvailableFormats));
+        if (pClientData->State.u32RequestedFormat == 0)
+            pClientData->State.fHostMsgReadData = false;
+    }
+    else if (pClientData->State.fHostMsgFormats)
+    {
+        LogFlowFunc(("vboxSvcClipboardReturnMsg: Formats %02X\n", pClientData->State.u32AvailableFormats));
         VBoxHGCMParmUInt32Set(&paParms[0], VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS);
-        VBoxHGCMParmUInt32Set(&paParms[1], pSvcCtx->u32AvailableFormats);
-        pSvcCtx->fHostMsgFormats = false;
+        VBoxHGCMParmUInt32Set(&paParms[1], pClientData->State.u32AvailableFormats);
+        pClientData->State.fHostMsgFormats = false;
     }
     else
@@ -254 +254 @@
 }
 
-void vboxSvcClipboardReportMsg(PVBOXCLIPBOARDSVCCTX pSvcCtx, uint32_t u32Msg, uint32_t u32Formats)
-{
-    AssertPtrReturnVoid(pSvcCtx);
+void vboxSvcClipboardReportMsg(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t u32Msg, uint32_t u32Formats)
+{
+    AssertPtrReturnVoid(pClientData);
 
     if (VBoxSvcClipboardLock())
@@ -265 +265 @@
             {
                 LogFlowFunc(("Quit\n"));
-                pSvcCtx->fHostMsgQuit = true;
+                pClientData->State.fHostMsgQuit = true;
             } break;
             case VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA:
             {
-                if (   vboxSvcClipboardMode () != VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST
-                    && vboxSvcClipboardMode () != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
+                if (   vboxSvcClipboardGetMode () != VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST
+                    && vboxSvcClipboardGetMode () != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
                 {
                     /* Skip the message. */
@@ -277 +277 @@
 
                 LogFlowFunc(("ReadData %02X\n", u32Formats));
-                pSvcCtx->u32RequestedFormat = u32Formats;
-                pSvcCtx->fHostMsgReadData = true;
+                pClientData->State.u32RequestedFormat = u32Formats;
+                pClientData->State.fHostMsgReadData = true;
             } break;
             case VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS:
             {
-                if (   vboxSvcClipboardMode () != VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST
-                    && vboxSvcClipboardMode () != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
+                if (   vboxSvcClipboardGetMode () != VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST
+                    && vboxSvcClipboardGetMode () != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
                 {
                     /* Skip the message. */
@@ -290 +290 @@
 
                 LogFlowFunc(("Formats %02X\n", u32Formats));
-                pSvcCtx->u32AvailableFormats = u32Formats;
-                pSvcCtx->fHostMsgFormats = true;
+                pClientData->State.u32AvailableFormats = u32Formats;
+                pClientData->State.fHostMsgFormats = true;
             } break;
             default:
@@ -300 +300 @@
         }
 
-        if (pSvcCtx->fAsync)
+        if (pClientData->State.fAsync)
         {
             /* The client waits for a response. */
-            bool fMessageReturned = vboxSvcClipboardReturnMsg(pSvcCtx, pSvcCtx->async.paParms);
+            bool fMessageReturned = vboxSvcClipboardReturnMsg(pClientData, pClientData->State.async.paParms);
 
             /* Make a copy of the handle. */
-            VBOXHGCMCALLHANDLE callHandle = pSvcCtx->async.callHandle;
+            VBOXHGCMCALLHANDLE callHandle = pClientData->State.async.callHandle;
 
             if (fMessageReturned)
             {
                 /* There is a response. */
-                pSvcCtx->fAsync = false;
+                pClientData->State.fAsync = false;
             }
 
@@ -331 +331 @@
 static int svcInit(void)
 {
-    int rc = RTCritSectInit(&critsect);
+    int rc = RTCritSectInit(&g_CritSect);
 
     if (RT_SUCCESS(rc))
@@ -344 +344 @@
         if (RT_FAILURE(rc))
         {
-            RTCritSectDelete(&critsect);
+            RTCritSectDelete(&g_CritSect);
         }
     }
@@ -354 +354 @@
 {
     VBoxClipboardSvcImplDestroy();
-    RTCritSectDelete(&critsect);
+    RTCritSectDelete(&g_CritSect);
     return VINF_SUCCESS;
 }
@@ -366 +366 @@
     RT_NOREF(u32ClientID);
 
-    PVBOXCLIPBOARDSVCCTX pSvcCtx = (PVBOXCLIPBOARDSVCCTX)pvClient;
+    PVBOXCLIPBOARDCLIENTDATA pClientData = (PVBOXCLIPBOARDCLIENTDATA)pvClient;
 
     LogFunc(("u32ClientID = %d\n", u32ClientID));
 
-    vboxSvcClipboardReportMsg(pSvcCtx, VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT, 0);
-
-    vboxSvcClipboardCompleteReadData(pSvcCtx, VERR_NO_DATA, 0);
-
-    VBoxClipboardSvcImplDisconnect(pSvcCtx);
-
-    memset(pSvcCtx, 0, sizeof(*pSvcCtx));
-
-    g_pSvcCtx = NULL;
+    vboxSvcClipboardReportMsg(pClientData, VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT, 0);
+
+    vboxSvcClipboardCompleteReadData(pClientData, VERR_NO_DATA, 0);
+
+#ifdef VBOX_VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
+    vboxClipboardSvcURIDestroy(&pClientData->URI);
+#endif
+
+    VBoxClipboardSvcImplDisconnect(pClientData);
+
+    g_pClientData = NULL;
 
     return VINF_SUCCESS;
@@ -386 +388 @@
 {
     RT_NOREF(fRequestor, fRestoring);
-    PVBOXCLIPBOARDSVCCTX pSvcCtx = (PVBOXCLIPBOARDSVCCTX)pvClient;
-
-    int rc = VINF_SUCCESS;
+    PVBOXCLIPBOARDCLIENTDATA pClientData = (PVBOXCLIPBOARDCLIENTDATA)pvClient;
 
     /* If there is already a client connected then we want to release it first. */
-    if (g_pSvcCtx != NULL)
-    {
-        uint32_t u32OldClientID = g_pSvcCtx->u32ClientID;
-
-        svcDisconnect(NULL, u32OldClientID, g_pSvcCtx);
+    if (g_pClientData != NULL)
+    {
+        uint32_t u32OldClientID = g_pClientData->State.u32ClientID;
+
+        svcDisconnect(NULL, u32OldClientID, g_pClientData);
+
         /* And free the resources in the hgcm subsystem. */
         g_pHelpers->pfnDisconnectClient(g_pHelpers->pvInstance, u32OldClientID);
     }
 
-    /* Register the client. */
-    memset(pSvcCtx, 0, sizeof(*pSvcCtx));
-
-    pSvcCtx->u32ClientID = u32ClientID;
-
-    rc = VBoxClipboardSvcImplConnect(pSvcCtx, VBoxSvcClipboardGetHeadless());
-
+    /* Register the client.
+     * Note: Do *not* memset the struct, as it contains classes (for caching). */
+    pClientData->State.u32ClientID = u32ClientID;
+
+    int rc = VBoxClipboardSvcImplConnect(pClientData, VBoxSvcClipboardGetHeadless());
+#ifdef VBOX_VBOX_WITH_SHARED_CLIPBOARD_URI_LIST
     if (RT_SUCCESS(rc))
-    {
-        g_pSvcCtx = pSvcCtx;
+        rc = vboxClipboardSvcURICreate(&pClientData->URI);
+#endif
+
+    if (RT_SUCCESS(rc))
+    {
+        g_pClientData = pClientData;
     }
 
@@ -431 +435 @@
              u32ClientID, u32Function, cParms, paParms));
 
-    PVBOXCLIPBOARDSVCCTX pSvcCtx = (PVBOXCLIPBOARDSVCCTX)pvClient;
+    PVBOXCLIPBOARDCLIENTDATA pClientData = (PVBOXCLIPBOARDCLIENTDATA)pvClient;
 
     bool fAsynchronousProcessing = false;
@@ -467 +471 @@
                 if (VBoxSvcClipboardLock())
                 {
-                    bool fMessageReturned = vboxSvcClipboardReturnMsg (pSvcCtx, paParms);
+                    bool fMessageReturned = vboxSvcClipboardReturnMsg (pClientData, paParms);
 
                     if (fMessageReturned)
                     {
                         /* Just return to the caller. */
-                        pSvcCtx->fAsync = false;
+                        pClientData->State.fAsync = false;
                     }
                     else
@@ -479 +483 @@
                         fAsynchronousProcessing = true;
 
-                        pSvcCtx->fAsync           = true;
-                        pSvcCtx->async.callHandle = callHandle;
-                        pSvcCtx->async.paParms    = paParms;
+                        pClientData->State.fAsync           = true;
+                        pClientData->State.async.callHandle = callHandle;
+                        pClientData->State.async.paParms    = paParms;
 
                         LogFunc(("async.\n"));
@@ -517 +521 @@
                 if (RT_SUCCESS (rc))
                 {
-                    if (   vboxSvcClipboardMode () != VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST
-                        && vboxSvcClipboardMode () != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
+                    if (   vboxSvcClipboardGetMode () != VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST
+                        && vboxSvcClipboardGetMode () != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
                     {
                         rc = VERR_NOT_SUPPORTED;
@@ -534 +538 @@
                     else
                     {
-                        VBoxClipboardSvcImplFormatAnnounce (pSvcCtx, u32Formats);
+                        VBoxClipboardSvcImplFormatAnnounce (pClientData, u32Formats);
                     }
                 }
@@ -570 +574 @@
                     if (RT_SUCCESS (rc))
                     {
-                        if (   vboxSvcClipboardMode () != VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST
-                            && vboxSvcClipboardMode () != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
+                        if (   vboxSvcClipboardGetMode () != VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST
+                            && vboxSvcClipboardGetMode () != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
                         {
                             rc = VERR_NOT_SUPPORTED;
@@ -592 +596 @@
                             if (g_fDelayedAnnouncement)
                             {
-                                vboxSvcClipboardReportMsg (g_pSvcCtx, VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS, g_u32DelayedFormats);
+                                vboxSvcClipboardReportMsg (g_pClientData, VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS, g_u32DelayedFormats);
                                 g_fDelayedAnnouncement = false;
                                 g_u32DelayedFormats = 0;
@@ -607 +611 @@
                             /* Release any other pending read, as we only
                              * support one pending read at one time. */
-                            vboxSvcClipboardCompleteReadData(pSvcCtx, VERR_NO_DATA, 0);
-                            rc = VBoxClipboardSvcImplReadData (pSvcCtx, u32Format, pv, cb, &cbActual);
+                            vboxSvcClipboardCompleteReadData(pClientData, VERR_NO_DATA, 0);
+                            rc = VBoxClipboardSvcImplReadData (pClientData, u32Format, pv, cb, &cbActual);
                         }
 
@@ -618 +622 @@
                             if (VBoxSvcClipboardLock())
                             {
-                                pSvcCtx->asyncRead.callHandle = callHandle;
-                                pSvcCtx->asyncRead.paParms    = paParms;
-                                pSvcCtx->fReadPending         = true;
+                                pClientData->State.asyncRead.callHandle = callHandle;
+                                pClientData->State.asyncRead.paParms    = paParms;
+                                pClientData->State.fReadPending         = true;
                                 fAsynchronousProcessing = true;
                                 VBoxSvcClipboardUnlock();
@@ -665 +669 @@
                     if (RT_SUCCESS (rc))
                     {
-                        if (   vboxSvcClipboardMode () != VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST
-                            && vboxSvcClipboardMode () != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
+                        if (   vboxSvcClipboardGetMode () != VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST
+                            && vboxSvcClipboardGetMode () != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
                         {
                             rc = VERR_NOT_SUPPORTED;
@@ -684 +688 @@
                         else
                         {
-                            VBoxClipboardSvcImplWriteData (pSvcCtx, pv, cb, u32Format);
+                            VBoxClipboardSvcImplWriteData (pClientData, pv, cb, u32Format);
                         }
                     }
@@ -713 +717 @@
  * then complete it, otherwise return.  See the protocol description in the
  * shared clipboard module description. */
-void vboxSvcClipboardCompleteReadData(PVBOXCLIPBOARDSVCCTX pSvcCtx, int rc, uint32_t cbActual)
+void vboxSvcClipboardCompleteReadData(PVBOXCLIPBOARDCLIENTDATA pClientData, int rc, uint32_t cbActual)
 {
     VBOXHGCMCALLHANDLE callHandle = NULL;
@@ -720 +724 @@
     if (VBoxSvcClipboardLock())  /* if not can we do anything useful? */
     {
-        callHandle   = pSvcCtx->asyncRead.callHandle;
-        paParms      = pSvcCtx->asyncRead.paParms;
-        fReadPending = pSvcCtx->fReadPending;
-        pSvcCtx->fReadPending = false;
+        callHandle   = pClientData->State.asyncRead.callHandle;
+        paParms      = pClientData->State.asyncRead.paParms;
+        fReadPending = pClientData->State.fReadPending;
+        pClientData->State.fReadPending = false;
         VBoxSvcClipboardUnlock();
     }
@@ -804 +808 @@
 static SSMFIELD const g_aClipboardClientDataFields[] =
 {
-    SSMFIELD_ENTRY(VBOXCLIPBOARDSVCCTX, u32ClientID),  /* for validation purposes */
-    SSMFIELD_ENTRY(VBOXCLIPBOARDSVCCTX, fHostMsgQuit),
-    SSMFIELD_ENTRY(VBOXCLIPBOARDSVCCTX, fHostMsgReadData),
-    SSMFIELD_ENTRY(VBOXCLIPBOARDSVCCTX, fHostMsgFormats),
-    SSMFIELD_ENTRY(VBOXCLIPBOARDSVCCTX, u32RequestedFormat),
+    SSMFIELD_ENTRY(VBOXCLIPBOARDCLIENTSTATE, u32ClientID),  /* for validation purposes */
+    SSMFIELD_ENTRY(VBOXCLIPBOARDCLIENTSTATE, fHostMsgQuit),
+    SSMFIELD_ENTRY(VBOXCLIPBOARDCLIENTSTATE, fHostMsgReadData),
+    SSMFIELD_ENTRY(VBOXCLIPBOARDCLIENTSTATE, fHostMsgFormats),
+    SSMFIELD_ENTRY(VBOXCLIPBOARDCLIENTSTATE, u32RequestedFormat),
     SSMFIELD_ENTRY_TERM()
 };
@@ -826 +830 @@
     LogFunc(("u32ClientID = %d\n", u32ClientID));
 
-    PVBOXCLIPBOARDSVCCTX pSvcCtx = (PVBOXCLIPBOARDSVCCTX)pvClient;
+    PVBOXCLIPBOARDCLIENTDATA pClientData = (PVBOXCLIPBOARDCLIENTDATA)pvClient;
 
     /* This field used to be the length. We're using it as a version field
        with the high bit set. */
     SSMR3PutU32(pSSM, UINT32_C(0x80000002));
-    int rc = SSMR3PutStructEx(pSSM, pSvcCtx, sizeof(*pSvcCtx), 0 /*fFlags*/, &g_aClipboardClientDataFields[0], NULL);
+    int rc = SSMR3PutStructEx(pSSM, pClientData, sizeof(*pClientData), 0 /*fFlags*/, &g_aClipboardClientDataFields[0], NULL);
     AssertRCReturn(rc, rc);
 
@@ -840 +844 @@
 }
 
-/**
- * This structure corresponds to the original layout of the
- * VBOXCLIPBOARDCLIENTDATA structure.  As the structure was saved as a whole
- * when saving state, we need to remember it forever in order to preserve
- * compatibility.
- *
- * (Starting with 3.1 this is no longer used.)
- *
- * @remarks Putting this outside svcLoadState to avoid visibility warning caused
- *          by -Wattributes.
- */
-typedef struct CLIPSAVEDSTATEDATA
-{
-    struct CLIPSAVEDSTATEDATA *pNext;
-    struct CLIPSAVEDSTATEDATA *pPrev;
-
-    VBOXCLIPBOARDCONTEXT *pCtx;
-
-    uint32_t u32ClientID;
-
-    bool fAsync: 1; /* Guest is waiting for a message. */
-
-    bool fHostMsgQuit: 1;
-    bool fHostMsgReadData: 1;
-    bool fHostMsgFormats: 1;
-
-    struct
-    {
-        VBOXHGCMCALLHANDLE callHandle;
-        VBOXHGCMSVCPARM *paParms;
-    } async;
-
-    struct
-    {
-        void *pv;
-        uint32_t cb;
-        uint32_t u32Format;
-    } data;
-
-    uint32_t u32AvailableFormats;
-    uint32_t u32RequestedFormat;
-
-} CLIPSAVEDSTATEDATA;
-
 static DECLCALLBACK(int) svcLoadState(void *, uint32_t u32ClientID, void *pvClient, PSSMHANDLE pSSM, uint32_t uVersion)
 {
@@ -891 +851 @@
     LogFunc(("u32ClientID = %d\n", u32ClientID));
 
-    PVBOXCLIPBOARDSVCCTX pSvcCtx = (PVBOXCLIPBOARDSVCCTX)pvClient;
+    PVBOXCLIPBOARDCLIENTDATA pClientData   = (PVBOXCLIPBOARDCLIENTDATA)pvClient;
+    AssertPtr(pClientData);
 
     /* Existing client can not be in async state yet. */
-    Assert(!pSvcCtx->fAsync);
+    Assert(!pClientData->State.fAsync);
 
     /* Save the client ID for data validation. */
     /** @todo isn't this the same as u32ClientID? Playing safe for now... */
-    uint32_t const u32ClientIDOld = pSvcCtx->u32ClientID;
+    uint32_t const u32ClientIDOld = pClientData->State.u32ClientID;
 
     /* Restore the client data. */
@@ -906 +867 @@
     if (lenOrVer == UINT32_C(0x80000002))
     {
-        rc = SSMR3GetStructEx(pSSM, pSvcCtx, sizeof(*pSvcCtx), 0 /*fFlags*/, &g_aClipboardClientDataFields[0], NULL);
+        rc = SSMR3GetStructEx(pSSM, pClientData, sizeof(*pClientData), 0 /*fFlags*/, &g_aClipboardClientDataFields[0], NULL);
         AssertRCReturn(rc, rc);
-    }
-    else if (lenOrVer == (SSMR3HandleHostBits(pSSM) == 64 ? 72U : 48U))
-    {
-        /**
-         * SSM descriptor table for the CLIPSAVEDSTATEDATA structure.
-         */
-        static SSMFIELD const s_aClipSavedStateDataFields30[] =
-        {
-            SSMFIELD_ENTRY_IGN_HCPTR(       CLIPSAVEDSTATEDATA, pNext),
-            SSMFIELD_ENTRY_IGN_HCPTR(       CLIPSAVEDSTATEDATA, pPrev),
-            SSMFIELD_ENTRY_IGN_HCPTR(       CLIPSAVEDSTATEDATA, pCtx),
-            SSMFIELD_ENTRY(                 CLIPSAVEDSTATEDATA, u32ClientID),
-            SSMFIELD_ENTRY_CUSTOM(fMsgQuit + fMsgReadData + fMsgFormats, RT_UOFFSETOF(CLIPSAVEDSTATEDATA, u32ClientID) + 4, 4),
-            SSMFIELD_ENTRY_IGN_HCPTR(       CLIPSAVEDSTATEDATA, async.callHandle),
-            SSMFIELD_ENTRY_IGN_HCPTR(       CLIPSAVEDSTATEDATA, async.paParms),
-            SSMFIELD_ENTRY_IGNORE(          CLIPSAVEDSTATEDATA, data.pv),
-            SSMFIELD_ENTRY_IGNORE(          CLIPSAVEDSTATEDATA, data.cb),
-            SSMFIELD_ENTRY_IGNORE(          CLIPSAVEDSTATEDATA, data.u32Format),
-            SSMFIELD_ENTRY_IGNORE(          CLIPSAVEDSTATEDATA, u32AvailableFormats),
-            SSMFIELD_ENTRY(                 CLIPSAVEDSTATEDATA, u32RequestedFormat),
-            SSMFIELD_ENTRY_TERM()
-        };
-
-        CLIPSAVEDSTATEDATA savedState;
-        RT_ZERO(savedState);
-        rc = SSMR3GetStructEx(pSSM, &savedState, sizeof(savedState), SSMSTRUCT_FLAGS_MEM_BAND_AID,
-                              &s_aClipSavedStateDataFields30[0], NULL);
-        AssertRCReturn(rc, rc);
-
-        pSvcCtx->fHostMsgQuit       = savedState.fHostMsgQuit;
-        pSvcCtx->fHostMsgReadData   = savedState.fHostMsgReadData;
-        pSvcCtx->fHostMsgFormats    = savedState.fHostMsgFormats;
-        pSvcCtx->u32RequestedFormat = savedState.u32RequestedFormat;
     }
     else
@@ -949 +877 @@
 
     /* Verify the client ID. */
-    if (pSvcCtx->u32ClientID != u32ClientIDOld)
-    {
-        LogFunc(("Client ID mismatch: expected %d, got %d\n", u32ClientIDOld, pSvcCtx->u32ClientID));
-        pSvcCtx->u32ClientID = u32ClientIDOld;
+    if (pClientData->State.u32ClientID != u32ClientIDOld)
+    {
+        LogFunc(("Client ID mismatch: expected %d, got %d\n", u32ClientIDOld, pClientData->State.u32ClientID));
+        pClientData->State.u32ClientID = u32ClientIDOld;
         return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
     }
 
     /* Actual host data are to be reported to guest (SYNC). */
-    VBoxClipboardSvcImplSync(pSvcCtx);
+    VBoxClipboardSvcImplSync(pClientData);
 
 #else  /* UNIT_TEST*/
@@ -968 +896 @@
 {
     RT_NOREF2(pvData, cbData);
-    if (g_pSvcCtx != NULL)
+    if (g_pClientData != NULL)
     {
         switch (u32Function)
@@ -982 +910 @@
                 else
                 {
-                    vboxSvcClipboardReportMsg (g_pSvcCtx, VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS, u32Format);
+                    vboxSvcClipboardReportMsg(g_pClientData, VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS, u32Format);
                 }
             } break;
@@ -988 +916 @@
             case VBOX_CLIPBOARD_EXT_FN_DATA_READ:
             {
-                vboxSvcClipboardReportMsg (g_pSvcCtx, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, u32Format);
+                vboxSvcClipboardReportMsg(g_pClientData, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, u32Format);
             } break;
 
@@ -1030 +958 @@
 }
 
-extern "C" DECLCALLBACK(DECLEXPORT(int)) VBoxHGCMSvcLoad (VBOXHGCMSVCFNTABLE *ptable)
+extern "C" DECLCALLBACK(DECLEXPORT(int)) VBoxHGCMSvcLoad(VBOXHGCMSVCFNTABLE *ptable)
 {
     int rc = VINF_SUCCESS;
@@ -1053 +981 @@
             g_pHelpers = ptable->pHelpers;
 
-            ptable->cbClient = sizeof(VBOXCLIPBOARDSVCCTX);
+            ptable->cbClient = sizeof(VBOXCLIPBOARDCLIENTDATA);
 
             ptable->pfnUnload     = svcUnload;

trunk/src/VBox/HostServices/SharedClipboard/testcase/tstClipboardServiceHost.cpp

@@ -26 +26 @@
 extern "C" DECLCALLBACK(DECLEXPORT(int)) VBoxHGCMSvcLoad (VBOXHGCMSVCFNTABLE *ptable);
 
-static VBOXCLIPBOARDSVCCTX g_Client;
+static VBOXCLIPBOARDCLIENTDATA g_Client;
 static VBOXHGCMSVCHELPERS g_Helpers = { NULL };
 
@@ -275 +275 @@
 int VBoxClipboardSvcImplInit() { return VINF_SUCCESS; }
 void VBoxClipboardSvcImplDestroy() { }
-void VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDSVCCTX) { AssertFailed(); }
-int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDSVCCTX, bool)
+void VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDCLIENTDATA) { AssertFailed(); }
+int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDCLIENTDATA, bool)
 { AssertFailed(); return VERR_WRONG_ORDER; }
-void VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDSVCCTX, unsigned int)
+void VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDCLIENTDATA, unsigned int)
 { AssertFailed(); }
-int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDSVCCTX, unsigned int, void *, unsigned int, unsigned int *)
+int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDCLIENTDATA, unsigned int, void *, unsigned int, unsigned int *)
 { AssertFailed(); return VERR_WRONG_ORDER; }
-void VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDSVCCTX, void *, unsigned int, unsigned int) { AssertFailed(); }
-int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDSVCCTX)
+void VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDCLIENTDATA, void *, unsigned int, unsigned int) { AssertFailed(); }
+int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDCLIENTDATA)
 { AssertFailed(); return VERR_WRONG_ORDER; }