require glib-2.0 >= 2.4.0

* configure.in: require glib-2.0 >= 2.4.0 * libsoup/*.c: use G_DEFINE_TYPE and g_type_class_add_private/G_TYPE_INSTANCE_GET_PRIVATE * libsoup/soup-types.h: kill SOUP_MAKE_TYPE and SOUP_MAKE_TYPE_WITH_IFACE * tests/revserver.c: use GThread. (patch from tml)
author: Dan Winship <danw@src.gnome.org> 2005-04-11 20:42:07 +0000
committer: Dan Winship <danw@src.gnome.org> 2005-04-11 20:42:07 +0000
commit: dbc7ce9e0f5bf9c8be764946886a9003fb129b29 (patch)
tree: 4a60b096b33fbce7a9ddf26f9ba1b77f6d8688d4 /libsoup
parent: 0d10ee7c5a25bf27440e914be3b891c5004ebc6f (diff)
download: libsoup-dbc7ce9e0f5bf9c8be764946886a9003fb129b29.tar.gz
35 files changed, 1225 insertions, 1223 deletions
diff --git a/libsoup/soup-address.c b/libsoup/soup-address.c
index c4d42ac0..4d00678b 100644
--- a/libsoup/soup-address.c
+++ b/libsoup/soup-address.c
@@ -36,7 +36,7 @@
 #define INADDR_NONE -1
 #endif
 
-struct SoupAddressPrivate {
+typedef struct {
 	struct sockaddr *sockaddr;
 
 	char *name, *physical;
@@ -44,19 +44,19 @@ struct SoupAddressPrivate {
 
 	SoupDNSEntry *lookup;
 	guint timeout_id;
-};
-
+} SoupAddressPrivate;
+#define SOUP_ADDRESS_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_ADDRESS, SoupAddressPrivate))
 
 /* sockaddr generic macros */
-#define SOUP_SIN(addr) ((struct sockaddr_in *)addr->priv->sockaddr)
+#define SOUP_SIN(priv) ((struct sockaddr_in *)priv->sockaddr)
 #ifdef HAVE_IPV6
-#define SOUP_SIN6(addr) ((struct sockaddr_in6 *)addr->priv->sockaddr)
+#define SOUP_SIN6(priv) ((struct sockaddr_in6 *)priv->sockaddr)
 #endif
 
 /* sockaddr family macros */
-#define SOUP_ADDRESS_GET_FAMILY(addr) (addr->priv->sockaddr->sa_family)
-#define SOUP_ADDRESS_SET_FAMILY(addr, family) \
-	(addr->priv->sockaddr->sa_family = family)
+#define SOUP_ADDRESS_GET_FAMILY(priv) (priv->sockaddr->sa_family)
+#define SOUP_ADDRESS_SET_FAMILY(priv, family) \
+	(priv->sockaddr->sa_family = family)
 #ifdef HAVE_IPV6
 #define SOUP_ADDRESS_FAMILY_IS_VALID(family) \
 	(family == AF_INET || family == AF_INET6)
