diff --git a/libsoup/soup-address.c b/libsoup/soup-address.c

index 0351db50..9c0b0a45 100644

--- a/libsoup/soup-address.c

+++ b/libsoup/soup-address.c

@@ -1183,10 +1183,10 @@ got_addresses (SoupAddress *addr, guint status, gpointer user_data)

 	if (error)

 		g_task_return_error (task, g_error_copy (error));

 	else {

-		GSocketAddress *addr;

+		GSocketAddress *socket_addr;

-		addr = next_address (g_task_get_source_object (task));

-		g_task_return_pointer (task, addr, g_object_unref);

+		socket_addr = next_address (g_task_get_source_object (task));

+		g_task_return_pointer (task, socket_addr, g_object_unref);

 	}

 	g_object_unref (task);

 }

diff --git a/libsoup/soup-auth-basic.c b/libsoup/soup-auth-basic.c

index 5f1e7186..d8b32264 100644

--- a/libsoup/soup-auth-basic.c

+++ b/libsoup/soup-auth-basic.c

@@ -74,7 +74,7 @@ soup_auth_basic_get_protection_space (SoupAuth *auth, SoupURI *source_uri)

 	/* Strip filename component */

 	p = strrchr (space, '/');

-	if (p == space && p[1])

+	if (p && p == space && p[1])

 		p[1] = '\0';

 	else if (p && p[1])

 		*p = '\0';

diff --git a/libsoup/soup-auth-digest.c b/libsoup/soup-auth-digest.c

index eda2a93c..45dd35be 100644

--- a/libsoup/soup-auth-digest.c

+++ b/libsoup/soup-auth-digest.c

