[client] initial host to client clipboard sync working

client/CMakeLists.txt

@@ -16,6 +16,7 @@ pkg_check_modules(PKGCONFIG REQUIRED
 	spice-protocol
 	fontconfig
 	x11
+	xfixes
 	wayland-egl
 	libconfig
 	nettle

client/clipboard/x11.c

@@ -20,15 +20,27 @@ Place, Suite 330, Boston, MA 02111-1307 USA
 #include "lg-clipboard.h"
 #include "debug.h"
 
+#include <X11/extensions/Xfixes.h>
+
 struct state
 {
   Display             * display;
   Window                window;
   Atom                  aSelection;
+  Atom                  aCurSelection;
   Atom                  aTargets;
-  Atom                  aTypes[LG_CLIPBOARD_DATA_MAX];
+  Atom                  aSelData;
+  Atom                  aIncr;
+  Atom                  aTypes[LG_CLIPBOARD_DATA_NONE];
+  LG_ClipboardReleaseFn releaseFn;
   LG_ClipboardRequestFn requestFn;
+  LG_ClipboardNotifyFn  notifyFn;
+  LG_ClipboardDataFn    dataFn;
   LG_ClipboardData      type;
+
+  // XFixes vars
+  int eventBase;
+  int errorBase;
 };
 
 static struct state * this = NULL;
@@ -47,7 +59,11 @@ static const char * x11_cb_getName()
   return "X11";
 }
 
-static bool x11_cb_init(SDL_SysWMinfo * wminfo)
+static bool x11_cb_init(
+    SDL_SysWMinfo         * wminfo,
+    LG_ClipboardReleaseFn   releaseFn,
+    LG_ClipboardNotifyFn    notifyFn,
+    LG_ClipboardDataFn      dataFn)
 {
   // final sanity check
   if (wminfo->subsystem != SDL_SYSWM_X11)
@@ -63,8 +79,14 @@ static bool x11_cb_init(SDL_SysWMinfo * wminfo)
   this->window        = wminfo->info.x11.window;
   this->aSelection    = XInternAtom(this->display, "CLIPBOARD", False);
   this->aTargets      = XInternAtom(this->display, "TARGETS"  , False);
+  this->aSelData      = XInternAtom(this->display, "SEL_DATA" , False);
+  this->aIncr         = XInternAtom(this->display, "INCR"     , False);
+  this->aCurSelection = BadValue;
+  this->releaseFn     = releaseFn;
+  this->notifyFn      = notifyFn;
+  this->dataFn        = dataFn;
 
-  for(int i = 0; i < LG_CLIPBOARD_DATA_MAX; ++i)
+  for(int i = 0; i < LG_CLIPBOARD_DATA_NONE; ++i)
   {
     this->aTypes[i] = XInternAtom(this->display, atomTypes[i], False);
     if (this->aTypes[i] == BadAlloc || this->aTypes[i] == BadValue)
@@ -79,6 +101,18 @@ static bool x11_cb_init(SDL_SysWMinfo * wminfo)
   // we need the raw X events
   SDL_EventState(SDL_SYSWMEVENT, SDL_ENABLE);
 
+  // use xfixes to get clipboard change notifications
+  if (!XFixesQueryExtension(this->display, &this->eventBase, &this->errorBase))
+  {
+    DEBUG_ERROR("failed to initialize xfixes");
+    free(this);
+    this = NULL;
+    return false;
+  }
+
+  XFixesSelectSelectionInput(this->display,DefaultRootWindow(this->display), XA_PRIMARY      , XFixesSetSelectionOwnerNotifyMask);
+  XFixesSelectSelectionInput(this->display,DefaultRootWindow(this->display), this->aSelection, XFixesSetSelectionOwnerNotifyMask);
+
   return true;
 }
 
@@ -154,7 +188,7 @@ static void x11_cb_wmevent(SDL_SysWMmsg * msg)
     }
 
     // look to see if we can satisfy the data type
-    for(int i = 0; i < LG_CLIPBOARD_DATA_MAX; ++i)
+    for(int i = 0; i < LG_CLIPBOARD_DATA_NONE; ++i)
       if (this->aTypes[i] == e.xselectionrequest.target && this->type == i)
       {
         // request the data
@@ -172,15 +206,113 @@ static void x11_cb_wmevent(SDL_SysWMmsg * msg)
     XFlush(this->display);
   }
 
