clipboard: added image support

1 files changed, 330 insertions, 20 deletions

diff --git a/sesman/chansrv/clipboard.c b/sesman/chansrv/clipboard.c
index 44add0c4..abb17e3e 100644
--- a/sesman/chansrv/clipboard.c
+++ b/sesman/chansrv/clipboard.c
@@ -2,6 +2,7 @@
  * xrdp: A Remote Desktop Protocol server.
  *
  * Copyright (C) Jay Sorg 2009-2012
+ * Copyright (C) Laxmikant Rashinkar 2012
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,6 +20,11 @@
    for help see
    http://tronche.com/gui/x/icccm/sec-2.html#s-2
    .../kde/kdebase/workspace/klipper/clipboardpoll.cpp
+
+  Revision:
+  Aug 05, 2012:
+    Laxmikant Rashinkar (LK dot Rashinkar at gmail.com)
+    added clipboard support for BMP images
 */
 
 #include <X11/Xlib.h>
@@ -31,6 +37,15 @@
 #include "clipboard.h"
 #include "xcommon.h"
 
+static char g_bmp_image_header[] =
+{
+    /* this is known to work */
+    //0x42, 0x4d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+
+    /* THIS IS BEING SENT BY WIN2008 */
+    0x42, 0x4d, 0x16, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00
+};
+
 extern int g_cliprdr_chan_id;   /* in chansrv.c */
 
 extern Display* g_display;      /* in xcommon.c */
@@ -52,6 +67,8 @@ static Atom g_primary_atom = 0;
 static Atom g_secondary_atom = 0;
 static Atom g_get_time_atom = 0;
 static Atom g_utf8_atom = 0;
+static Atom g_image_bmp_atom = 0;
+
 static Window g_wnd = 0;
 static int g_xfixes_event_base = 0;
 
@@ -73,6 +90,20 @@ static int g_data_in_time = 0;
 static int g_data_in_up_to_date = 0;
 static int g_got_format_announce = 0;
 
+/* for image data */
+static int g_want_image_data = 0;
+static XSelectionRequestEvent g_saved_selection_req_event;
+
+/* for clipboard INCR transfers */
+static Atom  g_incr_atom;
+static Atom  g_incr_atom_type;
+static Atom  g_incr_atom_target;
+static char* g_incr_data;
+static int   g_incr_data_size;
+static int   g_incr_in_progress = 0;
+
+static clipboard_format_id = CB_FORMAT_UNICODETEXT;
+
 /*****************************************************************************/
 /* this is one way to get the current time from the x server */
 static Time APP_CC
@@ -94,6 +125,17 @@ clipboard_get_server_time(void)
 }
 
 /*****************************************************************************/
+/* returns time in miliseconds
+   this is like g_time2 in os_calls, but not miliseconds since machine was
+   up, something else
+   this is a time value similar to what the xserver uses */
+static int APP_CC
+clipboard_get_local_time(void)
+{
+  return g_time3();
+}
+
+/*****************************************************************************/
 /* returns error */
 int APP_CC
 clipboard_init(void)
@@ -149,6 +191,10 @@ clipboard_init(void)
     g_primary_atom = XInternAtom(g_display, "PRIMARY", False);
     g_secondary_atom = XInternAtom(g_display, "SECONDARY", False);
     g_utf8_atom = XInternAtom(g_display, "UTF8_STRING", False);
+
+    g_image_bmp_atom = XInternAtom(g_display, "image/bmp", False);
+    g_incr_atom = XInternAtom(g_display, "INCR", False);
+
     g_wnd = XCreateSimpleWindow(g_display, RootWindowOfScreen(g_screen),
                                 0, 0, 4, 4, 0, 0, 0);
     input_mask = StructureNotifyMask | PropertyChangeMask;
@@ -233,7 +279,7 @@ clipboard_send_data_request(void)
   out_uint16_le(s, 4); /* CLIPRDR_DATA_REQUEST */
   out_uint16_le(s, 0); /* status */
   out_uint32_le(s, 4); /* length */
