remmina/remmina-1.0.0-add-clipboard-support.patch

From 3ebdd6e7b0ee53ecdaf0d14bada6b92e7334b12a Mon Sep 17 00:00:00 2001
From: Jean-Louis Dupond <jean-louis@dupond.be>
Date: Mon, 30 Apr 2012 23:10:04 +0200
Subject: [PATCH] Add clipboard support

---
 remmina-plugins/rdp/CMakeLists.txt |    2 +
 remmina-plugins/rdp/rdp_cliprdr.c  |  459 ++++++++++++++++++++++++++++++++++++
 remmina-plugins/rdp/rdp_cliprdr.h  |   33 +++
 remmina-plugins/rdp/rdp_event.c    |   19 ++
 remmina-plugins/rdp/rdp_plugin.c   |   15 ++
 remmina-plugins/rdp/rdp_plugin.h   |    6 +-
 6 files changed, 533 insertions(+), 1 deletion(-)
 create mode 100644 remmina-plugins/rdp/rdp_cliprdr.c
 create mode 100644 remmina-plugins/rdp/rdp_cliprdr.h

diff --git a/remmina-plugins/rdp/CMakeLists.txt b/remmina-plugins/rdp/CMakeLists.txt
index e3ec20b..8ae4a4d 100644
--- a/remmina-plugins/rdp/CMakeLists.txt
+++ b/remmina-plugins/rdp/CMakeLists.txt
@@ -33,6 +33,8 @@ set(REMMINA_PLUGIN_RDP_SRCS
 	rdp_gdi.h
 	rdp_graphics.c
 	rdp_graphics.h
+	rdp_cliprdr.c
+	rdp_cliprdr.h
 	)
 
 add_library(remmina-plugin-rdp ${REMMINA_PLUGIN_RDP_SRCS})