-  if (e.type == SelectionNotify)
+  if (e.type == SelectionClear && (
+        e.xselectionclear.selection == XA_PRIMARY ||
+        e.xselectionclear.selection == this->aSelection)
+     )
   {
-    DEBUG_WARN("FIXME: SelectionNotify");
+    this->aCurSelection = BadValue;
+    this->releaseFn();
     return;
   }
 
-  if (e.type == SelectionClear)
+  // if someone selected data
+  if (e.type == this->eventBase + XFixesSelectionNotify && (
+        ((XFixesSelectionNotifyEvent *)&e)->selection == XA_PRIMARY ||
+        ((XFixesSelectionNotifyEvent *)&e)->selection == this->aSelection)
+     )
   {
-    DEBUG_WARN("FIXME: SelectionClear");
+    // ask for the data type
+    XFixesSelectionNotifyEvent * sne = (XFixesSelectionNotifyEvent *)&e;
+
+    // remember which selection we are working with
+    this->aCurSelection = sne->selection;
+
+    XConvertSelection(
+        this->display,
+        sne->selection,
+        this->aTargets,
+        this->aTargets,
+        this->window,
+        CurrentTime);
+    return;
+  }
+
+  if (e.type == SelectionNotify)
+  {
+    if (e.xselection.property == None)
+      return;
+
+    Atom type;
+    int format;
+    unsigned long itemCount, after;
+    unsigned char *data;
+
+    XGetWindowProperty(
+        this->display,
+        this->window,
+        e.xselection.property,
+        0, ~0L, // start and length
+        True  , // delete the property
+        AnyPropertyType,
+        &type,
+        &format,
+        &itemCount,
+        &after,
+        &data);
+
+    // the target list
+    if (e.xselection.property == this->aTargets)
+    {
+      // the format is 32-bit and we must have data
+      // this is technically incorrect however as it's
+      // an array of padded 64-bit values
+      if (!data || format != 32)
+      {
+        this->notifyFn(LG_CLIPBOARD_DATA_NONE);
+        if (data)
+          XFree(data);
+        return;
+      }
+
+      // see if we support any of the targets listed
+      const uint64_t * targets = (const uint64_t *)data;
+      for(unsigned long i = 0; i < itemCount; ++i)
+      {
+        for(int n = 0; n < LG_CLIPBOARD_DATA_NONE; ++n)
+          if (this->aTypes[n] == targets[i])
+          {
+            // we have a match, so send the notification
+            this->notifyFn(n);
+            XFree(data);
+            return;
+          }
+      }
+
+      // no matches
+      this->notifyFn(LG_CLIPBOARD_DATA_NONE);
+      XFree(data);
+      return;
+    }
+
+    if (format == this->aIncr)
+    {
+      DEBUG_WARN("fixme: large paste buffers are not yet supported");
+    }
+    else
+    {
+      for(int i = 0; i < LG_CLIPBOARD_DATA_NONE; ++i)
+        if (this->aTypes[i] == type)
+        {
+          this->dataFn(i, data, itemCount);
+          XFree(data);
+          return;
+        }
+
+      DEBUG_WARN("clipboard data (%s) not in a supported format", XGetAtomName(this->display, type));
+    }
+
+    XFree(data);
     return;
   }
 }
@@ -194,11 +326,35 @@ static void x11_cb_notice(LG_ClipboardRequestFn requestFn, LG_ClipboardData type
   XFlush(this->display);
 }
 
+static void x11_cb_release()
+{
+  this->requestFn = NULL;
+  XSetSelectionOwner(this->display, XA_PRIMARY      , None, CurrentTime);
+  XSetSelectionOwner(this->display, this->aSelection, None, CurrentTime);
+  XFlush(this->display);
+}
+
+static void x11_cb_request(LG_ClipboardData type)
+{
+  if (this->aCurSelection == BadValue)
+    return;
+
+  XConvertSelection(
+      this->display,
+      this->aCurSelection,
+      this->aTypes[type],
+      this->aSelData,
+      this->window,
+      CurrentTime);
+}
+
 const LG_Clipboard LGC_X11 =
 {
   .getName = x11_cb_getName,
   .init    = x11_cb_init,
   .free    = x11_cb_free,
   .wmevent = x11_cb_wmevent,
-  .notice  = x11_cb_notice
+  .notice  = x11_cb_notice,
+  .release = x11_cb_release,
+  .request = x11_cb_request
 };

