[PATCH 10/25] Convert VncConnection into a proper GObject type



---
 src/vncbaseframebuffer.h |    2 +-
 src/vncconnection.c      | 1312 +++++++++++++++++++++++++++-------------------
 src/vncconnection.h      |   28 +-
 src/vncconnectionblt.h   |   29 +-
 src/vncdisplay.c         |    2 +-
 5 files changed, 824 insertions(+), 549 deletions(-)

diff --git a/src/vncbaseframebuffer.h b/src/vncbaseframebuffer.h
index 529a347..173e806 100644
--- a/src/vncbaseframebuffer.h
+++ b/src/vncbaseframebuffer.h
@@ -32,7 +32,7 @@ G_BEGIN_DECLS
 #define VNC_BASE_FRAMEBUFFER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), VNC_TYPE_BASE_FRAMEBUFFER, VncBaseFramebufferClass))
 #define VNC_IS_BASE_FRAMEBUFFER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VNC_TYPE_BASE_FRAMEBUFFER))
 #define VNC_IS_BASE_FRAMEBUFFER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VNC_TYPE_BASE_FRAMEBUFFER))
-#define VNC_BASE_FRAMEBUFFER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), VNC_TYPE_BASE_FRAMEBUFFER, VncBAseFramebufferClass))
+#define VNC_BASE_FRAMEBUFFER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), VNC_TYPE_BASE_FRAMEBUFFER, VncBaseFramebufferClass))
 
 
 typedef struct _VncBaseFramebuffer VncBaseFramebuffer;
diff --git a/src/vncconnection.c b/src/vncconnection.c
index 91eb284..bbe862e 100644
--- a/src/vncconnection.c
+++ b/src/vncconnection.c
@@ -100,7 +100,11 @@ struct g_condition_wait_source
 	gpointer data;
 };
 
-struct _VncConnection
+#define VNC_CONNECTION_GET_PRIVATE(obj)				\
+	(G_TYPE_INSTANCE_GET_PRIVATE((obj), VNC_TYPE_CONNECTION, VncConnectionPrivate))
+
+
+struct _VncConnectionPrivate
 {
 	GIOChannel *channel;
 	int fd;
@@ -178,6 +182,8 @@ struct _VncConnection
 	const guint8 const *keycode_map;
 };
 
+G_DEFINE_TYPE(VncConnection, vnc_connection, G_TYPE_OBJECT);
+
 #define nibhi(a) (((a) >> 4) & 0x0F)
 #define niblo(a) ((a) & 0x0F)
 
@@ -296,51 +302,97 @@ static gboolean g_condition_wait(g_condition_wait_func func, gpointer data)
 	return TRUE;
 }
 