diff --git a/remmina-plugins/rdp/rdp_cliprdr.c b/remmina-plugins/rdp/rdp_cliprdr.c
new file mode 100644
index 0000000..0821ffa
--- /dev/null
+++ b/remmina-plugins/rdp/rdp_cliprdr.c
@@ -0,0 +1,459 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2012-2012 Jean-Louis Dupond
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, 
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include "rdp_plugin.h"
+#include "rdp_cliprdr.h"
+
+#include <freerdp/freerdp.h>
+#include <freerdp/utils/memory.h>
+#include <freerdp/channels/channels.h>
+#include <freerdp/plugins/cliprdr.h>
+
+/*
+ * Get the formats we can export based on the current clipboard data.
+ */
+void remmina_rdp_cliprdr_get_target_types(uint32** dst_formats, uint16* size, GdkAtom* types, int count)
+{
+	int i;
+	gboolean image = FALSE;
+	gboolean text = FALSE;
+	gboolean textutf8 = FALSE;
+	int matches = 1;
+	uint32* formats = (uint32*) xmalloc(sizeof(uint32) * 10);
+
+	formats[0] = CB_FORMAT_RAW;	
+	for (i = 0; i < count; i++)
+	{	
+		GdkAtom atom = GDK_POINTER_TO_ATOM(types[i]);
+		gchar* name = gdk_atom_name(atom);
+		if (g_strcmp0("UTF8_STRING", name) == 0 || g_strcmp0("text/plain;charset=utf-8", name) == 0)
+		{
+			textutf8 = TRUE;
+		}
+		if (g_strcmp0("TEXT", name) == 0 || g_strcmp0("text/plain", name) == 0)
+		{
+			text = TRUE;
+		}
+		if (g_strcmp0("text/html", name) == 0)
+		{
+			formats[matches] = CB_FORMAT_HTML;
+			matches++;
+		}
+		if (g_strcmp0("image/png", name) == 0)
+		{
+			formats[matches] = CB_FORMAT_PNG;
+			image = TRUE;
+			matches++;
+		}
+		if (g_strcmp0("image/jpeg", name) == 0)
+		{
+			formats[matches] = CB_FORMAT_JPEG;
+			image = TRUE;
+			matches++;
+		}
+		if (g_strcmp0("image/bmp", name) == 0)
+		{
+			formats[matches] = CB_FORMAT_DIB;
+			image = TRUE;
+			matches++;
+		}
+	}
+	//Only add text formats if we don't have image formats
+	if (!image)
+	{
+		if (textutf8)
+		{
+			formats[matches] = CB_FORMAT_UNICODETEXT;
+			matches++;
+		}
+		if (text)
+		{
+			formats[matches] = CB_FORMAT_TEXT;
+			matches++;
+		}
+	}
+
+	*size = (uint16)matches;
+	*dst_formats = (uint32*) xmalloc(sizeof(uint32) * matches);
+	memcpy(*dst_formats, formats, sizeof(uint32) * matches);
+	g_free(formats);
+}
+
+int remmina_rdp_cliprdr_send_format_list_event(RemminaProtocolWidget* gp)
+{
+	GtkClipboard* clipboard;
+	GdkAtom* targets;
+	gboolean result = 0;
+	gint count;
+	RDP_EVENT* rdp_event;
+	RDP_CB_FORMAT_LIST_EVENT* format_list_event;
+	rfContext* rfi = GET_DATA(gp);
+
+	/* Lets see if we have something in our clipboard */
+	THREADS_ENTER
+	clipboard = gtk_widget_get_clipboard(rfi->drawing_area, GDK_SELECTION_CLIPBOARD);
+	if (clipboard)
+	{
+		result = gtk_clipboard_wait_for_targets(clipboard, &targets, &count);
+	}
+	THREADS_LEAVE
+	
+	if (!result)
+		return 1;
+
+	int i;
+	for (i = 0; i < count; i++)
+	{
+		g_printf("Target %d: %s\n", i, gdk_atom_name(targets[i]));
+	}
+
+	rdp_event = (RDP_EVENT*) xnew(RDP_CB_FORMAT_LIST_EVENT);
+	rdp_event->event_class = RDP_EVENT_CLASS_CLIPRDR;
+	rdp_event->event_type = RDP_EVENT_TYPE_CB_FORMAT_LIST;
+	format_list_event = (RDP_CB_FORMAT_LIST_EVENT*) rdp_event;
+	
+	remmina_rdp_cliprdr_get_target_types(&format_list_event->formats, &format_list_event->num_formats, targets, count);
+	g_free(targets);
+
+	int num_formats = format_list_event->num_formats;
+	g_printf("Sending %d formats\n", num_formats);
+	for (i = 0; i < num_formats; i++)
+	{
+		g_printf("Sending format %#X\n", format_list_event->formats[i]);
+	}
+	
+	return freerdp_channels_send_event(rfi->channels, (RDP_EVENT*) format_list_event);
+}
+
+static uint8* lf2crlf(uint8* data, int* size)
+{
+        uint8 c;
+        uint8* outbuf;
+        uint8* out;
+        uint8* in_end;
+        uint8* in;
+        int out_size;
+
+        out_size = (*size) * 2 + 1;
+        outbuf = (uint8*) xmalloc(out_size);
+        out = outbuf;
+        in = data;
+        in_end = data + (*size);
+
+        while (in < in_end)
+        {
+                c = *in++;
+                if (c == '\n')
+                {
+                        *out++ = '\r';
+                        *out++ = '\n';
+                }
+                else
+                {
+                        *out++ = c;
+                }
+        }
+
+        *out++ = 0;
+        *size = out - outbuf;
+
+        return outbuf;
+}
+
+static void crlf2lf(uint8* data, int* size)
+{
+        uint8 c;
+        uint8* out;
+        uint8* in;
+        uint8* in_end;
+
+        out = data;
+        in = data;
+        in_end = data + (*size);
+
+        while (in < in_end)
+        {
+                c = *in++;
+
+                if (c != '\r')
+                        *out++ = c;
+        }
+
+        *size = out - data;
+}
+
+uint8* remmina_rdp_cliprdr_get_data(RemminaProtocolWidget* gp, uint32 format, int* size)
+{
+	g_printf("GetData: Requested Format: %#X\n", format);
+	rfContext* rfi = GET_DATA(gp);
+	GtkClipboard* clipboard;
+	uint8* inbuf = NULL;
+	uint8* outbuf = NULL;
+	GdkPixbuf *image = NULL;
+	
+	THREADS_ENTER
+	clipboard = gtk_widget_get_clipboard(rfi->drawing_area, GDK_SELECTION_CLIPBOARD);
+	if (clipboard)
+	{
+		if (format == CB_FORMAT_TEXT || format == CB_FORMAT_UNICODETEXT || format == CB_FORMAT_HTML)
+		{
+			inbuf = (uint8*)gtk_clipboard_wait_for_text(clipboard);
+		}
+		if (format == CB_FORMAT_PNG || format == CB_FORMAT_JPEG || format == CB_FORMAT_DIB)
+		{
+			image = gtk_clipboard_wait_for_image(clipboard);
+		}
+	}
+	THREADS_LEAVE
+
+	if (format == CB_FORMAT_TEXT || format == CB_FORMAT_HTML || format == CB_FORMAT_UNICODETEXT)
+	{
+		lf2crlf(inbuf, size);
+		if (format == CB_FORMAT_TEXT)
+		{
+			outbuf = inbuf;
+		}
+		if (format == CB_FORMAT_HTML)
+		{
+			//TODO: check if we need special handling for HTML
+			outbuf = inbuf;
+		}
+		if (format == CB_FORMAT_UNICODETEXT)
+		{
+			size_t out_size;
+			UNICONV* uniconv;
+			
+			uniconv = freerdp_uniconv_new();
+			outbuf = (uint8*) freerdp_uniconv_out(uniconv, (char*) inbuf, &out_size);
+			freerdp_uniconv_free(uniconv);
+			*size = out_size + 2;
+		}
+	}
+	if (format == CB_FORMAT_PNG || format == CB_FORMAT_JPEG || format == CB_FORMAT_DIB)
+	{
+		gchar* data;
+		gsize buffersize;
+		if (format == CB_FORMAT_PNG)
+		{
+			gdk_pixbuf_save_to_buffer(image, &data, &buffersize, "png", NULL, NULL);
+			memcpy(outbuf, data, buffersize);
+		}
+		if (format == CB_FORMAT_JPEG)
+		{
+			gdk_pixbuf_save_to_buffer(image, &data, &buffersize, "jpeg", NULL, NULL);
+			memcpy(outbuf, data, buffersize);
+		}
+		if (format == CB_FORMAT_DIB)
+		{
+			gdk_pixbuf_save_to_buffer(image, &data, &buffersize, "bmp", NULL, NULL);
+			*size = buffersize - 14;
+			g_printf("Size of pixels: %d\n", *size);
+			outbuf = (uint8*) xmalloc(*size);
+			memcpy(outbuf, data + 14, *size);
+		}
+	}
+	
+	if (!outbuf)
+		outbuf = (uint8*)"";
+
+	return outbuf;
+}
+
+void remmina_rdp_cliprdr_parse_response_event(RemminaProtocolWidget* gp, RDP_EVENT* event)
+{
+	g_printf("Received RDP_EVENT_TYPE_CB_DATA_RESPONSE\n");
+
+	GtkClipboard* clipboard;
+	GdkPixbuf *image = NULL;
+	uint8* data;
+	int size;
+	gboolean text = FALSE;
+	gboolean img = FALSE;
+	rfContext* rfi = GET_DATA(gp);
+	RDP_CB_DATA_RESPONSE_EVENT* data_response_event;
+
+	data_response_event = (RDP_CB_DATA_RESPONSE_EVENT*) event;
+	data = data_response_event->data;
+	size = data_response_event->size;
+
+	g_printf("Requested format was: 0x%x\n", rfi->requested_format);
+	
+	if (rfi->requested_format == CB_FORMAT_TEXT || rfi->requested_format == CB_FORMAT_UNICODETEXT || rfi->requested_format == CB_FORMAT_HTML)
+	{
+		if (rfi->requested_format == CB_FORMAT_UNICODETEXT)
+		{
+			UNICONV* uniconv;
+
+			uniconv = freerdp_uniconv_new();
+			data = (uint8*) freerdp_uniconv_in(uniconv, data, size);
+			size = strlen((char*) data);
+			freerdp_uniconv_free(uniconv);
+		}
+		crlf2lf(data, &size);
+		text = TRUE;
+	}
+	if (rfi->requested_format == CB_FORMAT_DIB || rfi->requested_format == CB_FORMAT_PNG || rfi->requested_format == CB_FORMAT_JPEG)
+	{
+		/* Reconstruct header */
+		if (rfi->requested_format == CB_FORMAT_DIB)
+		{
+			STREAM* s;
+			uint16 bpp;
+			uint32 offset;
+			uint32 ncolors;
+
+			s = stream_new(0);
+			stream_attach(s, data, size);
+			stream_seek(s, 14);
+			stream_read_uint16(s, bpp);
+			stream_read_uint32(s, ncolors);
+			offset = 14 + 40 + (bpp <= 8 ? (ncolors == 0 ? (1 << bpp) : ncolors) * 4 : 0);
+			stream_detach(s);
+			stream_free(s);
+
+			s = stream_new(14 + size);
+			stream_write_uint8(s, 'B');
+			stream_write_uint8(s, 'M');
+			stream_write_uint32(s, 14 + size);
+			stream_write_uint32(s, 0);
+			stream_write_uint32(s, offset);
+			stream_write(s, data, size);
+
+			data = stream_get_head(s);
+			size = stream_get_length(s);
+			stream_detach(s);
+			stream_free(s);
+		}
+		GdkPixbufLoader *pixbuf;
+		pixbuf = gdk_pixbuf_loader_new();
+		gdk_pixbuf_loader_write(pixbuf, data, size, NULL);
+		image = gdk_pixbuf_loader_get_pixbuf(pixbuf);
+		img = TRUE;
+	}
+
+	THREADS_ENTER
+	clipboard = gtk_widget_get_clipboard(rfi->drawing_area, GDK_SELECTION_CLIPBOARD);
+	if (clipboard)
+	{
+		if (text || img)
+			rfi->clipboard_wait = TRUE;
+		if (text)
+			gtk_clipboard_set_text(clipboard, (gchar*)data, size);		
+		if (img)
+			gtk_clipboard_set_image(clipboard, image);
+	}
+	THREADS_LEAVE
+	
+}
+
+void remmina_handle_channel_event(RemminaProtocolWidget* gp, RDP_EVENT* event)
+{
+	RDP_EVENT* rdp_event = NULL;
+	rfContext* rfi = GET_DATA(gp);
+
+	switch (event->event_class)
+	{
+		case RDP_EVENT_CLASS_CLIPRDR:
+			g_printf("Event ID: %d\n", event->event_type);
+			if (event->event_type == RDP_EVENT_TYPE_CB_MONITOR_READY)
+			{
+				g_printf("Received CB_MONITOR_READY - Sending RDP_EVENT_TYPE_CB_FORMAT_LIST\n");
+				/* Sending our format list */
+				remmina_rdp_cliprdr_send_format_list_event(gp);
+			}
+			if (event->event_type == RDP_EVENT_TYPE_CB_FORMAT_LIST)
+			{
+				/* We received a FORMAT_LIST from the server, update our clipboard */
+				g_printf("Received RDP_EVENT_TYPE_CB_FORMAT_LIST\n");
+				int i;	
+				uint32 format = CB_FORMAT_RAW;	
+				RDP_CB_FORMAT_LIST_EVENT* format_list_event;
+
+				format_list_event = (RDP_CB_FORMAT_LIST_EVENT*) event;
+
+				g_printf("Format List Size: %d\n", format_list_event->num_formats);
+				for (i = 0; i < format_list_event->num_formats; i++)
+				{
+					g_printf("Format: 0x%X\n", format_list_event->formats[i]);
+					if (format_list_event->formats[i] == CB_FORMAT_UNICODETEXT)
+					{
+						format = CB_FORMAT_UNICODETEXT;
+						break;
+					}
+					if (format_list_event->formats[i] == CB_FORMAT_DIB)
+					{
+						format = CB_FORMAT_DIB;
+						break;
+					}
+					if (format_list_event->formats[i] == CB_FORMAT_JPEG)
+					{
+						format = CB_FORMAT_JPEG;
+						break;
+					}
+					if (format_list_event->formats[i] == CB_FORMAT_PNG)
+					{
+						format = CB_FORMAT_PNG;
+						break;
+					}
+					if (format_list_event->formats[i] == CB_FORMAT_TEXT)
+					{
+						format = CB_FORMAT_TEXT;
+						break;
+					}				
+				}
+				rfi->requested_format = format;
+				
+				g_printf("Format Requested: 0x%X\n", format);
+				/* Request Clipboard data of the server */
+				RDP_CB_DATA_REQUEST_EVENT* data_request_event;
+				rdp_event = (RDP_EVENT*) xnew(RDP_CB_DATA_REQUEST_EVENT);
+				rdp_event->event_class = RDP_EVENT_CLASS_CLIPRDR;
+				rdp_event->event_type = RDP_EVENT_TYPE_CB_DATA_REQUEST;
+				data_request_event = (RDP_CB_DATA_REQUEST_EVENT*) rdp_event;
+				data_request_event->format = format;
+				freerdp_channels_send_event(rfi->channels, (RDP_EVENT*) data_request_event);
+			}
+			if (event->event_type == RDP_EVENT_TYPE_CB_DATA_REQUEST)
+			{	
+				g_printf("Received RDP_EVENT_TYPE_CB_DATA_REQUEST\n");
+				
+				uint8* data;
+				int size;
+				RDP_CB_DATA_REQUEST_EVENT* data_request_event = (RDP_CB_DATA_REQUEST_EVENT*) event;
+				RDP_CB_DATA_RESPONSE_EVENT* data_response_event;
+
+				g_printf("Event Format: %d\n", data_request_event->format);
+
+				/* Send Data */
+				rdp_event = (RDP_EVENT*) xnew(RDP_CB_DATA_RESPONSE_EVENT);
+				rdp_event->event_class = RDP_EVENT_CLASS_CLIPRDR;
+				rdp_event->event_type = RDP_EVENT_TYPE_CB_DATA_RESPONSE;
+				data_response_event = (RDP_CB_DATA_RESPONSE_EVENT*) rdp_event;
+				data = remmina_rdp_cliprdr_get_data(gp, data_request_event->format, &size);
+				data_response_event->data = data;
+				data_response_event->size = size;
+				freerdp_channels_send_event(rfi->channels, rdp_event);
+			}
+			if (event->event_type == RDP_EVENT_TYPE_CB_DATA_RESPONSE)
+			{
+				remmina_rdp_cliprdr_parse_response_event(gp, event);
+			}
+	}
+}
diff --git a/remmina-plugins/rdp/rdp_cliprdr.h b/remmina-plugins/rdp/rdp_cliprdr.h
new file mode 100644
index 0000000..ed6bf70
--- /dev/null
+++ b/remmina-plugins/rdp/rdp_cliprdr.h
@@ -0,0 +1,33 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2010-2011 Vic Lee
+ * Copyright (C) 2012-2012 Jean-Louis Dupond
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, 
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __REMMINA_RDP_CLIPRDR_H__
+#define __REMMINA_RDP_CLIPRDR_H__
+
+G_BEGIN_DECLS
+
+RDP_EVENT* remmina_rdp_cliprdr_get_event(uint16 event_type);
+int remmina_rdp_cliprdr_send_format_list_event(RemminaProtocolWidget* gp);
+void remmina_handle_channel_event(RemminaProtocolWidget* gp, RDP_EVENT* event);
+
+G_END_DECLS
+
+#endif
diff --git a/remmina-plugins/rdp/rdp_event.c b/remmina-plugins/rdp/rdp_event.c
index f77f5f1..a936fb1 100644
--- a/remmina-plugins/rdp/rdp_event.c
+++ b/remmina-plugins/rdp/rdp_event.c
@@ -461,6 +461,16 @@ static gboolean remmina_rdp_event_on_key(GtkWidget* widget, GdkEventKey* event,
 	return TRUE;
 }
 