client/lg-clipboard.h

@@ -31,18 +31,23 @@ typedef enum LG_ClipboardData
   LG_CLIPBOARD_DATA_TIFF,
   LG_CLIPBOARD_DATA_JPEG,
 
-  LG_CLIPBOARD_DATA_MAX // enum max, not a data type
+  LG_CLIPBOARD_DATA_NONE // enum max, not a data type
 }
 LG_ClipboardData;
 
-typedef void (* LG_ClipboardReplyFn  )(void * opaque, LG_ClipboardData type, uint8_t * data, uint32_t size);
+typedef void (* LG_ClipboardReplyFn  )(void * opaque, const LG_ClipboardData type, uint8_t * data, uint32_t size);
 typedef void (* LG_ClipboardRequestFn)(LG_ClipboardReplyFn replyFn, void * opaque);
+typedef void (* LG_ClipboardReleaseFn)();
+typedef void (* LG_ClipboardNotifyFn)(LG_ClipboardData type);
+typedef void (* LG_ClipboardDataFn  )(const LG_ClipboardData type, uint8_t * data, size_t size);
 
 typedef const char * (* LG_ClipboardGetName)();
-typedef bool         (* LG_ClipboardInit)(SDL_SysWMinfo * wminfo);
+typedef bool         (* LG_ClipboardInit)(SDL_SysWMinfo * wminfo, LG_ClipboardReleaseFn releaseFn, LG_ClipboardNotifyFn notifyFn, LG_ClipboardDataFn dataFn);
 typedef void         (* LG_ClipboardFree)();
 typedef void         (* LG_ClipboardWMEvent)(SDL_SysWMmsg * msg);
 typedef void         (* LG_ClipboardNotice)(LG_ClipboardRequestFn requestFn, LG_ClipboardData type);
+typedef void         (* LG_ClipboardRelease)();
+typedef void         (* LG_ClipboardRequest)(LG_ClipboardData type);
 
 typedef struct LG_Clipboard
 {
@@ -51,5 +56,7 @@ typedef struct LG_Clipboard
   LG_ClipboardFree    free;
   LG_ClipboardWMEvent wmevent;
   LG_ClipboardNotice  notice;
+  LG_ClipboardRelease release;
+  LG_ClipboardRequest request;
 }
 LG_Clipboard;

client/main.c

@@ -492,7 +492,60 @@ static inline const uint32_t mapScancode(SDL_Scancode scancode)
   return ps2;
 }
 