+
+enum {
+	PROP_0,
+	PROP_FRAMEBUFFER,
+};
+
+
+static void vnc_connection_get_property(GObject *object,
+					guint prop_id,
+					GValue *value,
+					GParamSpec *pspec)
+{
+	VncConnection *conn = VNC_CONNECTION(object);
+	VncConnectionPrivate *priv = conn->priv;
+
+	switch (prop_id) {
+	case PROP_FRAMEBUFFER:
+		g_value_set_object(value, priv->fb);
+		break;
+
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
+	}
+}
+
+static void vnc_connection_set_property(GObject *object,
+					guint prop_id,
+					const GValue *value,
+					GParamSpec *pspec)
+{
+	VncConnection *conn = VNC_CONNECTION(object);
+
+	switch (prop_id) {
+	case PROP_FRAMEBUFFER:
+		vnc_connection_set_framebuffer(conn, g_value_get_object(value));
+		break;
+
+        default:
+            G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
+        }
+}
+
+
 static gboolean vnc_connection_use_compression(VncConnection *conn)
 {
-	return conn->compressed_buffer != NULL;
+	VncConnectionPrivate *priv = conn->priv;
+
+	return priv->compressed_buffer != NULL;
 }
 
 static int vnc_connection_zread(VncConnection *conn, void *buffer, size_t size)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	char *ptr = buffer;
 	size_t offset = 0;
 
 	while (offset < size) {
 		/* if data is available in the uncompressed buffer, then
 		 * copy */
-		if (conn->uncompressed_length) {
-			size_t len = MIN(conn->uncompressed_length,
+		if (priv->uncompressed_length) {
+			size_t len = MIN(priv->uncompressed_length,
 					 size - offset);
 
 			memcpy(ptr + offset,
-			       conn->uncompressed_buffer,
+			       priv->uncompressed_buffer,
 			       len);
 
-			conn->uncompressed_length -= len;
-			if (conn->uncompressed_length)
-				memmove(conn->uncompressed_buffer,
-					conn->uncompressed_buffer + len,
-					conn->uncompressed_length);
+			priv->uncompressed_length -= len;
+			if (priv->uncompressed_length)
+				memmove(priv->uncompressed_buffer,
+					priv->uncompressed_buffer + len,
+					priv->uncompressed_length);
 			offset += len;
 		} else {
 			int err;
 
-			conn->strm->next_in = conn->compressed_buffer;
-			conn->strm->avail_in = conn->compressed_length;
-			conn->strm->next_out = conn->uncompressed_buffer;
-			conn->strm->avail_out = sizeof(conn->uncompressed_buffer);
+			priv->strm->next_in = priv->compressed_buffer;
+			priv->strm->avail_in = priv->compressed_length;
+			priv->strm->next_out = priv->uncompressed_buffer;
+			priv->strm->avail_out = sizeof(priv->uncompressed_buffer);
 
 			/* inflate as much as possible */
-			err = inflate(conn->strm, Z_SYNC_FLUSH);
+			err = inflate(priv->strm, Z_SYNC_FLUSH);
 			if (err != Z_OK) {
 				errno = EIO;
 				return -1;
 			}
 
-			conn->uncompressed_length = (guint8 *)conn->strm->next_out - conn->uncompressed_buffer;
-			conn->compressed_length -= (guint8 *)conn->strm->next_in - conn->compressed_buffer;
-			conn->compressed_buffer = conn->strm->next_in;
+			priv->uncompressed_length = (guint8 *)priv->strm->next_out - priv->uncompressed_buffer;
+			priv->compressed_length -= (guint8 *)priv->strm->next_in - priv->compressed_buffer;
+			priv->compressed_buffer = priv->strm->next_in;
 		}
 	}
 
@@ -356,11 +408,12 @@ static int vnc_connection_zread(VncConnection *conn, void *buffer, size_t size)
  */
 static int vnc_connection_read_wire(VncConnection *conn, void *data, size_t len)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	int ret;
 
  reread:
-	if (conn->tls_session) {
-		ret = gnutls_read(conn->tls_session, data, len);
+	if (priv->tls_session) {
+		ret = gnutls_read(priv->tls_session, data, len);
 		if (ret < 0) {
 			if (ret == GNUTLS_E_AGAIN)
 				errno = EAGAIN;
@@ -369,31 +422,31 @@ static int vnc_connection_read_wire(VncConnection *conn, void *data, size_t len)
 			ret = -1;
 		}
 	} else
-		ret = recv (conn->fd, data, len, 0);
+		ret = recv (priv->fd, data, len, 0);
 
 	if (ret == -1) {
 		switch (errno) {
 		case EWOULDBLOCK:
-			if (conn->wait_interruptable) {
-				if (!g_io_wait_interruptable(&conn->wait,
-							     conn->channel, G_IO_IN)) {
-					GVNC_DEBUG("Read blocking interrupted %d", conn->has_error);
+			if (priv->wait_interruptable) {
+				if (!g_io_wait_interruptable(&priv->wait,
+							     priv->channel, G_IO_IN)) {
+					GVNC_DEBUG("Read blocking interrupted %d", priv->has_error);
 					return -EAGAIN;
 				}
 			} else
-				g_io_wait(conn->channel, G_IO_IN);
+				g_io_wait(priv->channel, G_IO_IN);
 		case EINTR:
 			goto reread;
 
 		default:
 			GVNC_DEBUG("Closing the connection: vnc_connection_read() - errno=%d", errno);
-			conn->has_error = TRUE;
+			priv->has_error = TRUE;
 			return -errno;
 		}
 	}
 	if (ret == 0) {
 		GVNC_DEBUG("Closing the connection: vnc_connection_read() - ret=0");
-		conn->has_error = TRUE;
+		priv->has_error = TRUE;
 		return -EPIPE;
 	}
 	//GVNC_DEBUG("Read wire %p %d -> %d", data, len, ret);
@@ -409,10 +462,12 @@ static int vnc_connection_read_wire(VncConnection *conn, void *data, size_t len)
  */
 static int vnc_connection_read_sasl(VncConnection *conn)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	size_t want;
-	//GVNC_DEBUG("Read SASL %p size %d offset %d", conn->saslDecoded,
-	//	   conn->saslDecodedLength, conn->saslDecodedOffset);
-	if (conn->saslDecoded == NULL) {
+
+	//GVNC_DEBUG("Read SASL %p size %d offset %d", priv->saslDecoded,
+	//	   priv->saslDecodedLength, priv->saslDecodedOffset);
+	if (priv->saslDecoded == NULL) {
 		char encoded[8192];
 		int encodedLen = sizeof(encoded);
 		int err, ret;
@@ -422,30 +477,30 @@ static int vnc_connection_read_sasl(VncConnection *conn)
 			return ret;
 		}
 
-		err = sasl_decode(conn->saslconn, encoded, ret,
-				  &conn->saslDecoded, &conn->saslDecodedLength);
+		err = sasl_decode(priv->saslconn, encoded, ret,
+				  &priv->saslDecoded, &priv->saslDecodedLength);
 		if (err != SASL_OK) {
 			GVNC_DEBUG("Failed to decode SASL data %s",
 				   sasl_errstring(err, NULL, NULL));
-			conn->has_error = TRUE;
+			priv->has_error = TRUE;
 			return -EINVAL;
 		}
-		conn->saslDecodedOffset = 0;
+		priv->saslDecodedOffset = 0;
 	}
 
-	want = conn->saslDecodedLength - conn->saslDecodedOffset;
-	if (want > sizeof(conn->read_buffer))
-		want = sizeof(conn->read_buffer);
+	want = priv->saslDecodedLength - priv->saslDecodedOffset;
+	if (want > sizeof(priv->read_buffer))
+		want = sizeof(priv->read_buffer);
 
-	memcpy(conn->read_buffer,
-	       conn->saslDecoded + conn->saslDecodedOffset,
+	memcpy(priv->read_buffer,
+	       priv->saslDecoded + priv->saslDecodedOffset,
 	       want);
-	conn->saslDecodedOffset += want;
-	if (conn->saslDecodedOffset == conn->saslDecodedLength) {
-		conn->saslDecodedLength = conn->saslDecodedOffset = 0;
-		conn->saslDecoded = NULL;
+	priv->saslDecodedOffset += want;
+	if (priv->saslDecodedOffset == priv->saslDecodedLength) {
+		priv->saslDecodedLength = priv->saslDecodedOffset = 0;
+		priv->saslDecoded = NULL;
 	}
-	//GVNC_DEBUG("Done read write %d - %d", want, conn->has_error);
+	//GVNC_DEBUG("Done read write %d - %d", want, priv->has_error);
 	return want;
 }
 #endif
@@ -457,8 +512,10 @@ static int vnc_connection_read_sasl(VncConnection *conn)
  */
 static int vnc_connection_read_plain(VncConnection *conn)
 {
-	//GVNC_DEBUG("Read plain %d", sizeof(conn->read_buffer));
-	return vnc_connection_read_wire(conn, conn->read_buffer, sizeof(conn->read_buffer));
+	VncConnectionPrivate *priv = conn->priv;
+
+	//GVNC_DEBUG("Read plain %d", sizeof(priv->read_buffer));
+	return vnc_connection_read_wire(conn, priv->read_buffer, sizeof(priv->read_buffer));
 }
 
 /*
@@ -466,9 +523,11 @@ static int vnc_connection_read_plain(VncConnection *conn)
  */
 static int vnc_connection_read_buf(VncConnection *conn)
 {
-	//GVNC_DEBUG("Start read %d", conn->has_error);
+	VncConnectionPrivate *priv = conn->priv;
+
+	//GVNC_DEBUG("Start read %d", priv->has_error);
 #if HAVE_SASL
-	if (conn->saslconn)
+	if (priv->saslconn)
 		return vnc_connection_read_sasl(conn);
 	else
 #endif
@@ -480,10 +539,11 @@ static int vnc_connection_read_buf(VncConnection *conn)
  */
 static int vnc_connection_read(VncConnection *conn, void *data, size_t len)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	char *ptr = data;
 	size_t offset = 0;
 
-	if (conn->has_error) return -EINVAL;
+	if (priv->has_error) return -EINVAL;
 
 	while (offset < len) {
 		size_t tmp;
@@ -494,25 +554,25 @@ static int vnc_connection_read(VncConnection *conn, void *data, size_t len)
 			int ret = vnc_connection_zread(conn, ptr + offset, len);
 			if (ret == -1) {
 				GVNC_DEBUG("Closing the connection: vnc_connection_read() - zread() failed");
-				conn->has_error = TRUE;
+				priv->has_error = TRUE;
 				return -errno;
 			}
 			offset += ret;
 			continue;
-		} else if (conn->read_offset == conn->read_size) {
+		} else if (priv->read_offset == priv->read_size) {
 			int ret = vnc_connection_read_buf(conn);
 
 			if (ret < 0)
 				return ret;
-			conn->read_offset = 0;
-			conn->read_size = ret;
+			priv->read_offset = 0;
+			priv->read_size = ret;
 		}
 
-		tmp = MIN(conn->read_size - conn->read_offset, len - offset);
+		tmp = MIN(priv->read_size - priv->read_offset, len - offset);
 
-		memcpy(ptr + offset, conn->read_buffer + conn->read_offset, tmp);
+		memcpy(ptr + offset, priv->read_buffer + priv->read_offset, tmp);
 
-		conn->read_offset += tmp;
+		priv->read_offset += tmp;
 		offset += tmp;
 	}
 
@@ -527,14 +587,15 @@ static void vnc_connection_flush_wire(VncConnection *conn,
 				      const void *data,
 				      size_t datalen)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	const char *ptr = data;
 	size_t offset = 0;
 	//GVNC_DEBUG("Flush write %p %d", data, datalen);
 	while (offset < datalen) {
 		int ret;
 
-		if (conn->tls_session) {
-			ret = gnutls_write(conn->tls_session,
+		if (priv->tls_session) {
+			ret = gnutls_write(priv->tls_session,
 					   ptr+offset,
 					   datalen-offset);
 			if (ret < 0) {
@@ -545,24 +606,24 @@ static void vnc_connection_flush_wire(VncConnection *conn,
 				ret = -1;
 			}
 		} else
-			ret = send (conn->fd,
+			ret = send (priv->fd,
 				    ptr+offset,
 				    datalen-offset, 0);
 		if (ret == -1) {
 			switch (errno) {
 			case EWOULDBLOCK:
-				g_io_wait(conn->channel, G_IO_OUT);
+				g_io_wait(priv->channel, G_IO_OUT);
 			case EINTR:
 				continue;
 			default:
 				GVNC_DEBUG("Closing the connection: vnc_connection_flush %d", errno);
-				conn->has_error = TRUE;
+				priv->has_error = TRUE;
 				return;
 			}
 		}
 		if (ret == 0) {
 			GVNC_DEBUG("Closing the connection: vnc_connection_flush");
-			conn->has_error = TRUE;
+			priv->has_error = TRUE;
 			return;
 		}
 		offset += ret;
@@ -577,21 +638,22 @@ static void vnc_connection_flush_wire(VncConnection *conn,
  */
 static void vnc_connection_flush_sasl(VncConnection *conn)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	const char *output;
 	unsigned int outputlen;
 	int err;
 
-	err = sasl_encode(conn->saslconn,
-			  conn->write_buffer,
-			  conn->write_offset,
+	err = sasl_encode(priv->saslconn,
+			  priv->write_buffer,
+			  priv->write_offset,
 			  &output, &outputlen);
 	if (err != SASL_OK) {
 		GVNC_DEBUG("Failed to encode SASL data %s",
 			   sasl_errstring(err, NULL, NULL));
-		conn->has_error = TRUE;
+		priv->has_error = TRUE;
 		return;
 	}
-	//GVNC_DEBUG("Flush SASL %d: %p %d", conn->write_offset, output, outputlen);
+	//GVNC_DEBUG("Flush SASL %d: %p %d", priv->write_offset, output, outputlen);
 	vnc_connection_flush_wire(conn, output, outputlen);
 }
 #endif
@@ -601,10 +663,12 @@ static void vnc_connection_flush_sasl(VncConnection *conn)
  */
 static void vnc_connection_flush_plain(VncConnection *conn)
 {
-	//GVNC_DEBUG("Flush plain %d", conn->write_offset);
+	VncConnectionPrivate *priv = conn->priv;
+
+	//GVNC_DEBUG("Flush plain %d", priv->write_offset);
 	vnc_connection_flush_wire(conn,
-				  conn->write_buffer,
-				  conn->write_offset);
+				  priv->write_buffer,
+				  priv->write_offset);
 }
 
 
@@ -613,33 +677,36 @@ static void vnc_connection_flush_plain(VncConnection *conn)
  */
 static void vnc_connection_flush(VncConnection *conn)
 {
-	//GVNC_DEBUG("STart write %d", conn->has_error);
+	VncConnectionPrivate *priv = conn->priv;
+
+	//GVNC_DEBUG("STart write %d", priv->has_error);
 #if HAVE_SASL
-	if (conn->saslconn)
+	if (priv->saslconn)
 		vnc_connection_flush_sasl(conn);
 	else
 #endif
 		vnc_connection_flush_plain(conn);
-	conn->write_offset = 0;
+	priv->write_offset = 0;
 }
 
 static void vnc_connection_write(VncConnection *conn, const void *data, size_t len)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	const char *ptr = data;
 	size_t offset = 0;
 
 	while (offset < len) {
 		ssize_t tmp;
 
-		if (conn->write_offset == sizeof(conn->write_buffer)) {
+		if (priv->write_offset == sizeof(priv->write_buffer)) {
 			vnc_connection_flush(conn);
 		}
 
-		tmp = MIN(sizeof(conn->write_buffer), len - offset);
+		tmp = MIN(sizeof(priv->write_buffer), len - offset);
 
-		memcpy(conn->write_buffer+conn->write_offset, ptr + offset, tmp);
+		memcpy(priv->write_buffer+priv->write_offset, ptr + offset, tmp);
 
-		conn->write_offset += tmp;
+		priv->write_offset += tmp;
 		offset += tmp;
 	}
 }
@@ -649,10 +716,11 @@ static ssize_t vnc_connection_tls_push(gnutls_transport_ptr_t transport,
 				       const void *data,
 				       size_t len) {
 	VncConnection *conn = transport;
+	VncConnectionPrivate *priv = conn->priv;
 	int ret;
 
  retry:
-	ret = write(conn->fd, data, len);
+	ret = write(priv->fd, data, len);
 	if (ret < 0) {
 		if (errno == EINTR)
 			goto retry;
@@ -666,10 +734,11 @@ static ssize_t vnc_connection_tls_pull(gnutls_transport_ptr_t transport,
 				       void *data,
 				       size_t len) {
 	VncConnection *conn = transport;
+	VncConnectionPrivate *priv = conn->priv;
 	int ret;
 
  retry:
-	ret = read(conn->fd, data, len);
+	ret = read(priv->fd, data, len);
 	if (ret < 0) {
 		if (errno == EINTR)
 			goto retry;
@@ -680,7 +749,9 @@ static ssize_t vnc_connection_tls_pull(gnutls_transport_ptr_t transport,
 
 static size_t vnc_connection_pixel_size(VncConnection *conn)
 {
-	return conn->fmt.bits_per_pixel / 8;
+	VncConnectionPrivate *priv = conn->priv;
+
+	return priv->fmt.bits_per_pixel / 8;
 }
 
 static void vnc_connection_read_pixel(VncConnection *conn, guint8 *pixel)
@@ -697,11 +768,12 @@ static guint8 vnc_connection_read_u8(VncConnection *conn)
 
 static int vnc_connection_read_u8_interruptable(VncConnection *conn, guint8 *value)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	int ret;
 
-	conn->wait_interruptable = 1;
+	priv->wait_interruptable = 1;
 	ret = vnc_connection_read(conn, value, sizeof(*value));
-	conn->wait_interruptable = 0;
+	priv->wait_interruptable = 0;
 
 	return ret;
 }
@@ -801,6 +873,7 @@ static gnutls_anon_client_credentials vnc_connection_tls_initialize_anon_cred(vo
 
 static gnutls_certificate_credentials_t vnc_connection_tls_initialize_cert_cred(VncConnection *conn)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	gnutls_certificate_credentials_t x509_cred;
 	int ret;
 
@@ -808,9 +881,9 @@ static gnutls_certificate_credentials_t vnc_connection_tls_initialize_cert_cred(
 		GVNC_DEBUG("Cannot allocate credentials %s", gnutls_strerror(ret));
 		return NULL;
 	}
-	if (conn->cred_x509_cacert) {
+	if (priv->cred_x509_cacert) {
 		if ((ret = gnutls_certificate_set_x509_trust_file(x509_cred,
-								  conn->cred_x509_cacert,
+								  priv->cred_x509_cacert,
 								  GNUTLS_X509_FMT_PEM)) < 0) {
 			GVNC_DEBUG("Cannot load CA certificate %s", gnutls_strerror(ret));
 			return NULL;
@@ -820,10 +893,10 @@ static gnutls_certificate_credentials_t vnc_connection_tls_initialize_cert_cred(
 		return NULL;
 	}
 
-	if (conn->cred_x509_cert && conn->cred_x509_key) {
+	if (priv->cred_x509_cert && priv->cred_x509_key) {
 		if ((ret = gnutls_certificate_set_x509_key_file (x509_cred,
-								 conn->cred_x509_cert,
-								 conn->cred_x509_key,
+								 priv->cred_x509_cert,
+								 priv->cred_x509_key,
 								 GNUTLS_X509_FMT_PEM)) < 0) {
 			GVNC_DEBUG("Cannot load certificate & key %s", gnutls_strerror(ret));
 			return NULL;
@@ -832,9 +905,9 @@ static gnutls_certificate_credentials_t vnc_connection_tls_initialize_cert_cred(
 		GVNC_DEBUG("No client cert or key provided");
 	}
 
-	if (conn->cred_x509_cacrl) {
+	if (priv->cred_x509_cacrl) {
 		if ((ret = gnutls_certificate_set_x509_crl_file(x509_cred,
-								conn->cred_x509_cacrl,
+								priv->cred_x509_cacrl,
 								GNUTLS_X509_FMT_PEM)) < 0) {
 			GVNC_DEBUG("Cannot load CRL %s", gnutls_strerror(ret));
 			return NULL;
@@ -850,6 +923,7 @@ static gnutls_certificate_credentials_t vnc_connection_tls_initialize_cert_cred(
 
 static int vnc_connection_validate_certificate(VncConnection *conn)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	int ret;
 	unsigned int status;
 	const gnutls_datum_t *certs;
@@ -857,7 +931,7 @@ static int vnc_connection_validate_certificate(VncConnection *conn)
 	time_t now;
 
 	GVNC_DEBUG("Validating");
-	if ((ret = gnutls_certificate_verify_peers2 (conn->tls_session, &status)) < 0) {
+	if ((ret = gnutls_certificate_verify_peers2 (priv->tls_session, &status)) < 0) {
 		GVNC_DEBUG("Verify failed %s", gnutls_strerror(ret));
 		return FALSE;
 	}
@@ -884,10 +958,10 @@ static int vnc_connection_validate_certificate(VncConnection *conn)
 		GVNC_DEBUG("Certificate is valid.");
 	}
 
-	if (gnutls_certificate_type_get(conn->tls_session) != GNUTLS_CRT_X509)
+	if (gnutls_certificate_type_get(priv->tls_session) != GNUTLS_CRT_X509)
 		return FALSE;
 
-	if (!(certs = gnutls_certificate_get_peers(conn->tls_session, &nCerts)))
+	if (!(certs = gnutls_certificate_get_peers(priv->tls_session, &nCerts)))
 		return FALSE;
 
 	for (i = 0 ; i < nCerts ; i++) {
@@ -920,14 +994,14 @@ static int vnc_connection_validate_certificate(VncConnection *conn)
 		}
 
 		if (i == 0) {
-			if (!conn->host) {
+			if (!priv->host) {
 				GVNC_DEBUG ("No hostname provided for certificate verification");
 				gnutls_x509_crt_deinit (cert);
 				return FALSE;
 			}
-			if (!gnutls_x509_crt_check_hostname (cert, conn->host)) {
+			if (!gnutls_x509_crt_check_hostname (cert, priv->host)) {
 				GVNC_DEBUG ("The certificate's owner does not match hostname '%s'",
-					    conn->host);
+					    priv->host);
 				gnutls_x509_crt_deinit (cert);
 				return FALSE;
 			}
@@ -969,12 +1043,15 @@ static void vnc_connection_read_pixel_format(VncConnection *conn, VncPixelFormat
 
 gboolean vnc_connection_has_error(VncConnection *conn)
 {
-	return conn->has_error;
+	VncConnectionPrivate *priv = conn->priv;
+
+	return priv->has_error;
 }
 
 gboolean vnc_connection_set_pixel_format(VncConnection *conn,
 					 const VncPixelFormat *fmt)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	guint8 pad[3] = {0};
 
 	vnc_connection_write_u8(conn, 0);
@@ -996,8 +1073,8 @@ gboolean vnc_connection_set_pixel_format(VncConnection *conn,
 	vnc_connection_write(conn, pad, 3);
 	vnc_connection_flush(conn);
 
-	if (&conn->fmt != fmt)
-		memcpy(&conn->fmt, fmt, sizeof(*fmt));
+	if (&priv->fmt != fmt)
+		memcpy(&priv->fmt, fmt, sizeof(*fmt));
 
 	return !vnc_connection_has_error(conn);
 }
@@ -1005,11 +1082,14 @@ gboolean vnc_connection_set_pixel_format(VncConnection *conn,
 
 const VncPixelFormat *vnc_connection_get_pixel_format(VncConnection *conn)
 {
-	return &conn->fmt;
+	VncConnectionPrivate *priv = conn->priv;
+
+	return &priv->fmt;
 }
 
 gboolean vnc_connection_set_encodings(VncConnection *conn, int n_encoding, gint32 *encoding)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	guint8 pad[1] = {0};
 	int i, skip_zrle=0;
 
@@ -1026,16 +1106,16 @@ gboolean vnc_connection_set_encodings(VncConnection *conn, int n_encoding, gint3
 	 * So we kill off ZRLE encoding for problematic pixel formats
 	 */
 	for (i = 0; i < n_encoding; i++)
-		if (conn->fmt.depth == 32 &&
-		    (conn->fmt.red_max > 255 ||
-		     conn->fmt.blue_max > 255 ||
-		     conn->fmt.green_max > 255) &&
+		if (priv->fmt.depth == 32 &&
+		    (priv->fmt.red_max > 255 ||
+		     priv->fmt.blue_max > 255 ||
+		     priv->fmt.green_max > 255) &&
 		    encoding[i] == GVNC_ENCODING_ZRLE) {
 			GVNC_DEBUG("Dropping ZRLE encoding for broken pixel format");
 			skip_zrle++;
 		}
 
-	conn->has_ext_key_event = FALSE;
+	priv->has_ext_key_event = FALSE;
 	vnc_connection_write_u8(conn, 2);
 	vnc_connection_write(conn, pad, 1);
 	vnc_connection_write_u16(conn, n_encoding - skip_zrle);
@@ -1066,20 +1146,21 @@ gboolean vnc_connection_framebuffer_update_request(VncConnection *conn,
 
 static void vnc_connection_buffered_write(VncConnection *conn, const void *data, size_t size)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	size_t left;
 
-	left = conn->xmit_buffer_capacity - conn->xmit_buffer_size;
+	left = priv->xmit_buffer_capacity - priv->xmit_buffer_size;
 	if (left < size) {
-		conn->xmit_buffer_capacity += size + 4095;
-		conn->xmit_buffer_capacity &= ~4095;
+		priv->xmit_buffer_capacity += size + 4095;
+		priv->xmit_buffer_capacity &= ~4095;
 
-		conn->xmit_buffer = g_realloc(conn->xmit_buffer, conn->xmit_buffer_capacity);
+		priv->xmit_buffer = g_realloc(priv->xmit_buffer, priv->xmit_buffer_capacity);
 	}
 
-	memcpy(&conn->xmit_buffer[conn->xmit_buffer_size],
+	memcpy(&priv->xmit_buffer[priv->xmit_buffer_size],
 	       data, size);
 
-	conn->xmit_buffer_size += size;
+	priv->xmit_buffer_size += size;
 }
 
 static void vnc_connection_buffered_write_u8(VncConnection *conn, guint8 value)
@@ -1101,17 +1182,20 @@ static void vnc_connection_buffered_write_u32(VncConnection *conn, guint32 value
 
 static void vnc_connection_buffered_flush(VncConnection *conn)
 {
-	g_io_wakeup(&conn->wait);
+	VncConnectionPrivate *priv = conn->priv;
+
+	g_io_wakeup(&priv->wait);
 }
 
 gboolean vnc_connection_key_event(VncConnection *conn, guint8 down_flag,
 				  guint32 key, guint16 scancode)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	guint8 pad[2] = {0};
 
-	GVNC_DEBUG("Key event %d %d %d %d", key, scancode, down_flag, conn->has_ext_key_event);
-	if (conn->has_ext_key_event) {
-		scancode = x_keycode_to_pc_keycode(conn->keycode_map, scancode);
+	GVNC_DEBUG("Key event %d %d %d %d", key, scancode, down_flag, priv->has_ext_key_event);
+	if (priv->has_ext_key_event) {
+		scancode = x_keycode_to_pc_keycode(priv->keycode_map, scancode);
 
 		vnc_connection_buffered_write_u8(conn, 255);
 		vnc_connection_buffered_write_u8(conn, 0);
@@ -1156,10 +1240,11 @@ gboolean vnc_connection_client_cut_text(VncConnection *conn,
 
 static inline guint8 *vnc_connection_get_local(VncConnection *conn, int x, int y)
 {
-	const VncPixelFormat *local = vnc_framebuffer_get_local_format(conn->fb);
-	int rowstride = vnc_framebuffer_get_rowstride(conn->fb);
+	VncConnectionPrivate *priv = conn->priv;
+	const VncPixelFormat *local = vnc_framebuffer_get_local_format(priv->fb);
+	int rowstride = vnc_framebuffer_get_rowstride(priv->fb);
 
-	return vnc_framebuffer_get_buffer(conn->fb) +
+	return vnc_framebuffer_get_buffer(priv->fb) +
 		(y * rowstride) +
 		(x * (local->bits_per_pixel / 8));
 }
@@ -1173,7 +1258,9 @@ static guint8 vnc_connection_swap_rfb_8(VncConnection *conn G_GNUC_UNUSED, guint
 /* VNC server RFB  format ->  local host native format */
 static guint16 vnc_connection_swap_rfb_16(VncConnection *conn, guint16 pixel)
 {
-	if (conn->fbSwapRemote)
+	VncConnectionPrivate *priv = conn->priv;
+
+	if (priv->fbSwapRemote)
 		return  (((pixel >> 8) & 0xFF) << 0) |
 			(((pixel >> 0) & 0xFF) << 8);
 	else
@@ -1183,7 +1270,9 @@ static guint16 vnc_connection_swap_rfb_16(VncConnection *conn, guint16 pixel)
 /* VNC server RFB  format ->  local host native format */
 static guint32 vnc_connection_swap_rfb_32(VncConnection *conn, guint32 pixel)
 {
-	if (conn->fbSwapRemote)
+	VncConnectionPrivate *priv = conn->priv;
+
+	if (priv->fbSwapRemote)
 		return  (((pixel >> 24) & 0xFF) <<  0) |
 			(((pixel >> 16) & 0xFF) <<  8) |
 			(((pixel >>  8) & 0xFF) << 16) |
@@ -1271,31 +1360,33 @@ static void vnc_connection_raw_update(VncConnection *conn,
 				      guint16 x, guint16 y,
 				      guint16 width, guint16 height)
 {
+	VncConnectionPrivate *priv = conn->priv;
+
 	/* optimize for perfect match between server/client
 	   FWIW, in the local case, we ought to be doing a write
 	   directly from the source framebuffer and a read directly
 	   into the client framebuffer
 	*/
-	if (vnc_framebuffer_perfect_format_match(conn->fb)) {
+	if (vnc_framebuffer_perfect_format_match(priv->fb)) {
 		int i;
-		int rowstride = vnc_framebuffer_get_rowstride(conn->fb);
-		guint8 *dst = vnc_framebuffer_get_buffer(conn->fb);
+		int rowstride = vnc_framebuffer_get_rowstride(priv->fb);
+		guint8 *dst = vnc_framebuffer_get_buffer(priv->fb);
 
-		dst += (y * rowstride) + (x * (conn->fmt.bits_per_pixel/8));
+		dst += (y * rowstride) + (x * (priv->fmt.bits_per_pixel/8));
 
 		for (i = 0; i < height; i++) {
 			vnc_connection_read(conn, dst,
-					    width * (conn->fmt.bits_per_pixel/8));
+					    width * (priv->fmt.bits_per_pixel/8));
 			dst += rowstride;
 		}
 	} else {
 		guint8 *dst;
 		int i;
 
-		dst = g_malloc(width * (conn->fmt.bits_per_pixel / 8));
+		dst = g_malloc(width * (priv->fmt.bits_per_pixel / 8));
 		for (i = 0; i < height; i++) {
-			vnc_connection_read(conn, dst, width * (conn->fmt.bits_per_pixel / 8));
-			vnc_framebuffer_blt(conn->fb, dst, 0, x, y + i, width, 1);
+			vnc_connection_read(conn, dst, width * (priv->fmt.bits_per_pixel / 8));
+			vnc_framebuffer_blt(priv->fb, dst, 0, x, y + i, width, 1);
 		}
 		g_free(dst);
 	}
@@ -1305,12 +1396,13 @@ static void vnc_connection_copyrect_update(VncConnection *conn,
 					   guint16 dst_x, guint16 dst_y,
 					   guint16 width, guint16 height)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	int src_x, src_y;
 
 	src_x = vnc_connection_read_u16(conn);
 	src_y = vnc_connection_read_u16(conn);
 
-	vnc_framebuffer_copyrect(conn->fb,
+	vnc_framebuffer_copyrect(priv->fb,
 				 src_x, src_y,
 				 dst_x, dst_y,
 				 width, height);
@@ -1322,6 +1414,7 @@ static void vnc_connection_hextile_rect(VncConnection *conn,
 					guint16 width, guint16 height,
 					guint8 *fg, guint8 *bg)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	int i;
 
 	if (flags & 0x01) {
@@ -1335,7 +1428,7 @@ static void vnc_connection_hextile_rect(VncConnection *conn,
 		if (flags & 0x04)
 			vnc_connection_read_pixel(conn, fg);
 
-		vnc_framebuffer_fill(conn->fb, bg, x, y, width, height);
+		vnc_framebuffer_fill(priv->fb, bg, x, y, width, height);
 
 		/* AnySubrects */
 		if (flags & 0x08) {
@@ -1351,7 +1444,7 @@ static void vnc_connection_hextile_rect(VncConnection *conn,
 				xy = vnc_connection_read_u8(conn);
 				wh = vnc_connection_read_u8(conn);
 
-				vnc_framebuffer_fill(conn->fb, fg,
+				vnc_framebuffer_fill(priv->fb, fg,
 						     x + nibhi(xy), y + niblo(xy),
 						     nibhi(wh) + 1, niblo(wh) + 1);
 			}
@@ -1388,13 +1481,14 @@ static void vnc_connection_rre_update(VncConnection *conn,
 				      guint16 x, guint16 y,
 				      guint16 width, guint16 height)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	guint8 bg[4];
 	guint32 num;
 	guint32 i;
 
 	num = vnc_connection_read_u32(conn);
 	vnc_connection_read_pixel(conn, bg);
-	vnc_framebuffer_fill(conn->fb, bg, x, y, width, height);
+	vnc_framebuffer_fill(priv->fb, bg, x, y, width, height);
 
 	for (i = 0; i < num; i++) {
 		guint8 fg[4];
@@ -1406,7 +1500,7 @@ static void vnc_connection_rre_update(VncConnection *conn,
 		sub_w = vnc_connection_read_u16(conn);
 		sub_h = vnc_connection_read_u16(conn);
 
-		vnc_framebuffer_fill(conn->fb, fg,
+		vnc_framebuffer_fill(priv->fb, fg,
 				     x + sub_x, y + sub_y, sub_w, sub_h);
 	}
 }
@@ -1415,17 +1509,18 @@ static void vnc_connection_rre_update(VncConnection *conn,
  * values. */
 static void vnc_connection_read_cpixel(VncConnection *conn, guint8 *pixel)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	int bpp = vnc_connection_pixel_size(conn);
 
 	memset(pixel, 0, bpp);
 
-	if (bpp == 4 && conn->fmt.true_color_flag) {
-		int fitsInMSB = ((conn->fmt.red_shift > 7) &&
-				 (conn->fmt.green_shift > 7) &&
-				 (conn->fmt.blue_shift > 7));
-		int fitsInLSB = (((conn->fmt.red_max << conn->fmt.red_shift) < (1 << 24)) &&
-				 ((conn->fmt.green_max << conn->fmt.green_shift) < (1 << 24)) &&
-				 ((conn->fmt.blue_max << conn->fmt.blue_shift) < (1 << 24)));
+	if (bpp == 4 && priv->fmt.true_color_flag) {
+		int fitsInMSB = ((priv->fmt.red_shift > 7) &&
+				 (priv->fmt.green_shift > 7) &&
+				 (priv->fmt.blue_shift > 7));
+		int fitsInLSB = (((priv->fmt.red_max << priv->fmt.red_shift) < (1 << 24)) &&
+				 ((priv->fmt.green_max << priv->fmt.green_shift) < (1 << 24)) &&
+				 ((priv->fmt.blue_max << priv->fmt.blue_shift) < (1 << 24)));
 
 		/*
 		 * We need to analyse the shifts to see if they fit in 3 bytes,
@@ -1435,8 +1530,8 @@ static void vnc_connection_read_cpixel(VncConnection *conn, guint8 *pixel)
 		 */
 		if (fitsInMSB || fitsInLSB) {
 			bpp = 3;
-			if (conn->fmt.depth == 24 &&
-			    conn->fmt.byte_order == G_BIG_ENDIAN)
+			if (priv->fmt.depth == 24 &&
+			    priv->fmt.byte_order == G_BIG_ENDIAN)
 				pixel++;
 		}
 	}
@@ -1448,6 +1543,7 @@ static void vnc_connection_zrle_update_tile_blit(VncConnection *conn,
 						 guint16 x, guint16 y,
 						 guint16 width, guint16 height)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	guint8 blit_data[4 * 64 * 64];
 	int i, bpp;
 
@@ -1456,26 +1552,27 @@ static void vnc_connection_zrle_update_tile_blit(VncConnection *conn,
 	for (i = 0; i < width * height; i++)
 		vnc_connection_read_cpixel(conn, blit_data + (i * bpp));
 
-	vnc_framebuffer_blt(conn->fb, blit_data, width * bpp, x, y, width, height);
+	vnc_framebuffer_blt(priv->fb, blit_data, width * bpp, x, y, width, height);
 }
 
 static guint8 vnc_connection_read_zrle_pi(VncConnection *conn, int palette_size)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	guint8 pi = 0;
 
-	if (conn->zrle_pi_bits == 0) {
-		conn->zrle_pi = vnc_connection_read_u8(conn);
-		conn->zrle_pi_bits = 8;
+	if (priv->zrle_pi_bits == 0) {
+		priv->zrle_pi = vnc_connection_read_u8(conn);
+		priv->zrle_pi_bits = 8;
 	}
 	if ( palette_size == 2) {
-		pi = (conn->zrle_pi >> (conn->zrle_pi_bits - 1)) & 1;
-		conn->zrle_pi_bits -= 1;
+		pi = (priv->zrle_pi >> (priv->zrle_pi_bits - 1)) & 1;
+		priv->zrle_pi_bits -= 1;
 	} else if ((palette_size == 3) || (palette_size == 4)) {
-		pi = (conn->zrle_pi >> (conn->zrle_pi_bits - 2)) & 3;
-		conn->zrle_pi_bits -= 2;
+		pi = (priv->zrle_pi >> (priv->zrle_pi_bits - 2)) & 3;
+		priv->zrle_pi_bits -= 2;
 	} else if ((palette_size >=5) && (palette_size <=16)){
-		pi = (conn->zrle_pi >> (conn->zrle_pi_bits - 4)) & 15;
-		conn->zrle_pi_bits -= 4;
+		pi = (priv->zrle_pi >> (priv->zrle_pi_bits - 4)) & 15;
+		priv->zrle_pi_bits -= 4;
 	}
 
 	return pi;
@@ -1486,6 +1583,7 @@ static void vnc_connection_zrle_update_tile_palette(VncConnection *conn,
 						    guint16 x, guint16 y,
 						    guint16 width, guint16 height)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	guint8 palette[128][4];
 	int i, j;
 
@@ -1494,12 +1592,12 @@ static void vnc_connection_zrle_update_tile_palette(VncConnection *conn,
 
 	for (j = 0; j < height; j++) {
 		/* discard any padding bits */
-		conn->zrle_pi_bits = 0;
+		priv->zrle_pi_bits = 0;
 
 		for (i = 0; i < width; i++) {
 			int ind = vnc_connection_read_zrle_pi(conn, palette_size);
 
-			vnc_framebuffer_set_pixel_at(conn->fb, palette[ind & 0x7F],
+			vnc_framebuffer_set_pixel_at(priv->fb, palette[ind & 0x7F],
 						     x + i, y + j);
 		}
 	}
@@ -1522,6 +1620,7 @@ static void vnc_connection_zrle_update_tile_rle(VncConnection *conn,
 						guint16 x, guint16 y,
 						guint16 width, guint16 height)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	int i, j, rl = 0;
 	guint8 pixel[4];
 
@@ -1531,7 +1630,7 @@ static void vnc_connection_zrle_update_tile_rle(VncConnection *conn,
 				vnc_connection_read_cpixel(conn, pixel);
 				rl = vnc_connection_read_zrle_rl(conn);
 			}
-			vnc_framebuffer_set_pixel_at(conn->fb, pixel, x + i, y + j);
+			vnc_framebuffer_set_pixel_at(priv->fb, pixel, x + i, y + j);
 			rl -= 1;
 		}
 	}
@@ -1542,6 +1641,7 @@ static void vnc_connection_zrle_update_tile_prle(VncConnection *conn,
 						 guint16 x, guint16 y,
 						 guint16 width, guint16 height)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	int i, j, rl = 0;
 	guint8 palette[128][4];
 	guint8 pi = 0;
@@ -1560,7 +1660,7 @@ static void vnc_connection_zrle_update_tile_prle(VncConnection *conn,
 					rl = 1;
 			}
 
-			vnc_framebuffer_set_pixel_at(conn->fb, palette[pi], x + i, y + j);
+			vnc_framebuffer_set_pixel_at(priv->fb, palette[pi], x + i, y + j);
 			rl -= 1;
 		}
 	}
@@ -1569,6 +1669,7 @@ static void vnc_connection_zrle_update_tile_prle(VncConnection *conn,
 static void vnc_connection_zrle_update_tile(VncConnection *conn, guint16 x, guint16 y,
 					    guint16 width, guint16 height)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	guint8 subencoding = vnc_connection_read_u8(conn);
 	guint8 pixel[4];
 
@@ -1578,7 +1679,7 @@ static void vnc_connection_zrle_update_tile(VncConnection *conn, guint16 x, guin
 	} else if (subencoding == 1) {
 		/* Solid tile of a single color */
 		vnc_connection_read_cpixel(conn, pixel);
-		vnc_framebuffer_fill(conn->fb, pixel, x, y, width, height);
+		vnc_framebuffer_fill(priv->fb, pixel, x, y, width, height);
 	} else if ((subencoding >= 2) && (subencoding <= 16)) {
 		/* Packed palette types */
 		vnc_connection_zrle_update_tile_palette(conn, subencoding,
@@ -1601,6 +1702,7 @@ static void vnc_connection_zrle_update(VncConnection *conn,
 				       guint16 x, guint16 y,
 				       guint16 width, guint16 height)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	guint32 length;
 	guint32 offset;
 	guint16 i, j;
@@ -1611,10 +1713,10 @@ static void vnc_connection_zrle_update(VncConnection *conn,
 	vnc_connection_read(conn, zlib_data, length);
 
 	/* setup subsequent calls to vnc_connection_read*() to use the compressed data */
-	conn->uncompressed_length = 0;
-	conn->compressed_length = length;
-	conn->compressed_buffer = zlib_data;
-	conn->strm = &conn->streams[0];
+	priv->uncompressed_length = 0;
+	priv->compressed_length = length;
+	priv->compressed_buffer = zlib_data;
+	priv->strm = &priv->streams[0];
 
 	offset = 0;
 	for (j = 0; j < height; j += 64) {
@@ -1627,10 +1729,10 @@ static void vnc_connection_zrle_update(VncConnection *conn,
 		}
 	}
 
-	conn->strm = NULL;
-	conn->uncompressed_length = 0;
-	conn->compressed_length = 0;
-	conn->compressed_buffer = NULL;
+	priv->strm = NULL;
+	priv->uncompressed_length = 0;
+	priv->compressed_length = 0;
+	priv->compressed_buffer = NULL;
 
 	g_free(zlib_data);
 }
@@ -1658,21 +1760,25 @@ static guint32 vnc_connection_read_cint(VncConnection *conn)
 
 static int vnc_connection_tpixel_size(VncConnection *conn)
 {
-	if (conn->fmt.depth == 24)
+	VncConnectionPrivate *priv = conn->priv;
+
+	if (priv->fmt.depth == 24)
 		return 3;
-	return conn->fmt.bits_per_pixel / 8;
+	return priv->fmt.bits_per_pixel / 8;
 }
 
 static void vnc_connection_read_tpixel(VncConnection *conn, guint8 *pixel)
 {
-	if (conn->fmt.depth == 24) {
+	VncConnectionPrivate *priv = conn->priv;
+
+	if (priv->fmt.depth == 24) {
 		uint32_t val;
 		vnc_connection_read(conn, pixel, 3);
-		val = (pixel[0] << conn->fmt.red_shift)
-			| (pixel[1] << conn->fmt.green_shift)
-			| (pixel[2] << conn->fmt.blue_shift);
+		val = (pixel[0] << priv->fmt.red_shift)
+			| (pixel[1] << priv->fmt.green_shift)
+			| (pixel[2] << priv->fmt.blue_shift);
 
-		if (conn->fmt.byte_order != G_BYTE_ORDER)
+		if (priv->fmt.byte_order != G_BYTE_ORDER)
 			val =   (((val >>  0) & 0xFF) << 24) |
 				(((val >>  8) & 0xFF) << 16) |
 				(((val >> 16) & 0xFF) << 8) |
@@ -1687,13 +1793,14 @@ static void vnc_connection_tight_update_copy(VncConnection *conn,
 					     guint16 x, guint16 y,
 					     guint16 width, guint16 height)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	guint8 pixel[4];
 	int i, j;
 
 	for (j = 0; j < height; j++) {
 		for (i = 0; i < width; i++) {
 			vnc_connection_read_tpixel(conn, pixel);
-			vnc_framebuffer_set_pixel_at(conn->fb, pixel, x + i, y + j);
+			vnc_framebuffer_set_pixel_at(priv->fb, pixel, x + i, y + j);
 		}
 	}
 }
@@ -1715,6 +1822,7 @@ static void vnc_connection_tight_update_palette(VncConnection *conn,
 						guint16 x, guint16 y,
 						guint16 width, guint16 height)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	int i, j;
 
 	for (j = 0; j < height; j++) {
@@ -1724,7 +1832,7 @@ static void vnc_connection_tight_update_palette(VncConnection *conn,
 			guint8 ind;
 
 			ind = vnc_connection_tight_get_pi(conn, &ra, i, palette_size);
-			vnc_framebuffer_set_pixel_at(conn->fb, &palette[ind * 4], x + i, y + j);
+			vnc_framebuffer_set_pixel_at(priv->fb, &palette[ind * 4], x + i, y + j);
 		}
 	}
 }
@@ -1733,13 +1841,17 @@ static void vnc_connection_tight_compute_predicted(VncConnection *conn, guint8 *
 						   guint8 *lp, guint8 *cp,
 						   guint8 *llp)
 {
-	conn->tight_compute_predicted(conn, ppixel, lp, cp, llp);
+	VncConnectionPrivate *priv = conn->priv;
+
+	priv->tight_compute_predicted(conn, ppixel, lp, cp, llp);
 }
 
 static void vnc_connection_tight_sum_pixel(VncConnection *conn,
 					   guint8 *lhs, guint8 *rhs)
 {
-	conn->tight_sum_pixel(conn, lhs, rhs);
+	VncConnectionPrivate *priv = conn->priv;
+
+	priv->tight_sum_pixel(conn, lhs, rhs);
 }
 
 static void vnc_connection_tight_update_gradient(VncConnection *conn,
@@ -1750,6 +1862,7 @@ static void vnc_connection_tight_update_gradient(VncConnection *conn,
 	guint8 zero_pixel[4];
 	guint8 *last_row, *row;
 	int bpp;
+	VncConnectionPrivate *priv = conn->priv;
 
 	bpp = vnc_connection_pixel_size(conn);
 	last_row = g_malloc(width * bpp);
@@ -1787,7 +1900,7 @@ static void vnc_connection_tight_update_gradient(VncConnection *conn,
 		}
 
 		/* write out row of pixel data */
-		vnc_framebuffer_blt(conn->fb, row, width * bpp, x, y + j, width, 1);
+		vnc_framebuffer_blt(priv->fb, row, width * bpp, x, y + j, width, 1);
 
 		/* swap last row and current row */
 		tmp_row = last_row;
@@ -1803,18 +1916,21 @@ static void jpeg_draw(void *opaque, int x, int y, int w, int h,
 		      guint8 *data, int stride)
 {
 	VncConnection *conn = opaque;
+	VncConnectionPrivate *priv = conn->priv;
 
-	vnc_framebuffer_rgb24_blt(conn->fb, data, stride, x, y, w, h);
+	vnc_framebuffer_rgb24_blt(priv->fb, data, stride, x, y, w, h);
 }
 
 static void vnc_connection_tight_update_jpeg(VncConnection *conn, guint16 x, guint16 y,
 					     guint16 width, guint16 height,
 					     guint8 *data, size_t length)
 {
-	if (conn->ops.render_jpeg == NULL)
+	VncConnectionPrivate *priv = conn->priv;
+
+	if (priv->ops.render_jpeg == NULL)
 		return;
 
-	conn->ops.render_jpeg(conn->ops_data, jpeg_draw, conn,
+	priv->ops.render_jpeg(priv->ops_data, jpeg_draw, conn,
 			      x, y, width, height, data, length);
 }
 
@@ -1822,6 +1938,7 @@ static void vnc_connection_tight_update(VncConnection *conn,
 					guint16 x, guint16 y,
 					guint16 width, guint16 height)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	guint8 ccontrol;
 	guint8 pixel[4];
 	int i;
@@ -1830,8 +1947,8 @@ static void vnc_connection_tight_update(VncConnection *conn,
 
 	for (i = 0; i < 4; i++) {
 		if (ccontrol & (1 << i)) {
-			inflateEnd(&conn->streams[i + 1]);
-			inflateInit(&conn->streams[i + 1]);
+			inflateEnd(&priv->streams[i + 1]);
+			inflateInit(&priv->streams[i + 1]);
 		}
 	}
 
@@ -1849,7 +1966,7 @@ static void vnc_connection_tight_update(VncConnection *conn,
 		if (ccontrol & 0x04)
 			filter_id = vnc_connection_read_u8(conn);
 
-		conn->strm = &conn->streams[(ccontrol & 0x03) + 1];
+		priv->strm = &priv->streams[(ccontrol & 0x03) + 1];
 
 		if (filter_id == 1) {
 			palette_size = vnc_connection_read_u8(conn);
@@ -1872,9 +1989,9 @@ static void vnc_connection_tight_update(VncConnection *conn,
 
 			vnc_connection_read(conn, zlib_data, zlib_length);
 
-			conn->uncompressed_length = 0;
-			conn->compressed_length = zlib_length;
-			conn->compressed_buffer = zlib_data;
+			priv->uncompressed_length = 0;
+			priv->compressed_length = zlib_length;
+			priv->compressed_buffer = zlib_data;
 		}
 
 		switch (filter_id) {
@@ -1891,24 +2008,24 @@ static void vnc_connection_tight_update(VncConnection *conn,
 			break;
 		default: /* error */
 			GVNC_DEBUG("Closing the connection: vnc_connection_tight_update() - filter_id unknown");
-			conn->has_error = TRUE;
+			priv->has_error = TRUE;
 			break;
 		}
 
 		if (data_size >= 12) {
-			conn->uncompressed_length = 0;
-			conn->compressed_length = 0;
-			conn->compressed_buffer = NULL;
+			priv->uncompressed_length = 0;
+			priv->compressed_length = 0;
+			priv->compressed_buffer = NULL;
 
 			g_free(zlib_data);
 		}
 
-		conn->strm = NULL;
+		priv->strm = NULL;
 	} else if (ccontrol == 8) {
 		/* fill */
 		/* FIXME check each width; endianness */
 		vnc_connection_read_tpixel(conn, pixel);
-		vnc_framebuffer_fill(conn->fb, pixel, x, y, width, height);
+		vnc_framebuffer_fill(priv->fb, pixel, x, y, width, height);
 	} else if (ccontrol == 9) {
 		/* jpeg */
 		guint32 length;
@@ -1923,18 +2040,20 @@ static void vnc_connection_tight_update(VncConnection *conn,
 	} else {
 		/* error */
 		GVNC_DEBUG("Closing the connection: vnc_connection_tight_update() - ccontrol unknown");
-		conn->has_error = TRUE;
+		priv->has_error = TRUE;
 	}
 }
 
 static void vnc_connection_update(VncConnection *conn, int x, int y, int width, int height)
 {
-	if (conn->has_error || !conn->ops.update)
+	VncConnectionPrivate *priv = conn->priv;
+
+	if (priv->has_error || !priv->ops.update)
 		return;
 	GVNC_DEBUG("Notify update area (%dx%d) at location %d,%d", width, height, x, y);
-	if (!conn->ops.update(conn->ops_data, x, y, width, height)) {
+	if (!priv->ops.update(priv->ops_data, x, y, width, height)) {
 		GVNC_DEBUG("Closing the connection: vnc_connection_update");
-		conn->has_error = TRUE;
+		priv->has_error = TRUE;
 	}
 }
 
@@ -1942,72 +2061,84 @@ static void vnc_connection_set_color_map_entry(VncConnection *conn, guint16 colo
 					       guint16 red, guint16 green,
 					       guint16 blue)
 {
-	if (conn->has_error || !conn->ops.set_color_map_entry)
+	VncConnectionPrivate *priv = conn->priv;
+
+	if (priv->has_error || !priv->ops.set_color_map_entry)
 		return;
-	if (!conn->ops.set_color_map_entry(conn->ops_data, color,
+	if (!priv->ops.set_color_map_entry(priv->ops_data, color,
 					   red, green, blue)) {
 		GVNC_DEBUG("Closing the connection: vnc_connection_set_color_map_entry");
-		conn->has_error = TRUE;
+		priv->has_error = TRUE;
 	}
 }
 
 static void vnc_connection_bell(VncConnection *conn)
 {
-	if (conn->has_error || !conn->ops.bell)
+	VncConnectionPrivate *priv = conn->priv;
+
+	if (priv->has_error || !priv->ops.bell)
 		return;
 
 	GVNC_DEBUG("Server beep");
 
-	if (!conn->ops.bell(conn->ops_data)) {
+	if (!priv->ops.bell(priv->ops_data)) {
 		GVNC_DEBUG("Closing the connection: vnc_connection_bell");
-		conn->has_error = TRUE;
+		priv->has_error = TRUE;
 	}
 }
 
 static void vnc_connection_server_cut_text(VncConnection *conn, const void *data,
 					   size_t len)
 {
-	if (conn->has_error || !conn->ops.server_cut_text)
+	VncConnectionPrivate *priv = conn->priv;
+
+	if (priv->has_error || !priv->ops.server_cut_text)
 		return;
 
-	if (!conn->ops.server_cut_text(conn->ops_data, data, len)) {
+	if (!priv->ops.server_cut_text(priv->ops_data, data, len)) {
 		GVNC_DEBUG("Closing the connection: vnc_connection_server_cut_text");
-		conn->has_error = TRUE;
+		priv->has_error = TRUE;
 	}
 }
 
 static void vnc_connection_resize(VncConnection *conn, int width, int height)
 {
-	if (conn->has_error)
+	VncConnectionPrivate *priv = conn->priv;
+
+	if (priv->has_error)
 		return;
 
-	conn->width = width;
-	conn->height = height;
+	priv->width = width;
+	priv->height = height;
 
-	if (!conn->ops.resize)
+	if (!priv->ops.resize)
 		return;
 
-	if (!conn->ops.resize(conn->ops_data, width, height)) {
+	if (!priv->ops.resize(priv->ops_data, width, height)) {
 		GVNC_DEBUG("Closing the connection: vnc_connection_resize");
-		conn->has_error = TRUE;
+		priv->has_error = TRUE;
 	}
 }
 
 static void vnc_connection_pixel_format(VncConnection *conn)
 {
-        if (conn->has_error || !conn->ops.pixel_format)
+	VncConnectionPrivate *priv = conn->priv;
+
+        if (priv->has_error || !priv->ops.pixel_format)
                 return;
-        if (!conn->ops.pixel_format(conn->ops_data, &conn->fmt))
-                conn->has_error = TRUE;
+        if (!priv->ops.pixel_format(priv->ops_data, &priv->fmt))
+                priv->has_error = TRUE;
 }
 
 static void vnc_connection_pointer_type_change(VncConnection *conn, int absolute)
 {
-	if (conn->has_error || !conn->ops.pointer_type_change)
+	VncConnectionPrivate *priv = conn->priv;
+
+	if (priv->has_error || !priv->ops.pointer_type_change)
 		return;
-	if (!conn->ops.pointer_type_change(conn->ops_data, absolute)) {
+	if (!priv->ops.pointer_type_change(priv->ops_data, absolute)) {
 		GVNC_DEBUG("Closing the connection: vnc_connection_pointer_type_change");
-		conn->has_error = TRUE;
+		priv->has_error = TRUE;
 	}
 }
 
@@ -2015,18 +2146,21 @@ static void vnc_connection_rich_cursor_blt(VncConnection *conn, guint8 *pixbuf,
 					   guint8 *image, guint8 *mask,
 					   int pitch, guint16 width, guint16 height)
 {
-	conn->rich_cursor_blt(conn, pixbuf, image, mask, pitch, width, height);
+	VncConnectionPrivate *priv = conn->priv;
+
+	priv->rich_cursor_blt(conn, pixbuf, image, mask, pitch, width, height);
 }
 
 static void vnc_connection_rich_cursor(VncConnection *conn, int x, int y, int width, int height)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	guint8 *pixbuf = NULL;
 
 	if (width && height) {
 		guint8 *image, *mask;
 		int imagelen, masklen;
 
-		imagelen = width * height * (conn->fmt.bits_per_pixel / 8);
+		imagelen = width * height * (priv->fmt.bits_per_pixel / 8);
 		masklen = ((width + 7)/8) * height;
 
 		image = g_malloc(imagelen);
@@ -2037,18 +2171,18 @@ static void vnc_connection_rich_cursor(VncConnection *conn, int x, int y, int wi
 		vnc_connection_read(conn, mask, masklen);
 
 		vnc_connection_rich_cursor_blt(conn, pixbuf, image, mask,
-					       width * (conn->fmt.bits_per_pixel/8),
+					       width * (priv->fmt.bits_per_pixel/8),
 					       width, height);
 
 		g_free(image);
 		g_free(mask);
 	}
 
-	if (conn->has_error || !conn->ops.local_cursor)
+	if (priv->has_error || !priv->ops.local_cursor)
 		return;
-	if (!conn->ops.local_cursor(conn->ops_data, x, y, width, height, pixbuf)) {
+	if (!priv->ops.local_cursor(priv->ops_data, x, y, width, height, pixbuf)) {
 		GVNC_DEBUG("Closing the connection: vnc_connection_rich_cursor() - !ops.local_cursor()");
-		conn->has_error = TRUE;
+		priv->has_error = TRUE;
 	}
 
 	g_free(pixbuf);
@@ -2056,6 +2190,7 @@ static void vnc_connection_rich_cursor(VncConnection *conn, int x, int y, int wi
 
 static void vnc_connection_xcursor(VncConnection *conn, int x, int y, int width, int height)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	guint8 *pixbuf = NULL;
 
 	if (width && height) {
@@ -2092,11 +2227,11 @@ static void vnc_connection_xcursor(VncConnection *conn, int x, int y, int width,
 		g_free(mask);
 	}
 
-	if (conn->has_error || !conn->ops.local_cursor)
+	if (priv->has_error || !priv->ops.local_cursor)
 		return;
-	if (!conn->ops.local_cursor(conn->ops_data, x, y, width, height, pixbuf)) {
+	if (!priv->ops.local_cursor(priv->ops_data, x, y, width, height, pixbuf)) {
 		GVNC_DEBUG("Closing the connection: vnc_connection_xcursor() - !ops.local_cursor()");
-		conn->has_error = TRUE;
+		priv->has_error = TRUE;
 	}
 
 	g_free(pixbuf);
@@ -2104,14 +2239,18 @@ static void vnc_connection_xcursor(VncConnection *conn, int x, int y, int width,
 
 static void vnc_connection_ext_key_event(VncConnection *conn)
 {
-	conn->has_ext_key_event = TRUE;
-	conn->keycode_map = x_keycode_to_pc_keycode_map();
+	VncConnectionPrivate *priv = conn->priv;
+
+	priv->has_ext_key_event = TRUE;
+	priv->keycode_map = x_keycode_to_pc_keycode_map();
 }
 
 static void vnc_connection_framebuffer_update(VncConnection *conn, gint32 etype,
 					      guint16 x, guint16 y,
 					      guint16 width, guint16 height)
 {
+	VncConnectionPrivate *priv = conn->priv;
+
 	GVNC_DEBUG("FramebufferUpdate type=%d area (%dx%d) at location %d,%d",
 		   etype, width, height, x, y);
 
@@ -2148,7 +2287,7 @@ static void vnc_connection_framebuffer_update(VncConnection *conn, gint32 etype,
 		vnc_connection_pointer_type_change(conn, x);
 		break;
         case GVNC_ENCODING_WMVi:
-                vnc_connection_read_pixel_format(conn, &conn->fmt);
+                vnc_connection_read_pixel_format(conn, &priv->fmt);
                 vnc_connection_pixel_format(conn);
                 break;
 	case GVNC_ENCODING_RICH_CURSOR:
@@ -2162,13 +2301,14 @@ static void vnc_connection_framebuffer_update(VncConnection *conn, gint32 etype,
 		break;
 	default:
 		GVNC_DEBUG("Received an unknown encoding type: %d", etype);
-		conn->has_error = TRUE;
+		priv->has_error = TRUE;
 		break;
 	}
 }
 
 gboolean vnc_connection_server_message(VncConnection *conn)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	guint8 msg;
 	int ret;
 
@@ -2176,10 +2316,10 @@ gboolean vnc_connection_server_message(VncConnection *conn)
 	   handle has_error appropriately */
 
 	do {
-		if (conn->xmit_buffer_size) {
-			vnc_connection_write(conn, conn->xmit_buffer, conn->xmit_buffer_size);
+		if (priv->xmit_buffer_size) {
+			vnc_connection_write(conn, priv->xmit_buffer, priv->xmit_buffer_size);
 			vnc_connection_flush(conn);
-			conn->xmit_buffer_size = 0;
+			priv->xmit_buffer_size = 0;
 		}
 	} while ((ret = vnc_connection_read_u8_interruptable(conn, &msg)) == -EAGAIN);
 
@@ -2243,14 +2383,14 @@ gboolean vnc_connection_server_message(VncConnection *conn)
 		n_text = vnc_connection_read_u32(conn);
 		if (n_text > (32 << 20)) {
 			GVNC_DEBUG("Closing the connection: vnc_connection_server_message() - cutText > allowed");
-			conn->has_error = TRUE;
+			priv->has_error = TRUE;
 			break;
 		}
 
 		data = g_new(char, n_text + 1);
 		if (data == NULL) {
 			GVNC_DEBUG("Closing the connection: vnc_connection_server_message() - cutText - !data");
-			conn->has_error = TRUE;
+			priv->has_error = TRUE;
 			break;
 		}
 
@@ -2262,7 +2402,7 @@ gboolean vnc_connection_server_message(VncConnection *conn)
 	}	break;
 	default:
 		GVNC_DEBUG("Received an unknown message: %u", msg);
-		conn->has_error = TRUE;
+		priv->has_error = TRUE;
 		break;
 	}
 
@@ -2271,28 +2411,35 @@ gboolean vnc_connection_server_message(VncConnection *conn)
 
 gboolean vnc_connection_wants_credential_password(VncConnection *conn)
 {
-	return conn->want_cred_password;
+	VncConnectionPrivate *priv = conn->priv;
+
+	return priv->want_cred_password;
 }
 
 gboolean vnc_connection_wants_credential_username(VncConnection *conn)
 {
-	return conn->want_cred_username;
+	VncConnectionPrivate *priv = conn->priv;
+
+	return priv->want_cred_username;
 }
 
 gboolean vnc_connection_wants_credential_x509(VncConnection *conn)
 {
-	return conn->want_cred_x509;
+	VncConnectionPrivate *priv = conn->priv;
+
+	return priv->want_cred_x509;
 }
 
 static gboolean vnc_connection_has_credentials(gpointer data)
 {
 	VncConnection *conn = data;
+	VncConnectionPrivate *priv = conn->priv;
 
-	if (conn->has_error)
+	if (priv->has_error)
 		return TRUE;
-	if (vnc_connection_wants_credential_username(conn) && !conn->cred_username)
+	if (vnc_connection_wants_credential_username(conn) && !priv->cred_username)
 		return FALSE;
-	if (vnc_connection_wants_credential_password(conn) && !conn->cred_password)
+	if (vnc_connection_wants_credential_password(conn) && !priv->cred_password)
 		return FALSE;
 	/*
 	 * For x509 we require a minimum of the CA cert.
@@ -2302,22 +2449,24 @@ static gboolean vnc_connection_has_credentials(gpointer data)
 	 * alone though - we'll merely find out when TLS
 	 * negotiation takes place.
 	 */
-	if (vnc_connection_wants_credential_x509(conn) && !conn->cred_x509_cacert)
+	if (vnc_connection_wants_credential_x509(conn) && !priv->cred_x509_cacert)
 		return FALSE;
 	return TRUE;
 }
 
 static gboolean vnc_connection_gather_credentials(VncConnection *conn)
 {
+	VncConnectionPrivate *priv = conn->priv;
+
 	if (!vnc_connection_has_credentials(conn)) {
 		GVNC_DEBUG("Requesting missing credentials");
-		if (conn->has_error || !conn->ops.auth_cred) {
-			conn->has_error = TRUE;
+		if (priv->has_error || !priv->ops.auth_cred) {
+			priv->has_error = TRUE;
 			return FALSE;
 		}
-		if (!conn->ops.auth_cred(conn->ops_data))
-			conn->has_error = TRUE;
-		if (conn->has_error)
+		if (!priv->ops.auth_cred(priv->ops_data))
+			priv->has_error = TRUE;
+		if (priv->has_error)
 			return FALSE;
 		GVNC_DEBUG("Waiting for missing credentials");
 		g_condition_wait(vnc_connection_has_credentials, conn);
@@ -2329,7 +2478,9 @@ static gboolean vnc_connection_gather_credentials(VncConnection *conn)
 
 static gboolean vnc_connection_check_auth_result(VncConnection *conn)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	guint32 result;
+
 	GVNC_DEBUG("Checking auth result");
 	result = vnc_connection_read_u32(conn);
 	if (!result) {
@@ -2337,7 +2488,7 @@ static gboolean vnc_connection_check_auth_result(VncConnection *conn)
 		return TRUE;
 	}
 
-	if (conn->minor >= 8) {
+	if (priv->minor >= 8) {
 		guint32 len;
 		char reason[1024];
 		len = vnc_connection_read_u32(conn);
@@ -2346,35 +2497,36 @@ static gboolean vnc_connection_check_auth_result(VncConnection *conn)
 		vnc_connection_read(conn, reason, len);
 		reason[len] = '\0';
 		GVNC_DEBUG("Fail %s", reason);
-		if (!conn->has_error && conn->ops.auth_failure)
-			conn->ops.auth_failure(conn->ops_data, reason);
+		if (!priv->has_error && priv->ops.auth_failure)
+			priv->ops.auth_failure(priv->ops_data, reason);
 	} else {
 		GVNC_DEBUG("Fail auth no result");
-		if (!conn->has_error && conn->ops.auth_failure)
-			conn->ops.auth_failure(conn->ops_data, NULL);
+		if (!priv->has_error && priv->ops.auth_failure)
+			priv->ops.auth_failure(priv->ops_data, NULL);
 	}
 	return FALSE;
 }
 
 static gboolean vnc_connection_perform_auth_vnc(VncConnection *conn)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	guint8 challenge[16];
 	guint8 key[8];
 
 	GVNC_DEBUG("Do Challenge");
-	conn->want_cred_password = TRUE;
-	conn->want_cred_username = FALSE;
-	conn->want_cred_x509 = FALSE;
+	priv->want_cred_password = TRUE;
+	priv->want_cred_username = FALSE;
+	priv->want_cred_x509 = FALSE;
 	if (!vnc_connection_gather_credentials(conn))
 		return FALSE;
 
-	if (!conn->cred_password)
+	if (!priv->cred_password)
 		return FALSE;
 
 	vnc_connection_read(conn, challenge, 16);
 
 	memset(key, 0, 8);
-	strncpy((char*)key, (char*)conn->cred_password, 8);
+	strncpy((char*)key, (char*)priv->cred_password, 8);
 
 	deskey(key, EN0);
 	des(challenge, challenge);
@@ -2391,7 +2543,8 @@ static gboolean vnc_connection_perform_auth_vnc(VncConnection *conn)
  *   Key has to be 8 bytes, length a multiple of 8 bytes.
  */
 static void
-vncEncryptBytes2(unsigned char *where, const int length, unsigned char *key) {
+vncEncryptBytes2(unsigned char *where, const int length, unsigned char *key)
+{
 	int i, j;
 	deskey(key, EN0);
 	for (i = 0; i< 8; i++)
@@ -2406,6 +2559,7 @@ vncEncryptBytes2(unsigned char *where, const int length, unsigned char *key) {
 
 static gboolean vnc_connection_perform_auth_mslogon(VncConnection *conn)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	struct vnc_dh *dh;
 	guchar gen[8], mod[8], resp[8], pub[8], key[8];
 	gcry_mpi_t genmpi, modmpi, respmpi, pubmpi, keympi;
@@ -2413,9 +2567,9 @@ static gboolean vnc_connection_perform_auth_mslogon(VncConnection *conn)
 	guint passwordLen, usernameLen;
 
 	GVNC_DEBUG("Do Challenge");
-	conn->want_cred_password = TRUE;
-	conn->want_cred_username = TRUE;
-	conn->want_cred_x509 = FALSE;
+	priv->want_cred_password = TRUE;
+	priv->want_cred_username = TRUE;
+	priv->want_cred_x509 = FALSE;
 	if (!vnc_connection_gather_credentials(conn))
 		return FALSE;
 
@@ -2437,8 +2591,8 @@ static gboolean vnc_connection_perform_auth_mslogon(VncConnection *conn)
 	keympi = vnc_dh_gen_key(dh, respmpi);
 	vnc_mpi_to_bytes(keympi, key);
 
-	passwordLen = strlen(conn->cred_password);
-	usernameLen = strlen(conn->cred_username);
+	passwordLen = strlen(priv->cred_password);
+	usernameLen = strlen(priv->cred_username);
 	if (passwordLen > sizeof(password))
 		passwordLen = sizeof(password);
 	if (usernameLen > sizeof(username))
@@ -2446,8 +2600,8 @@ static gboolean vnc_connection_perform_auth_mslogon(VncConnection *conn)
 
 	memset(password, 0, sizeof password);
 	memset(username, 0, sizeof username);
-	memcpy(password, conn->cred_password, passwordLen);
-	memcpy(username, conn->cred_username, usernameLen);
+	memcpy(password, priv->cred_password, passwordLen);
+	memcpy(username, priv->cred_username, usernameLen);
 
 	vncEncryptBytes2(username, sizeof(username), key);
 	vncEncryptBytes2(password, sizeof(password), key);
@@ -2496,21 +2650,22 @@ static gboolean
 vnc_connection_gather_sasl_credentials(VncConnection *conn,
 				       sasl_interact_t *interact)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	int ninteract;
 
-	conn->want_cred_password = FALSE;
-	conn->want_cred_username = FALSE;
-	conn->want_cred_x509 = FALSE;
+	priv->want_cred_password = FALSE;
+	priv->want_cred_username = FALSE;
+	priv->want_cred_x509 = FALSE;
 
 	for (ninteract = 0 ; interact[ninteract].id != 0 ; ninteract++) {
 		switch (interact[ninteract].id) {
 		case SASL_CB_AUTHNAME:
 		case SASL_CB_USER:
-			conn->want_cred_username = TRUE;
+			priv->want_cred_username = TRUE;
 			break;
 
 		case SASL_CB_PASS:
-			conn->want_cred_password = TRUE;
+			priv->want_cred_password = TRUE;
 			break;
 
 		default:
@@ -2521,8 +2676,8 @@ vnc_connection_gather_sasl_credentials(VncConnection *conn,
 		}
 	}
 
-	if ((conn->want_cred_password ||
-	     conn->want_cred_username) &&
+	if ((priv->want_cred_password ||
+	     priv->want_cred_username) &&
 	    !vnc_connection_gather_credentials(conn)) {
 		GVNC_DEBUG("%s", "cannot gather sasl credentials");
 		return FALSE;
@@ -2532,15 +2687,15 @@ vnc_connection_gather_sasl_credentials(VncConnection *conn,
 		switch (interact[ninteract].id) {
 		case SASL_CB_AUTHNAME:
 		case SASL_CB_USER:
-			interact[ninteract].result = conn->cred_username;
-			interact[ninteract].len = strlen(conn->cred_username);
-			GVNC_DEBUG("Gather Username %s", conn->cred_username);
+			interact[ninteract].result = priv->cred_username;
+			interact[ninteract].len = strlen(priv->cred_username);
+			GVNC_DEBUG("Gather Username %s", priv->cred_username);
 			break;
 
 		case SASL_CB_PASS:
-			interact[ninteract].result =  conn->cred_password;
-			interact[ninteract].len = strlen(conn->cred_password);
-			//GVNC_DEBUG("Gather Password %s", conn->cred_password);
+			interact[ninteract].result =  priv->cred_password;
+			interact[ninteract].len = strlen(priv->cred_password);
+			//GVNC_DEBUG("Gather Password %s", priv->cred_password);
 			break;
 		}
 	}
@@ -2592,6 +2747,7 @@ vnc_connection_gather_sasl_credentials(VncConnection *conn,
  */
 static gboolean vnc_connection_perform_auth_sasl(VncConnection *conn)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	sasl_conn_t *saslconn = NULL;
 	sasl_security_properties_t secprops;
 	const char *clientout;
@@ -2626,7 +2782,7 @@ static gboolean vnc_connection_perform_auth_sasl(VncConnection *conn)
 
 	/* Get local address in form  IPADDR:PORT */
 	salen = sizeof(sa);
-	if (getsockname(conn->fd, (struct sockaddr*)&sa, &salen) < 0) {
+	if (getsockname(priv->fd, (struct sockaddr*)&sa, &salen) < 0) {
 		GVNC_DEBUG("failed to get sock address %d (%s)",
 			   errno, strerror(errno));
 		goto error;
@@ -2638,7 +2794,7 @@ static gboolean vnc_connection_perform_auth_sasl(VncConnection *conn)
 
 	/* Get remote address in form  IPADDR:PORT */
 	salen = sizeof(sa);
-	if (getpeername(conn->fd, (struct sockaddr*)&sa, &salen) < 0) {
+	if (getpeername(priv->fd, (struct sockaddr*)&sa, &salen) < 0) {
 		GVNC_DEBUG("failed to get peer address %d (%s)",
 			   errno, strerror(errno));
 		g_free(localAddr);
@@ -2651,11 +2807,11 @@ static gboolean vnc_connection_perform_auth_sasl(VncConnection *conn)
 		goto error;
 	}
 
-	GVNC_DEBUG("Client SASL new host:'%s' local:'%s' remote:'%s'", conn->host, localAddr, remoteAddr);
+	GVNC_DEBUG("Client SASL new host:'%s' local:'%s' remote:'%s'", priv->host, localAddr, remoteAddr);
 
 	/* Setup a handle for being a client */
 	err = sasl_client_new("vnc",
-			      conn->host,
+			      priv->host,
 			      localAddr,
 			      remoteAddr,
 			      saslcb,
@@ -2671,10 +2827,10 @@ static gboolean vnc_connection_perform_auth_sasl(VncConnection *conn)
 	}
 
 	/* Initialize some connection props we care about */
-	if (conn->tls_session) {
+	if (priv->tls_session) {
 		gnutls_cipher_algorithm_t cipher;
 
-		cipher = gnutls_cipher_get(conn->tls_session);
+		cipher = gnutls_cipher_get(priv->tls_session);
 		if (!(ssf = (sasl_ssf_t)gnutls_cipher_get_key_size(cipher))) {
 			GVNC_DEBUG("%s", "invalid cipher size for TLS session");
 			goto error;
@@ -2692,11 +2848,11 @@ static gboolean vnc_connection_perform_auth_sasl(VncConnection *conn)
 
 	memset (&secprops, 0, sizeof secprops);
 	/* If we've got TLS, we don't care about SSF */
-	secprops.min_ssf = conn->tls_session ? 0 : 56; /* Equiv to DES supported by all Kerberos */
-	secprops.max_ssf = conn->tls_session ? 0 : 100000; /* Very strong ! AES == 256 */
+	secprops.min_ssf = priv->tls_session ? 0 : 56; /* Equiv to DES supported by all Kerberos */
+	secprops.max_ssf = priv->tls_session ? 0 : 100000; /* Very strong ! AES == 256 */
 	secprops.maxbufsize = 100000;
 	/* If we're not TLS, then forbid any anonymous or trivially crackable auth */
-	secprops.security_flags = conn->tls_session ? 0 :
+	secprops.security_flags = priv->tls_session ? 0 :
 		SASL_SEC_NOANONYMOUS | SASL_SEC_NOPLAINTEXT;
 
 	err = sasl_setprop(saslconn, SASL_SEC_PROPS, &secprops);
@@ -2708,7 +2864,7 @@ static gboolean vnc_connection_perform_auth_sasl(VncConnection *conn)
 
 	/* Get the supported mechanisms from the server */
 	mechlistlen = vnc_connection_read_u32(conn);
-	if (conn->has_error)
+	if (priv->has_error)
 		goto error;
 	if (mechlistlen > SASL_MAX_MECHLIST_LEN) {
 		GVNC_DEBUG("mechlistlen %d too long", mechlistlen);
@@ -2718,7 +2874,7 @@ static gboolean vnc_connection_perform_auth_sasl(VncConnection *conn)
 	mechlist = g_malloc(mechlistlen+1);
         vnc_connection_read(conn, mechlist, mechlistlen);
 	mechlist[mechlistlen] = '\0';
-	if (conn->has_error) {
+	if (priv->has_error) {
 		g_free(mechlist);
 		mechlist = NULL;
 		goto error;
@@ -2784,14 +2940,14 @@ static gboolean vnc_connection_perform_auth_sasl(VncConnection *conn)
 		vnc_connection_write_u32(conn, 0);
 	}
 	vnc_connection_flush(conn);
-	if (conn->has_error)
+	if (priv->has_error)
 		goto error;
 
 
 	GVNC_DEBUG("%s", "Getting sever start negotiation reply");
 	/* Read the 'START' message reply from server */
 	serverinlen = vnc_connection_read_u32(conn);
-	if (conn->has_error)
+	if (priv->has_error)
 		goto error;
 	if (serverinlen > SASL_MAX_DATA_LEN) {
 		GVNC_DEBUG("SASL negotiation data too long: %d bytes",
@@ -2809,7 +2965,7 @@ static gboolean vnc_connection_perform_auth_sasl(VncConnection *conn)
 		serverin = NULL;
 	}
 	complete = vnc_connection_read_u8(conn);
-	if (conn->has_error)
+	if (priv->has_error)
 		goto error;
 
 	GVNC_DEBUG("Client start result complete: %d. Data %d bytes %p '%s'",
@@ -2863,13 +3019,13 @@ static gboolean vnc_connection_perform_auth_sasl(VncConnection *conn)
 			vnc_connection_write_u32(conn, 0);
 		}
 		vnc_connection_flush(conn);
-		if (conn->has_error)
+		if (priv->has_error)
 			goto error;
 
 		GVNC_DEBUG("Server step with %d bytes %p", clientoutlen, clientout);
 
 		serverinlen = vnc_connection_read_u32(conn);
-		if (conn->has_error)
+		if (priv->has_error)
 			goto error;
 		if (serverinlen > SASL_MAX_DATA_LEN) {
 			GVNC_DEBUG("SASL negotiation data too long: %d bytes",
@@ -2887,7 +3043,7 @@ static gboolean vnc_connection_perform_auth_sasl(VncConnection *conn)
 			serverin = NULL;
 		}
 		complete = vnc_connection_read_u8(conn);
-		if (conn->has_error)
+		if (priv->has_error)
 			goto error;
 
 		GVNC_DEBUG("Client step result complete: %d. Data %d bytes %p '%s'",
@@ -2902,7 +3058,7 @@ static gboolean vnc_connection_perform_auth_sasl(VncConnection *conn)
 	}
 
 	/* Check for suitable SSF if non-TLS */
-	if (!conn->tls_session) {
+	if (!priv->tls_session) {
 		err = sasl_getprop(saslconn, SASL_SSF, &val);
 		if (err != SASL_OK) {
 			GVNC_DEBUG("cannot query SASL ssf on connection %d (%s)",
@@ -2922,11 +3078,11 @@ static gboolean vnc_connection_perform_auth_sasl(VncConnection *conn)
 	/* This must come *after* check-auth-result, because the former
 	 * is defined to be sent unencrypted, and setting saslconn turns
 	 * on the SSF layer encryption processing */
-	conn->saslconn = saslconn;
+	priv->saslconn = saslconn;
 	return ret;
 
  error:
-	conn->has_error = TRUE;
+	priv->has_error = TRUE;
 	if (saslconn)
 		sasl_dispose(&saslconn);
 	return FALSE;
@@ -2936,6 +3092,7 @@ static gboolean vnc_connection_perform_auth_sasl(VncConnection *conn)
 
 static gboolean vnc_connection_start_tls(VncConnection *conn, int anonTLS)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	static const int cert_type_priority[] = { GNUTLS_CRT_X509, 0 };
 	static const int protocol_priority[]= { GNUTLS_TLS1_1, GNUTLS_TLS1_0, GNUTLS_SSL3, 0 };
 	static const int kx_priority[] = {GNUTLS_KX_DHE_DSS, GNUTLS_KX_RSA, GNUTLS_KX_DHE_RSA, GNUTLS_KX_SRP, 0};
@@ -2945,90 +3102,90 @@ static gboolean vnc_connection_start_tls(VncConnection *conn, int anonTLS)
 	GVNC_DEBUG("Do TLS handshake");
 	if (vnc_connection_tls_initialize() < 0) {
 		GVNC_DEBUG("Failed to init TLS");
-		conn->has_error = TRUE;
+		priv->has_error = TRUE;
 		return FALSE;
 	}
-	if (conn->tls_session == NULL) {
-		if (gnutls_init(&conn->tls_session, GNUTLS_CLIENT) < 0) {
-			conn->has_error = TRUE;
+	if (priv->tls_session == NULL) {
+		if (gnutls_init(&priv->tls_session, GNUTLS_CLIENT) < 0) {
+			priv->has_error = TRUE;
 			return FALSE;
 		}
 
-		if (gnutls_set_default_priority(conn->tls_session) < 0) {
-			gnutls_deinit(conn->tls_session);
-			conn->has_error = TRUE;
+		if (gnutls_set_default_priority(priv->tls_session) < 0) {
+			gnutls_deinit(priv->tls_session);
+			priv->has_error = TRUE;
 			return FALSE;
 		}
 
-		if (gnutls_kx_set_priority(conn->tls_session, anonTLS ? kx_anon : kx_priority) < 0) {
-			gnutls_deinit(conn->tls_session);
-			conn->has_error = TRUE;
+		if (gnutls_kx_set_priority(priv->tls_session, anonTLS ? kx_anon : kx_priority) < 0) {
+			gnutls_deinit(priv->tls_session);
+			priv->has_error = TRUE;
 			return FALSE;
 		}
 
-		if (gnutls_certificate_type_set_priority(conn->tls_session, cert_type_priority) < 0) {
-			gnutls_deinit(conn->tls_session);
-			conn->has_error = TRUE;
+		if (gnutls_certificate_type_set_priority(priv->tls_session, cert_type_priority) < 0) {
+			gnutls_deinit(priv->tls_session);
+			priv->has_error = TRUE;
 			return FALSE;
 		}
 
-		if (gnutls_protocol_set_priority(conn->tls_session, protocol_priority) < 0) {
-			gnutls_deinit(conn->tls_session);
-			conn->has_error = TRUE;
+		if (gnutls_protocol_set_priority(priv->tls_session, protocol_priority) < 0) {
+			gnutls_deinit(priv->tls_session);
+			priv->has_error = TRUE;
 			return FALSE;
 		}
 
 		if (anonTLS) {
 			gnutls_anon_client_credentials anon_cred = vnc_connection_tls_initialize_anon_cred();
 			if (!anon_cred) {
-				gnutls_deinit(conn->tls_session);
-				conn->has_error = TRUE;
+				gnutls_deinit(priv->tls_session);
+				priv->has_error = TRUE;
 				return FALSE;
 			}
-			if (gnutls_credentials_set(conn->tls_session, GNUTLS_CRD_ANON, anon_cred) < 0) {
-				gnutls_deinit(conn->tls_session);
-				conn->has_error = TRUE;
+			if (gnutls_credentials_set(priv->tls_session, GNUTLS_CRD_ANON, anon_cred) < 0) {
+				gnutls_deinit(priv->tls_session);
+				priv->has_error = TRUE;
 				return FALSE;
 			}
 		} else {
-			conn->want_cred_password = FALSE;
-			conn->want_cred_username = FALSE;
-			conn->want_cred_x509 = TRUE;
+			priv->want_cred_password = FALSE;
+			priv->want_cred_username = FALSE;
+			priv->want_cred_x509 = TRUE;
 			if (!vnc_connection_gather_credentials(conn))
 				return FALSE;
 
 			gnutls_certificate_credentials_t x509_cred = vnc_connection_tls_initialize_cert_cred(conn);
 			if (!x509_cred) {
-				gnutls_deinit(conn->tls_session);
-				conn->has_error = TRUE;
+				gnutls_deinit(priv->tls_session);
+				priv->has_error = TRUE;
 				return FALSE;
 			}
-			if (gnutls_credentials_set(conn->tls_session, GNUTLS_CRD_CERTIFICATE, x509_cred) < 0) {
-				gnutls_deinit(conn->tls_session);
-				conn->has_error = TRUE;
+			if (gnutls_credentials_set(priv->tls_session, GNUTLS_CRD_CERTIFICATE, x509_cred) < 0) {
+				gnutls_deinit(priv->tls_session);
+				priv->has_error = TRUE;
 				return FALSE;
 			}
 		}
 
-		gnutls_transport_set_ptr(conn->tls_session, (gnutls_transport_ptr_t)conn);
-		gnutls_transport_set_push_function(conn->tls_session, vnc_connection_tls_push);
-		gnutls_transport_set_pull_function(conn->tls_session, vnc_connection_tls_pull);
+		gnutls_transport_set_ptr(priv->tls_session, (gnutls_transport_ptr_t)conn);
+		gnutls_transport_set_push_function(priv->tls_session, vnc_connection_tls_push);
+		gnutls_transport_set_pull_function(priv->tls_session, vnc_connection_tls_pull);
 	}
 
  retry:
-	if ((ret = gnutls_handshake(conn->tls_session)) < 0) {
+	if ((ret = gnutls_handshake(priv->tls_session)) < 0) {
 		if (!gnutls_error_is_fatal(ret)) {
 			GVNC_DEBUG("Handshake was blocking");
-			if (!gnutls_record_get_direction(conn->tls_session))
-				g_io_wait(conn->channel, G_IO_IN);
+			if (!gnutls_record_get_direction(priv->tls_session))
+				g_io_wait(priv->channel, G_IO_IN);
 			else
-				g_io_wait(conn->channel, G_IO_OUT);
+				g_io_wait(priv->channel, G_IO_OUT);
 			goto retry;
 		}
 		GVNC_DEBUG("Handshake failed %s", gnutls_strerror(ret));
-		gnutls_deinit(conn->tls_session);
-		conn->tls_session = NULL;
-		conn->has_error = TRUE;
+		gnutls_deinit(priv->tls_session);
+		priv->tls_session = NULL;
+		priv->has_error = TRUE;
 		return FALSE;
 	}
 
@@ -3039,7 +3196,7 @@ static gboolean vnc_connection_start_tls(VncConnection *conn, int anonTLS)
 	} else {
 		if (!vnc_connection_validate_certificate(conn)) {
 			GVNC_DEBUG("Certificate validation failed");
-			conn->has_error = TRUE;
+			priv->has_error = TRUE;
 			return FALSE;
 		}
 		return TRUE;
@@ -3049,10 +3206,11 @@ static gboolean vnc_connection_start_tls(VncConnection *conn, int anonTLS)
 static gboolean vnc_connection_has_auth_subtype(gpointer data)
 {
 	VncConnection *conn = data;
+	VncConnectionPrivate *priv = conn->priv;
 
-	if (conn->has_error)
+	if (priv->has_error)
 		return TRUE;
-	if (conn->auth_subtype == GVNC_AUTH_INVALID)
+	if (priv->auth_subtype == GVNC_AUTH_INVALID)
 		return FALSE;
 	return TRUE;
 }
@@ -3060,6 +3218,7 @@ static gboolean vnc_connection_has_auth_subtype(gpointer data)
 
 static gboolean vnc_connection_perform_auth_tls(VncConnection *conn)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	unsigned int nauth, i;
 	unsigned int auth[20];
 
@@ -3082,7 +3241,7 @@ static gboolean vnc_connection_perform_auth_tls(VncConnection *conn)
 
 	if (nauth > sizeof(auth)) {
 		GVNC_DEBUG("Too many (%d) auth types", nauth);
-		conn->has_error = TRUE;
+		priv->has_error = TRUE;
 		return FALSE;
 	}
 	for (i = 0 ; i < nauth ; i++) {
@@ -3093,27 +3252,27 @@ static gboolean vnc_connection_perform_auth_tls(VncConnection *conn)
 		GVNC_DEBUG("Possible sub-auth %d", auth[i]);
 	}
 
-	if (conn->has_error || !conn->ops.auth_subtype)
+	if (priv->has_error || !priv->ops.auth_subtype)
 		return FALSE;
 
-	if (!conn->ops.auth_subtype(conn->ops_data, nauth, auth))
-		conn->has_error = TRUE;
-	if (conn->has_error)
+	if (!priv->ops.auth_subtype(priv->ops_data, nauth, auth))
+		priv->has_error = TRUE;
+	if (priv->has_error)
 		return FALSE;
 
 	GVNC_DEBUG("Waiting for auth subtype");
 	g_condition_wait(vnc_connection_has_auth_subtype, conn);
-	if (conn->has_error)
+	if (priv->has_error)
 		return FALSE;
 
-	GVNC_DEBUG("Choose auth %d", conn->auth_subtype);
+	GVNC_DEBUG("Choose auth %d", priv->auth_subtype);
 
-	vnc_connection_write_u8(conn, conn->auth_subtype);
+	vnc_connection_write_u8(conn, priv->auth_subtype);
 	vnc_connection_flush(conn);
 
-	switch (conn->auth_subtype) {
+	switch (priv->auth_subtype) {
 	case GVNC_AUTH_NONE:
-		if (conn->minor == 8)
+		if (priv->minor == 8)
 			return vnc_connection_check_auth_result(conn);
 		return TRUE;
 	case GVNC_AUTH_VNC:
@@ -3131,6 +3290,7 @@ static gboolean vnc_connection_perform_auth_tls(VncConnection *conn)
 
 static gboolean vnc_connection_perform_auth_vencrypt(VncConnection *conn)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	int major, minor, status, anonTLS;
 	unsigned int nauth, i;
 	unsigned int auth[20];
@@ -3167,40 +3327,40 @@ static gboolean vnc_connection_perform_auth_vencrypt(VncConnection *conn)
 		GVNC_DEBUG("Possible auth %d", auth[i]);
 	}
 
-	if (conn->has_error || !conn->ops.auth_subtype)
+	if (priv->has_error || !priv->ops.auth_subtype)
 		return FALSE;
 
-	if (!conn->ops.auth_subtype(conn->ops_data, nauth, auth))
-		conn->has_error = TRUE;
-	if (conn->has_error)
+	if (!priv->ops.auth_subtype(priv->ops_data, nauth, auth))
+		priv->has_error = TRUE;
+	if (priv->has_error)
 		return FALSE;
 
 	GVNC_DEBUG("Waiting for auth subtype");
 	g_condition_wait(vnc_connection_has_auth_subtype, conn);
-	if (conn->has_error)
+	if (priv->has_error)
 		return FALSE;
 
-	GVNC_DEBUG("Choose auth %d", conn->auth_subtype);
+	GVNC_DEBUG("Choose auth %d", priv->auth_subtype);
 
 	if (!vnc_connection_gather_credentials(conn))
 		return FALSE;
 
 #if !DEBUG
-	if (conn->auth_subtype == GVNC_AUTH_VENCRYPT_PLAIN) {
+	if (priv->auth_subtype == GVNC_AUTH_VENCRYPT_PLAIN) {
 		GVNC_DEBUG("Cowardly refusing to transmit plain text password");
 		return FALSE;
 	}
 #endif
 
-	vnc_connection_write_u32(conn, conn->auth_subtype);
+	vnc_connection_write_u32(conn, priv->auth_subtype);
 	vnc_connection_flush(conn);
 	status = vnc_connection_read_u8(conn);
 	if (status != 1) {
-		GVNC_DEBUG("Server refused VeNCrypt auth %d %d", conn->auth_subtype, status);
+		GVNC_DEBUG("Server refused VeNCrypt auth %d %d", priv->auth_subtype, status);
 		return FALSE;
 	}
 
-	switch (conn->auth_subtype) {
+	switch (priv->auth_subtype) {
 	case GVNC_AUTH_VENCRYPT_TLSNONE:
 	case GVNC_AUTH_VENCRYPT_TLSPLAIN:
 	case GVNC_AUTH_VENCRYPT_TLSVNC:
@@ -3215,9 +3375,9 @@ static gboolean vnc_connection_perform_auth_vencrypt(VncConnection *conn)
 		GVNC_DEBUG("Could not start TLS");
 		return FALSE;
 	}
-	GVNC_DEBUG("Completed TLS setup, do subauth %d", conn->auth_subtype);
+	GVNC_DEBUG("Completed TLS setup, do subauth %d", priv->auth_subtype);
 
-	switch (conn->auth_subtype) {
+	switch (priv->auth_subtype) {
 		/* Plain certificate based auth */
 	case GVNC_AUTH_VENCRYPT_TLSNONE:
 	case GVNC_AUTH_VENCRYPT_X509NONE:
@@ -3239,7 +3399,7 @@ static gboolean vnc_connection_perform_auth_vencrypt(VncConnection *conn)
 #endif
 
 	default:
-		GVNC_DEBUG("Unknown auth subtype %d", conn->auth_subtype);
+		GVNC_DEBUG("Unknown auth subtype %d", priv->auth_subtype);
 		return FALSE;
 	}
 }
@@ -3247,20 +3407,22 @@ static gboolean vnc_connection_perform_auth_vencrypt(VncConnection *conn)
 static gboolean vnc_connection_has_auth_type(gpointer data)
 {
 	VncConnection *conn = data;
+	VncConnectionPrivate *priv = conn->priv;
 
-	if (conn->has_error)
+	if (priv->has_error)
 		return TRUE;
-	if (conn->auth_type == GVNC_AUTH_INVALID)
+	if (priv->auth_type == GVNC_AUTH_INVALID)
 		return FALSE;
 	return TRUE;
 }
 
 static gboolean vnc_connection_perform_auth(VncConnection *conn)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	unsigned int nauth, i;
 	unsigned int auth[10];
 
-	if (conn->minor <= 6) {
+	if (priv->minor <= 6) {
 		nauth = 1;
 		auth[0] = vnc_connection_read_u32(conn);
 	} else {
@@ -3272,7 +3434,7 @@ static gboolean vnc_connection_perform_auth(VncConnection *conn)
 			return vnc_connection_check_auth_result(conn);
 
 		if (nauth > sizeof(auth)) {
-			conn->has_error = TRUE;
+			priv->has_error = TRUE;
 			return FALSE;
 		}
 		for (i = 0 ; i < nauth ; i++)
@@ -3283,38 +3445,38 @@ static gboolean vnc_connection_perform_auth(VncConnection *conn)
 		GVNC_DEBUG("Possible auth %u", auth[i]);
 	}
 
-	if (conn->has_error || !conn->ops.auth_type)
+	if (priv->has_error || !priv->ops.auth_type)
 		return FALSE;
 
-	if (!conn->ops.auth_type(conn->ops_data, nauth, auth))
-		conn->has_error = TRUE;
-	if (conn->has_error)
+	if (!priv->ops.auth_type(priv->ops_data, nauth, auth))
+		priv->has_error = TRUE;
+	if (priv->has_error)
 		return FALSE;
 
 	GVNC_DEBUG("Waiting for auth type");
 	g_condition_wait(vnc_connection_has_auth_type, conn);
-	if (conn->has_error)
+	if (priv->has_error)
 		return FALSE;
 
-	GVNC_DEBUG("Choose auth %u", conn->auth_type);
+	GVNC_DEBUG("Choose auth %u", priv->auth_type);
 	if (!vnc_connection_gather_credentials(conn))
 		return FALSE;
 
-	if (conn->minor > 6) {
-		vnc_connection_write_u8(conn, conn->auth_type);
+	if (priv->minor > 6) {
+		vnc_connection_write_u8(conn, priv->auth_type);
 		vnc_connection_flush(conn);
 	}
 
-	switch (conn->auth_type) {
+	switch (priv->auth_type) {
 	case GVNC_AUTH_NONE:
-		if (conn->minor == 8)
+		if (priv->minor == 8)
 			return vnc_connection_check_auth_result(conn);
 		return TRUE;
 	case GVNC_AUTH_VNC:
 		return vnc_connection_perform_auth_vnc(conn);
 
 	case GVNC_AUTH_TLS:
-		if (conn->minor < 7)
+		if (priv->minor < 7)
 			return FALSE;
 		return vnc_connection_perform_auth_tls(conn);
 
@@ -3330,9 +3492,9 @@ static gboolean vnc_connection_perform_auth(VncConnection *conn)
 		return vnc_connection_perform_auth_mslogon(conn);
 
 	default:
-		if (conn->ops.auth_unsupported)
-			conn->ops.auth_unsupported (conn->ops_data, conn->auth_type);
-		conn->has_error = TRUE;
+		if (priv->ops.auth_unsupported)
+			priv->ops.auth_unsupported (priv->ops_data, priv->auth_type);
+		priv->has_error = TRUE;
 
 		return FALSE;
 	}
@@ -3340,126 +3502,171 @@ static gboolean vnc_connection_perform_auth(VncConnection *conn)
 	return TRUE;
 }
 
-VncConnection *vnc_connection_new(const struct vnc_connection_ops *ops, gpointer ops_data)
+static void vnc_connection_finalize (GObject *object)
 {
-	VncConnection *conn = g_malloc0(sizeof(*conn));
+	VncConnection *conn = VNC_CONNECTION(object);
+	VncConnectionPrivate *priv = conn->priv;
 
-	conn->fd = -1;
+	if (vnc_connection_is_open(conn))
+		vnc_connection_close(conn);
 
-	memcpy(&conn->ops, ops, sizeof(*ops));
-	conn->ops_data = ops_data;
-	conn->auth_type = GVNC_AUTH_INVALID;
-	conn->auth_subtype = GVNC_AUTH_INVALID;
+	if (priv->fb)
+		g_object_unref(G_OBJECT(priv->fb));
 
-	return conn;
+	G_OBJECT_CLASS(vnc_connection_parent_class)->finalize (object);
 }
 
-void vnc_connection_free(VncConnection *conn)
+static void vnc_connection_class_init(VncConnectionClass *klass)
 {
-	if (!conn)
-		return;
+	GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
-	if (vnc_connection_is_open(conn))
-		vnc_connection_close(conn);
+	object_class->finalize = vnc_connection_finalize;
+	object_class->get_property = vnc_connection_get_property;
+	object_class->set_property = vnc_connection_set_property;
+
+	g_object_class_install_property(object_class,
+					PROP_FRAMEBUFFER,
+					g_param_spec_object("framebuffer",
+							    "The desktop framebuffer",
+							    "The desktop framebuffer instance",
+							    VNC_TYPE_FRAMEBUFFER,
+							    G_PARAM_READABLE |
+							    G_PARAM_WRITABLE |
+							    G_PARAM_STATIC_NAME |
+							    G_PARAM_STATIC_NICK |
+							    G_PARAM_STATIC_BLURB));
+
+	g_type_class_add_private(klass, sizeof(VncConnectionPrivate));
+}
+
+
+void vnc_connection_init(VncConnection *fb)
+{
+	VncConnectionPrivate *priv;
+
+	priv = fb->priv = VNC_CONNECTION_GET_PRIVATE(fb);
+
+	memset(priv, 0, sizeof(*priv));
+
+	priv->fd = -1;
+	priv->auth_type = GVNC_AUTH_INVALID;
+	priv->auth_subtype = GVNC_AUTH_INVALID;
+}
+
+
+VncConnection *vnc_connection_new(const struct vnc_connection_ops *ops, gpointer ops_data)
+{
+	VncConnection *conn;
+	VncConnectionPrivate *priv;
 
-	if (conn->fb)
-		g_object_unref(G_OBJECT(conn->fb));
+	conn = VNC_CONNECTION(g_object_new(VNC_TYPE_CONNECTION,
+					   NULL));
 
-	g_free(conn);
-	conn = NULL;
+	priv = conn->priv;
+
+	/* XXX kill this */
+	memcpy(&priv->ops, ops, sizeof(*ops));
+	priv->ops_data = ops_data;
+
+	return conn;
 }
 
 void vnc_connection_close(VncConnection *conn)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	int i;
 
-	if (conn->tls_session) {
-		gnutls_bye(conn->tls_session, GNUTLS_SHUT_RDWR);
-		conn->tls_session = NULL;
+	if (priv->tls_session) {
+		gnutls_bye(priv->tls_session, GNUTLS_SHUT_RDWR);
+		priv->tls_session = NULL;
 	}
 #if HAVE_SASL
-	if (conn->saslconn)
-		sasl_dispose (&conn->saslconn);
+	if (priv->saslconn)
+		sasl_dispose (&priv->saslconn);
 #endif
 
-	if (conn->channel) {
-		g_io_channel_unref(conn->channel);
-		conn->channel = NULL;
+	if (priv->channel) {
+		g_io_channel_unref(priv->channel);
+		priv->channel = NULL;
 	}
-	if (conn->fd != -1) {
-		close(conn->fd);
-		conn->fd = -1;
+	if (priv->fd != -1) {
+		close(priv->fd);
+		priv->fd = -1;
 	}
 
-	if (conn->host) {
-		g_free(conn->host);
-		conn->host = NULL;
+	if (priv->host) {
+		g_free(priv->host);
+		priv->host = NULL;
 	}
 
-	if (conn->port) {
-		g_free(conn->port);
-		conn->port = NULL;
+	if (priv->port) {
+		g_free(priv->port);
+		priv->port = NULL;
 	}
 
-	if (conn->name) {
-		g_free(conn->name);
-		conn->name = NULL;
+	if (priv->name) {
+		g_free(priv->name);
+		priv->name = NULL;
 	}
 
-	g_free (conn->xmit_buffer);
+	g_free (priv->xmit_buffer);
 
-	if (conn->cred_username) {
-		g_free(conn->cred_username);
-		conn->cred_username = NULL;
+	if (priv->cred_username) {
+		g_free(priv->cred_username);
+		priv->cred_username = NULL;
 	}
-	if (conn->cred_password) {
-		g_free(conn->cred_password);
-		conn->cred_password = NULL;
+	if (priv->cred_password) {
+		g_free(priv->cred_password);
+		priv->cred_password = NULL;
 	}
 
-	if (conn->cred_x509_cacert) {
-		g_free(conn->cred_x509_cacert);
-		conn->cred_x509_cacert = NULL;
+	if (priv->cred_x509_cacert) {
+		g_free(priv->cred_x509_cacert);
+		priv->cred_x509_cacert = NULL;
 	}
-	if (conn->cred_x509_cacrl) {
-		g_free(conn->cred_x509_cacrl);
-		conn->cred_x509_cacrl = NULL;
+	if (priv->cred_x509_cacrl) {
+		g_free(priv->cred_x509_cacrl);
+		priv->cred_x509_cacrl = NULL;
 	}
-	if (conn->cred_x509_cert) {
-		g_free(conn->cred_x509_cert);
-		conn->cred_x509_cert = NULL;
+	if (priv->cred_x509_cert) {
+		g_free(priv->cred_x509_cert);
+		priv->cred_x509_cert = NULL;
 	}
-	if (conn->cred_x509_key) {
-		g_free(conn->cred_x509_key);
-		conn->cred_x509_key = NULL;
+	if (priv->cred_x509_key) {
+		g_free(priv->cred_x509_key);
+		priv->cred_x509_key = NULL;
 	}
 
 	for (i = 0; i < 5; i++)
-		inflateEnd(&conn->streams[i]);
+		inflateEnd(&priv->streams[i]);
 
-	conn->auth_type = GVNC_AUTH_INVALID;
-	conn->auth_subtype = GVNC_AUTH_INVALID;
+	priv->auth_type = GVNC_AUTH_INVALID;
+	priv->auth_subtype = GVNC_AUTH_INVALID;
 
-	conn->has_error = 0;
+	priv->has_error = 0;
 }
 
 void vnc_connection_shutdown(VncConnection *conn)
 {
-	close(conn->fd);
-	conn->fd = -1;
-	conn->has_error = 1;
+	VncConnectionPrivate *priv = conn->priv;
+
+	close(priv->fd);
+	priv->fd = -1;
+	priv->has_error = 1;
 	GVNC_DEBUG("Waking up couroutine to shutdown gracefully");
-	g_io_wakeup(&conn->wait);
+	g_io_wakeup(&priv->wait);
 }
 
 gboolean vnc_connection_is_open(VncConnection *conn)
 {
+	VncConnectionPrivate *priv = conn->priv;
+
 	if (!conn)
 		return FALSE;
 
-	if (conn->fd != -1)
+	if (priv->fd != -1)
 		return TRUE;
-	if (conn->host)
+	if (priv->host)
 		return TRUE;
 	return FALSE;
 }
@@ -3467,53 +3674,64 @@ gboolean vnc_connection_is_open(VncConnection *conn)
 
 gboolean vnc_connection_is_initialized(VncConnection *conn)
 {
+	VncConnectionPrivate *priv = conn->priv;
+
 	if (!vnc_connection_is_open(conn))
 		return FALSE;
-	if (conn->name)
+	if (priv->name)
 		return TRUE;
 	return FALSE;
 }
 
-static gboolean vnc_connection_before_version (VncConnection *conn, int major, int minor) {
-	return (conn->major < major) || (conn->major == major && conn->minor < minor);
+
+static gboolean vnc_connection_before_version (VncConnection *conn, int major, int minor)
+{
+	VncConnectionPrivate *priv = conn->priv;
+
+	return (priv->major < major) || (priv->major == major && priv->minor < minor);
 }
-static gboolean vnc_connection_after_version (VncConnection *conn, int major, int minor) {
+
+
+static gboolean vnc_connection_after_version (VncConnection *conn, int major, int minor)
+{
 	return !vnc_connection_before_version (conn, major, minor+1);
 }
 
+
 gboolean vnc_connection_initialize(VncConnection *conn, gboolean shared_flag)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	int ret, i;
 	char version[13];
 	guint32 n_name;
 
-	conn->absolute = 1;
+	priv->absolute = 1;
 
 	vnc_connection_read(conn, version, 12);
 	version[12] = 0;
 
- 	ret = sscanf(version, "RFB %03d.%03d\n", &conn->major, &conn->minor);
+ 	ret = sscanf(version, "RFB %03d.%03d\n", &priv->major, &priv->minor);
 	if (ret != 2) {
 		GVNC_DEBUG("Error while getting server version");
 		goto fail;
 	}
 
-	GVNC_DEBUG("Server version: %d.%d", conn->major, conn->minor);
+	GVNC_DEBUG("Server version: %d.%d", priv->major, priv->minor);
 
 	if (vnc_connection_before_version(conn, 3, 3)) {
-		GVNC_DEBUG("Server version is not supported (%d.%d)", conn->major, conn->minor);
+		GVNC_DEBUG("Server version is not supported (%d.%d)", priv->major, priv->minor);
 		goto fail;
 	} else if (vnc_connection_before_version(conn, 3, 7)) {
-		conn->minor = 3;
+		priv->minor = 3;
 	} else if (vnc_connection_after_version(conn, 3, 8)) {
-		conn->major = 3;
-		conn->minor = 8;
+		priv->major = 3;
+		priv->minor = 8;
 	}
 
-	snprintf(version, 12, "RFB %03d.%03d\n", conn->major, conn->minor);
+	snprintf(version, 12, "RFB %03d.%03d\n", priv->major, priv->minor);
 	vnc_connection_write(conn, version, 12);
 	vnc_connection_flush(conn);
-	GVNC_DEBUG("Using version: %d.%d", conn->major, conn->minor);
+	GVNC_DEBUG("Using version: %d.%d", priv->major, priv->minor);
 
 	if (!vnc_connection_perform_auth(conn)) {
 		GVNC_DEBUG("Auth failed");
@@ -3522,44 +3740,44 @@ gboolean vnc_connection_initialize(VncConnection *conn, gboolean shared_flag)
 
 	vnc_connection_write_u8(conn, shared_flag); /* shared flag */
 	vnc_connection_flush(conn);
-	conn->width = vnc_connection_read_u16(conn);
-	conn->height = vnc_connection_read_u16(conn);
+	priv->width = vnc_connection_read_u16(conn);
+	priv->height = vnc_connection_read_u16(conn);
 
 	if (vnc_connection_has_error(conn))
 		return FALSE;
 
-	vnc_connection_read_pixel_format(conn, &conn->fmt);
+	vnc_connection_read_pixel_format(conn, &priv->fmt);
 
 	n_name = vnc_connection_read_u32(conn);
 	if (n_name > 4096)
 		goto fail;
 
-	conn->name = g_new(char, n_name + 1);
+	priv->name = g_new(char, n_name + 1);
 
-	vnc_connection_read(conn, conn->name, n_name);
-	conn->name[n_name] = 0;
-	GVNC_DEBUG("Display name '%s'", conn->name);
+	vnc_connection_read(conn, priv->name, n_name);
+	priv->name[n_name] = 0;
+	GVNC_DEBUG("Display name '%s'", priv->name);
 
 	if (vnc_connection_has_error(conn))
 		return FALSE;
 
-	if (!conn->ops.get_preferred_pixel_format)
+	if (!priv->ops.get_preferred_pixel_format)
 		goto fail;
-	if (conn->ops.get_preferred_pixel_format(conn->ops_data, &conn->fmt))
-		vnc_connection_set_pixel_format(conn, &conn->fmt);
+	if (priv->ops.get_preferred_pixel_format(priv->ops_data, &priv->fmt))
+		vnc_connection_set_pixel_format(conn, &priv->fmt);
 	else
 		goto fail;
-	memset(&conn->strm, 0, sizeof(conn->strm));
+	memset(&priv->strm, 0, sizeof(priv->strm));
 	/* FIXME what level? */
 	for (i = 0; i < 5; i++)
-		inflateInit(&conn->streams[i]);
-	conn->strm = NULL;
+		inflateInit(&priv->streams[i]);
+	priv->strm = NULL;
 
-	vnc_connection_resize(conn, conn->width, conn->height);
+	vnc_connection_resize(conn, priv->width, priv->height);
 	return !vnc_connection_has_error(conn);
 
  fail:
-	conn->has_error = 1;
+	priv->has_error = 1;
 	return !vnc_connection_has_error(conn);
 }
 
@@ -3595,6 +3813,8 @@ static gboolean vnc_connection_set_nonblock(int fd)
 
 gboolean vnc_connection_open_fd(VncConnection *conn, int fd)
 {
+	VncConnectionPrivate *priv = conn->priv;
+
 	if (vnc_connection_is_open(conn)) {
 		GVNC_DEBUG ("Error: already connected?");
 		return FALSE;
@@ -3605,7 +3825,7 @@ gboolean vnc_connection_open_fd(VncConnection *conn, int fd)
 	if (!vnc_connection_set_nonblock(fd))
 		return FALSE;
 
-	if (!(conn->channel =
+	if (!(priv->channel =
 #ifdef WIN32
 	      g_io_channel_win32_new_socket(_get_osfhandle(fd))
 #else
@@ -3615,20 +3835,21 @@ gboolean vnc_connection_open_fd(VncConnection *conn, int fd)
 		GVNC_DEBUG ("Failed to g_io_channel_unix_new()");
 		return FALSE;
 	}
-	conn->fd = fd;
+	priv->fd = fd;
 
 	return !vnc_connection_has_error(conn);
 }
 
 gboolean vnc_connection_open_host(VncConnection *conn, const char *host, const char *port)
 {
+	VncConnectionPrivate *priv = conn->priv;
         struct addrinfo *ai, *runp, hints;
         int ret;
 	if (vnc_connection_is_open(conn))
 		return FALSE;
 
-	conn->host = g_strdup(host);
-	conn->port = g_strdup(port);
+	priv->host = g_strdup(host);
+	priv->port = g_strdup(port);
 
         GVNC_DEBUG("Resolving host %s %s", host, port);
         memset (&hints, '\0', sizeof (hints));
@@ -3673,8 +3894,8 @@ gboolean vnc_connection_open_host(VncConnection *conn, const char *host, const c
                    as explained in connect(2) man page */
                 if ((connect(fd, runp->ai_addr, runp->ai_addrlen) == 0) ||
 		    errno == EISCONN) {
-                        conn->channel = chan;
-                        conn->fd = fd;
+                        priv->channel = chan;
+                        priv->fd = fd;
                         freeaddrinfo(ai);
                         return !vnc_connection_has_error(conn);
                 }
@@ -3700,9 +3921,11 @@ gboolean vnc_connection_open_host(VncConnection *conn, const char *host, const c
 
 gboolean vnc_connection_set_auth_type(VncConnection *conn, unsigned int type)
 {
+	VncConnectionPrivate *priv = conn->priv;
+
         GVNC_DEBUG("Thinking about auth type %u", type);
-        if (conn->auth_type != GVNC_AUTH_INVALID) {
-                conn->has_error = TRUE;
+        if (priv->auth_type != GVNC_AUTH_INVALID) {
+                priv->has_error = TRUE;
                 return !vnc_connection_has_error(conn);
         }
         if (type != GVNC_AUTH_NONE &&
@@ -3712,43 +3935,47 @@ gboolean vnc_connection_set_auth_type(VncConnection *conn, unsigned int type)
             type != GVNC_AUTH_VENCRYPT &&
             type != GVNC_AUTH_SASL) {
 		GVNC_DEBUG("Unsupported auth type %u", type);
-            	if (conn->ops.auth_unsupported)
-			conn->ops.auth_unsupported (conn->ops_data, type);
+            	if (priv->ops.auth_unsupported)
+			priv->ops.auth_unsupported (priv->ops_data, type);
 
-                conn->has_error = TRUE;
+                priv->has_error = TRUE;
                 return !vnc_connection_has_error(conn);
         }
         GVNC_DEBUG("Decided on auth type %u", type);
-        conn->auth_type = type;
-        conn->auth_subtype = GVNC_AUTH_INVALID;
+        priv->auth_type = type;
+        priv->auth_subtype = GVNC_AUTH_INVALID;
 
 	return !vnc_connection_has_error(conn);
 }
 
 gboolean vnc_connection_set_auth_subtype(VncConnection *conn, unsigned int type)
 {
+	VncConnectionPrivate *priv = conn->priv;
+
         GVNC_DEBUG("Requested auth subtype %d", type);
-        if (conn->auth_type != GVNC_AUTH_VENCRYPT &&
-	    conn->auth_type != GVNC_AUTH_TLS) {
-                conn->has_error = TRUE;
+        if (priv->auth_type != GVNC_AUTH_VENCRYPT &&
+	    priv->auth_type != GVNC_AUTH_TLS) {
+                priv->has_error = TRUE;
 		return !vnc_connection_has_error(conn);
         }
-        if (conn->auth_subtype != GVNC_AUTH_INVALID) {
-                conn->has_error = TRUE;
+        if (priv->auth_subtype != GVNC_AUTH_INVALID) {
+                priv->has_error = TRUE;
 		return !vnc_connection_has_error(conn);
         }
-        conn->auth_subtype = type;
+        priv->auth_subtype = type;
 
 	return !vnc_connection_has_error(conn);
 }
 
 gboolean vnc_connection_set_credential_password(VncConnection *conn, const char *password)
 {
+	VncConnectionPrivate *priv = conn->priv;
+
         GVNC_DEBUG("Set password credential %s", password);
-        if (conn->cred_password)
-                g_free(conn->cred_password);
-        if (!(conn->cred_password = g_strdup(password))) {
-                conn->has_error = TRUE;
+        if (priv->cred_password)
+                g_free(priv->cred_password);
+        if (!(priv->cred_password = g_strdup(password))) {
+                priv->has_error = TRUE;
                 return FALSE;
         }
         return TRUE;
@@ -3756,11 +3983,13 @@ gboolean vnc_connection_set_credential_password(VncConnection *conn, const char
 
 gboolean vnc_connection_set_credential_username(VncConnection *conn, const char *username)
 {
+	VncConnectionPrivate *priv = conn->priv;
+
         GVNC_DEBUG("Set username credential %s", username);
-        if (conn->cred_username)
-                g_free(conn->cred_username);
-        if (!(conn->cred_username = g_strdup(username))) {
-                conn->has_error = TRUE;
+        if (priv->cred_username)
+                g_free(priv->cred_username);
+        if (!(priv->cred_username = g_strdup(username))) {
+                priv->has_error = TRUE;
                 return FALSE;
         }
         return TRUE;
@@ -3768,11 +3997,13 @@ gboolean vnc_connection_set_credential_username(VncConnection *conn, const char
 
 gboolean vnc_connection_set_credential_x509_cacert(VncConnection *conn, const char *file)
 {
+	VncConnectionPrivate *priv = conn->priv;
+
         GVNC_DEBUG("Set x509 cacert %s", file);
-        if (conn->cred_x509_cacert)
-                g_free(conn->cred_x509_cacert);
-        if (!(conn->cred_x509_cacert = g_strdup(file))) {
-                conn->has_error = TRUE;
+        if (priv->cred_x509_cacert)
+                g_free(priv->cred_x509_cacert);
+        if (!(priv->cred_x509_cacert = g_strdup(file))) {
+                priv->has_error = TRUE;
                 return FALSE;
         }
         return TRUE;
@@ -3780,11 +4011,13 @@ gboolean vnc_connection_set_credential_x509_cacert(VncConnection *conn, const ch
 
 gboolean vnc_connection_set_credential_x509_cacrl(VncConnection *conn, const char *file)
 {
+	VncConnectionPrivate *priv = conn->priv;
+
         GVNC_DEBUG("Set x509 cacrl %s", file);
-        if (conn->cred_x509_cacrl)
-                g_free(conn->cred_x509_cacrl);
-        if (!(conn->cred_x509_cacrl = g_strdup(file))) {
-                conn->has_error = TRUE;
+        if (priv->cred_x509_cacrl)
+                g_free(priv->cred_x509_cacrl);
+        if (!(priv->cred_x509_cacrl = g_strdup(file))) {
+                priv->has_error = TRUE;
                 return FALSE;
         }
         return TRUE;
@@ -3792,11 +4025,13 @@ gboolean vnc_connection_set_credential_x509_cacrl(VncConnection *conn, const cha
 
 gboolean vnc_connection_set_credential_x509_key(VncConnection *conn, const char *file)
 {
+	VncConnectionPrivate *priv = conn->priv;
+
         GVNC_DEBUG("Set x509 key %s", file);
-        if (conn->cred_x509_key)
-                g_free(conn->cred_x509_key);
-        if (!(conn->cred_x509_key = g_strdup(file))) {
-                conn->has_error = TRUE;
+        if (priv->cred_x509_key)
+                g_free(priv->cred_x509_key);
+        if (!(priv->cred_x509_key = g_strdup(file))) {
+                priv->has_error = TRUE;
                 return FALSE;
         }
         return TRUE;
@@ -3804,11 +4039,13 @@ gboolean vnc_connection_set_credential_x509_key(VncConnection *conn, const char
 
 gboolean vnc_connection_set_credential_x509_cert(VncConnection *conn, const char *file)
 {
+	VncConnectionPrivate *priv = conn->priv;
+
         GVNC_DEBUG("Set x509 cert %s", file);
-        if (conn->cred_x509_cert)
-                g_free(conn->cred_x509_cert);
-        if (!(conn->cred_x509_cert = g_strdup(file))) {
-                conn->has_error = TRUE;
+        if (priv->cred_x509_cert)
+                g_free(priv->cred_x509_cert);
+        if (!(priv->cred_x509_cert = g_strdup(file))) {
+                priv->has_error = TRUE;
                 return FALSE;
         }
         return TRUE;
@@ -3817,47 +4054,56 @@ gboolean vnc_connection_set_credential_x509_cert(VncConnection *conn, const char
 
 gboolean vnc_connection_set_framebuffer(VncConnection *conn, VncFramebuffer *fb)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	const VncPixelFormat *remote;
 	int i;
 
-	if (conn->fb)
-		g_object_unref(G_OBJECT(conn->fb));
-	conn->fb = fb;
-	g_object_ref(G_OBJECT(conn->fb));
+	if (priv->fb)
+		g_object_unref(G_OBJECT(priv->fb));
+	priv->fb = fb;
+	g_object_ref(G_OBJECT(priv->fb));
 
-	remote = vnc_framebuffer_get_remote_format(conn->fb);
+	remote = vnc_framebuffer_get_remote_format(priv->fb);
 
-	conn->fbSwapRemote = remote->byte_order != G_BYTE_ORDER;
+	priv->fbSwapRemote = remote->byte_order != G_BYTE_ORDER;
 
-        i = conn->fmt.bits_per_pixel / 8;
+        i = priv->fmt.bits_per_pixel / 8;
 
         if (i == 4) i = 3;
 
-	conn->rich_cursor_blt = vnc_connection_rich_cursor_blt_table[i - 1];
-	conn->tight_compute_predicted = vnc_connection_tight_compute_predicted_table[i - 1];
-	conn->tight_sum_pixel = vnc_connection_tight_sum_pixel_table[i - 1];
+	priv->rich_cursor_blt = vnc_connection_rich_cursor_blt_table[i - 1];
+	priv->tight_compute_predicted = vnc_connection_tight_compute_predicted_table[i - 1];
+	priv->tight_sum_pixel = vnc_connection_tight_sum_pixel_table[i - 1];
 
 	return !vnc_connection_has_error(conn);
 }
 
 const char *vnc_connection_get_name(VncConnection *conn)
 {
-	return conn->name;
+	VncConnectionPrivate *priv = conn->priv;
+
+	return priv->name;
 }
 
 int vnc_connection_get_width(VncConnection *conn)
 {
-	return conn->width;
+	VncConnectionPrivate *priv = conn->priv;
+
+	return priv->width;
 }
 
 int vnc_connection_get_height(VncConnection *conn)
 {
-	return conn->height;
+	VncConnectionPrivate *priv = conn->priv;
+
+	return priv->height;
 }
 
 gboolean vnc_connection_using_raw_keycodes(VncConnection *conn)
 {
-	return conn->has_ext_key_event;
+	VncConnectionPrivate *priv = conn->priv;
+
+	return priv->has_ext_key_event;
 }
 
 /*
diff --git a/src/vncconnection.h b/src/vncconnection.h
index 9f7b281..aba1e7c 100644
--- a/src/vncconnection.h
+++ b/src/vncconnection.h
@@ -25,7 +25,31 @@
 
 #include "vncframebuffer.h"
 
+G_BEGIN_DECLS
+
+#define VNC_TYPE_CONNECTION            (vnc_connection_get_type ())
+#define VNC_CONNECTION(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), VNC_TYPE_CONNECTION, VncConnection))
+#define VNC_CONNECTION_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), VNC_TYPE_CONNECTION, VncConnectionClass))
+#define VNC_IS_CONNECTION(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VNC_TYPE_CONNECTION))
+#define VNC_IS_CONNECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VNC_TYPE_CONNECTION))
+#define VNC_CONNECTION_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), VNC_TYPE_CONNECTION, VncConnectionClass))
+
+
 typedef struct _VncConnection VncConnection;
+typedef struct _VncConnectionPrivate VncConnectionPrivate;
+typedef struct _VncConnectionClass VncConnectionClass;
+
+struct _VncConnection
+{
+	GObject parent;
+
+	VncConnectionPrivate *priv;
+};
+
+struct _VncConnectionClass
+{
+	GObjectClass parent_class;
+};
 
 typedef void (rgb24_render_func)(void *, int, int, int, int, guint8 *, int);
 
@@ -109,9 +133,9 @@ typedef enum {
 	GVNC_AUTH_VENCRYPT_TLSSASL = 264,
 } VncConnectionAuthVencrypt;
 
+GType vnc_connection_get_type(void) G_GNUC_CONST;
 
 VncConnection *vnc_connection_new(const struct vnc_connection_ops *ops, gpointer ops_data);
-void vnc_connection_free(VncConnection *conn);
 
 void vnc_connection_close(VncConnection *conn);
 void vnc_connection_shutdown(VncConnection *conn);
@@ -172,6 +196,8 @@ int vnc_connection_get_height(VncConnection *conn);
 /* HACK this is temporary */
 gboolean vnc_connection_using_raw_keycodes(VncConnection *conn);
 
+G_END_DECLS
+
 #endif
 /*
  * Local variables:
diff --git a/src/vncconnectionblt.h b/src/vncconnectionblt.h
index 031fcf2..c894bdc 100644
--- a/src/vncconnectionblt.h
+++ b/src/vncconnectionblt.h
@@ -32,7 +32,7 @@
 #define TIGHT_SUM_PIXEL SPLICE(vnc_connection_tight_sum_pixel_, SUFFIX())
 #define SWAP_RFB(conn, pixel) SPLICE(vnc_connection_swap_rfb_, SRC)(conn, pixel)
 #define SWAP_IMG(conn, pixel) SPLICE(vnc_connection_swap_img_, DST)(conn, pixel)
-#define COMPONENT(color, pixel) ((SWAP_RFB(conn, pixel) >> conn->fmt.SPLICE(color, _shift) & conn->fmt.SPLICE(color, _max)))
+#define COMPONENT(color, pixel) ((SWAP_RFB(conn, pixel) >> priv->fmt.SPLICE(color, _shift) & priv->fmt.SPLICE(color, _max)))
 
 
 /* We need to convert to a GdkPixbuf which is always 32-bit */
@@ -41,6 +41,7 @@ static void RICH_CURSOR_BLIT(VncConnection *conn, guint8 *pixbuf,
 			     guint8 *image, guint8 *mask, int pitch,
 			     guint16 width, guint16 height)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	int x1, y1;
 	guint32 *dst = (guint32 *)pixbuf;
 	guint8 *src = image;
@@ -69,11 +70,11 @@ static void RICH_CURSOR_BLIT(VncConnection *conn, guint8 *pixbuf,
 #endif
 
 	/* Then this adjusts for remote having less bpp than 32 */
-	for (n = 255 ; n > conn->fmt.red_max ; n>>= 1)
+	for (n = 255 ; n > priv->fmt.red_max ; n>>= 1)
 		rs++;
-	for (n = 255 ; n > conn->fmt.green_max ; n>>= 1)
+	for (n = 255 ; n > priv->fmt.green_max ; n>>= 1)
 		gs++;
-	for (n = 255 ; n > conn->fmt.blue_max ; n>>= 1)
+	for (n = 255 ; n > priv->fmt.blue_max ; n>>= 1)
 		bs++;
 
 	for (y1 = 0; y1 < height; y1++) {
@@ -103,29 +104,31 @@ static void TIGHT_COMPUTE_PREDICTED(VncConnection *conn, src_pixel_t *ppixel,
 				    src_pixel_t *lp, src_pixel_t *cp,
 				    src_pixel_t *llp)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	ssrc_pixel_t red, green, blue;
 
 	red = COMPONENT(red, *lp) + COMPONENT(red, *cp) - COMPONENT(red, *llp);
 	red = MAX(red, 0);
-	red = MIN(red, conn->fmt.red_max);
+	red = MIN(red, priv->fmt.red_max);
 
 	green = COMPONENT(green, *lp) + COMPONENT(green, *cp) - COMPONENT(green, *llp);
 	green = MAX(green, 0);
-	green = MIN(green, conn->fmt.green_max);
+	green = MIN(green, priv->fmt.green_max);
 
 	blue = COMPONENT(blue, *lp) + COMPONENT(blue, *cp) - COMPONENT(blue, *llp);
 	blue = MAX(blue, 0);
-	blue = MIN(blue, conn->fmt.blue_max);
+	blue = MIN(blue, priv->fmt.blue_max);
 
 	*ppixel = SWAP_RFB(conn,
-		       (red << conn->fmt.red_shift) |
-		       (green << conn->fmt.green_shift) |
-		       (blue << conn->fmt.blue_shift));
+		       (red << priv->fmt.red_shift) |
+		       (green << priv->fmt.green_shift) |
+		       (blue << priv->fmt.blue_shift));
 }
 
 static void TIGHT_SUM_PIXEL(VncConnection *conn,
 			    src_pixel_t *lhs, src_pixel_t *rhs)
 {
+	VncConnectionPrivate *priv = conn->priv;
 	src_pixel_t red, green, blue;
 
 	red = COMPONENT(red, *lhs) + COMPONENT(red, *rhs);
@@ -133,9 +136,9 @@ static void TIGHT_SUM_PIXEL(VncConnection *conn,
 	blue = COMPONENT(blue, *lhs) + COMPONENT(blue, *rhs);
 
 	*lhs = SWAP_RFB(conn,
-		    ((red & conn->fmt.red_max) << conn->fmt.red_shift) |
-		    ((green & conn->fmt.green_max) << conn->fmt.green_shift) |
-		    ((blue & conn->fmt.blue_max) << conn->fmt.blue_shift));
+		    ((red & priv->fmt.red_max) << priv->fmt.red_shift) |
+		    ((green & priv->fmt.green_max) << priv->fmt.green_shift) |
+		    ((blue & priv->fmt.blue_max) << priv->fmt.blue_shift));
 }
 
 #endif
diff --git a/src/vncdisplay.c b/src/vncdisplay.c
index 4eb10af..165f67a 100644
--- a/src/vncdisplay.c
+++ b/src/vncdisplay.c
@@ -1619,7 +1619,7 @@ static void vnc_display_finalize (GObject *obj)
 	if (vnc_connection_is_open(priv->conn)) {
 		g_warning("VNC widget finalized before the connection finished shutting down\n");
 	}
-	vnc_connection_free(priv->conn);
+	g_object_unref(G_OBJECT(priv->conn));
 	display->priv->conn = NULL;
 
 	if (priv->fb) {
-- 
1.6.5.2



[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]