+static gboolean remmina_rdp_event_on_clipboard(GtkClipboard *clipboard, GdkEvent *event, RemminaProtocolWidget *gp)
+{
+	RemminaPluginRdpEvent rdp_event = { 0 };
+
+	rdp_event.type = REMMINA_RDP_EVENT_TYPE_CLIPBOARD;
+	remmina_rdp_event_event_push(gp, &rdp_event);
+
+	return TRUE;
+}
+
 void remmina_rdp_event_init(RemminaProtocolWidget* gp)
 {
 	gint n;
@@ -470,6 +480,7 @@ void remmina_rdp_event_init(RemminaProtocolWidget* gp)
 	XPixmapFormatValues* pf;
 	XPixmapFormatValues* pfs;
 	rfContext* rfi;
+	GtkClipboard* clipboard;
 
 	rfi = GET_DATA(gp);
 	rfi->drawing_area = gtk_drawing_area_new();
@@ -508,6 +519,14 @@ void remmina_rdp_event_init(RemminaProtocolWidget* gp)
 	g_signal_connect(G_OBJECT(rfi->drawing_area), "key-release-event",
 		G_CALLBACK(remmina_rdp_event_on_key), gp);
 
+	RemminaFile* remminafile = remmina_plugin_service->protocol_plugin_get_file(gp);
+	if (!remmina_plugin_service->file_get_int(remminafile, "disableclipboard", FALSE))
+	{
+		clipboard = gtk_widget_get_clipboard(rfi->drawing_area, GDK_SELECTION_CLIPBOARD);
+		g_signal_connect(clipboard, "owner-change",
+			G_CALLBACK(remmina_rdp_event_on_clipboard), gp);
+	}
+
 	rfi->pressed_keys = g_array_new(FALSE, TRUE, sizeof (gint));
 	rfi->event_queue = g_async_queue_new_full(g_free);
 	rfi->ui_queue = g_async_queue_new();
diff --git a/remmina-plugins/rdp/rdp_plugin.c b/remmina-plugins/rdp/rdp_plugin.c
index 08874e6..fd0fe08 100644
--- a/remmina-plugins/rdp/rdp_plugin.c
+++ b/remmina-plugins/rdp/rdp_plugin.c
@@ -24,6 +24,7 @@
 #include "rdp_graphics.h"
 #include "rdp_file.h"
 #include "rdp_settings.h"
+#include "rdp_cliprdr.h"
 
 #include <errno.h>
 #include <pthread.h>
@@ -31,6 +32,7 @@
 #include <freerdp/freerdp.h>
 #include <freerdp/constants.h>
 #include <freerdp/utils/memory.h>
+#include <freerdp/plugins/cliprdr.h>
 
 #define REMMINA_RDP_FEATURE_TOOL_REFRESH		1
 #define REMMINA_RDP_FEATURE_SCALE			2
@@ -128,6 +130,11 @@ boolean rf_check_fds(RemminaProtocolWidget* gp)
 				input->MouseEvent(input, event->mouse_event.flags,
 						event->mouse_event.x, event->mouse_event.y);
 				break;
+			case REMMINA_RDP_EVENT_TYPE_CLIPBOARD:
+				if (!rfi->clipboard_wait)
+					remmina_rdp_cliprdr_send_format_list_event(gp);
+				rfi->clipboard_wait = FALSE;
+				break;
 		}
 
 		g_free(event);