-void clipboardRequestFn(const LG_ClipboardReplyFn replyFn, void * opaque)
+static LG_ClipboardData spice_type_to_clipboard_type(const SpiceDataType type)
+{
+  switch(type)
+  {
+    case SPICE_DATA_TEXT: return LG_CLIPBOARD_DATA_TEXT; break;
+    case SPICE_DATA_PNG : return LG_CLIPBOARD_DATA_PNG ; break;
+    case SPICE_DATA_BMP : return LG_CLIPBOARD_DATA_BMP ; break;
+    case SPICE_DATA_TIFF: return LG_CLIPBOARD_DATA_TIFF; break;
+    case SPICE_DATA_JPEG: return LG_CLIPBOARD_DATA_JPEG; break;
+    default:
+      DEBUG_ERROR("invalid spice data type");
+      return LG_CLIPBOARD_DATA_NONE;
+  }
+}
+
+static SpiceDataType clipboard_type_to_spice_type(const LG_ClipboardData type)
+{
+  switch(type)
+  {
+    case LG_CLIPBOARD_DATA_TEXT: return SPICE_DATA_TEXT; break;
+    case LG_CLIPBOARD_DATA_PNG : return SPICE_DATA_PNG ; break;
+    case LG_CLIPBOARD_DATA_BMP : return SPICE_DATA_BMP ; break;
+    case LG_CLIPBOARD_DATA_TIFF: return SPICE_DATA_TIFF; break;
+    case LG_CLIPBOARD_DATA_JPEG: return SPICE_DATA_JPEG; break;
+    default:
+      DEBUG_ERROR("invalid clipboard data type");
+      return SPICE_DATA_NONE;
+  }
+}
+
+void clipboardRelease()
+{
+  spice_clipboard_release();
+
+  // another application just took the clipboard ownership
+}
+
+void clipboardNotify(const LG_ClipboardData type)
+{
+  if (type == LG_CLIPBOARD_DATA_NONE)
+  {
+    spice_clipboard_release();
+    return;
+  }
+
+  spice_clipboard_grab(clipboard_type_to_spice_type(type));
+}
+
+void clipboardData(const LG_ClipboardData type, uint8_t * data, size_t size)
+{
+  spice_clipboard_data(clipboard_type_to_spice_type(type), data, (uint32_t)size);
+}
+
+void clipboardRequest(const LG_ClipboardReplyFn replyFn, void * opaque)
 {
   state.cbReplyData = opaque;
   state.cbReplyFn   = replyFn;
@@ -506,18 +559,7 @@ void spiceClipboardNotice(const SpiceDataType type)
     return;
 
   state.cbType = type;
-
+  state.lgc->notice(clipboardRequest, spice_type_to_clipboard_type(type));
-  LG_ClipboardData t;
-  switch(type)
-  {
-    case LG_CLIPBOARD_DATA_TEXT: t = SPICE_DATA_TEXT; break;
-    case LG_CLIPBOARD_DATA_PNG : t = SPICE_DATA_PNG ; break;
-    case LG_CLIPBOARD_DATA_BMP : t = SPICE_DATA_BMP ; break;
-    case LG_CLIPBOARD_DATA_TIFF: t = SPICE_DATA_TIFF; break;
-    case LG_CLIPBOARD_DATA_JPEG: t = SPICE_DATA_JPEG; break;
-  }
-
-  state.lgc->notice(clipboardRequestFn, t);
 }
 
 void spiceClipboardData(const SpiceDataType type, uint8_t * buffer, uint32_t size)
@@ -538,6 +580,18 @@ void spiceClipboardData(const SpiceDataType type, uint8_t * buffer, uint32_t siz
   state.cbReplyFn(state.cbReplyData, type, buffer, size);
 }
 