@@ -343,7 +343,7 @@ soup_auth_digest_compute_response (const char        *method,

 	g_checksum_update (checksum, (guchar *)method, strlen (method));

 	g_checksum_update (checksum, (guchar *)":", 1);

 	g_checksum_update (checksum, (guchar *)uri, strlen (uri));

-	strncpy (hex_a2, g_checksum_get_string (checksum), 33);

+	memcpy (hex_a2, g_checksum_get_string (checksum), sizeof (char) * 33);

 	g_checksum_free (checksum);

 	/* compute KD */

diff --git a/libsoup/soup-auth-negotiate.c b/libsoup/soup-auth-negotiate.c

index 1fdf142d..941e49be 100644

--- a/libsoup/soup-auth-negotiate.c

+++ b/libsoup/soup-auth-negotiate.c

@@ -200,9 +200,9 @@ soup_auth_negotiate_get_connection_authorization (SoupConnectionAuth *auth,

 			/* FIXME: report further upward via

 			 * soup_message_get_error_message  */

 			if (conn->initialized)

-				g_warning ("gssapi step failed: %s", err->message);

+				g_warning ("gssapi step failed: %s", err ? err->message : "Internal error");

 			else

-				g_warning ("gssapi init failed: %s", err->message);

+				g_warning ("gssapi init failed: %s", err ? err->message : "Internal error");

 			conn->state = SOUP_NEGOTIATE_FAILED;

 			g_clear_error (&err;;

@@ -274,9 +274,9 @@ soup_auth_negotiate_update_connection (SoupConnectionAuth *auth, SoupMessage *ms

 			/* FIXME: report further upward via

 			 * soup_message_get_error_message  */

 			if (conn->initialized)

-				g_warning ("gssapi step failed: %s", err->message);

+				g_warning ("gssapi step failed: %s", err ? err->message : "Internal error");

 			else

-				g_warning ("gssapi init failed: %s", err->message);

+				g_warning ("gssapi init failed: %s", err ? err->message : "Internal error");

 			success = FALSE;

 		}

 	} else if (!strncmp (header, "Negotiate ", 10)) {

diff --git a/libsoup/soup-auth-ntlm.c b/libsoup/soup-auth-ntlm.c

index 19a551ee..f4009aa8 100644

--- a/libsoup/soup-auth-ntlm.c

+++ b/libsoup/soup-auth-ntlm.c

@@ -810,7 +810,7 @@ soup_ntlm_response (const char *nonce,

 	ntlm_set_string (&resp.nt_resp, &offset, sizeof (nt_resp));

 	out = g_malloc (((offset + 3) * 4) / 3 + 6);

-	strncpy (out, "NTLM ", 5);

+	memcpy (out, "NTLM ", 5);

 	p = out + 5;

 	state = save = 0;

diff --git a/libsoup/soup-auth.c b/libsoup/soup-auth.c

index 00aa405e..48f39359 100644

--- a/libsoup/soup-auth.c

+++ b/libsoup/soup-auth.c

@@ -107,13 +107,9 @@ soup_auth_get_property (GObject *object, guint prop_id,

 		g_value_set_string (value, soup_auth_get_scheme_name (auth));

 		break;

 	case PROP_REALM:

-		if (auth->realm)

-			g_free (auth->realm);

 		g_value_set_string (value, soup_auth_get_realm (auth));

 		break;

 	case PROP_HOST:

-		if (priv->host)

-			g_free (priv->host);

 		g_value_set_string (value, soup_auth_get_host (auth));

 		break;

 	case PROP_IS_FOR_PROXY:

@@ -349,10 +345,12 @@ soup_auth_authenticate (SoupAuth *auth, const char *username, const char *passwo

 gboolean

 soup_auth_is_for_proxy (SoupAuth *auth)

 {

-	SoupAuthPrivate *priv = soup_auth_get_instance_private (auth);

+	SoupAuthPrivate *priv;

 	g_return_val_if_fail (SOUP_IS_AUTH (auth), FALSE);

+	priv = soup_auth_get_instance_private (auth);

+

 	return priv->proxy;

 }

@@ -367,9 +365,14 @@ soup_auth_is_for_proxy (SoupAuth *auth)

 const char *

 soup_auth_get_scheme_name (SoupAuth *auth)

 {

+	SoupAuthClass *klass;

+

 	g_return_val_if_fail (SOUP_IS_AUTH (auth), NULL);

-	return SOUP_AUTH_GET_CLASS (auth)->scheme_name;

+	klass = SOUP_AUTH_GET_CLASS (auth);

+	g_return_val_if_fail (klass != NULL, NULL);

+

+	return klass->scheme_name;

 }

 /**

@@ -383,10 +386,12 @@ soup_auth_get_scheme_name (SoupAuth *auth)

 const char *

 soup_auth_get_host (SoupAuth *auth)

 {

-	SoupAuthPrivate *priv = soup_auth_get_instance_private (auth);

+	SoupAuthPrivate *priv;

 	g_return_val_if_fail (SOUP_IS_AUTH (auth), NULL);

+	priv = soup_auth_get_instance_private (auth);

+

 	return priv->host;

 }

@@ -423,13 +428,18 @@ soup_auth_get_realm (SoupAuth *auth)

 char *

 soup_auth_get_info (SoupAuth *auth)

 {

+	SoupAuthClass *klass;

+

 	g_return_val_if_fail (SOUP_IS_AUTH (auth), NULL);

+	klass = SOUP_AUTH_GET_CLASS (auth);

+	g_return_val_if_fail (klass != NULL, NULL);

+

 	if (SOUP_IS_CONNECTION_AUTH (auth))

-		return g_strdup (SOUP_AUTH_GET_CLASS (auth)->scheme_name);

+		return g_strdup (klass->scheme_name);

 	else {

 		return g_strdup_printf ("%s:%s",

-					SOUP_AUTH_GET_CLASS (auth)->scheme_name,

+					klass->scheme_name,

 					auth->realm);

 	}

 }

@@ -445,9 +455,14 @@ soup_auth_get_info (SoupAuth *auth)

 gboolean

 soup_auth_is_authenticated (SoupAuth *auth)

 {

+	SoupAuthClass *klass;

+

 	g_return_val_if_fail (SOUP_IS_AUTH (auth), TRUE);

-	return SOUP_AUTH_GET_CLASS (auth)->is_authenticated (auth);

+	klass = SOUP_AUTH_GET_CLASS (auth);

+	g_return_val_if_fail (klass != NULL, TRUE);

+

+	return klass->is_authenticated (auth);

 }

 /**

@@ -464,10 +479,15 @@ soup_auth_is_authenticated (SoupAuth *auth)

 char *

 soup_auth_get_authorization (SoupAuth *auth, SoupMessage *msg)

 {

+	SoupAuthClass *klass;

+

 	g_return_val_if_fail (SOUP_IS_AUTH (auth), NULL);

 	g_return_val_if_fail (msg != NULL, NULL);

-	return SOUP_AUTH_GET_CLASS (auth)->get_authorization (auth, msg);

+	klass = SOUP_AUTH_GET_CLASS (auth);

+	g_return_val_if_fail (klass != NULL, NULL);

+

+	return klass->get_authorization (auth, msg);

 }

 /**

@@ -488,13 +508,18 @@ gboolean

 soup_auth_is_ready (SoupAuth    *auth,

 		    SoupMessage *msg)

 {

+	SoupAuthClass *klass;

+

 	g_return_val_if_fail (SOUP_IS_AUTH (auth), TRUE);

 	g_return_val_if_fail (SOUP_IS_MESSAGE (msg), TRUE);

-	if (SOUP_AUTH_GET_CLASS (auth)->is_ready)

-		return SOUP_AUTH_GET_CLASS (auth)->is_ready (auth, msg);

+	klass = SOUP_AUTH_GET_CLASS (auth);

+	g_return_val_if_fail (klass != NULL, TRUE);

+

+	if (klass->is_ready)

+		return klass->is_ready (auth, msg);

 	else

-		return SOUP_AUTH_GET_CLASS (auth)->is_authenticated (auth);

+		return klass->is_authenticated (auth);

 }

 /**

@@ -511,9 +536,14 @@ soup_auth_is_ready (SoupAuth    *auth,

 gboolean

 soup_auth_can_authenticate (SoupAuth *auth)

 {

+	SoupAuthClass *klass;

+

 	g_return_val_if_fail (SOUP_IS_AUTH (auth), FALSE);

-	return SOUP_AUTH_GET_CLASS (auth)->can_authenticate (auth);

+	klass = SOUP_AUTH_GET_CLASS (auth);

+	g_return_val_if_fail (klass != NULL, FALSE);

+

+	return klass->can_authenticate (auth);

 }

 /**

@@ -533,10 +563,15 @@ soup_auth_can_authenticate (SoupAuth *auth)

 GSList *

 soup_auth_get_protection_space (SoupAuth *auth, SoupURI *source_uri)

 {

+	SoupAuthClass *klass;

+

 	g_return_val_if_fail (SOUP_IS_AUTH (auth), NULL);

 	g_return_val_if_fail (source_uri != NULL, NULL);

-	return SOUP_AUTH_GET_CLASS (auth)->get_protection_space (auth, source_uri);

+	klass = SOUP_AUTH_GET_CLASS (auth);

+	g_return_val_if_fail (klass != NULL, NULL);

+

+	return klass->get_protection_space (auth, source_uri);

 }

 /**

diff --git a/libsoup/soup-body-output-stream.c b/libsoup/soup-body-output-stream.c

index 314d7ee9..58e9b3ee 100644

--- a/libsoup/soup-body-output-stream.c

+++ b/libsoup/soup-body-output-stream.c

@@ -162,7 +162,6 @@ again:

 	case SOUP_BODY_OUTPUT_STREAM_STATE_CHUNK_SIZE:

 		g_snprintf (buf, sizeof (bostream->priv->buf),

 			    "%lx\r\n", (gulong)count);

-		len = strlen (buf);

 		if (count > 0)

 			bostream->priv->chunked_state = SOUP_BODY_OUTPUT_STREAM_STATE_CHUNK;

@@ -182,13 +181,11 @@ again:

 	case SOUP_BODY_OUTPUT_STREAM_STATE_CHUNK_END:

 		strncpy (buf, "\r\n", sizeof (bostream->priv->buf));

-		len = 2;

 		bostream->priv->chunked_state = SOUP_BODY_OUTPUT_STREAM_STATE_DONE;

 		break;

 	case SOUP_BODY_OUTPUT_STREAM_STATE_TRAILERS:

 		strncpy (buf, "\r\n", sizeof (bostream->priv->buf));

-		len = 2;

 		bostream->priv->chunked_state = SOUP_BODY_OUTPUT_STREAM_STATE_DONE;

 		break;

diff --git a/libsoup/soup-cache.c b/libsoup/soup-cache.c

index 682625e6..63c13121 100644

--- a/libsoup/soup-cache.c

+++ b/libsoup/soup-cache.c

@@ -822,6 +822,9 @@ soup_cache_content_processor_wrap_input (SoupContentProcessor *processor,

 	StreamHelper *helper;

 	time_t request_time, response_time;

+	g_return_val_if_fail (SOUP_IS_CACHE (cache), NULL);

+	g_return_val_if_fail (SOUP_IS_MESSAGE (msg), NULL);

+

 	/* First of all, check if we should cache the resource. */

 	cacheability = soup_cache_get_cacheability (cache, msg);

 	entry = soup_cache_entry_lookup (cache, msg);

@@ -1075,6 +1078,9 @@ soup_cache_has_response (SoupCache *cache, SoupMessage *msg)

 	int max_age, max_stale, min_fresh;

 	GList *lru_item, *item;

+	g_return_val_if_fail (SOUP_IS_CACHE (cache), SOUP_CACHE_RESPONSE_STALE);

+	g_return_val_if_fail (SOUP_IS_MESSAGE (msg), SOUP_CACHE_RESPONSE_STALE);

+

 	entry = soup_cache_entry_lookup (cache, msg);

 	/* 1. The presented Request-URI and that of stored response

@@ -1226,10 +1232,15 @@ soup_cache_has_response (SoupCache *cache, SoupMessage *msg)

 SoupCacheability

 soup_cache_get_cacheability (SoupCache *cache, SoupMessage *msg)

 {

+	SoupCacheClass *klass;

+

 	g_return_val_if_fail (SOUP_IS_CACHE (cache), SOUP_CACHE_UNCACHEABLE);

 	g_return_val_if_fail (SOUP_IS_MESSAGE (msg), SOUP_CACHE_UNCACHEABLE);

-	return SOUP_CACHE_GET_CLASS (cache)->get_cacheability (cache, msg);

+	klass = SOUP_CACHE_GET_CLASS (cache);

+	g_return_val_if_fail (klass != NULL, SOUP_CACHE_UNCACHEABLE);

+

+	return klass->get_cacheability (cache, msg);

 }

 static gboolean

@@ -1404,6 +1415,9 @@ soup_cache_cancel_conditional_request (SoupCache   *cache,

 {

 	SoupCacheEntry *entry;

+	g_return_if_fail (SOUP_IS_CACHE (cache));

+	g_return_if_fail (SOUP_IS_MESSAGE (msg));

+

 	entry = soup_cache_entry_lookup (cache, msg);

 	if (entry)

 		entry->being_validated = FALSE;

@@ -1415,7 +1429,12 @@ void

 soup_cache_update_from_conditional_request (SoupCache   *cache,

 					    SoupMessage *msg)

 {

-	SoupCacheEntry *entry = soup_cache_entry_lookup (cache, msg);

+	SoupCacheEntry *entry;

+

+	g_return_if_fail (SOUP_IS_CACHE (cache));

+	g_return_if_fail (SOUP_IS_MESSAGE (msg));

+

+	entry = soup_cache_entry_lookup (cache, msg);

 	if (!entry)

 		return;

diff --git a/libsoup/soup-connection-auth.c b/libsoup/soup-connection-auth.c

index f55cfe6b..a44013e3 100644

--- a/libsoup/soup-connection-auth.c

+++ b/libsoup/soup-connection-auth.c

@@ -39,8 +39,14 @@ soup_connection_auth_free_connection_state (SoupConnectionAuth *auth,

 					    SoupConnection     *conn,

 					    gpointer            state)

 {

+	SoupConnectionAuthClass *klass;

+

 	g_signal_handlers_disconnect_by_func (conn, G_CALLBACK (connection_disconnected), auth);

-	SOUP_CONNECTION_AUTH_GET_CLASS (auth)->free_connection_state (auth, state);

+

+	klass = SOUP_CONNECTION_AUTH_GET_CLASS (auth);

+	g_return_if_fail (klass != NULL);

+

+	klass->free_connection_state (auth, state);

 }

 static void

@@ -91,6 +97,7 @@ soup_connection_auth_get_connection_state_for_message (SoupConnectionAuth *auth,

 						       SoupMessage *msg)

 {

 	SoupConnection *conn;

+	SoupConnectionAuthClass *klass;

 	gpointer state;

 	g_return_val_if_fail (SOUP_IS_CONNECTION_AUTH (auth), NULL);

@@ -101,7 +108,10 @@ soup_connection_auth_get_connection_state_for_message (SoupConnectionAuth *auth,

 	if (state)

 		return state;

-	state = SOUP_CONNECTION_AUTH_GET_CLASS (auth)->create_connection_state (auth);

+	klass = SOUP_CONNECTION_AUTH_GET_CLASS (auth);

+	g_return_val_if_fail (klass != NULL, NULL);

+

+	state = klass->create_connection_state (auth);

 	if (conn) {

 		g_signal_connect (conn, "disconnected",

 				  G_CALLBACK (connection_disconnected), auth);

@@ -117,12 +127,15 @@ soup_connection_auth_update (SoupAuth    *auth,

 			     GHashTable  *auth_params)

 {

 	SoupConnectionAuth *cauth = SOUP_CONNECTION_AUTH (auth);

+	SoupConnectionAuthClass *klass = SOUP_CONNECTION_AUTH_GET_CLASS (auth);

 	gpointer conn = soup_connection_auth_get_connection_state_for_message (cauth, msg);

 	GHashTableIter iter;

 	GString *auth_header;

 	gpointer key, value;

 	gboolean result;

+	g_return_val_if_fail (klass != NULL, FALSE);

+

 	/* Recreate @auth_header out of @auth_params. If the

 	 * base64 data ended with 1 or more "="s, then it

 	 * will have been parsed as key=value. Otherwise

@@ -147,8 +160,7 @@ soup_connection_auth_update (SoupAuth    *auth,

 		}

 	}

-	result = SOUP_CONNECTION_AUTH_GET_CLASS (auth)->

-		update_connection (cauth, msg, auth_header->str, conn);

+	result = klass->update_connection (cauth, msg, auth_header->str, conn);

 	g_string_free (auth_header, TRUE);

 	return result;

@@ -159,10 +171,13 @@ soup_connection_auth_get_authorization (SoupAuth    *auth,

 					SoupMessage *msg)

 {

 	SoupConnectionAuth *cauth = SOUP_CONNECTION_AUTH (auth);

+	SoupConnectionAuthClass *klass;

 	gpointer conn = soup_connection_auth_get_connection_state_for_message (cauth, msg);

-	return SOUP_CONNECTION_AUTH_GET_CLASS (auth)->

-		get_connection_authorization (cauth, msg, conn);

+	klass = SOUP_CONNECTION_AUTH_GET_CLASS (auth);

+	g_return_val_if_fail (klass != NULL, NULL);

+

+	return klass->get_connection_authorization (cauth, msg, conn);

 }

 static gboolean

@@ -170,10 +185,13 @@ soup_connection_auth_is_ready (SoupAuth    *auth,

 			       SoupMessage *msg)

 {

 	SoupConnectionAuth *cauth = SOUP_CONNECTION_AUTH (auth);

+	SoupConnectionAuthClass *klass;

 	gpointer conn = soup_connection_auth_get_connection_state_for_message (cauth, msg);

-	return SOUP_CONNECTION_AUTH_GET_CLASS (auth)->

-		is_connection_ready (SOUP_CONNECTION_AUTH (auth), msg, conn);

+	klass = SOUP_CONNECTION_AUTH_GET_CLASS (auth);

+	g_return_val_if_fail (klass != NULL, FALSE);

+

+	return klass->is_connection_ready (SOUP_CONNECTION_AUTH (auth), msg, conn);

 }

 static void

diff --git a/libsoup/soup-content-sniffer-stream.c b/libsoup/soup-content-sniffer-stream.c

index b8a8c97e..7f74c705 100644

--- a/libsoup/soup-content-sniffer-stream.c

+++ b/libsoup/soup-content-sniffer-stream.c

@@ -167,7 +167,8 @@ read_internal (GInputStream  *stream,

 	if (sniffer->priv->buffer) {

 		nread = MIN (count, sniffer->priv->buffer_nread);

-		memcpy (buffer, sniffer->priv->buffer, nread);

+		if (buffer)

+			memcpy (buffer, sniffer->priv->buffer, nread);

 		if (nread == sniffer->priv->buffer_nread) {

 			g_free (sniffer->priv->buffer);

 			sniffer->priv->buffer = NULL;

diff --git a/libsoup/soup-content-sniffer.c b/libsoup/soup-content-sniffer.c

index 7573fde5..20e10d71 100644

--- a/libsoup/soup-content-sniffer.c

+++ b/libsoup/soup-content-sniffer.c

@@ -925,11 +925,16 @@ soup_content_sniffer_sniff (SoupContentSniffer *sniffer,

 			    SoupMessage *msg, SoupBuffer *buffer,

 			    GHashTable **params)

 {

+	SoupContentSnifferClass *klass;

+

 	g_return_val_if_fail (SOUP_IS_CONTENT_SNIFFER (sniffer), NULL);

 	g_return_val_if_fail (SOUP_IS_MESSAGE (msg), NULL);

 	g_return_val_if_fail (buffer != NULL, NULL);

-	return SOUP_CONTENT_SNIFFER_GET_CLASS (sniffer)->sniff (sniffer, msg, buffer, params);

+	klass = SOUP_CONTENT_SNIFFER_GET_CLASS (sniffer);

+	g_return_val_if_fail (klass != NULL, NULL);

+

+	return klass->sniff (sniffer, msg, buffer, params);

 }

 /**

@@ -946,7 +951,12 @@ soup_content_sniffer_sniff (SoupContentSniffer *sniffer,

 gsize

 soup_content_sniffer_get_buffer_size (SoupContentSniffer *sniffer)

 {

+	SoupContentSnifferClass *klass;

+

 	g_return_val_if_fail (SOUP_IS_CONTENT_SNIFFER (sniffer), 0);

-	return SOUP_CONTENT_SNIFFER_GET_CLASS (sniffer)->get_buffer_size (sniffer);

+	klass = SOUP_CONTENT_SNIFFER_GET_CLASS (sniffer);

+	g_return_val_if_fail (klass != NULL, 0);

+

+	return klass->get_buffer_size (sniffer);

 }

diff --git a/libsoup/soup-cookie-jar.c b/libsoup/soup-cookie-jar.c

index 2369c8a7..3996c62f 100644

--- a/libsoup/soup-cookie-jar.c

+++ b/libsoup/soup-cookie-jar.c

@@ -888,7 +888,12 @@ soup_cookie_jar_set_accept_policy (SoupCookieJar *jar,

 gboolean

 soup_cookie_jar_is_persistent (SoupCookieJar *jar)

 {

+	SoupCookieJarClass *klass;

+

 	g_return_val_if_fail (SOUP_IS_COOKIE_JAR (jar), FALSE);

-	return SOUP_COOKIE_JAR_GET_CLASS (jar)->is_persistent (jar);

+	klass = SOUP_COOKIE_JAR_GET_CLASS (jar);

+	g_return_val_if_fail (klass != NULL, FALSE);

+

+	return klass->is_persistent (jar);

 }

diff --git a/libsoup/soup-message-headers.c b/libsoup/soup-message-headers.c

index a180c6ee..abef34cb 100644

--- a/libsoup/soup-message-headers.c

+++ b/libsoup/soup-message-headers.c

@@ -1324,7 +1324,7 @@ content_type_setter (SoupMessageHeaders *hdrs, const char *value)

 {

 	g_free (hdrs->content_type);

 	if (value) {

-		char *content_type, *p;

+		char *content_type = NULL, *p;

 		parse_content_foo (hdrs, "Content-Type", &content_type, NULL);

 		p = strpbrk (content_type, " /");

diff --git a/libsoup/soup-session.c b/libsoup/soup-session.c

index ae340b9c..42f38889 100644

--- a/libsoup/soup-session.c

+++ b/libsoup/soup-session.c

@@ -2175,11 +2175,15 @@ void

 soup_session_queue_message (SoupSession *session, SoupMessage *msg,

 			    SoupSessionCallback callback, gpointer user_data)

 {

+	SoupSessionClass *klass;

+

 	g_return_if_fail (SOUP_IS_SESSION (session));

 	g_return_if_fail (SOUP_IS_MESSAGE (msg));

-	SOUP_SESSION_GET_CLASS (session)->queue_message (session, msg,

-							 callback, user_data);

+	klass = SOUP_SESSION_GET_CLASS (session);

+	g_return_if_fail (klass != NULL);

+

+	klass->queue_message (session, msg, callback, user_data);

 	/* The SoupMessageQueueItem will hold a ref on @msg until it is

 	 * finished, so we can drop the ref adopted from the caller now.

 	 */

@@ -2219,10 +2223,15 @@ soup_session_real_requeue_message (SoupSession *session, SoupMessage *msg)

 void

 soup_session_requeue_message (SoupSession *session, SoupMessage *msg)

 {

+	SoupSessionClass *klass;

+

 	g_return_if_fail (SOUP_IS_SESSION (session));

 	g_return_if_fail (SOUP_IS_MESSAGE (msg));

-	SOUP_SESSION_GET_CLASS (session)->requeue_message (session, msg);

+	klass = SOUP_SESSION_GET_CLASS (session);

+	g_return_if_fail (klass != NULL);

+

+	klass->requeue_message (session, msg);

 }

 static guint

@@ -2266,10 +2275,15 @@ soup_session_real_send_message (SoupSession *session, SoupMessage *msg)

 guint

 soup_session_send_message (SoupSession *session, SoupMessage *msg)

 {

+	SoupSessionClass *klass;

+

 	g_return_val_if_fail (SOUP_IS_SESSION (session), SOUP_STATUS_MALFORMED);

 	g_return_val_if_fail (SOUP_IS_MESSAGE (msg), SOUP_STATUS_MALFORMED);

-	return SOUP_SESSION_GET_CLASS (session)->send_message (session, msg);

+	klass = SOUP_SESSION_GET_CLASS (session);

+	g_return_val_if_fail (klass != NULL, SOUP_STATUS_MALFORMED);

+

+	return klass->send_message (session, msg);

 }

@@ -2350,7 +2364,14 @@ soup_session_real_kick_queue (SoupSession *session)

 void

 soup_session_kick_queue (SoupSession *session)

 {

-	SOUP_SESSION_GET_CLASS (session)->kick (session);

+	SoupSessionClass *klass;

+

+	g_return_if_fail (SOUP_IS_SESSION (session));

+

+	klass = SOUP_SESSION_GET_CLASS (session);

+	g_return_if_fail (klass != NULL);

+

+	klass->kick (session);

 }

 /**

@@ -2450,11 +2471,15 @@ soup_session_cancel_message (SoupSession *session, SoupMessage *msg,

 			     guint status_code)

 {

 	SoupSessionPrivate *priv;

+	SoupSessionClass *klass;

 	SoupMessageQueueItem *item;

 	g_return_if_fail (SOUP_IS_SESSION (session));

 	g_return_if_fail (SOUP_IS_MESSAGE (msg));

+	klass = SOUP_SESSION_GET_CLASS (session);

+	g_return_if_fail (klass != NULL);

+

 	priv = soup_session_get_instance_private (session);

 	item = soup_message_queue_lookup (priv->queue, msg);

 	/* If the message is already ending, don't do anything */

@@ -2465,7 +2490,7 @@ soup_session_cancel_message (SoupSession *session, SoupMessage *msg,

 		return;

 	}

-	SOUP_SESSION_GET_CLASS (session)->cancel_message (session, msg, status_code);

+	klass->cancel_message (session, msg, status_code);

 	soup_message_queue_item_unref (item);

 }

@@ -2538,15 +2563,20 @@ soup_session_real_flush_queue (SoupSession *session)

 void

 soup_session_abort (SoupSession *session)

 {

+	SoupSessionClass *klass;

 	SoupSessionPrivate *priv;

 	GSList *conns, *c;

 	GHashTableIter iter;

 	gpointer conn, host;

 	g_return_if_fail (SOUP_IS_SESSION (session));

+

+	klass = SOUP_SESSION_GET_CLASS (session);

+	g_return_if_fail (klass != NULL);

+

 	priv = soup_session_get_instance_private (session);

-	SOUP_SESSION_GET_CLASS (session)->flush_queue (session);

+	klass->flush_queue (session);

 	/* Close all idle connections */

 	g_mutex_lock (&priv->conn_lock);

diff --git a/libsoup/soup-status.h b/libsoup/soup-status.h

index 28d481db..514dfc31 100644

--- a/libsoup/soup-status.h

+++ b/libsoup/soup-status.h

@@ -8,7 +8,7 @@

 #ifndef SOUP_STATUS_H

 #define SOUP_STATUS_H 1

-#include <libsoup/soup-types.h>

+#include <libsoup/soup-version.h>

 G_BEGIN_DECLS

diff --git a/libsoup/soup-uri.c b/libsoup/soup-uri.c

index be778d6c..74c362e9 100644

--- a/libsoup/soup-uri.c

+++ b/libsoup/soup-uri.c

@@ -1348,7 +1348,7 @@ soup_uri_is_http (SoupURI *uri, char **aliases)

 			return TRUE;

 	}

-	if (!aliases[1] && !strcmp (aliases[0], "*"))

+	if (aliases[0] && !aliases[1] && !strcmp (aliases[0], "*"))

 		return TRUE;

 	else

 		return FALSE;

diff --git a/libsoup/soup-xmlrpc.c b/libsoup/soup-xmlrpc.c

index 42dcda9c..60fb814c 100644

--- a/libsoup/soup-xmlrpc.c

+++ b/libsoup/soup-xmlrpc.c

@@ -588,7 +588,7 @@ signature_get_next_complete_type (const char **signature)

 			(*signature)++;

-			if ( (*signature)[0] == stack[stack_len - 1])

+			if (stack_len > 0 && (*signature)[0] == stack[stack_len - 1])

 				stack_len--;

 		} while (stack_len > 0);

diff --git a/tests/test-utils.c b/tests/test-utils.c

index 9c742060..7a21fa02 100644

--- a/tests/test-utils.c

+++ b/tests/test-utils.c

@@ -676,9 +676,11 @@ soup_test_request_read_all (SoupRequest   *req,

 	if (!SOUP_IS_SESSION_SYNC (soup_request_get_session (req)))

 		data.loop = g_main_loop_new (g_main_context_get_thread_default (), FALSE);

+	else

+		data.loop = NULL;

 	do {

-		if (SOUP_IS_SESSION_SYNC (soup_request_get_session (req))) {

+		if (!data.loop) {

 			nread = g_input_stream_read (stream, buf, sizeof (buf),

 						     cancellable, error);

 		} else {

@@ -691,7 +693,7 @@ soup_test_request_read_all (SoupRequest   *req,

 		}

 	} while (nread > 0);

-	if (!SOUP_IS_SESSION_SYNC (soup_request_get_session (req)))

+	if (data.loop)

 		g_main_loop_unref (data.loop);

 	return nread == 0;