-  out_uint32_le(s, 0x0d);
+  out_uint32_le(s, clipboard_format_id);
   s_mark_end(s);
   size = (int)(s->end - s->data);
   LOGM((LOG_LEVEL_DEBUG,"clipboard_send_data_request: data out, sending "
@@ -266,21 +312,32 @@ clipboard_send_format_ack(void)
   return rv;
 }
 
+static char windows_native_format[] =
+{
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
 /*****************************************************************************/
 static int APP_CC
-clipboard_send_format_announce(void)
+clipboard_send_format_announce(tui32 format_id, char* format_name)
 {
   struct stream* s;
   int size;
   int rv;
+  unsigned char format_buf[32];
 
+  g_memset(format_buf, 0, 32);
+  g_snprintf(format_buf, 31, "Native");
   make_stream(s);
   init_stream(s, 8192);
   out_uint16_le(s, 2); /* CLIPRDR_FORMAT_ANNOUNCE */
   out_uint16_le(s, 0); /* status */
-  out_uint32_le(s, 0x90); /* length */
-  out_uint32_le(s, 0x0d); /* extra 4 bytes ? */
-  out_uint8s(s, 0x90);
+  out_uint32_le(s, 4 + sizeof(windows_native_format)); /* length */
+  out_uint32_le(s, format_id);
+  out_uint8p(s, windows_native_format, sizeof(windows_native_format));
   s_mark_end(s);
   size = (int)(s->end - s->data);
   LOGM((LOG_LEVEL_DEBUG,"clipboard_send_format_announce: data out, sending "
@@ -322,6 +379,39 @@ clipboard_out_unicode(struct stream* s, char* text, int num_chars)
 
 /*****************************************************************************/
 static int APP_CC
+clipboard_send_data_response_for_image(void)
+{
+  struct stream* s;
+  int size;
+  int rv;
+
+  LOG(10, ("clipboard_send_data_response_for_image: g_last_clip_size %d\n",
+      g_last_clip_size));
+  make_stream(s);
+  init_stream(s, 64 + g_last_clip_size);
+  out_uint16_le(s, 5); /* CLIPRDR_DATA_RESPONSE */
+  out_uint16_le(s, 1); /* status */
+  out_uint32_le(s, g_last_clip_size); /* length */
+  /* insert image data */
+  if (g_last_clip_type == g_image_bmp_atom)
+  {
+    /* do not insert first header */
+    out_uint8p(s, g_last_clip_data + 14, g_last_clip_size - 14);
+  }
+  out_uint16_le(s, 0); /* nil for string */
+  out_uint32_le(s, 0);
+  out_uint32_le(s, 0);
+  out_uint32_le(s, 0);
+  s_mark_end(s);
+  size = (int)(s->end - s->data);
+  /* HANGING HERE WHEN IMAGE DATA IS TOO BIG!!!! */
+  rv = send_channel_data(g_cliprdr_chan_id, s->data, size);
+  free_stream(s);
+  return rv;
+}
+
+/*****************************************************************************/
+static int APP_CC
 clipboard_send_data_response(void)
 {
   struct stream* s;
@@ -333,6 +423,10 @@ clipboard_send_data_response(void)
   num_chars = 0;
   if (g_last_clip_data != 0)
   {
+    if (g_last_clip_type == g_image_bmp_atom)
+    {
+      return clipboard_send_data_response_for_image();
+    }
     if ((g_last_clip_type == XA_STRING) || (g_last_clip_type == g_utf8_atom))
     {
       num_chars = g_mbstowcs(0, g_last_clip_data, 0);
@@ -468,6 +562,68 @@ clipboard_process_data_request(struct stream* s, int clip_msg_status,
 }
 
 /*****************************************************************************/
+/* sent as a reply to CB_FORMAT_DATA_REQUEST; used to indicate whether
+   processing of the CB_FORMAT_DATA_REQUEST was successful; if processing
+   was successful, CB_FORMAT_DATA_RESPONSE includes contents of requested
+   clipboard data. */
+static int APP_CC
+clipboard_process_data_response_for_image(struct stream * s,
+                                          int clip_msg_status,
+                                          int clip_msg_len)
+{
+  XSelectionRequestEvent* lxev = &g_saved_selection_req_event;
+  char* cptr;
+  char cdata;
+  int len;
+  int index;
+  int data_in_len;
+
+  LOGM((LOG_LEVEL_DEBUG, "clipboard_process_data_response_for_image: "
+        "CLIPRDR_DATA_RESPONSE_FOR_IMAGE"));
+  g_waiting_for_data_response = 0;
+  len = (int)(s->end - s->p);
+  if (len < 1)
+  {
+    return 0;
+  }
+  if (g_last_clip_type == g_image_bmp_atom)
+  {
+    /* space for inserting bmp image header */
+    len += 14;
+    cptr = (char*)g_malloc(len, 0);
+    if (cptr == 0)
+    {
+      return 0;
+    }
+    g_memcpy(cptr, g_bmp_image_header, 14);
+    index = 14;
+  }
+  else
+  {
+    return;
+  }
+  while (s_check(s))
+  {
+    in_uint8(s, cdata);
+    cptr[index++] = cdata;
+  }
+  if (len >= 0)
+  {
+    g_data_in = cptr;
+    g_data_in_size = len;
+    g_data_in_time = clipboard_get_local_time();
+    g_data_in_up_to_date = 1;
+  }
+  clipboard_provide_selection(lxev, lxev->target, 8, cptr, len);
+  return 0;
+}
+
+/*****************************************************************************/
+/* sent as a reply to CB_FORMAT_DATA_REQUEST; used to indicate whether
+   processing of the CB_FORMAT_DATA_REQUEST was successful; if processing was
+   successful, CB_FORMAT_DATA_RESPONSE includes contents of requested
+   clipboard data. */
+/*****************************************************************************/
 static int APP_CC
 clipboard_process_data_response(struct stream* s, int clip_msg_status,
                                 int clip_msg_len)
@@ -479,6 +635,12 @@ clipboard_process_data_response(struct stream* s, int clip_msg_status,
   int index;
   int data_in_len;
 
+  if (g_want_image_data)
+  {
+    g_want_image_data = 0;
+    clipboard_process_data_response_for_image(s, clip_msg_status, clip_msg_len);
+    return 0;
+  }
   LOGM((LOG_LEVEL_DEBUG,"clipboard_process_data_response: "
         "CLIPRDR_DATA_RESPONSE"));
   g_waiting_for_data_response = 0;
@@ -581,19 +743,31 @@ clipboard_data_in(struct stream* s, int chan_id, int chan_flags, int length,
   rv = 0;
   switch (clip_msg_id)
   {
-    case 2: /* CLIPRDR_FORMAT_ANNOUNCE */
+    /* sent by client or server when its local system clipboard is   */
+    /* updated with new clipboard data; contains Clipboard Format ID */
+    /* and name pairs of new Clipboard Formats on the clipboard.     */
+    case CB_FORMAT_LIST: /* CLIPRDR_FORMAT_ANNOUNCE */
       rv = clipboard_process_format_announce(ls, clip_msg_status,
                                              clip_msg_len);
       break;
-    case 3: /* CLIPRDR_FORMAT_ACK */
+    /* response to CB_FORMAT_LIST; used to indicate whether */
+    /* processing of the Format List PDU was successful     */
+    case CB_FORMAT_LIST_RESPONSE: /* CLIPRDR_FORMAT_ACK */
       rv = clipboard_prcoess_format_ack(ls, clip_msg_status,
                                         clip_msg_len);
       break;
-    case 4: /* CLIPRDR_DATA_REQUEST */
+    /* sent by recipient of CB_FORMAT_LIST; used to request data for one */
+    /* of the formats that was listed in CB_FORMAT_LIST                  */
+    case CB_FORMAT_DATA_REQUEST: /* CLIPRDR_DATA_REQUEST */
       rv = clipboard_process_data_request(ls, clip_msg_status,
                                           clip_msg_len);
       break;
-    case 5: /* CLIPRDR_DATA_RESPONSE */
+    /* sent as a reply to CB_FORMAT_DATA_REQUEST; used to indicate */
+    /* whether processing of the CB_FORMAT_DATA_REQUEST was        */
+    /* successful; if processing was successful,                   */
+    /* CB_FORMAT_DATA_RESPONSE includes contents of requested      */
+    /* clipboard data.                                             */
+    case CB_FORMAT_DATA_RESPONSE: /* CLIPRDR_DATA_RESPONSE */
       rv = clipboard_process_data_response(ls, clip_msg_status,
                                            clip_msg_len);
       break;
@@ -668,6 +842,18 @@ clipboard_get_window_property(Window wnd, Atom prop, Atom* type, int* fmt,
     /* XGetWindowProperty failed */
     return 1;
   }
+
+  if (ltype == g_incr_atom)
+  {
+    g_incr_in_progress = 1;
+    g_incr_atom_type = prop;
+    g_incr_data_size = 0;
+    g_free(g_incr_data);
+    g_incr_data = 0;
+    XDeleteProperty(g_display, g_wnd, prop);
+    return;
+  }
+
   if (llen_after < 1)
   {
     /* no data, ok */
@@ -748,10 +934,13 @@ clipboard_event_selection_notify(XEvent* xevent)
   int index;
   int convert_to_string;
   int convert_to_utf8;
+  int convert_to_bmp_image;
   int send_format_announce;
   int atom;
   int* atoms;
   Atom type;
+  tui32 format_id;
+  unsigned char format_name[32];
 
   LOGM((LOG_LEVEL_DEBUG, "clipboard_event_selection_notify:"));
   data_size = 0;
@@ -764,6 +953,7 @@ clipboard_event_selection_notify(XEvent* xevent)
   data = 0;
   type = 0;
   lxevent = (XSelectionEvent*)xevent;
+  g_memset(format_name, 0, 32);
   if (lxevent->property == None)
   {
     LOGM((LOG_LEVEL_ERROR, "clipboard_event_selection_notify: clip could "
@@ -772,6 +962,13 @@ clipboard_event_selection_notify(XEvent* xevent)
   }
   if (rv == 0)
   {
+    /* we need this if the call below turns out to be a
+       clipboard INCR operation */
+    if (!g_incr_in_progress)
+    {
+      g_incr_atom_target = lxevent->target;
+    }
+
     rv = clipboard_get_window_property(lxevent->requestor, lxevent->property,
                                        &type, &fmt,
                                        &n_items, &data, &data_size);
@@ -804,6 +1001,10 @@ clipboard_event_selection_notify(XEvent* xevent)
             {
               convert_to_string = 1;
             }
+            else if (atom == g_image_bmp_atom)
+            {
+              convert_to_bmp_image = 1;
+            }
           }
         }
         else
@@ -818,6 +1019,7 @@ clipboard_event_selection_notify(XEvent* xevent)
         LOGM((LOG_LEVEL_DEBUG,"clipboard_event_selection_notify: UTF8_STRING "
               "data_size %d", data_size));
         g_free(g_last_clip_data);
+        g_last_clip_data = 0;
         g_last_clip_size = data_size;
         g_last_clip_data = g_malloc(g_last_clip_size + 1, 0);
         g_last_clip_type = g_utf8_atom;
@@ -830,12 +1032,28 @@ clipboard_event_selection_notify(XEvent* xevent)
         LOGM((LOG_LEVEL_DEBUG,"clipboard_event_selection_notify: XA_STRING "
               "data_size %d", data_size));
         g_free(g_last_clip_data);
+        g_last_clip_data = 0;
         g_last_clip_size = data_size;
         g_last_clip_data = g_malloc(g_last_clip_size + 1, 0);
         g_last_clip_type = XA_STRING;
         g_memcpy(g_last_clip_data, data, g_last_clip_size);
         g_last_clip_data[g_last_clip_size] = 0;
         send_format_announce = 1;
+        format_id = CB_FORMAT_UNICODETEXT;
+      }
+      else if (lxevent->target == g_image_bmp_atom)
+      {
+        LOGM((LOG_LEVEL_DEBUG, "clipboard_event_selection_notify: image/bmp "
+              "data_size %d", data_size));
+        g_free(g_last_clip_data);
+        g_last_clip_data = 0;
+        g_last_clip_size = data_size;
+        g_last_clip_data = g_malloc(data_size, 0);
+        g_last_clip_type = g_image_bmp_atom;
+        g_memcpy(g_last_clip_data, data, data_size);
+        send_format_announce = 1;
+        format_id = CB_FORMAT_DIB;
+        g_strcpy(format_name, "image/bmp");
       }
       else
       {
@@ -859,9 +1077,14 @@ clipboard_event_selection_notify(XEvent* xevent)
     XConvertSelection(g_display, g_clipboard_atom, XA_STRING,
                       g_clip_property_atom, g_wnd, lxevent->time);
   }
+  else if (convert_to_bmp_image)
+  {
+    XConvertSelection(g_display, g_clipboard_atom, g_image_bmp_atom,
+                      g_clip_property_atom, g_wnd, lxevent->time);
+  }
   if (send_format_announce)
   {
-    if (clipboard_send_format_announce() != 0)
+    if (clipboard_send_format_announce(format_id, format_name) != 0)
     {
       rv = 4;
     }
@@ -885,17 +1108,23 @@ clipboard_event_selection_notify(XEvent* xevent)
      Atom property;
      Time time;
    } XSelectionRequestEvent; */
+/*
+ * When XGetWindowProperty and XChangeProperty talk about "format 32" it
+ * doesn't mean a 32bit value, but actually a long. So 32 means 4 bytes on
+ * a 32bit machine and 8 bytes on a 64 machine
+ */
 static int APP_CC
 clipboard_event_selection_request(XEvent* xevent)
 {
-  //XEvent xev;
   XSelectionRequestEvent* lxev;
-  tui32 ui32[8];
+  XEvent xev;
+  Atom atom_buf[10];
   Atom type;
   int fmt;
   int n_items;
   int xdata_size;
   char* xdata;
+  int i;
 
   lxev = (XSelectionRequestEvent*)xevent;
   LOGM((LOG_LEVEL_DEBUG, "clipboard_event_selection_request: g_wnd %d, "
@@ -913,20 +1142,21 @@ clipboard_event_selection_request(XEvent* xevent)
     /* requestor is asking what the selection can be converted to */
     LOGM((LOG_LEVEL_DEBUG, "clipboard_event_selection_request: "
           "g_targets_atom"));
-    ui32[0] = g_targets_atom;
-    ui32[1] = g_timestamp_atom;
-    ui32[2] = g_multiple_atom;
-    ui32[3] = XA_STRING;
-    ui32[4] = g_utf8_atom;
-    return clipboard_provide_selection(lxev, XA_ATOM, 32, (char*)ui32, 5);
+    atom_buf[0] = g_targets_atom;
+    atom_buf[1] = g_timestamp_atom;
+    atom_buf[2] = g_multiple_atom;
+    atom_buf[3] = XA_STRING;
+    atom_buf[4] = g_utf8_atom;
+    atom_buf[5] = g_image_bmp_atom;
+    return clipboard_provide_selection(lxev, XA_ATOM, 32, (char*)atom_buf, 6);
   }
   else if (lxev->target == g_timestamp_atom)
   {
     /* requestor is asking the time I got the selection */
     LOGM((LOG_LEVEL_DEBUG, "clipboard_event_selection_request: "
           "g_timestamp_atom"));
-    ui32[0] = g_selection_time;
-    return clipboard_provide_selection(lxev, XA_INTEGER, 32, (char*)ui32, 1);
+    atom_buf[0] = g_selection_time;
+    return clipboard_provide_selection(lxev, XA_INTEGER, 32, (char*)atom_buf, 1);
   }
   else if (lxev->target == g_multiple_atom)
   {
@@ -950,6 +1180,7 @@ clipboard_event_selection_request(XEvent* xevent)
   {
     LOGM((LOG_LEVEL_DEBUG, "clipboard_event_selection_request: %s",
           XGetAtomName(g_display, lxev->target)));
+    clipboard_format_id = CB_FORMAT_UNICODETEXT;
     if (g_data_in_up_to_date)
     {
       return clipboard_provide_selection(lxev, lxev->target, 8,
@@ -1017,9 +1248,88 @@ clipboard_event_selection_clear(XEvent* xevent)
 static int APP_CC
 clipboard_event_property_notify(XEvent* xevent)
 {
+  Atom actual_type_return;
+  int actual_format_return;
+  unsigned long nitems_returned;
+  unsigned long bytes_left;
+  unsigned char* data;
+  int rv;
+  int format_in_bytes;
+  int new_data_len;
+  char* cptr;
+  unsigned char format_name[32];
+
   LOG(10, ("clipboard_check_wait_objs: PropertyNotify .window %d "
       ".state %d .atom %d", xevent->xproperty.window,
       xevent->xproperty.state, xevent->xproperty.atom));
+  if (g_incr_in_progress &&
+      (xevent->xproperty.atom == g_incr_atom_type) &&
+      (xevent->xproperty.state == PropertyNewValue))
+  {
+    rv = XGetWindowProperty(g_display, g_wnd, g_incr_atom_type, 0, 0, 0,
+                            AnyPropertyType, &actual_type_return, &actual_format_return,
+                            &nitems_returned, &bytes_left, (unsigned char **) &data);
+    if (data != 0)
+    {
+      XFree(data);
+      data = 0;
+    }
+    if (bytes_left <= 0)
+    {
+      g_memset(format_name, 0, 32);
+      /* clipboard INCR cycle has completed */
+      g_incr_in_progress = 0;
+      g_last_clip_size = g_incr_data_size;
+      g_last_clip_data = g_incr_data;
+      g_last_clip_type = g_incr_atom_target;
+      if (g_incr_atom_target == g_image_bmp_atom)
+      {
+        g_snprintf(format_name, 31, "image/bmp");
+        clipboard_send_format_announce(CB_FORMAT_DIB, format_name);
+      }
+      XDeleteProperty(g_display, g_wnd, g_incr_atom_type);
+    }
+    else
+    {
+      rv = XGetWindowProperty(g_display, g_wnd, g_incr_atom_type, 0, bytes_left, 0,
+                              AnyPropertyType, &actual_type_return, &actual_format_return,
+                              &nitems_returned, &bytes_left, (unsigned char **) &data);
+
+      format_in_bytes = actual_format_return / 8;
+      if (actual_format_return == 32 && sizeof(long) == 8)
+      {
+        /* on a 64 bit machine, actual_format_return of 32 implies long */
+        format_in_bytes = 8;
+      }
+      new_data_len = nitems_returned * format_in_bytes;
+#if 1
+      g_free(g_incr_data);
+      cptr = (char *) g_malloc(g_incr_data_size + new_data_len, 0);
+#else
+      cptr = (char *) realloc(g_incr_data, g_incr_data_size + new_data_len);
+#endif
+      if (cptr == NULL)
+      {
+        /* cannot add any more data */
+        if (data != 0)
+        {
+          XFree(data);
+          data = 0;
+        }
+        XDeleteProperty(g_display, g_wnd, g_incr_atom_type);
+        return 0;
+      }
+      g_incr_data = cptr;
+      g_memcpy(g_incr_data + g_incr_data_size, data, new_data_len);
+      g_incr_data_size += new_data_len;
+      if (data)
+      {
+        XFree(data);
+        data = 0;
+      }
+      XDeleteProperty(g_display, g_wnd, g_incr_atom_type);
+    }
+  }
   return 0;
 }