+void spiceClipboardRelease()
+{
+  if (state.lgc && state.lgc->release)
+    state.lgc->release();
+}
+
+void spiceClipboardRequest(const SpiceDataType type)
+{
+  if (state.lgc && state.lgc->request)
+    state.lgc->request(spice_type_to_clipboard_type(type));
+}
+
 int eventFilter(void * userdata, SDL_Event * event)
 {
   static bool serverMode   = false;
@@ -982,7 +1036,7 @@ int run()
   if (state.lgc)
   {
     DEBUG_INFO("Using Clipboard: %s", state.lgc->getName());
-    if (!state.lgc->init(&wminfo))
+    if (!state.lgc->init(&wminfo, clipboardRelease, clipboardNotify, clipboardData))
     {
       DEBUG_WARN("Failed to initialize the clipboard interface, continuing anyway");
       state.lgc = NULL;
@@ -1022,7 +1076,11 @@ int run()
 
     if (params.useSpice)
     {
-      spice_set_on_clipboard_cb(spiceClipboardNotice, spiceClipboardData);
+      spice_set_clipboard_cb(
+          spiceClipboardNotice,
+          spiceClipboardData,
+          spiceClipboardRelease,
+          spiceClipboardRequest);
       if (!spice_connect(params.spiceHost, params.spicePort, ""))
       {
         DEBUG_ERROR("Failed to connect to spice server");

client/spice/spice.c

@@ -116,13 +116,17 @@ struct Spice
   bool cbSupported;
   bool cbSelection;
 
-  bool                 cbGrabbed;
+  // clipboard variables
+  bool                  cbAgentGrabbed;
+  bool                  cbClientGrabbed;
   SpiceDataType         cbType;
   uint8_t *             cbBuffer;
   uint32_t              cbRemain;
   uint32_t              cbSize;
   SpiceClipboardNotice  cbNoticeFn;
   SpiceClipboardData    cbDataFn;
+  SpiceClipboardRelease cbReleaseFn;
+  SpiceClipboardRequest cbRequestFn;
 };
 
 // globals
@@ -150,6 +154,10 @@ bool spice_agent_connect  ();
 bool spice_agent_send_caps(bool request);
 void spice_agent_on_clipboard();
 
+// utility functions
+static uint32_t spice_type_to_agent_type(SpiceDataType type);
+static SpiceDataType agent_type_to_spice_type(uint32_t type);
+
 // thread safe read/write methods
 bool spice_write_msg       (struct SpiceChannel * channel, uint32_t type, const void * buffer, const ssize_t size);
 bool spice_agent_write_msg (uint32_t type, const void * buffer, const ssize_t size);
@@ -207,6 +215,9 @@ void spice_disconnect()
   spice.cbBuffer = NULL;
   spice.cbRemain = 0;
   spice.cbSize   = 0;
+
+  spice.cbAgentGrabbed  = false;
+  spice.cbClientGrabbed = false;
 }
 
 // ============================================================================
@@ -1008,7 +1019,9 @@ bool spice_agent_process(uint32_t dataSize)
       if (msg.type == VD_AGENT_CLIPBOARD_RELEASE)
       {
         DEBUG_PROTO("VD_AGENT_CLIPBOARD_RELEASE");
-        spice.cbGrabbed = false;
+        spice.cbAgentGrabbed = false;
+        if (spice.cbReleaseFn)
+          spice.cbReleaseFn();
         return true;
       }
 
@@ -1058,6 +1071,8 @@ bool spice_agent_process(uint32_t dataSize)
         else
         {
           DEBUG_PROTO("VD_AGENT_CLIPBOARD_REQUEST");
+          if (spice.cbRequestFn)
+            spice.cbRequestFn(agent_type_to_spice_type(type));
           return true;
         }
       }
@@ -1077,19 +1092,8 @@ bool spice_agent_process(uint32_t dataSize)
         // there is zero documentation on the types field, it might be a bitfield
         // but for now we are going to assume it's not.
 
-        switch(types[0])
+        spice.cbType         = agent_type_to_spice_type(types[0]);
-        {
+        spice.cbAgentGrabbed = true;
-          case VD_AGENT_CLIPBOARD_UTF8_TEXT : spice.cbType = SPICE_DATA_TEXT; break;
-          case VD_AGENT_CLIPBOARD_IMAGE_PNG : spice.cbType = SPICE_DATA_PNG ; break;
-          case VD_AGENT_CLIPBOARD_IMAGE_BMP : spice.cbType = SPICE_DATA_BMP ; break;
-          case VD_AGENT_CLIPBOARD_IMAGE_TIFF: spice.cbType = SPICE_DATA_TIFF; break;
-          case VD_AGENT_CLIPBOARD_IMAGE_JPG : spice.cbType = SPICE_DATA_JPEG; break;
-          default:
-            DEBUG_WARN("Unknown clipboard data type: %u", types[0]);
-            return true;
-        }
-
-        spice.cbGrabbed = true;
         if (spice.cbSelection)
         {
           // Windows doesnt support this, so until it's needed there is no point messing with it
@@ -1166,12 +1170,15 @@ bool spice_agent_write_msg(uint32_t type, const void * buffer, const ssize_t siz
     return false;
   }
 
+  if (buffer && size)
+  {
     if (spice_write_nl(&spice.scMain, buffer, size) != size)
     {
       LG_UNLOCK(spice.scMain.lock);
       DEBUG_ERROR("failed to write agent data payload");
       return false;
     }
+  }
 
   LG_UNLOCK(spice.scMain.lock);
   return true;
@@ -1455,11 +1462,43 @@ bool spice_mouse_release(uint32_t button)
 
 // ============================================================================
 
+static uint32_t spice_type_to_agent_type(SpiceDataType type)
+{
+  switch(type)
+  {
+    case SPICE_DATA_TEXT: return VD_AGENT_CLIPBOARD_UTF8_TEXT ; break;
+    case SPICE_DATA_PNG : return VD_AGENT_CLIPBOARD_IMAGE_PNG ; break;
+    case SPICE_DATA_BMP : return VD_AGENT_CLIPBOARD_IMAGE_BMP ; break;
+    case SPICE_DATA_TIFF: return VD_AGENT_CLIPBOARD_IMAGE_TIFF; break;
+    case SPICE_DATA_JPEG: return VD_AGENT_CLIPBOARD_IMAGE_JPG ; break;
+    default:
+      DEBUG_ERROR("unsupported spice data type specified");
+      return VD_AGENT_CLIPBOARD_NONE;
+  }
+}
+
+static SpiceDataType agent_type_to_spice_type(uint32_t type)
+{
+  switch(type)
+  {
+    case VD_AGENT_CLIPBOARD_UTF8_TEXT : return SPICE_DATA_TEXT; break;
+    case VD_AGENT_CLIPBOARD_IMAGE_PNG : return SPICE_DATA_PNG ; break;
+    case VD_AGENT_CLIPBOARD_IMAGE_BMP : return SPICE_DATA_BMP ; break;
+    case VD_AGENT_CLIPBOARD_IMAGE_TIFF: return SPICE_DATA_TIFF; break;
+    case VD_AGENT_CLIPBOARD_IMAGE_JPG : return SPICE_DATA_JPEG; break;
+    default:
+      DEBUG_ERROR("unsupported agent data type specified");
+      return SPICE_DATA_NONE;
+  }
+}
+
+// ============================================================================
+
 bool spice_clipboard_request(SpiceDataType type)
 {
   VDAgentClipboardRequest req;
 
-  if (!spice.cbGrabbed)
+  if (!spice.cbAgentGrabbed)
   {
     DEBUG_ERROR("the agent has not grabbed any data yet");
     return false;
@@ -1471,18 +1510,7 @@ bool spice_clipboard_request(SpiceDataType type)
     return false;
   }
 
-  switch(type)
+  req.type = spice_type_to_agent_type(type);
-  {
-    case SPICE_DATA_TEXT: req.type = VD_AGENT_CLIPBOARD_UTF8_TEXT ; break;
-    case SPICE_DATA_PNG : req.type = VD_AGENT_CLIPBOARD_IMAGE_PNG ; break;
-    case SPICE_DATA_BMP : req.type = VD_AGENT_CLIPBOARD_IMAGE_BMP ; break;
-    case SPICE_DATA_TIFF: req.type = VD_AGENT_CLIPBOARD_IMAGE_TIFF; break;
-    case SPICE_DATA_JPEG: req.type = VD_AGENT_CLIPBOARD_IMAGE_JPG ; break;
-    default:
-      DEBUG_ERROR("invalid clipboard data type requested");
-      return false;
-  }
-
   if (!spice_agent_write_msg(VD_AGENT_CLIPBOARD_REQUEST, &req, sizeof(req)))
   {
     DEBUG_ERROR("failed to request clipboard data");
@@ -1494,18 +1522,124 @@ bool spice_clipboard_request(SpiceDataType type)
 
 // ============================================================================
 
-bool spice_set_on_clipboard_cb(SpiceClipboardNotice cbNoticeFn, SpiceClipboardData cbDataFn)
+bool spice_set_clipboard_cb(SpiceClipboardNotice cbNoticeFn, SpiceClipboardData cbDataFn, SpiceClipboardRelease cbReleaseFn, SpiceClipboardRequest cbRequestFn)
 {
   if ((cbNoticeFn && !cbDataFn) || (cbDataFn && !cbNoticeFn))
   {
-    DEBUG_ERROR("Clipboard callback notice and data callbacks must be specified");
+    DEBUG_ERROR("clipboard callback notice and data callbacks must be specified");
     return false;
   }
 
   spice.cbNoticeFn  = cbNoticeFn;
   spice.cbDataFn    = cbDataFn;
+  spice.cbReleaseFn = cbReleaseFn;
+  spice.cbRequestFn = cbRequestFn;
 
   return true;
 }
 
 // ============================================================================
+
+bool spice_clipboard_grab(SpiceDataType type)
+{
+  // release first if we have grabbed previously
+  if (spice.cbClientGrabbed && !spice_clipboard_release())
+    return false;
+
+  if (type == SPICE_DATA_NONE)
+  {
+    DEBUG_ERROR("grab type is invalid");
+    return false;
+  }
+
+  if (spice.cbSelection)
+  {
+    uint8_t req[8] = { VD_AGENT_CLIPBOARD_SELECTION_CLIPBOARD };
+    ((uint32_t*)req)[1] = spice_type_to_agent_type(type);
+
+    if (!spice_agent_write_msg(VD_AGENT_CLIPBOARD_GRAB, req, sizeof(req)))
+    {
+      DEBUG_ERROR("failed to grab the clipboard");
+      return false;
+    }
+
+    spice.cbClientGrabbed = true;
+    return true;
+  }
+
+  uint32_t req = spice_type_to_agent_type(type);
+  if (!spice_agent_write_msg(VD_AGENT_CLIPBOARD_GRAB, &req, sizeof(req)))
+  {
+    DEBUG_ERROR("failed to grab the clipboard");
+    return false;
+  }
+
+  spice.cbClientGrabbed = true;
+  return true;
+}
+
+// ============================================================================
+
+bool spice_clipboard_release()
+{
+  // check if if there is anything to release first
+  if (!spice.cbClientGrabbed)
+    return true;
+
+  if (spice.cbSelection)
+  {
+    uint8_t req[4] = { VD_AGENT_CLIPBOARD_SELECTION_CLIPBOARD };
+    if (!spice_agent_write_msg(VD_AGENT_CLIPBOARD_RELEASE, req, sizeof(req)))
+    {
+      DEBUG_ERROR("failed to release the clipboard");
+      return false;
+    }
+
+    spice.cbClientGrabbed = false;
+    return true;
+  }
+
+   if (!spice_agent_write_msg(VD_AGENT_CLIPBOARD_RELEASE, NULL, 0))
+   {
+     DEBUG_ERROR("failed to release the clipboard");
+     return false;
+   }
+
+   spice.cbClientGrabbed = false;
+   return true;
+}
+
+// ============================================================================
+
+bool spice_clipboard_data(SpiceDataType type, uint8_t * data, size_t size)
+{
+  uint8_t * buffer;
+  uint8_t bufSize;
+
+  if (spice.cbSelection)
+  {
+    bufSize                = 8 + size;
+    buffer                 = (uint8_t *)malloc(bufSize);
+    buffer[0]              = VD_AGENT_CLIPBOARD_SELECTION_CLIPBOARD;
+    buffer[1]              = buffer[2] = buffer[3] = 0;
+    ((uint32_t*)buffer)[1] = spice_type_to_agent_type(type);
+    memcpy(buffer + 8, data, size);
+  }
+  else
+  {
+    bufSize                = 4 + size;
+    buffer                 = (uint8_t *)malloc(bufSize);
+    ((uint32_t*)buffer)[0] = spice_type_to_agent_type(type);
+    memcpy(buffer + 4, data, size);
+  }
+
+  if (!spice_agent_write_msg(VD_AGENT_CLIPBOARD, buffer, bufSize))
+  {
+    DEBUG_ERROR("failed to write the clipboard data");
+    free(buffer);
+    return false;
+  }
+
+  free(buffer);
+  return true;
+}

client/spice/spice.h

@@ -27,12 +27,16 @@ typedef enum SpiceDataType
   SPICE_DATA_PNG,
   SPICE_DATA_BMP,
   SPICE_DATA_TIFF,
-  SPICE_DATA_JPEG
+  SPICE_DATA_JPEG,
+
+  SPICE_DATA_NONE
 }
 SpiceDataType;
 
-typedef void (*SpiceClipboardNotice)(const SpiceDataType type);
+typedef void (*SpiceClipboardNotice )(const SpiceDataType type);
 typedef void (*SpiceClipboardData   )(const SpiceDataType type, uint8_t * buffer, uint32_t size);
+typedef void (*SpiceClipboardRelease)();
+typedef void (*SpiceClipboardRequest)(const SpiceDataType type);
 
 bool spice_connect(const char * host, const unsigned short port, const char * password);
 void spice_disconnect();
@@ -48,6 +52,13 @@ bool spice_mouse_press   (uint32_t button);
 bool spice_mouse_release (uint32_t button);
 
 bool spice_clipboard_request(SpiceDataType type);
+bool spice_clipboard_grab   (SpiceDataType type);
+bool spice_clipboard_release();
+bool spice_clipboard_data   (SpiceDataType type, uint8_t * data, size_t size);
 
 /* events */
-bool spice_set_on_clipboard_cb(SpiceClipboardNotice cbNoticeFn, SpiceClipboardData cbDataFn);
+bool spice_set_clipboard_cb(
+    SpiceClipboardNotice  cbNoticeFn,
+    SpiceClipboardData    cbDataFn,
+    SpiceClipboardRelease cbReleaseFn,
+    SpiceClipboardRequest cbRequestFn);