Adding upstream version 1.4.34+dfsg.upstream/1.4.34+dfsg

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 2228 insertions, 0 deletions

diff --git a/plugins/vnc/vnc_plugin.c b/plugins/vnc/vnc_plugin.c
new file mode 100644
index 0000000..633a2a9
--- /dev/null
+++ b/plugins/vnc/vnc_plugin.c
@@ -0,0 +1,2228 @@
+/*
+ * Remmina - The GTK+ Remote Desktop Client
+ * Copyright (C) 2010-2011 Vic Lee
+ * Copyright (C) 2014-2015 Antenore Gatta, Fabio Castelli, Giovanni Panozzo
+ * Copyright (C) 2016-2022 Antenore Gatta, Giovanni Panozzo
+ * Copyright (C) 2022-2023 Antenore Gatta, Giovanni Panozzo, Hiroyuki Tanaka
+ *
+ * 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301, USA.
+ *
+ *  In addition, as a special exception, the copyright holders give
+ *  permission to link the code of portions of this program with the
+ *  OpenSSL library under certain conditions as described in each
+ *  individual source file, and distribute linked combinations
+ *  including the two.
+ *  You must obey the GNU General Public License in all respects
+ *  for all of the code used other than OpenSSL. *  If you modify
+ *  file(s) with this exception, you may extend this exception to your
+ *  version of the file(s), but you are not obligated to do so. *  If you
+ *  do not wish to do so, delete this exception statement from your
+ *  version. *  If you delete this exception statement from all source
+ *  files in the program, then also delete it here.
+ *
+ */
+
+#include <gmodule.h>
+#include "vnc_plugin.h"
+#include <rfb/rfbclient.h>
+
+#define REMMINA_PLUGIN_VNC_FEATURE_PREF_QUALITY            1
+#define REMMINA_PLUGIN_VNC_FEATURE_PREF_VIEWONLY           2
+#define REMMINA_PLUGIN_VNC_FEATURE_PREF_DISABLESERVERINPUT 3
+#define REMMINA_PLUGIN_VNC_FEATURE_TOOL_REFRESH            4
+#define REMMINA_PLUGIN_VNC_FEATURE_TOOL_CHAT               5
+#define REMMINA_PLUGIN_VNC_FEATURE_SCALE                   6
+#define REMMINA_PLUGIN_VNC_FEATURE_UNFOCUS                 7
+#define REMMINA_PLUGIN_VNC_FEATURE_TOOL_SENDCTRLALTDEL     8
+#define REMMINA_PLUGIN_VNC_FEATURE_PREF_COLOR	           9
+#define REMMINA_PLUGIN_VNC_FEATURE_DYNRESUPDATE 	       10
+
+#define VNC_DEFAULT_PORT 5900
+
+#define GET_PLUGIN_DATA(gp) (RemminaPluginVncData *)g_object_get_data(G_OBJECT(gp), "plugin-data")
+
+static RemminaPluginService *remmina_plugin_service = NULL;
+
+static int dot_cursor_x_hot = 2;
+static int dot_cursor_y_hot = 2;
+static const gchar *dot_cursor_xpm[] =
+{ "5 5 3 1", "  c None", ".	c #000000", "+	c #FFFFFF", " ... ", ".+++.", ".+ +.", ".+++.", " ... " };
+
+
+#define LOCK_BUFFER(t)      if (t) { CANCEL_DEFER } pthread_mutex_lock(&gpdata->buffer_mutex);
+#define UNLOCK_BUFFER(t)    pthread_mutex_unlock(&gpdata->buffer_mutex); if (t) { CANCEL_ASYNC }
+
+struct onMainThread_cb_data {
+	enum { FUNC_UPDATE_SCALE } func;
+	GtkWidget *		widget;
+	gint			x, y, width, height;
+	RemminaProtocolWidget * gp;
+	gboolean		scale;
+
+	/* Mutex for thread synchronization */
+	pthread_mutex_t		mu;
+	/* Flag to catch cancellations */
+	gboolean		cancelled;
+};
+
+static gboolean onMainThread_cb(struct onMainThread_cb_data *d)
+{
+	TRACE_CALL(__func__);
+	if (!d->cancelled) {
+		switch (d->func) {
+		case FUNC_UPDATE_SCALE:
+			remmina_plugin_vnc_update_scale(d->gp, d->scale);
+			break;
+		}
+		pthread_mutex_unlock(&d->mu);
+	} else {
+		/* thread has been cancelled, so we must free d memory here */
+		g_free(d);
+	}
+	return G_SOURCE_REMOVE;
+}
+
+
+static void onMainThread_cleanup_handler(gpointer data)
+{
+	TRACE_CALL(__func__);
+	struct onMainThread_cb_data *d = data;
+
+	d->cancelled = TRUE;
+}
+
+
+static void onMainThread_schedule_callback_and_wait(struct onMainThread_cb_data *d)
+{
+	TRACE_CALL(__func__);
+	d->cancelled = FALSE;
+	pthread_cleanup_push(onMainThread_cleanup_handler, d);
+	pthread_mutex_init(&d->mu, NULL);
+	pthread_mutex_lock(&d->mu);
+	gdk_threads_add_idle((GSourceFunc)onMainThread_cb, (gpointer)d);
+
+	pthread_mutex_lock(&d->mu);
+
+	pthread_cleanup_pop(0);
+	pthread_mutex_unlock(&d->mu);
+	pthread_mutex_destroy(&d->mu);
+}
+
+/**
+ * Function check_for_endianness() returns 1, if architecture
+ * is little endian, 0 in case of big endian.
+ */
+static gboolean check_for_endianness()
+{
+	unsigned int x = 1;
+	char *c = (char *)&x;
+
+	return (int)*c;
+}
+
+static void remmina_plugin_vnc_event_push(RemminaProtocolWidget *gp, gint event_type, gpointer p1, gpointer p2, gpointer p3)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginVncData *gpdata = GET_PLUGIN_DATA(gp);
+	RemminaPluginVncEvent *event;
+
+	event = g_new(RemminaPluginVncEvent, 1);
+	event->event_type = event_type;
+	switch (event_type) {
+	case REMMINA_PLUGIN_VNC_EVENT_KEY:
+		event->event_data.key.keyval = GPOINTER_TO_UINT(p1);
+		event->event_data.key.pressed = GPOINTER_TO_INT(p2);
+		break;
+	case REMMINA_PLUGIN_VNC_EVENT_POINTER:
+		event->event_data.pointer.x = GPOINTER_TO_INT(p1);
+		event->event_data.pointer.y = GPOINTER_TO_INT(p2);
+		event->event_data.pointer.button_mask = GPOINTER_TO_INT(p3);
+		break;
+	case REMMINA_PLUGIN_VNC_EVENT_CUTTEXT:
+	case REMMINA_PLUGIN_VNC_EVENT_CHAT_SEND:
+		event->event_data.text.text = g_strdup((char *)p1);
+		break;
+	default:
+		break;
+	}
+
+	pthread_mutex_lock(&gpdata->vnc_event_queue_mutex);
+	g_queue_push_tail(gpdata->vnc_event_queue, event);
+	pthread_mutex_unlock(&gpdata->vnc_event_queue_mutex);
+
+	if (write(gpdata->vnc_event_pipe[1], "\0", 1)) {
+		/* Ignore */
+	}
+}
+
+static void remmina_plugin_vnc_event_free(RemminaPluginVncEvent *event)
+{
+	TRACE_CALL(__func__);
+	switch (event->event_type) {
+	case REMMINA_PLUGIN_VNC_EVENT_CUTTEXT:
+	case REMMINA_PLUGIN_VNC_EVENT_CHAT_SEND:
+		g_free(event->event_data.text.text);
+		break;
+	default:
+		break;
+	}
+	g_free(event);
+}
+
+static void remmina_plugin_vnc_event_free_all(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginVncData *gpdata = GET_PLUGIN_DATA(gp);
+	RemminaPluginVncEvent *event;
+
+	/* This is called from main thread after plugin thread has
+	 * been closed, so no queue locking is necessary here */
+	while ((event = g_queue_pop_head(gpdata->vnc_event_queue)) != NULL)
+		remmina_plugin_vnc_event_free(event);
+}
+
+static void remmina_plugin_vnc_scale_area(RemminaProtocolWidget *gp, gint *x, gint *y, gint *w, gint *h)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginVncData *gpdata = GET_PLUGIN_DATA(gp);
+	GtkAllocation widget_allocation;
+	gint width, height;
+	gint sx, sy, sw, sh;
+
+	if (gpdata->rgb_buffer == NULL)
+		return;
+
+	width = remmina_plugin_service->protocol_plugin_get_width(gp);
+	height = remmina_plugin_service->protocol_plugin_get_height(gp);
+
+	gtk_widget_get_allocation(GTK_WIDGET(gp), &widget_allocation);
+
+	if (widget_allocation.width == width && widget_allocation.height == height)
+		return; /* Same size, no scaling */
+
+	/* We have to extend the scaled region 2 scaled pixels, to avoid gaps */
+	sx = MIN(MAX(0, (*x) * widget_allocation.width / width - widget_allocation.width / width - 2), widget_allocation.width - 1);
+	sy = MIN(MAX(0, (*y) * widget_allocation.height / height - widget_allocation.height / height - 2), widget_allocation.height - 1);
+	sw = MIN(widget_allocation.width - sx, (*w) * widget_allocation.width / width + widget_allocation.width / width + 4);
+	sh = MIN(widget_allocation.height - sy, (*h) * widget_allocation.height / height + widget_allocation.height / height + 4);
+
+	*x = sx;
+	*y = sy;
+	*w = sw;
+	*h = sh;
+}
+
+static void remmina_plugin_vnc_update_scale(RemminaProtocolWidget *gp, gboolean scale)
+{
+	TRACE_CALL(__func__);
+	/* This function can be called from a non main thread */
+
+	RemminaPluginVncData *gpdata;
+	gint width, height;
+	
+	if (!remmina_plugin_service->is_main_thread()) {
+		struct onMainThread_cb_data *d;
+		d = (struct onMainThread_cb_data *)g_malloc(sizeof(struct onMainThread_cb_data));
+		d->func = FUNC_UPDATE_SCALE;
+		d->gp = gp;
+		d->scale = scale;
+		onMainThread_schedule_callback_and_wait(d);
+		g_free(d);
+		return;
+	}
+
+	gpdata = GET_PLUGIN_DATA(gp);
+
+	width = remmina_plugin_service->protocol_plugin_get_width(gp);
+	height = remmina_plugin_service->protocol_plugin_get_height(gp);
+	if (scale)
+		/* In scaled mode, drawing_area will get its dimensions from its parent */
+		gtk_widget_set_size_request(GTK_WIDGET(gpdata->drawing_area), -1, -1);
+	else
+		/* In non scaled mode, the plugins forces dimensions of drawing area */
+		gtk_widget_set_size_request(GTK_WIDGET(gpdata->drawing_area), width, height);
+
+	remmina_plugin_service->protocol_plugin_update_align(gp);
+}
+
+gboolean remmina_plugin_vnc_setcursor(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginVncData *gpdata = GET_PLUGIN_DATA(gp);
+	GdkCursor *cur;
+
+	LOCK_BUFFER(FALSE);
+	gpdata->queuecursor_handler = 0;
+
+	if (gpdata->queuecursor_surface) {
+		cur = gdk_cursor_new_from_surface(gdk_display_get_default(), gpdata->queuecursor_surface, gpdata->queuecursor_x,
+						  gpdata->queuecursor_y);
+		gdk_window_set_cursor(gtk_widget_get_window(gpdata->drawing_area), cur);
+		g_object_unref(cur);
+		cairo_surface_destroy(gpdata->queuecursor_surface);
+		gpdata->queuecursor_surface = NULL;
+	} else {
+		gdk_window_set_cursor(gtk_widget_get_window(gpdata->drawing_area), NULL);
+	}
+	UNLOCK_BUFFER(FALSE);
+
+	return FALSE;
+}
+
+static void remmina_plugin_vnc_queuecursor(RemminaProtocolWidget *gp, cairo_surface_t *surface, gint x, gint y)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginVncData *gpdata = GET_PLUGIN_DATA(gp);
+
+	if (gpdata->queuecursor_surface)
+		cairo_surface_destroy(gpdata->queuecursor_surface);
+	gpdata->queuecursor_surface = surface;
+	gpdata->queuecursor_x = x;
+	gpdata->queuecursor_y = y;
+	if (!gpdata->queuecursor_handler)
+		gpdata->queuecursor_handler = IDLE_ADD((GSourceFunc)remmina_plugin_vnc_setcursor, gp);
+}
+
+typedef struct _RemminaKeyVal {
+	guint	keyval;
+	guint16 keycode;
+} RemminaKeyVal;
+
+/***************************** LibVNCClient related codes *********************************/
+
+static const uint32_t remmina_plugin_vnc_no_encrypt_auth_types[] =
+{ rfbNoAuth, rfbVncAuth, rfbMSLogon, 0 };
+
+static RemminaPluginVncEvent *remmina_plugin_vnc_event_queue_pop_head(RemminaPluginVncData *gpdata)
+{
+	RemminaPluginVncEvent *event;
+
+	CANCEL_DEFER;
+	pthread_mutex_lock(&gpdata->vnc_event_queue_mutex);
+
+	event = g_queue_pop_head(gpdata->vnc_event_queue);
+
+	pthread_mutex_unlock(&gpdata->vnc_event_queue_mutex);
+	CANCEL_ASYNC;
+
+	return event;
+}
+
+static void remmina_plugin_vnc_process_vnc_event(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginVncEvent *event;
+	RemminaPluginVncData *gpdata = GET_PLUGIN_DATA(gp);
+	rfbClient *cl;
+	gchar buf[100];
+
+	cl = (rfbClient *)gpdata->client;
+	while ((event = remmina_plugin_vnc_event_queue_pop_head(gpdata)) != NULL) {
+		if (cl) {
+			switch (event->event_type) {
+			case REMMINA_PLUGIN_VNC_EVENT_KEY:
+				SendKeyEvent(cl, event->event_data.key.keyval, event->event_data.key.pressed);
+				break;
+			case REMMINA_PLUGIN_VNC_EVENT_POINTER:
+				SendPointerEvent(cl, event->event_data.pointer.x, event->event_data.pointer.y,
+						 event->event_data.pointer.button_mask);
+				break;
+			case REMMINA_PLUGIN_VNC_EVENT_CUTTEXT:
+				if (event->event_data.text.text) {
+					rfbClientLog("sending clipboard text '%s'\n", event->event_data.text.text);
+					SendClientCutText(cl, event->event_data.text.text, strlen(event->event_data.text.text));
+				}
+				break;
+			case REMMINA_PLUGIN_VNC_EVENT_CHAT_OPEN:
+				TextChatOpen(cl);
+				break;
+			case REMMINA_PLUGIN_VNC_EVENT_CHAT_SEND:
+				TextChatSend(cl, event->event_data.text.text);
+				break;
+			case REMMINA_PLUGIN_VNC_EVENT_CHAT_CLOSE:
+				TextChatClose(cl);
+				TextChatFinish(cl);
+				break;
+			default:
+				rfbClientLog("Ignoring VNC event: 0x%x\n", event->event_type);
+				break;
+			}
+		}
+		remmina_plugin_vnc_event_free(event);
+	}
+	if (read(gpdata->vnc_event_pipe[0], buf, sizeof(buf))) {
+		/* Ignore */
+	}
+}
+
+typedef struct _RemminaPluginVncCuttextParam {
+	RemminaProtocolWidget * gp;
+	gchar *			text;
+	gint			textlen;
+} RemminaPluginVncCuttextParam;
+
+static void remmina_plugin_vnc_update_quality(rfbClient *cl, gint quality)
+{
+	TRACE_CALL(__func__);
+	RemminaProtocolWidget *gp = rfbClientGetClientData(cl, NULL);
+	RemminaFile *remminafile;
+	gchar *enc = NULL;
+
+	/**
+	 * "0", "Poor (fastest)"
+	 * "1", "Medium"
+	 * "2", "Good"
+	 * "9", "Best (slowest)"
+	 */
+	switch (quality) {
+	case 9:
+		cl->appData.useBGR233 = 0;
+		cl->appData.encodingsString = "copyrect zlib hextile raw";
+		cl->appData.compressLevel = 1;
+		cl->appData.qualityLevel = 9;
+		break;
+	case 2:
+		cl->appData.useBGR233 = 0;
+		cl->appData.encodingsString = "tight zrle ultra copyrect hextile zlib corre rre raw";
+		cl->appData.compressLevel = 2;
+		cl->appData.qualityLevel = 7;
+		break;
+	case 1:
+		cl->appData.useBGR233 = 0;
+		cl->appData.encodingsString = "tight zrle ultra copyrect hextile zlib corre rre raw";
+		cl->appData.compressLevel = 3;
+		cl->appData.qualityLevel = 5;
+		break;
+	case 0:
+	default:
+		// bpp8 and tight encoding is not supported in libvnc
+		cl->appData.useBGR233 = 1;
+		cl->appData.encodingsString = "copyrect zrle ultra zlib hextile corre rre raw";
+		cl->appData.qualityLevel = 1;
+		break;
+	}
+	remminafile = remmina_plugin_service->protocol_plugin_get_file(gp);
+	enc = g_strdup(remmina_plugin_service->file_get_string(remminafile, "encodings"));
+	if (enc) {
+		cl->appData.encodingsString = g_strdup(enc);
+		g_free (enc), enc = NULL;
+	}
+	gboolean tight = remmina_plugin_service->file_get_int (remminafile, "tightencoding", FALSE);
+	if (tight) {
+		if (!g_strrstr ( g_strdup(cl->appData.encodingsString), "tight\0")) {
+			cl->appData.encodingsString = g_strdup_printf("%s %s", "tight", g_strdup(cl->appData.encodingsString));
+		}
+	}
+
+	REMMINA_PLUGIN_DEBUG("Quality: %d", quality);
+	REMMINA_PLUGIN_DEBUG("Encodings: %s", cl->appData.encodingsString);
+}
+
+static void remmina_plugin_vnc_update_colordepth(rfbClient *cl, gint colordepth)
+{
+	TRACE_CALL(__func__);
+
+	cl->format.depth = colordepth;
+	cl->appData.requestedDepth = colordepth;
+
+	cl->format.trueColour = 1;
+	cl->format.bigEndian = check_for_endianness()?FALSE:TRUE;
+
+	switch (colordepth) {
+	case 8:
+		cl->format.depth = 8;
+		cl->format.bitsPerPixel = 8;
+		cl->format.blueMax = 3;
+		cl->format.blueShift = 6;
+		cl->format.greenMax = 7;
+		cl->format.greenShift = 3;
+		cl->format.redMax = 7;
+		cl->format.redShift = 0;
+		break;
+	case 16:
+		cl->format.depth = 15;
+		cl->format.bitsPerPixel = 16;
+		cl->format.redShift = 11;
+		cl->format.greenShift = 6;
+		cl->format.blueShift = 1;
+		cl->format.redMax = 31;
+		cl->format.greenMax = 31;
+		cl->format.blueMax = 31;
+		break;
+	case 32:
+	default:
+		cl->format.depth = 24;
+		cl->format.bitsPerPixel = 32;
+		cl->format.blueShift = 0;
+		cl->format.redShift = 16;
+		cl->format.greenShift = 8;
+		cl->format.blueMax = 0xff;
+		cl->format.redMax = 0xff;
+		cl->format.greenMax = 0xff;
+		break;
+	}
+
+	rfbClientLog("colordepth          = %d\n", colordepth);
+	rfbClientLog("format.depth        = %d\n", cl->format.depth);
+	rfbClientLog("format.bitsPerPixel = %d\n", cl->format.bitsPerPixel);
+	rfbClientLog("format.blueShift    = %d\n", cl->format.blueShift);
+	rfbClientLog("format.redShift     = %d\n", cl->format.redShift);
+	rfbClientLog("format.trueColour   = %d\n", cl->format.trueColour);
+	rfbClientLog("format.greenShift   = %d\n", cl->format.greenShift);
+	rfbClientLog("format.blueMax      = %d\n", cl->format.blueMax);
+	rfbClientLog("format.redMax       = %d\n", cl->format.redMax);
+	rfbClientLog("format.greenMax     = %d\n", cl->format.greenMax);
+	rfbClientLog("format.bigEndian    = %d\n", cl->format.bigEndian);
+}
+
+static rfbBool remmina_plugin_vnc_rfb_allocfb(rfbClient *cl)
+{
+	TRACE_CALL(__func__);
+	RemminaProtocolWidget *gp = rfbClientGetClientData(cl, NULL);
+	RemminaPluginVncData *gpdata = GET_PLUGIN_DATA(gp);
+	gint width, height, depth, size;
+	gboolean scale;
+	cairo_surface_t *new_surface, *old_surface;
+
+	width = cl->width;
+	height = cl->height;
+	depth = cl->format.bitsPerPixel;
+	size = width * height * (depth / 8);
+
+	new_surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height);
+	if (cairo_surface_status(new_surface) != CAIRO_STATUS_SUCCESS)
+		return FALSE;
+	old_surface = gpdata->rgb_buffer;
+
+	LOCK_BUFFER(TRUE);
+
+	remmina_plugin_service->protocol_plugin_set_width(gp, width);
+	remmina_plugin_service->protocol_plugin_set_height(gp, height);
+
+	gpdata->rgb_buffer = new_surface;
+
+	if (gpdata->vnc_buffer)
+		g_free(gpdata->vnc_buffer);
+	gpdata->vnc_buffer = (guchar *)g_malloc(size);
+	cl->frameBuffer = gpdata->vnc_buffer;
+
+	UNLOCK_BUFFER(TRUE);
+
+	if (old_surface)
+		cairo_surface_destroy(old_surface);
+
+	scale = (remmina_plugin_service->remmina_protocol_widget_get_current_scale_mode(gp) != REMMINA_PROTOCOL_WIDGET_SCALE_MODE_NONE);
+	remmina_plugin_vnc_update_scale(gp, scale);
+
+	/* Notify window of change so that scroll border can be hidden or shown if needed */
+	remmina_plugin_service->protocol_plugin_desktop_resize(gp);
+
+	/* Refresh the client’s updateRect - bug in xvncclient */
+	cl->updateRect.w = width;
+	cl->updateRect.h = height;
+
+	return TRUE;
+}
+
+static gint remmina_plugin_vnc_bits(gint n)
+{
+	TRACE_CALL(__func__);
+	gint b = 0;
+
+	while (n) {
+		b++;
+		n >>= 1;
+	}
+	return b ? b : 1;
+}
+
+static gboolean remmina_plugin_vnc_queue_draw_area_real(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginVncData *gpdata = GET_PLUGIN_DATA(gp);
+	gint x, y, w, h;
+
+	if (GTK_IS_WIDGET(gp) && gpdata->connected) {
+		LOCK_BUFFER(FALSE);
+		x = gpdata->queuedraw_x;
+		y = gpdata->queuedraw_y;
+		w = gpdata->queuedraw_w;
+		h = gpdata->queuedraw_h;
+		gpdata->queuedraw_handler = 0;
+		UNLOCK_BUFFER(FALSE);
+
+		gtk_widget_queue_draw_area(GTK_WIDGET(gp), x, y, w, h);
+	}
+	return FALSE;
+}
+
+static void remmina_plugin_vnc_queue_draw_area(RemminaProtocolWidget *gp, gint x, gint y, gint w, gint h)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginVncData *gpdata = GET_PLUGIN_DATA(gp);
+	gint nx2, ny2, ox2, oy2;
+
+	LOCK_BUFFER(TRUE);
+	if (gpdata->queuedraw_handler) {
+		nx2 = x + w;
+		ny2 = y + h;
+		ox2 = gpdata->queuedraw_x + gpdata->queuedraw_w;
+		oy2 = gpdata->queuedraw_y + gpdata->queuedraw_h;
+		gpdata->queuedraw_x = MIN(gpdata->queuedraw_x, x);
+		gpdata->queuedraw_y = MIN(gpdata->queuedraw_y, y);
+		gpdata->queuedraw_w = MAX(ox2, nx2) - gpdata->queuedraw_x;
+		gpdata->queuedraw_h = MAX(oy2, ny2) - gpdata->queuedraw_y;
+	} else {
+		gpdata->queuedraw_x = x;
+		gpdata->queuedraw_y = y;
+		gpdata->queuedraw_w = w;
+		gpdata->queuedraw_h = h;
+		gpdata->queuedraw_handler = IDLE_ADD((GSourceFunc)remmina_plugin_vnc_queue_draw_area_real, gp);
+	}
+	UNLOCK_BUFFER(TRUE);
+}
+
+static void remmina_plugin_vnc_rfb_fill_buffer(rfbClient *cl, guchar *dest, gint dest_rowstride, guchar *src,
+					       gint src_rowstride, guchar *mask, gint w, gint h)
+{
+	TRACE_CALL(__func__);
+	guchar *srcptr;
+	gint bytesPerPixel;
+	guint32 src_pixel;
+	gint ix, iy;
+	gint i;
+	guchar c;
+	gint rs, gs, bs, rm, gm, bm, rl, gl, bl, rr, gr, br;
+	gint r;
+	guint32 *destptr;
+
+	union {
+		struct {
+			guchar a, r, g, b;
+		} colors;
+		guint32 argb;
+	} dst_pixel;
+
+	bytesPerPixel = cl->format.bitsPerPixel / 8;
+	switch (cl->format.bitsPerPixel) {
+	case 32:
+		/* The following codes fill in the Alpha channel swap red/green value */
+		for (iy = 0; iy < h; iy++) {
+			destptr = (guint32 *)(dest + iy * dest_rowstride);
+			srcptr = src + iy * src_rowstride;
+			for (ix = 0; ix < w; ix++) {
+				if (!mask || *mask++) {
+					dst_pixel.colors.a = 0xff;
+					dst_pixel.colors.r = *(srcptr + 2);
+					dst_pixel.colors.g = *(srcptr + 1);
+					dst_pixel.colors.b = *srcptr;
+					*destptr++ = ntohl(dst_pixel.argb);
+				} else {
+					*destptr++ = 0;
+				}
+				srcptr += 4;
+			}
+		}
+		break;
+	default:
+		rm = cl->format.redMax;
+		gm = cl->format.greenMax;
+		bm = cl->format.blueMax;
+		rr = remmina_plugin_vnc_bits(rm);
+		gr = remmina_plugin_vnc_bits(gm);
+		br = remmina_plugin_vnc_bits(bm);
+		rl = 8 - rr;
+		gl = 8 - gr;
+		bl = 8 - br;
+		rs = cl->format.redShift;
+		gs = cl->format.greenShift;
+		bs = cl->format.blueShift;
+		for (iy = 0; iy < h; iy++) {
+			destptr = (guint32 *)(dest + iy * dest_rowstride);
+			srcptr = src + iy * src_rowstride;
+			for (ix = 0; ix < w; ix++) {
+				src_pixel = 0;
+				for (i = 0; i < bytesPerPixel; i++)
+					src_pixel += (*srcptr++) << (8 * i);
+
+				if (!mask || *mask++) {
+					dst_pixel.colors.a = 0xff;
+					c = (guchar)((src_pixel >> rs) & rm) << rl;
+					for (r = rr; r < 8; r *= 2)
+						c |= c >> r;
+					dst_pixel.colors.r = c;
+					c = (guchar)((src_pixel >> gs) & gm) << gl;
+					for (r = gr; r < 8; r *= 2)
+						c |= c >> r;
+					dst_pixel.colors.g = c;
+					c = (guchar)((src_pixel >> bs) & bm) << bl;
+					for (r = br; r < 8; r *= 2)
+						c |= c >> r;
+					dst_pixel.colors.b = c;
+					*destptr++ = ntohl(dst_pixel.argb);
+				} else {
+					*destptr++ = 0;
+				}
+			}
+		}
+		break;
+	}
+}
+
+static void remmina_plugin_vnc_rfb_updatefb(rfbClient *cl, int x, int y, int w, int h)
+{
+	TRACE_CALL(__func__);
+	RemminaProtocolWidget *gp = rfbClientGetClientData(cl, NULL);
+	RemminaPluginVncData *gpdata = GET_PLUGIN_DATA(gp);
+	gint bytesPerPixel;
+	gint rowstride;
+	gint width;
+
+	LOCK_BUFFER(TRUE);
+
+	if (w >= 1 || h >= 1) {
+		width = remmina_plugin_service->protocol_plugin_get_width(gp);
+		bytesPerPixel = cl->format.bitsPerPixel / 8;
+		rowstride = cairo_image_surface_get_stride(gpdata->rgb_buffer);
+		cairo_surface_flush(gpdata->rgb_buffer);
+		remmina_plugin_vnc_rfb_fill_buffer(cl, cairo_image_surface_get_data(gpdata->rgb_buffer) + y * rowstride + x * 4,
+						   rowstride, gpdata->vnc_buffer + ((y * width + x) * bytesPerPixel), width * bytesPerPixel, NULL,
+						   w, h);
+		cairo_surface_mark_dirty(gpdata->rgb_buffer);
+	}
+
+	if ((remmina_plugin_service->remmina_protocol_widget_get_current_scale_mode(gp) != REMMINA_PROTOCOL_WIDGET_SCALE_MODE_NONE))
+		remmina_plugin_vnc_scale_area(gp, &x, &y, &w, &h);
+
+	UNLOCK_BUFFER(TRUE);
+
+	remmina_plugin_vnc_queue_draw_area(gp, x, y, w, h);
+}
+
+static void remmina_plugin_vnc_rfb_finished(rfbClient *cl) __attribute__ ((unused));
+static void remmina_plugin_vnc_rfb_finished(rfbClient *cl)
+{
+	TRACE_CALL(__func__);
+	REMMINA_PLUGIN_DEBUG("FinishedFrameBufferUpdate");
+}
+
+static void remmina_plugin_vnc_rfb_led_state(rfbClient *cl, int value, int pad)
+{
+	TRACE_CALL(__func__);
+	REMMINA_PLUGIN_DEBUG("Led state - value: %d, pad: %d", value, pad);
+}
+
+static gboolean remmina_plugin_vnc_queue_cuttext(RemminaPluginVncCuttextParam *param)
+{
+	TRACE_CALL(__func__);
+	RemminaProtocolWidget *gp = param->gp;
+	RemminaPluginVncData *gpdata = GET_PLUGIN_DATA(gp);
+	GDateTime *t;
+	glong diff;
+	const char *cur_charset;
+	gchar *text;
+	gsize br, bw;
+
+	if (GTK_IS_WIDGET(gp) && gpdata->connected) {
+		t = g_date_time_new_now_utc();
+		diff = g_date_time_difference(t, gpdata->clipboard_timer) / 100000; // tenth of second
+		if (diff >= 10) {
+			g_date_time_unref(gpdata->clipboard_timer);
+			gpdata->clipboard_timer = t;
+			/* Convert text from VNC latin-1 to current GTK charset (usually UTF-8) */
+			g_get_charset(&cur_charset);
+			text = g_convert_with_fallback(param->text, param->textlen, cur_charset, "ISO-8859-1", "?", &br, &bw, NULL);
+			gtk_clipboard_set_text(gtk_clipboard_get(GDK_SELECTION_CLIPBOARD), text, bw);
+			g_free(text);
+		} else {
+			g_date_time_unref(t);
+		}
+	}
+	g_free(param->text);
+	g_free(param);
+	return FALSE;
+}
+
+static void remmina_plugin_vnc_rfb_cuttext(rfbClient *cl, const char *text, int textlen)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginVncCuttextParam *param;
+
+	param = g_new(RemminaPluginVncCuttextParam, 1);
+	param->gp = (RemminaProtocolWidget *)rfbClientGetClientData(cl, NULL);
+	param->text = g_malloc(textlen);
+	memcpy(param->text, text, textlen);
+	param->textlen = textlen;
+	IDLE_ADD((GSourceFunc)remmina_plugin_vnc_queue_cuttext, param);
+}
+
+static char *
+remmina_plugin_vnc_rfb_password(rfbClient *cl)
+{
+	TRACE_CALL(__func__);
+	RemminaProtocolWidget *gp = rfbClientGetClientData(cl, NULL);
+	RemminaPluginVncData *gpdata = GET_PLUGIN_DATA(gp);
+	RemminaFile *remminafile;
+	gchar *pwd = NULL;
+
+	gpdata->auth_called = TRUE;
+	remminafile = remmina_plugin_service->protocol_plugin_get_file(gp);
+
+	if (gpdata->auth_first)
+		pwd = g_strdup(remmina_plugin_service->file_get_string(remminafile, "password"));
+	if (!pwd) {
+		gboolean save;
+		gint ret;
+		gboolean disablepasswordstoring = remmina_plugin_service->file_get_int(remminafile, "disablepasswordstoring", FALSE);
+		ret = remmina_plugin_service->protocol_plugin_init_auth(gp,
+									(disablepasswordstoring ? 0 : REMMINA_MESSAGE_PANEL_FLAG_SAVEPASSWORD),
+									_("Enter VNC password"),
+									NULL,
+									remmina_plugin_service->file_get_string(remminafile, "password"),
+									NULL,
+									NULL);
+		if (ret != GTK_RESPONSE_OK) {
+			gpdata->connected = FALSE;
+			return NULL;
+		}
+		pwd = remmina_plugin_service->protocol_plugin_init_get_password(gp);
+		save = remmina_plugin_service->protocol_plugin_init_get_savepassword(gp);
+		if (save)
+			remmina_plugin_service->file_set_string(remminafile, "password", pwd);
+		else
+			remmina_plugin_service->file_set_string(remminafile, "password", NULL);
+	}
+	return pwd;
+}
+
+static rfbCredential *
+remmina_plugin_vnc_rfb_credential(rfbClient *cl, int credentialType)
+{
+	TRACE_CALL(__func__);
+	rfbCredential *cred;
+	RemminaProtocolWidget *gp = rfbClientGetClientData(cl, NULL);
+	RemminaPluginVncData *gpdata = GET_PLUGIN_DATA(gp);
+	RemminaFile *remminafile;
+	gint ret;
+	gchar *s1, *s2;
+	gboolean disablepasswordstoring;
+
+	gpdata->auth_called = TRUE;
+	remminafile = remmina_plugin_service->protocol_plugin_get_file(gp);
+
+	cred = g_new0(rfbCredential, 1);
+
+	switch (credentialType) {
+	case rfbCredentialTypeUser:
+
+		s1 = g_strdup(remmina_plugin_service->file_get_string(remminafile, "username"));
+
+		s2 = g_strdup(remmina_plugin_service->file_get_string(remminafile, "password"));
+
+		if (gpdata->auth_first && s1 && s2) {
+			cred->userCredential.username = s1;
+			cred->userCredential.password = s2;
+		} else {
+			g_free(s1);
+			g_free(s2);
+
+			disablepasswordstoring = remmina_plugin_service->file_get_int(remminafile, "disablepasswordstoring", FALSE);
+			ret = remmina_plugin_service->protocol_plugin_init_auth(gp,
+										(disablepasswordstoring ? 0 : REMMINA_MESSAGE_PANEL_FLAG_SAVEPASSWORD) | REMMINA_MESSAGE_PANEL_FLAG_USERNAME,
+										_("Enter VNC authentication credentials"),
+										remmina_plugin_service->file_get_string(remminafile, "username"),
+										remmina_plugin_service->file_get_string(remminafile, "password"),
+										NULL,
+										NULL);
+			if (ret == GTK_RESPONSE_OK) {
+				gboolean save = remmina_plugin_service->protocol_plugin_init_get_savepassword(gp);
+				cred->userCredential.username = remmina_plugin_service->protocol_plugin_init_get_username(gp);
+				cred->userCredential.password = remmina_plugin_service->protocol_plugin_init_get_password(gp);
+				if (save) {
+					remmina_plugin_service->file_set_string(remminafile, "username", cred->userCredential.username);
+					remmina_plugin_service->file_set_string(remminafile, "password", cred->userCredential.password);
+				} else {
+					remmina_plugin_service->file_set_string(remminafile, "username", NULL);
+					remmina_plugin_service->file_set_string(remminafile, "password", NULL);
+				}
+			} else {
+				g_free(cred);
+				cred = NULL;
+				gpdata->connected = FALSE;
+			}
+		}
+		break;
+
+	case rfbCredentialTypeX509:
+		if (gpdata->auth_first &&
+		    remmina_plugin_service->file_get_string(remminafile, "cacert")) {
+			cred->x509Credential.x509CACertFile = g_strdup(remmina_plugin_service->file_get_string(remminafile, "cacert"));
+			cred->x509Credential.x509CACrlFile = g_strdup(remmina_plugin_service->file_get_string(remminafile, "cacrl"));
+			cred->x509Credential.x509ClientCertFile = g_strdup(remmina_plugin_service->file_get_string(remminafile, "clientcert"));
+			cred->x509Credential.x509ClientKeyFile = g_strdup(remmina_plugin_service->file_get_string(remminafile, "clientkey"));
+		} else {
+			ret = remmina_plugin_service->protocol_plugin_init_authx509(gp);
+
+			if (ret == GTK_RESPONSE_OK) {
+				cred->x509Credential.x509CACertFile = remmina_plugin_service->protocol_plugin_init_get_cacert(gp);
+				cred->x509Credential.x509CACrlFile = remmina_plugin_service->protocol_plugin_init_get_cacrl(gp);
+				cred->x509Credential.x509ClientCertFile = remmina_plugin_service->protocol_plugin_init_get_clientcert(gp);
+				cred->x509Credential.x509ClientKeyFile = remmina_plugin_service->protocol_plugin_init_get_clientkey(gp);
+			} else {
+				g_free(cred);
+				cred = NULL;
+				gpdata->connected = FALSE;
+			}
+		}
+		break;
+
+	default:
+		g_free(cred);
+		cred = NULL;
+		break;
+	}
+	return cred;
+}
+
+static void remmina_plugin_vnc_rfb_cursor_shape(rfbClient *cl, int xhot, int yhot, int width, int height, int bytesPerPixel)
+{
+	TRACE_CALL(__func__);
+	RemminaProtocolWidget *gp = rfbClientGetClientData(cl, NULL);
+	RemminaPluginVncData *gpdata = GET_PLUGIN_DATA(gp);
+
+	if (!gtk_widget_get_window(GTK_WIDGET(gp)))
+		return;
+
+	if (width && height) {
+		gint stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, width);
+		guchar *data = g_malloc(stride * height);
+		remmina_plugin_vnc_rfb_fill_buffer(cl, data, stride, cl->rcSource,
+						   width * cl->format.bitsPerPixel / 8, cl->rcMask, width, height);
+		cairo_surface_t *surface = cairo_image_surface_create_for_data(data, CAIRO_FORMAT_ARGB32, width, height, stride);
+		if (cairo_surface_status(surface) != CAIRO_STATUS_SUCCESS) {
+			g_free(data);
+			return;
+		}
+		if (cairo_surface_set_user_data(surface, NULL, NULL, g_free) != CAIRO_STATUS_SUCCESS) {
+			g_free(data);
+			return;
+		}
+
+		LOCK_BUFFER(TRUE);
+		remmina_plugin_vnc_queuecursor(gp, surface, xhot, yhot);
+		UNLOCK_BUFFER(TRUE);
+	}
+}
+
+static void remmina_plugin_vnc_rfb_bell(rfbClient *cl)
+{
+	TRACE_CALL(__func__);
+	REMMINA_PLUGIN_DEBUG("Bell message received");
+	RemminaProtocolWidget *gp;
+	RemminaFile *remminafile;
+	GdkWindow *window;
+
+	gp = (RemminaProtocolWidget *)(rfbClientGetClientData(cl, NULL));
+	remminafile = remmina_plugin_service->protocol_plugin_get_file(gp);
+
+	if (remmina_plugin_service->file_get_int(remminafile, "disableserverbell", FALSE))
+		return;
+
+	window = gtk_widget_get_window(GTK_WIDGET(gp));
+
+	if (window)
+		gdk_window_beep(window);
+	REMMINA_PLUGIN_DEBUG("Beep emitted");
+}
+
+/* Translate known VNC messages. It’s for intltool only, not for gcc */
+#ifdef __DO_NOT_COMPILE_ME__
+N_("Unable to connect to VNC server")
+N_("Couldn’t convert '%s' to host address")
+N_("VNC connection failed: %s")
+N_("Your connection has been rejected.")
+#endif
+/** @todo We only store the last message at this moment. */
+#define MAX_ERROR_LENGTH 1000
+static gchar vnc_error[MAX_ERROR_LENGTH + 1];
+static gboolean vnc_encryption_disable_requested;
+
+static void remmina_plugin_vnc_rfb_output(const char *format, ...)
+{
+	TRACE_CALL(__func__);
+	gchar *f, *p, *ff;
+
+	if (!rfbEnableClientLogging)
+		return;
+
+	va_list args;
+	va_start(args, format);
+	/* eliminate the last \n */
+	f = g_strdup(format);
+	if (f[strlen(f) - 1] == '\n') f[strlen(f) - 1] = '\0';
+
+	if (g_strcmp0(f, "VNC connection failed: %s") == 0) {
+		p = va_arg(args, gchar *);
+		g_snprintf(vnc_error, MAX_ERROR_LENGTH, _(f), _(p));
+	} else if (g_strcmp0(f, "The VNC server requested an unknown authentication method. %s") == 0) {
+		p = va_arg(args, gchar *);
+		if (vnc_encryption_disable_requested) {
+			ff = g_strconcat(_("The VNC server requested an unknown authentication method. %s"),
+					 ". ",
+					 _("Please retry after turning on encryption for this profile."),
+					 NULL);
+			g_snprintf(vnc_error, MAX_ERROR_LENGTH, ff, p);
+			g_free(ff);
+		} else {
+			g_snprintf(vnc_error, MAX_ERROR_LENGTH, _(f), p);
+		}
+	} else {
+		g_vsnprintf(vnc_error, MAX_ERROR_LENGTH, _(f), args);
+	}
+	g_free(f);
+	va_end(args);
+
+	REMMINA_PLUGIN_DEBUG("VNC returned: %s", vnc_error);
+}
+
+static void remmina_plugin_vnc_chat_on_send(RemminaProtocolWidget *gp, const gchar *text)
+{
+	TRACE_CALL(__func__);
+	gchar *ptr;
+
+	/* Need to add a line-feed for UltraVNC */
+	ptr = g_strdup_printf("%s\n", text);
+	remmina_plugin_vnc_event_push(gp, REMMINA_PLUGIN_VNC_EVENT_CHAT_SEND, ptr, NULL, NULL);
+	g_free(ptr);
+}
+
+static void remmina_plugin_vnc_chat_on_destroy(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	remmina_plugin_vnc_event_push(gp, REMMINA_PLUGIN_VNC_EVENT_CHAT_CLOSE, NULL, NULL, NULL);
+}
+
+/* Send CTRL+ALT+DEL keys keystrokes to the plugin drawing_area widget */
+static void remmina_plugin_vnc_send_ctrlaltdel(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	guint keys[] = { GDK_KEY_Control_L, GDK_KEY_Alt_L, GDK_KEY_Delete };
+	RemminaPluginVncData *gpdata = GET_PLUGIN_DATA(gp);
+
+	remmina_plugin_service->protocol_plugin_send_keys_signals(gpdata->drawing_area,
+								  keys, G_N_ELEMENTS(keys), GDK_KEY_PRESS | GDK_KEY_RELEASE);
+}
+
+static gboolean remmina_plugin_vnc_close_chat(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	remmina_plugin_service->protocol_plugin_chat_close(gp);
+	return FALSE;
+}
+
+static gboolean remmina_plugin_vnc_open_chat(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginVncData *gpdata = GET_PLUGIN_DATA(gp);
+	rfbClient *cl;
+
+	cl = (rfbClient *)gpdata->client;
+
+	remmina_plugin_service->protocol_plugin_chat_open(gp, cl->desktopName, remmina_plugin_vnc_chat_on_send,
+							  remmina_plugin_vnc_chat_on_destroy);
+	remmina_plugin_vnc_event_push(gp, REMMINA_PLUGIN_VNC_EVENT_CHAT_OPEN, NULL, NULL, NULL);
+	return FALSE;
+}
+
+static void remmina_plugin_vnc_rfb_chat(rfbClient *cl, int value, char *text)
+{
+	TRACE_CALL(__func__);
+	RemminaProtocolWidget *gp;
+
+	gp = (RemminaProtocolWidget *)(rfbClientGetClientData(cl, NULL));
+	switch (value) {
+	case rfbTextChatOpen:
+		IDLE_ADD((GSourceFunc)remmina_plugin_vnc_open_chat, gp);
+		break;
+	case rfbTextChatClose:
+		/* Do nothing… but wait for the next rfbTextChatFinished signal */
+		break;
+	case rfbTextChatFinished:
+		IDLE_ADD((GSourceFunc)remmina_plugin_vnc_close_chat, gp);
+		break;
+	default:
+		/* value is the text length */
+		remmina_plugin_service->protocol_plugin_chat_receive(gp, text);
+		break;
+	}
+}
+
+static gboolean remmina_plugin_vnc_incoming_connection(RemminaProtocolWidget *gp, rfbClient *cl)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginVncData *gpdata = GET_PLUGIN_DATA(gp);
+	fd_set fds;
+
+	/**
+	 * @fixme This may fail or not working as expected with multiple network interfaces,
+	 * change with ListenAtTcpPortAndAddress
+	 */
+	gpdata->listen_sock = ListenAtTcpPort(cl->listenPort);
+	if (gpdata->listen_sock < 0)
+		return FALSE;
+
+	remmina_plugin_service->protocol_plugin_init_show_listen(gp, cl->listenPort);
+
+	remmina_plugin_service->protocol_plugin_start_reverse_tunnel(gp, cl->listenPort);
+
+	FD_ZERO(&fds);
+	if (gpdata->listen_sock >= 0)
+		FD_SET(gpdata->listen_sock, &fds);
+
+	select(gpdata->listen_sock + 1, &fds, NULL, NULL, NULL);
+
+	if (!FD_ISSET(gpdata->listen_sock, &fds)) {
+		close(gpdata->listen_sock);
+		gpdata->listen_sock = -1;
+		return FALSE;
+	}
+
+	if (FD_ISSET(gpdata->listen_sock, &fds))
+		cl->sock = AcceptTcpConnection(gpdata->listen_sock);
+	if (cl->sock >= 0) {
+		close(gpdata->listen_sock);
+		gpdata->listen_sock = -1;
+	}
+	if (cl->sock < 0 || !SetNonBlocking(cl->sock))
+		return FALSE;
+
+	return TRUE;
+}
+
+
+static gboolean remmina_plugin_vnc_main_loop(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginVncData *gpdata = GET_PLUGIN_DATA(gp);
+	gint ret;
+	gint i;
+	rfbClient *cl;
+	fd_set fds;
+	struct timeval timeout;
+
+	if (!gpdata->connected) {
+		gpdata->running = FALSE;
+		return FALSE;
+	}
+
+	cl = (rfbClient *)gpdata->client;
+
+	/*
+	 * Do not explicitly wait while data is on the buffer, see:
+	 * - https://jira.glyptodon.com/browse/GUAC-1056
+	 * - https://jira.glyptodon.com/browse/GUAC-1056?focusedCommentId=14348&page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#comment-14348
+	 * - https://github.com/apache/guacamole-server/blob/67680bd2d51e7949453f0f7ffc7f4234a1136715/src/protocols/vnc/vnc.c#L155
+	 */
+	if (cl->buffered)
+		goto handle_buffered;
+
+	timeout.tv_sec = 10;
+	timeout.tv_usec = 0;
+	FD_ZERO(&fds);
+	FD_SET(cl->sock, &fds);
+	FD_SET(gpdata->vnc_event_pipe[0], &fds);
+	ret = select(MAX(cl->sock, gpdata->vnc_event_pipe[0]) + 1, &fds, NULL, NULL, &timeout);
+
+	/* Sometimes it returns <0 when opening a modal dialog in other window. Absolutely weird */
+	/* So we continue looping anyway */
+	if (ret <= 0)
+		return TRUE;
+
+	if (FD_ISSET(gpdata->vnc_event_pipe[0], &fds))
+		remmina_plugin_vnc_process_vnc_event(gp);
+	if (FD_ISSET(cl->sock, &fds)) {
+		i = WaitForMessage(cl, 500);
+		if (i < 0)
+			return TRUE;
+handle_buffered:
+		if (!HandleRFBServerMessage(cl)) {
+			gpdata->running = FALSE;
+			if (gpdata->connected && !remmina_plugin_service->protocol_plugin_is_closed(gp))
+				remmina_plugin_service->protocol_plugin_signal_connection_closed(gp);
+			return FALSE;
+		}
+	}
+
+	return TRUE;
+}
+
+static gboolean remmina_plugin_vnc_main(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginVncData *gpdata = GET_PLUGIN_DATA(gp);
+	RemminaFile *remminafile;
+	rfbClient *cl = NULL;
+	gchar *host;
+	gchar *s = NULL;
+	
+	remminafile = remmina_plugin_service->protocol_plugin_get_file(gp);
+	gpdata->running = TRUE;
+
+	rfbClientLog = rfbClientErr = remmina_plugin_vnc_rfb_output;
+
+	gint colordepth = remmina_plugin_service->file_get_int(remminafile, "colordepth", 32);
+	gint quality = remmina_plugin_service->file_get_int(remminafile, "quality", 9);
+
+	while (gpdata->connected) {
+		gpdata->auth_called = FALSE;
+
+		host = remmina_plugin_service->protocol_plugin_start_direct_tunnel(gp, VNC_DEFAULT_PORT, TRUE);
+
+		if (host == NULL) {
+			REMMINA_PLUGIN_DEBUG("host is null");
+			gpdata->connected = FALSE;
+			break;
+		}
+
+		/* int bitsPerSample,int samplesPerPixel, int bytesPerPixel */
+		switch (colordepth) {
+		case 8:
+			cl = rfbGetClient(2, 3, 1);
+			break;
+		case 15:
+		case 16:
+			cl = rfbGetClient(5, 3, 2);
+			break;
+		case 24:
+			cl = rfbGetClient(6, 3, 3);
+			break;
+		case 32:
+		default:
+			cl = rfbGetClient(8, 3, 4);
+			break;
+		}
+		REMMINA_PLUGIN_DEBUG("Color depth: %d", colordepth);
+		cl->MallocFrameBuffer = remmina_plugin_vnc_rfb_allocfb;
+		cl->canHandleNewFBSize = TRUE;
+		cl->GetPassword = remmina_plugin_vnc_rfb_password;
+		cl->GetCredential = remmina_plugin_vnc_rfb_credential;
+		cl->GotFrameBufferUpdate = remmina_plugin_vnc_rfb_updatefb;
+		/**
+		 * @fixme we have to implement FinishedFrameBufferUpdate
+		 * This is to know when the server has finished to send a batch of frame buffer
+		 * updates.
+		 * cl->FinishedFrameBufferUpdate = remmina_plugin_vnc_rfb_finished;
+		 */
+		/**
+		 * @fixme we have to implement HandleKeyboardLedState
+		 * cl->HandleKeyboardLedState = remmina_plugin_vnc_rfb_led_state
+		 */
+		cl->HandleKeyboardLedState = remmina_plugin_vnc_rfb_led_state;
+		cl->GotXCutText = (
+			remmina_plugin_service->file_get_int(remminafile, "disableclipboard", FALSE) ?
+			NULL : remmina_plugin_vnc_rfb_cuttext);
+		cl->GotCursorShape = remmina_plugin_vnc_rfb_cursor_shape;
+		cl->Bell = remmina_plugin_vnc_rfb_bell;
+		cl->HandleTextChat = remmina_plugin_vnc_rfb_chat;
+		/**
+		 * @fixme we have to implement HandleXvpMsg
+		 * cl->HandleXvpMsg = remmina_plugin_vnc_rfb_handle_xvp;
+		 */
+
+		rfbClientSetClientData(cl, NULL, gp);
+
+		if (host[0] == '\0') {
+			cl->serverHost = g_strdup(host);
+			cl->listenSpecified = TRUE;
+			if (remmina_plugin_service->file_get_int(remminafile, "ssh_tunnel_enabled", FALSE))
+				/* When we use reverse tunnel, the local port does not really matter.
+				 * Hardcode a default port just in case the remote port is customized
+				 * to a privilege port then we will have problem listening. */
+				cl->listenPort = 5500;
+			else
+				cl->listenPort = remmina_plugin_service->file_get_int(remminafile, "listenport", 5500);
+
+			remmina_plugin_vnc_incoming_connection(gp, cl);
+		} else {
+			if (strstr(host, "unix://") == host) {
+				cl->serverHost = g_strdup(host + strlen("unix://"));
+				cl->serverPort  = 0;
+			} else {
+				remmina_plugin_service->get_server_port(host, VNC_DEFAULT_PORT, &s, &cl->serverPort);
+				cl->serverHost = g_strdup(s);
+				g_free(s);
+				/* Support short-form (:0, :1) */
+				if (cl->serverPort < 100)
+					cl->serverPort += VNC_DEFAULT_PORT;
+			}
+		}
+		g_free(host);
+		host = NULL;
+
+		if (cl->serverHost && strstr(cl->serverHost, "unix://") != cl->serverHost && remmina_plugin_service->file_get_string(remminafile, "proxy")) {
+			remmina_plugin_service->get_server_port(
+				remmina_plugin_service->file_get_string(remminafile, "server"),
+				VNC_DEFAULT_PORT,
+				&cl->destHost,
+				&cl->destPort);
+			remmina_plugin_service->get_server_port(
+				remmina_plugin_service->file_get_string(remminafile, "proxy"),
+				VNC_DEFAULT_PORT,
+				&cl->serverHost,
+				&cl->serverPort);
+			REMMINA_PLUGIN_DEBUG("cl->serverHost: %s", cl->serverHost);
+			REMMINA_PLUGIN_DEBUG("cl->serverPort: %d", cl->serverPort);
+			REMMINA_PLUGIN_DEBUG("cl->destHost: %s", cl->destHost);
+			REMMINA_PLUGIN_DEBUG("cl->destPort: %d", cl->destPort);
+		}
+
+		cl->appData.useRemoteCursor = (
+			remmina_plugin_service->file_get_int(remminafile, "showcursor", FALSE) ? FALSE : TRUE);
+
+		remmina_plugin_vnc_update_quality(cl, quality);
+		remmina_plugin_vnc_update_colordepth(cl, colordepth);
+		if ((cl->format.depth == 8) && (quality == 9))
+			cl->appData.encodingsString = "copyrect zlib hextile raw";
+		else if ((cl->format.depth == 8) && (quality == 2))
+			cl->appData.encodingsString = "zrle ultra copyrect hextile zlib corre rre raw";
+		else if ((cl->format.depth == 8) && (quality == 1))
+			cl->appData.encodingsString = "zrle ultra copyrect hextile zlib corre rre raw";
+		else if ((cl->format.depth == 8) && (quality == 0))
+			cl->appData.encodingsString = "zrle ultra copyrect hextile zlib corre rre raw";
+		SetFormatAndEncodings(cl);
+
+		if (remmina_plugin_service->file_get_int(remminafile, "disableencryption", FALSE)) {
+			vnc_encryption_disable_requested = TRUE;
+			SetClientAuthSchemes(cl, remmina_plugin_vnc_no_encrypt_auth_types, -1);
+		} else {
+			vnc_encryption_disable_requested = FALSE;
+		}
+
+		if (rfbInitClient(cl, NULL, NULL)) {
+			REMMINA_PLUGIN_DEBUG("Client initialization successfull");
+			break;
+		} else {
+			REMMINA_PLUGIN_DEBUG("Client initialization failed");
+		}
+
+		/* If the authentication is not called, it has to be a fatal error and must quit */
+		if (!gpdata->auth_called) {
+			REMMINA_PLUGIN_DEBUG("Client not authenticated");
+			gpdata->connected = FALSE;
+			break;
+		}
+
+		/* vnc4server reports "already in use" after authentication. Workaround here */
+		if (strstr(vnc_error, "The server is already in use")) {
+			gpdata->connected = FALSE;
+			gpdata->auth_called = FALSE;
+			break;
+		}
+		/* Don't assume authentication failed for known network-related errors in
+		   libvncclient/sockets.c. */
+		if (strstr(vnc_error, "read (") || strstr(vnc_error, "select\n") ||
+			strstr(vnc_error, "write\n") || strstr(vnc_error, "Connection timed out")) {
+			gpdata->connected = FALSE;
+			gpdata->auth_called = FALSE;
+			break;
+		}
+
+		/* Otherwise, it’s a password error. Try to clear saved password if any */
+		remmina_plugin_service->file_set_string(remminafile, "password", NULL);
+
+		if (!gpdata->connected)
+			break;
+
+		remmina_plugin_service->protocol_plugin_init_show_retry(gp);
+
+		/* It’s safer to sleep a while before reconnect */
+		sleep(2);
+
+		gpdata->auth_first = FALSE;
+	}
+
+	if (!gpdata->connected) {
+		REMMINA_PLUGIN_DEBUG("Client not connected with error: %s", vnc_error);
+		if (cl && !gpdata->auth_called && !(remmina_plugin_service->protocol_plugin_has_error(gp)))
+			remmina_plugin_service->protocol_plugin_set_error(gp, "%s", vnc_error);
+		gpdata->running = FALSE;
+
+		remmina_plugin_service->protocol_plugin_signal_connection_closed(gp);
+
+		return FALSE;
+	}
+
+	REMMINA_PLUGIN_DEBUG("Client connected");
+	remmina_plugin_service->protocol_plugin_init_save_cred(gp);
+
+	gpdata->client = cl;
+
+	remmina_plugin_service->protocol_plugin_signal_connection_opened(gp);
+
+	if (remmina_plugin_service->file_get_int(remminafile, "disableserverinput", FALSE))
+		PermitServerInput(cl, 1);
+
+	if (gpdata->thread) {
+		while (remmina_plugin_vnc_main_loop(gp)) {
+		}
+		gpdata->running = FALSE;
+	} else {
+		IDLE_ADD((GSourceFunc)remmina_plugin_vnc_main_loop, gp);
+	}
+
+	return FALSE;
+}
+
+
+static gpointer
+remmina_plugin_vnc_main_thread(gpointer data)
+{
+	TRACE_CALL(__func__);
+	pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
+
+	CANCEL_ASYNC
+	remmina_plugin_vnc_main((RemminaProtocolWidget *)data);
+	return NULL;
+}
+
+
+static RemminaPluginVncCoordinates remmina_plugin_vnc_scale_coordinates(GtkWidget *widget, RemminaProtocolWidget *gp, gint x, gint y)
+{
+	GtkAllocation widget_allocation;
+	RemminaPluginVncCoordinates result;
+
+	if ((remmina_plugin_service->remmina_protocol_widget_get_current_scale_mode(gp) != REMMINA_PROTOCOL_WIDGET_SCALE_MODE_NONE)) {
+		gtk_widget_get_allocation(widget, &widget_allocation);
+		result.x = x * remmina_plugin_service->protocol_plugin_get_width(gp) / widget_allocation.width;
+		result.y = y * remmina_plugin_service->protocol_plugin_get_height(gp) / widget_allocation.height;
+	} else {
+		result.x = x;
+		result.y = y;
+	}
+
+	return result;
+}
+
+static gboolean remmina_plugin_vnc_on_motion(GtkWidget *widget, GdkEventMotion *event, RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginVncData *gpdata = GET_PLUGIN_DATA(gp);
+	RemminaFile *remminafile;
+	RemminaPluginVncCoordinates coordinates;
+
+	if (!gpdata->connected || !gpdata->client)
+		return FALSE;
+	remminafile = remmina_plugin_service->protocol_plugin_get_file(gp);
+	if (remmina_plugin_service->file_get_int(remminafile, "viewonly", FALSE))
+		return FALSE;
+
+	coordinates = remmina_plugin_vnc_scale_coordinates(widget, gp, event->x, event->y);
+	remmina_plugin_vnc_event_push(gp, REMMINA_PLUGIN_VNC_EVENT_POINTER, GINT_TO_POINTER(coordinates.x), GINT_TO_POINTER(coordinates.y),
+				      GINT_TO_POINTER(gpdata->button_mask));
+	return TRUE;
+}
+
+static gboolean remmina_plugin_vnc_on_button(GtkWidget *widget, GdkEventButton *event, RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginVncData *gpdata = GET_PLUGIN_DATA(gp);
+	RemminaFile *remminafile;
+	RemminaPluginVncCoordinates coordinates;
+	gint mask;
+
+	if (!gpdata->connected || !gpdata->client)
+		return FALSE;
+	remminafile = remmina_plugin_service->protocol_plugin_get_file(gp);
+	if (remmina_plugin_service->file_get_int(remminafile, "viewonly", FALSE))
+		return FALSE;
+
+	/* We only accept 3 buttons */
+	if (event->button < 1 || event->button > 3)
+		return FALSE;
+	/* We bypass 2button-press and 3button-press events */
+	if (event->type != GDK_BUTTON_PRESS && event->type != GDK_BUTTON_RELEASE)
+		return TRUE;
+
+	mask = (1 << (event->button - 1));
+	gpdata->button_mask = (event->type == GDK_BUTTON_PRESS ? (gpdata->button_mask | mask) :
+			       (gpdata->button_mask & (0xff - mask)));
+
+	coordinates = remmina_plugin_vnc_scale_coordinates(widget, gp, event->x, event->y);
+	remmina_plugin_vnc_event_push(gp, REMMINA_PLUGIN_VNC_EVENT_POINTER, GINT_TO_POINTER(coordinates.x), GINT_TO_POINTER(coordinates.y),
+				      GINT_TO_POINTER(gpdata->button_mask));
+	return TRUE;
+}
+
+static gint delta_to_mask(float delta, float *accum, gint mask_plus, gint mask_minus)
+{
+	*accum += delta;
+	if (*accum >= 1.0) {
+		*accum = 0.0;
+		return mask_plus;
+	} else if (*accum <= -1.0) {
+		*accum = 0.0;
+		return mask_minus;
+	}
+	return 0;
+}
+
+static gboolean remmina_plugin_vnc_on_scroll(GtkWidget *widget, GdkEventScroll *event, RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginVncData *gpdata = GET_PLUGIN_DATA(gp);
+	RemminaFile *remminafile;
+	RemminaPluginVncCoordinates coordinates;
+	gint mask;
+
+	if (!gpdata->connected || !gpdata->client)
+		return FALSE;
+	remminafile = remmina_plugin_service->protocol_plugin_get_file(gp);
+	if (remmina_plugin_service->file_get_int(remminafile, "viewonly", FALSE))
+		return FALSE;
+
+	switch (event->direction) {
+	case GDK_SCROLL_UP:
+		mask = (1 << 3);
+		gpdata->scroll_y_accumulator = 0;
+		break;
+	case GDK_SCROLL_DOWN:
+		mask = (1 << 4);
+		gpdata->scroll_y_accumulator = 0;
+		break;
+	case GDK_SCROLL_LEFT:
+		mask = (1 << 5);
+		gpdata->scroll_x_accumulator = 0;
+		break;
+	case GDK_SCROLL_RIGHT:
+		mask = (1 << 6);
+		gpdata->scroll_x_accumulator = 0;
+		break;
+#if GTK_CHECK_VERSION(3, 4, 0)
+	case GDK_SCROLL_SMOOTH:
+		/* RFB does not seems to support SMOOTH scroll, so we accumulate GTK delta requested
+		 * up to 1.0 and then send a normal RFB wheel scroll when the accumulator reaches 1.0 */
+		mask = delta_to_mask(event->delta_y, &(gpdata->scroll_y_accumulator), (1 << 4), (1 << 3));
+		mask |= delta_to_mask(event->delta_x, &(gpdata->scroll_x_accumulator), (1 << 6), (1 << 5));
+		if (!mask)
+			return FALSE;
+		break;
+#endif
+	default:
+		return FALSE;
+	}
+
+	coordinates = remmina_plugin_vnc_scale_coordinates(widget, gp, event->x, event->y);
+	remmina_plugin_vnc_event_push(gp, REMMINA_PLUGIN_VNC_EVENT_POINTER, GINT_TO_POINTER(coordinates.x), GINT_TO_POINTER(coordinates.y),
+				      GINT_TO_POINTER(mask | gpdata->button_mask));
+	remmina_plugin_vnc_event_push(gp, REMMINA_PLUGIN_VNC_EVENT_POINTER, GINT_TO_POINTER(coordinates.x), GINT_TO_POINTER(coordinates.y),
+				      GINT_TO_POINTER(gpdata->button_mask));
+
+	return TRUE;
+}
+
+static void remmina_plugin_vnc_release_key(RemminaProtocolWidget *gp, guint16 keycode)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginVncData *gpdata = GET_PLUGIN_DATA(gp);
+	RemminaKeyVal *k;
+	gint i;
+
+	if (!gpdata)
+		return;
+
+	if (keycode == 0) {
+		/* Send all release key events for previously pressed keys */
+		for (i = 0; i < gpdata->pressed_keys->len; i++) {
+			k = g_ptr_array_index(gpdata->pressed_keys, i);
+			remmina_plugin_vnc_event_push(gp, REMMINA_PLUGIN_VNC_EVENT_KEY, GUINT_TO_POINTER(k->keyval),
+						      GINT_TO_POINTER(FALSE), NULL);
+			g_free(k);
+		}
+		g_ptr_array_set_size(gpdata->pressed_keys, 0);
+	} else {
+		/* Unregister the keycode only */
+		for (i = 0; i < gpdata->pressed_keys->len; i++) {
+			k = g_ptr_array_index(gpdata->pressed_keys, i);
+			if (k->keycode == keycode) {
+				g_free(k);
+				g_ptr_array_remove_index_fast(gpdata->pressed_keys, i);
+				break;
+			}
+		}
+	}
+}
+
+static gboolean remmina_plugin_vnc_on_key(GtkWidget *widget, GdkEventKey *event, RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginVncData *gpdata = GET_PLUGIN_DATA(gp);
+	RemminaFile *remminafile;
+	RemminaKeyVal *k;
+	guint event_keyval;
+	guint keyval;
+
+	if (!gpdata->connected || !gpdata->client)
+		return FALSE;
+	remminafile = remmina_plugin_service->protocol_plugin_get_file(gp);
+	if (remmina_plugin_service->file_get_int(remminafile, "viewonly", FALSE))
+		return FALSE;
+
+	gpdata->scroll_x_accumulator = 0;
+	gpdata->scroll_y_accumulator = 0;
+
+	/* When sending key release, try first to find out a previously sent keyval
+	 * to workaround bugs like https://bugs.freedesktop.org/show_bug.cgi?id=7430 */
+
+	event_keyval = event->keyval;
+	if (event->type == GDK_KEY_RELEASE) {
+		for (int i = 0; i < gpdata->pressed_keys->len; i++) {
+			k = g_ptr_array_index(gpdata->pressed_keys, i);
+			if (k->keycode == event->hardware_keycode) {
+				event_keyval = k->keyval;
+				break;
+			}
+		}
+	}
+
+	keyval = remmina_plugin_service->pref_keymap_get_keyval(remmina_plugin_service->file_get_string(remminafile, "keymap"),
+								event_keyval);
+
+	remmina_plugin_vnc_event_push(gp, REMMINA_PLUGIN_VNC_EVENT_KEY, GUINT_TO_POINTER(keyval),
+				      GINT_TO_POINTER(event->type == GDK_KEY_PRESS ? TRUE : FALSE), NULL);
+
+	/* Register/unregister the pressed key */
+	if (event->type == GDK_KEY_PRESS) {
+		k = g_new(RemminaKeyVal, 1);
+		k->keyval = keyval;
+		k->keycode = event->hardware_keycode;
+		g_ptr_array_add(gpdata->pressed_keys, k);
+	} else {
+		remmina_plugin_vnc_release_key(gp, event->hardware_keycode);
+	}
+	return TRUE;
+}
+
+static void remmina_plugin_vnc_on_cuttext_request(GtkClipboard *clipboard, const gchar *text, RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginVncData *gpdata = GET_PLUGIN_DATA(gp);
+	GDateTime *t;
+	glong diff;
+	gsize br, bw;
+	gchar *latin1_text;
+	const char *cur_charset;
+
+	if (text) {
+		/* A timer (1 second) to avoid clipboard "loopback": text cut out from VNC won’t paste back into VNC */
+		t = g_date_time_new_now_utc();
+		diff = g_date_time_difference(t, gpdata->clipboard_timer) / 100000; // tenth of second
+		if (diff < 10)
+			return;
+		g_date_time_unref(gpdata->clipboard_timer);
+		gpdata->clipboard_timer = t;
+		/* Convert text from current charset to latin-1 before sending to remote server.
+		 * See RFC6143 7.5.6 */
+		g_get_charset(&cur_charset);
+		latin1_text = g_convert_with_fallback(text, -1, "ISO-8859-1", cur_charset, "?", &br, &bw, NULL);
+		remmina_plugin_vnc_event_push(gp, REMMINA_PLUGIN_VNC_EVENT_CUTTEXT, (gpointer)latin1_text, NULL, NULL);
+		g_free(latin1_text);
+	}
+}
+
+static void remmina_plugin_vnc_on_cuttext(GtkClipboard *clipboard, GdkEvent *event, RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginVncData *gpdata = GET_PLUGIN_DATA(gp);
+	RemminaFile *remminafile;
+
+	if (!gpdata->connected || !gpdata->client)
+		return;
+	remminafile = remmina_plugin_service->protocol_plugin_get_file(gp);
+	if (remmina_plugin_service->file_get_int(remminafile, "viewonly", FALSE))
+		return;
+
+	gtk_clipboard_request_text(clipboard, (GtkClipboardTextReceivedFunc)remmina_plugin_vnc_on_cuttext_request, gp);
+}
+
+static void remmina_plugin_vnc_on_realize(RemminaProtocolWidget *gp, gpointer data)
+{
+	TRACE_CALL(__func__);
+	RemminaFile *remminafile;
+	GdkCursor *cursor;
+	GdkPixbuf *pixbuf;
+
+	remminafile = remmina_plugin_service->protocol_plugin_get_file(gp);
+
+	if (remmina_plugin_service->file_get_int(remminafile, "showcursor", FALSE)) {
+		/* Hide local cursor (show a small dot instead) */
+		pixbuf = gdk_pixbuf_new_from_xpm_data(dot_cursor_xpm);
+		cursor = gdk_cursor_new_from_pixbuf(gdk_display_get_default(), pixbuf, dot_cursor_x_hot, dot_cursor_y_hot);
+		g_object_unref(pixbuf);
+		gdk_window_set_cursor(gtk_widget_get_window(GTK_WIDGET(gp)), cursor);
+		g_object_unref(cursor);
+	}
+}
+
+/******************************************************************************************/
+
+static gboolean remmina_plugin_vnc_open_connection(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginVncData *gpdata = GET_PLUGIN_DATA(gp);
+	RemminaFile *remminafile;
+
+	remminafile = remmina_plugin_service->protocol_plugin_get_file(gp);
+
+	gpdata->connected = TRUE;
+	gchar *server;
+	gint port;
+	const gchar* raw_server;
+
+	remmina_plugin_service->protocol_plugin_register_hostkey(gp, gpdata->drawing_area);
+
+	g_signal_connect(G_OBJECT(gp), "realize", G_CALLBACK(remmina_plugin_vnc_on_realize), NULL);
+	g_signal_connect(G_OBJECT(gpdata->drawing_area), "motion-notify-event", G_CALLBACK(remmina_plugin_vnc_on_motion), gp);
+	g_signal_connect(G_OBJECT(gpdata->drawing_area), "button-press-event", G_CALLBACK(remmina_plugin_vnc_on_button), gp);
+	g_signal_connect(G_OBJECT(gpdata->drawing_area), "button-release-event", G_CALLBACK(remmina_plugin_vnc_on_button), gp);
+	g_signal_connect(G_OBJECT(gpdata->drawing_area), "scroll-event", G_CALLBACK(remmina_plugin_vnc_on_scroll), gp);
+	g_signal_connect(G_OBJECT(gpdata->drawing_area), "key-press-event", G_CALLBACK(remmina_plugin_vnc_on_key), gp);
+	g_signal_connect(G_OBJECT(gpdata->drawing_area), "key-release-event", G_CALLBACK(remmina_plugin_vnc_on_key), gp);
+
+	if (!remmina_plugin_service->file_get_int(remminafile, "disableclipboard", FALSE))
+		gpdata->clipboard_handler = g_signal_connect(G_OBJECT(gtk_clipboard_get(GDK_SELECTION_CLIPBOARD)),
+							     "owner-change", G_CALLBACK(remmina_plugin_vnc_on_cuttext), gp);
+
+
+	if (pthread_create(&gpdata->thread, NULL, remmina_plugin_vnc_main_thread, gp)) {
+		/* I don’t think this will ever happen… */
+		g_print("Could not initialize pthread. Falling back to non-thread mode…\n");
+		g_timeout_add(0, (GSourceFunc)remmina_plugin_vnc_main, gp);
+		gpdata->thread = 0;
+	}
+
+	raw_server = remmina_plugin_service->file_get_string(remminafile, "server");
+
+	if (raw_server && strstr(raw_server, "unix://") == raw_server) {
+		REMMINA_PLUGIN_AUDIT(_("Connected to %s via VNC"), raw_server);
+	} else {
+		remmina_plugin_service->get_server_port(raw_server,
+				VNC_DEFAULT_PORT,
+				&server,
+				&port);
+
+		REMMINA_PLUGIN_AUDIT(_("Connected to %s:%d via VNC"), server, port);
+		g_free(server), server = NULL;
+	}
+#if LIBVNCSERVER_CHECK_VERSION_VERSION(0, 9, 14)
+	remmina_plugin_service->protocol_plugin_unlock_dynres(gp);
+#endif
+	return TRUE;
+}
+
+static gboolean remmina_plugin_vnc_close_connection_timeout(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginVncData *gpdata = GET_PLUGIN_DATA(gp);
+
+	gchar *server;
+	gint port;
+
+	RemminaFile *remminafile = remmina_plugin_service->protocol_plugin_get_file(gp);
+	remmina_plugin_service->get_server_port(remmina_plugin_service->file_get_string(remminafile, "server"),
+			VNC_DEFAULT_PORT,
+			&server,
+			&port);
+
+	REMMINA_PLUGIN_AUDIT(_("Disconnected from %s:%d via VNC"), server, port);
+	g_free(server), server = NULL;
+
+	/* wait until the running attribute is set to false by the VNC thread */
+	if (gpdata->running)
+		return TRUE;
+
+	/* unregister the clipboard monitor */
+	if (gpdata->clipboard_handler) {
+		g_signal_handler_disconnect(G_OBJECT(gtk_clipboard_get(GDK_SELECTION_CLIPBOARD)), gpdata->clipboard_handler);
+		gpdata->clipboard_handler = 0;
+	}
+
+	if (gpdata->queuecursor_handler) {
+		g_source_remove(gpdata->queuecursor_handler);
+		gpdata->queuecursor_handler = 0;
+	}
+	if (gpdata->queuecursor_surface) {
+		cairo_surface_destroy(gpdata->queuecursor_surface);
+		gpdata->queuecursor_surface = NULL;
+	}
+
+	if (gpdata->queuedraw_handler) {
+		g_source_remove(gpdata->queuedraw_handler);
+		gpdata->queuedraw_handler = 0;
+	}
+	if (gpdata->listen_sock >= 0)
+		close(gpdata->listen_sock);
+	if (gpdata->client) {
+		rfbClientCleanup((rfbClient *)gpdata->client);
+		gpdata->client = NULL;
+	}
+	if (gpdata->rgb_buffer) {
+		cairo_surface_destroy(gpdata->rgb_buffer);
+		gpdata->rgb_buffer = NULL;
+	}
+	if (gpdata->vnc_buffer) {
+		g_free(gpdata->vnc_buffer);
+		gpdata->vnc_buffer = NULL;
+	}
+	g_ptr_array_free(gpdata->pressed_keys, TRUE);
+	g_date_time_unref(gpdata->clipboard_timer);
+	remmina_plugin_vnc_event_free_all(gp);
+	g_queue_free(gpdata->vnc_event_queue);
+	pthread_mutex_destroy(&gpdata->vnc_event_queue_mutex);
+	close(gpdata->vnc_event_pipe[0]);
+	close(gpdata->vnc_event_pipe[1]);
+
+
+	pthread_mutex_destroy(&gpdata->buffer_mutex);
+	remmina_plugin_service->protocol_plugin_signal_connection_closed(gp);
+
+	return FALSE;
+}
+
+static gboolean remmina_plugin_vnc_close_connection(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginVncData *gpdata = GET_PLUGIN_DATA(gp);
+
+	gpdata->connected = FALSE;
+
+	if (gpdata->thread) {
+		pthread_cancel(gpdata->thread);
+		if (gpdata->thread) pthread_join(gpdata->thread, NULL);
+		gpdata->running = FALSE;
+		remmina_plugin_vnc_close_connection_timeout(gp);
+	} else {
+		g_timeout_add(200, (GSourceFunc)remmina_plugin_vnc_close_connection_timeout, gp);
+	}
+
+	return FALSE;
+}
+
+static gboolean remmina_plugin_vnc_query_feature(RemminaProtocolWidget *gp, const RemminaProtocolFeature *feature)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginVncData *gpdata = GET_PLUGIN_DATA(gp);
+	switch (feature->id) {
+	case REMMINA_PLUGIN_VNC_FEATURE_PREF_DISABLESERVERINPUT:
+		return SupportsClient2Server((rfbClient *)(gpdata->client), rfbSetServerInput) ? TRUE : FALSE;
+	case REMMINA_PLUGIN_VNC_FEATURE_TOOL_CHAT:
+		return SupportsClient2Server((rfbClient *)(gpdata->client), rfbTextChat) ? TRUE : FALSE;
+	default:
+		return TRUE;
+	}
+}
+
+static void remmina_plugin_vnc_call_feature(RemminaProtocolWidget *gp, const RemminaProtocolFeature *feature)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginVncData *gpdata = GET_PLUGIN_DATA(gp);
+	RemminaFile *remminafile;
+	rfbClient*  client;
+	uint8_t previous_bpp;
+	remminafile = remmina_plugin_service->protocol_plugin_get_file(gp);
+	switch (feature->id) {
+	case REMMINA_PLUGIN_VNC_FEATURE_PREF_QUALITY:
+		remmina_plugin_vnc_update_quality((rfbClient *)(gpdata->client),
+						  remmina_plugin_service->file_get_int(remminafile, "quality", 9));
+		remmina_plugin_vnc_update_colordepth((rfbClient *)(gpdata->client),
+						     remmina_plugin_service->file_get_int(remminafile, "colordepth", 32));
+		SetFormatAndEncodings((rfbClient *)(gpdata->client));
+		break;
+	case REMMINA_PLUGIN_VNC_FEATURE_PREF_COLOR:
+		client = (rfbClient *)(gpdata->client);
+		previous_bpp = client->format.bitsPerPixel;
+		remmina_plugin_vnc_update_colordepth(client,
+						     remmina_plugin_service->file_get_int(remminafile, "colordepth", 32));
+		SetFormatAndEncodings(client);
+		//Need to clear away old and reallocate if we're increasing bpp 
+		if (client->format.bitsPerPixel > previous_bpp){
+			remmina_plugin_vnc_rfb_allocfb((rfbClient *)(gpdata->client));
+			SendFramebufferUpdateRequest((rfbClient *)(gpdata->client), 0, 0,
+					     remmina_plugin_service->protocol_plugin_get_width(gp),
+					     remmina_plugin_service->protocol_plugin_get_height(gp), FALSE);
+		}
+		break;
+	case REMMINA_PLUGIN_VNC_FEATURE_PREF_VIEWONLY:
+		break;
+	case REMMINA_PLUGIN_VNC_FEATURE_PREF_DISABLESERVERINPUT:
+		PermitServerInput((rfbClient *)(gpdata->client),
+				  remmina_plugin_service->file_get_int(remminafile, "disableserverinput", FALSE) ? 1 : 0);
+		break;
+	case REMMINA_PLUGIN_VNC_FEATURE_UNFOCUS:
+		remmina_plugin_vnc_release_key(gp, 0);
+		break;
+	case REMMINA_PLUGIN_VNC_FEATURE_SCALE:
+		remmina_plugin_vnc_update_scale(gp, remmina_plugin_service->file_get_int(remminafile, "scale", FALSE));
+		break;
+	case REMMINA_PLUGIN_VNC_FEATURE_TOOL_REFRESH:
+		SendFramebufferUpdateRequest((rfbClient *)(gpdata->client), 0, 0,
+					     remmina_plugin_service->protocol_plugin_get_width(gp),
+					     remmina_plugin_service->protocol_plugin_get_height(gp), FALSE);
+		break;
+	case REMMINA_PLUGIN_VNC_FEATURE_TOOL_CHAT:
+		remmina_plugin_vnc_open_chat(gp);
+		break;
+	case REMMINA_PLUGIN_VNC_FEATURE_TOOL_SENDCTRLALTDEL:
+		remmina_plugin_vnc_send_ctrlaltdel(gp);
+		break;
+	default:
+		break;
+	}
+}
+
+/* Send a keystroke to the plugin window */
+static void remmina_plugin_vnc_keystroke(RemminaProtocolWidget *gp, const guint keystrokes[], const gint keylen)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginVncData *gpdata = GET_PLUGIN_DATA(gp);
+
+	remmina_plugin_service->protocol_plugin_send_keys_signals(gpdata->drawing_area,
+								  keystrokes, keylen, GDK_KEY_PRESS | GDK_KEY_RELEASE);
+	return;
+}
+
+#if LIBVNCSERVER_CHECK_VERSION_VERSION(0, 9, 14)
+static gboolean remmina_plugin_vnc_on_size_allocate(GtkWidget *widget, GtkAllocation *alloc, RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaScaleMode scale_mode = remmina_plugin_service->remmina_protocol_widget_get_current_scale_mode(gp);
+	RemminaPluginVncData *gpdata = GET_PLUGIN_DATA(gp);
+
+	if (scale_mode == REMMINA_PROTOCOL_WIDGET_SCALE_MODE_DYNRES){
+		char str[1024];
+		sprintf(str, "DEBUG: %d x %d", alloc->width, alloc->height);
+		TRACE_CALL(str);
+		if (gpdata->client){
+			SendExtDesktopSize(gpdata->client, alloc->width, alloc->height);
+		}
+	}
+	return TRUE;
+}
+#endif
+
+static gboolean remmina_plugin_vnc_on_draw(GtkWidget *widget, cairo_t *context, RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginVncData *gpdata = GET_PLUGIN_DATA(gp);
+	cairo_surface_t *surface;
+	gint width, height;
+	GtkAllocation widget_allocation;
+
+	LOCK_BUFFER(FALSE);
+
+	surface = gpdata->rgb_buffer;
+	if (!surface) {
+		UNLOCK_BUFFER(FALSE);
+		return FALSE;
+	}
+
+	width = remmina_plugin_service->protocol_plugin_get_width(gp);
+	height = remmina_plugin_service->protocol_plugin_get_height(gp);
+
+	if ((remmina_plugin_service->remmina_protocol_widget_get_current_scale_mode(gp) != REMMINA_PROTOCOL_WIDGET_SCALE_MODE_NONE)) {
+		gtk_widget_get_allocation(widget, &widget_allocation);
+		cairo_scale(context,
+			    (double)widget_allocation.width / width,
+			    (double)widget_allocation.height / height);
+	}
+
+	cairo_rectangle(context, 0, 0, width, height);
+	cairo_set_source_surface(context, surface, 0, 0);
+	cairo_fill(context);
+
+	UNLOCK_BUFFER(FALSE);
+	return TRUE;
+}
+
+static void remmina_plugin_vnc_init(RemminaProtocolWidget *gp)
+{
+	TRACE_CALL(__func__);
+	RemminaPluginVncData *gpdata;
+	gint flags;
+	gdouble aspect_ratio;
+
+	gpdata = g_new0(RemminaPluginVncData, 1);
+	g_object_set_data_full(G_OBJECT(gp), "plugin-data", gpdata, g_free);
+
+	gboolean disable_smooth_scrolling = FALSE;
+	RemminaFile *remminafile = remmina_plugin_service->protocol_plugin_get_file(gp);
+
+	disable_smooth_scrolling = remmina_plugin_service->file_get_int(remminafile, "disablesmoothscrolling", FALSE);
+	REMMINA_PLUGIN_DEBUG("Disable smooth scrolling is set to %d", disable_smooth_scrolling);
+
+	gpdata->drawing_area = gtk_drawing_area_new();
+	gtk_widget_show(gpdata->drawing_area);
+
+	aspect_ratio = remmina_plugin_service->file_get_double(remminafile, "aspect_ratio", 0);
+	if (aspect_ratio > 0){
+		GtkWidget* aspectframe = gtk_aspect_frame_new(NULL, 0, 0, aspect_ratio, FALSE);
+
+		gtk_frame_set_shadow_type(GTK_FRAME(aspectframe), GTK_SHADOW_NONE);
+		gtk_widget_show(aspectframe);
+		gtk_container_add(GTK_CONTAINER(aspectframe), gpdata->drawing_area);
+		gtk_container_add(GTK_CONTAINER(gp), aspectframe);
+	}
+	else{
+		gtk_container_add(GTK_CONTAINER(gp), gpdata->drawing_area);
+	}
+
+	gtk_widget_add_events(
+		gpdata->drawing_area,
+		GDK_POINTER_MOTION_MASK | GDK_BUTTON_PRESS_MASK
+		| GDK_BUTTON_RELEASE_MASK | GDK_KEY_PRESS_MASK
+		| GDK_KEY_RELEASE_MASK
+		| GDK_SCROLL_MASK);
+	gtk_widget_set_can_focus(gpdata->drawing_area, TRUE);
+
+	if (!disable_smooth_scrolling) {
+		REMMINA_PLUGIN_DEBUG("Adding GDK_SMOOTH_SCROLL_MASK");
+		gtk_widget_add_events(gpdata->drawing_area, GDK_SMOOTH_SCROLL_MASK);
+	}
+
+
+	g_signal_connect(G_OBJECT(gpdata->drawing_area), "draw", G_CALLBACK(remmina_plugin_vnc_on_draw), gp);
+#if LIBVNCSERVER_CHECK_VERSION_VERSION(0, 9, 14)
+	g_signal_connect(G_OBJECT(gpdata->drawing_area), "size-allocate", G_CALLBACK(remmina_plugin_vnc_on_size_allocate), gp);
+#endif
+	gpdata->auth_first = TRUE;
+	gpdata->clipboard_timer = g_date_time_new_now_utc();
+	gpdata->listen_sock = -1;
+	gpdata->pressed_keys = g_ptr_array_new();
+	gpdata->vnc_event_queue = g_queue_new();
+	pthread_mutex_init(&gpdata->vnc_event_queue_mutex, NULL);
+	if (pipe(gpdata->vnc_event_pipe)) {
+		g_print("Error creating pipes.\n");
+		gpdata->vnc_event_pipe[0] = 0;
+		gpdata->vnc_event_pipe[1] = 0;
+	}
+	flags = fcntl(gpdata->vnc_event_pipe[0], F_GETFL, 0);
+	fcntl(gpdata->vnc_event_pipe[0], F_SETFL, flags | O_NONBLOCK);
+
+	pthread_mutex_init(&gpdata->buffer_mutex, NULL);
+}
+
+/* Array of key/value pairs for color depths */
+static gpointer colordepth_list[] =
+{
+	"32", N_("True colour (32 bpp)"),
+	"16", N_("High colour (16 bpp)"),
+	"8",  N_("256 colours (8 bpp)"),
+	NULL
+};
+
+/* Array of key/value pairs for quality selection */
+static gpointer quality_list[] =
+{
+	"2", N_("Good"),
+	"9", N_("Best (slowest)"),
+	"1", N_("Medium"),
+	"0", N_("Poor (fastest)"),
+	NULL
+};
+
+static gchar repeater_tooltip[] =
+	N_("Connect to VNC using a repeater:\n"
+	   "  • The server field must contain the repeater ID, e.g. ID:123456789\n"
+	   "  • The repeater field have to be set to the repeater IP and port, like:\n"
+	   "    10.10.10.12:5901\n"
+	   "  • From the remote VNC server, you will connect to\n"
+	   "    the repeater, e.g. with x11vnc:\n"
+	   "    x11vnc -connect repeater=ID:123456789+10.10.10.12:5500");
+
+static gchar vnciport_tooltip[] =
+	N_("Listening for remote VNC connection:\n"
+	   "  • The “Listen on port” field is the port Remmina will listen to,\n"
+	   "    e.g. 8888\n"
+	   "  • From the remote VNC server, you will connect to\n"
+	   "    Remmina, e.g. with x11vnc:\n"
+	   "    x11vnc -display :0 -connect 192.168.1.36:8888");
+
+static gchar aspect_ratio_tooltip[] =
+	N_("Lock the aspect ratio when dynamic resolution is enabled:\n"
+	   "\n"
+	   "  • The aspect ratio should be entered as a decimal number, e.g. 1.777\n"
+	   "  • 16:9 corresponds roughly to 1.7777, 4:3 corresponds roughly to 1.333\n"
+	   "  • The default value of 0 does not enforce any aspect ratio");	   
+
+static gchar vncencodings_tooltip[] =
+	N_("Overriding the pre-set VNC encoding quality:\n"
+	   "\n"
+	   "  • “Poor (fastest)” sets encoding to “copyrect zlib hextile raw”\n"
+	   "  • “Medium” sets encoding to “tight zrle ultra copyrect hextile zlib corre rre raw”\n"
+	   "  • “Good” sets encoding to “tight zrle ultra copyrect hextile zlib corre rre raw”\n"
+	   "  • “Best (slowest)” sets encoding to “copyrect zrle ultra zlib hextile corre rre raw”");
+
+/* Array of RemminaProtocolSetting for basic settings.
+ * Each item is composed by:
+ * a) RemminaProtocolSettingType for setting type
+ * b) Setting name
+ * c) Setting description
+ * d) Compact disposition
+ * e) Values for REMMINA_PROTOCOL_SETTING_TYPE_SELECT or REMMINA_PROTOCOL_SETTING_TYPE_COMBO
+ * f) Setting tooltip
+ * g) Validation data pointer, will be passed to the validation callback method.
+ * h) Validation callback method (Can be NULL. Every entry will be valid then.)
+ *		use following prototype:
+ *		gboolean mysetting_validator_method(gpointer key, gpointer value,
+ *						    gpointer validator_data);
+ *		gpointer key is a gchar* containing the setting's name,
+ *		gpointer value contains the value which should be validated,
+ *		gpointer validator_data contains your passed data.
+ */
+static const RemminaProtocolSetting remmina_plugin_vnc_basic_settings[] =
+{
+	{ REMMINA_PROTOCOL_SETTING_TYPE_SERVER,	  "server",	NULL,		     FALSE, "_rfb._tcp",     NULL,	       NULL, NULL },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_TEXT,	  "proxy",	N_("Repeater"),	     FALSE, NULL,	     repeater_tooltip, NULL, NULL },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_TEXT,	  "username",	N_("Username"),	     FALSE, NULL,	     NULL,	       NULL, NULL },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_PASSWORD, "password",	N_("User password"), FALSE, NULL,	     NULL,	       NULL, NULL },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_SELECT,	  "colordepth", N_("Colour depth"),  FALSE, colordepth_list, NULL,	       NULL, NULL },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_SELECT,	  "quality",	N_("Quality"),	     FALSE, quality_list,    NULL,	       NULL, NULL },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_KEYMAP,	  "keymap",	NULL,		     FALSE, NULL,	     NULL,	       NULL, NULL },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_END,	  NULL,		NULL,		     FALSE, NULL,	     NULL,	       NULL, NULL }
+};
+
+// Same as above.
+static const RemminaProtocolSetting remmina_plugin_vnci_basic_settings[] =
+{
+	{ REMMINA_PROTOCOL_SETTING_TYPE_TEXT,	  "listenport", N_("Listen on port"), FALSE, NULL,	      vnciport_tooltip, NULL, NULL},
+	{ REMMINA_PROTOCOL_SETTING_TYPE_TEXT,	  "username",	N_("Username"),	      FALSE, NULL,	      NULL,		NULL, NULL},
+	{ REMMINA_PROTOCOL_SETTING_TYPE_PASSWORD, "password",	N_("User password"),  FALSE, NULL,	      NULL,		NULL, NULL},
+	{ REMMINA_PROTOCOL_SETTING_TYPE_SELECT,	  "colordepth", N_("Colour depth"),   FALSE, colordepth_list, NULL,		NULL, NULL},
+	{ REMMINA_PROTOCOL_SETTING_TYPE_SELECT,	  "quality",	N_("Quality"),	      FALSE, quality_list,    NULL,		NULL, NULL},
+	{ REMMINA_PROTOCOL_SETTING_TYPE_KEYMAP,	  "keymap",	NULL,		      FALSE, NULL,	      NULL,		NULL, NULL},
+	{ REMMINA_PROTOCOL_SETTING_TYPE_END,	  NULL,		NULL,		      FALSE, NULL,	      NULL,		NULL, NULL}
+};
+
+/* Array of RemminaProtocolSetting for advanced settings.
+ * Each item is composed by:
+ * a) RemminaProtocolSettingType for setting type
+ * b) Setting name
+ * c) Setting description
+ * d) Compact disposition
+ * e) Values for REMMINA_PROTOCOL_SETTING_TYPE_SELECT or REMMINA_PROTOCOL_SETTING_TYPE_COMBO
+ * f) Setting Tooltip
+ */
+static const RemminaProtocolSetting remmina_plugin_vnc_advanced_settings[] =
+{
+	{ REMMINA_PROTOCOL_SETTING_TYPE_TEXT,  "encodings",		 N_("Override pre-set VNC encodings"),	        FALSE, NULL, vncencodings_tooltip },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_TEXT,  "aspect_ratio",		 N_("Dynamic resolution enforced aspec ratio"),	        FALSE, NULL, aspect_ratio_tooltip },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_CHECK, "tightencoding", N_("Force tight encoding"),			TRUE, NULL, N_("Enabling this may help when the remote desktop looks scrambled") },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_CHECK, "disablesmoothscrolling", N_("Disable smooth scrolling"),		FALSE, NULL, NULL },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_CHECK, "disablepasswordstoring", N_("Forget passwords after use"),		TRUE,  NULL, NULL },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_CHECK, "disableserverbell",	 N_("Ignore remote bell messages"),		FALSE, NULL, NULL },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_CHECK, "disableserverinput",	 N_("Prevent local interaction on the server"), TRUE,  NULL, NULL },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_CHECK, "showcursor",		 N_("Show remote cursor"),			FALSE,  NULL, NULL },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_CHECK, "disableclipboard",	 N_("Turn off clipboard sync"),			TRUE,  NULL, NULL },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_CHECK, "disableencryption",	 N_("Turn off encryption"),			FALSE, NULL, NULL },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_CHECK, "viewonly",		 N_("View only"),				TRUE, NULL, NULL },
+	{ REMMINA_PROTOCOL_SETTING_TYPE_END,   NULL,			 NULL,						FALSE, NULL, NULL }
+};
+
+/* Array for available features.
+ * The last element of the array must be REMMINA_PROTOCOL_FEATURE_TYPE_END. */
+static const RemminaProtocolFeature remmina_plugin_vnc_features[] =
+{
+	{ REMMINA_PROTOCOL_FEATURE_TYPE_PREF,	 REMMINA_PLUGIN_VNC_FEATURE_PREF_QUALITY,	     GINT_TO_POINTER(REMMINA_PROTOCOL_FEATURE_PREF_RADIO), "quality",
+	  quality_list },
+	{ REMMINA_PROTOCOL_FEATURE_TYPE_PREF,	 REMMINA_PLUGIN_VNC_FEATURE_PREF_COLOR,	     GINT_TO_POINTER(REMMINA_PROTOCOL_FEATURE_PREF_RADIO), "colordepth",
+	  colordepth_list },
+	{ REMMINA_PROTOCOL_FEATURE_TYPE_PREF,	 REMMINA_PLUGIN_VNC_FEATURE_PREF_VIEWONLY,	     GINT_TO_POINTER(REMMINA_PROTOCOL_FEATURE_PREF_CHECK), "viewonly",
+	  N_("View only") },
+	{ REMMINA_PROTOCOL_FEATURE_TYPE_PREF,	 REMMINA_PLUGIN_VNC_FEATURE_PREF_DISABLESERVERINPUT, GINT_TO_POINTER(REMMINA_PROTOCOL_FEATURE_PREF_CHECK), "disableserverinput",N_("Prevent local interaction on the server")  },
+	{ REMMINA_PROTOCOL_FEATURE_TYPE_TOOL,	 REMMINA_PLUGIN_VNC_FEATURE_TOOL_REFRESH,	     N_("Refresh"),					   NULL,		NULL					       },
+	{ REMMINA_PROTOCOL_FEATURE_TYPE_TOOL,	 REMMINA_PLUGIN_VNC_FEATURE_TOOL_CHAT,		     N_("Open Chat…"),					   "face-smile",	NULL					       },
+	{ REMMINA_PROTOCOL_FEATURE_TYPE_TOOL,	 REMMINA_PLUGIN_VNC_FEATURE_TOOL_SENDCTRLALTDEL,     N_("Send Ctrl+Alt+Delete"),			   NULL,		NULL					       },
+	{ REMMINA_PROTOCOL_FEATURE_TYPE_SCALE,	 REMMINA_PLUGIN_VNC_FEATURE_SCALE,		     NULL,						   NULL,		NULL					       },
+	{ REMMINA_PROTOCOL_FEATURE_TYPE_UNFOCUS, REMMINA_PLUGIN_VNC_FEATURE_UNFOCUS,		     NULL,						   NULL,		NULL					       },
+#if LIBVNCSERVER_CHECK_VERSION_VERSION(0, 9, 14)
+	{ REMMINA_PROTOCOL_FEATURE_TYPE_DYNRESUPDATE, REMMINA_PLUGIN_VNC_FEATURE_DYNRESUPDATE,	       NULL,			   NULL, NULL },
+#endif	
+	{ REMMINA_PROTOCOL_FEATURE_TYPE_END,	 0,						     NULL,						   NULL,		NULL					       }
+};
+
+/* Protocol plugin definition and features */
+static RemminaProtocolPlugin remmina_plugin_vnc =
+{
+	REMMINA_PLUGIN_TYPE_PROTOCOL,                   // Type
+	VNC_PLUGIN_NAME,                                // Name
+	VNC_PLUGIN_DESCRIPTION,                         // Description
+	GETTEXT_PACKAGE,                                // Translation domain
+	VNC_PLUGIN_VERSION,                             // Version number
+	VNC_PLUGIN_APPICON,                             // Icon for normal connection
+	VNC_PLUGIN_SSH_APPICON,                         // Icon for SSH connection
+	remmina_plugin_vnc_basic_settings,              // Array for basic settings
+	remmina_plugin_vnc_advanced_settings,           // Array for advanced settings
+	REMMINA_PROTOCOL_SSH_SETTING_TUNNEL,            // SSH settings type
+	remmina_plugin_vnc_features,                    // Array for available features
+	remmina_plugin_vnc_init,                        // Plugin initialization
+	remmina_plugin_vnc_open_connection,             // Plugin open connection
+	remmina_plugin_vnc_close_connection,            // Plugin close connection
+	remmina_plugin_vnc_query_feature,               // Query for available features
+	remmina_plugin_vnc_call_feature,                // Call a feature
+	remmina_plugin_vnc_keystroke                    // Send a keystroke
+};
+
+/* Protocol plugin definition and features */
+static RemminaProtocolPlugin remmina_plugin_vnci =
+{
+	REMMINA_PLUGIN_TYPE_PROTOCOL,                   // Type
+	VNCI_PLUGIN_NAME,                               // Name
+	VNCI_PLUGIN_DESCRIPTION,                        // Description
+	GETTEXT_PACKAGE,                                // Translation domain
+	VERSION,                                        // Version number
+	VNCI_PLUGIN_APPICON,                            // Icon for normal connection
+	VNCI_PLUGIN_SSH_APPICON,                        // Icon for SSH connection
+	remmina_plugin_vnci_basic_settings,             // Array for basic settings
+	remmina_plugin_vnc_advanced_settings,           // Array for advanced settings
+	REMMINA_PROTOCOL_SSH_SETTING_REVERSE_TUNNEL,    // SSH settings type
+	remmina_plugin_vnc_features,                    // Array for available features
+	remmina_plugin_vnc_init,                        // Plugin initialization
+	remmina_plugin_vnc_open_connection,             // Plugin open connection
+	remmina_plugin_vnc_close_connection,            // Plugin close connection
+	remmina_plugin_vnc_query_feature,               // Query for available features
+	remmina_plugin_vnc_call_feature,                // Call a feature
+	remmina_plugin_vnc_keystroke,                   // Send a keystroke
+	NULL,                                           // No screenshot support available
+	NULL,                                           // RCW map event
+	NULL                                            // RCW unmap event
+};
+
+G_MODULE_EXPORT gboolean
+remmina_plugin_entry(RemminaPluginService *service)
+{
+	TRACE_CALL(__func__);
+	remmina_plugin_service = service;
+
+	bindtextdomain(GETTEXT_PACKAGE, REMMINA_RUNTIME_LOCALEDIR);
+	bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
+
+	if (!service->register_plugin((RemminaPlugin *)&remmina_plugin_vnc))
+		return FALSE;
+
+	if (!service->register_plugin((RemminaPlugin *)&remmina_plugin_vnci))
+		return FALSE;
+
+	return TRUE;
+}