@@ -503,6 +510,7 @@ static boolean remmina_rdp_verify_certificate(freerdp* instance, char* subject,
 
 static int remmina_rdp_receive_channel_data(freerdp* instance, int channelId, uint8* data, int size, int flags, int total_size)
 {
+	g_printf("EVENT RECEIVED -> DATA: %s\nSIZE: %d\nFLAGS: %d\n", (char*)data, size, flags);
 	return freerdp_channels_data(instance, channelId, data, size, flags, total_size);
 }
 
@@ -518,6 +526,7 @@ static void remmina_rdp_main_loop(RemminaProtocolWidget* gp)
 	fd_set rfds_set;
 	fd_set wfds_set;
 	rfContext* rfi;
+	RDP_EVENT* event;
 
 	memset(rfds, 0, sizeof(rfds));
 	memset(wfds, 0, sizeof(wfds));
@@ -591,6 +600,12 @@ static void remmina_rdp_main_loop(RemminaProtocolWidget* gp)
 		{
 			break;
 		}
+		else
+		{
+			event = freerdp_channels_pop_event(rfi->channels);
+			if (event)
+				remmina_handle_channel_event(gp, event);
+		}
 		/* check ui */
 		if (!rf_check_fds(gp))
 		{
diff --git a/remmina-plugins/rdp/rdp_plugin.h b/remmina-plugins/rdp/rdp_plugin.h
index a3774d9..1931384 100644
--- a/remmina-plugins/rdp/rdp_plugin.h
+++ b/remmina-plugins/rdp/rdp_plugin.h
@@ -133,12 +133,16 @@ struct rf_context
 	GArray* pressed_keys;
 	GAsyncQueue* event_queue;
 	gint event_pipe[2];
+
+	gboolean clipboard_wait;
+	uint32 requested_format;
 };
 
 typedef enum
 {
 	REMMINA_RDP_EVENT_TYPE_SCANCODE,
-	REMMINA_RDP_EVENT_TYPE_MOUSE
+	REMMINA_RDP_EVENT_TYPE_MOUSE,
+	REMMINA_RDP_EVENT_TYPE_CLIPBOARD
 } RemminaPluginRdpEventType;
 
 struct remmina_plugin_rdp_event
-- 
1.7.10