@@ -75,33 +75,33 @@ struct SoupAddressPrivate {
 /* sockaddr port macros */
 #define SOUP_ADDRESS_PORT_IS_VALID(port) (port >= 0 && port <= 65535)
 #ifdef HAVE_IPV6
-#define SOUP_ADDRESS_GET_PORT(addr) \
-	(addr->priv->sockaddr->sa_family == AF_INET ? \
-		SOUP_SIN(addr)->sin_port : \
-		SOUP_SIN6(addr)->sin6_port)
-#define SOUP_ADDRESS_SET_PORT(addr, port) \
+#define SOUP_ADDRESS_GET_PORT(priv) \
+	(priv->sockaddr->sa_family == AF_INET ? \
+		SOUP_SIN(priv)->sin_port : \
+		SOUP_SIN6(priv)->sin6_port)
+#define SOUP_ADDRESS_SET_PORT(priv, port) \
 	G_STMT_START {					\
-	if (addr->priv->sockaddr->sa_family == AF_INET)	\
-		SOUP_SIN(addr)->sin_port = port;	\
+	if (priv->sockaddr->sa_family == AF_INET)	\
+		SOUP_SIN(priv)->sin_port = port;	\
 	else						\
-		SOUP_SIN6(addr)->sin6_port = port;	\
+		SOUP_SIN6(priv)->sin6_port = port;	\
 	} G_STMT_END
 #else
-#define SOUP_ADDRESS_GET_PORT(addr) (SOUP_SIN(addr)->sin_port)
-#define SOUP_ADDRESS_SET_PORT(addr, port) (SOUP_SIN(addr)->sin_port = port)
+#define SOUP_ADDRESS_GET_PORT(priv) (SOUP_SIN(priv)->sin_port)
+#define SOUP_ADDRESS_SET_PORT(priv, port) (SOUP_SIN(priv)->sin_port = port)
 #endif
 
 /* sockaddr data macros */
 #ifdef HAVE_IPV6
-#define SOUP_ADDRESS_GET_DATA(addr) \
-	(addr->priv->sockaddr->sa_family == AF_INET ? \
-		(gpointer)&SOUP_SIN(addr)->sin_addr : \
-		(gpointer)&SOUP_SIN6(addr)->sin6_addr)
+#define SOUP_ADDRESS_GET_DATA(priv) \
+	(priv->sockaddr->sa_family == AF_INET ? \
+		(gpointer)&SOUP_SIN(priv)->sin_addr : \
+		(gpointer)&SOUP_SIN6(priv)->sin6_addr)
 #else
-#define SOUP_ADDRESS_GET_DATA(addr) ((gpointer)&SOUP_SIN(addr)->sin_addr)
+#define SOUP_ADDRESS_GET_DATA(priv) ((gpointer)&SOUP_SIN(priv)->sin_addr)
 #endif
-#define SOUP_ADDRESS_SET_DATA(addr, data, length) \
-	memcpy (SOUP_ADDRESS_GET_DATA (addr), data, length)
+#define SOUP_ADDRESS_SET_DATA(priv, data, length) \
+	memcpy (SOUP_ADDRESS_GET_DATA (priv), data, length)
 
 
 enum {
@@ -111,43 +111,40 @@ enum {
 
 static guint signals[LAST_SIGNAL] = { 0 };
 
-#define PARENT_TYPE G_TYPE_OBJECT
-static GObjectClass *parent_class;
+G_DEFINE_TYPE (SoupAddress, soup_address, G_TYPE_OBJECT)
 
 static void
-init (GObject *object)
+soup_address_init (SoupAddress *addr)
 {
-	SoupAddress *addr = SOUP_ADDRESS (object);
-
-	addr->priv = g_new0 (SoupAddressPrivate, 1);
 }
 
 static void
 finalize (GObject *object)
 {
 	SoupAddress *addr = SOUP_ADDRESS (object);
+	SoupAddressPrivate *priv = SOUP_ADDRESS_GET_PRIVATE (addr);
 
-	if (addr->priv->sockaddr)
-		g_free (addr->priv->sockaddr);
-	if (addr->priv->name)
-		g_free (addr->priv->name);
-	if (addr->priv->physical)
-		g_free (addr->priv->physical);
-
-	if (addr->priv->lookup)
-		soup_dns_entry_cancel_lookup (addr->priv->lookup);
-	if (addr->priv->timeout_id)
-		g_source_remove (addr->priv->timeout_id);
+	if (priv->sockaddr)
+		g_free (priv->sockaddr);
+	if (priv->name)
+		g_free (priv->name);
+	if (priv->physical)
+		g_free (priv->physical);
 
-	g_free (addr->priv);
+	if (priv->lookup)
+		soup_dns_entry_cancel_lookup (priv->lookup);
+	if (priv->timeout_id)
+		g_source_remove (priv->timeout_id);
 
-	G_OBJECT_CLASS (parent_class)->finalize (object);
+	G_OBJECT_CLASS (soup_address_parent_class)->finalize (object);
 }
 
 static void
-class_init (GObjectClass *object_class)
+soup_address_class_init (SoupAddressClass *address_class)
 {
-	parent_class = g_type_class_ref (PARENT_TYPE);
+	GObjectClass *object_class = G_OBJECT_CLASS (address_class);
+
+	g_type_class_add_private (address_class, sizeof (SoupAddressPrivate));
 
 	/* virtual method override */
 	object_class->finalize = finalize;
@@ -164,9 +161,6 @@ class_init (GObjectClass *object_class)
 			      G_TYPE_INT);
 }
 
-SOUP_MAKE_TYPE (soup_address, SoupAddress, class_init, init, PARENT_TYPE)
-
-
 
 /**
  * soup_address_new:
@@ -184,13 +178,15 @@ SoupAddress *
 soup_address_new (const char *name, guint port)
 {
 	SoupAddress *addr;
+	SoupAddressPrivate *priv;
 
 	g_return_val_if_fail (name != NULL, NULL);
 	g_return_val_if_fail (SOUP_ADDRESS_PORT_IS_VALID (port), NULL);
 
 	addr = g_object_new (SOUP_TYPE_ADDRESS, NULL);
-	addr->priv->name = g_strdup (name);
-	addr->priv->port = port;
+	priv = SOUP_ADDRESS_GET_PRIVATE (addr);
+	priv->name = g_strdup (name);
+	priv->port = port;
 
 	return addr;
 }
@@ -209,14 +205,16 @@ SoupAddress *
 soup_address_new_from_sockaddr (struct sockaddr *sa, int len)
 {
 	SoupAddress *addr;
+	SoupAddressPrivate *priv;
 
 	g_return_val_if_fail (sa != NULL, NULL);
 	g_return_val_if_fail (SOUP_ADDRESS_FAMILY_IS_VALID (sa->sa_family), NULL);
 	g_return_val_if_fail (len == SOUP_ADDRESS_FAMILY_SOCKADDR_SIZE (sa->sa_family), NULL);
 
 	addr = g_object_new (SOUP_TYPE_ADDRESS, NULL);
-	addr->priv->sockaddr = g_memdup (sa, len);
-	addr->priv->port = ntohs (SOUP_ADDRESS_GET_PORT (addr));
+	priv = SOUP_ADDRESS_GET_PRIVATE (addr);
+	priv->sockaddr = g_memdup (sa, len);
+	priv->port = ntohs (SOUP_ADDRESS_GET_PORT (priv));
 	return addr;
 }
 
@@ -235,17 +233,18 @@ SoupAddress *
 soup_address_new_any (SoupAddressFamily family, guint port)
 {
 	SoupAddress *addr;
+	SoupAddressPrivate *priv;
 
 	g_return_val_if_fail (SOUP_ADDRESS_FAMILY_IS_VALID (family), NULL);
 	g_return_val_if_fail (SOUP_ADDRESS_PORT_IS_VALID (port), NULL);
 
 	addr = g_object_new (SOUP_TYPE_ADDRESS, NULL);
-	addr->priv->port = port;
+	priv = SOUP_ADDRESS_GET_PRIVATE (addr);
+	priv->port = port;
 
-	addr->priv->sockaddr =
-		g_malloc0 (SOUP_ADDRESS_FAMILY_SOCKADDR_SIZE (family));
-	SOUP_ADDRESS_SET_FAMILY (addr, family);
-	SOUP_ADDRESS_SET_PORT (addr, htons (port));
+	priv->sockaddr = g_malloc0 (SOUP_ADDRESS_FAMILY_SOCKADDR_SIZE (family));
+	SOUP_ADDRESS_SET_FAMILY (priv, family);
+	SOUP_ADDRESS_SET_PORT (priv, htons (port));
 
 	return addr;
 }
@@ -263,7 +262,7 @@ soup_address_get_name (SoupAddress *addr)
 {
 	g_return_val_if_fail (SOUP_IS_ADDRESS (addr), NULL);
 
-	return addr->priv->name;
+	return SOUP_ADDRESS_GET_PRIVATE (addr)->name;
 }
 
 /**
@@ -279,12 +278,15 @@ soup_address_get_name (SoupAddress *addr)
 struct sockaddr *
 soup_address_get_sockaddr (SoupAddress *addr, int *len)
 {
+	SoupAddressPrivate *priv;
+
 	g_return_val_if_fail (SOUP_IS_ADDRESS (addr), NULL);
+	priv = SOUP_ADDRESS_GET_PRIVATE (addr);
 
-	if (addr->priv->sockaddr && len)
-		*len = SOUP_ADDRESS_FAMILY_SOCKADDR_SIZE (SOUP_ADDRESS_GET_FAMILY (addr));
+	if (priv->sockaddr && len)
+		*len = SOUP_ADDRESS_FAMILY_SOCKADDR_SIZE (SOUP_ADDRESS_GET_FAMILY (priv));
 
-	return addr->priv->sockaddr;
+	return priv->sockaddr;
 }
 
 /**
@@ -299,18 +301,21 @@ soup_address_get_sockaddr (SoupAddress *addr, int *len)
 const char *
 soup_address_get_physical (SoupAddress *addr)
 {
+	SoupAddressPrivate *priv;
+
 	g_return_val_if_fail (SOUP_IS_ADDRESS (addr), NULL);
+	priv = SOUP_ADDRESS_GET_PRIVATE (addr);
 
-	if (!addr->priv->sockaddr)
+	if (!priv->sockaddr)
 		return NULL;
 
-	if (!addr->priv->physical) {
-		addr->priv->physical =
-			soup_dns_ntop (SOUP_ADDRESS_GET_DATA (addr),
-				       SOUP_ADDRESS_GET_FAMILY (addr));
+	if (!priv->physical) {
+		priv->physical =
+			soup_dns_ntop (SOUP_ADDRESS_GET_DATA (priv),
+				       SOUP_ADDRESS_GET_FAMILY (priv));
 	}
 
-	return addr->priv->physical;
+	return priv->physical;
 }
 
 /**
@@ -326,34 +331,35 @@ soup_address_get_port (SoupAddress *addr)
 {
 	g_return_val_if_fail (SOUP_IS_ADDRESS (addr), 0);
 
-	return addr->priv->port;
+	return SOUP_ADDRESS_GET_PRIVATE (addr)->port;
 }
 
 
 static guint
 update_address_from_entry (SoupAddress *addr, SoupDNSEntry *entry)
 {
+	SoupAddressPrivate *priv = SOUP_ADDRESS_GET_PRIVATE (addr);
 	struct hostent *h;
 
 	h = soup_dns_entry_get_hostent (entry);
 	if (!h)
 		return SOUP_STATUS_CANT_RESOLVE;
 
-	if (!addr->priv->name)
-		addr->priv->name = g_strdup (h->h_name);
+	if (!priv->name)
+		priv->name = g_strdup (h->h_name);
 
-	if (!addr->priv->sockaddr &&
+	if (!priv->sockaddr &&
 	    SOUP_ADDRESS_FAMILY_IS_VALID (h->h_addrtype) &&
 	    SOUP_ADDRESS_FAMILY_DATA_SIZE (h->h_addrtype) == h->h_length) {
-		addr->priv->sockaddr = g_malloc0 (SOUP_ADDRESS_FAMILY_SOCKADDR_SIZE (h->h_addrtype));
-		SOUP_ADDRESS_SET_FAMILY (addr, h->h_addrtype);
-		SOUP_ADDRESS_SET_PORT (addr, htons (addr->priv->port));
-		SOUP_ADDRESS_SET_DATA (addr, h->h_addr, h->h_length);
+		priv->sockaddr = g_malloc0 (SOUP_ADDRESS_FAMILY_SOCKADDR_SIZE (h->h_addrtype));
+		SOUP_ADDRESS_SET_FAMILY (priv, h->h_addrtype);
+		SOUP_ADDRESS_SET_PORT (priv, htons (priv->port));
+		SOUP_ADDRESS_SET_DATA (priv, h->h_addr, h->h_length);
 	}
 
 	soup_dns_free_hostent (h);
 
-	if (addr->priv->name && addr->priv->sockaddr)
+	if (priv->name && priv->sockaddr)
 		return SOUP_STATUS_OK;
 	else
 		return SOUP_STATUS_CANT_RESOLVE;
@@ -363,20 +369,21 @@ static gboolean
 timeout_check_lookup (gpointer user_data)
 {
 	SoupAddress *addr = user_data;
+	SoupAddressPrivate *priv = SOUP_ADDRESS_GET_PRIVATE (addr);
 	guint status;
 
-	if (addr->priv->name && addr->priv->sockaddr) {
-		addr->priv->timeout_id = 0;
+	if (priv->name && priv->sockaddr) {
+		priv->timeout_id = 0;
 		g_signal_emit (addr, signals[DNS_RESULT], 0, SOUP_STATUS_OK);
 		return FALSE;
 	}
 
-	if (!soup_dns_entry_check_lookup (addr->priv->lookup))
+	if (!soup_dns_entry_check_lookup (priv->lookup))
 		return TRUE;
 
-	status = update_address_from_entry (addr, addr->priv->lookup);
-	addr->priv->lookup = NULL;
-	addr->priv->timeout_id = 0;
+	status = update_address_from_entry (addr, priv->lookup);
+	priv->lookup = NULL;
+	priv->timeout_id = 0;
 
 	g_signal_emit (addr, signals[DNS_RESULT], 0, status);
 	return FALSE;
@@ -399,26 +406,27 @@ soup_address_resolve_async (SoupAddress *addr,
 			    SoupAddressCallback callback,
 			    gpointer user_data)
 {
+	SoupAddressPrivate *priv;
+
 	g_return_if_fail (SOUP_IS_ADDRESS (addr));
+	priv = SOUP_ADDRESS_GET_PRIVATE (addr);
 
 	if (callback) {
 		soup_signal_connect_once (addr, "dns_result",
 					  G_CALLBACK (callback), user_data);
 	}
 
-	if (addr->priv->timeout_id)
+	if (priv->timeout_id)
 		return;
 
-	if (!addr->priv->sockaddr) {
-		addr->priv->lookup =
-			soup_dns_entry_from_name (addr->priv->name);
-	} else if (!addr->priv->name) {
-		addr->priv->lookup =
-			soup_dns_entry_from_addr (SOUP_ADDRESS_GET_DATA (addr),
-						  SOUP_ADDRESS_GET_FAMILY (addr));
+	if (!priv->sockaddr) {
+		priv->lookup = soup_dns_entry_from_name (priv->name);
+	} else if (!priv->name) {
+		priv->lookup = soup_dns_entry_from_addr (SOUP_ADDRESS_GET_DATA (priv),
+							 SOUP_ADDRESS_GET_FAMILY (priv));
 	}
 
-	addr->priv->timeout_id = g_timeout_add (100, timeout_check_lookup, addr);
+	priv->timeout_id = g_timeout_add (100, timeout_check_lookup, addr);
 }
 
 /**
@@ -434,14 +442,16 @@ guint
 soup_address_resolve_sync (SoupAddress *addr)
 {
 	SoupDNSEntry *entry;
+	SoupAddressPrivate *priv;
 
 	g_return_val_if_fail (SOUP_IS_ADDRESS (addr), SOUP_STATUS_MALFORMED);
+	priv = SOUP_ADDRESS_GET_PRIVATE (addr);
 
-	if (addr->priv->name)
-		entry = soup_dns_entry_from_name (addr->priv->name);
+	if (priv->name)
+		entry = soup_dns_entry_from_name (priv->name);
 	else {
-		entry = soup_dns_entry_from_addr (SOUP_ADDRESS_GET_DATA (addr),
-						  SOUP_ADDRESS_GET_FAMILY (addr));
+		entry = soup_dns_entry_from_addr (SOUP_ADDRESS_GET_DATA (priv),
+						  SOUP_ADDRESS_GET_FAMILY (priv));
 	}
 
 	return update_address_from_entry (addr, entry);
diff --git a/libsoup/soup-address.h b/libsoup/soup-address.h
index 24b08a3a..c1140e2b 100644
--- a/libsoup/soup-address.h
+++ b/libsoup/soup-address.h
@@ -18,12 +18,9 @@
 #define SOUP_IS_ADDRESS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_ADDRESS))
 #define SOUP_ADDRESS_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_ADDRESS, SoupAddressClass))
 
-typedef struct SoupAddressPrivate SoupAddressPrivate;
-
 struct SoupAddress {
 	GObject parent;
 
-	SoupAddressPrivate *priv;
 };
 
 typedef struct {
diff --git a/libsoup/soup-auth-basic.c b/libsoup/soup-auth-basic.c
index 68755aaf..f91acd0a 100644
--- a/libsoup/soup-auth-basic.c
+++ b/libsoup/soup-auth-basic.c
@@ -24,39 +24,36 @@ static void authenticate (SoupAuth *auth, const char *username, const char *pass
 static gboolean is_authenticated (SoupAuth *auth);
 static char *get_authorization (SoupAuth *auth, SoupMessage *msg);
 
-struct SoupAuthBasicPrivate {
+typedef struct {
 	char *realm, *token;
-};
+} SoupAuthBasicPrivate;
+#define SOUP_AUTH_BASIC_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_AUTH_BASIC, SoupAuthBasicPrivate))
 
-#define PARENT_TYPE SOUP_TYPE_AUTH
-static SoupAuthClass *parent_class;
+G_DEFINE_TYPE (SoupAuthBasic, soup_auth_basic, SOUP_TYPE_AUTH)
 
 static void
-init (GObject *object)
+soup_auth_basic_init (SoupAuthBasic *basic)
 {
-	SoupAuthBasic *basic = SOUP_AUTH_BASIC (object);
-
-	basic->priv = g_new0 (SoupAuthBasicPrivate, 1);
 }
 
 static void
 finalize (GObject *object)
 {
-	SoupAuthBasic *basic = SOUP_AUTH_BASIC (object);
+	SoupAuthBasicPrivate *priv = SOUP_AUTH_BASIC_GET_PRIVATE (object);
 
-	g_free (basic->priv->realm);
-	g_free (basic->priv->token);
-	g_free (basic->priv);
+	g_free (priv->realm);
+	g_free (priv->token);
 
-	G_OBJECT_CLASS (parent_class)->finalize (object);
+	G_OBJECT_CLASS (soup_auth_basic_parent_class)->finalize (object);
 }
 
 static void
-class_init (GObjectClass *object_class)
+soup_auth_basic_class_init (SoupAuthBasicClass *auth_basic_class)
 {
-	SoupAuthClass *auth_class = SOUP_AUTH_CLASS (object_class);
+	SoupAuthClass *auth_class = SOUP_AUTH_CLASS (auth_basic_class);
+	GObjectClass *object_class = G_OBJECT_CLASS (auth_basic_class);
 
-	parent_class = g_type_class_ref (PARENT_TYPE);
+	g_type_class_add_private (auth_basic_class, sizeof (SoupAuthBasicPrivate));
 
 	auth_class->scheme_name = "Basic";
 
@@ -70,13 +67,11 @@ class_init (GObjectClass *object_class)
 	object_class->finalize = finalize;
 }
 
-SOUP_MAKE_TYPE (soup_auth_basic, SoupAuthBasic, class_init, init, PARENT_TYPE)
-
 
 static void
 construct (SoupAuth *auth, const char *header)
 {
-	SoupAuthBasic *basic = SOUP_AUTH_BASIC (auth);
+	SoupAuthBasicPrivate *priv = SOUP_AUTH_BASIC_GET_PRIVATE (auth);
 	GHashTable *tokens;
 
 	header += sizeof ("Basic");
@@ -85,7 +80,7 @@ construct (SoupAuth *auth, const char *header)
 	if (!tokens)
 		return;
 
-	basic->priv->realm = soup_header_param_copy_token (tokens, "realm");
+	priv->realm = soup_header_param_copy_token (tokens, "realm");
 	soup_header_param_destroy_hash (tokens);
 }
 
@@ -107,15 +102,13 @@ get_protection_space (SoupAuth *auth, const SoupUri *source_uri)
 static const char *
 get_realm (SoupAuth *auth)
 {
-	SoupAuthBasic *basic = SOUP_AUTH_BASIC (auth);
-
-	return basic->priv->realm;
+	return SOUP_AUTH_BASIC_GET_PRIVATE (auth)->realm;
 }
 
 static void
 authenticate (SoupAuth *auth, const char *username, const char *password)
 {
-	SoupAuthBasic *basic = SOUP_AUTH_BASIC (auth);
+	SoupAuthBasicPrivate *priv = SOUP_AUTH_BASIC_GET_PRIVATE (auth);
 	char *user_pass;
 	int len;
 
@@ -125,7 +118,7 @@ authenticate (SoupAuth *auth, const char *username, const char *password)
 	user_pass = g_strdup_printf ("%s:%s", username, password);
 	len = strlen (user_pass);
 
-	basic->priv->token = soup_base64_encode (user_pass, len);
+	priv->token = soup_base64_encode (user_pass, len);
 
 	memset (user_pass, 0, len);
 	g_free (user_pass);
@@ -134,15 +127,13 @@ authenticate (SoupAuth *auth, const char *username, const char *password)
 static gboolean
 is_authenticated (SoupAuth *auth)
 {
-	SoupAuthBasic *basic = SOUP_AUTH_BASIC (auth);
-
-	return basic->priv->token != NULL;
+	return SOUP_AUTH_BASIC_GET_PRIVATE (auth)->token != NULL;
 }
 
 static char *
 get_authorization (SoupAuth *auth, SoupMessage *msg)
 {
-	SoupAuthBasic *basic = SOUP_AUTH_BASIC (auth);
+	SoupAuthBasicPrivate *priv = SOUP_AUTH_BASIC_GET_PRIVATE (auth);
 
-	return g_strdup_printf ("Basic %s", basic->priv->token);
+	return g_strdup_printf ("Basic %s", priv->token);
 }
diff --git a/libsoup/soup-auth-basic.h b/libsoup/soup-auth-basic.h
index a0c09563..f6b7e2db 100644
--- a/libsoup/soup-auth-basic.h
+++ b/libsoup/soup-auth-basic.h
@@ -15,12 +15,9 @@
 #define SOUP_IS_AUTH_BASIC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SOUP_TYPE_AUTH_BASIC))
 #define SOUP_AUTH_BASIC_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_AUTH_BASIC, SoupAuthBasicClass))
 
-typedef struct SoupAuthBasicPrivate SoupAuthBasicPrivate;
-
 typedef struct {
 	SoupAuth parent;
 
-	SoupAuthBasicPrivate *priv;
 } SoupAuthBasic;
 
 typedef struct {
diff --git a/libsoup/soup-auth-digest.c b/libsoup/soup-auth-digest.c
index a125d12e..e54c262c 100644
--- a/libsoup/soup-auth-digest.c
+++ b/libsoup/soup-auth-digest.c
@@ -39,7 +39,7 @@ typedef enum {
 	ALGORITHM_MD5_SESS = 1 << 1
 } AlgorithmType;
 
-struct SoupAuthDigestPrivate {
+typedef struct {
 	char          *user;
 	guchar         hex_a1[33];
 
@@ -54,46 +54,42 @@ struct SoupAuthDigestPrivate {
 	char          *cnonce;
 	int            nc;
 	QOPType        qop;
-};
+} SoupAuthDigestPrivate;
+#define SOUP_AUTH_DIGEST_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_AUTH_DIGEST, SoupAuthDigestPrivate))
 
-#define PARENT_TYPE SOUP_TYPE_AUTH
-static SoupAuthClass *parent_class;
+G_DEFINE_TYPE (SoupAuthDigest, soup_auth_digest, SOUP_TYPE_AUTH)
 
 static void
-init (GObject *object)
+soup_auth_digest_init (SoupAuthDigest *digest)
 {
-	SoupAuthDigest *digest = SOUP_AUTH_DIGEST (object);
-
-	digest->priv = g_new0 (SoupAuthDigestPrivate, 1);
 }
 
 static void
 finalize (GObject *object)
 {
-	SoupAuthDigest *digest = SOUP_AUTH_DIGEST (object);
-
-	if (digest->priv->user)
-		g_free (digest->priv->user);
-	if (digest->priv->realm)
-		g_free (digest->priv->realm);
-	if (digest->priv->nonce)
-		g_free (digest->priv->nonce);
-	if (digest->priv->domain)
-		g_free (digest->priv->domain);
-	if (digest->priv->cnonce)
-		g_free (digest->priv->cnonce);
-
-	g_free (digest->priv);
-
-	G_OBJECT_CLASS (parent_class)->finalize (object);
+	SoupAuthDigestPrivate *priv = SOUP_AUTH_DIGEST_GET_PRIVATE (object);
+
+	if (priv->user)
+		g_free (priv->user);
+	if (priv->realm)
+		g_free (priv->realm);
+	if (priv->nonce)
+		g_free (priv->nonce);
+	if (priv->domain)
+		g_free (priv->domain);
+	if (priv->cnonce)
+		g_free (priv->cnonce);
+
+	G_OBJECT_CLASS (soup_auth_digest_parent_class)->finalize (object);
 }
 
 static void
-class_init (GObjectClass *object_class)
+soup_auth_digest_class_init (SoupAuthDigestClass *auth_digest_class)
 {
-	SoupAuthClass *auth_class = SOUP_AUTH_CLASS (object_class);
+	SoupAuthClass *auth_class = SOUP_AUTH_CLASS (auth_digest_class);
+	GObjectClass *object_class = G_OBJECT_CLASS (auth_digest_class);
 
-	parent_class = g_type_class_ref (PARENT_TYPE);
+	g_type_class_add_private (auth_digest_class, sizeof (SoupAuthDigestPrivate));
 
 	auth_class->scheme_name = "Digest";
 
@@ -107,8 +103,6 @@ class_init (GObjectClass *object_class)
 	object_class->finalize = finalize;
 }
 
-SOUP_MAKE_TYPE (soup_auth_digest, SoupAuthDigest, class_init, init, PARENT_TYPE)
-
 typedef struct {
 	char *name;
 	guint type;
@@ -155,7 +149,7 @@ decode_algorithm (const char *name)
 static void
 construct (SoupAuth *auth, const char *header)
 {
-	SoupAuthDigest *digest = SOUP_AUTH_DIGEST (auth);
+	SoupAuthDigestPrivate *priv = SOUP_AUTH_DIGEST_GET_PRIVATE (auth);
 	GHashTable *tokens;
 	char *tmp, *ptr;
 
@@ -165,13 +159,13 @@ construct (SoupAuth *auth, const char *header)
 	if (!tokens)
 		return;
 
-	digest->priv->nc = 1;
+	priv->nc = 1;
 	/* We're just going to do qop=auth for now */
-	digest->priv->qop = QOP_AUTH;
+	priv->qop = QOP_AUTH;
 
-	digest->priv->realm = soup_header_param_copy_token (tokens, "realm");
-	digest->priv->domain = soup_header_param_copy_token (tokens, "domain");
-	digest->priv->nonce = soup_header_param_copy_token (tokens, "nonce");
+	priv->realm = soup_header_param_copy_token (tokens, "realm");
+	priv->domain = soup_header_param_copy_token (tokens, "domain");
+	priv->nonce = soup_header_param_copy_token (tokens, "nonce");
 
 	tmp = soup_header_param_copy_token (tokens, "qop");
 	ptr = tmp;
@@ -181,7 +175,7 @@ construct (SoupAuth *auth, const char *header)
 
 		token = soup_header_param_decode_token ((char **)&ptr);
 		if (token)
-			digest->priv->qop_options |= decode_qop (token);
+			priv->qop_options |= decode_qop (token);
 		g_free (token);
 
 		if (*ptr == ',')
@@ -190,7 +184,7 @@ construct (SoupAuth *auth, const char *header)
 	g_free (tmp);
 
 	tmp = soup_header_param_copy_token (tokens, "algorithm");
-	digest->priv->algorithm = decode_algorithm (tmp);
+	priv->algorithm = decode_algorithm (tmp);
 	g_free (tmp);
 
 	soup_header_param_destroy_hash (tokens);
@@ -199,19 +193,19 @@ construct (SoupAuth *auth, const char *header)
 static GSList *
 get_protection_space (SoupAuth *auth, const SoupUri *source_uri)
 {
-	SoupAuthDigest *digest = SOUP_AUTH_DIGEST (auth);
+	SoupAuthDigestPrivate *priv = SOUP_AUTH_DIGEST_GET_PRIVATE (auth);
 	GSList *space = NULL;
 	SoupUri *uri;
 	char *domain, *d, *lasts, *dir, *slash;
 
-	if (!digest->priv->domain || !*digest->priv->domain) {
+	if (!priv->domain || !*priv->domain) {
 		/* If no domain directive, the protection space is the
 		 * whole server.
 		 */
 		return g_slist_prepend (NULL, g_strdup (""));
 	}
 
-	domain = g_strdup (digest->priv->domain);
+	domain = g_strdup (priv->domain);
 	for (d = strtok_r (domain, " ", &lasts); d; d = strtok_r (NULL, " ", &lasts)) {
 		if (*d == '/')
 			dir = g_strdup (d);
@@ -243,9 +237,7 @@ get_protection_space (SoupAuth *auth, const SoupUri *source_uri)
 static const char *
 get_realm (SoupAuth *auth)
 {
-	SoupAuthDigest *digest = SOUP_AUTH_DIGEST (auth);
-
-	return digest->priv->realm;
+	return SOUP_AUTH_DIGEST_GET_PRIVATE (auth)->realm;
 }
 
 static void
@@ -261,7 +253,7 @@ digest_hex (guchar *digest, guchar hex[33])
 static void
 authenticate (SoupAuth *auth, const char *username, const char *password)
 {
-	SoupAuthDigest *digest = SOUP_AUTH_DIGEST (auth);
+	SoupAuthDigestPrivate *priv = SOUP_AUTH_DIGEST_GET_PRIVATE (auth);
 	SoupMD5Context ctx;
 	guchar d[16];
 	char *bgen;
@@ -269,13 +261,13 @@ authenticate (SoupAuth *auth, const char *username, const char *password)
 	g_return_if_fail (username != NULL);
 
 	bgen = g_strdup_printf ("%p:%lu:%lu",
-			       auth,
-			       (unsigned long) getpid (),
-			       (unsigned long) time (0));
-	digest->priv->cnonce = soup_base64_encode (bgen, strlen (bgen));
+				auth,
+				(unsigned long) getpid (),
+				(unsigned long) time (0));
+	priv->cnonce = soup_base64_encode (bgen, strlen (bgen));
 	g_free (bgen);
 
-	digest->priv->user = g_strdup (username);
+	priv->user = g_strdup (username);
 
 	/* compute A1 */
 	soup_md5_init (&ctx);
@@ -283,43 +275,41 @@ authenticate (SoupAuth *auth, const char *username, const char *password)
 	soup_md5_update (&ctx, username, strlen (username));
 
 	soup_md5_update (&ctx, ":", 1);
-	if (digest->priv->realm) {
-		soup_md5_update (&ctx, digest->priv->realm,
-				 strlen (digest->priv->realm));
+	if (priv->realm) {
+		soup_md5_update (&ctx, priv->realm,
+				 strlen (priv->realm));
 	}
 
 	soup_md5_update (&ctx, ":", 1);
 	if (password)
 		soup_md5_update (&ctx, password, strlen (password));
 
-	if (digest->priv->algorithm == ALGORITHM_MD5_SESS) {
+	if (priv->algorithm == ALGORITHM_MD5_SESS) {
 		soup_md5_final (&ctx, d);
 
 		soup_md5_init (&ctx);
 		soup_md5_update (&ctx, d, 16);
 		soup_md5_update (&ctx, ":", 1);
-		soup_md5_update (&ctx, digest->priv->nonce,
-				 strlen (digest->priv->nonce));
+		soup_md5_update (&ctx, priv->nonce,
+				 strlen (priv->nonce));
 		soup_md5_update (&ctx, ":", 1);
-		soup_md5_update (&ctx, digest->priv->cnonce,
-				 strlen (digest->priv->cnonce));
+		soup_md5_update (&ctx, priv->cnonce,
+				 strlen (priv->cnonce));
 	}
 
 	/* hexify A1 */
 	soup_md5_final (&ctx, d);
-	digest_hex (d, digest->priv->hex_a1);
+	digest_hex (d, priv->hex_a1);
 }
 
 static gboolean
 is_authenticated (SoupAuth *auth)
 {
-	SoupAuthDigest *digest = SOUP_AUTH_DIGEST (auth);
-
-	return digest->priv->cnonce != NULL;
+	return SOUP_AUTH_DIGEST_GET_PRIVATE (auth)->cnonce != NULL;
 }
 
 static char *
-compute_response (SoupAuthDigest *digest, SoupMessage *msg)
+compute_response (SoupAuthDigestPrivate *priv, SoupMessage *msg)
 {
 	guchar hex_a2[33], o[33];
 	guchar d[16];
@@ -339,7 +329,7 @@ compute_response (SoupAuthDigest *digest, SoupMessage *msg)
 
 	g_free (url);
 
-	if (digest->priv->qop == QOP_AUTH_INT) {
+	if (priv->qop == QOP_AUTH_INT) {
 		/* FIXME: Actually implement. Ugh. */
 		soup_md5_update (&md5, ":", 1);
 		soup_md5_update (&md5, "00000000000000000000000000000000", 32);
@@ -351,27 +341,27 @@ compute_response (SoupAuthDigest *digest, SoupMessage *msg)
 
 	/* compute KD */
 	soup_md5_init (&md5);
-	soup_md5_update (&md5, digest->priv->hex_a1, 32);
+	soup_md5_update (&md5, priv->hex_a1, 32);
 	soup_md5_update (&md5, ":", 1);
-	soup_md5_update (&md5, digest->priv->nonce,
-			 strlen (digest->priv->nonce));
+	soup_md5_update (&md5, priv->nonce,
+			 strlen (priv->nonce));
 	soup_md5_update (&md5, ":", 1);
 
-	if (digest->priv->qop) {
+	if (priv->qop) {
 		char *tmp;
 
-		tmp = g_strdup_printf ("%.8x", digest->priv->nc);
+		tmp = g_strdup_printf ("%.8x", priv->nc);
 
 		soup_md5_update (&md5, tmp, strlen (tmp));
 		g_free (tmp);
 		soup_md5_update (&md5, ":", 1);
-		soup_md5_update (&md5, digest->priv->cnonce,
-				 strlen (digest->priv->cnonce));
+		soup_md5_update (&md5, priv->cnonce,
+				 strlen (priv->cnonce));
 		soup_md5_update (&md5, ":", 1);
 
-		if (digest->priv->qop == QOP_AUTH)
+		if (priv->qop == QOP_AUTH)
 			tmp = "auth";
-		else if (digest->priv->qop == QOP_AUTH_INT)
+		else if (priv->qop == QOP_AUTH_INT)
 			tmp = "auth-int";
 		else
 			g_assert_not_reached ();
@@ -391,7 +381,7 @@ compute_response (SoupAuthDigest *digest, SoupMessage *msg)
 static char *
 get_authorization (SoupAuth *auth, SoupMessage *msg)
 {
-	SoupAuthDigest *digest = (SoupAuthDigest *) auth;
+	SoupAuthDigestPrivate *priv = SOUP_AUTH_DIGEST_GET_PRIVATE (auth);
 	char *response;
 	char *qop = NULL;
 	char *nc;
@@ -403,35 +393,35 @@ get_authorization (SoupAuth *auth, SoupMessage *msg)
 	g_return_val_if_fail (uri != NULL, NULL);
 	url = soup_uri_to_string (uri, TRUE);
 
-	response = compute_response (digest, msg);
+	response = compute_response (priv, msg);
 
-	if (digest->priv->qop == QOP_AUTH)
+	if (priv->qop == QOP_AUTH)
 		qop = "auth";
-	else if (digest->priv->qop == QOP_AUTH_INT)
+	else if (priv->qop == QOP_AUTH_INT)
 		qop = "auth-int";
 	else
 		g_assert_not_reached ();
 
-	nc = g_strdup_printf ("%.8x", digest->priv->nc);
+	nc = g_strdup_printf ("%.8x", priv->nc);
 
 	out = g_strdup_printf (
 		"Digest username=\"%s\", realm=\"%s\", nonce=\"%s\", %s%s%s "
 		"%s%s%s %s%s%s uri=\"%s\", response=\"%s\"",
-		digest->priv->user,
-		digest->priv->realm,
-		digest->priv->nonce,
+		priv->user,
+		priv->realm,
+		priv->nonce,
 
-		digest->priv->qop ? "cnonce=\"" : "",
-		digest->priv->qop ? digest->priv->cnonce : "",
-		digest->priv->qop ? "\"," : "",
+		priv->qop ? "cnonce=\"" : "",
+		priv->qop ? priv->cnonce : "",
+		priv->qop ? "\"," : "",
 
-		digest->priv->qop ? "nc=" : "",
-		digest->priv->qop ? nc : "",
-		digest->priv->qop ? "," : "",
+		priv->qop ? "nc=" : "",
+		priv->qop ? nc : "",
+		priv->qop ? "," : "",
 
-		digest->priv->qop ? "qop=" : "",
-		digest->priv->qop ? qop : "",
-		digest->priv->qop ? "," : "",
+		priv->qop ? "qop=" : "",
+		priv->qop ? qop : "",
+		priv->qop ? "," : "",
 
 		url,
 		response);
@@ -440,7 +430,7 @@ get_authorization (SoupAuth *auth, SoupMessage *msg)
 	g_free (url);
 	g_free (nc);
 
-	digest->priv->nc++;
+	priv->nc++;
 
 	return out;
 }
diff --git a/libsoup/soup-auth-digest.h b/libsoup/soup-auth-digest.h
index 3b8e072f..b8bf8fa8 100644
--- a/libsoup/soup-auth-digest.h
+++ b/libsoup/soup-auth-digest.h
@@ -15,12 +15,9 @@
 #define SOUP_IS_AUTH_DIGEST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SOUP_TYPE_AUTH_DIGEST))
 #define SOUP_AUTH_DIGEST_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_AUTH_DIGEST, SoupAuthDigestClass))
 
-typedef struct SoupAuthDigestPrivate SoupAuthDigestPrivate;
-
 typedef struct {
 	SoupAuth parent;
 
-	SoupAuthDigestPrivate *priv;
 } SoupAuthDigest;
 
 typedef struct {
diff --git a/libsoup/soup-auth.c b/libsoup/soup-auth.c
index ba80a2f5..fdc9f7d7 100644
--- a/libsoup/soup-auth.c
+++ b/libsoup/soup-auth.c
@@ -15,17 +15,17 @@
 #include "soup-auth-basic.h"
 #include "soup-auth-digest.h"
 
-#define PARENT_TYPE G_TYPE_OBJECT
-static GObjectClass *parent_class;
+G_DEFINE_TYPE (SoupAuth, soup_auth, G_TYPE_OBJECT)
 
 static void
-class_init (GObjectClass *object_class)
+soup_auth_class_init (SoupAuthClass *auth_class)
 {
-	parent_class = g_type_class_ref (PARENT_TYPE);
 }
 
-SOUP_MAKE_TYPE (soup_auth, SoupAuth, class_init, NULL, PARENT_TYPE)
-
+static void
+soup_auth_init (SoupAuth *auth)
+{
+}
 
 typedef struct {
 	const char  *scheme;
diff --git a/libsoup/soup-connection-ntlm.c b/libsoup/soup-connection-ntlm.c
index 66eacd29..5cc1eaaf 100644
--- a/libsoup/soup-connection-ntlm.c
+++ b/libsoup/soup-connection-ntlm.c
@@ -27,14 +27,14 @@ typedef enum {
 	SOUP_CONNECTION_NTLM_FAILED
 } SoupConnectionNTLMState;
 
-struct SoupConnectionNTLMPrivate {
+typedef struct {
 	char *user;
 	guchar nt_hash[21], lm_hash[21];
 	SoupConnectionNTLMState state;
-};
+} SoupConnectionNTLMPrivate;
+#define SOUP_CONNECTION_NTLM_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_CONNECTION_NTLM, SoupConnectionNTLMPrivate))
 
-#define PARENT_TYPE SOUP_TYPE_CONNECTION
-static SoupConnectionClass *parent_class;
+G_DEFINE_TYPE (SoupConnectionNTLM, soup_connection_ntlm, SOUP_TYPE_CONNECTION)
 
 static char     *soup_ntlm_request         (void);
 static gboolean  soup_ntlm_parse_challenge (const char  *challenge,
@@ -47,58 +47,52 @@ static char     *soup_ntlm_response        (const char  *nonce,
 					    const char  *domain);
 
 static void
-init (GObject *object)
+soup_connection_ntlm_init (SoupConnectionNTLM *ntlm)
 {
-	SoupConnectionNTLM *ntlm = SOUP_CONNECTION_NTLM (object);
-
-	ntlm->priv = g_new0 (SoupConnectionNTLMPrivate, 1);
 }
 
 static void
 finalize (GObject *object)
 {
-	SoupConnectionNTLM *ntlm = SOUP_CONNECTION_NTLM (object);
-
-	g_free (ntlm->priv->user);
-	memset (ntlm->priv->nt_hash, 0, sizeof (ntlm->priv->nt_hash));
-	memset (ntlm->priv->lm_hash, 0, sizeof (ntlm->priv->lm_hash));
+	SoupConnectionNTLMPrivate *priv = SOUP_CONNECTION_NTLM_GET_PRIVATE (object);
 
-	g_free (ntlm->priv);
+	g_free (priv->user);
+	memset (priv->nt_hash, 0, sizeof (priv->nt_hash));
+	memset (priv->lm_hash, 0, sizeof (priv->lm_hash));
 
-	G_OBJECT_CLASS (parent_class)->finalize (object);
+	G_OBJECT_CLASS (soup_connection_ntlm_parent_class)->finalize (object);
 }
 
 static void
-class_init (GObjectClass *object_class)
+soup_connection_ntlm_class_init (SoupConnectionNTLMClass *connection_ntlm_class)
 {
-	SoupConnectionClass *connection_class =
-		SOUP_CONNECTION_CLASS (object_class);
+	SoupConnectionClass *connection_class = SOUP_CONNECTION_CLASS (connection_ntlm_class);
+	GObjectClass *object_class = G_OBJECT_CLASS (connection_ntlm_class);
 
-	parent_class = g_type_class_ref (PARENT_TYPE);
+	g_type_class_add_private (connection_ntlm_class, sizeof (SoupConnectionNTLMPrivate));
 
 	connection_class->send_request = send_request;
 	object_class->finalize = finalize;
 }
 
-SOUP_MAKE_TYPE (soup_connection_ntlm, SoupConnectionNTLM, class_init, init, PARENT_TYPE)
-
 
 static void
 ntlm_authorize_pre (SoupMessage *msg, gpointer user_data)
 {
 	SoupConnectionNTLM *ntlm = user_data;
+	SoupConnectionNTLMPrivate *priv = SOUP_CONNECTION_NTLM_GET_PRIVATE (ntlm);
 	const GSList *headers;
 	const char *val;
 	char *nonce, *header;
 	char *username, *domain_username = NULL, *password = NULL;
 	char *slash, *domain;
 
-	if (ntlm->priv->state > SOUP_CONNECTION_NTLM_SENT_REQUEST) {
+	if (priv->state > SOUP_CONNECTION_NTLM_SENT_REQUEST) {
 		/* We already authenticated, but then got another 401.
 		 * That means "permission denied", so don't try to
 		 * authenticate again.
 		 */
-		ntlm->priv->state = SOUP_CONNECTION_NTLM_FAILED;
+		priv->state = SOUP_CONNECTION_NTLM_FAILED;
 		goto done;
 	}
 
@@ -111,12 +105,12 @@ ntlm_authorize_pre (SoupMessage *msg, gpointer user_data)
 		headers = headers->next;
 	}
 	if (!headers) {
-		ntlm->priv->state = SOUP_CONNECTION_NTLM_FAILED;
+		priv->state = SOUP_CONNECTION_NTLM_FAILED;
 		goto done;
 	}
 
 	if (!soup_ntlm_parse_challenge (val, &nonce, &domain)) {
-		ntlm->priv->state = SOUP_CONNECTION_NTLM_FAILED;
+		priv->state = SOUP_CONNECTION_NTLM_FAILED;
 		goto done;
 	}
 
@@ -147,7 +141,7 @@ ntlm_authorize_pre (SoupMessage *msg, gpointer user_data)
 	soup_message_add_header (msg->request_headers,
 				 "Authorization", header);
 	g_free (header);
-	ntlm->priv->state = SOUP_CONNECTION_NTLM_RECEIVED_CHALLENGE;
+	priv->state = SOUP_CONNECTION_NTLM_RECEIVED_CHALLENGE;
 
  done:
 	/* Remove the WWW-Authenticate headers so the session won't try
@@ -159,37 +153,35 @@ ntlm_authorize_pre (SoupMessage *msg, gpointer user_data)
 static void
 ntlm_authorize_post (SoupMessage *msg, gpointer conn)
 {
-	SoupConnectionNTLM *ntlm = conn;
+	SoupConnectionNTLMPrivate *priv = SOUP_CONNECTION_NTLM_GET_PRIVATE (conn);
 
-	if (ntlm->priv->state == SOUP_CONNECTION_NTLM_RECEIVED_CHALLENGE &&
+	if (priv->state == SOUP_CONNECTION_NTLM_RECEIVED_CHALLENGE &&
 	    soup_message_get_header (msg->request_headers, "Authorization")) {
 		/* We just added the last Auth header, so restart it. */
-		ntlm->priv->state = SOUP_CONNECTION_NTLM_SENT_RESPONSE;
+		priv->state = SOUP_CONNECTION_NTLM_SENT_RESPONSE;
 		soup_message_restarted (msg);
 		soup_connection_send_request (conn, msg);
 	}
 }
 
 static void
-ntlm_cleanup_msg (SoupMessage *msg, gpointer user_data)
+ntlm_cleanup_msg (SoupMessage *msg, gpointer conn)
 {
-	SoupConnectionNTLM *ntlm = user_data;
-
 	/* Do this when the message is restarted, in case it's
 	 * restarted on a different connection.
 	 */
 	soup_message_remove_handler (msg, SOUP_HANDLER_PRE_BODY,
-				     ntlm_authorize_pre, ntlm);
+				     ntlm_authorize_pre, conn);
 	soup_message_remove_handler (msg, SOUP_HANDLER_POST_BODY,
-				     ntlm_authorize_post, ntlm);
+				     ntlm_authorize_post, conn);
 }
 
 void
 send_request (SoupConnection *conn, SoupMessage *req)
 {
-	SoupConnectionNTLM *ntlm = SOUP_CONNECTION_NTLM (conn);
+	SoupConnectionNTLMPrivate *priv = SOUP_CONNECTION_NTLM_GET_PRIVATE (conn);
 
-	if (ntlm->priv->state == SOUP_CONNECTION_NTLM_NEW) {
+	if (priv->state == SOUP_CONNECTION_NTLM_NEW) {
 		char *header = soup_ntlm_request ();
 
 		soup_message_remove_header (req->request_headers,
@@ -197,7 +189,7 @@ send_request (SoupConnection *conn, SoupMessage *req)
 		soup_message_add_header (req->request_headers,
 					 "Authorization", header);
 		g_free (header);
-		ntlm->priv->state = SOUP_CONNECTION_NTLM_SENT_REQUEST;
+		priv->state = SOUP_CONNECTION_NTLM_SENT_REQUEST;
 	}
 
 	soup_message_add_status_code_handler (req, SOUP_STATUS_UNAUTHORIZED,
@@ -209,11 +201,11 @@ send_request (SoupConnection *conn, SoupMessage *req)
 					      ntlm_authorize_post, conn);
 
 	g_signal_connect (req, "restarted",
-			  G_CALLBACK (ntlm_cleanup_msg), ntlm);
+			  G_CALLBACK (ntlm_cleanup_msg), conn);
 	g_signal_connect (req, "finished",
-			  G_CALLBACK (ntlm_cleanup_msg), ntlm);
+			  G_CALLBACK (ntlm_cleanup_msg), conn);
 
-	SOUP_CONNECTION_CLASS (parent_class)->send_request (conn, req);
+	SOUP_CONNECTION_CLASS (soup_connection_ntlm_parent_class)->send_request (conn, req);
 }
 
 
diff --git a/libsoup/soup-connection-ntlm.h b/libsoup/soup-connection-ntlm.h
index 8d0a2425..b9a2b5c2 100644
--- a/libsoup/soup-connection-ntlm.h
+++ b/libsoup/soup-connection-ntlm.h
@@ -15,12 +15,9 @@
 #define SOUP_IS_CONNECTION_NTLM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SOUP_TYPE_CONNECTION_NTLM))
 #define SOUP_CONNECTION_NTLM_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_CONNECTION_NTLM, SoupConnectionNTLMClass))
 
-typedef struct SoupConnectionNTLMPrivate SoupConnectionNTLMPrivate;
-
 typedef struct {
 	SoupConnection parent;
 
-	SoupConnectionNTLMPrivate *priv;
 } SoupConnectionNTLM;
 
 typedef struct {
diff --git a/libsoup/soup-connection.c b/libsoup/soup-connection.c
index 17676f99..0e885684 100644
--- a/libsoup/soup-connection.c
+++ b/libsoup/soup-connection.c
@@ -31,7 +31,7 @@
 #include "soup-ssl.h"
 #include "soup-uri.h"
 
-struct SoupConnectionPrivate {
+typedef struct {
 	SoupSocket  *socket;
 
 	/* proxy_uri is the URI of the proxy server we are connected
@@ -48,10 +48,10 @@ struct SoupConnectionPrivate {
 	SoupMessage *cur_req;
 	time_t       last_used;
 	gboolean     connected, in_use;
-};
+} SoupConnectionPrivate;
+#define SOUP_CONNECTION_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_CONNECTION, SoupConnectionPrivate))
 
-#define PARENT_TYPE G_TYPE_OBJECT
-static GObjectClass *parent_class;
+G_DEFINE_TYPE (SoupConnection, soup_connection, G_TYPE_OBJECT)
 
 enum {
 	CONNECT_RESULT,
@@ -64,14 +64,14 @@ enum {
 static guint signals[LAST_SIGNAL] = { 0 };
 
 enum {
-  PROP_0,
+	PROP_0,
 
-  PROP_ORIGIN_URI,
-  PROP_PROXY_URI,
-  PROP_SSL_CREDS,
-  PROP_MESSAGE_FILTER,
+	PROP_ORIGIN_URI,
+	PROP_PROXY_URI,
+	PROP_SSL_CREDS,
+	PROP_MESSAGE_FILTER,
 
-  LAST_PROP
+	LAST_PROP
 };
 
 static void set_property (GObject *object, guint prop_id,
@@ -83,50 +83,45 @@ static void request_done (SoupMessage *req, gpointer user_data);
 static void send_request (SoupConnection *conn, SoupMessage *req);
 
 static void
-init (GObject *object)
+soup_connection_init (SoupConnection *conn)
 {
-	SoupConnection *conn = SOUP_CONNECTION (object);
-
-	conn->priv = g_new0 (SoupConnectionPrivate, 1);
 }
 
 static void
 finalize (GObject *object)
 {
-	SoupConnection *conn = SOUP_CONNECTION (object);
-
-	if (conn->priv->proxy_uri)
-		soup_uri_free (conn->priv->proxy_uri);
-	if (conn->priv->origin_uri)
-		soup_uri_free (conn->priv->origin_uri);
+	SoupConnectionPrivate *priv = SOUP_CONNECTION_GET_PRIVATE (object);
 
-	if (conn->priv->filter)
-		g_object_unref (conn->priv->filter);
+	if (priv->proxy_uri)
+		soup_uri_free (priv->proxy_uri);
+	if (priv->origin_uri)
+		soup_uri_free (priv->origin_uri);
 
-	g_free (conn->priv);
+	if (priv->filter)
+		g_object_unref (priv->filter);
 
-	G_OBJECT_CLASS (parent_class)->finalize (object);
+	G_OBJECT_CLASS (soup_connection_parent_class)->finalize (object);
 }
 
 static void
 dispose (GObject *object)
 {
 	SoupConnection *conn = SOUP_CONNECTION (object);
+	SoupConnectionPrivate *priv = SOUP_CONNECTION_GET_PRIVATE (object);
 
-	if (conn->priv->cur_req)
-		request_done (conn->priv->cur_req, conn);
+	if (priv->cur_req)
+		request_done (priv->cur_req, conn);
 	soup_connection_disconnect (conn);
 
-	G_OBJECT_CLASS (parent_class)->dispose (object);
+	G_OBJECT_CLASS (soup_connection_parent_class)->dispose (object);
 }
 
 static void
-class_init (GObjectClass *object_class)
+soup_connection_class_init (SoupConnectionClass *connection_class)
 {
-	SoupConnectionClass *connection_class =
-		SOUP_CONNECTION_CLASS (object_class);
+	GObjectClass *object_class = G_OBJECT_CLASS (connection_class);
 
-	parent_class = g_type_class_ref (PARENT_TYPE);
+	g_type_class_add_private (connection_class, sizeof (SoupConnectionPrivate));
 
 	/* virtual method definition */
 	connection_class->send_request = send_request;
@@ -209,8 +204,6 @@ class_init (GObjectClass *object_class)
 				      G_PARAM_READWRITE));
 }
 
-SOUP_MAKE_TYPE (soup_connection, SoupConnection, class_init, init, PARENT_TYPE)
-
 
 /**
  * soup_connection_new:
@@ -247,29 +240,29 @@ static void
 set_property (GObject *object, guint prop_id,
 	      const GValue *value, GParamSpec *pspec)
 {
-	SoupConnection *conn = SOUP_CONNECTION (object);
+	SoupConnectionPrivate *priv = SOUP_CONNECTION_GET_PRIVATE (object);
 	gpointer pval;
 
 	switch (prop_id) {
 	case PROP_ORIGIN_URI:
 		pval = g_value_get_pointer (value);
-		conn->priv->origin_uri = pval ? soup_uri_copy (pval) : NULL;
-		if (!conn->priv->proxy_uri)
-			conn->priv->conn_uri = conn->priv->origin_uri;
+		priv->origin_uri = pval ? soup_uri_copy (pval) : NULL;
+		if (!priv->proxy_uri)
+			priv->conn_uri = priv->origin_uri;
 		break;
 	case PROP_PROXY_URI:
 		pval = g_value_get_pointer (value);
-		conn->priv->proxy_uri = pval ? soup_uri_copy (pval) : NULL;
-		if (conn->priv->proxy_uri)
-			conn->priv->conn_uri = conn->priv->proxy_uri;
+		priv->proxy_uri = pval ? soup_uri_copy (pval) : NULL;
+		if (priv->proxy_uri)
+			priv->conn_uri = priv->proxy_uri;
 		else
-			conn->priv->conn_uri = conn->priv->origin_uri;
+			priv->conn_uri = priv->origin_uri;
 		break;
 	case PROP_SSL_CREDS:
-		conn->priv->ssl_creds = g_value_get_pointer (value);
+		priv->ssl_creds = g_value_get_pointer (value);
 		break;
 	case PROP_MESSAGE_FILTER:
-		conn->priv->filter = g_object_ref (g_value_get_pointer (value));
+		priv->filter = g_object_ref (g_value_get_pointer (value));
 		break;
 	default:
 		break;
@@ -280,23 +273,23 @@ static void
 get_property (GObject *object, guint prop_id,
 	      GValue *value, GParamSpec *pspec)
 {
-	SoupConnection *conn = SOUP_CONNECTION (object);
+	SoupConnectionPrivate *priv = SOUP_CONNECTION_GET_PRIVATE (object);
 
 	switch (prop_id) {
 	case PROP_ORIGIN_URI:
-		g_value_set_pointer (value, conn->priv->origin_uri ?
-				     soup_uri_copy (conn->priv->origin_uri) :
+		g_value_set_pointer (value, priv->origin_uri ?
+				     soup_uri_copy (priv->origin_uri) :
 				     NULL);
 		break;
 	case PROP_PROXY_URI:
-		g_value_set_pointer (value, conn->priv->proxy_uri ?
-				     soup_uri_copy (conn->priv->proxy_uri) :
+		g_value_set_pointer (value, priv->proxy_uri ?
+				     soup_uri_copy (priv->proxy_uri) :
 				     NULL);
 	case PROP_SSL_CREDS:
-		g_value_set_pointer (value, conn->priv->ssl_creds);
+		g_value_set_pointer (value, priv->ssl_creds);
 		break;
 	case PROP_MESSAGE_FILTER:
-		g_value_set_pointer (value, g_object_ref (conn->priv->filter));
+		g_value_set_pointer (value, g_object_ref (priv->filter));
 		break;
 	default:
 		break;
@@ -304,26 +297,25 @@ get_property (GObject *object, guint prop_id,
 }
 
 static void
-set_current_request (SoupConnection *conn, SoupMessage *req)
+set_current_request (SoupConnectionPrivate *priv, SoupMessage *req)
 {
-	g_return_if_fail (conn->priv->cur_req == NULL);
+	g_return_if_fail (priv->cur_req == NULL);
 
 	req->status = SOUP_MESSAGE_STATUS_RUNNING;
-	conn->priv->cur_req = req;
-	conn->priv->in_use = TRUE;
-	g_object_add_weak_pointer (G_OBJECT (req),
-				   (gpointer *)conn->priv->cur_req);
+	priv->cur_req = req;
+	priv->in_use = TRUE;
+	g_object_add_weak_pointer (G_OBJECT (req), (gpointer *)priv->cur_req);
 }
 
 static void
-clear_current_request (SoupConnection *conn)
+clear_current_request (SoupConnectionPrivate *priv)
 {
-	if (conn->priv->cur_req) {
-		g_object_remove_weak_pointer (G_OBJECT (conn->priv->cur_req),
-					      (gpointer *)conn->priv->cur_req);
-		conn->priv->cur_req = NULL;
+	if (priv->cur_req) {
+		g_object_remove_weak_pointer (G_OBJECT (priv->cur_req),
+					      (gpointer *)priv->cur_req);
+		priv->cur_req = NULL;
 	}
-	conn->priv->in_use = FALSE;
+	priv->in_use = FALSE;
 }
 
 static void
@@ -333,9 +325,9 @@ socket_disconnected (SoupSocket *sock, gpointer conn)
 }
 
 static inline guint
-proxified_status (SoupConnection *conn, guint status)
+proxified_status (SoupConnectionPrivate *priv, guint status)
 {
-	if (!conn->priv->proxy_uri)
+	if (!priv->proxy_uri)
 		return status;
 
 	if (status == SOUP_STATUS_CANT_RESOLVE)
@@ -350,14 +342,15 @@ static void
 tunnel_connect_finished (SoupMessage *msg, gpointer user_data)
 {
 	SoupConnection *conn = user_data;
+	SoupConnectionPrivate *priv = SOUP_CONNECTION_GET_PRIVATE (conn);
 	guint status = msg->status_code;
 
-	clear_current_request (conn);
+	clear_current_request (priv);
 
 	if (SOUP_STATUS_IS_SUCCESSFUL (status)) {
-		if (soup_socket_start_proxy_ssl (conn->priv->socket,
-						 conn->priv->origin_uri->host))
-			conn->priv->connected = TRUE;
+		if (soup_socket_start_proxy_ssl (priv->socket,
+						 priv->origin_uri->host))
+			priv->connected = TRUE;
 		else
 			status = SOUP_STATUS_SSL_FAILED;
 	} else if (SOUP_STATUS_IS_REDIRECTION (status)) {
@@ -366,7 +359,7 @@ tunnel_connect_finished (SoupMessage *msg, gpointer user_data)
 	}
 
 	g_signal_emit (conn, signals[CONNECT_RESULT], 0,
-		       proxified_status (conn, status));
+		       proxified_status (priv, status));
 	g_object_unref (msg);
 }
 
@@ -405,11 +398,12 @@ static void
 socket_connect_result (SoupSocket *sock, guint status, gpointer user_data)
 {
 	SoupConnection *conn = user_data;
+	SoupConnectionPrivate *priv = SOUP_CONNECTION_GET_PRIVATE (conn);
 
 	if (!SOUP_STATUS_IS_SUCCESSFUL (status))
 		goto done;
 
-	if (conn->priv->conn_uri->protocol == SOUP_PROTOCOL_HTTPS) {
+	if (priv->conn_uri->protocol == SOUP_PROTOCOL_HTTPS) {
 		if (!soup_socket_start_ssl (sock)) {
 			status = SOUP_STATUS_SSL_FAILED;
 			goto done;
@@ -417,13 +411,13 @@ socket_connect_result (SoupSocket *sock, guint status, gpointer user_data)
 	}
 
 	/* See if we need to tunnel */
-	if (conn->priv->proxy_uri &&
-	    conn->priv->origin_uri &&
-	    conn->priv->origin_uri->protocol == SOUP_PROTOCOL_HTTPS) {
+	if (priv->proxy_uri &&
+	    priv->origin_uri &&
+	    priv->origin_uri->protocol == SOUP_PROTOCOL_HTTPS) {
 		SoupMessage *connect_msg;
 
 		connect_msg = soup_message_new_from_uri (SOUP_METHOD_CONNECT,
-							 conn->priv->origin_uri);
+							 priv->origin_uri);
 
 		g_signal_connect (connect_msg, "restarted",
 				  G_CALLBACK (tunnel_connect_restarted), conn);
@@ -434,11 +428,11 @@ socket_connect_result (SoupSocket *sock, guint status, gpointer user_data)
 		return;
 	}
 
-	conn->priv->connected = TRUE;
+	priv->connected = TRUE;
 
  done:
 	g_signal_emit (conn, signals[CONNECT_RESULT], 0,
-		       proxified_status (conn, status));
+		       proxified_status (priv, status));
 }
 
 /**
@@ -454,20 +448,23 @@ soup_connection_connect_async (SoupConnection *conn,
 			       SoupConnectionCallback callback,
 			       gpointer user_data)
 {
+	SoupConnectionPrivate *priv;
+
 	g_return_if_fail (SOUP_IS_CONNECTION (conn));
-	g_return_if_fail (conn->priv->socket == NULL);
+	priv = SOUP_CONNECTION_GET_PRIVATE (conn);
+	g_return_if_fail (priv->socket == NULL);
 
 	if (callback) {
 		soup_signal_connect_once (conn, "connect_result",
 					  G_CALLBACK (callback), user_data);
 	}
 
-	conn->priv->socket =
-		soup_socket_client_new_async (conn->priv->conn_uri->host,
-					      conn->priv->conn_uri->port,
-					      conn->priv->ssl_creds,
+	priv->socket =
+		soup_socket_client_new_async (priv->conn_uri->host,
+					      priv->conn_uri->port,
+					      priv->ssl_creds,
 					      socket_connect_result, conn);
-	g_signal_connect (conn->priv->socket, "disconnected",
+	g_signal_connect (priv->socket, "disconnected",
 			  G_CALLBACK (socket_disconnected), conn);
 }
 
@@ -482,38 +479,40 @@ soup_connection_connect_async (SoupConnection *conn,
 guint
 soup_connection_connect_sync (SoupConnection *conn)
 {
+	SoupConnectionPrivate *priv;
 	guint status;
 
 	g_return_val_if_fail (SOUP_IS_CONNECTION (conn), SOUP_STATUS_MALFORMED);
-	g_return_val_if_fail (conn->priv->socket == NULL, SOUP_STATUS_MALFORMED);
+	priv = SOUP_CONNECTION_GET_PRIVATE (conn);
+	g_return_val_if_fail (priv->socket == NULL, SOUP_STATUS_MALFORMED);
 
-	conn->priv->socket =
-		soup_socket_client_new_sync (conn->priv->conn_uri->host,
-					     conn->priv->conn_uri->port,
-					     conn->priv->ssl_creds,
+	priv->socket =
+		soup_socket_client_new_sync (priv->conn_uri->host,
+					     priv->conn_uri->port,
+					     priv->ssl_creds,
 					     &status);
 
 	if (!SOUP_STATUS_IS_SUCCESSFUL (status))
 		goto fail;
 
-	g_signal_connect (conn->priv->socket, "disconnected",
+	g_signal_connect (priv->socket, "disconnected",
 			  G_CALLBACK (socket_disconnected), conn);
 
-	if (conn->priv->conn_uri->protocol == SOUP_PROTOCOL_HTTPS) {
-		if (!soup_socket_start_ssl (conn->priv->socket)) {
+	if (priv->conn_uri->protocol == SOUP_PROTOCOL_HTTPS) {
+		if (!soup_socket_start_ssl (priv->socket)) {
 			status = SOUP_STATUS_SSL_FAILED;
 			goto fail;
 		}
 	}
 
 	/* See if we need to tunnel */
-	if (conn->priv->proxy_uri &&
-	    conn->priv->origin_uri &&
-	    conn->priv->origin_uri->protocol == SOUP_PROTOCOL_HTTPS) {
+	if (priv->proxy_uri &&
+	    priv->origin_uri &&
+	    priv->origin_uri->protocol == SOUP_PROTOCOL_HTTPS) {
 		SoupMessage *connect_msg;
 
 		connect_msg = soup_message_new_from_uri (SOUP_METHOD_CONNECT,
-							 conn->priv->origin_uri);
+							 priv->origin_uri);
 		soup_connection_send_request (conn, connect_msg);
 		status = connect_msg->status_code;
 
@@ -531,16 +530,16 @@ soup_connection_connect_sync (SoupConnection *conn)
 	}
 
 	if (SOUP_STATUS_IS_SUCCESSFUL (status))
-		conn->priv->connected = TRUE;
+		priv->connected = TRUE;
 	else {
 	fail:
-		if (conn->priv->socket) {
-			g_object_unref (conn->priv->socket);
-			conn->priv->socket = NULL;
+		if (priv->socket) {
+			g_object_unref (priv->socket);
+			priv->socket = NULL;
 		}
 	}
 
-	status = proxified_status (conn, status);
+	status = proxified_status (priv, status);
 	g_signal_emit (conn, signals[CONNECT_RESULT], 0, status);
 	return status;
 }
@@ -556,33 +555,36 @@ soup_connection_connect_sync (SoupConnection *conn)
 void
 soup_connection_disconnect (SoupConnection *conn)
 {
+	SoupConnectionPrivate *priv;
+
 	g_return_if_fail (SOUP_IS_CONNECTION (conn));
+	priv = SOUP_CONNECTION_GET_PRIVATE (conn);
 
-	if (!conn->priv->socket)
+	if (!priv->socket)
 		return;
 
-	g_signal_handlers_disconnect_by_func (conn->priv->socket,
+	g_signal_handlers_disconnect_by_func (priv->socket,
 					      socket_disconnected, conn);
-	soup_socket_disconnect (conn->priv->socket);
-	g_object_unref (conn->priv->socket);
-	conn->priv->socket = NULL;
+	soup_socket_disconnect (priv->socket);
+	g_object_unref (priv->socket);
+	priv->socket = NULL;
 
 	/* Don't emit "disconnected" if we aren't yet connected */
-	if (!conn->priv->connected)
+	if (!priv->connected)
 		return;
 
-	conn->priv->connected = FALSE;
+	priv->connected = FALSE;
 	g_signal_emit (conn, signals[DISCONNECTED], 0);
 
-	if (!conn->priv->cur_req ||
-	    conn->priv->cur_req->status_code != SOUP_STATUS_IO_ERROR)
+	if (!priv->cur_req ||
+	    priv->cur_req->status_code != SOUP_STATUS_IO_ERROR)
 		return;
 
 	/* There was a message queued on this connection, but the
 	 * socket was closed while it was being sent.
 	 */
 
-	if (conn->priv->last_used != 0) {
+	if (priv->last_used != 0) {
 		/* If last_used is not 0, then that means at least one
 		 * message was successfully sent on this connection
 		 * before, and so the most likely cause of the
@@ -596,11 +598,11 @@ soup_connection_disconnect (SoupConnection *conn)
 		 * all we need to do to get the message requeued in
 		 * this case is to change its status.
 		 */
-		conn->priv->cur_req->status = SOUP_MESSAGE_STATUS_QUEUED;
+		priv->cur_req->status = SOUP_MESSAGE_STATUS_QUEUED;
 		return;
 	}
 
-	/* If conn->priv->last_used is 0, then that means this was the
+	/* If priv->last_used is 0, then that means this was the
 	 * first message to be sent on this connection, so the error
 	 * probably means that there's some network or server problem,
 	 * so we let the IO_ERROR be returned to the caller.
@@ -630,7 +632,7 @@ soup_connection_is_in_use (SoupConnection *conn)
 {
 	g_return_val_if_fail (SOUP_IS_CONNECTION (conn), FALSE);
 
-	return conn->priv->in_use;
+	return SOUP_CONNECTION_GET_PRIVATE (conn)->in_use;
 }
 
 /**
@@ -647,7 +649,7 @@ soup_connection_last_used (SoupConnection *conn)
 {
 	g_return_val_if_fail (SOUP_IS_CONNECTION (conn), FALSE);
 
-	return conn->priv->last_used;
+	return SOUP_CONNECTION_GET_PRIVATE (conn)->last_used;
 }
 
 static void
@@ -661,9 +663,10 @@ static void
 request_done (SoupMessage *req, gpointer user_data)
 {
 	SoupConnection *conn = user_data;
+	SoupConnectionPrivate *priv = SOUP_CONNECTION_GET_PRIVATE (conn);
 
-	clear_current_request (conn);
-	conn->priv->last_used = time (NULL);
+	clear_current_request (priv);
+	priv->last_used = time (NULL);
 
 	if (!soup_message_is_keepalive (req))
 		soup_connection_disconnect (conn);
@@ -676,22 +679,24 @@ request_done (SoupMessage *req, gpointer user_data)
 static void
 send_request (SoupConnection *conn, SoupMessage *req)
 {
+	SoupConnectionPrivate *priv = SOUP_CONNECTION_GET_PRIVATE (conn);
+
 	g_object_ref (conn);
 
-	if (req != conn->priv->cur_req) {
-		set_current_request (conn, req);
+	if (req != priv->cur_req) {
+		set_current_request (priv, req);
 
 		g_signal_connect (req, "restarted",
 				  G_CALLBACK (request_restarted), conn);
 		g_signal_connect (req, "finished",
 				  G_CALLBACK (request_done), conn);
 
-		if (conn->priv->filter)
-			soup_message_filter_setup_message (conn->priv->filter, req);
+		if (priv->filter)
+			soup_message_filter_setup_message (priv->filter, req);
 	}
 
-	soup_message_send_request (req, conn->priv->socket,
-				   conn->priv->proxy_uri != NULL);
+	soup_message_send_request (req, priv->socket,
+				   priv->proxy_uri != NULL);
 }
 
 /**
@@ -707,7 +712,7 @@ soup_connection_send_request (SoupConnection *conn, SoupMessage *req)
 {
 	g_return_if_fail (SOUP_IS_CONNECTION (conn));
 	g_return_if_fail (SOUP_IS_MESSAGE (req));
-	g_return_if_fail (conn->priv->socket != NULL);
+	g_return_if_fail (SOUP_CONNECTION_GET_PRIVATE (conn)->socket != NULL);
 
 	SOUP_CONNECTION_GET_CLASS (conn)->send_request (conn, req);
 }
@@ -726,7 +731,7 @@ soup_connection_reserve (SoupConnection *conn)
 {
 	g_return_if_fail (SOUP_IS_CONNECTION (conn));
 
-	conn->priv->in_use = TRUE;
+	SOUP_CONNECTION_GET_PRIVATE (conn)->in_use = TRUE;
 }
 
 /**
@@ -742,7 +747,7 @@ soup_connection_release (SoupConnection *conn)
 {
 	g_return_if_fail (SOUP_IS_CONNECTION (conn));
 
-	conn->priv->in_use = FALSE;
+	SOUP_CONNECTION_GET_PRIVATE (conn)->in_use = FALSE;
 }
 
 /**
diff --git a/libsoup/soup-connection.h b/libsoup/soup-connection.h
index 959bceb9..f3c056cc 100644
--- a/libsoup/soup-connection.h
+++ b/libsoup/soup-connection.h
@@ -17,12 +17,9 @@
 #define SOUP_IS_CONNECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_CONNECTION))
 #define SOUP_CONNECTION_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_CONNECTION, SoupConnectionClass))
 
-typedef struct SoupConnectionPrivate SoupConnectionPrivate;
-
 struct SoupConnection {
 	GObject parent;
 
-	SoupConnectionPrivate *priv;
 };
 
 typedef struct {
diff --git a/libsoup/soup-message-client-io.c b/libsoup/soup-message-client-io.c
index fdc64294..1cad9f63 100644
--- a/libsoup/soup-message-client-io.c
+++ b/libsoup/soup-message-client-io.c
@@ -24,6 +24,7 @@ parse_response_headers (SoupMessage *req,
 			guint *content_len,
 			gpointer user_data)
 {
+	SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (req);
 	const char *length, *enc;
 	SoupHttpVersion version;
 	GHashTable *resp_hdrs;
@@ -36,8 +37,8 @@ parse_response_headers (SoupMessage *req,
 					  (char **) &req->reason_phrase))
 		return SOUP_STATUS_MALFORMED;
 
-	if (version < req->priv->http_version)
-		req->priv->http_version = version;
+	if (version < priv->http_version)
+		priv->http_version = version;
 
 	meth_id   = soup_method_get_id (req->method);
 	resp_hdrs = req->response_headers;
@@ -107,6 +108,7 @@ get_request_headers (SoupMessage *req, GString *header,
 		     SoupTransferEncoding *encoding,
 		     gpointer user_data)
 {
+	SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (req);
 	gboolean proxy = GPOINTER_TO_UINT (user_data);
 	const SoupUri *uri = soup_message_get_uri (req);
 	const char *expect;
@@ -122,7 +124,7 @@ get_request_headers (SoupMessage *req, GString *header,
 		uri_string = soup_uri_to_string (uri, !proxy);
 	}
 
-	if (req->priv->http_version == SOUP_HTTP_1_0) {
+	if (priv->http_version == SOUP_HTTP_1_0) {
 		g_string_append_printf (header, "%s %s HTTP/1.0\r\n",
 					req->method, uri_string);
 	} else {
@@ -154,7 +156,7 @@ get_request_headers (SoupMessage *req, GString *header,
 
 	expect = soup_message_get_header (req->request_headers, "Expect");
 	if (expect && !strcmp (expect, "100-continue"))
-		req->priv->msg_flags |= SOUP_MESSAGE_EXPECT_CONTINUE;
+		priv->msg_flags |= SOUP_MESSAGE_EXPECT_CONTINUE;
 }
 
 /**
diff --git a/libsoup/soup-message-handlers.c b/libsoup/soup-message-handlers.c
index 89ccbf81..20553e35 100644
--- a/libsoup/soup-message-handlers.c
+++ b/libsoup/soup-message-handlers.c
@@ -72,15 +72,16 @@ run_handler (SoupMessage     *msg,
 void
 soup_message_run_handlers (SoupMessage *msg, SoupHandlerPhase invoke_phase)
 {
+	SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg);
 	GSList *copy, *list;
 
 	g_return_if_fail (SOUP_IS_MESSAGE (msg));
 
 	/* Jump through hoops to deal with callbacks that modify the list. */
-	copy = g_slist_copy (msg->priv->content_handlers);
+	copy = g_slist_copy (priv->content_handlers);
 
 	for (list = copy; list; list = list->next) {
-		if (!g_slist_find (msg->priv->content_handlers, list->data))
+		if (!g_slist_find (priv->content_handlers, list->data))
 			continue;
 		run_handler (msg, invoke_phase, list->data);
 
@@ -101,6 +102,7 @@ add_handler (SoupMessage           *msg,
 	     guint                  status_code,
 	     SoupStatusClass        status_class)
 {
+	SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg);
 	SoupHandlerData *data;
 
 	data = g_new0 (SoupHandlerData, 1);
@@ -123,8 +125,8 @@ add_handler (SoupMessage           *msg,
 		break;
 	}
 
-	msg->priv->content_handlers =
-		g_slist_append (msg->priv->content_handlers, data);
+	priv->content_handlers =
+		g_slist_append (priv->content_handlers, data);
 }
 
 /**
@@ -244,7 +246,9 @@ soup_message_remove_handler (SoupMessage           *msg,
 			     SoupMessageCallbackFn  handler_cb,
 			     gpointer               user_data)
 {
-	GSList *iter = msg->priv->content_handlers;
+	SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg);
+
+	GSList *iter = priv->content_handlers;
 
 	while (iter) {
 		SoupHandlerData *data = iter->data;
@@ -252,8 +256,8 @@ soup_message_remove_handler (SoupMessage           *msg,
 		if (data->handler_cb == handler_cb &&
 		    data->user_data == user_data &&
 		    data->phase == phase) {
-			msg->priv->content_handlers =
-				g_slist_remove (msg->priv->content_handlers,
+			priv->content_handlers =
+				g_slist_remove (priv->content_handlers,
 						data);
 			g_free (data);
 			break;
diff --git a/libsoup/soup-message-io.c b/libsoup/soup-message-io.c
index 7350378b..b551a277 100644
--- a/libsoup/soup-message-io.c
+++ b/libsoup/soup-message-io.c
@@ -64,15 +64,16 @@ typedef struct {
  */
 #define dummy_to_make_emacs_happy {
 #define SOUP_MESSAGE_IO_PREPARE_FOR_CALLBACK { gboolean cancelled; g_object_ref (msg);
-#define SOUP_MESSAGE_IO_RETURN_IF_CANCELLED_OR_PAUSED cancelled = (msg->priv->io_data != io); g_object_unref (msg); if (cancelled || !io->read_tag || !io->write_tag) return; }
-#define SOUP_MESSAGE_IO_RETURN_VAL_IF_CANCELLED_OR_PAUSED(val) cancelled = (msg->priv->io_data != io); g_object_unref (msg); if (cancelled || !io->read_tag || !io->write_tag) return val; }
+#define SOUP_MESSAGE_IO_RETURN_IF_CANCELLED_OR_PAUSED cancelled = (priv->io_data != io); g_object_unref (msg); if (cancelled || !io->read_tag || !io->write_tag) return; }
+#define SOUP_MESSAGE_IO_RETURN_VAL_IF_CANCELLED_OR_PAUSED(val) cancelled = (priv->io_data != io); g_object_unref (msg); if (cancelled || !io->read_tag || !io->write_tag) return val; }
 
 #define RESPONSE_BLOCK_SIZE 8192
 
 static void
 io_cleanup (SoupMessage *msg)
 {
-	SoupMessageIOData *io = msg->priv->io_data;
+	SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg);
+	SoupMessageIOData *io = priv->io_data;
 
 	if (!io)
 		return;
@@ -89,7 +90,7 @@ io_cleanup (SoupMessage *msg)
 	g_string_free (io->write_buf, TRUE);
 
 	g_free (io);
-	msg->priv->io_data = NULL;
+	priv->io_data = NULL;
 }
 
 /**
@@ -102,7 +103,8 @@ io_cleanup (SoupMessage *msg)
 void
 soup_message_io_stop (SoupMessage *msg)
 {
-	SoupMessageIOData *io = msg->priv->io_data;
+	SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg);
+	SoupMessageIOData *io = priv->io_data;
 
 	if (!io)
 		return;
@@ -145,7 +147,8 @@ soup_message_io_finished (SoupMessage *msg)
 static void
 io_error (SoupSocket *sock, SoupMessage *msg)
 {
-	SoupMessageIOData *io = msg->priv->io_data;
+	SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg);
+	SoupMessageIOData *io = priv->io_data;
 
 	/* Closing the connection to signify EOF is sometimes ok */
 	if (io->read_state == SOUP_MESSAGE_IO_STATE_BODY &&
@@ -173,7 +176,8 @@ io_error (SoupSocket *sock, SoupMessage *msg)
 static gboolean
 read_metadata (SoupMessage *msg, const char *boundary)
 {
-	SoupMessageIOData *io = msg->priv->io_data;
+	SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg);
+	SoupMessageIOData *io = priv->io_data;
 	SoupSocketIOStatus status;
 	char read_buf[RESPONSE_BLOCK_SIZE];
 	guint boundary_len = strlen (boundary);
@@ -206,7 +210,8 @@ read_metadata (SoupMessage *msg, const char *boundary)
 static gboolean
 read_body_chunk (SoupMessage *msg)
 {
-	SoupMessageIOData *io = msg->priv->io_data;
+	SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg);
+	SoupMessageIOData *io = priv->io_data;
 	SoupSocketIOStatus status;
 	char read_buf[RESPONSE_BLOCK_SIZE];
 	guint len = sizeof (read_buf);
@@ -259,7 +264,8 @@ read_body_chunk (SoupMessage *msg)
 static gboolean
 write_data (SoupMessage *msg, const char *data, guint len)
 {
-	SoupMessageIOData *io = msg->priv->io_data;
+	SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg);
+	SoupMessageIOData *io = priv->io_data;
 	SoupSocketIOStatus status;
 	gsize nwrote;
 
@@ -326,7 +332,8 @@ static void io_read (SoupSocket *sock, SoupMessage *msg);
 static void
 io_write (SoupSocket *sock, SoupMessage *msg)
 {
-	SoupMessageIOData *io = msg->priv->io_data;
+	SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg);
+	SoupMessageIOData *io = priv->io_data;
 
  write_more:
 	switch (io->write_state) {
@@ -366,7 +373,7 @@ io_write (SoupSocket *sock, SoupMessage *msg)
 				 */
 			}
 		} else if (io->mode == SOUP_MESSAGE_IO_CLIENT &&
-			   msg->priv->msg_flags & SOUP_MESSAGE_EXPECT_CONTINUE) {
+			   priv->msg_flags & SOUP_MESSAGE_EXPECT_CONTINUE) {
 			/* Need to wait for the Continue response */
 			io->write_state = SOUP_MESSAGE_IO_STATE_BLOCKING;
 			io->read_state = SOUP_MESSAGE_IO_STATE_HEADERS;
@@ -499,7 +506,8 @@ io_write (SoupSocket *sock, SoupMessage *msg)
 static void
 io_read (SoupSocket *sock, SoupMessage *msg)
 {
-	SoupMessageIOData *io = msg->priv->io_data;
+	SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg);
+	SoupMessageIOData *io = priv->io_data;
 	guint status;
 
  read_more:
@@ -550,7 +558,7 @@ io_read (SoupSocket *sock, SoupMessage *msg)
 				io->read_state = SOUP_MESSAGE_IO_STATE_HEADERS;
 			}
 		} else if (io->mode == SOUP_MESSAGE_IO_SERVER &&
-			   (msg->priv->msg_flags & SOUP_MESSAGE_EXPECT_CONTINUE)) {
+			   (priv->msg_flags & SOUP_MESSAGE_EXPECT_CONTINUE)) {
 			/* The client requested a Continue response. */
 			io->write_state = SOUP_MESSAGE_IO_STATE_HEADERS;
 			io->read_state = SOUP_MESSAGE_IO_STATE_BLOCKING;
@@ -661,6 +669,7 @@ new_iostate (SoupMessage *msg, SoupSocket *sock, SoupMessageIOMode mode,
 	     SoupMessageParseHeadersFn parse_headers_cb,
 	     gpointer user_data)
 {
+	SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg);
 	SoupMessageIOData *io;
 
 	io = g_new0 (SoupMessageIOData, 1);
@@ -674,7 +683,7 @@ new_iostate (SoupMessage *msg, SoupSocket *sock, SoupMessageIOMode mode,
 	io->write_encoding   = SOUP_TRANSFER_UNKNOWN;
 
 	io->read_meta_buf    = g_byte_array_new ();
-	if (!(msg->priv->msg_flags & SOUP_MESSAGE_OVERWRITE_CHUNKS))
+	if (!(priv->msg_flags & SOUP_MESSAGE_OVERWRITE_CHUNKS))
 		io->read_buf = g_byte_array_new ();
 	io->write_buf        = g_string_new (NULL);
 
@@ -688,9 +697,9 @@ new_iostate (SoupMessage *msg, SoupSocket *sock, SoupMessageIOMode mode,
 	io->read_state  = SOUP_MESSAGE_IO_STATE_NOT_STARTED;
 	io->write_state = SOUP_MESSAGE_IO_STATE_NOT_STARTED;
 
-	if (msg->priv->io_data)
+	if (priv->io_data)
 		io_cleanup (msg);
-	msg->priv->io_data = io;
+	priv->io_data = io;
 	return io;
 }
 
@@ -763,7 +772,8 @@ soup_message_io_server (SoupMessage *msg, SoupSocket *sock,
 void  
 soup_message_io_pause (SoupMessage *msg)
 {
-	SoupMessageIOData *io = msg->priv->io_data;
+	SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg);
+	SoupMessageIOData *io = priv->io_data;
 
 	g_return_if_fail (io != NULL);
 
@@ -786,7 +796,8 @@ soup_message_io_pause (SoupMessage *msg)
 void  
 soup_message_io_unpause (SoupMessage *msg)
 {
-	SoupMessageIOData *io = msg->priv->io_data;
+	SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg);
+	SoupMessageIOData *io = priv->io_data;
 
 	g_return_if_fail (io != NULL);
 
diff --git a/libsoup/soup-message-private.h b/libsoup/soup-message-private.h
index c17bc78d..e1168f6d 100644
--- a/libsoup/soup-message-private.h
+++ b/libsoup/soup-message-private.h
@@ -8,7 +8,7 @@
 
 #include <libsoup/soup-message.h>
 
-struct SoupMessagePrivate {
+typedef struct {
 	gpointer           io_data;
 
 	guint              msg_flags;
@@ -20,7 +20,8 @@ struct SoupMessagePrivate {
 	SoupHttpVersion    http_version;
 
 	SoupUri           *uri;
-};
+} SoupMessagePrivate;
+#define SOUP_MESSAGE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_MESSAGE, SoupMessagePrivate))
 
 void             soup_message_run_handlers     (SoupMessage      *msg,
 						SoupHandlerPhase  phase);
diff --git a/libsoup/soup-message-server-io.c b/libsoup/soup-message-server-io.c
index 96d8dc84..1462cec6 100644
--- a/libsoup/soup-message-server-io.c
+++ b/libsoup/soup-message-server-io.c
@@ -25,6 +25,7 @@ parse_request_headers (SoupMessage *msg, char *headers, guint headers_len,
 		       SoupTransferEncoding *encoding, guint *content_len,
 		       gpointer sock)
 {
+	SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg);
 	SoupUri *uri;
 	char *req_path = NULL, *url;
 	const char *expect, *length, *enc, *req_host;
@@ -34,12 +35,12 @@ parse_request_headers (SoupMessage *msg, char *headers, guint headers_len,
 					 msg->request_headers,
 					 (char **) &msg->method,
 					 &req_path,
-					 &msg->priv->http_version))
+					 &priv->http_version))
 		return SOUP_STATUS_BAD_REQUEST;
 
 	expect = soup_message_get_header (msg->request_headers, "Expect");
 	if (expect && !strcmp (expect, "100-continue"))
-		msg->priv->msg_flags |= SOUP_MESSAGE_EXPECT_CONTINUE;
+		priv->msg_flags |= SOUP_MESSAGE_EXPECT_CONTINUE;
 
 	/* Handle request body encoding */
 	length = soup_message_get_header (msg->request_headers,
@@ -90,7 +91,7 @@ parse_request_headers (SoupMessage *msg, char *headers, guint headers_len,
 				       soup_server_get_protocol (server) == SOUP_PROTOCOL_HTTPS ? "https" : "http",
 				       req_host, soup_server_get_port (server),
 				       req_path);
-	} else if (msg->priv->http_version == SOUP_HTTP_1_0) {
+	} else if (priv->http_version == SOUP_HTTP_1_0) {
 		/* No Host header, no AbsoluteUri */
 		SoupAddress *addr = soup_socket_get_local_address (sock);
 		const char *host = soup_address_get_physical (addr);
diff --git a/libsoup/soup-message.c b/libsoup/soup-message.c
index 2960f74a..50afe930 100644
--- a/libsoup/soup-message.c
+++ b/libsoup/soup-message.c
@@ -14,8 +14,7 @@
 #include "soup-misc.h"
 #include "soup-uri.h"
 
-#define PARENT_TYPE G_TYPE_OBJECT
-static GObjectClass *parent_class;
+G_DEFINE_TYPE (SoupMessage, soup_message, G_TYPE_OBJECT)
 
 enum {
 	WROTE_INFORMATIONAL,
@@ -45,12 +44,8 @@ static void finished (SoupMessage *req);
 static void free_chunks (SoupMessage *msg);
 
 static void
-init (GObject *object)
+soup_message_init (SoupMessage *msg)
 {
-	SoupMessage *msg = SOUP_MESSAGE (object);
-
-	msg->priv = g_new0 (SoupMessagePrivate, 1);
-
 	msg->status  = SOUP_MESSAGE_STATUS_IDLE;
 
 	msg->request_headers = g_hash_table_new (soup_str_case_hash,
@@ -59,18 +54,19 @@ init (GObject *object)
 	msg->response_headers = g_hash_table_new (soup_str_case_hash,
 						  soup_str_case_equal);
 
-	msg->priv->http_version = SOUP_HTTP_1_1;
+	SOUP_MESSAGE_GET_PRIVATE (msg)->http_version = SOUP_HTTP_1_1;
 }
 
 static void
 finalize (GObject *object)
 {
 	SoupMessage *msg = SOUP_MESSAGE (object);
+	SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg);
 
 	soup_message_io_stop (msg);
 
-	if (msg->priv->uri)
-		soup_uri_free (msg->priv->uri);
+	if (priv->uri)
+		soup_uri_free (priv->uri);
 
 	if (msg->request.owner == SOUP_BUFFER_SYSTEM_OWNED)
 		g_free (msg->request.body);
@@ -84,22 +80,20 @@ finalize (GObject *object)
 	soup_message_clear_headers (msg->response_headers);
 	g_hash_table_destroy (msg->response_headers);
 
-	g_slist_foreach (msg->priv->content_handlers, (GFunc) g_free, NULL);
-	g_slist_free (msg->priv->content_handlers);
+	g_slist_foreach (priv->content_handlers, (GFunc) g_free, NULL);
+	g_slist_free (priv->content_handlers);
 
 	g_free ((char *) msg->reason_phrase);
 
-	g_free (msg->priv);
-
-	G_OBJECT_CLASS (parent_class)->finalize (object);
+	G_OBJECT_CLASS (soup_message_parent_class)->finalize (object);
 }
 
 static void
-class_init (GObjectClass *object_class)
+soup_message_class_init (SoupMessageClass *message_class)
 {
-	SoupMessageClass *message_class = SOUP_MESSAGE_CLASS (object_class);
+	GObjectClass *object_class = G_OBJECT_CLASS (message_class);
 
-	parent_class = g_type_class_ref (PARENT_TYPE);
+	g_type_class_add_private (message_class, sizeof (SoupMessagePrivate));
 
 	/* virtual method definition */
 	message_class->wrote_body   = wrote_body;
@@ -197,8 +191,6 @@ class_init (GObjectClass *object_class)
 			      G_TYPE_NONE, 0);
 }
 
-SOUP_MAKE_TYPE (soup_message, SoupMessage, class_init, init, PARENT_TYPE)
-
 
 /**
  * soup_message_new:
@@ -227,7 +219,7 @@ soup_message_new (const char *method, const char *uri_string)
 
 	msg = g_object_new (SOUP_TYPE_MESSAGE, NULL);
 	msg->method = method ? method : SOUP_METHOD_GET;
-	msg->priv->uri = uri;
+	SOUP_MESSAGE_GET_PRIVATE (msg)->uri = uri;
 
 	return msg;
 }
@@ -248,7 +240,7 @@ soup_message_new_from_uri (const char *method, const SoupUri *uri)
 
 	msg = g_object_new (SOUP_TYPE_MESSAGE, NULL);
 	msg->method = method ? method : SOUP_METHOD_GET;
-	msg->priv->uri = soup_uri_copy (uri);
+	SOUP_MESSAGE_GET_PRIVATE (msg)->uri = soup_uri_copy (uri);
 
 	return msg;
 }
@@ -695,7 +687,7 @@ soup_message_set_flags (SoupMessage *msg, guint flags)
 {
 	g_return_if_fail (SOUP_IS_MESSAGE (msg));
 
-	msg->priv->msg_flags = flags;
+	SOUP_MESSAGE_GET_PRIVATE (msg)->msg_flags = flags;
 }
 
 /**
@@ -711,7 +703,7 @@ soup_message_get_flags (SoupMessage *msg)
 {
 	g_return_val_if_fail (SOUP_IS_MESSAGE (msg), 0);
 
-	return msg->priv->msg_flags;
+	return SOUP_MESSAGE_GET_PRIVATE (msg)->msg_flags;
 }
 
 /**
@@ -728,7 +720,7 @@ soup_message_set_http_version (SoupMessage *msg, SoupHttpVersion version)
 {
 	g_return_if_fail (SOUP_IS_MESSAGE (msg));
 
-	msg->priv->http_version = version;
+	SOUP_MESSAGE_GET_PRIVATE (msg)->http_version = version;
 }
 
 /**
@@ -745,7 +737,7 @@ soup_message_get_http_version (SoupMessage *msg)
 {
 	g_return_val_if_fail (SOUP_IS_MESSAGE (msg), SOUP_HTTP_1_0);
 
-	return msg->priv->http_version;
+	return SOUP_MESSAGE_GET_PRIVATE (msg)->http_version;
 }
 
 /**
@@ -769,7 +761,7 @@ soup_message_is_keepalive (SoupMessage *msg)
 	    soup_method_get_id (msg->method) == SOUP_METHOD_ID_CONNECT)
 		return TRUE;
 
-	if (msg->priv->http_version == SOUP_HTTP_1_0) {
+	if (SOUP_MESSAGE_GET_PRIVATE (msg)->http_version == SOUP_HTTP_1_0) {
 		/* Only persistent if the client requested keepalive
 		 * and the server agreed.
 		 */
@@ -804,17 +796,20 @@ soup_message_is_keepalive (SoupMessage *msg)
 void
 soup_message_set_uri (SoupMessage *msg, const SoupUri *new_uri)
 {
+	SoupMessagePrivate *priv;
+
 	g_return_if_fail (SOUP_IS_MESSAGE (msg));
+	priv = SOUP_MESSAGE_GET_PRIVATE (msg);
 
-	if (msg->priv->uri && new_uri) {
-		if (strcmp (msg->priv->uri->host, new_uri->host) != 0)
+	if (priv->uri && new_uri) {
+		if (strcmp (priv->uri->host, new_uri->host) != 0)
 			soup_message_io_stop (msg);
 	} else if (!new_uri)
 		soup_message_io_stop (msg);
 
-	if (msg->priv->uri)
-		soup_uri_free (msg->priv->uri);
-	msg->priv->uri = soup_uri_copy (new_uri);
+	if (priv->uri)
+		soup_uri_free (priv->uri);
+	priv->uri = soup_uri_copy (new_uri);
 }
 
 /**
@@ -830,7 +825,7 @@ soup_message_get_uri (SoupMessage *msg)
 {
 	g_return_val_if_fail (SOUP_IS_MESSAGE (msg), NULL);
 
-	return msg->priv->uri;
+	return SOUP_MESSAGE_GET_PRIVATE (msg)->uri;
 }
 
 /**
@@ -893,9 +888,11 @@ soup_message_add_chunk (SoupMessage   *msg,
 			const char    *body,
 			guint          length)
 {
+	SoupMessagePrivate *priv;
 	SoupDataBuffer *chunk;
 
 	g_return_if_fail (SOUP_IS_MESSAGE (msg));
+	priv = SOUP_MESSAGE_GET_PRIVATE (msg);
 	g_return_if_fail (body != NULL || length == 0);
 
 	chunk = g_new0 (SoupDataBuffer, 1);
@@ -908,11 +905,11 @@ soup_message_add_chunk (SoupMessage   *msg,
 	}
 	chunk->length = length;
 
-	if (msg->priv->chunks) {
-		g_slist_append (msg->priv->last_chunk, chunk);
-		msg->priv->last_chunk = msg->priv->last_chunk->next;
+	if (priv->chunks) {
+		g_slist_append (priv->last_chunk, chunk);
+		priv->last_chunk = priv->last_chunk->next;
 	} else {
-		msg->priv->chunks = msg->priv->last_chunk =
+		priv->chunks = priv->last_chunk =
 			g_slist_append (NULL, chunk);
 	}
 }
@@ -944,17 +941,19 @@ soup_message_add_final_chunk (SoupMessage *msg)
 SoupDataBuffer *
 soup_message_pop_chunk (SoupMessage *msg)
 {
+	SoupMessagePrivate *priv;
 	SoupDataBuffer *chunk;
 
 	g_return_val_if_fail (SOUP_IS_MESSAGE (msg), NULL);
+	priv = SOUP_MESSAGE_GET_PRIVATE (msg);
 
-	if (!msg->priv->chunks)
+	if (!priv->chunks)
 		return NULL;
 
-	chunk = msg->priv->chunks->data;
-	msg->priv->chunks = g_slist_remove (msg->priv->chunks, chunk);
-	if (!msg->priv->chunks)
-		msg->priv->last_chunk = NULL;
+	chunk = priv->chunks->data;
+	priv->chunks = g_slist_remove (priv->chunks, chunk);
+	if (!priv->chunks)
+		priv->last_chunk = NULL;
 
 	return chunk;
 }
@@ -962,10 +961,11 @@ soup_message_pop_chunk (SoupMessage *msg)
 static void
 free_chunks (SoupMessage *msg)
 {
+	SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg);
 	SoupDataBuffer *chunk;
 	GSList *ch;
 
-	for (ch = msg->priv->chunks; ch; ch = ch->next) {
+	for (ch = priv->chunks; ch; ch = ch->next) {
 		chunk = ch->data;
 
 		if (chunk->owner == SOUP_BUFFER_SYSTEM_OWNED)
@@ -973,6 +973,6 @@ free_chunks (SoupMessage *msg)
 		g_free (chunk);
 	}
 
-	g_slist_free (msg->priv->chunks);
-	msg->priv->chunks = msg->priv->last_chunk = NULL;
+	g_slist_free (priv->chunks);
+	priv->chunks = priv->last_chunk = NULL;
 }
diff --git a/libsoup/soup-message.h b/libsoup/soup-message.h
index af2b28d8..e47da727 100644
--- a/libsoup/soup-message.h
+++ b/libsoup/soup-message.h
@@ -16,8 +16,6 @@
 #define SOUP_IS_MESSAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_MESSAGE))
 #define SOUP_MESSAGE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_MESSAGE, SoupMessageClass))
 
-typedef struct SoupMessagePrivate SoupMessagePrivate;
-
 typedef enum {
 	SOUP_MESSAGE_STATUS_IDLE,
 	SOUP_MESSAGE_STATUS_QUEUED,
@@ -49,8 +47,6 @@ typedef struct {
 struct SoupMessage {
 	GObject parent;
 
-	SoupMessagePrivate *priv;
-
 	const char         *method;
 
 	guint               status_code;
diff --git a/libsoup/soup-server-message.c b/libsoup/soup-server-message.c
index 24bb9590..0de75108 100644
--- a/libsoup/soup-server-message.c
+++ b/libsoup/soup-server-message.c
@@ -17,24 +17,21 @@
 #include "soup-server-message.h"
 #include "soup-server.h"
 
-struct SoupServerMessagePrivate {
+typedef struct {
 	SoupServer *server;
 
 	SoupTransferEncoding encoding;
 
 	gboolean  started;
 	gboolean  finished;
-};
+} SoupServerMessagePrivate;
+#define SOUP_SERVER_MESSAGE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_SERVER_MESSAGE, SoupServerMessagePrivate))
 
-#define PARENT_TYPE SOUP_TYPE_MESSAGE
-static SoupMessageClass *parent_class;
+G_DEFINE_TYPE (SoupServerMessage, soup_server_message, SOUP_TYPE_MESSAGE)
 
 static void
-init (GObject *object)
+soup_server_message_init (SoupServerMessage *smsg)
 {
-	SoupServerMessage *smsg = SOUP_SERVER_MESSAGE (object);
-
-	smsg->priv = g_new0 (SoupServerMessagePrivate, 1);
 }
 
 static void
@@ -45,36 +42,32 @@ finalize (GObject *object)
 	/* FIXME */
 	g_free ((char *) ((SoupMessage *)smsg)->method);
 
-	g_free (smsg->priv);
-
-	G_OBJECT_CLASS (parent_class)->finalize (object);
+	G_OBJECT_CLASS (soup_server_message_parent_class)->finalize (object);
 }
 
 static void
 dispose (GObject *object)
 {
-	SoupServerMessage *smsg = SOUP_SERVER_MESSAGE (object);
+	SoupServerMessagePrivate *priv = SOUP_SERVER_MESSAGE_GET_PRIVATE (object);
 
-	if (smsg->priv->server)
-		g_object_unref (smsg->priv->server);
+	if (priv->server)
+		g_object_unref (priv->server);
 
-	G_OBJECT_CLASS (parent_class)->dispose (object);
+	G_OBJECT_CLASS (soup_server_message_parent_class)->dispose (object);
 }
 
-
-
 static void
-class_init (GObjectClass *object_class)
+soup_server_message_class_init (SoupServerMessageClass *soup_server_message_class)
 {
-	parent_class = g_type_class_ref (PARENT_TYPE);
+	GObjectClass *object_class = G_OBJECT_CLASS (soup_server_message_class);
+
+	g_type_class_add_private (soup_server_message_class, sizeof (SoupServerMessagePrivate));
 
 	/* virtual method override */
 	object_class->finalize = finalize;
 	object_class->dispose = dispose;
 }
 
-SOUP_MAKE_TYPE (soup_server_message, SoupServerMessage, class_init, init, PARENT_TYPE)
-
 
 SoupServerMessage *
 soup_server_message_new (SoupServer *server)
@@ -84,7 +77,7 @@ soup_server_message_new (SoupServer *server)
 	g_return_val_if_fail (SOUP_IS_SERVER (server), NULL);
 
 	smsg = g_object_new (SOUP_TYPE_SERVER_MESSAGE, NULL);
-	smsg->priv->server = g_object_ref (server);
+	SOUP_SERVER_MESSAGE_GET_PRIVATE (smsg)->server = g_object_ref (server);
 
 	return smsg;
 }
@@ -94,7 +87,7 @@ soup_server_message_get_server (SoupServerMessage *smsg)
 {
 	g_return_val_if_fail (SOUP_IS_SERVER_MESSAGE (smsg), NULL);
 
-	return smsg->priv->server;
+	return SOUP_SERVER_MESSAGE_GET_PRIVATE (smsg)->server;
 }
 
 void
@@ -103,7 +96,7 @@ soup_server_message_set_encoding (SoupServerMessage *smsg,
 {
 	g_return_if_fail (SOUP_IS_SERVER_MESSAGE (smsg));
 
-	smsg->priv->encoding = encoding;
+	SOUP_SERVER_MESSAGE_GET_PRIVATE (smsg)->encoding = encoding;
 }
 
 SoupTransferEncoding
@@ -111,7 +104,7 @@ soup_server_message_get_encoding (SoupServerMessage *smsg)
 {
 	g_return_val_if_fail (SOUP_IS_SERVER_MESSAGE (smsg), SOUP_TRANSFER_UNKNOWN);
 
-	return smsg->priv->encoding;
+	return SOUP_SERVER_MESSAGE_GET_PRIVATE (smsg)->encoding;
 }
 
 void
@@ -119,7 +112,7 @@ soup_server_message_start (SoupServerMessage *smsg)
 {
 	g_return_if_fail (SOUP_IS_SERVER_MESSAGE (smsg));
 
-	smsg->priv->started = TRUE;
+	SOUP_SERVER_MESSAGE_GET_PRIVATE (smsg)->started = TRUE;
 
 	soup_message_io_unpause (SOUP_MESSAGE (smsg));
 }
@@ -129,16 +122,19 @@ soup_server_message_is_started (SoupServerMessage *smsg)
 {
 	g_return_val_if_fail (SOUP_IS_SERVER_MESSAGE (smsg), TRUE);
 
-	return smsg->priv->started;
+	return SOUP_SERVER_MESSAGE_GET_PRIVATE (smsg)->started;
 }
 
 void
 soup_server_message_finish  (SoupServerMessage *smsg)
 {
+	SoupServerMessagePrivate *priv;
+
 	g_return_if_fail (SOUP_IS_SERVER_MESSAGE (smsg));
+	priv = SOUP_SERVER_MESSAGE_GET_PRIVATE (smsg);
 
-	smsg->priv->started = TRUE;
-	smsg->priv->finished = TRUE;
+	priv->started = TRUE;
+	priv->finished = TRUE;
 
 	soup_message_io_unpause (SOUP_MESSAGE (smsg));
 }
@@ -148,5 +144,5 @@ soup_server_message_is_finished (SoupServerMessage *smsg)
 {
 	g_return_val_if_fail (SOUP_IS_SERVER_MESSAGE (smsg), TRUE);
 
-	return smsg->priv->finished;
+	return SOUP_SERVER_MESSAGE_GET_PRIVATE (smsg)->finished;
 }
diff --git a/libsoup/soup-server-message.h b/libsoup/soup-server-message.h
index 349c2b7c..201b43ac 100644
--- a/libsoup/soup-server-message.h
+++ b/libsoup/soup-server-message.h
@@ -15,12 +15,9 @@
 #define SOUP_IS_SERVER_MESSAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_SERVER_MESSAGE))
 #define SOUP_SERVER_MESSAGE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_SERVER_MESSAGE, SoupServerMessageClass))
 
-typedef struct SoupServerMessagePrivate SoupServerMessagePrivate;
-
 struct SoupServerMessage {
 	SoupMessage parent;
 
-	SoupServerMessagePrivate *priv;
 };
 
 typedef struct {
diff --git a/libsoup/soup-server.c b/libsoup/soup-server.c
index e0738da7..620266c2 100644
--- a/libsoup/soup-server.c
+++ b/libsoup/soup-server.c
@@ -26,10 +26,9 @@
 #include "soup-socket.h"
 #include "soup-ssl.h"
 
-#define PARENT_TYPE G_TYPE_OBJECT
-static GObjectClass *parent_class;
+G_DEFINE_TYPE (SoupServer, soup_server, G_TYPE_OBJECT)
 
-struct SoupServerPrivate {
+typedef struct {
 	SoupAddress       *interface;
 	guint              port;
 
@@ -43,17 +42,18 @@ struct SoupServerPrivate {
 
 	GHashTable        *handlers; /* KEY: path, VALUE: SoupServerHandler */
 	SoupServerHandler *default_handler;
-};
+} SoupServerPrivate;
+#define SOUP_SERVER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_SERVER, SoupServerPrivate))
 
 enum {
-  PROP_0,
+	PROP_0,
 
-  PROP_PORT,
-  PROP_INTERFACE,
-  PROP_SSL_CERT_FILE,
-  PROP_SSL_KEY_FILE,
+	PROP_PORT,
+	PROP_INTERFACE,
+	PROP_SSL_CERT_FILE,
+	PROP_SSL_KEY_FILE,
 
-  LAST_PROP
+	LAST_PROP
 };
 
 static void set_property (GObject *object, guint prop_id,
@@ -62,12 +62,11 @@ static void get_property (GObject *object, guint prop_id,
 			  GValue *value, GParamSpec *pspec);
 
 static void
-init (GObject *object)
+soup_server_init (SoupServer *server)
 {
-	SoupServer *server = SOUP_SERVER (object);
+	SoupServerPrivate *priv = SOUP_SERVER_GET_PRIVATE (server);
 
-	server->priv = g_new0 (SoupServerPrivate, 1);
-	server->priv->handlers = g_hash_table_new (g_str_hash, g_str_equal);
+	priv->handlers = g_hash_table_new (g_str_hash, g_str_equal);
 }
 
 static void
@@ -96,45 +95,45 @@ static void
 finalize (GObject *object)
 {
 	SoupServer *server = SOUP_SERVER (object);
+	SoupServerPrivate *priv = SOUP_SERVER_GET_PRIVATE (server);
 
-	if (server->priv->interface)
-		g_object_unref (server->priv->interface);
+	if (priv->interface)
+		g_object_unref (priv->interface);
 
-	g_free (server->priv->ssl_cert_file);
-	g_free (server->priv->ssl_key_file);
-	if (server->priv->ssl_creds)
-		soup_ssl_free_server_credentials (server->priv->ssl_creds);
+	g_free (priv->ssl_cert_file);
+	g_free (priv->ssl_key_file);
+	if (priv->ssl_creds)
+		soup_ssl_free_server_credentials (priv->ssl_creds);
 
-	if (server->priv->listen_sock)
-		g_object_unref (server->priv->listen_sock);
+	if (priv->listen_sock)
+		g_object_unref (priv->listen_sock);
 
-	while (server->priv->client_socks) {
-		SoupSocket *sock = server->priv->client_socks->data;
+	while (priv->client_socks) {
+		SoupSocket *sock = priv->client_socks->data;
 
 		soup_socket_disconnect (sock);
-		server->priv->client_socks =
-			g_slist_remove (server->priv->client_socks, sock);
+		priv->client_socks =
+			g_slist_remove (priv->client_socks, sock);
 	}
 
-	if (server->priv->default_handler)
-		free_handler (server, server->priv->default_handler);
+	if (priv->default_handler)
+		free_handler (server, priv->default_handler);
 
-	g_hash_table_foreach (server->priv->handlers,
-			      free_handler_foreach, server);
-	g_hash_table_destroy (server->priv->handlers);
+	g_hash_table_foreach (priv->handlers, free_handler_foreach, server);
+	g_hash_table_destroy (priv->handlers);
 
-	if (server->priv->loop)
-		g_main_loop_unref (server->priv->loop);
+	if (priv->loop)
+		g_main_loop_unref (priv->loop);
 
-	g_free (server->priv);
-
-	G_OBJECT_CLASS (parent_class)->finalize (object);
+	G_OBJECT_CLASS (soup_server_parent_class)->finalize (object);
 }
 
 static void
-class_init (GObjectClass *object_class)
+soup_server_class_init (SoupServerClass *server_class)
 {
-	parent_class = g_type_class_ref (PARENT_TYPE);
+	GObjectClass *object_class = G_OBJECT_CLASS (server_class);
+
+	g_type_class_add_private (server_class, sizeof (SoupServerPrivate));
 
 	/* virtual method override */
 	object_class->finalize = finalize;
@@ -159,44 +158,43 @@ class_init (GObjectClass *object_class)
 	g_object_class_install_property (
 		object_class, PROP_SSL_CERT_FILE,
 		g_param_spec_string (SOUP_SERVER_SSL_CERT_FILE,
-				      "SSL certificate file",
-				      "File containing server SSL certificate",
-				      NULL,
-				      G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
+				     "SSL certificate file",
+				     "File containing server SSL certificate",
+				     NULL,
+				     G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 	g_object_class_install_property (
 		object_class, PROP_SSL_KEY_FILE,
 		g_param_spec_string (SOUP_SERVER_SSL_KEY_FILE,
-				      "SSL key file",
-				      "File containing server SSL key",
-				      NULL,
-				      G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
+				     "SSL key file",
+				     "File containing server SSL key",
+				     NULL,
+				     G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 }
 
-SOUP_MAKE_TYPE (soup_server, SoupServer, class_init, init, PARENT_TYPE)
 
 static void
 set_property (GObject *object, guint prop_id,
 	      const GValue *value, GParamSpec *pspec)
 {
-	SoupServer *server = SOUP_SERVER (object);
+	SoupServerPrivate *priv = SOUP_SERVER_GET_PRIVATE (object);
 
 	switch (prop_id) {
 	case PROP_PORT:
-		server->priv->port = g_value_get_uint (value);
+		priv->port = g_value_get_uint (value);
 		break;
 	case PROP_INTERFACE:
-		if (server->priv->interface)
-			g_object_unref (server->priv->interface);
-		server->priv->interface = g_value_get_object (value);
-		if (server->priv->interface)
-			g_object_ref (server->priv->interface);
+		if (priv->interface)
+			g_object_unref (priv->interface);
+		priv->interface = g_value_get_object (value);
+		if (priv->interface)
+			g_object_ref (priv->interface);
 		break;
 	case PROP_SSL_CERT_FILE:
-		server->priv->ssl_cert_file =
+		priv->ssl_cert_file =
 			g_strdup (g_value_get_string (value));
 		break;
 	case PROP_SSL_KEY_FILE:
-		server->priv->ssl_key_file =
+		priv->ssl_key_file =
 			g_strdup (g_value_get_string (value));
 		break;
 	default:
@@ -208,20 +206,20 @@ static void
 get_property (GObject *object, guint prop_id,
 	      GValue *value, GParamSpec *pspec)
 {
-	SoupServer *server = SOUP_SERVER (object);
+	SoupServerPrivate *priv = SOUP_SERVER_GET_PRIVATE (object);
 
 	switch (prop_id) {
 	case PROP_PORT:
-		g_value_set_uint (value, server->priv->port);
+		g_value_set_uint (value, priv->port);
 		break;
 	case PROP_INTERFACE:
-		g_value_set_object (value, g_object_ref (server->priv->interface));
+		g_value_set_object (value, g_object_ref (priv->interface));
 		break;
 	case PROP_SSL_CERT_FILE:
-		g_value_set_string (value, g_strdup (server->priv->ssl_cert_file));
+		g_value_set_string (value, g_strdup (priv->ssl_cert_file));
 		break;
 	case PROP_SSL_KEY_FILE:
-		g_value_set_string (value, g_strdup (server->priv->ssl_key_file));
+		g_value_set_string (value, g_strdup (priv->ssl_key_file));
 		break;
 	default:
 		break;
@@ -232,6 +230,7 @@ SoupServer *
 soup_server_new (const char *optname1, ...)
 {
 	SoupServer *server;
+	SoupServerPrivate *priv;
 	va_list ap;
 
 	va_start (ap, optname1);
@@ -241,27 +240,29 @@ soup_server_new (const char *optname1, ...)
 
 	if (!server)
 		return NULL;
-	if (!server->priv->interface) {
-		server->priv->interface =
+	priv = SOUP_SERVER_GET_PRIVATE (server);
+
+	if (!priv->interface) {
+		priv->interface =
 			soup_address_new_any (SOUP_ADDRESS_FAMILY_IPV4,
-					      server->priv->port);
+					      priv->port);
 	}
 
-	if (server->priv->ssl_cert_file && server->priv->ssl_key_file) {
-		server->priv->ssl_creds = soup_ssl_get_server_credentials (
-			server->priv->ssl_cert_file,
-			server->priv->ssl_key_file);
-		if (!server->priv->ssl_creds) {
+	if (priv->ssl_cert_file && priv->ssl_key_file) {
+		priv->ssl_creds = soup_ssl_get_server_credentials (
+			priv->ssl_cert_file,
+			priv->ssl_key_file);
+		if (!priv->ssl_creds) {
 			g_object_unref (server);
 			return NULL;
 		}
 	}
 
-	server->priv->listen_sock =
-		soup_socket_server_new (server->priv->interface,
-					server->priv->ssl_creds,
+	priv->listen_sock =
+		soup_socket_server_new (priv->interface,
+					priv->ssl_creds,
 					NULL, NULL);
-	if (!server->priv->listen_sock) {
+	if (!priv->listen_sock) {
 		g_object_unref (server);
 		return NULL;
 	}
@@ -269,11 +270,10 @@ soup_server_new (const char *optname1, ...)
 	/* Re-resolve the interface address, in particular in case
 	 * the passed-in address had SOUP_ADDRESS_ANY_PORT.
 	 */
-	g_object_unref (server->priv->interface);
-	server->priv->interface =
-		soup_socket_get_local_address (server->priv->listen_sock);
-	g_object_ref (server->priv->interface);
-	server->priv->port = soup_address_get_port (server->priv->interface);
+	g_object_unref (priv->interface);
+	priv->interface = soup_socket_get_local_address (priv->listen_sock);
+	g_object_ref (priv->interface);
+	priv->port = soup_address_get_port (priv->interface);
 
 	return server;
 }
@@ -283,15 +283,18 @@ soup_server_get_port (SoupServer *server)
 {
 	g_return_val_if_fail (SOUP_IS_SERVER (server), 0);
 
-	return server->priv->port;
+	return SOUP_SERVER_GET_PRIVATE (server)->port;
 }
 
 SoupProtocol
 soup_server_get_protocol (SoupServer *server)
 {
+	SoupServerPrivate *priv;
+
 	g_return_val_if_fail (SOUP_IS_SERVER (server), 0);
+	priv = SOUP_SERVER_GET_PRIVATE (server);
 
-	if (server->priv->ssl_cert_file && server->priv->ssl_key_file)
+	if (priv->ssl_cert_file && priv->ssl_key_file)
 		return SOUP_PROTOCOL_HTTPS;
 	else
 		return SOUP_PROTOCOL_HTTP;
@@ -420,8 +423,9 @@ start_request (SoupServer *server, SoupSocket *server_sock)
 static void
 socket_disconnected (SoupSocket *sock, SoupServer *server)
 {
-	server->priv->client_socks =
-		g_slist_remove (server->priv->client_socks, sock);
+	SoupServerPrivate *priv = SOUP_SERVER_GET_PRIVATE (server);
+
+	priv->client_socks = g_slist_remove (priv->client_socks, sock);
 	g_signal_handlers_disconnect_by_func (sock, socket_disconnected, server);
 	g_object_unref (sock);
 }
@@ -430,10 +434,10 @@ static void
 new_connection (SoupSocket *listner, SoupSocket *sock, gpointer user_data)
 {
 	SoupServer *server = user_data;
+	SoupServerPrivate *priv = SOUP_SERVER_GET_PRIVATE (server);
 
 	g_object_ref (sock);
-	server->priv->client_socks =
-		g_slist_prepend (server->priv->client_socks, sock);
+	priv->client_socks = g_slist_prepend (priv->client_socks, sock);
 	g_signal_connect (sock, "disconnected",
 			  G_CALLBACK (socket_disconnected), server);
 	start_request (server, sock);
@@ -442,17 +446,20 @@ new_connection (SoupSocket *listner, SoupSocket *sock, gpointer user_data)
 void
 soup_server_run_async (SoupServer *server)
 {
+	SoupServerPrivate *priv;
+
 	g_return_if_fail (SOUP_IS_SERVER (server));
+	priv = SOUP_SERVER_GET_PRIVATE (server);
 
-	if (!server->priv->listen_sock) {
-		if (server->priv->loop) {
-			g_main_loop_unref (server->priv->loop);
-			server->priv->loop = NULL;
+	if (!priv->listen_sock) {
+		if (priv->loop) {
+			g_main_loop_unref (priv->loop);
+			priv->loop = NULL;
 		}
 		return;
 	}
 
-	g_signal_connect (server->priv->listen_sock, "new_connection",
+	g_signal_connect (priv->listen_sock, "new_connection",
 			  G_CALLBACK (new_connection), server);
 	g_object_ref (server);
 
@@ -463,23 +470,29 @@ soup_server_run_async (SoupServer *server)
 void
 soup_server_run (SoupServer *server)
 {
+	SoupServerPrivate *priv;
+
 	g_return_if_fail (SOUP_IS_SERVER (server));
+	priv = SOUP_SERVER_GET_PRIVATE (server);
 
-	if (!server->priv->loop) {
-		server->priv->loop = g_main_loop_new (NULL, TRUE);
+	if (!priv->loop) {
+		priv->loop = g_main_loop_new (NULL, TRUE);
 		soup_server_run_async (server);
 	}
 
-	if (server->priv->loop)
-		g_main_loop_run (server->priv->loop);
+	if (priv->loop)
+		g_main_loop_run (priv->loop);
 }
 
 void
 soup_server_quit (SoupServer *server)
 {
+	SoupServerPrivate *priv;
+
 	g_return_if_fail (SOUP_IS_SERVER (server));
+	priv = SOUP_SERVER_GET_PRIVATE (server);
 
-	g_main_loop_quit (server->priv->loop);
+	g_main_loop_quit (priv->loop);
 	g_object_unref (server);
 }
 
@@ -494,9 +507,13 @@ append_handler (gpointer key, gpointer value, gpointer user_data)
 GSList *
 soup_server_list_handlers (SoupServer *server)
 {
+	SoupServerPrivate *priv;
 	GSList *ret = NULL;
 
-	g_hash_table_foreach (server->priv->handlers, append_handler, &ret);
+	g_return_val_if_fail (SOUP_IS_SERVER (server), NULL);
+	priv = SOUP_SERVER_GET_PRIVATE (server);
+
+	g_hash_table_foreach (priv->handlers, append_handler, &ret);
 
 	return ret;
 }
@@ -504,13 +521,15 @@ soup_server_list_handlers (SoupServer *server)
 SoupServerHandler *
 soup_server_get_handler (SoupServer *server, const char *path)
 {
+	SoupServerPrivate *priv;
 	char *mypath, *dir;
 	SoupServerHandler *hand = NULL;
 
 	g_return_val_if_fail (SOUP_IS_SERVER (server), NULL);
+	priv = SOUP_SERVER_GET_PRIVATE (server);
 
-	if (!path || !server->priv->handlers)
-		return server->priv->default_handler;
+	if (!path || !priv->handlers)
+		return priv->default_handler;
 
 	mypath = g_strdup (path);
 
@@ -520,7 +539,7 @@ soup_server_get_handler (SoupServer *server, const char *path)
 	dir = mypath;
 
 	do {
-		hand = g_hash_table_lookup (server->priv->handlers, mypath);
+		hand = g_hash_table_lookup (priv->handlers, mypath);
 		if (hand) {
 			g_free (mypath);
 			return hand;
@@ -532,7 +551,7 @@ soup_server_get_handler (SoupServer *server, const char *path)
 
 	g_free (mypath);
 
-	return server->priv->default_handler;
+	return priv->default_handler;
 }
 
 SoupAddress *
@@ -584,11 +603,13 @@ soup_server_add_handler (SoupServer            *server,
 			 SoupServerUnregisterFn unregister,
 			 gpointer               user_data)
 {
+	SoupServerPrivate *priv;
 	SoupServerHandler *hand;
 	SoupServerAuthContext *new_auth_ctx = NULL;
 
 	g_return_if_fail (SOUP_IS_SERVER (server));
 	g_return_if_fail (callback != NULL);
+	priv = SOUP_SERVER_GET_PRIVATE (server);
 
 	if (auth_ctx)
 		new_auth_ctx = auth_context_copy (auth_ctx);
@@ -602,31 +623,33 @@ soup_server_add_handler (SoupServer            *server,
 
 	if (path) {
 		soup_server_remove_handler (server, path);
-		g_hash_table_insert (server->priv->handlers, hand->path, hand);
+		g_hash_table_insert (priv->handlers, hand->path, hand);
 	} else {
 		soup_server_remove_handler (server, NULL);
-		server->priv->default_handler = hand;
+		priv->default_handler = hand;
 	}
 }
 
 void
 soup_server_remove_handler (SoupServer *server, const char *path)
 {
+	SoupServerPrivate *priv;
 	SoupServerHandler *hand;
 
 	g_return_if_fail (SOUP_IS_SERVER (server));
+	priv = SOUP_SERVER_GET_PRIVATE (server);
 
 	if (!path) {
-		if (server->priv->default_handler) {
-			free_handler (server, server->priv->default_handler);
-			server->priv->default_handler = NULL;
+		if (priv->default_handler) {
+			free_handler (server, priv->default_handler);
+			priv->default_handler = NULL;
 		}
 		return;
 	}
 
-	hand = g_hash_table_lookup (server->priv->handlers, path);
+	hand = g_hash_table_lookup (priv->handlers, path);
 	if (hand) {
-		g_hash_table_remove (server->priv->handlers, path);
+		g_hash_table_remove (priv->handlers, path);
 		free_handler (server, hand);
 	}
 }
diff --git a/libsoup/soup-server.h b/libsoup/soup-server.h
index 4c9adf61..c2f6061e 100644
--- a/libsoup/soup-server.h
+++ b/libsoup/soup-server.h
@@ -17,12 +17,9 @@
 #define SOUP_IS_SERVER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_SERVER))
 #define SOUP_SERVER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_SERVER, SoupServerClass))
 
-typedef struct SoupServerPrivate SoupServerPrivate;
-
 struct SoupServer {
 	GObject parent;
 
-	SoupServerPrivate *priv;
 };
 
 typedef struct {
diff --git a/libsoup/soup-session-async.c b/libsoup/soup-session-async.c
index 81a9d44e..b35afecf 100644
--- a/libsoup/soup-session-async.c
+++ b/libsoup/soup-session-async.c
@@ -12,10 +12,6 @@
 #include "soup-session-async.h"
 #include "soup-connection.h"
 
-struct SoupSessionAsyncPrivate {
-	int dummy;
-};
-
 static gboolean run_queue (SoupSessionAsync *sa, gboolean try_pruning);
 
 static void  queue_message   (SoupSession *session, SoupMessage *req,
@@ -23,41 +19,23 @@ static void  queue_message   (SoupSession *session, SoupMessage *req,
 			      gpointer user_data);
 static guint send_message    (SoupSession *session, SoupMessage *req);
 
-#define PARENT_TYPE SOUP_TYPE_SESSION
-static SoupSessionClass *parent_class;
+G_DEFINE_TYPE (SoupSessionAsync, soup_session_async, SOUP_TYPE_SESSION)
 
 static void
-init (GObject *object)
+soup_session_async_init (SoupSessionAsync *sa)
 {
-	SoupSessionAsync *sa = SOUP_SESSION_ASYNC (object);
-
-	sa->priv = g_new0 (SoupSessionAsyncPrivate, 1);
 }
 
 static void
-finalize (GObject *object)
+soup_session_async_class_init (SoupSessionAsyncClass *soup_session_async_class)
 {
-	SoupSessionAsync *sa = SOUP_SESSION_ASYNC (object);
-
-	g_free (sa->priv);
-
-	G_OBJECT_CLASS (parent_class)->finalize (object);
-}
-
-static void
-class_init (GObjectClass *object_class)
-{
-	SoupSessionClass *session_class = SOUP_SESSION_CLASS (object_class);
-
-	parent_class = g_type_class_ref (PARENT_TYPE);
+	SoupSessionClass *session_class = SOUP_SESSION_CLASS (soup_session_async_class);
 
 	/* virtual method override */
 	session_class->queue_message = queue_message;
 	session_class->send_message = send_message;
-	object_class->finalize = finalize;
 }
 
-SOUP_MAKE_TYPE (soup_session_async, SoupSessionAsync, class_init, init, PARENT_TYPE)
 
 SoupSession *
 soup_session_async_new (void)
@@ -205,8 +183,7 @@ queue_message (SoupSession *session, SoupMessage *req,
 	g_signal_connect_after (req, "finished",
 				G_CALLBACK (final_finished), sa);
 
-	SOUP_SESSION_CLASS (parent_class)->queue_message (session, req,
-							  callback, user_data);
+	SOUP_SESSION_CLASS (soup_session_async_parent_class)->queue_message (session, req, callback, user_data);
 
 	run_queue (sa, TRUE);
 }
diff --git a/libsoup/soup-session-async.h b/libsoup/soup-session-async.h
index 26f5fe75..2423809e 100644
--- a/libsoup/soup-session-async.h
+++ b/libsoup/soup-session-async.h
@@ -16,12 +16,9 @@
 #define SOUP_IS_SESSION_ASYNC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_SESSION_ASYNC))
 #define SOUP_SESSION_ASYNC_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_SESSION_ASYNC, SoupSessionAsyncClass))
 
-typedef struct SoupSessionAsyncPrivate SoupSessionAsyncPrivate;
-
 struct SoupSessionAsync {
 	SoupSession parent;
 
-	SoupSessionAsyncPrivate *priv;
 };
 
 typedef struct {
diff --git a/libsoup/soup-session-sync.c b/libsoup/soup-session-sync.c
index 120f0165..88e700ad 100644
--- a/libsoup/soup-session-sync.c
+++ b/libsoup/soup-session-sync.c
@@ -12,10 +12,11 @@
 #include "soup-session-sync.h"
 #include "soup-connection.h"
 
-struct SoupSessionSyncPrivate {
+typedef struct {
 	GMutex *lock;
 	GCond *cond;
-};
+} SoupSessionSyncPrivate;
+#define SOUP_SESSION_SYNC_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_SESSION_SYNC, SoupSessionSyncPrivate))
 
 void         queue_message  (SoupSession *session, SoupMessage *msg,
 			     SoupMessageCallbackFn callback,
@@ -23,37 +24,35 @@ void         queue_message  (SoupSession *session, SoupMessage *msg,
 static guint send_message   (SoupSession *session, SoupMessage *msg);
 static void  cancel_message (SoupSession *session, SoupMessage *msg);
 
-#define PARENT_TYPE SOUP_TYPE_SESSION
-static SoupSessionClass *parent_class;
+G_DEFINE_TYPE (SoupSessionSync, soup_session_sync, SOUP_TYPE_SESSION)
 
 static void
-init (GObject *object)
+soup_session_sync_init (SoupSessionSync *ss)
 {
-	SoupSessionSync *ss = SOUP_SESSION_SYNC (object);
+	SoupSessionSyncPrivate *priv = SOUP_SESSION_SYNC_GET_PRIVATE (ss);
 
-	ss->priv = g_new0 (SoupSessionSyncPrivate, 1);
-	ss->priv->lock = g_mutex_new ();
-	ss->priv->cond = g_cond_new ();
+	priv->lock = g_mutex_new ();
+	priv->cond = g_cond_new ();
 }
 
 static void
 finalize (GObject *object)
 {
-	SoupSessionSync *ss = SOUP_SESSION_SYNC (object);
+	SoupSessionSyncPrivate *priv = SOUP_SESSION_SYNC_GET_PRIVATE (object);
 
-	g_mutex_free (ss->priv->lock);
-	g_cond_free (ss->priv->cond);
-	g_free (ss->priv);
+	g_mutex_free (priv->lock);
+	g_cond_free (priv->cond);
 
-	G_OBJECT_CLASS (parent_class)->finalize (object);
+	G_OBJECT_CLASS (soup_session_sync_parent_class)->finalize (object);
 }
 
 static void
-class_init (GObjectClass *object_class)
+soup_session_sync_class_init (SoupSessionSyncClass *session_sync_class)
 {
-	SoupSessionClass *session_class = SOUP_SESSION_CLASS (object_class);
+	GObjectClass *object_class = G_OBJECT_CLASS (session_sync_class);
+	SoupSessionClass *session_class = SOUP_SESSION_CLASS (session_sync_class);
 
-	parent_class = g_type_class_ref (PARENT_TYPE);
+	g_type_class_add_private (session_sync_class, sizeof (SoupSessionSyncPrivate));
 
 	/* virtual method override */
 	session_class->queue_message = queue_message;
@@ -62,7 +61,6 @@ class_init (GObjectClass *object_class)
 	object_class->finalize = finalize;
 }
 
-SOUP_MAKE_TYPE (soup_session_sync, SoupSessionSync, class_init, init, PARENT_TYPE)
 
 SoupSession *
 soup_session_sync_new (void)
@@ -96,12 +94,12 @@ queue_message (SoupSession *session, SoupMessage *msg,
 static SoupConnection *
 wait_for_connection (SoupSession *session, SoupMessage *msg)
 {
-	SoupSessionSync *ss = SOUP_SESSION_SYNC (session);
+	SoupSessionSyncPrivate *priv = SOUP_SESSION_SYNC_GET_PRIVATE (session);
 	SoupConnection *conn;
 	gboolean try_pruning = FALSE, is_new = FALSE;
 	guint status;
 
-	g_mutex_lock (ss->priv->lock);
+	g_mutex_lock (priv->lock);
 
  try_again:
 	conn = soup_session_get_connection (session, msg,
@@ -127,7 +125,7 @@ wait_for_connection (SoupSession *session, SoupMessage *msg)
 			}
 		}
 
-		g_mutex_unlock (ss->priv->lock);
+		g_mutex_unlock (priv->lock);
 		return conn;
 	}
 
@@ -135,11 +133,11 @@ wait_for_connection (SoupSession *session, SoupMessage *msg)
 		goto try_again;
 
 	/* Wait... */
-	g_cond_wait (ss->priv->cond, ss->priv->lock);
+	g_cond_wait (priv->cond, priv->lock);
 
 	/* See if something bad happened */
 	if (msg->status == SOUP_MESSAGE_STATUS_FINISHED) {
-		g_mutex_unlock (ss->priv->lock);
+		g_mutex_unlock (priv->lock);
 		return NULL;
 	}
 
@@ -149,11 +147,10 @@ wait_for_connection (SoupSession *session, SoupMessage *msg)
 static guint
 send_message (SoupSession *session, SoupMessage *msg)
 {
-	SoupSessionSync *ss = SOUP_SESSION_SYNC (session);
+	SoupSessionSyncPrivate *priv = SOUP_SESSION_SYNC_GET_PRIVATE (session);
 	SoupConnection *conn;
 
-	SOUP_SESSION_CLASS (parent_class)->queue_message (session, msg,
-							  NULL, NULL);
+	SOUP_SESSION_CLASS (soup_session_sync_parent_class)->queue_message (session, msg, NULL, NULL);
 
 	do {
 		/* Get a connection */
@@ -162,7 +159,7 @@ send_message (SoupSession *session, SoupMessage *msg)
 			return msg->status_code;
 
 		soup_connection_send_request (conn, msg);
-		g_cond_broadcast (ss->priv->cond);
+		g_cond_broadcast (priv->cond);
 	} while (msg->status != SOUP_MESSAGE_STATUS_FINISHED);
 
 	return msg->status_code;
@@ -171,9 +168,9 @@ send_message (SoupSession *session, SoupMessage *msg)
 static void
 cancel_message (SoupSession *session, SoupMessage *msg)
 {
-	SoupSessionSync *ss = SOUP_SESSION_SYNC (session);
+	SoupSessionSyncPrivate *priv = SOUP_SESSION_SYNC_GET_PRIVATE (session);
 
-	SOUP_SESSION_CLASS (parent_class)->cancel_message (session, msg);
-	g_cond_broadcast (ss->priv->cond);
+	SOUP_SESSION_CLASS (soup_session_sync_parent_class)->cancel_message (session, msg);
+	g_cond_broadcast (priv->cond);
 }
 
diff --git a/libsoup/soup-session-sync.h b/libsoup/soup-session-sync.h
index 87652791..b775de03 100644
--- a/libsoup/soup-session-sync.h
+++ b/libsoup/soup-session-sync.h
@@ -16,12 +16,9 @@
 #define SOUP_IS_SESSION_SYNC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_SESSION_SYNC))
 #define SOUP_SESSION_SYNC_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_SESSION_SYNC, SoupSessionSyncClass))
 
-typedef struct SoupSessionSyncPrivate SoupSessionSyncPrivate;
-
 struct SoupSessionSync {
 	SoupSession parent;
 
-	SoupSessionSyncPrivate *priv;
 };
 
 typedef struct {
diff --git a/libsoup/soup-session.c b/libsoup/soup-session.c
index 78511564..a0820964 100644
--- a/libsoup/soup-session.c
+++ b/libsoup/soup-session.c
@@ -33,7 +33,7 @@ typedef struct {
 	GHashTable *auths;            /* scheme:realm -> SoupAuth */
 } SoupSessionHost;
 
-struct SoupSessionPrivate {
+typedef struct {
 	SoupUri *proxy_uri;
 	guint max_conns, max_conns_per_host;
 	gboolean use_ntlm;
@@ -54,11 +54,12 @@ struct SoupSessionPrivate {
 	 * Must not emit signals or destroy objects while holding it.
 	 */
 	GMutex *host_lock;
-};
+} SoupSessionPrivate;
+#define SOUP_SESSION_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_SESSION, SoupSessionPrivate))
 
 static guint    host_uri_hash  (gconstpointer key);
 static gboolean host_uri_equal (gconstpointer v1, gconstpointer v2);
-static void     free_host      (SoupSessionHost *host, SoupSession *session);
+static void     free_host      (SoupSessionHost *host);
 
 static void setup_message   (SoupMessageFilter *filter, SoupMessage *msg);
 
@@ -71,8 +72,11 @@ static void cancel_message  (SoupSession *session, SoupMessage *msg);
 #define SOUP_SESSION_MAX_CONNS_DEFAULT 10
 #define SOUP_SESSION_MAX_CONNS_PER_HOST_DEFAULT 4
 
-#define PARENT_TYPE G_TYPE_OBJECT
-static GObjectClass *parent_class;
+static void filter_iface_init (SoupMessageFilterClass *filter_class);
+
+G_DEFINE_TYPE_EXTENDED (SoupSession, soup_session, G_TYPE_OBJECT, 0,
+			G_IMPLEMENT_INTERFACE (SOUP_TYPE_MESSAGE_FILTER,
+					       filter_iface_init))
 
 enum {
 	AUTHENTICATE,
@@ -83,15 +87,15 @@ enum {
 static guint signals[LAST_SIGNAL] = { 0 };
 
 enum {
-  PROP_0,
+	PROP_0,
 
-  PROP_PROXY_URI,
-  PROP_MAX_CONNS,
-  PROP_MAX_CONNS_PER_HOST,
-  PROP_USE_NTLM,
-  PROP_SSL_CA_FILE,
+	PROP_PROXY_URI,
+	PROP_MAX_CONNS,
+	PROP_MAX_CONNS_PER_HOST,
+	PROP_USE_NTLM,
+	PROP_SSL_CA_FILE,
 
-  LAST_PROP
+	LAST_PROP
 };
 
 static void set_property (GObject *object, guint prop_id,
@@ -100,74 +104,74 @@ static void get_property (GObject *object, guint prop_id,
 			  GValue *value, GParamSpec *pspec);
 
 static void
-init (GObject *object)
+soup_session_init (SoupSession *session)
 {
-	SoupSession *session = SOUP_SESSION (object);
+	SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session);
 
-	session->priv = g_new0 (SoupSessionPrivate, 1);
-	session->priv->host_lock = g_mutex_new ();
 	session->queue = soup_message_queue_new ();
-	session->priv->hosts = g_hash_table_new (host_uri_hash,
-						 host_uri_equal);
-	session->priv->conns = g_hash_table_new (NULL, NULL);
 
-	session->priv->max_conns = SOUP_SESSION_MAX_CONNS_DEFAULT;
-	session->priv->max_conns_per_host = SOUP_SESSION_MAX_CONNS_PER_HOST_DEFAULT;
+	priv->host_lock = g_mutex_new ();
+	priv->hosts = g_hash_table_new (host_uri_hash, host_uri_equal);
+	priv->conns = g_hash_table_new (NULL, NULL);
+
+	priv->max_conns = SOUP_SESSION_MAX_CONNS_DEFAULT;
+	priv->max_conns_per_host = SOUP_SESSION_MAX_CONNS_PER_HOST_DEFAULT;
 }
 
 static gboolean
-foreach_free_host (gpointer key, gpointer host, gpointer session)
+foreach_free_host (gpointer key, gpointer host, gpointer data)
 {
-	free_host (host, session);
+	free_host (host);
 	return TRUE;
 }
 
 static void
-cleanup_hosts (SoupSession *session)
+cleanup_hosts (SoupSessionPrivate *priv)
 {
-	g_hash_table_foreach_remove (session->priv->hosts,
-				     foreach_free_host, session);
+	g_hash_table_foreach_remove (priv->hosts, foreach_free_host, NULL);
 }
 
 static void
 dispose (GObject *object)
 {
 	SoupSession *session = SOUP_SESSION (object);
+	SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session);
 	GSList *f;
 
 	soup_session_abort (session);
-	cleanup_hosts (session);
+	cleanup_hosts (priv);
 
-	if (session->priv->filters) {
-		for (f = session->priv->filters; f; f = f->next)
+	if (priv->filters) {
+		for (f = priv->filters; f; f = f->next)
 			g_object_unref (f->data);
-		g_slist_free (session->priv->filters);
-		session->priv->filters = NULL;
+		g_slist_free (priv->filters);
+		priv->filters = NULL;
 	}
 
-	G_OBJECT_CLASS (parent_class)->dispose (object);
+	G_OBJECT_CLASS (soup_session_parent_class)->dispose (object);
 }
 
 static void
 finalize (GObject *object)
 {
 	SoupSession *session = SOUP_SESSION (object);
+	SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session);
 
-	g_mutex_free (session->priv->host_lock);
 	soup_message_queue_destroy (session->queue);
-	g_hash_table_destroy (session->priv->hosts);
-	g_hash_table_destroy (session->priv->conns);
-	g_free (session->priv);
 
-	G_OBJECT_CLASS (parent_class)->finalize (object);
+	g_mutex_free (priv->host_lock);
+	g_hash_table_destroy (priv->hosts);
+	g_hash_table_destroy (priv->conns);
+
+	G_OBJECT_CLASS (soup_session_parent_class)->finalize (object);
 }
 
 static void
-class_init (GObjectClass *object_class)
+soup_session_class_init (SoupSessionClass *session_class)
 {
-	SoupSessionClass *session_class = SOUP_SESSION_CLASS (object_class);
+	GObjectClass *object_class = G_OBJECT_CLASS (session_class);
 
-	parent_class = g_type_class_ref (PARENT_TYPE);
+	g_type_class_add_private (session_class, sizeof (SoupSessionPrivate));
 
 	/* virtual method definition */
 	session_class->queue_message = queue_message;
@@ -243,10 +247,10 @@ class_init (GObjectClass *object_class)
 	g_object_class_install_property (
 		object_class, PROP_SSL_CA_FILE,
 		g_param_spec_string (SOUP_SESSION_SSL_CA_FILE,
-				      "SSL CA file",
-				      "File containing SSL CA certificates",
-				      NULL,
-				      G_PARAM_READWRITE));
+				     "SSL CA file",
+				     "File containing SSL CA certificates",
+				     NULL,
+				     G_PARAM_READWRITE));
 }
 
 static void
@@ -256,7 +260,6 @@ filter_iface_init (SoupMessageFilterClass *filter_class)
 	filter_class->setup_message = setup_message;
 }
 
-SOUP_MAKE_TYPE_WITH_IFACE (soup_session, SoupSession, class_init, init, PARENT_TYPE, filter_iface_init, SOUP_TYPE_MESSAGE_FILTER)
 
 static gboolean
 safe_uri_equal (const SoupUri *a, const SoupUri *b)
@@ -287,6 +290,7 @@ set_property (GObject *object, guint prop_id,
 	      const GValue *value, GParamSpec *pspec)
 {
 	SoupSession *session = SOUP_SESSION (object);
+	SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session);
 	gpointer pval;
 	gboolean need_abort = FALSE;
 	gboolean ca_file_changed = FALSE;
@@ -296,45 +300,45 @@ set_property (GObject *object, guint prop_id,
 	case PROP_PROXY_URI:
 		pval = g_value_get_pointer (value);
 
-		if (!safe_uri_equal (session->priv->proxy_uri, pval))
+		if (!safe_uri_equal (priv->proxy_uri, pval))
 			need_abort = TRUE;
 
-		if (session->priv->proxy_uri)
-			soup_uri_free (session->priv->proxy_uri);
+		if (priv->proxy_uri)
+			soup_uri_free (priv->proxy_uri);
 
-		session->priv->proxy_uri = pval ? soup_uri_copy (pval) : NULL;
+		priv->proxy_uri = pval ? soup_uri_copy (pval) : NULL;
 
 		if (need_abort) {
 			soup_session_abort (session);
-			cleanup_hosts (session);
+			cleanup_hosts (priv);
 		}
 
 		break;
 	case PROP_MAX_CONNS:
-		session->priv->max_conns = g_value_get_int (value);
+		priv->max_conns = g_value_get_int (value);
 		break;
 	case PROP_MAX_CONNS_PER_HOST:
-		session->priv->max_conns_per_host = g_value_get_int (value);
+		priv->max_conns_per_host = g_value_get_int (value);
 		break;
 	case PROP_USE_NTLM:
-		session->priv->use_ntlm = g_value_get_boolean (value);
+		priv->use_ntlm = g_value_get_boolean (value);
 		break;
 	case PROP_SSL_CA_FILE:
 		new_ca_file = g_value_get_string (value);
 
-		if (!safe_str_equal (session->priv->ssl_ca_file, new_ca_file))
+		if (!safe_str_equal (priv->ssl_ca_file, new_ca_file))
 			ca_file_changed = TRUE;
 
-		g_free (session->priv->ssl_ca_file);
-		session->priv->ssl_ca_file = g_strdup (new_ca_file);
+		g_free (priv->ssl_ca_file);
+		priv->ssl_ca_file = g_strdup (new_ca_file);
 
 		if (ca_file_changed) {
-			if (session->priv->ssl_creds) {
-				soup_ssl_free_client_credentials (session->priv->ssl_creds);
-				session->priv->ssl_creds = NULL;
+			if (priv->ssl_creds) {
+				soup_ssl_free_client_credentials (priv->ssl_creds);
+				priv->ssl_creds = NULL;
 			}
 
-			cleanup_hosts (session);
+			cleanup_hosts (priv);
 		}
 
 		break;
@@ -348,24 +352,25 @@ get_property (GObject *object, guint prop_id,
 	      GValue *value, GParamSpec *pspec)
 {
 	SoupSession *session = SOUP_SESSION (object);
+	SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session);
 
 	switch (prop_id) {
 	case PROP_PROXY_URI:
-		g_value_set_pointer (value, session->priv->proxy_uri ?
-				     soup_uri_copy (session->priv->proxy_uri) :
+		g_value_set_pointer (value, priv->proxy_uri ?
+				     soup_uri_copy (priv->proxy_uri) :
 				     NULL);
 		break;
 	case PROP_MAX_CONNS:
-		g_value_set_int (value, session->priv->max_conns);
+		g_value_set_int (value, priv->max_conns);
 		break;
 	case PROP_MAX_CONNS_PER_HOST:
-		g_value_set_int (value, session->priv->max_conns_per_host);
+		g_value_set_int (value, priv->max_conns_per_host);
 		break;
 	case PROP_USE_NTLM:
-		g_value_set_boolean (value, session->priv->use_ntlm);
+		g_value_set_boolean (value, priv->use_ntlm);
 		break;
 	case PROP_SSL_CA_FILE:
-		g_value_set_string (value, session->priv->ssl_ca_file);
+		g_value_set_string (value, priv->ssl_ca_file);
 		break;
 	default:
 		break;
@@ -384,12 +389,14 @@ get_property (GObject *object, guint prop_id,
 void
 soup_session_add_filter (SoupSession *session, SoupMessageFilter *filter)
 {
+	SoupSessionPrivate *priv;
+
 	g_return_if_fail (SOUP_IS_SESSION (session));
 	g_return_if_fail (SOUP_IS_MESSAGE_FILTER (filter));
+	priv = SOUP_SESSION_GET_PRIVATE (session);
 
 	g_object_ref (filter);
-	session->priv->filters = g_slist_prepend (session->priv->filters,
-						  filter);
+	priv->filters = g_slist_prepend (priv->filters, filter);
 }
 
 /**
@@ -402,11 +409,13 @@ soup_session_add_filter (SoupSession *session, SoupMessageFilter *filter)
 void
 soup_session_remove_filter (SoupSession *session, SoupMessageFilter *filter)
 {
+	SoupSessionPrivate *priv;
+
 	g_return_if_fail (SOUP_IS_SESSION (session));
 	g_return_if_fail (SOUP_IS_MESSAGE_FILTER (filter));
+	priv = SOUP_SESSION_GET_PRIVATE (session);
 
-	session->priv->filters = g_slist_remove (session->priv->filters,
-						 filter);
+	priv->filters = g_slist_remove (priv->filters, filter);
 	g_object_unref (filter);
 }
 
@@ -437,15 +446,16 @@ host_uri_equal (gconstpointer v1, gconstpointer v2)
 static SoupSessionHost *
 soup_session_host_new (SoupSession *session, const SoupUri *source_uri)
 {
+	SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session);
 	SoupSessionHost *host;
 
 	host = g_new0 (SoupSessionHost, 1);
 	host->root_uri = soup_uri_copy_root (source_uri);
 
 	if (host->root_uri->protocol == SOUP_PROTOCOL_HTTPS &&
-	    !session->priv->ssl_creds) {
-		session->priv->ssl_creds =
-			soup_ssl_get_client_credentials (session->priv->ssl_ca_file);
+	    !priv->ssl_creds) {
+		priv->ssl_creds =
+			soup_ssl_get_client_credentials (priv->ssl_ca_file);
 	}
 
 	return host;
@@ -458,15 +468,16 @@ soup_session_host_new (SoupSession *session, const SoupUri *source_uri)
 static SoupSessionHost *
 get_host_for_message (SoupSession *session, SoupMessage *msg)
 {
+	SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session);
 	SoupSessionHost *host;
 	const SoupUri *source = soup_message_get_uri (msg);
 
-	host = g_hash_table_lookup (session->priv->hosts, source);
+	host = g_hash_table_lookup (priv->hosts, source);
 	if (host)
 		return host;
 
 	host = soup_session_host_new (session, source);
-	g_hash_table_insert (session->priv->hosts, host->root_uri, host);
+	g_hash_table_insert (priv->hosts, host->root_uri, host);
 
 	return host;
 }
@@ -477,12 +488,14 @@ get_host_for_message (SoupSession *session, SoupMessage *msg)
 static SoupSessionHost *
 get_proxy_host (SoupSession *session)
 {
-	if (session->priv->proxy_host || !session->priv->proxy_uri)
-		return session->priv->proxy_host;
+	SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session);
+
+	if (priv->proxy_host || !priv->proxy_uri)
+		return priv->proxy_host;
 
-	session->priv->proxy_host =
-		soup_session_host_new (session, session->priv->proxy_uri);
-	return session->priv->proxy_host;
+	priv->proxy_host =
+		soup_session_host_new (session, priv->proxy_uri);
+	return priv->proxy_host;
 }
 
 static void
@@ -500,7 +513,7 @@ free_auth (gpointer scheme_realm, gpointer auth, gpointer data)
 }
 
 static void
-free_host (SoupSessionHost *host, SoupSession *session)
+free_host (SoupSessionHost *host)
 {
 	while (host->connections) {
 		SoupConnection *conn = host->connections->data;
@@ -589,11 +602,12 @@ authenticate_auth (SoupSession *session, SoupAuth *auth,
 		   SoupMessage *msg, gboolean prior_auth_failed,
 		   gboolean proxy)
 {
+	SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session);
 	const SoupUri *uri;
 	char *username = NULL, *password = NULL;
 
 	if (proxy)
-		uri = session->priv->proxy_uri;
+		uri = priv->proxy_uri;
 	else
 		uri = soup_message_get_uri (msg);
 
@@ -821,9 +835,10 @@ static void
 setup_message (SoupMessageFilter *filter, SoupMessage *msg)
 {
 	SoupSession *session = SOUP_SESSION (filter);
+	SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session);
 	GSList *f;
 
-	for (f = session->priv->filters; f; f = f->next) {
+	for (f = priv->filters; f; f = f->next) {
 		filter = f->data;
 		soup_message_filter_setup_message (filter, msg);
 	}
@@ -834,7 +849,7 @@ setup_message (SoupMessageFilter *filter, SoupMessage *msg)
 		SOUP_HANDLER_POST_BODY,
 		authorize_handler, session);
 
-	if (session->priv->proxy_uri) {
+	if (priv->proxy_uri) {
 		add_auth (session, msg, TRUE);
 		soup_message_add_status_code_handler  (
 			msg, SOUP_STATUS_PROXY_UNAUTHORIZED,
@@ -873,22 +888,23 @@ find_oldest_connection (gpointer key, gpointer host, gpointer data)
 gboolean
 soup_session_try_prune_connection (SoupSession *session)
 {
+	SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session);
 	SoupConnection *oldest = NULL;
 
-	g_mutex_lock (session->priv->host_lock);
-	g_hash_table_foreach (session->priv->conns, find_oldest_connection,
+	g_mutex_lock (priv->host_lock);
+	g_hash_table_foreach (priv->conns, find_oldest_connection,
 			      &oldest);
 	if (oldest) {
 		/* Ref the connection before unlocking the mutex in
 		 * case someone else tries to prune it too.
 		 */
 		g_object_ref (oldest);
-		g_mutex_unlock (session->priv->host_lock);
+		g_mutex_unlock (priv->host_lock);
 		soup_connection_disconnect (oldest);
 		g_object_unref (oldest);
 		return TRUE;
 	} else {
-		g_mutex_unlock (session->priv->host_lock);
+		g_mutex_unlock (priv->host_lock);
 		return FALSE;
 	}
 }
@@ -897,21 +913,22 @@ static void
 connection_disconnected (SoupConnection *conn, gpointer user_data)
 {
 	SoupSession *session = user_data;
+	SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session);
 	SoupSessionHost *host;
 
-	g_mutex_lock (session->priv->host_lock);
+	g_mutex_lock (priv->host_lock);
 
-	host = g_hash_table_lookup (session->priv->conns, conn);
+	host = g_hash_table_lookup (priv->conns, conn);
 	if (host) {
-		g_hash_table_remove (session->priv->conns, conn);
+		g_hash_table_remove (priv->conns, conn);
 		host->connections = g_slist_remove (host->connections, conn);
 		host->num_conns--;
 	}
 
 	g_signal_handlers_disconnect_by_func (conn, connection_disconnected, session);
-	session->priv->num_conns--;
+	priv->num_conns--;
 
-	g_mutex_unlock (session->priv->host_lock);
+	g_mutex_unlock (priv->host_lock);
 	g_object_unref (conn);
 }
 
@@ -919,27 +936,28 @@ static void
 connect_result (SoupConnection *conn, guint status, gpointer user_data)
 {
 	SoupSession *session = user_data;
+	SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session);
 	SoupSessionHost *host;
 	SoupMessageQueueIter iter;
 	SoupMessage *msg;
 
-	g_mutex_lock (session->priv->host_lock);
+	g_mutex_lock (priv->host_lock);
 
-	host = g_hash_table_lookup (session->priv->conns, conn);
+	host = g_hash_table_lookup (priv->conns, conn);
 	if (!host) {
-		g_mutex_unlock (session->priv->host_lock);
+		g_mutex_unlock (priv->host_lock);
 		return;
 	}
 
 	if (status == SOUP_STATUS_OK) {
 		soup_connection_reserve (conn);
 		host->connections = g_slist_prepend (host->connections, conn);
-		g_mutex_unlock (session->priv->host_lock);
+		g_mutex_unlock (priv->host_lock);
 		return;
 	}
 
 	/* The connection failed. */
-	g_mutex_unlock (session->priv->host_lock);
+	g_mutex_unlock (priv->host_lock);
 	connection_disconnected (conn, session);
 
 	if (host->connections) {
@@ -1014,17 +1032,18 @@ SoupConnection *
 soup_session_get_connection (SoupSession *session, SoupMessage *msg,
 			     gboolean *try_pruning, gboolean *is_new)
 {
+	SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session);
 	SoupConnection *conn;
 	SoupSessionHost *host;
 	GSList *conns;
 
-	g_mutex_lock (session->priv->host_lock);
+	g_mutex_lock (priv->host_lock);
 
 	host = get_host_for_message (session, msg);
 	for (conns = host->connections; conns; conns = conns->next) {
 		if (!soup_connection_is_in_use (conns->data)) {
 			soup_connection_reserve (conns->data);
-			g_mutex_unlock (session->priv->host_lock);
+			g_mutex_unlock (priv->host_lock);
 			*is_new = FALSE;
 			return conns->data;
 		}
@@ -1034,33 +1053,33 @@ soup_session_get_connection (SoupSession *session, SoupMessage *msg,
 		/* We already started a connection for this
 		 * message, so don't start another one.
 		 */
-		g_mutex_unlock (session->priv->host_lock);
+		g_mutex_unlock (priv->host_lock);
 		return NULL;
 	}
 
-	if (host->num_conns >= session->priv->max_conns_per_host) {
-		g_mutex_unlock (session->priv->host_lock);
+	if (host->num_conns >= priv->max_conns_per_host) {
+		g_mutex_unlock (priv->host_lock);
 		return NULL;
 	}
 
-	if (session->priv->num_conns >= session->priv->max_conns) {
+	if (priv->num_conns >= priv->max_conns) {
 		*try_pruning = TRUE;
-		g_mutex_unlock (session->priv->host_lock);
+		g_mutex_unlock (priv->host_lock);
 		return NULL;
 	}
 
-	/* Make sure session->priv->proxy_host gets set now while
+	/* Make sure priv->proxy_host gets set now while
 	 * we have the host_lock.
 	 */
-	if (session->priv->proxy_uri)
+	if (priv->proxy_uri)
 		get_proxy_host (session);
 
 	conn = g_object_new (
-		(session->priv->use_ntlm ?
+		(priv->use_ntlm ?
 		 SOUP_TYPE_CONNECTION_NTLM : SOUP_TYPE_CONNECTION),
 		SOUP_CONNECTION_ORIGIN_URI, host->root_uri,
-		SOUP_CONNECTION_PROXY_URI, session->priv->proxy_uri,
-		SOUP_CONNECTION_SSL_CREDENTIALS, session->priv->ssl_creds,
+		SOUP_CONNECTION_PROXY_URI, priv->proxy_uri,
+		SOUP_CONNECTION_SSL_CREDENTIALS, priv->ssl_creds,
 		SOUP_CONNECTION_MESSAGE_FILTER, session,
 		NULL);
 	g_signal_connect (conn, "connect_result",
@@ -1076,13 +1095,13 @@ soup_session_get_connection (SoupSession *session, SoupMessage *msg,
 			  G_CALLBACK (connection_reauthenticate),
 			  session);
 
-	g_hash_table_insert (session->priv->conns, conn, host);
+	g_hash_table_insert (priv->conns, conn, host);
 
 	/* We increment the connection counts so it counts against the
 	 * totals, but we don't add it to the host's connection list
 	 * yet, since it's not ready for use.
 	 */
-	session->priv->num_conns++;
+	priv->num_conns++;
 	host->num_conns++;
 
 	/* Mark the request as connecting, so we don't try to open
@@ -1090,7 +1109,7 @@ soup_session_get_connection (SoupSession *session, SoupMessage *msg,
 	 */
 	msg->status = SOUP_MESSAGE_STATUS_CONNECTING;
 
-	g_mutex_unlock (session->priv->host_lock);
+	g_mutex_unlock (priv->host_lock);
 	*is_new = TRUE;
 	return conn;
 }
diff --git a/libsoup/soup-session.h b/libsoup/soup-session.h
index 8e5be50c..cdafd968 100644
--- a/libsoup/soup-session.h
+++ b/libsoup/soup-session.h
@@ -17,13 +17,9 @@
 #define SOUP_IS_SESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_SESSION))
 #define SOUP_SESSION_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_SESSION, SoupSessionClass))
 
-typedef struct SoupSessionPrivate SoupSessionPrivate;
-
 struct SoupSession {
 	GObject parent;
 
-	SoupSessionPrivate *priv;
-
 	/* protected */
 	SoupMessageQueue *queue;
 };
diff --git a/libsoup/soup-soap-message.c b/libsoup/soup-soap-message.c
index 3d552ac2..89c59072 100644
--- a/libsoup/soup-soap-message.c
+++ b/libsoup/soup-soap-message.c
@@ -8,9 +8,9 @@
 #include "soup-soap-message.h"
 #include "soup-uri.h"
 
-#define PARENT_TYPE SOUP_TYPE_MESSAGE
+G_DEFINE_TYPE (SoupSoapMessage, soup_soap_message, SOUP_TYPE_MESSAGE)
 
-struct _SoupSoapMessagePrivate {
+typedef struct {
 	/* Serialization fields */
 	xmlDocPtr doc;
 	xmlNodePtr last_node;
@@ -20,77 +20,58 @@ struct _SoupSoapMessagePrivate {
 	gchar *env_uri;
 	gboolean body_started;
 	gchar *action;
-};
-
-static GObjectClass *parent_class = NULL;
+} SoupSoapMessagePrivate;
+#define SOUP_SOAP_MESSAGE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_SOAP_MESSAGE, SoupSoapMessagePrivate))
 
 static void
 finalize (GObject *object)
 {
-	SoupSoapMessage *msg = SOUP_SOAP_MESSAGE (object);
-	SoupSoapMessagePrivate *priv;
-
-	/* free memory */
-
-	priv = msg->priv;
+	SoupSoapMessagePrivate *priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (object);
 
 	if (priv->doc) 
 		xmlFreeDoc (priv->doc);
-	priv->doc = NULL;
-
 	if (priv->action)
 		g_free (priv->action);
-	priv->action = NULL;
-
-	 if (priv->env_uri)
+	if (priv->env_uri)
                 g_free (priv->env_uri);
-	 priv->env_uri = NULL;
-
 	if (priv->env_prefix)
                 g_free (priv->env_prefix);
-        priv->env_prefix = NULL;
-
-	g_free (msg->priv);
-	msg->priv = NULL;
 
-	parent_class->finalize (object);
+	G_OBJECT_CLASS (soup_soap_message_parent_class)->finalize (object);
 }
 
 static void
-class_init (SoupSoapMessageClass *klass)
+soup_soap_message_class_init (SoupSoapMessageClass *soup_soap_message_class)
 {
-	GObjectClass *object_class;
+	GObjectClass *object_class = G_OBJECT_CLASS (soup_soap_message_class);
 
-	parent_class = g_type_class_peek_parent (klass);
-
-	object_class = G_OBJECT_CLASS (klass);
 	object_class->finalize = finalize;
 }
 
 static void
-init (SoupSoapMessage *msg, SoupSoapMessageClass *klass)
+soup_soap_message_init (SoupSoapMessage *msg)
 {
-	msg->priv = g_new0 (SoupSoapMessagePrivate, 1);
+	SoupSoapMessagePrivate *priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
 
 	/* initialize XML structures */
-	msg->priv->doc = xmlNewDoc ("1.0");
-	msg->priv->doc->standalone = FALSE;
-	msg->priv->doc->encoding = g_strdup ("UTF-8");
+	priv->doc = xmlNewDoc ("1.0");
+	priv->doc->standalone = FALSE;
+	priv->doc->encoding = g_strdup ("UTF-8");
 }
 
-SOUP_MAKE_TYPE (soup_soap_message, SoupSoapMessage, class_init, init, PARENT_TYPE)
 
 static xmlNsPtr
 fetch_ns (SoupSoapMessage *msg, const char *prefix, const char *ns_uri)
 {
+	SoupSoapMessagePrivate *priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
         xmlNsPtr ns = NULL;
                                                                                 
         if (prefix && ns_uri)
-                ns = xmlNewNs (msg->priv->last_node, ns_uri, prefix);
+                ns = xmlNewNs (priv->last_node, ns_uri, prefix);
         else if (prefix && !ns_uri) {
-                ns = xmlSearchNs (msg->priv->doc, msg->priv->last_node, prefix);
+                ns = xmlSearchNs (priv->doc, priv->last_node, prefix);
                 if (!ns)
-			ns = xmlNewNs (msg->priv->last_node, "", prefix);
+			ns = xmlNewNs (priv->last_node, "", prefix);
         }
                                                                                 
         return ns;
@@ -141,21 +122,23 @@ soup_soap_message_new_from_uri (const char *method, const SoupUri *uri,
 				const char *env_prefix, const char *env_uri)
 {
 	SoupSoapMessage *msg;
+	SoupSoapMessagePrivate *priv;
 
 	msg = g_object_new (SOUP_TYPE_SOAP_MESSAGE, NULL);
+	priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
 	SOUP_MESSAGE (msg)->method = method ? method : SOUP_METHOD_GET;
 	soup_message_set_uri (SOUP_MESSAGE (msg), (const SoupUri *) uri);
 
-	msg->priv->doc->standalone = standalone;
+	priv->doc->standalone = standalone;
 
 	if (xml_encoding) {
-		g_free ((char *) msg->priv->doc->encoding);
-		msg->priv->doc->encoding = g_strdup (xml_encoding);
+		g_free ((char *) priv->doc->encoding);
+		priv->doc->encoding = g_strdup (xml_encoding);
 	}
 
 	if (env_prefix || env_uri) {
-		msg->priv->env_prefix = g_strdup (env_prefix);
-		msg->priv->env_uri = g_strdup (env_uri);
+		priv->env_prefix = g_strdup (env_prefix);
+		priv->env_uri = g_strdup (env_uri);
 	}
 
 	return msg;
@@ -170,38 +153,41 @@ soup_soap_message_new_from_uri (const char *method, const SoupUri *uri,
 void
 soup_soap_message_start_envelope (SoupSoapMessage *msg)
 {
-	g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg));
-
-	msg->priv->last_node = msg->priv->doc->xmlRootNode =
-		xmlNewDocNode (msg->priv->doc, NULL, "Envelope", NULL);
+	SoupSoapMessagePrivate *priv;
 
-	msg->priv->soap_ns = xmlNewNs (msg->priv->doc->xmlRootNode,
-				       msg->priv->env_uri ? msg->priv->env_uri :
-				       "http://schemas.xmlsoap.org/soap/envelope/",
-				       msg->priv->env_prefix ? msg->priv->env_prefix : "SOAP-ENV");
-	if (msg->priv->env_uri) {
-		g_free (msg->priv->env_uri);
-		msg->priv->env_uri = NULL;
+	g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg));
+	priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
+
+	priv->last_node = priv->doc->xmlRootNode =
+		xmlNewDocNode (priv->doc, NULL, "Envelope", NULL);
+
+	priv->soap_ns = xmlNewNs (priv->doc->xmlRootNode,
+				  priv->env_uri ? priv->env_uri :
+				  "http://schemas.xmlsoap.org/soap/envelope/",
+				  priv->env_prefix ? priv->env_prefix : "SOAP-ENV");
+	if (priv->env_uri) {
+		g_free (priv->env_uri);
+		priv->env_uri = NULL;
 	}
-	if (msg->priv->env_prefix) {
-		g_free (msg->priv->env_prefix);
-		msg->priv->env_prefix = NULL;
+	if (priv->env_prefix) {
+		g_free (priv->env_prefix);
+		priv->env_prefix = NULL;
 	}
 
-	xmlSetNs (msg->priv->doc->xmlRootNode, msg->priv->soap_ns);
+	xmlSetNs (priv->doc->xmlRootNode, priv->soap_ns);
 
-	xmlNewNs (msg->priv->doc->xmlRootNode,
+	xmlNewNs (priv->doc->xmlRootNode,
 		  "http://schemas.xmlsoap.org/soap/encoding/",
                   "SOAP-ENC");
-	xmlNewNs (msg->priv->doc->xmlRootNode,
+	xmlNewNs (priv->doc->xmlRootNode,
                   "http://www.w3.org/1999/XMLSchema",
                   "xsd");
-	xmlNewNs (msg->priv->doc->xmlRootNode,
+	xmlNewNs (priv->doc->xmlRootNode,
 		  "http://schemas.xmlsoap.org/soap/envelope/",
 		  "SOAP-ENV");
-	msg->priv->xsi_ns = xmlNewNs (msg->priv->doc->xmlRootNode,
-				      "http://www.w3.org/1999/XMLSchema-instance",
-				      "xsi");
+	priv->xsi_ns = xmlNewNs (priv->doc->xmlRootNode,
+				 "http://www.w3.org/1999/XMLSchema-instance",
+				 "xsi");
 }
 
 /**
@@ -225,16 +211,19 @@ soup_soap_message_end_envelope (SoupSoapMessage *msg)
 void
 soup_soap_message_start_body (SoupSoapMessage *msg)
 {
+	SoupSoapMessagePrivate *priv;
+
 	g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg));
+	priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
 
-	if (msg->priv->body_started)
+	if (priv->body_started)
 		return;
 
-	msg->priv->last_node = xmlNewChild (msg->priv->last_node,
-					    msg->priv->soap_ns,
-					    "Body", NULL);
+	priv->last_node = xmlNewChild (priv->last_node,
+				       priv->soap_ns,
+				       "Body", NULL);
 
-	msg->priv->body_started = TRUE;
+	priv->body_started = TRUE;
 }
 
 /**
@@ -275,15 +264,18 @@ soup_soap_message_start_element (SoupSoapMessage *msg,
 				 const char *prefix,
 				 const char *ns_uri)
 {
+	SoupSoapMessagePrivate *priv;
+
 	g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg));
+	priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
 
-	msg->priv->last_node = xmlNewChild (msg->priv->last_node, NULL, name, NULL);
+	priv->last_node = xmlNewChild (priv->last_node, NULL, name, NULL);
 
-	xmlSetNs (msg->priv->last_node, fetch_ns (msg, prefix, ns_uri));
+	xmlSetNs (priv->last_node, fetch_ns (msg, prefix, ns_uri));
 
-	if (msg->priv->body_started && !msg->priv->action)
-		msg->priv->action = g_strconcat (ns_uri ? ns_uri : "",
-						 "#", name, NULL);
+	if (priv->body_started && !priv->action)
+		priv->action = g_strconcat (ns_uri ? ns_uri : "",
+					    "#", name, NULL);
 }
 
 /**
@@ -295,9 +287,12 @@ soup_soap_message_start_element (SoupSoapMessage *msg,
 void
 soup_soap_message_end_element (SoupSoapMessage *msg)
 {
+	SoupSoapMessagePrivate *priv;
+
 	g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg));
+	priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
 
-	msg->priv->last_node = msg->priv->last_node->parent;
+	priv->last_node = priv->last_node->parent;
 }
 
 /**
@@ -320,16 +315,19 @@ soup_soap_message_start_fault (SoupSoapMessage *msg,
 			       const char *faultstring,
 			       const char *faultfactor)
 {
+	SoupSoapMessagePrivate *priv;
+
 	g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg));
+	priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
 
-	msg->priv->last_node = xmlNewChild (msg->priv->last_node,
-					    msg->priv->soap_ns,
-					    "Fault", NULL);
-	xmlNewChild (msg->priv->last_node, msg->priv->soap_ns, "faultcode", faultcode);
-	xmlNewChild (msg->priv->last_node, msg->priv->soap_ns, "faultstring", faultstring);
+	priv->last_node = xmlNewChild (priv->last_node,
+				       priv->soap_ns,
+				       "Fault", NULL);
+	xmlNewChild (priv->last_node, priv->soap_ns, "faultcode", faultcode);
+	xmlNewChild (priv->last_node, priv->soap_ns, "faultstring", faultstring);
 
-	msg->priv->last_node = xmlNewChild (msg->priv->last_node, msg->priv->soap_ns,
-					    "faultfactor", faultfactor);
+	priv->last_node = xmlNewChild (priv->last_node, priv->soap_ns,
+				       "faultfactor", faultfactor);
 	if (!faultfactor)
 		soup_soap_message_set_null (msg);
 
@@ -358,12 +356,15 @@ soup_soap_message_end_fault (SoupSoapMessage *msg)
 void
 soup_soap_message_start_fault_detail (SoupSoapMessage *msg)
 {
+	SoupSoapMessagePrivate *priv;
+
         g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg));
+	priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
                                                                                 
-        msg->priv->last_node = xmlNewChild (msg->priv->last_node,
-					    msg->priv->soap_ns,
-					    "detail",
-					    NULL);
+        priv->last_node = xmlNewChild (priv->last_node,
+				       priv->soap_ns,
+				       "detail",
+				       NULL);
 }
 
 /**
@@ -393,10 +394,13 @@ soup_soap_message_end_fault_detail (SoupSoapMessage *msg)
 void
 soup_soap_message_start_header (SoupSoapMessage *msg)
 {
+	SoupSoapMessagePrivate *priv;
+
 	g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg));
+	priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
 
-	msg->priv->last_node = xmlNewChild (msg->priv->last_node, msg->priv->soap_ns,
-					    "Header", NULL);
+	priv->last_node = xmlNewChild (priv->last_node, priv->soap_ns,
+				       "Header", NULL);
 }
 
 /**
@@ -431,13 +435,16 @@ soup_soap_message_start_header_element (SoupSoapMessage *msg,
 					const char *prefix,
 					const char *ns_uri)
 {
+	SoupSoapMessagePrivate *priv;
+
 	g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg));
+	priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
 
 	soup_soap_message_start_element (msg, name, prefix, ns_uri);
 	if (actor_uri)
-		xmlNewNsProp (msg->priv->last_node, msg->priv->soap_ns, "actorUri", actor_uri);
+		xmlNewNsProp (priv->last_node, priv->soap_ns, "actorUri", actor_uri);
 	if (must_understand)
-		xmlNewNsProp (msg->priv->last_node, msg->priv->soap_ns, "mustUnderstand", "1");
+		xmlNewNsProp (priv->last_node, priv->soap_ns, "mustUnderstand", "1");
 }
 
 /**
@@ -521,9 +528,12 @@ soup_soap_message_write_time (SoupSoapMessage *msg, const time_t *timeval)
 void
 soup_soap_message_write_string (SoupSoapMessage *msg, const char *string)
 {
+	SoupSoapMessagePrivate *priv;
+
 	g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg));
+	priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
 
-	xmlNodeAddContent (msg->priv->last_node, string);
+	xmlNodeAddContent (priv->last_node, string);
 }
 
 /**
@@ -537,9 +547,12 @@ soup_soap_message_write_string (SoupSoapMessage *msg, const char *string)
 void
 soup_soap_message_write_buffer (SoupSoapMessage *msg, const char *buffer, int len)
 {
+	SoupSoapMessagePrivate *priv;
+
 	g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg));
+	priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
 
-	xmlNodeAddContentLen (msg->priv->last_node, buffer, len);
+	xmlNodeAddContentLen (priv->last_node, buffer, len);
 }
 
 /**
@@ -553,9 +566,12 @@ soup_soap_message_write_buffer (SoupSoapMessage *msg, const char *buffer, int le
 void
 soup_soap_message_set_element_type (SoupSoapMessage *msg, const char *xsi_type)
 {
+	SoupSoapMessagePrivate *priv;
+
 	g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg));
+	priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
 
-	xmlNewNsProp (msg->priv->last_node, msg->priv->xsi_ns, "type", xsi_type);
+	xmlNewNsProp (priv->last_node, priv->xsi_ns, "type", xsi_type);
 }
 
 /**
@@ -567,9 +583,12 @@ soup_soap_message_set_element_type (SoupSoapMessage *msg, const char *xsi_type)
 void
 soup_soap_message_set_null (SoupSoapMessage *msg)
 {
+	SoupSoapMessagePrivate *priv;
+
 	g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg));
+	priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
 
-	xmlNewNsProp (msg->priv->last_node, msg->priv->xsi_ns, "null", "1");
+	xmlNewNsProp (priv->last_node, priv->xsi_ns, "null", "1");
 }
 
 /**
@@ -589,9 +608,12 @@ soup_soap_message_add_attribute (SoupSoapMessage *msg,
 				 const char *prefix,
 				 const char *ns_uri)
 {
+	SoupSoapMessagePrivate *priv;
+
 	g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg));
+	priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
 
-	xmlNewNsProp (msg->priv->last_node,
+	xmlNewNsProp (priv->last_node,
 		      fetch_ns (msg, prefix, ns_uri),
 		      name, value);
 }
@@ -607,9 +629,12 @@ soup_soap_message_add_attribute (SoupSoapMessage *msg,
 void
 soup_soap_message_add_namespace (SoupSoapMessage *msg, const char *prefix, const char *ns_uri)
 {
+	SoupSoapMessagePrivate *priv;
+
 	g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg));
+	priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
 
-	xmlNewNs (msg->priv->last_node, ns_uri ? ns_uri : "", prefix);
+	xmlNewNs (priv->last_node, ns_uri ? ns_uri : "", prefix);
 }
 
 /**
@@ -624,7 +649,10 @@ soup_soap_message_add_namespace (SoupSoapMessage *msg, const char *prefix, const
 void
 soup_soap_message_set_default_namespace (SoupSoapMessage *msg, const char *ns_uri)
 {
+	SoupSoapMessagePrivate *priv;
+
 	g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg));
+	priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
 
 	soup_soap_message_add_namespace (msg, NULL, ns_uri);
 }
@@ -640,9 +668,12 @@ soup_soap_message_set_default_namespace (SoupSoapMessage *msg, const char *ns_ur
 void
 soup_soap_message_set_encoding_style (SoupSoapMessage *msg, const char *enc_style)
 {
+	SoupSoapMessagePrivate *priv;
+
 	g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg));
+	priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
 
-	xmlNewNsProp (msg->priv->last_node, msg->priv->soap_ns, "encodingStyle", enc_style);
+	xmlNewNsProp (priv->last_node, priv->soap_ns, "encodingStyle", enc_style);
 }
 
 /**
@@ -654,23 +685,26 @@ soup_soap_message_set_encoding_style (SoupSoapMessage *msg, const char *enc_styl
 void
 soup_soap_message_reset (SoupSoapMessage *msg)
 {
+	SoupSoapMessagePrivate *priv;
+
 	g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg));
+	priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
 
-	xmlFreeDoc (msg->priv->doc);
-	msg->priv->doc = xmlNewDoc ("1.0");
-	msg->priv->last_node = NULL;
+	xmlFreeDoc (priv->doc);
+	priv->doc = xmlNewDoc ("1.0");
+	priv->last_node = NULL;
 
-	g_free (msg->priv->action);
-	msg->priv->action = NULL;
-	msg->priv->body_started = FALSE;
+	g_free (priv->action);
+	priv->action = NULL;
+	priv->body_started = FALSE;
 
-	if (msg->priv->env_uri)
-		g_free (msg->priv->env_uri);
-	msg->priv->env_uri = NULL;
+	if (priv->env_uri)
+		g_free (priv->env_uri);
+	priv->env_uri = NULL;
 
-	if (msg->priv->env_prefix)
-		g_free (msg->priv->env_prefix);
-	msg->priv->env_prefix = NULL;
+	if (priv->env_prefix)
+		g_free (priv->env_prefix);
+	priv->env_prefix = NULL;
 }
 
 /**
@@ -682,12 +716,14 @@ soup_soap_message_reset (SoupSoapMessage *msg)
 void
 soup_soap_message_persist (SoupSoapMessage *msg)
 {
+	SoupSoapMessagePrivate *priv;
 	xmlChar *body;
 	int len;
 
 	g_return_if_fail (SOUP_IS_SOAP_MESSAGE (msg));
+	priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
 
-	xmlDocDumpMemory (msg->priv->doc, &body, &len);
+	xmlDocDumpMemory (priv->doc, &body, &len);
 
 	/* serialize to SoupMessage class */
 	soup_message_set_request (SOUP_MESSAGE (msg), "text/xml",
@@ -708,12 +744,14 @@ soup_soap_message_persist (SoupSoapMessage *msg)
 const char *
 soup_soap_message_get_namespace_prefix (SoupSoapMessage *msg, const char *ns_uri)
 {
+	SoupSoapMessagePrivate *priv;
 	xmlNsPtr ns = NULL;
 
 	g_return_val_if_fail (SOUP_IS_SOAP_MESSAGE (msg), NULL);
+	priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
 	g_return_val_if_fail (ns_uri != NULL, NULL);
 
-	ns = xmlSearchNsByHref (msg->priv->doc, msg->priv->last_node, ns_uri);
+	ns = xmlSearchNsByHref (priv->doc, priv->last_node, ns_uri);
 	if (ns) {
 		if (ns->prefix)
 			return ns->prefix;
@@ -736,9 +774,12 @@ soup_soap_message_get_namespace_prefix (SoupSoapMessage *msg, const char *ns_uri
 xmlDocPtr
 soup_soap_message_get_xml_doc (SoupSoapMessage *msg)
 {
+	SoupSoapMessagePrivate *priv;
+
 	g_return_val_if_fail (SOUP_IS_SOAP_MESSAGE (msg), NULL);
+	priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
 
-	return msg->priv->doc;
+	return priv->doc;
 }
 
 /**
@@ -753,10 +794,12 @@ soup_soap_message_get_xml_doc (SoupSoapMessage *msg)
 SoupSoapResponse *
 soup_soap_message_parse_response (SoupSoapMessage *msg)
 {
+	SoupSoapMessagePrivate *priv;
 	char *xmlstr;
 	SoupSoapResponse *soap_response;
 
 	g_return_val_if_fail (SOUP_IS_SOAP_MESSAGE (msg), NULL);
+	priv = SOUP_SOAP_MESSAGE_GET_PRIVATE (msg);
 
 	xmlstr = g_malloc0 (SOUP_MESSAGE (msg)->response.length + 1);
 	strncpy (xmlstr, SOUP_MESSAGE (msg)->response.body, SOUP_MESSAGE (msg)->response.length);
diff --git a/libsoup/soup-soap-message.h b/libsoup/soup-soap-message.h
index 1fef1e6b..055a5d61 100644
--- a/libsoup/soup-soap-message.h
+++ b/libsoup/soup-soap-message.h
@@ -20,11 +20,9 @@ G_BEGIN_DECLS
 #define SOUP_IS_SOAP_MESSAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SOUP_TYPE_SOAP_MESSAGE))
 #define SOUP_SOAP_MESSAGE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_SOAP_MESSAGE, SoupSoapMessageClass))
 
-typedef struct _SoupSoapMessagePrivate SoupSoapMessagePrivate;
-
 typedef struct {
 	SoupMessage parent;
-	SoupSoapMessagePrivate *priv;
+
 } SoupSoapMessage;
 
 typedef struct {
diff --git a/libsoup/soup-soap-response.c b/libsoup/soup-soap-response.c
index b0746d13..e1ad47bc 100644
--- a/libsoup/soup-soap-response.c
+++ b/libsoup/soup-soap-response.c
@@ -10,9 +10,9 @@
 #include "soup-soap-response.h"
 #include "soup-types.h"
 
-#define PARENT_TYPE G_TYPE_OBJECT
+G_DEFINE_TYPE (SoupSoapResponse, soup_soap_response, G_TYPE_OBJECT)
 
-struct _SoupSoapResponsePrivate {
+typedef struct {
 	/* the XML document */
 	xmlDocPtr xmldoc;
 	xmlNodePtr xml_root;
@@ -20,56 +20,40 @@ struct _SoupSoapResponsePrivate {
 	xmlNodePtr xml_method;
 	xmlNodePtr soap_fault;
 	GList *parameters;
-};
-
-static GObjectClass *parent_class = NULL;
+} SoupSoapResponsePrivate;
+#define SOUP_SOAP_RESPONSE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_SOAP_RESPONSE, SoupSoapResponsePrivate))
 
 static void
 finalize (GObject *object)
 {
-	SoupSoapResponse *response = SOUP_SOAP_RESPONSE (object);
-
-	/* free memory */
-	if (response->priv->xmldoc) {
-		xmlFreeDoc (response->priv->xmldoc);
-		response->priv->xmldoc = NULL;
-	}
-
-	response->priv->xml_root = NULL;
-	response->priv->xml_body = NULL;
-	response->priv->xml_method = NULL;
-
-	if (response->priv->parameters != NULL) {
-		g_list_free (response->priv->parameters);
-		response->priv->parameters = NULL;
-	}
+	SoupSoapResponsePrivate *priv = SOUP_SOAP_RESPONSE_GET_PRIVATE (object);
 
-	g_free (response->priv);
-	response->priv = NULL;
+	if (priv->xmldoc)
+		xmlFreeDoc (priv->xmldoc);
+	if (priv->parameters != NULL)
+		g_list_free (priv->parameters);
 
-	parent_class->finalize (object);
+	G_OBJECT_CLASS (soup_soap_response_parent_class)->finalize (object);
 }
 
 static void
-class_init (SoupSoapResponseClass *klass)
+soup_soap_response_class_init (SoupSoapResponseClass *soup_soap_response_class)
 {
-	GObjectClass *object_class;
+	GObjectClass *object_class = G_OBJECT_CLASS (soup_soap_response_class);
 
-	parent_class = g_type_class_peek_parent (klass);
+	g_type_class_add_private (soup_soap_response_class, sizeof (SoupSoapResponsePrivate));
 
-	object_class = G_OBJECT_CLASS (klass);
 	object_class->finalize = finalize;
 }
 
 static void
-init (SoupSoapResponse *response, SoupSoapResponseClass *klass)
+soup_soap_response_init (SoupSoapResponse *response)
 {
-	response->priv = g_new0 (SoupSoapResponsePrivate, 1);
+	SoupSoapResponsePrivate *priv = SOUP_SOAP_RESPONSE_GET_PRIVATE (response);
 
-	response->priv->xmldoc = xmlNewDoc ("1.0");
+	priv->xmldoc = xmlNewDoc ("1.0");
 }
 
-SOUP_MAKE_TYPE (soup_soap_response, SoupSoapResponse, class_init, init, PARENT_TYPE)
 
 /**
  * soup_soap_response_new:
@@ -114,17 +98,17 @@ soup_soap_response_new_from_string (const char *xmlstr)
 }
 
 static void
-parse_parameters (SoupSoapResponse *response, xmlNodePtr xml_method)
+parse_parameters (SoupSoapResponsePrivate *priv, xmlNodePtr xml_method)
 {
 	xmlNodePtr tmp;
 
 	for (tmp = xml_method->xmlChildrenNode; tmp != NULL; tmp = tmp->next) {
 		if (!strcmp (tmp->name, "Fault")) {
-			response->priv->soap_fault = tmp;
+			priv->soap_fault = tmp;
 			continue;
 		} else {
 			/* regular parameters */
-			response->priv->parameters = g_list_append (response->priv->parameters, tmp);
+			priv->parameters = g_list_append (priv->parameters, tmp);
 		}
 	}
 }
@@ -142,33 +126,35 @@ parse_parameters (SoupSoapResponse *response, xmlNodePtr xml_method)
 gboolean
 soup_soap_response_from_string (SoupSoapResponse *response, const char *xmlstr)
 {
+	SoupSoapResponsePrivate *priv;
 	xmlDocPtr old_doc = NULL;
 	xmlNodePtr xml_root, xml_body = NULL, xml_method = NULL;
 
 	g_return_val_if_fail (SOUP_IS_SOAP_RESPONSE (response), FALSE);
+	priv = SOUP_SOAP_RESPONSE_GET_PRIVATE (response);
 	g_return_val_if_fail (xmlstr != NULL, FALSE);
 
 	/* clear the previous contents */
-	if (response->priv->xmldoc)
-		old_doc = response->priv->xmldoc;
+	if (priv->xmldoc)
+		old_doc = priv->xmldoc;
 
 	/* parse the string */
-	response->priv->xmldoc = xmlParseMemory (xmlstr, strlen (xmlstr));
-	if (!response->priv->xmldoc) {
-		response->priv->xmldoc = old_doc;
+	priv->xmldoc = xmlParseMemory (xmlstr, strlen (xmlstr));
+	if (!priv->xmldoc) {
+		priv->xmldoc = old_doc;
 		return FALSE;
 	}
 
-	xml_root = xmlDocGetRootElement (response->priv->xmldoc);
+	xml_root = xmlDocGetRootElement (priv->xmldoc);
 	if (!xml_root) {
-		xmlFreeDoc (response->priv->xmldoc);
-		response->priv->xmldoc = old_doc;
+		xmlFreeDoc (priv->xmldoc);
+		priv->xmldoc = old_doc;
 		return FALSE;
 	}
 
 	if (strcmp (xml_root->name, "Envelope") != 0) {
-		xmlFreeDoc (response->priv->xmldoc);
-		response->priv->xmldoc = old_doc;
+		xmlFreeDoc (priv->xmldoc);
+		priv->xmldoc = old_doc;
 		return FALSE;
 	}
 
@@ -177,8 +163,8 @@ soup_soap_response_from_string (SoupSoapResponse *response, const char *xmlstr)
 		if (strcmp (xml_body->name, "Header") == 0)
 			xml_body = xml_root->xmlChildrenNode->next;
 		if (strcmp (xml_body->name, "Body") != 0) {
-			xmlFreeDoc (response->priv->xmldoc);
-			response->priv->xmldoc = old_doc;
+			xmlFreeDoc (priv->xmldoc);
+			priv->xmldoc = old_doc;
 			return FALSE;
 		}
 
@@ -186,14 +172,14 @@ soup_soap_response_from_string (SoupSoapResponse *response, const char *xmlstr)
 
 		/* read all parameters */
 		if (xml_method)
-			parse_parameters (response, xml_method);
+			parse_parameters (priv, xml_method);
 	}
 
 	xmlFreeDoc (old_doc);
 
-	response->priv->xml_root = xml_root;
-	response->priv->xml_body = xml_body;
-	response->priv->xml_method = xml_method;
+	priv->xml_root = xml_root;
+	priv->xml_body = xml_body;
+	priv->xml_method = xml_method;
 
 	return TRUE;
 }
@@ -209,10 +195,13 @@ soup_soap_response_from_string (SoupSoapResponse *response, const char *xmlstr)
 const char *
 soup_soap_response_get_method_name (SoupSoapResponse *response)
 {
+	SoupSoapResponsePrivate *priv;
+
 	g_return_val_if_fail (SOUP_IS_SOAP_RESPONSE (response), NULL);
-	g_return_val_if_fail (response->priv->xml_method != NULL, NULL);
+	priv = SOUP_SOAP_RESPONSE_GET_PRIVATE (response);
+	g_return_val_if_fail (priv->xml_method != NULL, NULL);
 
-	return (const char *) response->priv->xml_method->name;
+	return (const char *) priv->xml_method->name;
 }
 
 /**
@@ -225,11 +214,14 @@ soup_soap_response_get_method_name (SoupSoapResponse *response)
 void
 soup_soap_response_set_method_name (SoupSoapResponse *response, const char *method_name)
 {
+	SoupSoapResponsePrivate *priv;
+
 	g_return_if_fail (SOUP_IS_SOAP_RESPONSE (response));
-	g_return_if_fail (response->priv->xml_method != NULL);
+	priv = SOUP_SOAP_RESPONSE_GET_PRIVATE (response);
+	g_return_if_fail (priv->xml_method != NULL);
 	g_return_if_fail (method_name != NULL);
 
-	xmlNodeSetName (response->priv->xml_method, method_name);
+	xmlNodeSetName (priv->xml_method, method_name);
 }
 
 /**
@@ -394,9 +386,12 @@ soup_soap_parameter_get_property (SoupSoapParameter *param, const char *prop_nam
 const GList *
 soup_soap_response_get_parameters (SoupSoapResponse *response)
 {
+	SoupSoapResponsePrivate *priv;
+
 	g_return_val_if_fail (SOUP_IS_SOAP_RESPONSE (response), NULL);
+	priv = SOUP_SOAP_RESPONSE_GET_PRIVATE (response);
 
-	return (const GList *) response->priv->parameters;
+	return (const GList *) priv->parameters;
 }
 
 /**
@@ -412,9 +407,12 @@ soup_soap_response_get_parameters (SoupSoapResponse *response)
 SoupSoapParameter *
 soup_soap_response_get_first_parameter (SoupSoapResponse *response)
 {
+	SoupSoapResponsePrivate *priv;
+
 	g_return_val_if_fail (SOUP_IS_SOAP_RESPONSE (response), NULL);
+	priv = SOUP_SOAP_RESPONSE_GET_PRIVATE (response);
 
-	return response->priv->parameters ? response->priv->parameters->data : NULL;
+	return priv->parameters ? priv->parameters->data : NULL;
 }
 
 /**
@@ -433,12 +431,14 @@ SoupSoapParameter *
 soup_soap_response_get_first_parameter_by_name (SoupSoapResponse *response,
 						const char *name)
 {
+	SoupSoapResponsePrivate *priv;
 	GList *l;
 
 	g_return_val_if_fail (SOUP_IS_SOAP_RESPONSE (response), NULL);
+	priv = SOUP_SOAP_RESPONSE_GET_PRIVATE (response);
 	g_return_val_if_fail (name != NULL, NULL);
 
-	for (l = response->priv->parameters; l != NULL; l = l->next) {
+	for (l = priv->parameters; l != NULL; l = l->next) {
 		SoupSoapParameter *param = (SoupSoapParameter *) l->data;
 
 		if (!strcmp (name, param->name))
@@ -461,12 +461,14 @@ SoupSoapParameter *
 soup_soap_response_get_next_parameter (SoupSoapResponse *response,
 				       SoupSoapParameter *from)
 {
+	SoupSoapResponsePrivate *priv;
 	GList *l;
 
 	g_return_val_if_fail (SOUP_IS_SOAP_RESPONSE (response), NULL);
+	priv = SOUP_SOAP_RESPONSE_GET_PRIVATE (response);
 	g_return_val_if_fail (from != NULL, NULL);
 
-	l = g_list_find (response->priv->parameters, (gconstpointer) from);
+	l = g_list_find (priv->parameters, (gconstpointer) from);
 	if (!l)
 		return NULL;
 
diff --git a/libsoup/soup-soap-response.h b/libsoup/soup-soap-response.h
index b2a7742f..32427e27 100644
--- a/libsoup/soup-soap-response.h
+++ b/libsoup/soup-soap-response.h
@@ -18,11 +18,9 @@ G_BEGIN_DECLS
 #define SOUP_IS_SOAP_RESPONSE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SOUP_TYPE_SOAP_RESPONSE))
 #define SOUP_SOAP_RESPONSE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_SOAP_RESPONSE, SoupSoapResponseClass))
 
-typedef struct _SoupSoapResponsePrivate SoupSoapResponsePrivate;
-
 typedef struct {
 	GObject parent;
-	SoupSoapResponsePrivate *priv;
+
 } SoupSoapResponse;
 
 typedef struct {
diff --git a/libsoup/soup-socket.c b/libsoup/soup-socket.c
index d1de93ec..a9770298 100644
--- a/libsoup/soup-socket.c
+++ b/libsoup/soup-socket.c
@@ -26,8 +26,7 @@
 #include <netinet/in.h>
 #include <netinet/tcp.h>
 
-#define PARENT_TYPE G_TYPE_OBJECT
-static GObjectClass *parent_class;
+G_DEFINE_TYPE (SoupSocket, soup_socket, G_TYPE_OBJECT)
 
 enum {
 	CONNECT_RESULT,
@@ -52,7 +51,7 @@ enum {
 	LAST_PROP
 };
 
-struct SoupSocketPrivate {
+typedef struct {
 	int sockfd;
 	SoupAddress *local_addr, *remote_addr;
 	GIOChannel *iochannel;
@@ -68,7 +67,8 @@ struct SoupSocketPrivate {
 	GByteArray     *read_buf;
 
 	GMutex *iolock, *addrlock;
-};
+} SoupSocketPrivate;
+#define SOUP_SOCKET_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_SOCKET, SoupSocketPrivate))
 
 #ifdef HAVE_IPV6
 #define soup_sockaddr_max sockaddr_in6
@@ -82,67 +82,66 @@ static void get_property (GObject *object, guint prop_id,
 			  GValue *value, GParamSpec *pspec);
 
 static void
-init (GObject *object)
+soup_socket_init (SoupSocket *sock)
 {
-	SoupSocket *sock = SOUP_SOCKET (object);
-
-	sock->priv = g_new0 (SoupSocketPrivate, 1);
-	sock->priv->sockfd = -1;
-	sock->priv->non_blocking = sock->priv->nodelay = TRUE;
-	sock->priv->reuseaddr = TRUE;
-	sock->priv->addrlock = g_mutex_new ();
-	sock->priv->iolock = g_mutex_new ();
+	SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock);
+
+	priv->sockfd = -1;
+	priv->non_blocking = priv->nodelay = TRUE;
+	priv->reuseaddr = TRUE;
+	priv->addrlock = g_mutex_new ();
+	priv->iolock = g_mutex_new ();
 }
 
 static void
-disconnect_internal (SoupSocket *sock)
+disconnect_internal (SoupSocketPrivate *priv)
 {
-	g_io_channel_unref (sock->priv->iochannel);
-	sock->priv->iochannel = NULL;
-	sock->priv->sockfd = -1;
+	g_io_channel_unref (priv->iochannel);
+	priv->iochannel = NULL;
+	priv->sockfd = -1;
 
-	if (sock->priv->read_tag) {
-		g_source_remove (sock->priv->read_tag);
-		sock->priv->read_tag = 0;
+	if (priv->read_tag) {
+		g_source_remove (priv->read_tag);
+		priv->read_tag = 0;
 	}
-	if (sock->priv->write_tag) {
-		g_source_remove (sock->priv->write_tag);
-		sock->priv->write_tag = 0;
+	if (priv->write_tag) {
+		g_source_remove (priv->write_tag);
+		priv->write_tag = 0;
 	}
-	if (sock->priv->error_tag) {
-		g_source_remove (sock->priv->error_tag);
-		sock->priv->error_tag = 0;
+	if (priv->error_tag) {
+		g_source_remove (priv->error_tag);
+		priv->error_tag = 0;
 	}
 }
 
 static void
 finalize (GObject *object)
 {
-	SoupSocket *sock = SOUP_SOCKET (object);
-
-	if (sock->priv->iochannel)
-		disconnect_internal (sock);
+	SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (object);
 
-	if (sock->priv->local_addr)
-		g_object_unref (sock->priv->local_addr);
-	if (sock->priv->remote_addr)
-		g_object_unref (sock->priv->remote_addr);
+	if (priv->iochannel)
+		disconnect_internal (priv);
 
-	if (sock->priv->watch)
-		g_source_remove (sock->priv->watch);
+	if (priv->local_addr)
+		g_object_unref (priv->local_addr);
+	if (priv->remote_addr)
+		g_object_unref (priv->remote_addr);
 
-	g_mutex_free (sock->priv->addrlock);
-	g_mutex_free (sock->priv->iolock);
+	if (priv->watch)
+		g_source_remove (priv->watch);
 
-	g_free (sock->priv);
+	g_mutex_free (priv->addrlock);
+	g_mutex_free (priv->iolock);
 
-	G_OBJECT_CLASS (parent_class)->finalize (object);
+	G_OBJECT_CLASS (soup_socket_parent_class)->finalize (object);
 }
 
 static void
-class_init (GObjectClass *object_class)
+soup_socket_class_init (SoupSocketClass *socket_class)
 {
-	parent_class = g_type_class_ref (PARENT_TYPE);
+	GObjectClass *object_class = G_OBJECT_CLASS (socket_class);
+
+	g_type_class_add_private (socket_class, sizeof (SoupSocketPrivate));
 
 	/* virtual method override */
 	object_class->finalize = finalize;
@@ -230,32 +229,30 @@ class_init (GObjectClass *object_class)
 				      G_PARAM_READWRITE));
 }
 
-SOUP_MAKE_TYPE (soup_socket, SoupSocket, class_init, init, PARENT_TYPE)
-
 
 static void
-update_fdflags (SoupSocket *sock)
+update_fdflags (SoupSocketPrivate *priv)
 {
 	int flags, opt;
 
-	if (sock->priv->sockfd == -1)
+	if (priv->sockfd == -1)
 		return;
 
-	flags = fcntl (sock->priv->sockfd, F_GETFL, 0);
+	flags = fcntl (priv->sockfd, F_GETFL, 0);
 	if (flags != -1) {
-		if (sock->priv->non_blocking)
+		if (priv->non_blocking)
 			flags |= O_NONBLOCK;
 		else
 			flags &= ~O_NONBLOCK;
-		fcntl (sock->priv->sockfd, F_SETFL, flags);
+		fcntl (priv->sockfd, F_SETFL, flags);
 	}
 
-	opt = (sock->priv->nodelay != 0);
-	setsockopt (sock->priv->sockfd, IPPROTO_TCP,
+	opt = (priv->nodelay != 0);
+	setsockopt (priv->sockfd, IPPROTO_TCP,
 		    TCP_NODELAY, &opt, sizeof (opt));
 
-	opt = (sock->priv->reuseaddr != 0);
-	setsockopt (sock->priv->sockfd, SOL_SOCKET,
+	opt = (priv->reuseaddr != 0);
+	setsockopt (priv->sockfd, SOL_SOCKET,
 		    SO_REUSEADDR, &opt, sizeof (opt));
 }
 
@@ -263,23 +260,23 @@ static void
 set_property (GObject *object, guint prop_id,
 	      const GValue *value, GParamSpec *pspec)
 {
-	SoupSocket *sock = SOUP_SOCKET (object);
+	SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (object);
 
 	switch (prop_id) {
 	case PROP_NON_BLOCKING:
-		sock->priv->non_blocking = g_value_get_boolean (value);
-		update_fdflags (sock);
+		priv->non_blocking = g_value_get_boolean (value);
+		update_fdflags (priv);
 		break;
 	case PROP_NODELAY:
-		sock->priv->nodelay = g_value_get_boolean (value);
-		update_fdflags (sock);
+		priv->nodelay = g_value_get_boolean (value);
+		update_fdflags (priv);
 		break;
 	case PROP_REUSEADDR:
-		sock->priv->reuseaddr = g_value_get_boolean (value);
-		update_fdflags (sock);
+		priv->reuseaddr = g_value_get_boolean (value);
+		update_fdflags (priv);
 		break;
 	case PROP_SSL_CREDENTIALS:
-		sock->priv->ssl_creds = g_value_get_pointer (value);
+		priv->ssl_creds = g_value_get_pointer (value);
 		break;
 	default:
 		break;
@@ -290,23 +287,23 @@ static void
 get_property (GObject *object, guint prop_id,
 	      GValue *value, GParamSpec *pspec)
 {
-	SoupSocket *sock = SOUP_SOCKET (object);
+	SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (object);
 
 	switch (prop_id) {
 	case PROP_NON_BLOCKING:
-		g_value_set_boolean (value, sock->priv->non_blocking);
+		g_value_set_boolean (value, priv->non_blocking);
 		break;
 	case PROP_NODELAY:
-		g_value_set_boolean (value, sock->priv->nodelay);
+		g_value_set_boolean (value, priv->nodelay);
 		break;
 	case PROP_REUSEADDR:
-		g_value_set_boolean (value, sock->priv->reuseaddr);
+		g_value_set_boolean (value, priv->reuseaddr);
 		break;
 	case PROP_IS_SERVER:
-		g_value_set_boolean (value, sock->priv->is_server);
+		g_value_set_boolean (value, priv->is_server);
 		break;
 	case PROP_SSL_CREDENTIALS:
-		g_value_set_pointer (value, sock->priv->ssl_creds);
+		g_value_set_pointer (value, priv->ssl_creds);
 		break;
 	default:
 		break;
@@ -338,29 +335,30 @@ soup_socket_new (const char *optname1, ...)
 }
 
 static GIOChannel *
-get_iochannel (SoupSocket *sock)
+get_iochannel (SoupSocketPrivate *priv)
 {
-	g_mutex_lock (sock->priv->iolock);
-	if (!sock->priv->iochannel) {
-		sock->priv->iochannel =
-			g_io_channel_unix_new (sock->priv->sockfd);
-		g_io_channel_set_close_on_unref (sock->priv->iochannel, TRUE);
-		g_io_channel_set_encoding (sock->priv->iochannel, NULL, NULL);
-		g_io_channel_set_buffered (sock->priv->iochannel, FALSE);
+	g_mutex_lock (priv->iolock);
+	if (!priv->iochannel) {
+		priv->iochannel =
+			g_io_channel_unix_new (priv->sockfd);
+		g_io_channel_set_close_on_unref (priv->iochannel, TRUE);
+		g_io_channel_set_encoding (priv->iochannel, NULL, NULL);
+		g_io_channel_set_buffered (priv->iochannel, FALSE);
 	}
-	g_mutex_unlock (sock->priv->iolock);
-	return sock->priv->iochannel;
+	g_mutex_unlock (priv->iolock);
+	return priv->iochannel;
 }
 
 static gboolean
 idle_connect_result (gpointer user_data)
 {
 	SoupSocket *sock = user_data;
+	SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock);
 
-	sock->priv->watch = 0;
+	priv->watch = 0;
 
 	g_signal_emit (sock, signals[CONNECT_RESULT], 0,
-		       sock->priv->sockfd != -1 ? SOUP_STATUS_OK : SOUP_STATUS_CANT_CONNECT);
+		       priv->sockfd != -1 ? SOUP_STATUS_OK : SOUP_STATUS_CANT_CONNECT);
 	return FALSE;
 }
 
@@ -368,17 +366,18 @@ static gboolean
 connect_watch (GIOChannel* iochannel, GIOCondition condition, gpointer data)
 {
 	SoupSocket *sock = data;
+	SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock);
 	int error = 0;
 	int len = sizeof (error);
 
 	/* Remove the watch now in case we don't return immediately */
-	g_source_remove (sock->priv->watch);
-	sock->priv->watch = 0;
+	g_source_remove (priv->watch);
+	priv->watch = 0;
 
 	if (condition & ~(G_IO_IN | G_IO_OUT))
 		goto cant_connect;
 
-	if (getsockopt (sock->priv->sockfd, SOL_SOCKET, SO_ERROR,
+	if (getsockopt (priv->sockfd, SOL_SOCKET, SO_ERROR,
 			&error, &len) != 0)
 		goto cant_connect;
 	if (error)
@@ -395,6 +394,7 @@ static void
 got_address (SoupAddress *addr, guint status, gpointer user_data)
 {
 	SoupSocket *sock = user_data;
+	SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock);
 
 	if (!SOUP_STATUS_IS_SUCCESSFUL (status)) {
 		g_signal_emit (sock, signals[CONNECT_RESULT], 0, status);
@@ -402,7 +402,7 @@ got_address (SoupAddress *addr, guint status, gpointer user_data)
 		return;
 	}
 
-	soup_socket_connect (sock, sock->priv->remote_addr);
+	soup_socket_connect (sock, priv->remote_addr);
 	/* soup_socket_connect re-reffed addr */
 	g_object_unref (addr);
 
@@ -428,24 +428,26 @@ got_address (SoupAddress *addr, guint status, gpointer user_data)
 guint
 soup_socket_connect (SoupSocket *sock, SoupAddress *remote_addr)
 {
+	SoupSocketPrivate *priv;
 	struct sockaddr *sa;
 	int len, status;
 
 	g_return_val_if_fail (SOUP_IS_SOCKET (sock), SOUP_STATUS_MALFORMED);
-	g_return_val_if_fail (!sock->priv->is_server, SOUP_STATUS_MALFORMED);
-	g_return_val_if_fail (sock->priv->sockfd == -1, SOUP_STATUS_MALFORMED);
+	priv = SOUP_SOCKET_GET_PRIVATE (sock);
+	g_return_val_if_fail (!priv->is_server, SOUP_STATUS_MALFORMED);
+	g_return_val_if_fail (priv->sockfd == -1, SOUP_STATUS_MALFORMED);
 	g_return_val_if_fail (SOUP_IS_ADDRESS (remote_addr), SOUP_STATUS_MALFORMED);
 
-	sock->priv->remote_addr = g_object_ref (remote_addr);
-	if (!sock->priv->non_blocking) {
+	priv->remote_addr = g_object_ref (remote_addr);
+	if (!priv->non_blocking) {
 		status = soup_address_resolve_sync (remote_addr);
 		if (!SOUP_STATUS_IS_SUCCESSFUL (status))
 			return status;
 	}
 
-	sa = soup_address_get_sockaddr (sock->priv->remote_addr, &len);
+	sa = soup_address_get_sockaddr (priv->remote_addr, &len);
 	if (!sa) {
-		if (!sock->priv->non_blocking)
+		if (!priv->non_blocking)
 			return SOUP_STATUS_CANT_RESOLVE;
 
 		g_object_ref (sock);
@@ -453,38 +455,38 @@ soup_socket_connect (SoupSocket *sock, SoupAddress *remote_addr)
 		return SOUP_STATUS_CONTINUE;
 	}
 
-	sock->priv->sockfd = socket (sa->sa_family, SOCK_STREAM, 0);
-	if (sock->priv->sockfd == -1) {
+	priv->sockfd = socket (sa->sa_family, SOCK_STREAM, 0);
+	if (priv->sockfd == -1) {
 		goto done;
 	}
-	update_fdflags (sock);
+	update_fdflags (priv);
 
-	status = connect (sock->priv->sockfd, sa, len);
+	status = connect (priv->sockfd, sa, len);
 
 	if (status == -1) {
 		if (errno == EINPROGRESS) {
 			/* Wait for connect to succeed or fail */
-			sock->priv->watch =
-				g_io_add_watch (get_iochannel (sock),
+			priv->watch =
+				g_io_add_watch (get_iochannel (priv),
 						G_IO_IN | G_IO_OUT |
 						G_IO_PRI | G_IO_ERR |
 						G_IO_HUP | G_IO_NVAL,
 						connect_watch, sock);
 			return SOUP_STATUS_CONTINUE;
 		} else {
-			close (sock->priv->sockfd);
-			sock->priv->sockfd = -1;
+			close (priv->sockfd);
+			priv->sockfd = -1;
 		}
 	}
 
  done:
-	if (sock->priv->non_blocking) {
-		sock->priv->watch = g_idle_add (idle_connect_result, sock);
+	if (priv->non_blocking) {
+		priv->watch = g_idle_add (idle_connect_result, sock);
 		return SOUP_STATUS_CONTINUE;
-	} else if (sock->priv->sockfd == -1)
+	} else if (priv->sockfd == -1)
 		return SOUP_STATUS_CANT_CONNECT;
 	else {
-		get_iochannel (sock);
+		get_iochannel (priv);
 		return SOUP_STATUS_OK;
 	}
 }
@@ -493,37 +495,39 @@ static gboolean
 listen_watch (GIOChannel* iochannel, GIOCondition condition, gpointer data)
 {
 	SoupSocket *sock = data, *new;
+	SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock), *new_priv;
 	struct soup_sockaddr_max sa;
 	int sa_len, sockfd;
 
 	if (condition & (G_IO_HUP | G_IO_ERR)) {
-		g_source_remove (sock->priv->watch);
-		sock->priv->watch = 0;
+		g_source_remove (priv->watch);
+		priv->watch = 0;
 		return FALSE;
 	}
 
 	sa_len = sizeof (sa);
-	sockfd = accept (sock->priv->sockfd, (struct sockaddr *)&sa, &sa_len);
+	sockfd = accept (priv->sockfd, (struct sockaddr *)&sa, &sa_len);
 	if (sockfd == -1)
 		return TRUE;
 
 	new = g_object_new (SOUP_TYPE_SOCKET, NULL);
-	new->priv->sockfd = sockfd;
-	new->priv->non_blocking = sock->priv->non_blocking;
-	new->priv->nodelay = sock->priv->nodelay;
-	new->priv->is_server = TRUE;
-	new->priv->ssl_creds = sock->priv->ssl_creds;
-	update_fdflags (new);
+	new_priv = SOUP_SOCKET_GET_PRIVATE (new);
+	new_priv->sockfd = sockfd;
+	new_priv->non_blocking = priv->non_blocking;
+	new_priv->nodelay = priv->nodelay;
+	new_priv->is_server = TRUE;
+	new_priv->ssl_creds = priv->ssl_creds;
+	update_fdflags (new_priv);
 
-	new->priv->remote_addr = soup_address_new_from_sockaddr ((struct sockaddr *)&sa, sa_len);
+	new_priv->remote_addr = soup_address_new_from_sockaddr ((struct sockaddr *)&sa, sa_len);
 
-	if (new->priv->ssl_creds) {
+	if (new_priv->ssl_creds) {
 		if (!soup_socket_start_ssl (new)) {
 			g_object_unref (new);
 			return TRUE;
 		}
 	} else
-		get_iochannel (new);
+		get_iochannel (new_priv);
 
 	g_signal_emit (sock, signals[NEW_CONNECTION], 0, new);
 	g_object_unref (new);
@@ -545,16 +549,18 @@ listen_watch (GIOChannel* iochannel, GIOCondition condition, gpointer data)
 gboolean
 soup_socket_listen (SoupSocket *sock, SoupAddress *local_addr)
 {
+	SoupSocketPrivate *priv;
 	struct sockaddr *sa;
 	int sa_len;
 
 	g_return_val_if_fail (SOUP_IS_SOCKET (sock), FALSE);
-	g_return_val_if_fail (sock->priv->is_server, FALSE);
-	g_return_val_if_fail (sock->priv->sockfd == -1, FALSE);
+	priv = SOUP_SOCKET_GET_PRIVATE (sock);
+	g_return_val_if_fail (priv->is_server, FALSE);
+	g_return_val_if_fail (priv->sockfd == -1, FALSE);
 	g_return_val_if_fail (SOUP_IS_ADDRESS (local_addr), FALSE);
 
 	/* @local_addr may have its port set to 0. So we intentionally
-	 * don't store it in sock->priv->local_addr, so that if the
+	 * don't store it in priv->local_addr, so that if the
 	 * caller calls soup_socket_get_local_address() later, we'll
 	 * have to make a new addr by calling getsockname(), which
 	 * will have the right port number.
@@ -562,28 +568,28 @@ soup_socket_listen (SoupSocket *sock, SoupAddress *local_addr)
 	sa = soup_address_get_sockaddr (local_addr, &sa_len);
 	g_return_val_if_fail (sa != NULL, FALSE);
 
-	sock->priv->sockfd = socket (sa->sa_family, SOCK_STREAM, 0);
-	if (sock->priv->sockfd < 0)
+	priv->sockfd = socket (sa->sa_family, SOCK_STREAM, 0);
+	if (priv->sockfd < 0)
 		goto cant_listen;
-	update_fdflags (sock);
+	update_fdflags (priv);
 
 	/* Bind */
-	if (bind (sock->priv->sockfd, sa, sa_len) != 0)
+	if (bind (priv->sockfd, sa, sa_len) != 0)
 		goto cant_listen;
 
 	/* Listen */
-	if (listen (sock->priv->sockfd, 10) != 0)
+	if (listen (priv->sockfd, 10) != 0)
 		goto cant_listen;
 
-	sock->priv->watch = g_io_add_watch (get_iochannel (sock),
-					    G_IO_IN | G_IO_ERR | G_IO_HUP,
-					    listen_watch, sock);
+	priv->watch = g_io_add_watch (get_iochannel (priv),
+				      G_IO_IN | G_IO_ERR | G_IO_HUP,
+				      listen_watch, sock);
 	return TRUE;
 
  cant_listen:
-	if (sock->priv->sockfd != -1) {
-		close (sock->priv->sockfd);
-		sock->priv->sockfd = -1;
+	if (priv->sockfd != -1) {
+		close (priv->sockfd);
+		priv->sockfd = -1;
 	}
 
 	return FALSE;
@@ -600,7 +606,9 @@ soup_socket_listen (SoupSocket *sock, SoupAddress *local_addr)
 gboolean
 soup_socket_start_ssl (SoupSocket *sock)
 {
-	return soup_socket_start_proxy_ssl (sock, soup_address_get_name (sock->priv->remote_addr));
+	SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock);
+
+	return soup_socket_start_proxy_ssl (sock, soup_address_get_name (priv->remote_addr));
 }
 	
 /**
@@ -616,18 +624,19 @@ soup_socket_start_ssl (SoupSocket *sock)
 gboolean
 soup_socket_start_proxy_ssl (SoupSocket *sock, const char *ssl_host)
 {
+	SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock);
 	GIOChannel *ssl_chan;
 
-	get_iochannel (sock);
+	get_iochannel (priv);
 	ssl_chan = soup_ssl_wrap_iochannel (
-		sock->priv->iochannel, sock->priv->is_server ?
+		priv->iochannel, priv->is_server ?
 		SOUP_SSL_TYPE_SERVER : SOUP_SSL_TYPE_CLIENT,
-		ssl_host, sock->priv->ssl_creds);
+		ssl_host, priv->ssl_creds);
 
 	if (!ssl_chan)
 		return FALSE;
 
-	sock->priv->iochannel = ssl_chan;
+	priv->iochannel = ssl_chan;
 	return TRUE;
 }
 	
@@ -683,6 +692,7 @@ soup_socket_client_new_sync (const char *hostname, guint port,
 			     gpointer ssl_creds, guint *status_ret)
 {
 	SoupSocket *sock;
+	SoupSocketPrivate *priv;
 	guint status;
 
 	g_return_val_if_fail (hostname != NULL, NULL);
@@ -690,7 +700,8 @@ soup_socket_client_new_sync (const char *hostname, guint port,
 	sock = g_object_new (SOUP_TYPE_SOCKET,
 			     SOUP_SOCKET_SSL_CREDENTIALS, ssl_creds,
 			     NULL);
-	sock->priv->non_blocking = FALSE;
+	priv = SOUP_SOCKET_GET_PRIVATE (sock);
+	priv->non_blocking = FALSE;
 	status = soup_socket_connect (sock, soup_address_new (hostname, port));
 
 	if (!SOUP_STATUS_IS_SUCCESSFUL (status)) {
@@ -723,13 +734,15 @@ soup_socket_server_new (SoupAddress *local_addr, gpointer ssl_creds,
 			gpointer user_data)
 {
 	SoupSocket *sock;
+	SoupSocketPrivate *priv;
 
 	g_return_val_if_fail (SOUP_IS_ADDRESS (local_addr), NULL);
 
 	sock = g_object_new (SOUP_TYPE_SOCKET,
 			     SOUP_SOCKET_SSL_CREDENTIALS, ssl_creds,
 			     NULL);
-	sock->priv->is_server = TRUE;
+	priv = SOUP_SOCKET_GET_PRIVATE (sock);
+	priv->is_server = TRUE;
 	if (!soup_socket_listen (sock, local_addr)) {
 		g_object_unref (sock);
 		return NULL;
@@ -754,16 +767,18 @@ soup_socket_server_new (SoupAddress *local_addr, gpointer ssl_creds,
 void
 soup_socket_disconnect (SoupSocket *sock)
 {
+	SoupSocketPrivate *priv;
 	gboolean already_disconnected = FALSE;
 
 	g_return_if_fail (SOUP_IS_SOCKET (sock));
+	priv = SOUP_SOCKET_GET_PRIVATE (sock);
 
-	if (g_mutex_trylock (sock->priv->iolock)) {
-		if (sock->priv->iochannel)
-			disconnect_internal (sock);
+	if (g_mutex_trylock (priv->iolock)) {
+		if (priv->iochannel)
+			disconnect_internal (priv);
 		else
 			already_disconnected = TRUE;
-		g_mutex_unlock (sock->priv->iolock);
+		g_mutex_unlock (priv->iolock);
 	} else {
 		int sockfd;
 
@@ -772,12 +787,12 @@ soup_socket_disconnect (SoupSocket *sock)
 		 * the file descriptor out from under it.
 		 */
 
-		sockfd = sock->priv->sockfd;
-		sock->priv->sockfd = -1;
+		sockfd = priv->sockfd;
+		priv->sockfd = -1;
 		if (sockfd == -1)
 			already_disconnected = TRUE;
 		else {
-			g_io_channel_set_close_on_unref (sock->priv->iochannel,
+			g_io_channel_set_close_on_unref (priv->iochannel,
 							 FALSE);
 			close (sockfd);
 		}
@@ -806,9 +821,12 @@ soup_socket_disconnect (SoupSocket *sock)
 gboolean
 soup_socket_is_connected (SoupSocket *sock)
 {
+	SoupSocketPrivate *priv;
+
 	g_return_val_if_fail (SOUP_IS_SOCKET (sock), FALSE);
+	priv = SOUP_SOCKET_GET_PRIVATE (sock);
 
-	return sock->priv->iochannel != NULL;
+	return priv->iochannel != NULL;
 }
 
 /**
@@ -822,20 +840,23 @@ soup_socket_is_connected (SoupSocket *sock)
 SoupAddress *
 soup_socket_get_local_address (SoupSocket *sock)
 {
+	SoupSocketPrivate *priv;
+
 	g_return_val_if_fail (SOUP_IS_SOCKET (sock), NULL);
+	priv = SOUP_SOCKET_GET_PRIVATE (sock);
 
-	g_mutex_lock (sock->priv->addrlock);
-	if (!sock->priv->local_addr) {
+	g_mutex_lock (priv->addrlock);
+	if (!priv->local_addr) {
 		struct soup_sockaddr_max bound_sa;
 		int sa_len;
 
 		sa_len = sizeof (bound_sa);
-		getsockname (sock->priv->sockfd, (struct sockaddr *)&bound_sa, &sa_len);
-		sock->priv->local_addr = soup_address_new_from_sockaddr ((struct sockaddr *)&bound_sa, sa_len);
+		getsockname (priv->sockfd, (struct sockaddr *)&bound_sa, &sa_len);
+		priv->local_addr = soup_address_new_from_sockaddr ((struct sockaddr *)&bound_sa, sa_len);
 	}
-	g_mutex_unlock (sock->priv->addrlock);
+	g_mutex_unlock (priv->addrlock);
 
-	return sock->priv->local_addr;
+	return priv->local_addr;
 }
 
 /**
@@ -849,20 +870,23 @@ soup_socket_get_local_address (SoupSocket *sock)
 SoupAddress *
 soup_socket_get_remote_address (SoupSocket *sock)
 {
+	SoupSocketPrivate *priv;
+
 	g_return_val_if_fail (SOUP_IS_SOCKET (sock), NULL);
+	priv = SOUP_SOCKET_GET_PRIVATE (sock);
 
-	g_mutex_lock (sock->priv->addrlock);
-	if (!sock->priv->remote_addr) {
+	g_mutex_lock (priv->addrlock);
+	if (!priv->remote_addr) {
 		struct soup_sockaddr_max bound_sa;
 		int sa_len;
 
 		sa_len = sizeof (bound_sa);
-		getpeername (sock->priv->sockfd, (struct sockaddr *)&bound_sa, &sa_len);
-		sock->priv->remote_addr = soup_address_new_from_sockaddr ((struct sockaddr *)&bound_sa, sa_len);
+		getpeername (priv->sockfd, (struct sockaddr *)&bound_sa, &sa_len);
+		priv->remote_addr = soup_address_new_from_sockaddr ((struct sockaddr *)&bound_sa, sa_len);
 	}
-	g_mutex_unlock (sock->priv->addrlock);
+	g_mutex_unlock (priv->addrlock);
 
-	return sock->priv->remote_addr;
+	return priv->remote_addr;
 }
 
 
@@ -872,8 +896,9 @@ static gboolean
 socket_read_watch (GIOChannel *chan, GIOCondition cond, gpointer user_data)
 {
 	SoupSocket *sock = user_data;
+	SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock);
 
-	sock->priv->read_tag = 0;
+	priv->read_tag = 0;
 	g_signal_emit (sock, signals[READABLE], 0);
 
 	return FALSE;
@@ -882,14 +907,15 @@ socket_read_watch (GIOChannel *chan, GIOCondition cond, gpointer user_data)
 static SoupSocketIOStatus
 read_from_network (SoupSocket *sock, gpointer buffer, gsize len, gsize *nread)
 {
+	SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock);
 	GIOStatus status;
 	GIOCondition cond = G_IO_IN;
 	GError *err = NULL;
 
-	if (!sock->priv->iochannel) 
+	if (!priv->iochannel) 
 		return SOUP_SOCKET_EOF;
 
-	status = g_io_channel_read_chars (sock->priv->iochannel,
+	status = g_io_channel_read_chars (priv->iochannel,
 					  buffer, len, nread, &err);
 	if (err) {
 		if (err->domain == SOUP_SSL_ERROR &&
@@ -910,9 +936,9 @@ read_from_network (SoupSocket *sock, gpointer buffer, gsize len, gsize *nread)
 		if (*nread > 0)
 			return SOUP_SOCKET_OK;
 
-		if (!sock->priv->read_tag) {
-			sock->priv->read_tag =
-				g_io_add_watch (sock->priv->iochannel, cond,
+		if (!priv->read_tag) {
+			priv->read_tag =
+				g_io_add_watch (priv->iochannel, cond,
 						socket_read_watch, sock);
 		}
 		return SOUP_SOCKET_WOULD_BLOCK;
@@ -928,14 +954,15 @@ read_from_network (SoupSocket *sock, gpointer buffer, gsize len, gsize *nread)
 static SoupSocketIOStatus
 read_from_buf (SoupSocket *sock, gpointer buffer, gsize len, gsize *nread)
 {
-	GByteArray *read_buf = sock->priv->read_buf;
+	SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock);
+	GByteArray *read_buf = priv->read_buf;
 
 	*nread = MIN (read_buf->len, len);
 	memcpy (buffer, read_buf->data, *nread);
 
 	if (*nread == read_buf->len) {
 		g_byte_array_free (read_buf, TRUE);
-		sock->priv->read_buf = NULL;
+		priv->read_buf = NULL;
 	} else {
 		memmove (read_buf->data, read_buf->data + *nread, 
 			 read_buf->len - *nread);
@@ -971,16 +998,18 @@ read_from_buf (SoupSocket *sock, gpointer buffer, gsize len, gsize *nread)
 SoupSocketIOStatus
 soup_socket_read (SoupSocket *sock, gpointer buffer, gsize len, gsize *nread)
 {
+	SoupSocketPrivate *priv;
 	SoupSocketIOStatus status;
 
 	g_return_val_if_fail (SOUP_IS_SOCKET (sock), SOUP_SOCKET_ERROR);
+	priv = SOUP_SOCKET_GET_PRIVATE (sock);
 
-	g_mutex_lock (sock->priv->iolock);
-	if (sock->priv->read_buf)
+	g_mutex_lock (priv->iolock);
+	if (priv->read_buf)
 		status = read_from_buf (sock, buffer, len, nread);
 	else
 		status = read_from_network (sock, buffer, len, nread);
-	g_mutex_unlock (sock->priv->iolock);
+	g_mutex_unlock (priv->iolock);
 
 	return status;
 }
@@ -1008,21 +1037,23 @@ soup_socket_read_until (SoupSocket *sock, gpointer buffer, gsize len,
 			gconstpointer boundary, gsize boundary_len,
 			gsize *nread, gboolean *got_boundary)
 {
+	SoupSocketPrivate *priv;
 	SoupSocketIOStatus status;
 	GByteArray *read_buf;
 	guint match_len, prev_len;
 	guint8 *p, *end;
 
 	g_return_val_if_fail (SOUP_IS_SOCKET (sock), SOUP_SOCKET_ERROR);
+	priv = SOUP_SOCKET_GET_PRIVATE (sock);
 	g_return_val_if_fail (len >= boundary_len, SOUP_SOCKET_ERROR);
 
-	g_mutex_lock (sock->priv->iolock);
+	g_mutex_lock (priv->iolock);
 
 	*got_boundary = FALSE;
 
-	if (!sock->priv->read_buf)
-		sock->priv->read_buf = g_byte_array_new ();
-	read_buf = sock->priv->read_buf;
+	if (!priv->read_buf)
+		priv->read_buf = g_byte_array_new ();
+	read_buf = priv->read_buf;
 
 	if (read_buf->len < boundary_len) {
 		prev_len = read_buf->len;
@@ -1033,7 +1064,7 @@ soup_socket_read_until (SoupSocket *sock, gpointer buffer, gsize len,
 		read_buf->len = prev_len + *nread;
 
 		if (status != SOUP_SOCKET_OK) {
-			g_mutex_unlock (sock->priv->iolock);
+			g_mutex_unlock (priv->iolock);
 			return status;
 		}
 	}
@@ -1055,7 +1086,7 @@ soup_socket_read_until (SoupSocket *sock, gpointer buffer, gsize len,
 	match_len = p - read_buf->data;
 	status = read_from_buf (sock, buffer, MIN (len, match_len), nread);
 
-	g_mutex_unlock (sock->priv->iolock);
+	g_mutex_unlock (priv->iolock);
 	return status;
 }
 
@@ -1063,8 +1094,9 @@ static gboolean
 socket_write_watch (GIOChannel *chan, GIOCondition condition, gpointer user_data)
 {
 	SoupSocket *sock = user_data;
+	SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock);
 
-	sock->priv->write_tag = 0;
+	priv->write_tag = 0;
 	g_signal_emit (sock, signals[WRITABLE], 0);
 
 	return FALSE;
@@ -1095,26 +1127,28 @@ SoupSocketIOStatus
 soup_socket_write (SoupSocket *sock, gconstpointer buffer,
 		   gsize len, gsize *nwrote)
 {
+	SoupSocketPrivate *priv;
 	GIOStatus status;
 	gpointer pipe_handler;
 	GIOCondition cond = G_IO_OUT;
 	GError *err = NULL;
 
 	g_return_val_if_fail (SOUP_IS_SOCKET (sock), SOUP_SOCKET_ERROR);
+	priv = SOUP_SOCKET_GET_PRIVATE (sock);
 
-	g_mutex_lock (sock->priv->iolock);
+	g_mutex_lock (priv->iolock);
 
-	if (!sock->priv->iochannel) {
-		g_mutex_unlock (sock->priv->iolock);
+	if (!priv->iochannel) {
+		g_mutex_unlock (priv->iolock);
 		return SOUP_SOCKET_EOF;
 	}
-	if (sock->priv->write_tag) {
-		g_mutex_unlock (sock->priv->iolock);
+	if (priv->write_tag) {
+		g_mutex_unlock (priv->iolock);
 		return SOUP_SOCKET_WOULD_BLOCK;
 	}
 
 	pipe_handler = signal (SIGPIPE, SIG_IGN);
-	status = g_io_channel_write_chars (sock->priv->iochannel,
+	status = g_io_channel_write_chars (priv->iochannel,
 					   buffer, len, nwrote, &err);
 	signal (SIGPIPE, pipe_handler);
 	if (err) {
@@ -1131,18 +1165,18 @@ soup_socket_write (SoupSocket *sock, gconstpointer buffer,
 	}
 
 	if (status != G_IO_STATUS_NORMAL && status != G_IO_STATUS_AGAIN) {
-		g_mutex_unlock (sock->priv->iolock);
+		g_mutex_unlock (priv->iolock);
 		return SOUP_SOCKET_ERROR;
 	}
 
 	if (*nwrote) {
-		g_mutex_unlock (sock->priv->iolock);
+		g_mutex_unlock (priv->iolock);
 		return SOUP_SOCKET_OK;
 	}
 
-	sock->priv->write_tag =
-		g_io_add_watch (sock->priv->iochannel, cond, 
+	priv->write_tag =
+		g_io_add_watch (priv->iochannel, cond, 
 				socket_write_watch, sock);
-	g_mutex_unlock (sock->priv->iolock);
+	g_mutex_unlock (priv->iolock);
 	return SOUP_SOCKET_WOULD_BLOCK;
 }
diff --git a/libsoup/soup-socket.h b/libsoup/soup-socket.h
index 49e88a9d..bb43caa7 100644
--- a/libsoup/soup-socket.h
+++ b/libsoup/soup-socket.h
@@ -15,12 +15,9 @@
 #define SOUP_IS_SOCKET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_SOCKET))
 #define SOUP_SOCKET_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_SOCKET, SoupSocketClass))
 
-typedef struct SoupSocketPrivate SoupSocketPrivate;
-
 struct SoupSocket {
 	GObject parent;
 
-	SoupSocketPrivate *priv;
 };
 
 typedef struct {
diff --git a/libsoup/soup-types.h b/libsoup/soup-types.h
index c7a97aa7..ecd72827 100644
--- a/libsoup/soup-types.h
+++ b/libsoup/soup-types.h
@@ -25,30 +25,6 @@ typedef struct SoupSessionSync       SoupSessionSync;
 typedef struct SoupSocket            SoupSocket;
 typedef struct SoupUri               SoupUri;
 
-#define SOUP_MAKE_TYPE(type_name,TypeName,class_init,init,parent) \
-GType type_name##_get_type(void)\
-{\
-	static GType type = 0;				\
-	if (!type){					\
-		static GTypeInfo const object_info = {	\
-			sizeof (TypeName##Class),	\
-							\
-			(GBaseInitFunc) NULL,		\
-			(GBaseFinalizeFunc) NULL,	\
-							\
-			(GClassInitFunc) class_init,	\
-			(GClassFinalizeFunc) NULL,	\
-			NULL,	/* class_data */	\
-							\
-			sizeof (TypeName),		\
-			0,	/* n_preallocs */	\
-			(GInstanceInitFunc) init,	\
-		};					\
-		type = g_type_register_static (parent, #TypeName, &object_info, 0); \
-	}						\
-	return type;					\
-}
-
 #define SOUP_MAKE_INTERFACE(type_name,TypeName,base_init) \
 GType type_name##_get_type(void)\
 {\
@@ -73,34 +49,4 @@ GType type_name##_get_type(void)\
 	return type;					\
 }
 
-#define SOUP_MAKE_TYPE_WITH_IFACE(type_name,TypeName,class_init,init,parent,iface_init,iparent) \
-GType type_name##_get_type(void)\
-{\
-	static GType type = 0;				\
-	if (!type){					\
-		static GTypeInfo const object_info = {	\
-			sizeof (TypeName##Class),	\
-							\
-			(GBaseInitFunc) NULL,		\
-			(GBaseFinalizeFunc) NULL,	\
-							\
-			(GClassInitFunc) class_init,	\
-			(GClassFinalizeFunc) NULL,	\
-			NULL,	/* class_data */	\
-							\
-			sizeof (TypeName),		\
-			0,	/* n_preallocs */	\
-			(GInstanceInitFunc) init,	\
-		};					\
-		static GInterfaceInfo const iface_info = {	\
-			(GInterfaceInitFunc) iface_init,	\
-			NULL,					\
-			NULL					\
-		};						\
-		type = g_type_register_static (parent, #TypeName, &object_info, 0);	\
-		g_type_add_interface_static (type, iparent, &iface_info);		\
-	}						\
-	return type;					\
-}
-
 #endif
author	Dan Winship <danw@src.gnome.org>	2005-04-11 20:42:07 +0000
committer	Dan Winship <danw@src.gnome.org>	2005-04-11 20:42:07 +0000
commit	dbc7ce9e0f5bf9c8be764946886a9003fb129b29 (patch)
tree	4a60b096b33fbce7a9ddf26f9ba1b77f6d8688d4 /libsoup
parent	0d10ee7c5a25bf27440e914be3b891c5004ebc6f (diff)
download	libsoup-dbc7ce9e0f5bf9c8be764946886a9003fb129b29.tar.gz