Split SoupMessage into client and server partscarlosgc/split-io

Add SoupServerMessage and move there all the server only functionality.

27 files changed, 846 insertions, 556 deletions

diff --git a/tests/auth-test.c b/tests/auth-test.c
index 9f7720ab..1f3ba064 100644
--- a/tests/auth-test.c
+++ b/tests/auth-test.c
@@ -838,19 +838,24 @@ select_auth_test_one (SoupURI *uri,
 }
 
 static void
-server_callback (SoupServer *server, SoupMessage *msg,
-		 const char *path, GHashTable *query,
-		 SoupClientContext *context, gpointer data)
+server_callback (SoupServer        *server,
+		 SoupServerMessage *msg,
+		 const char        *path,
+		 GHashTable        *query,
+		 gpointer           data)
 {
-	soup_message_set_response (msg, "text/plain",
-				   SOUP_MEMORY_STATIC,
-				   "OK\r\n", 4);
-	soup_message_set_status (msg, SOUP_STATUS_OK);
+	soup_server_message_set_response (msg, "text/plain",
+					  SOUP_MEMORY_STATIC,
+					  "OK\r\n", 4);
+	soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
 }
 
 static gboolean
-server_basic_auth_callback (SoupAuthDomain *auth_domain, SoupMessage *msg,
-			    const char *username, const char *password, gpointer data)
+server_basic_auth_callback (SoupAuthDomain    *auth_domain,
+			    SoupServerMessage *msg,
+			    const char        *username,
+			    const char        *password,
+			    gpointer           data)
 {
 	if (strcmp (username, "user") != 0)
 		return FALSE;
@@ -858,8 +863,10 @@ server_basic_auth_callback (SoupAuthDomain *auth_domain, SoupMessage *msg,
 }
 
 static char *
-server_digest_auth_callback (SoupAuthDomain *auth_domain, SoupMessage *msg,
-			     const char *username, gpointer data)
+server_digest_auth_callback (SoupAuthDomain    *auth_domain,
+			     SoupServerMessage *msg,
+			     const char        *username,
+			     gpointer           data)
 {
 	if (strcmp (username, "user") != 0)
 		return NULL;
@@ -974,19 +981,21 @@ do_select_auth_test (void)
 }
 
 static void
-sneakily_close_connection (SoupMessage *msg, gpointer user_data)
+sneakily_close_connection (SoupServerMessage *msg,
+			   gpointer           user_data)
 {
 	/* Sneakily close the connection after the response, by
 	 * tricking soup-message-io into thinking that had been
 	 * the plan all along.
 	 */
-	soup_message_headers_append (msg->response_headers,
+	soup_message_headers_append (soup_server_message_get_response_headers (msg),
 				     "Connection", "close");
 }
 
 static void
-auth_close_request_started (SoupServer *server, SoupMessage *msg,
-			    SoupClientContext *client, gpointer user_data)
+auth_close_request_started (SoupServer        *server,
+			    SoupServerMessage *msg,
+			    gpointer           user_data)
 {
 	g_signal_connect (msg, "wrote-headers",
 			  G_CALLBACK (sneakily_close_connection), NULL);
@@ -1112,13 +1121,20 @@ do_infinite_auth_test (void)
 }
 
 static void
-disappear_request_read (SoupServer *server, SoupMessage *msg,
-			SoupClientContext *context, gpointer user_data)
+disappear_request_read (SoupServer        *server,
+			SoupServerMessage *msg,
+			gpointer           user_data)
 {
+	SoupMessageHeaders *request_headers;
+	SoupMessageHeaders *response_headers;
+
+	request_headers = soup_server_message_get_request_headers (msg);
+	response_headers = soup_server_message_get_response_headers (msg);
+
 	/* Remove the WWW-Authenticate header if this was a failed attempt */
-	if (soup_message_headers_get_one (msg->request_headers, "Authorization") &&
-	    msg->status_code == SOUP_STATUS_UNAUTHORIZED)
-		soup_message_headers_remove (msg->response_headers, "WWW-Authenticate");
+	if (soup_message_headers_get_one (request_headers, "Authorization") &&
+	    soup_server_message_get_status (msg, NULL) == SOUP_STATUS_UNAUTHORIZED)
+		soup_message_headers_remove (response_headers, "WWW-Authenticate");
 }
 
 static void
diff --git a/tests/cache-test.c b/tests/cache-test.c
index 34e26be8..a048db57 100644
--- a/tests/cache-test.c
+++ b/tests/cache-test.c
@@ -6,53 +6,62 @@
 #include "test-utils.h"
 
 static void
-server_callback (SoupServer *server, SoupMessage *msg,
-		 const char *path, GHashTable *query,
-		 SoupClientContext *context, gpointer data)
+server_callback (SoupServer        *server,
+		 SoupServerMessage *msg,
+		 const char        *path,
+		 GHashTable        *query,
+		 gpointer           data)
 {
 	const char *last_modified, *etag;
 	const char *header;
+	const char *method;
+	SoupMessageHeaders *request_headers;
+	SoupMessageHeaders *response_headers;
 	guint status = SOUP_STATUS_OK;
 
-	if (msg->method != SOUP_METHOD_GET && msg->method != SOUP_METHOD_POST) {
-		soup_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED);
+	method = soup_server_message_get_method (msg);
+
+	if (method != SOUP_METHOD_GET && method != SOUP_METHOD_POST) {
+		soup_server_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED, NULL);
 		return;
 	}
 
-	header = soup_message_headers_get_one (msg->request_headers,
+	request_headers = soup_server_message_get_request_headers (msg);
+	response_headers = soup_server_message_get_response_headers (msg);
+	header = soup_message_headers_get_one (request_headers,
 					       "Test-Set-Expires");
 	if (header) {
-		soup_message_headers_append (msg->response_headers,
+		soup_message_headers_append (response_headers,
 					     "Expires",
 					     header);
 	}
 
-	header = soup_message_headers_get_one (msg->request_headers,
+	header = soup_message_headers_get_one (request_headers,
 					       "Test-Set-Cache-Control");
 	if (header) {
-		soup_message_headers_append (msg->response_headers,
+		soup_message_headers_append (response_headers,
 					     "Cache-Control",
 					     header);
 	}
 
-	last_modified = soup_message_headers_get_one (msg->request_headers,
+	last_modified = soup_message_headers_get_one (request_headers,
 						      "Test-Set-Last-Modified");
 	if (last_modified) {
-		soup_message_headers_append (msg->response_headers,
+		soup_message_headers_append (response_headers,
 					     "Last-Modified",
 					     last_modified);
 	}
 
-	etag = soup_message_headers_get_one (msg->request_headers,
+	etag = soup_message_headers_get_one (request_headers,
 					     "Test-Set-ETag");
 	if (etag) {
-		soup_message_headers_append (msg->response_headers,
+		soup_message_headers_append (response_headers,
 					     "ETag",
 					     etag);
 	}
 
 
-	header = soup_message_headers_get_one (msg->request_headers,
+	header = soup_message_headers_get_one (request_headers,
 					       "If-Modified-Since");
 	if (header && last_modified) {
 		GDateTime *modified_date, *header_date;
@@ -67,17 +76,17 @@ server_callback (SoupServer *server, SoupMessage *msg,
                 g_date_time_unref (header_date);
 	}
 
-	header = soup_message_headers_get_one (msg->request_headers,
+	header = soup_message_headers_get_one (request_headers,
 					       "If-None-Match");
 	if (header && etag) {
 		if (!strcmp (header, etag))
 			status = SOUP_STATUS_NOT_MODIFIED;
 	}
 
-	header = soup_message_headers_get_one (msg->request_headers,
+	header = soup_message_headers_get_one (request_headers,
 					       "Test-Set-My-Header");
 	if (header) {
-		soup_message_headers_append (msg->response_headers,
+		soup_message_headers_append (response_headers,
 					     "My-Header",
 					     header);
 	}
@@ -93,12 +102,12 @@ server_callback (SoupServer *server, SoupMessage *msg,
 		if (etag)
 			g_checksum_update (sum, (guchar *)etag, strlen (etag));
 		body = g_checksum_get_string (sum);
-		soup_message_set_response (msg, "text/plain",
-					   SOUP_MEMORY_COPY,
-					   body, strlen (body) + 1);
+		soup_server_message_set_response (msg, "text/plain",
+						  SOUP_MEMORY_COPY,
+						  body, strlen (body) + 1);
 		g_checksum_free (sum);
 	}
-	soup_message_set_status (msg, status);
+	soup_server_message_set_status (msg, status, NULL);
 }
 
 static gboolean
diff --git a/tests/coding-test.c b/tests/coding-test.c
index 696f46f5..75233351 100644
--- a/tests/coding-test.c
+++ b/tests/coding-test.c
@@ -10,26 +10,34 @@ SoupServer *server;
 SoupURI *base_uri;
 
 static void
-server_callback (SoupServer *server, SoupMessage *msg,
-		 const char *path, GHashTable *query,
-		 SoupClientContext *context, gpointer data)
+server_callback (SoupServer        *server,
+		 SoupServerMessage *msg,
+		 const char        *path,
+		 GHashTable        *query,
+		 gpointer           data)
 {
 	const char *accept_encoding, *options;
 	GSList *codings;
 	GBytes *response = NULL;
+	SoupMessageHeaders *request_headers;
+	SoupMessageHeaders *response_headers;
+	SoupMessageBody *response_body;
 
-	options = soup_message_headers_get_one (msg->request_headers,
+	request_headers = soup_server_message_get_request_headers (msg);
+	options = soup_message_headers_get_one (request_headers,
 						"X-Test-Options");
 	if (!options)
 		options = "";
 
-	accept_encoding = soup_message_headers_get_list (msg->request_headers,
+	accept_encoding = soup_message_headers_get_list (request_headers,
 							 "Accept-Encoding");
 	if (accept_encoding && !soup_header_contains (options, "force-encode"))
 		codings = soup_header_parse_quality_list (accept_encoding, NULL);
 	else
 		codings = NULL;
 
+	response_headers = soup_server_message_get_response_headers (msg);
+
 	if (codings) {
 		gboolean claim_deflate, claim_gzip;
 		const char *extension = NULL, *encoding = NULL;
@@ -58,7 +66,7 @@ server_callback (SoupServer *server, SoupMessage *msg,
 			response = soup_test_load_resource (resource, NULL);
 
 			if (response) {
-				soup_message_headers_append (msg->response_headers,
+				soup_message_headers_append (response_headers,
 							     "Content-Encoding",
 							     encoding);
 			}
@@ -75,7 +83,7 @@ server_callback (SoupServer *server, SoupMessage *msg,
 		 * the error with "Content-Encoding: gzip" but there's
 		 * no body, so, eh.
 		 */
-		soup_message_set_status (msg, SOUP_STATUS_NOT_FOUND);
+		soup_server_message_set_status (msg, SOUP_STATUS_NOT_FOUND, NULL);
 		return;
 	}
 
@@ -86,34 +94,35 @@ server_callback (SoupServer *server, SoupMessage *msg,
 		    soup_header_contains (options, "prefer-deflate-raw"))
 			encoding = "deflate";
 
-		soup_message_headers_replace (msg->response_headers,
+		soup_message_headers_replace (response_headers,
 					      "Content-Encoding",
 					      encoding);
 	}
 
 	/* Content-Type matches the "real" format, not the sent format */
 	if (g_str_has_suffix (path, ".gz")) {
-		soup_message_headers_append (msg->response_headers,
+		soup_message_headers_append (response_headers,
 					     "Content-Type",
 					     "application/gzip");
 	} else {
-		soup_message_headers_append (msg->response_headers,
+		soup_message_headers_append (response_headers,
 					     "Content-Type",
 					     "text/plain");
 	}
 
-	soup_message_set_status (msg, SOUP_STATUS_OK);
-	soup_message_headers_set_encoding (msg->response_headers, SOUP_ENCODING_CHUNKED);
+	soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
+	soup_message_headers_set_encoding (response_headers, SOUP_ENCODING_CHUNKED);
 
+	response_body = soup_server_message_get_response_body (msg);
 	if (!soup_header_contains (options, "empty"))
-		soup_message_body_append_bytes (msg->response_body, response);
+		soup_message_body_append_bytes (response_body, response);
 	g_bytes_unref (response);
 
 	if (soup_header_contains (options, "trailing-junk")) {
-		soup_message_body_append (msg->response_body, SOUP_MEMORY_COPY,
+		soup_message_body_append (response_body, SOUP_MEMORY_COPY,
 					  options, strlen (options));
 	}
-	soup_message_body_complete (msg->response_body);
+	soup_message_body_complete (response_body);
 }
 
 typedef struct {
diff --git a/tests/connection-test.c b/tests/connection-test.c
index d267c3ec..f694bf94 100644
--- a/tests/connection-test.c
+++ b/tests/connection-test.c
@@ -7,7 +7,7 @@
 
 #include "soup-connection.h"
 #include "soup-socket-private.h"
-#include "soup-server-private.h"
+#include "soup-server-message-private.h"
 
 #include <gio/gnetworking.h>
 
@@ -16,15 +16,17 @@ SoupURI *base_uri;
 GMutex server_mutex;
 
 static void
-forget_close (SoupMessage *msg, gpointer user_data)
+forget_close (SoupServerMessage *msg,
+	      gpointer           user_data)
 {
-	soup_message_headers_remove (msg->response_headers, "Connection");
+	soup_message_headers_remove (soup_server_message_get_response_headers (msg),
+				     "Connection");
 }
 
 static void
-close_socket (SoupMessage *msg, gpointer user_data)
+close_socket (SoupServerMessage *msg,
+	      SoupSocket        *sock)
 {
-	SoupSocket *sock = user_data;
         GSocket *gsocket;
 	int sockfd;
 
@@ -42,7 +44,8 @@ close_socket (SoupMessage *msg, gpointer user_data)
 	/* Then add the missing data to the message now, so SoupServer
 	 * can clean up after itself properly.
 	 */
-	soup_message_body_append (msg->response_body, SOUP_MEMORY_STATIC,
+	soup_message_body_append (soup_server_message_get_response_body (msg),
+				  SOUP_MEMORY_STATIC,
 				  "foo", 3);
 }
 
@@ -53,8 +56,9 @@ timeout_socket (SoupSocket *sock, gpointer user_data)
 }
 
 static void
-timeout_request_started (SoupServer *server, SoupMessage *msg,
-			 SoupClientContext *client, gpointer user_data)
+timeout_request_started (SoupServer        *server,
+			 SoupServerMessage *msg,
+			 gpointer           user_data)
 {
 	SoupSocket *sock;
 	GMainContext *context = g_main_context_get_thread_default ();
@@ -62,7 +66,7 @@ timeout_request_started (SoupServer *server, SoupMessage *msg,
 
 	g_signal_handlers_disconnect_by_func (server, timeout_request_started, NULL);
 
-	sock = soup_client_context_get_soup_socket (client);
+	sock = soup_server_message_get_soup_socket (msg);
 	readable = g_signal_connect (sock, "readable",
 				    G_CALLBACK (timeout_socket), NULL);
 
@@ -104,10 +108,14 @@ setup_timeout_persistent (SoupServer *server, SoupSocket *sock)
 }
 
 static void
-server_callback (SoupServer *server, SoupMessage *msg,
-		 const char *path, GHashTable *query,
-		 SoupClientContext *context, gpointer data)
+server_callback (SoupServer        *server,
+		 SoupServerMessage *msg,
+		 const char        *path,
+		 GHashTable        *query,
+		 gpointer           data)
 {
+	const char *method;
+
 	/* The way this gets used in the tests, we don't actually
 	 * need to hold it through the whole function, so it's simpler
 	 * to just release it right away.
@@ -115,21 +123,25 @@ server_callback (SoupServer *server, SoupMessage *msg,
 	g_mutex_lock (&server_mutex);
 	g_mutex_unlock (&server_mutex);
 
-	if (msg->method != SOUP_METHOD_GET && msg->method != SOUP_METHOD_POST) {
-		soup_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED);
+	method = soup_server_message_get_method (msg);
+	if (method != SOUP_METHOD_GET && method != SOUP_METHOD_POST) {
+		soup_server_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED, NULL);
 		return;
 	}
 
 	if (g_str_has_prefix (path, "/content-length/")) {
 		gboolean too_long = strcmp (path, "/content-length/long") == 0;
 		gboolean no_close = strcmp (path, "/content-length/noclose") == 0;
+		SoupMessageHeaders *response_headers;
+
+		soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
+		soup_server_message_set_response (msg, "text/plain",
+						  SOUP_MEMORY_STATIC, "foobar", 6);
 
-		soup_message_set_status (msg, SOUP_STATUS_OK);
-		soup_message_set_response (msg, "text/plain",
-					   SOUP_MEMORY_STATIC, "foobar", 6);
+		response_headers = soup_server_message_get_response_headers (msg);
 		if (too_long)
-			soup_message_headers_set_content_length (msg->response_headers, 9);
-		soup_message_headers_append (msg->response_headers,
+			soup_message_headers_set_content_length (response_headers, 9);
+		soup_message_headers_append (response_headers,
 					     "Connection", "close");
 
 		if (too_long) {
@@ -140,7 +152,7 @@ server_callback (SoupServer *server, SoupMessage *msg,
 			 * the declared Content-Length. Instead, we
 			 * forcibly close the socket at that point.
 			 */
-			sock = soup_client_context_get_soup_socket (context);
+			sock = soup_server_message_get_soup_socket (msg);
 			g_signal_connect (msg, "wrote-chunk",
 					  G_CALLBACK (close_socket), sock);
 		} else if (no_close) {
@@ -158,13 +170,13 @@ server_callback (SoupServer *server, SoupMessage *msg,
 	if (!strcmp (path, "/timeout-persistent")) {
 		SoupSocket *sock;
 
-		sock = soup_client_context_get_soup_socket (context);
+		sock = soup_server_message_get_soup_socket (msg);
 		setup_timeout_persistent (server, sock);
 	}
 
-	soup_message_set_status (msg, SOUP_STATUS_OK);
-	soup_message_set_response (msg, "text/plain",
-				   SOUP_MEMORY_STATIC, "index", 5);
+	soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
+	soup_server_message_set_response (msg, "text/plain",
+					  SOUP_MEMORY_STATIC, "index", 5);
 	return;
 }
 
diff --git a/tests/context-test.c b/tests/context-test.c
index a47a3142..e8c55dc8 100644
--- a/tests/context-test.c
+++ b/tests/context-test.c
@@ -10,12 +10,13 @@ static char *base_uri;
 
 typedef struct {
 	SoupServer *server;
-	SoupMessage *msg;
+	SoupServerMessage *msg;
 	GSource *timeout;
 } SlowData;
 
 static void
-request_finished (SoupMessage *msg, gpointer data)
+request_finished (SoupServerMessage *msg,
+		  gpointer           data)
 {
 	SlowData *sd = data;
 
@@ -28,10 +29,12 @@ static gboolean
 add_body_chunk (gpointer data)
 {
 	SlowData *sd = data;
+	SoupMessageBody *response_body;
 
-	soup_message_body_append (sd->msg->response_body,
+	response_body = soup_server_message_get_response_body (sd->msg);
+	soup_message_body_append (response_body,
 				  SOUP_MEMORY_STATIC, "OK\r\n", 4);
-	soup_message_body_complete (sd->msg->response_body);
+	soup_message_body_complete (response_body);
 	soup_server_unpause_message (sd->server, sd->msg);
 	g_object_unref (sd->msg);
 
@@ -39,25 +42,29 @@ add_body_chunk (gpointer data)
 }
 
 static void
-server_callback (SoupServer *server, SoupMessage *msg,
-		 const char *path, GHashTable *query,
-		 SoupClientContext *context, gpointer data)
+server_callback (SoupServer        *server,
+		 SoupServerMessage *msg,
+		 const char        *path,
+		 GHashTable        *query,
+		 gpointer           data)
 {
 	SlowData *sd;
+	SoupMessageHeaders *response_headers;
 
-	if (msg->method != SOUP_METHOD_GET) {
-		soup_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED);
+	if (soup_server_message_get_method (msg) != SOUP_METHOD_GET) {
+		soup_server_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED, NULL);
 		return;
 	}
 
-	soup_message_set_status (msg, SOUP_STATUS_OK);
+	soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
 	if (!strcmp (path, "/fast")) {
-		soup_message_set_response (msg, "text/plain",
-					   SOUP_MEMORY_STATIC, "OK\r\n", 4);
+		soup_server_message_set_response (msg, "text/plain",
+						  SOUP_MEMORY_STATIC, "OK\r\n", 4);
 		return;
 	}
 
-	soup_message_headers_set_encoding (msg->response_headers,
+	response_headers = soup_server_message_get_response_headers (msg);
+	soup_message_headers_set_encoding (response_headers,
 					   SOUP_ENCODING_CHUNKED);
 	g_object_ref (msg);
 	soup_server_pause_message (server, msg);
diff --git a/tests/continue-test.c b/tests/continue-test.c
index 85d1a4e6..2b63b1b7 100644
--- a/tests/continue-test.c
+++ b/tests/continue-test.c
@@ -14,37 +14,65 @@ static SoupURI *base_uri;
 static GSList *events;
 
 static void
-event (SoupMessage *msg, const char *side, const char *message)
+client_event (SoupMessage *msg,
+	      const char  *message)
 {
-	char *data = g_strdup_printf ("%s-%s", side, message);
+	char *data = g_strdup_printf ("client-%s", message);
+
+	debug_printf (2, "  %s", data);
+	debug_printf (2, "\n");
+
+	events = g_slist_append (events, data);
+}
+
+static void
+server_event (SoupServerMessage *msg,
+	      const char        *message)
+{
+	char *data = g_strdup_printf ("server-%s", message);
 	gboolean record_status =
 		(!strcmp (data, "server-wrote_headers") ||
 		 !strcmp (data, "server-wrote_informational"));
+	const char *reason_phrase;
+	guint status_code = soup_server_message_get_status (msg, &reason_phrase);
 
 	debug_printf (2, "  %s", data);
 	if (record_status)
-		debug_printf (2, " (%s)", msg->reason_phrase);
+		debug_printf (2, " (%s)", reason_phrase);
 	debug_printf (2, "\n");
 
 	events = g_slist_append (events, data);
 	if (record_status)
-		events = g_slist_append (events, GUINT_TO_POINTER (msg->status_code));
+		events = g_slist_append (events, GUINT_TO_POINTER (status_code));
 }
 
-#define EVENT_HANDLER(name)			\
+#define CLIENT_EVENT_HANDLER(name)		\
 static void					\
-name (SoupMessage *msg, gpointer side)		\
+client_##name (SoupMessage *msg, gpointer side)	\
 {						\
-	event (msg, side, #name);		\
+	client_event (msg, #name);		\
 }
 
-EVENT_HANDLER (got_informational)
-EVENT_HANDLER (got_headers)
-EVENT_HANDLER (got_body)
-EVENT_HANDLER (wrote_informational)
-EVENT_HANDLER (wrote_headers)
-EVENT_HANDLER (wrote_body)
-EVENT_HANDLER (finished)
+#define SERVER_EVENT_HANDLER(name)		\
+static void					\
+server_##name (SoupServerMessage *msg, gpointer side)	\
+{						\
+	server_event (msg, #name);		\
+}
+
+CLIENT_EVENT_HANDLER (got_informational)
+CLIENT_EVENT_HANDLER (got_headers)
+CLIENT_EVENT_HANDLER (got_body)
+CLIENT_EVENT_HANDLER (wrote_headers)
+CLIENT_EVENT_HANDLER (wrote_body)
+CLIENT_EVENT_HANDLER (finished)
+
+SERVER_EVENT_HANDLER (got_headers)
+SERVER_EVENT_HANDLER (got_body)
+SERVER_EVENT_HANDLER (wrote_informational)
+SERVER_EVENT_HANDLER (wrote_headers)
+SERVER_EVENT_HANDLER (wrote_body)
+SERVER_EVENT_HANDLER (finished)
 
 static void
 restarted (SoupMessage *msg,
@@ -76,7 +104,6 @@ do_message (const char *path, gboolean long_body,
 	}
 	soup_uri_set_path (uri, path);
 	msg = soup_message_new_from_uri ("POST", uri);
-	g_print ("DBG: soup_message_new_from_uri: %p\n", msg);
 	soup_uri_free (uri);
 
 	body = long_body ? LONG_BODY : SHORT_BODY;
@@ -88,20 +115,18 @@ do_message (const char *path, gboolean long_body,
 						       SOUP_EXPECTATION_CONTINUE);
 	}
 
-	g_signal_connect (msg, "got_informational",
-			  G_CALLBACK (got_informational), "client");
-	g_signal_connect (msg, "got_headers",
-			  G_CALLBACK (got_headers), "client");
-	g_signal_connect (msg, "got_body",
-			  G_CALLBACK (got_body), "client");
-	g_signal_connect (msg, "wrote_informational",
-			  G_CALLBACK (wrote_informational), "client");
-	g_signal_connect (msg, "wrote_headers",
-			  G_CALLBACK (wrote_headers), "client");
-	g_signal_connect (msg, "wrote_body",
-			  G_CALLBACK (wrote_body), "client");
+	g_signal_connect (msg, "got-informational",
+			  G_CALLBACK (client_got_informational), NULL);
+	g_signal_connect (msg, "got-headers",
+			  G_CALLBACK (client_got_headers), NULL);
+	g_signal_connect (msg, "got-body",
+			  G_CALLBACK (client_got_body), NULL);
+	g_signal_connect (msg, "wrote-headers",
+			  G_CALLBACK (client_wrote_headers), NULL);
+	g_signal_connect (msg, "wrote-body",
+			  G_CALLBACK (client_wrote_body), NULL);
 	g_signal_connect (msg, "finished",
-			  G_CALLBACK (finished), "client");
+			  G_CALLBACK (client_finished), NULL);
 	g_signal_connect (msg, "restarted",
 			  G_CALLBACK (restarted), request_body);
 
@@ -401,47 +426,54 @@ do_test_auth_long_expect_pass (void)
 /* SERVER */
 
 static void
-server_got_headers (SoupMessage *msg, gpointer server)
+_server_got_headers (SoupServerMessage *msg,
+		     gpointer           server)
 {
+	guint status_code;
+	SoupMessageHeaders *request_headers;
+
+	status_code = soup_server_message_get_status (msg, NULL);
 	/* FIXME */
-	if (msg->status_code != SOUP_STATUS_CONTINUE &&
-	    msg->status_code != 0)
+	if (status_code != SOUP_STATUS_CONTINUE && status_code != 0)
 		return;
 
-	if (soup_message_headers_get_expectations (msg->request_headers) &
+	request_headers = soup_server_message_get_request_headers (msg);
+	if (soup_message_headers_get_expectations (request_headers) &
 	    SOUP_EXPECTATION_CONTINUE) {
 		const char *length;
 
-		length = soup_message_headers_get_one (msg->request_headers,
+		length = soup_message_headers_get_one (request_headers,
 						       "Content-Length");
 		if (length && atoi (length) > MAX_POST_LENGTH) {
-			soup_message_set_status (msg, SOUP_STATUS_REQUEST_ENTITY_TOO_LARGE);
-			soup_message_headers_append (msg->response_headers, "Connection", "close");
+			SoupMessageHeaders *response_headers;
+
+			response_headers = soup_server_message_get_response_headers (msg);
+			soup_server_message_set_status (msg, SOUP_STATUS_REQUEST_ENTITY_TOO_LARGE, NULL);
+			soup_message_headers_append (response_headers, "Connection", "close");
 		}
 	}
-}	
+}
 
 static void
-request_started (SoupServer *server, SoupMessage *msg,
-		 SoupClientContext *client, gpointer user_data)
+request_started (SoupServer        *server,
+		 SoupServerMessage *msg,
+		 gpointer           user_data)
 {
-	g_signal_connect (msg, "got_headers",
-			  G_CALLBACK (server_got_headers), server);
-
-	g_signal_connect (msg, "got_informational",
-			  G_CALLBACK (got_informational), "server");
-	g_signal_connect (msg, "got_headers",
-			  G_CALLBACK (got_headers), "server");
-	g_signal_connect (msg, "got_body",
-			  G_CALLBACK (got_body), "server");
-	g_signal_connect (msg, "wrote_informational",
-			  G_CALLBACK (wrote_informational), "server");
-	g_signal_connect (msg, "wrote_headers",
-			  G_CALLBACK (wrote_headers), "server");
-	g_signal_connect (msg, "wrote_body",
-			  G_CALLBACK (wrote_body), "server");
+	g_signal_connect (msg, "got-headers",
+			  G_CALLBACK (_server_got_headers), server);
+
+	g_signal_connect (msg, "got-headers",
+			  G_CALLBACK (server_got_headers), NULL);
+	g_signal_connect (msg, "got-body",
+			  G_CALLBACK (server_got_body), NULL);
+	g_signal_connect (msg, "wrote-informational",
+			  G_CALLBACK (server_wrote_informational), NULL);
+	g_signal_connect (msg, "wrote-headers",
+			  G_CALLBACK (server_wrote_headers), NULL);
+	g_signal_connect (msg, "wrote-body",
+			  G_CALLBACK (server_wrote_body), NULL);
 	g_signal_connect (msg, "finished",
-			  G_CALLBACK (finished), "server");
+			  G_CALLBACK (server_finished), NULL);
 }
 
 static gboolean
@@ -452,18 +484,25 @@ auth_callback (SoupAuthDomain *auth_domain, SoupMessage *msg,
 }
 
 static void
-server_callback (SoupServer *server, SoupMessage *msg,
-		 const char *path, GHashTable *query,
-		 SoupClientContext *context, gpointer data)
+server_callback (SoupServer        *server,
+		 SoupServerMessage *msg,
+		 const char        *path,
+		 GHashTable        *query,
+		 gpointer           data)
 {
-	if (msg->method != SOUP_METHOD_POST) {
-		soup_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED);
-		soup_message_headers_append (msg->response_headers, "Connection", "close");
-	} else if (msg->request_body->length > MAX_POST_LENGTH) {
-		soup_message_set_status (msg, SOUP_STATUS_REQUEST_ENTITY_TOO_LARGE);
-		soup_message_headers_append (msg->response_headers, "Connection", "close");
+	SoupMessageHeaders *response_headers;
+	SoupMessageBody *request_body;
+
+	response_headers = soup_server_message_get_response_headers (msg);
+	request_body = soup_server_message_get_request_body (msg);
+	if (soup_server_message_get_method (msg) != SOUP_METHOD_POST) {
+		soup_server_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED, NULL);
+		soup_message_headers_append (response_headers, "Connection", "close");
+	} else if (request_body->length > MAX_POST_LENGTH) {
+		soup_server_message_set_status (msg, SOUP_STATUS_REQUEST_ENTITY_TOO_LARGE, NULL);
+		soup_message_headers_append (response_headers, "Connection", "close");
 	} else
-		soup_message_set_status (msg, SOUP_STATUS_CREATED);
+		soup_server_message_set_status (msg, SOUP_STATUS_CREATED, NULL);
 }
 
 static SoupServer *
diff --git a/tests/cookies-test.c b/tests/cookies-test.c
index 63c9e711..163f4f42 100644
--- a/tests/cookies-test.c
+++ b/tests/cookies-test.c
@@ -11,27 +11,34 @@ const char *first_party = "http://127.0.0.1/";
 const char *third_party = "http://localhost/";
 
 static void
-server_callback (SoupServer *server, SoupMessage *msg,
-		 const char *path, GHashTable *query,
-		 SoupClientContext *context, gpointer data)
+server_callback (SoupServer        *server,
+		 SoupServerMessage *msg,
+		 const char        *path,
+		 GHashTable        *query,
+		 gpointer           data)
 {
+	SoupMessageHeaders *response_headers;
+	SoupMessageHeaders *request_headers;
+
+	response_headers = soup_server_message_get_response_headers (msg);
+	request_headers = soup_server_message_get_request_headers (msg);
 	if (g_str_equal (path, "/index.html")) {
-		soup_message_headers_replace (msg->response_headers,
+		soup_message_headers_replace (response_headers,
 					      "Set-Cookie",
 					      "foo=bar");
 	} else if (g_str_equal (path, "/foo.jpg")) {
-		soup_message_headers_replace (msg->response_headers,
+		soup_message_headers_replace (response_headers,
 					      "Set-Cookie",
 					      "baz=qux");
-	} else if (soup_message_headers_get_one (msg->request_headers,
+	} else if (soup_message_headers_get_one (request_headers,
 						 "Echo-Set-Cookie")) {
-		soup_message_headers_replace (msg->response_headers,
+		soup_message_headers_replace (response_headers,
 					      "Set-Cookie",
-					      soup_message_headers_get_one (msg->request_headers,
+					      soup_message_headers_get_one (request_headers,
 									    "Echo-Set-Cookie"));
 	}
 
-	soup_message_set_status (msg, SOUP_STATUS_OK);
+	soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
 }
 
 typedef struct {
diff --git a/tests/forms-test.c b/tests/forms-test.c
index 1a07fa00..9d069a4c 100644
--- a/tests/forms-test.c
+++ b/tests/forms-test.c
@@ -250,16 +250,20 @@ do_form_decode_test (void)
 }
 
 static void
-hello_callback (SoupServer *server, SoupMessage *msg,
-		const char *path, GHashTable *query,
-		SoupClientContext *context, gpointer data)
+hello_callback (SoupServer        *server,
+		SoupServerMessage *msg,
+		const char        *path,
+		GHashTable        *query,
+		gpointer           data)
 {
 	char *title, *name, *fmt;
 	const char *content_type;
 	GString *buf;
+	const char *method;
 
-	if (msg->method != SOUP_METHOD_GET && msg->method != SOUP_METHOD_HEAD) {
-		soup_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED);
+	method = soup_server_message_get_method (msg);
+	if (method != SOUP_METHOD_GET && method != SOUP_METHOD_HEAD) {
+		soup_server_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED, NULL);
 		return;
 	}
 
@@ -296,17 +300,19 @@ hello_callback (SoupServer *server, SoupMessage *msg,
 		}
 	}
 
-	soup_message_set_response (msg, content_type,
-				   SOUP_MEMORY_TAKE,
-				   buf->str, buf->len);
+	soup_server_message_set_response (msg, content_type,
+					  SOUP_MEMORY_TAKE,
+					  buf->str, buf->len);
 	g_string_free (buf, FALSE);
-	soup_message_set_status (msg, SOUP_STATUS_OK);
+	soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
 }
 
 static void
-md5_get_callback (SoupServer *server, SoupMessage *msg,
-		  const char *path, GHashTable *query,
-		  SoupClientContext *context, gpointer data)
+md5_get_callback (SoupServer        *server,
+		  SoupServerMessage *msg,
+		  const char        *path,
+		  GHashTable        *query,
+		  gpointer           data)
 {
 	const char *file = NULL, *md5sum = NULL, *fmt;
 	const char *content_type;
@@ -340,17 +346,19 @@ md5_get_callback (SoupServer *server, SoupMessage *msg,
 			g_string_append_printf (buf, "%s", md5sum);
 	}
 
-	soup_message_set_response (msg, content_type,
-				   SOUP_MEMORY_TAKE,
-				   buf->str, buf->len);
+	soup_server_message_set_response (msg, content_type,
+					  SOUP_MEMORY_TAKE,
+					  buf->str, buf->len);
 	g_string_free (buf, FALSE);
-	soup_message_set_status (msg, SOUP_STATUS_OK);
+	soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
 }
 
 static void
-md5_post_callback (SoupServer *server, SoupMessage *msg,
-		   const char *path, GHashTable *query,
-		   SoupClientContext *context, gpointer data)
+md5_post_callback (SoupServer        *server,
+		   SoupServerMessage *msg,
+		   const char        *path,
+		   GHashTable        *query,
+		   gpointer           data)
 {
 	const char *content_type;
 	GHashTable *params;
@@ -358,17 +366,23 @@ md5_post_callback (SoupServer *server, SoupMessage *msg,
 	char *filename, *md5sum, *redirect_uri;
 	GBytes *file;
 	SoupURI *uri;
+	SoupMultipart *multipart;
+	GBytes *body;
+	SoupMessageHeaders *request_headers;
 
-	content_type = soup_message_headers_get_content_type (msg->request_headers, NULL);
+	request_headers = soup_server_message_get_request_headers (msg);
+	content_type = soup_message_headers_get_content_type (request_headers, NULL);
 	if (!content_type || strcmp (content_type, "multipart/form-data") != 0) {
-		soup_message_set_status (msg, SOUP_STATUS_BAD_REQUEST);
+		soup_server_message_set_status (msg, SOUP_STATUS_BAD_REQUEST, NULL);
 		return;
 	}
 
-	params = soup_form_decode_multipart (msg, "file",
-					     &filename, NULL, &file);
+	body = soup_message_body_flatten (soup_server_message_get_request_body (msg));
+	multipart = soup_multipart_new_from_message (request_headers, body);
+	g_bytes_unref (body);
+	params = multipart ? soup_form_decode_multipart (multipart, "file", &filename, NULL, &file) : NULL;
 	if (!params) {
-		soup_message_set_status (msg, SOUP_STATUS_BAD_REQUEST);
+		soup_server_message_set_status (msg, SOUP_STATUS_BAD_REQUEST, NULL);
 		return;
 	}
 	fmt = g_hash_table_lookup (params, "fmt");
@@ -376,7 +390,7 @@ md5_post_callback (SoupServer *server, SoupMessage *msg,
 	md5sum = g_compute_checksum_for_bytes (G_CHECKSUM_MD5, file);
 	g_bytes_unref (file);
 
-	uri = soup_uri_copy (soup_message_get_uri (msg));
+	uri = soup_uri_copy (soup_server_message_get_uri (msg));
 	soup_uri_set_query_from_fields (uri,
 					"file", filename ? filename : "",
 					"md5sum", md5sum,
@@ -384,7 +398,7 @@ md5_post_callback (SoupServer *server, SoupMessage *msg,
 					NULL);
 	redirect_uri = soup_uri_to_string (uri, FALSE);
 
-	soup_message_set_redirect (msg, SOUP_STATUS_SEE_OTHER, redirect_uri);
+	soup_server_message_set_redirect (msg, SOUP_STATUS_SEE_OTHER, redirect_uri);
 
 	g_free (redirect_uri);
 	soup_uri_free (uri);
@@ -394,16 +408,22 @@ md5_post_callback (SoupServer *server, SoupMessage *msg,
 }
 
 static void
-md5_callback (SoupServer *server, SoupMessage *msg,
-	      const char *path, GHashTable *query,
-	      SoupClientContext *context, gpointer data)
+md5_callback (SoupServer        *server,
+	      SoupServerMessage *msg,
+	      const char        *path,
+	      GHashTable        *query,
+	      gpointer           data)
 {
-	if (msg->method == SOUP_METHOD_GET || msg->method == SOUP_METHOD_HEAD)
-		md5_get_callback (server, msg, path, query, context, data);
-	else if (msg->method == SOUP_METHOD_POST)
-		md5_post_callback (server, msg, path, query, context, data);
+	const char *method;
+
+	method = soup_server_message_get_method (msg);
+
+	if (method == SOUP_METHOD_GET || method == SOUP_METHOD_HEAD)
+		md5_get_callback (server, msg, path, query, data);
+	else if (method == SOUP_METHOD_POST)
+		md5_post_callback (server, msg, path, query, data);
 	else
-		soup_message_set_status (msg, SOUP_STATUS_METHOD_NOT_ALLOWED);
+		soup_server_message_set_status (msg, SOUP_STATUS_METHOD_NOT_ALLOWED, NULL);
 }
 
 static gboolean run_tests = TRUE;
diff --git a/tests/hsts-db-test.c b/tests/hsts-db-test.c
index f45e355d..2adc05b7 100644
--- a/tests/hsts-db-test.c
+++ b/tests/hsts-db-test.c
@@ -13,42 +13,47 @@ SoupURI *https_uri;
    test the Soup HSTS feature.
  */
 static void
-server_callback  (SoupServer *server, SoupMessage *msg,
-		  const char *path, GHashTable *query,
-		  SoupClientContext *context, gpointer data)
+server_callback  (SoupServer        *server,
+                  SoupServerMessage *msg,
+		  const char        *path,
+                  GHashTable        *query,
+		  gpointer           data)
 {
+        SoupMessageHeaders *response_headers;
 	const char *server_protocol = data;
 
+        response_headers = soup_server_message_get_response_headers (msg);
+
 	if (strcmp (server_protocol, "http") == 0) {
 		char *uri_string;
 		SoupURI *uri = soup_uri_new ("https://localhost");
 		soup_uri_set_path (uri, path);
 		uri_string = soup_uri_to_string (uri, FALSE);
 		fprintf (stderr, "server is redirecting to HTTPS\n");
-		soup_message_set_redirect (msg, SOUP_STATUS_MOVED_PERMANENTLY, uri_string);
+		soup_server_message_set_redirect (msg, SOUP_STATUS_MOVED_PERMANENTLY, uri_string);
 		soup_uri_free (uri);
 		g_free (uri_string);
 	} else if (strcmp (server_protocol, "https") == 0) {
-		soup_message_set_status (msg, SOUP_STATUS_OK);
+		soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
 		if (strcmp (path, "/long-lasting") == 0) {
-			soup_message_headers_append (msg->response_headers,
+			soup_message_headers_append (response_headers,
 						     "Strict-Transport-Security",
 						     "max-age=31536000");
 		} else if (strcmp (path, "/two-seconds") == 0) {
-			soup_message_headers_append (msg->response_headers,
+			soup_message_headers_append (response_headers,
 						     "Strict-Transport-Security",
 						     "max-age=2");
 		} else if (strcmp (path, "/delete") == 0) {
-			soup_message_headers_append (msg->response_headers,
+			soup_message_headers_append (response_headers,
 						     "Strict-Transport-Security",
 						     "max-age=0");
 		} else if (strcmp (path, "/subdomains") == 0) {
-			soup_message_headers_append (msg->response_headers,
+			soup_message_headers_append (response_headers,
 						     "Strict-Transport-Security",
 						     "max-age=31536000; includeSubDomains");
 		}
                 else if (strcmp (path, "/very-long-lasting") == 0) {
-			soup_message_headers_append (msg->response_headers,
+			soup_message_headers_append (response_headers,
 						     "Strict-Transport-Security",
 						     "max-age=631138519");
 		}
diff --git a/tests/hsts-test.c b/tests/hsts-test.c
index e8c7d877..9bb36edf 100644
--- a/tests/hsts-test.c
+++ b/tests/hsts-test.c
@@ -13,88 +13,93 @@ SoupURI *https_uri;
    test the Soup HSTS feature.
  */
 static void
-server_callback  (SoupServer *server, SoupMessage *msg,
-		  const char *path, GHashTable *query,
-		  SoupClientContext *context, gpointer data)
+server_callback  (SoupServer        *server,
+		  SoupServerMessage *msg,
+		  const char        *path,
+		  GHashTable        *query,
+		  gpointer           data)
 {
+	SoupMessageHeaders *response_headers;
 	const char *server_protocol = data;
 
+	response_headers = soup_server_message_get_response_headers (msg);
+
 	if (strcmp (server_protocol, "http") == 0) {
 		if (strcmp (path, "/insecure") == 0) {
-			soup_message_headers_append (msg->response_headers,
+			soup_message_headers_append (response_headers,
 						     "Strict-Transport-Security",
 						     "max-age=31536000");
-			soup_message_set_status (msg, SOUP_STATUS_OK);
+			soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
 		} else {
 			char *uri_string;
 			SoupURI *uri = soup_uri_new ("https://localhost");
 			soup_uri_set_path (uri, path);
 			uri_string = soup_uri_to_string (uri, FALSE);
-			soup_message_set_redirect (msg, SOUP_STATUS_MOVED_PERMANENTLY, uri_string);
+			soup_server_message_set_redirect (msg, SOUP_STATUS_MOVED_PERMANENTLY, uri_string);
 			soup_uri_free (uri);
 			g_free (uri_string);
 		}
 	} else if (strcmp (server_protocol, "https") == 0) {
-		soup_message_set_status (msg, SOUP_STATUS_OK);
+		soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
 		if (strcmp (path, "/long-lasting") == 0) {
-			soup_message_headers_append (msg->response_headers,
+			soup_message_headers_append (response_headers,
 						     "Strict-Transport-Security",
 						     "max-age=31536000");
 		} else if (strcmp (path, "/two-seconds") == 0) {
-			soup_message_headers_append (msg->response_headers,
+			soup_message_headers_append (response_headers,
 						     "Strict-Transport-Security",
 						     "max-age=2");
 		} else if (strcmp (path, "/three-seconds") == 0) {
-			soup_message_headers_append (msg->response_headers,
+			soup_message_headers_append (response_headers,
 						     "Strict-Transport-Security",
 						     "max-age=3");
 		} else if (strcmp (path, "/delete") == 0) {
-			soup_message_headers_append (msg->response_headers,
+			soup_message_headers_append (response_headers,
 						     "Strict-Transport-Security",
 						     "max-age=0");
 		} else if (strcmp (path, "/subdomains") == 0) {
-			soup_message_headers_append (msg->response_headers,
+			soup_message_headers_append (response_headers,
 						     "Strict-Transport-Security",
 						     "max-age=31536000; includeSubDomains");
 		} else if (strcmp (path, "/no-sts-header") == 0) {
 			/* Do not add anything */
 		} else if (strcmp (path, "/multiple-headers") == 0) {
-			soup_message_headers_append (msg->response_headers,
+			soup_message_headers_append (response_headers,
 						     "Strict-Transport-Security",
 						     "max-age=31536000; includeSubDomains");
-			soup_message_headers_append (msg->response_headers,
+			soup_message_headers_append (response_headers,
 						     "Strict-Transport-Security",
 						     "max-age=1; includeSubDomains");
 		} else if (strcmp (path, "/missing-values") == 0) {
-			soup_message_headers_append (msg->response_headers,
+			soup_message_headers_append (response_headers,
 						     "Strict-Transport-Security",
 						     "");
 		} else if (strcmp (path, "/invalid-values") == 0) {
-			soup_message_headers_append (msg->response_headers,
+			soup_message_headers_append (response_headers,
 						     "Strict-Transport-Security",
 						     "max-age=foo");
 		} else if (strcmp (path, "/extra-values-0") == 0) {
-			soup_message_headers_append (msg->response_headers,
+			soup_message_headers_append (response_headers,
 						     "Strict-Transport-Security",
 						     "max-age=3600; foo");
 		} else if (strcmp (path, "/extra-values-1") == 0) {
-			soup_message_headers_append (msg->response_headers,
+			soup_message_headers_append (response_headers,
 						     "Strict-Transport-Security",
 						     " max-age=3600; includeDomains; foo");
 		} else if (strcmp (path, "/duplicated-directives") == 0) {
-			soup_message_headers_append (msg->response_headers,
+			soup_message_headers_append (response_headers,
 						     "Strict-Transport-Security",
 						     "max-age=3600; includeDomains; includeDomains");
 		} else if (strcmp (path, "/case-insensitive-header") == 0) {
-			soup_message_headers_append (msg->response_headers,
+			soup_message_headers_append (response_headers,
 						     "STRICT-TRANSPORT-SECURITY",
 						     "max-age=3600");
 		} else if (strcmp (path, "/case-insensitive-directives") == 0) {
-			soup_message_headers_append (msg->response_headers,
+			soup_message_headers_append (response_headers,
 						     "Strict-Transport-Security",
 						     "MAX-AGE=3600; includesubdomains");
 		} else if (strcmp (path, "/optional-quotations") == 0) {
-			soup_message_headers_append (msg->response_headers,
+			soup_message_headers_append (response_headers,
 						     "Strict-Transport-Security",
 						     "max-age=\"31536000\"");
 		}
diff --git a/tests/misc-test.c b/tests/misc-test.c
index 759c2abf..beb586ba 100644
--- a/tests/misc-test.c
+++ b/tests/misc-test.c
@@ -27,29 +27,37 @@ timeout_finish_message (gpointer msg)
 }
 
 static void
-server_callback (SoupServer *server, SoupMessage *msg,
-		 const char *path, GHashTable *query,
-		 SoupClientContext *context, gpointer data)
-{
-	SoupURI *uri = soup_message_get_uri (msg);
+server_callback (SoupServer        *server,
+		 SoupServerMessage *msg,
+		 const char        *path,
+		 GHashTable        *query,
+		 gpointer           data)
+{
+	SoupMessageHeaders *request_headers;
+	SoupMessageHeaders *response_headers;
+	const char *method = soup_server_message_get_method (msg);
+	SoupURI *uri = soup_server_message_get_uri (msg);
 	const char *server_protocol = data;
 
-	if (msg->method != SOUP_METHOD_GET && msg->method != SOUP_METHOD_POST) {
-		soup_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED);
+	if (method != SOUP_METHOD_GET && method != SOUP_METHOD_POST) {
+		soup_server_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED, NULL);
 		return;
 	}
 
 	if (!strcmp (path, "/redirect")) {
-		soup_message_set_redirect (msg, SOUP_STATUS_FOUND, "/");
+		soup_server_message_set_redirect (msg, SOUP_STATUS_FOUND, "/");
 		return;
 	}
 
+	request_headers = soup_server_message_get_request_headers (msg);
+	response_headers = soup_server_message_get_response_headers (msg);
+
 	if (!strcmp (path, "/alias-redirect")) {
 		SoupURI *redirect_uri;
 		char *redirect_string;
 		const char *redirect_protocol;
 
-		redirect_protocol = soup_message_headers_get_one (msg->request_headers, "X-Redirect-Protocol");
+		redirect_protocol = soup_message_headers_get_one (request_headers, "X-Redirect-Protocol");
 
 		redirect_uri = soup_uri_copy (uri);
 		soup_uri_set_scheme (redirect_uri, "foo");
@@ -60,13 +68,13 @@ server_callback (SoupServer *server, SoupMessage *msg,
 		soup_uri_set_path (redirect_uri, "/alias-redirected");
 		redirect_string = soup_uri_to_string (redirect_uri, FALSE);
 
-		soup_message_set_redirect (msg, SOUP_STATUS_FOUND, redirect_string);
+		soup_server_message_set_redirect (msg, SOUP_STATUS_FOUND, redirect_string);
 		g_free (redirect_string);
 		soup_uri_free (redirect_uri);
 		return;
 	} else if (!strcmp (path, "/alias-redirected")) {
-		soup_message_set_status (msg, SOUP_STATUS_OK);
-		soup_message_headers_append (msg->response_headers,
+		soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
+		soup_message_headers_append (response_headers,
 					     "X-Redirected-Protocol",
 					     server_protocol);
 		return;
@@ -79,14 +87,14 @@ server_callback (SoupServer *server, SoupMessage *msg,
 				  1000, timeout_finish_message, msg);
 	}
 
-	soup_message_set_status (msg, SOUP_STATUS_OK);
+	soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
 	if (!strcmp (uri->host, "foo")) {
-		soup_message_set_response (msg, "text/plain",
-					   SOUP_MEMORY_STATIC, "foo-index", 9);
+		soup_server_message_set_response (msg, "text/plain",
+						  SOUP_MEMORY_STATIC, "foo-index", 9);
 		return;
 	} else {
-		soup_message_set_response (msg, "text/plain",
-					   SOUP_MEMORY_STATIC, "index", 5);
+		soup_server_message_set_response (msg, "text/plain",
+						  SOUP_MEMORY_STATIC, "index", 5);
 		return;
 	}
 }
diff --git a/tests/multipart-test.c b/tests/multipart-test.c
index c0c09dc8..d9a00ae1 100644
--- a/tests/multipart-test.c
+++ b/tests/multipart-test.c
@@ -58,26 +58,33 @@ const char *payload = \
         "\r\n--cut-here--";
 
 static void
-server_callback (SoupServer *server, SoupMessage *msg,
-		 const char *path, GHashTable *query,
-		 SoupClientContext *context, gpointer data)
+server_callback (SoupServer        *server,
+		 SoupServerMessage *msg,
+		 const char        *path,
+		 GHashTable        *query,
+		 gpointer           data)
 {
-	if (msg->method != SOUP_METHOD_GET) {
-		soup_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED);
+	SoupMessageHeaders *response_headers;
+	SoupMessageBody *response_body;
+
+	if (soup_server_message_get_method (msg) != SOUP_METHOD_GET) {
+		soup_server_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED, NULL);
 		return;
 	}
 
-	soup_message_set_status (msg, SOUP_STATUS_OK);
+	soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
 
-	soup_message_headers_append (msg->response_headers,
+	response_headers = soup_server_message_get_response_headers (msg);
+	soup_message_headers_append (response_headers,
 				     "Content-Type", "multipart/x-mixed-replace; boundary=cut-here");
 
-	soup_message_body_append (msg->response_body,
+	response_body = soup_server_message_get_response_body (msg);
+	soup_message_body_append (response_body,
 				  SOUP_MEMORY_STATIC,
 				  payload,
 				  strlen (payload));
 
-	soup_message_body_complete (msg->response_body);
+	soup_message_body_complete (response_body);
 }
 
 static void
diff --git a/tests/no-ssl-test.c b/tests/no-ssl-test.c
index b92dd2c2..02bec973 100644
--- a/tests/no-ssl-test.c
+++ b/tests/no-ssl-test.c
@@ -38,16 +38,15 @@ do_ssl_tests (gconstpointer data)
 
 static void
 server_handler (SoupServer        *server,
-		SoupMessage       *msg,
+		SoupServerMessage *msg,
 		const char        *path,
 		GHashTable        *query,
-		SoupClientContext *client,
 		gpointer           user_data)
 {
-	soup_message_set_status (msg, SOUP_STATUS_OK);
-	soup_message_set_response (msg, "text/plain",
-				   SOUP_MEMORY_STATIC,
-				   "ok\r\n", 4);
+	soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
+	soup_server_message_set_response (msg, "text/plain",
+					  SOUP_MEMORY_STATIC,
+					  "ok\r\n", 4);
 }
 
 int
diff --git a/tests/ntlm-test.c b/tests/ntlm-test.c
index 0a980f9b..c3d69c9b 100644
--- a/tests/ntlm-test.c
+++ b/tests/ntlm-test.c
@@ -55,19 +55,22 @@ clear_state (gpointer connections, GObject *ex_connection)
 }
 
 static void
-server_callback (SoupServer *server, SoupMessage *msg,
-		 const char *path, GHashTable *query,
-		 SoupClientContext *client, gpointer data)
+server_callback (SoupServer        *server,
+		 SoupServerMessage *msg,
+		 const char        *path,
+		 GHashTable        *query,
+		 gpointer           data)
 {
 	TestServer *ts = data;
 	GSocket *socket;
 	const char *auth;
+	SoupMessageHeaders *request_headers;
 	NTLMServerState state, required_user = 0;
 	gboolean auth_required, not_found = FALSE;
 	gboolean basic_allowed = TRUE, ntlm_allowed = TRUE;
 
-	if (msg->method != SOUP_METHOD_GET) {
-		soup_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED);
+	if (soup_server_message_get_method (msg) != SOUP_METHOD_GET) {
+		soup_server_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED, NULL);
 		return;
 	}
 
@@ -86,10 +89,10 @@ server_callback (SoupServer *server, SoupMessage *msg,
 	if (strstr (path, "/404"))
 		not_found = TRUE;
 
-	socket = soup_client_context_get_socket (client);
+	socket = soup_server_message_get_socket (msg);
 	state = GPOINTER_TO_INT (g_hash_table_lookup (ts->connections, socket));
-	auth = soup_message_headers_get_one (msg->request_headers,
-					     "Authorization");
+	request_headers = soup_server_message_get_request_headers (msg);
+	auth = soup_message_headers_get_one (request_headers, "Authorization");
 
 	if (auth) {
 		if (!strncmp (auth, "NTLM ", 5)) {
@@ -126,33 +129,36 @@ server_callback (SoupServer *server, SoupMessage *msg,
 		auth_required = FALSE;
 
 	if (auth_required) {
-		soup_message_set_status (msg, SOUP_STATUS_UNAUTHORIZED);
+		SoupMessageHeaders *response_headers;
 
+		soup_server_message_set_status (msg, SOUP_STATUS_UNAUTHORIZED, NULL);
+
+		response_headers = soup_server_message_get_response_headers (msg);
 		if (basic_allowed && state != NTLM_RECEIVED_REQUEST) {
-			soup_message_headers_append (msg->response_headers,
+			soup_message_headers_append (response_headers,
 						     "WWW-Authenticate",
 						     "Basic realm=\"ntlm-test\"");
 		}
 
 		if (ntlm_allowed && state == NTLM_RECEIVED_REQUEST) {
-			soup_message_headers_append (msg->response_headers,
+			soup_message_headers_append (response_headers,
 						     "WWW-Authenticate",
 						     ts->ntlmssp ? ("NTLM " NTLMSSP_CHALLENGE) : ts->ntlmv2 ? ("NTLM " NTLMV2_CHALLENGE) : ("NTLM " NTLMV1_CHALLENGE));
 			state = NTLM_SENT_CHALLENGE;
 		} else if (ntlm_allowed) {
-			soup_message_headers_append (msg->response_headers,
+			soup_message_headers_append (response_headers,
 						     "WWW-Authenticate", "NTLM");
-			soup_message_headers_append (msg->response_headers,
+			soup_message_headers_append (response_headers,
 						     "Connection", "close");
 		}
 	} else {
 		if (not_found)
-			soup_message_set_status (msg, SOUP_STATUS_NOT_FOUND);
+			soup_server_message_set_status (msg, SOUP_STATUS_NOT_FOUND, NULL);
 		else {
-			soup_message_set_response (msg, "text/plain",
-						   SOUP_MEMORY_STATIC,
-						   "OK\r\n", 4);
-			soup_message_set_status (msg, SOUP_STATUS_OK);
+			soup_server_message_set_response (msg, "text/plain",
+							  SOUP_MEMORY_STATIC,
+							  "OK\r\n", 4);
+			soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
 		}
 	}
 
diff --git a/tests/proxy-test.c b/tests/proxy-test.c
index a17671d4..03c79377 100644
--- a/tests/proxy-test.c
+++ b/tests/proxy-test.c
@@ -238,13 +238,15 @@ do_async_proxy_test (gconstpointer data)
 }
 
 static void
-server_callback (SoupServer *server, SoupMessage *msg,
-		 const char *path, GHashTable *query,
-		 SoupClientContext *context, gpointer data)
+server_callback (SoupServer        *server,
+		 SoupServerMessage *msg,
+		 const char        *path,
+		 GHashTable        *query,
+		 gpointer           data)
 {
-	SoupURI *uri = soup_message_get_uri (msg);
+	SoupURI *uri = soup_server_message_get_uri (msg);
 
-	soup_message_set_status (msg, uri->fragment ? SOUP_STATUS_BAD_REQUEST : SOUP_STATUS_OK);
+	soup_server_message_set_status (msg, uri->fragment ? SOUP_STATUS_BAD_REQUEST : SOUP_STATUS_OK, NULL);
 }
 
 static void
diff --git a/tests/pull-api-test.c b/tests/pull-api-test.c
index f73d8cee..36d44a5e 100644
--- a/tests/pull-api-test.c
+++ b/tests/pull-api-test.c
@@ -52,8 +52,6 @@ typedef struct {
 } FullyAsyncData;
 
 static void fully_async_got_headers (SoupMessage *msg, gpointer user_data);
-static void fully_async_got_chunk   (SoupMessage *msg, GBytes *chunk,
-				     gpointer user_data);
 static gboolean fully_async_request_chunk (gpointer user_data);
 
 static void
@@ -99,12 +97,6 @@ do_fully_async_test (SoupSession *session,
 	ad.read_so_far = 0;
 	ad.expected_status = expected_status;
 
-	/* Since we aren't going to look at the final value of
-	 * msg->response_body, we tell libsoup to not even bother
-	 * generating it.
-	 */
-	soup_message_body_set_accumulate (msg->response_body, FALSE);
-
 	/* Connect to "got_headers", from which we'll decide where to
 	 * go next.
 	 */
@@ -187,45 +179,11 @@ fully_async_got_headers (SoupMessage *msg, gpointer user_data)
 	 * until one is requested.
 	 */
 	ad->chunks_ready = TRUE;
-	g_signal_connect (msg, "got_chunk",
-			  G_CALLBACK (fully_async_got_chunk), ad);
 	if (!ad->chunk_wanted)
 		soup_session_pause_message (ad->session, msg);
 }
 
 static void
-fully_async_got_chunk (SoupMessage *msg, GBytes *chunk, gpointer user_data)
-{
-	FullyAsyncData *ad = user_data;
-
-	debug_printf (2, "  got chunk from %lu - %lu\n",
-		      (unsigned long) ad->read_so_far,
-		      (unsigned long) ad->read_so_far + g_bytes_get_size (chunk));
-
-	/* We've got a chunk, let's process it. In the case of the
-	 * test program, that means comparing it against
-	 * correct_response to make sure that we got the right data.
-	 */
-        gsize chunk_length = g_bytes_get_size (chunk);
-	g_assert_cmpint (ad->read_so_far + chunk_length, <=, g_bytes_get_size (correct_response));
-	soup_assert_cmpmem (g_bytes_get_data (chunk, NULL), chunk_length,
-			    (guchar*)g_bytes_get_data (correct_response, NULL) + ad->read_so_far,
-			    chunk_length);
-	ad->read_so_far += chunk_length;
-
-	/* Now pause I/O, and prepare to read another chunk later.
-	 * (Again, the timeout just abstractly represents the idea of
-	 * the application requesting another chunk at some random
-	 * point in the future. You wouldn't be using a timeout in a
-	 * real program.)
-	 */
-	soup_session_pause_message (ad->session, msg);
-	ad->chunk_wanted = FALSE;
-
-	ad->timeout = g_timeout_add (10, fully_async_request_chunk, ad);
-}
-
-static void
 do_fast_async_test (gconstpointer data)
 {
 	const char *base_uri = data;
diff --git a/tests/range-test.c b/tests/range-test.c
index ce8a744b..bf97f958 100644
--- a/tests/range-test.c
+++ b/tests/range-test.c
@@ -349,15 +349,14 @@ do_apache_range_test (void)
 
 static void
 server_handler (SoupServer        *server,
-		SoupMessage       *msg, 
+		SoupServerMessage *msg,
 		const char        *path,
 		GHashTable        *query,
-		SoupClientContext *client,
 		gpointer           user_data)
 {
-	soup_message_set_status (msg, SOUP_STATUS_OK);
-	soup_message_body_append_bytes (msg->response_body,
-					 full_response);
+	soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
+	soup_message_body_append_bytes (soup_server_message_get_response_body (msg),
+					full_response);
 }
 
 static void
diff --git a/tests/redirect-test.c b/tests/redirect-test.c
index d360065a..9ecc2e2d 100644
--- a/tests/redirect-test.c
+++ b/tests/redirect-test.c
@@ -287,72 +287,82 @@ do_async_req_api_test (gconstpointer test)
 }
 
 static void
-server_callback (SoupServer *server, SoupMessage *msg,
-		 const char *path, GHashTable *query,
-		 SoupClientContext *context, gpointer data)
+server_callback (SoupServer        *server,
+		 SoupServerMessage *msg,
+		 const char        *path,
+		 GHashTable        *query,
+		 gpointer           data)
 {
 	char *remainder;
 	guint status_code;
+	SoupMessageHeaders *response_headers;
+	const char *method;
 
 	/* Make sure that a HTTP/1.0 redirect doesn't cause an
 	 * HTTP/1.0 re-request. (#521848)
 	 */
-	if (soup_message_get_http_version (msg) == SOUP_HTTP_1_0) {
-		soup_message_set_status (msg, SOUP_STATUS_BAD_REQUEST);
+	if (soup_server_message_get_http_version (msg) == SOUP_HTTP_1_0) {
+		soup_server_message_set_status (msg, SOUP_STATUS_BAD_REQUEST, NULL);
 		return;
 	}
 
+	method = soup_server_message_get_method (msg);
+	response_headers = soup_server_message_get_response_headers (msg);
+
 	if (g_str_has_prefix (path, "/bad")) {
 		if (!strcmp (path, "/bad")) {
-			soup_message_set_status (msg, SOUP_STATUS_FOUND);
-			soup_message_headers_replace (msg->response_headers,
+			soup_server_message_set_status (msg, SOUP_STATUS_FOUND, NULL);
+			soup_message_headers_replace (response_headers,
 						      "Location",
 						      "/bad with spaces");
 		} else if (!strcmp (path, "/bad-recursive")) {
-			soup_message_set_status (msg, SOUP_STATUS_FOUND);
-			soup_message_headers_replace (msg->response_headers,
+			soup_server_message_set_status (msg, SOUP_STATUS_FOUND, NULL);
+			soup_message_headers_replace (response_headers,
 						      "Location",
 						      "/bad-recursive");
 		} else if (!strcmp (path, "/bad-no-host")) {
-			soup_message_set_status (msg, SOUP_STATUS_FOUND);
-			soup_message_headers_replace (msg->response_headers,
+			soup_server_message_set_status (msg, SOUP_STATUS_FOUND, NULL);
+			soup_message_headers_replace (response_headers,
 						      "Location",
 						      "about:blank");
 		} else if (!strcmp (path, "/bad with spaces"))
-			soup_message_set_status (msg, SOUP_STATUS_OK);
+			soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
 		else
-			soup_message_set_status (msg, SOUP_STATUS_NOT_FOUND);
+			soup_server_message_set_status (msg, SOUP_STATUS_NOT_FOUND, NULL);
 		return;
 	} else if (!strcmp (path, "/server2")) {
-		soup_message_set_status (msg, SOUP_STATUS_FOUND);
-		soup_message_headers_replace (msg->response_headers,
+		soup_server_message_set_status (msg, SOUP_STATUS_FOUND, NULL);
+		soup_message_headers_replace (response_headers,
 					      "Location",
 					      server2_uri);
 		return;
 	} else if (!strcmp (path, "/")) {
-		if (msg->method != SOUP_METHOD_GET &&
-		    msg->method != SOUP_METHOD_HEAD) {
-			soup_message_set_status (msg, SOUP_STATUS_METHOD_NOT_ALLOWED);
+		SoupMessageBody *request_body;
+
+		if (method != SOUP_METHOD_GET &&
+		    method != SOUP_METHOD_HEAD) {
+			soup_server_message_set_status (msg, SOUP_STATUS_METHOD_NOT_ALLOWED, NULL);
 			return;
 		}
 
 		/* Make sure that redirecting a POST clears the body */
-		if (msg->request_body->length) {
-			soup_message_set_status (msg, SOUP_STATUS_BAD_REQUEST);
+		request_body = soup_server_message_get_request_body (msg);
+		if (request_body->length) {
+			soup_server_message_set_status (msg, SOUP_STATUS_BAD_REQUEST, NULL);
 			return;
 		}
 
-		soup_message_set_status (msg, SOUP_STATUS_OK);
+		soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
 
 		/* FIXME: this is wrong, though it doesn't matter for
 		 * the purposes of this test, and to do the right
 		 * thing currently we'd have to set Content-Length by
 		 * hand.
 		 */
-		if (msg->method != SOUP_METHOD_HEAD) {
-			soup_message_set_response (msg, "text/plain",
-						   SOUP_MEMORY_STATIC,
-						   "OK\r\n", 4);
+		if (method != SOUP_METHOD_HEAD) {
+			soup_server_message_set_response (msg, "text/plain",
+							  SOUP_MEMORY_STATIC,
+							  "OK\r\n", 4);
 		}
 		return;
 	}
@@ -360,7 +370,7 @@ server_callback (SoupServer *server, SoupMessage *msg,
 	status_code = strtoul (path + 1, &remainder, 10);
 	if (!SOUP_STATUS_IS_REDIRECTION (status_code) ||
 	    (*remainder && *remainder != '/')) {
-		soup_message_set_status (msg, SOUP_STATUS_NOT_FOUND);
+		soup_server_message_set_status (msg, SOUP_STATUS_NOT_FOUND, NULL);
 		return;
 	}
 
@@ -369,18 +379,20 @@ server_callback (SoupServer *server, SoupMessage *msg,
 	 * the rest of the time.
 	 */
 	if (*remainder == '/')
-		soup_message_set_http_version (msg, SOUP_HTTP_1_0);
+		soup_server_message_set_http_version (msg, SOUP_HTTP_1_0);
 
-	soup_message_set_redirect (msg, status_code,
-				   *remainder ? remainder : "/");
+	soup_server_message_set_redirect (msg, status_code,
+					  *remainder ? remainder : "/");
 }
 
 static void
-server2_callback (SoupServer *server, SoupMessage *msg,
-		  const char *path, GHashTable *query,
-		  SoupClientContext *context, gpointer data)
+server2_callback (SoupServer        *server,
+		  SoupServerMessage *msg,
+		  const char        *path,
+		  GHashTable        *query,
+		  gpointer           data)
 {
-	soup_message_set_status (msg, SOUP_STATUS_OK);
+	soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
 }
 
 int
diff --git a/tests/request-body-test.c b/tests/request-body-test.c
index fb5cd31d..fad90c7f 100644
--- a/tests/request-body-test.c
+++ b/tests/request-body-test.c
@@ -138,30 +138,32 @@ do_request_test (gconstpointer data)
 }
 
 static void
-server_callback (SoupServer *server, SoupMessage *msg,
-                 const char *path, GHashTable *query,
-                 SoupClientContext *context, gpointer data)
+server_callback (SoupServer        *server,
+		 SoupServerMessage *msg,
+                 const char        *path,
+		 GHashTable        *query,
+                 gpointer           data)
 {
         SoupMessageBody *md5_body;
         char *md5;
 
         if (g_str_has_prefix (path, "/redirect")) {
-                soup_message_set_redirect (msg, SOUP_STATUS_FOUND, "/");
+                soup_server_message_set_redirect (msg, SOUP_STATUS_FOUND, "/");
                 return;
         }
 
-        if (msg->method == SOUP_METHOD_PUT) {
-                soup_message_set_status (msg, SOUP_STATUS_CREATED);
-                md5_body = msg->request_body;
+        if (soup_server_message_get_method (msg) == SOUP_METHOD_PUT) {
+                soup_server_message_set_status (msg, SOUP_STATUS_CREATED, NULL);
+                md5_body = soup_server_message_get_request_body (msg);
         } else {
-                soup_message_set_status (msg, SOUP_STATUS_METHOD_NOT_ALLOWED);
+                soup_server_message_set_status (msg, SOUP_STATUS_METHOD_NOT_ALLOWED, NULL);
                 return;
         }
 
         md5 = g_compute_checksum_for_data (G_CHECKSUM_MD5,
                                            (guchar *)md5_body->data,
                                            md5_body->length);
-        soup_message_headers_append (msg->response_headers,
+        soup_message_headers_append (soup_server_message_get_response_headers (msg),
                                      "Content-MD5", md5);
         g_free (md5);
 }
diff --git a/tests/server-auth-test.c b/tests/server-auth-test.c
index dd92f1a6..54910967 100644
--- a/tests/server-auth-test.c
+++ b/tests/server-auth-test.c
@@ -227,15 +227,20 @@ do_server_auth_test (gconstpointer data)
 }
 
 static gboolean
-basic_auth_callback (SoupAuthDomain *auth_domain, SoupMessage *msg,
-		     const char *username, const char *password, gpointer data)
+basic_auth_callback (SoupAuthDomain    *auth_domain,
+		     SoupServerMessage *msg,
+		     const char        *username,
+		     const char        *password,
+		     gpointer           data)
 {
 	return !strcmp (username, "user") && !strcmp (password, "password");
 }
 
 static char *
-digest_auth_callback (SoupAuthDomain *auth_domain, SoupMessage *msg,
-		      const char *username, gpointer data)
+digest_auth_callback (SoupAuthDomain    *auth_domain,
+		      SoupServerMessage *msg,
+		      const char        *username,
+		      gpointer           data)
 {
 	if (strcmp (username, "user") != 0)
 		return NULL;
@@ -251,27 +256,33 @@ digest_auth_callback (SoupAuthDomain *auth_domain, SoupMessage *msg,
 }
 
 static void
-server_callback (SoupServer *server, SoupMessage *msg,
-		 const char *path, GHashTable *query,
-		 SoupClientContext *context, gpointer data)
+server_callback (SoupServer        *server,
+		 SoupServerMessage *msg,
+		 const char        *path,
+		 GHashTable        *query,
+		 gpointer           data)
 {
-	if (msg->method != SOUP_METHOD_GET && msg->method != SOUP_METHOD_HEAD) {
-		soup_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED);
+	const char *method;
+
+	method = soup_server_message_get_method (msg);
+	if (method != SOUP_METHOD_GET && method != SOUP_METHOD_HEAD) {
+		soup_server_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED, NULL);
 		return;
 	}
 
-	soup_message_set_response (msg, "text/plain",
-				   SOUP_MEMORY_STATIC,
-				   "OK\r\n", 4);
-	soup_message_set_status (msg, SOUP_STATUS_OK);
+	soup_server_message_set_response (msg, "text/plain",
+					  SOUP_MEMORY_STATIC,
+					  "OK\r\n", 4);
+	soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
 }
 
 static void
-got_headers_callback (SoupMessage *msg, gpointer data)
+got_headers_callback (SoupServerMessage *msg,
+		      gpointer           data)
 {
 	const char *header;
 
-	header = soup_message_headers_get_one (msg->request_headers,
+	header = soup_message_headers_get_one (soup_server_message_get_request_headers (msg),
 					       "Authorization");
 	if (header) {
 		if (strstr (header, "Basic "))
@@ -282,11 +293,12 @@ got_headers_callback (SoupMessage *msg, gpointer data)
 }
 
 static void
-wrote_headers_callback (SoupMessage *msg, gpointer data)
+wrote_headers_callback (SoupServerMessage *msg,
+			gpointer           data)
 {
 	const char *header;
 
-	header = soup_message_headers_get_list (msg->response_headers,
+	header = soup_message_headers_get_list (soup_server_message_get_response_headers (msg),
 						"WWW-Authenticate");
 	if (header) {
 		if (strstr (header, "Basic "))
@@ -297,12 +309,13 @@ wrote_headers_callback (SoupMessage *msg, gpointer data)
 }
 
 static void
-request_started_callback (SoupServer *server, SoupMessage *msg,
-			  SoupClientContext *client, gpointer data)
+request_started_callback (SoupServer        *server,
+			  SoupServerMessage *msg,
+			  gpointer           data)
 {
-	g_signal_connect (msg, "got_headers",
+	g_signal_connect (msg, "got-headers",
 			  G_CALLBACK (got_headers_callback), NULL);
-	g_signal_connect (msg, "wrote_headers",
+	g_signal_connect (msg, "wrote-headers",
 			  G_CALLBACK (wrote_headers_callback), NULL);
 }
 
diff --git a/tests/server-test.c b/tests/server-test.c
index 3c5a1cab..8b18f8a7 100644
--- a/tests/server-test.c
+++ b/tests/server-test.c
@@ -14,27 +14,32 @@ typedef struct {
 } ServerData;
 
 static void
-server_callback (SoupServer *server, SoupMessage *msg,
-		 const char *path, GHashTable *query,
-		 SoupClientContext *context, gpointer data)
+server_callback (SoupServer        *server,
+		 SoupServerMessage *msg,
+		 const char        *path,
+		 GHashTable        *query,
+		 gpointer           data)
 {
-	soup_message_headers_append (msg->response_headers,
+	const char *method;
+
+	soup_message_headers_append (soup_server_message_get_response_headers (msg),
 				     "X-Handled-By", "server_callback");
 
 	if (!strcmp (path, "*")) {
 		soup_test_assert (FALSE, "default server_callback got request for '*'");
-		soup_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR);
+		soup_server_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR, NULL);
 		return;
 	}
 
-	if (msg->method != SOUP_METHOD_GET && msg->method != SOUP_METHOD_POST) {
-		soup_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED);
+	method = soup_server_message_get_method (msg);
+	if (method != SOUP_METHOD_GET && method != SOUP_METHOD_POST) {
+		soup_server_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED, NULL);
 		return;
 	}
 
-	soup_message_set_status (msg, SOUP_STATUS_OK);
-	soup_message_set_response (msg, "text/plain",
-				   SOUP_MEMORY_STATIC, "index", 5);
+	soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
+	soup_server_message_set_response (msg, "text/plain",
+					  SOUP_MEMORY_STATIC, "index", 5);
 }
 
 static void
@@ -90,25 +95,27 @@ server_teardown (ServerData *sd, gconstpointer test_data)
 }
 
 static void
-server_star_callback (SoupServer *server, SoupMessage *msg,
-		      const char *path, GHashTable *query,
-		      SoupClientContext *context, gpointer data)
+server_star_callback (SoupServer        *server,
+		      SoupServerMessage *msg,
+		      const char        *path,
+		      GHashTable        *query,
+		      gpointer           data)
 {
-	soup_message_headers_append (msg->response_headers,
+	soup_message_headers_append (soup_server_message_get_response_headers (msg),
 				     "X-Handled-By", "star_callback");
 
 	if (strcmp (path, "*") != 0) {
 		soup_test_assert (FALSE, "server_star_callback got request for '%s'", path);
-		soup_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR);
+		soup_server_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR, NULL);
 		return;
 	}
 
-	if (msg->method != SOUP_METHOD_OPTIONS) {
-		soup_message_set_status (msg, SOUP_STATUS_METHOD_NOT_ALLOWED);
+	if (soup_server_message_get_method (msg) != SOUP_METHOD_OPTIONS) {
+		soup_server_message_set_status (msg, SOUP_STATUS_METHOD_NOT_ALLOWED, NULL);
 		return;
 	}
 
-	soup_message_set_status (msg, SOUP_STATUS_OK);
+	soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
 }
 
 /* Server handlers for "*" work but are separate from handlers for
@@ -345,26 +352,28 @@ do_dot_dot_test (ServerData *sd, gconstpointer test_data)
 }
 
 static void
-ipv6_server_callback (SoupServer *server, SoupMessage *msg,
-		      const char *path, GHashTable *query,
-		      SoupClientContext *context, gpointer data)
+ipv6_server_callback (SoupServer        *server,
+		      SoupServerMessage *msg,
+		      const char        *path,
+		      GHashTable        *query,
+		      gpointer           data)
 {
 	const char *host;
 	GSocketAddress *addr;
 	char expected_host[128];
 
-	addr = soup_client_context_get_local_address (context);
+	addr = soup_server_message_get_local_address (msg);
 	g_snprintf (expected_host, sizeof (expected_host),
 		    "[::1]:%d",
 		    g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr)));
 
-	host = soup_message_headers_get_one (msg->request_headers, "Host");
+	host = soup_message_headers_get_one (soup_server_message_get_request_headers (msg), "Host");
 	g_assert_cmpstr (host, ==, expected_host);
 
 	if (g_test_failed ())
-		soup_message_set_status (msg, SOUP_STATUS_BAD_REQUEST);
+		soup_server_message_set_status (msg, SOUP_STATUS_BAD_REQUEST, NULL);
 	else
-		soup_message_set_status (msg, SOUP_STATUS_OK);
+		soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
 }
 
 static void
@@ -413,19 +422,21 @@ do_ipv6_test (ServerData *sd, gconstpointer test_data)
 }
 
 static void
-multi_server_callback (SoupServer *server, SoupMessage *msg,
-		       const char *path, GHashTable *query,
-		       SoupClientContext *context, gpointer data)
+multi_server_callback (SoupServer        *server,
+		       SoupServerMessage *msg,
+		       const char        *path,
+		       GHashTable        *query,
+		       gpointer           data)
 {
 	GSocketAddress *addr;
 	GInetSocketAddress *iaddr;
 	SoupURI *uri;
 	char *uristr, *addrstr;
 
-	addr = soup_client_context_get_local_address (context);
+	addr = soup_server_message_get_local_address (msg);
 	iaddr = G_INET_SOCKET_ADDRESS (addr);
 
-	uri = soup_message_get_uri (msg);
+	uri = soup_server_message_get_uri (msg);
 	uristr = soup_uri_to_string (uri, FALSE);
 
 	addrstr = g_inet_address_to_string (g_inet_socket_address_get_address (iaddr));
@@ -436,9 +447,9 @@ multi_server_callback (SoupServer *server, SoupMessage *msg,
 
 	/* FIXME ssl */
 
-	soup_message_set_response (msg, "text/plain",
-				   SOUP_MEMORY_TAKE, uristr, strlen (uristr));
-	soup_message_set_status (msg, SOUP_STATUS_OK);
+	soup_server_message_set_response (msg, "text/plain",
+					  SOUP_MEMORY_TAKE, uristr, strlen (uristr));
+	soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
 }
 
 static void
@@ -794,27 +805,29 @@ g_test_io_stream_new (GInputStream *input, GOutputStream *output)
 }
 
 static void
-mem_server_callback (SoupServer *server, SoupMessage *msg,
-		     const char *path, GHashTable *query,
-		     SoupClientContext *context, gpointer data)
+mem_server_callback (SoupServer        *server,
+		     SoupServerMessage *msg,
+		     const char        *path,
+		     GHashTable        *query,
+		     gpointer           data)
 {
 	GSocketAddress *addr;
 	GSocket *sock;
 	const char *host;
 
-	addr = soup_client_context_get_local_address (context);
+	addr = soup_server_message_get_local_address (msg);
 	g_assert_nonnull (addr);
 
-	addr = soup_client_context_get_remote_address (context);
+	addr = soup_server_message_get_remote_address (msg);
 	g_assert_nonnull (addr);
 
-	sock = soup_client_context_get_socket (context);
+	sock = soup_server_message_get_socket (msg);
 	g_assert_null (sock);
 
-	host = soup_client_context_get_host (context);
+	host = soup_server_message_get_remote_host (msg);
 	g_assert_cmpstr (host, ==, "127.0.0.1");
 
-	server_callback (server, msg, path, query, context, data);
+	server_callback (server, msg, path, query, data);
 }
 
 static void
@@ -858,7 +871,7 @@ do_iostream_accept_test (void)
 
 typedef struct {
 	SoupServer *server;
-	SoupMessage *smsg;
+	SoupServerMessage *smsg;
 	gboolean handler_called;
 	gboolean paused;
 } UnhandledServerData;
@@ -873,15 +886,17 @@ idle_unpause_message (gpointer user_data)
 }
 
 static void
-unhandled_server_callback (SoupServer *server, SoupMessage *msg,
-			   const char *path, GHashTable *query,
-			   SoupClientContext *context, gpointer data)
+unhandled_server_callback (SoupServer        *server,
+			   SoupServerMessage *msg,
+			   const char        *path,
+			   GHashTable        *query,
+			   gpointer           data)
 {
 	UnhandledServerData *usd = data;
 
 	usd->handler_called = TRUE;
 
-	if (soup_message_headers_get_one (msg->request_headers, "X-Test-Server-Pause")) {
+	if (soup_message_headers_get_one (soup_server_message_get_request_headers (msg), "X-Test-Server-Pause")) {
 		usd->paused = TRUE;
 		usd->server = server;
 		usd->smsg = msg;
@@ -946,7 +961,9 @@ do_fail_500_test (ServerData *sd, gconstpointer pause)
 }
 
 static void
-stream_got_chunk (SoupMessage *msg, GBytes *chunk, gpointer user_data)
+stream_got_chunk (SoupServerMessage *msg,
+		  GBytes            *chunk,
+		  gpointer           user_data)
 {
 	GChecksum *checksum = user_data;
 
@@ -954,26 +971,29 @@ stream_got_chunk (SoupMessage *msg, GBytes *chunk, gpointer user_data)
 }
 
 static void
-stream_got_body (SoupMessage *msg, gpointer user_data)
+stream_got_body (SoupServerMessage *msg,
+		 gpointer           user_data)
 {
 	GChecksum *checksum = user_data;
 	const char *md5 = g_checksum_get_string (checksum);
 
-	soup_message_set_status (msg, SOUP_STATUS_OK);
-	soup_message_set_response (msg, "text/plain", SOUP_MEMORY_COPY,
-				   md5, strlen (md5));
+	soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
+	soup_server_message_set_response (msg, "text/plain", SOUP_MEMORY_COPY,
+					  md5, strlen (md5));
 	g_checksum_free (checksum);
 }
 
 static void
-early_stream_callback (SoupServer *server, SoupMessage *msg,
-		       const char *path, GHashTable *query,
-		       SoupClientContext *context, gpointer data)
+early_stream_callback (SoupServer        *server,
+		       SoupServerMessage *msg,
+		       const char        *path,
+		       GHashTable        *query,
+		       gpointer           data)
 {
 	GChecksum *checksum;
 
-	if (msg->method != SOUP_METHOD_POST) {
-		soup_message_set_status (msg, SOUP_STATUS_METHOD_NOT_ALLOWED);
+	if (soup_server_message_get_method (msg) != SOUP_METHOD_POST) {
+		soup_server_message_set_status (msg, SOUP_STATUS_METHOD_NOT_ALLOWED, NULL);
 		return;
 	}
 
@@ -983,7 +1003,7 @@ early_stream_callback (SoupServer *server, SoupMessage *msg,
 	g_signal_connect (msg, "got-body",
 			  G_CALLBACK (stream_got_body), checksum);
 
-	soup_message_body_set_accumulate (msg->request_body, TRUE);
+	soup_message_body_set_accumulate (soup_server_message_get_request_body (msg), TRUE);
 }
 
 static void
@@ -1016,12 +1036,14 @@ do_early_stream_test (ServerData *sd, gconstpointer test_data)
 }
 
 static void
-early_respond_callback (SoupServer *server, SoupMessage *msg,
-			const char *path, GHashTable *query,
-			SoupClientContext *context, gpointer data)
+early_respond_callback (SoupServer        *server,
+			SoupServerMessage *msg,
+			const char        *path,
+			GHashTable        *query,
+			gpointer           data)
 {
 	if (!strcmp (path, "/"))
-		soup_message_set_status (msg, SOUP_STATUS_FORBIDDEN);
+		soup_server_message_set_status (msg, SOUP_STATUS_FORBIDDEN, NULL);
 }
 
 static void
@@ -1040,7 +1062,6 @@ do_early_respond_test (ServerData *sd, gconstpointer test_data)
 	msg = soup_message_new_from_uri ("GET", sd->base_uri);
 	soup_test_session_send_message (session, msg);
 	soup_test_assert_message_status (msg, SOUP_STATUS_FORBIDDEN);
-	g_assert_cmpint (msg->response_body->length, ==, 0);
 	g_object_unref (msg);
 
 	/* The early handler will ignore this one */
@@ -1057,11 +1078,13 @@ do_early_respond_test (ServerData *sd, gconstpointer test_data)
 }
 
 static void
-early_multi_callback (SoupServer *server, SoupMessage *msg,
-		      const char *path, GHashTable *query,
-		      SoupClientContext *context, gpointer data)
+early_multi_callback (SoupServer        *server,
+		      SoupServerMessage *msg,
+		      const char        *path,
+		      GHashTable        *query,
+		      gpointer           data)
 {
-	soup_message_headers_append (msg->response_headers, "X-Early", "yes");
+	soup_message_headers_append (soup_server_message_get_response_headers (msg), "X-Early", "yes");
 }
 
 static void
@@ -1147,8 +1170,7 @@ typedef struct {
 
 typedef struct {
 	SoupServer *self;
-	SoupMessage *msg;
-	SoupClientContext *context;
+	SoupServerMessage *msg;
 	GCancellable *cancellable;
 
 	TunnelEnd client, server;
@@ -1272,11 +1294,12 @@ tunnel_read_cb (GObject      *object,
 }
 
 static void
-start_tunnel (SoupMessage *msg, gpointer user_data)
+start_tunnel (SoupServerMessage *msg,
+	      gpointer           user_data)
 {
 	Tunnel *tunnel = user_data;
 
-	tunnel->client.iostream = soup_client_context_steal_connection (tunnel->context);
+	tunnel->client.iostream = soup_server_message_steal_connection (msg);
 	tunnel->client.istream = g_io_stream_get_input_stream (tunnel->client.iostream);
 	tunnel->client.ostream = g_io_stream_get_output_stream (tunnel->client.iostream);
 	g_clear_object (&tunnel->self);
@@ -1309,10 +1332,10 @@ tunnel_connected_cb (GObject      *object,
 	tunnel->server.iostream = (GIOStream *)
 		g_socket_client_connect_to_host_finish (G_SOCKET_CLIENT (object), result, &error);
 	if (!tunnel->server.iostream) {
-		soup_message_set_status (tunnel->msg, SOUP_STATUS_BAD_GATEWAY);
-		soup_message_set_response (tunnel->msg, "text/plain",
-					   SOUP_MEMORY_COPY,
-					   error->message, strlen (error->message));
+		soup_server_message_set_status (tunnel->msg, SOUP_STATUS_BAD_GATEWAY, NULL);
+		soup_server_message_set_response (tunnel->msg, "text/plain",
+						  SOUP_MEMORY_COPY,
+						  error->message, strlen (error->message));
 		g_error_free (error);
 		soup_server_unpause_message (tunnel->self, tunnel->msg);
 		tunnel_close (tunnel);
@@ -1322,23 +1345,25 @@ tunnel_connected_cb (GObject      *object,
 	tunnel->server.istream = g_io_stream_get_input_stream (tunnel->server.iostream);
 	tunnel->server.ostream = g_io_stream_get_output_stream (tunnel->server.iostream);
 
-	soup_message_set_status (tunnel->msg, SOUP_STATUS_OK);
+	soup_server_message_set_status (tunnel->msg, SOUP_STATUS_OK, NULL);
 	soup_server_unpause_message (tunnel->self, tunnel->msg);
 	g_signal_connect (tunnel->msg, "wrote-body",
 			  G_CALLBACK (start_tunnel), tunnel);
 }
 
 static void
-proxy_server_callback (SoupServer *server, SoupMessage *msg,
-		       const char *path, GHashTable *query,
-		       SoupClientContext *context, gpointer data)
+proxy_server_callback (SoupServer        *server,
+		       SoupServerMessage *msg,
+		       const char        *path,
+		       GHashTable        *query,
+		       gpointer           data)
 {
 	GSocketClient *sclient;
 	SoupURI *dest_uri;
 	Tunnel *tunnel;
 
-	if (msg->method != SOUP_METHOD_CONNECT) {
-		soup_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED);
+	if (soup_server_message_get_method (msg) != SOUP_METHOD_CONNECT) {
+		soup_server_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED, NULL);
 		return;
 	}
 
@@ -1347,9 +1372,8 @@ proxy_server_callback (SoupServer *server, SoupMessage *msg,
 	tunnel = g_new0 (Tunnel, 1);
 	tunnel->self = g_object_ref (server);
 	tunnel->msg = g_object_ref (msg);
-	tunnel->context = context;
 
-	dest_uri = soup_message_get_uri (msg);
+	dest_uri = soup_server_message_get_uri (msg);
 	sclient = g_socket_client_new ();
 	g_socket_client_connect_to_host_async (sclient, dest_uri->host, dest_uri->port,
 					       NULL, tunnel_connected_cb, tunnel);
diff --git a/tests/session-test.c b/tests/session-test.c
index a3952f7d..be85d669 100644
--- a/tests/session-test.c
+++ b/tests/session-test.c
@@ -18,10 +18,9 @@ timeout_cb (gpointer user_data)
 
 static void
 server_handler (SoupServer        *server,
-		SoupMessage       *msg, 
+		SoupServerMessage *msg,
 		const char        *path,
 		GHashTable        *query,
-		SoupClientContext *client,
 		gpointer           user_data)
 {
 	if (!strcmp (path, "/request-timeout")) {
@@ -35,10 +34,10 @@ server_handler (SoupServer        *server,
 	} else
 		server_processed_message = TRUE;
 
-	soup_message_set_status (msg, SOUP_STATUS_OK);
-	soup_message_set_response (msg, "text/plain",
-				   SOUP_MEMORY_STATIC,
-				   "ok\r\n", 4);
+	soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
+	soup_server_message_set_response (msg, "text/plain",
+					  SOUP_MEMORY_STATIC,
+					  "ok\r\n", 4);
 }
 
 static void
diff --git a/tests/sniffing-test.c b/tests/sniffing-test.c
index 98547a34..e81811b0 100644
--- a/tests/sniffing-test.c
+++ b/tests/sniffing-test.c
@@ -10,27 +10,32 @@ SoupURI *base_uri;
 SoupMessageBody *chunk_data;
 
 static void
-server_callback (SoupServer *server, SoupMessage *msg,
-		 const char *path, GHashTable *query,
-		 SoupClientContext *context, gpointer data)
+server_callback (SoupServer        *server,
+		 SoupServerMessage *msg,
+		 const char        *path,
+		 GHashTable        *query,
+		 gpointer           data)
 {
 	GError *error = NULL;
 	char *query_key;
 	GBytes *response = NULL;
 	gsize offset;
+	SoupMessageHeaders *response_headers;
+	SoupMessageBody *response_body;
 	gboolean empty_response = FALSE;
 
-	if (msg->method != SOUP_METHOD_GET) {
-		soup_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED);
+	if (soup_server_message_get_method (msg) != SOUP_METHOD_GET) {
+		soup_server_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED, NULL);
 		return;
 	}
 
-	soup_message_set_status (msg, SOUP_STATUS_OK);
+	soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
 
+	response_headers = soup_server_message_get_response_headers (msg);
 	if (query) {
 		query_key = g_hash_table_lookup (query, "chunked");
 		if (query_key && g_str_equal (query_key, "yes")) {
-			soup_message_headers_set_encoding (msg->response_headers,
+			soup_message_headers_set_encoding (response_headers,
 							   SOUP_ENCODING_CHUNKED);
 		}
 
@@ -45,7 +50,7 @@ server_callback (SoupServer *server, SoupMessage *msg,
 			g_assert_no_error (error);
 		}
 
-		soup_message_headers_append (msg->response_headers,
+		soup_message_headers_append (response_headers,
 					     "Content-Type", "text/plain");
 	}
 
@@ -56,10 +61,10 @@ server_callback (SoupServer *server, SoupMessage *msg,
 		g_assert_no_error (error);
 		g_free (base_name);
 
-		soup_message_headers_append (msg->response_headers,
+		soup_message_headers_append (response_headers,
 					     "X-Content-Type-Options", "nosniff");
 
-		soup_message_headers_append (msg->response_headers,
+		soup_message_headers_append (response_headers,
 					     "Content-Type", "no/sniffing-allowed");
 	}
 
@@ -70,7 +75,7 @@ server_callback (SoupServer *server, SoupMessage *msg,
 		g_assert_no_error (error);
 		g_free (base_name);
 
-		soup_message_headers_append (msg->response_headers,
+		soup_message_headers_append (response_headers,
 					     "Content-Type", "text/plain");
 	}
 
@@ -81,7 +86,7 @@ server_callback (SoupServer *server, SoupMessage *msg,
 		g_assert_no_error (error);
 		g_free (base_name);
 
-		soup_message_headers_append (msg->response_headers,
+		soup_message_headers_append (response_headers,
 					     "Content-Type", "UNKNOWN/unknown");
 	}
 
@@ -99,7 +104,7 @@ server_callback (SoupServer *server, SoupMessage *msg,
 		ptr = g_strrstr (components[2], "_");
 		*ptr = '/';
 
-		soup_message_headers_append (msg->response_headers,
+		soup_message_headers_append (response_headers,
 					     "Content-Type", components[2]);
 		g_strfreev (components);
 	}
@@ -111,24 +116,25 @@ server_callback (SoupServer *server, SoupMessage *msg,
 		g_assert_no_error (error);
 		g_free (base_name);
 
-		soup_message_headers_append (msg->response_headers,
+		soup_message_headers_append (response_headers,
 					     "Content-Type", "text/xml");
-		soup_message_headers_append (msg->response_headers,
+		soup_message_headers_append (response_headers,
 					     "Content-Type", "text/plain");
 	}
 
+	response_body = soup_server_message_get_response_body (msg);
 	if (response) {
-                gsize response_size = g_bytes_get_size (response);                
+                gsize response_size = g_bytes_get_size (response);
 		for (offset = 0; offset < response_size; offset += 500) {
                         GBytes *chunk = g_bytes_new_from_bytes (response, offset, MIN (500, response_size - offset));
-                        soup_message_body_append_bytes (msg->response_body, chunk);
+                        soup_message_body_append_bytes (response_body, chunk);
                         g_bytes_unref (chunk);
 		}
 
 		g_bytes_unref (response);
 	}
 
-	soup_message_body_complete (msg->response_body);
+	soup_message_body_complete (response_body);
 }
 
 static gboolean
@@ -229,7 +235,9 @@ do_signals_test (gboolean should_content_sniff,
 
 	soup_message_set_uri (msg, uri);
 
+#if 0
 	soup_message_body_set_accumulate (msg->response_body, should_accumulate);
+#endif
 
 	g_object_connect (msg,
 			  "signal::got-headers", got_headers, GINT_TO_POINTER (should_pause),
@@ -258,8 +266,10 @@ do_signals_test (gboolean should_content_sniff,
 
 	if (!should_accumulate && chunk_data)
 		body = soup_message_body_flatten (chunk_data);
+#if 0
 	else if (msg->response_body)
 		body = soup_message_body_flatten (msg->response_body);
+#endif
 
 	if (body) {
                 //g_message ("|||body (%zu): %s", g_bytes_get_size (body), (char*)g_bytes_get_data (body, NULL));
diff --git a/tests/ssl-test.c b/tests/ssl-test.c
index 1422834a..c314b2d7 100644
--- a/tests/ssl-test.c
+++ b/tests/ssl-test.c
@@ -238,16 +238,15 @@ do_tls_interaction_test (void)
 
 static void
 server_handler (SoupServer        *server,
-		SoupMessage       *msg, 
+		SoupServerMessage *msg,
 		const char        *path,
 		GHashTable        *query,
-		SoupClientContext *client,
 		gpointer           user_data)
 {
-	soup_message_set_status (msg, SOUP_STATUS_OK);
-	soup_message_set_response (msg, "text/plain",
-				   SOUP_MEMORY_STATIC,
-				   "ok\r\n", 4);
+	soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
+	soup_server_message_set_response (msg, "text/plain",
+					  SOUP_MEMORY_STATIC,
+					  "ok\r\n", 4);
 }
 
 int
diff --git a/tests/streaming-test.c b/tests/streaming-test.c
index b1a10d54..a9280cb8 100644
--- a/tests/streaming-test.c
+++ b/tests/streaming-test.c
@@ -11,16 +11,20 @@ GBytes *full_response;
 char *full_response_md5;
 
 static void
-write_next_chunk (SoupMessage *msg, gpointer user_data)
+write_next_chunk (SoupServerMessage *msg,
+		  gpointer           user_data)
 {
 	gsize *offset = user_data;
 	gsize chunk_length;
+	SoupMessageBody *response_body;
+
+	response_body = soup_server_message_get_response_body (msg);
 
 	chunk_length = MIN (RESPONSE_CHUNK_SIZE, g_bytes_get_size (full_response) - *offset);
 	if (chunk_length > 0) {
 		debug_printf (2, "  writing chunk\n");
                 GBytes *chunk = g_bytes_new_from_bytes (full_response, *offset, chunk_length);
-                soup_message_body_append_bytes (msg->response_body, chunk);
+                soup_message_body_append_bytes (response_body, chunk);
                 g_bytes_unref (chunk);
 		*offset += chunk_length;
 	} else {
@@ -29,44 +33,49 @@ write_next_chunk (SoupMessage *msg, gpointer user_data)
 		 * cases, but it's harmless in the content-length
 		 * case.
 		 */
-		soup_message_body_complete (msg->response_body);
+		soup_message_body_complete (response_body);
 	}
 }
 
 static void
-free_offset (SoupMessage *msg, gpointer offset)
+free_offset (SoupServerMessage *msg,
+	     gpointer           offset)
 {
 	g_free (offset);
 }
 
 static void
-server_callback (SoupServer *server, SoupMessage *msg,
-		 const char *path, GHashTable *query,
-		 SoupClientContext *context, gpointer data)
+server_callback (SoupServer        *server,
+		 SoupServerMessage *msg,
+		 const char        *path,
+		 GHashTable        *query,
+		 gpointer           data)
 {
 	gsize *offset;
+	SoupMessageHeaders *response_headers;
 
+	response_headers = soup_server_message_get_response_headers (msg);
 	if (!strcmp (path, "/chunked")) {
-		soup_message_headers_set_encoding (msg->response_headers,
+		soup_message_headers_set_encoding (response_headers,
 						   SOUP_ENCODING_CHUNKED);
 	} else if (!strcmp (path, "/content-length")) {
-		soup_message_headers_set_encoding (msg->response_headers,
+		soup_message_headers_set_encoding (response_headers,
 						   SOUP_ENCODING_CONTENT_LENGTH);
-		soup_message_headers_set_content_length (msg->response_headers,
+		soup_message_headers_set_content_length (response_headers,
 							 g_bytes_get_size (full_response));
 	} else if (!strcmp (path, "/eof")) {
-		soup_message_headers_set_encoding (msg->response_headers,
+		soup_message_headers_set_encoding (response_headers,
 						   SOUP_ENCODING_EOF);
 	} else {
-		soup_message_set_status (msg, SOUP_STATUS_NOT_FOUND);
+		soup_server_message_set_status (msg, SOUP_STATUS_NOT_FOUND, NULL);
 		return;
 	}
-	soup_message_set_status (msg, SOUP_STATUS_OK);
+	soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
 
 	offset = g_new0 (gsize, 1);
-	g_signal_connect (msg, "wrote_headers",
+	g_signal_connect (msg, "wrote-headers",
 			  G_CALLBACK (write_next_chunk), offset);
-	g_signal_connect (msg, "wrote_chunk",
+	g_signal_connect (msg, "wrote-chunk",
 			  G_CALLBACK (write_next_chunk), offset);
 	g_signal_connect (msg, "finished",
 			  G_CALLBACK (free_offset), offset);
diff --git a/tests/timeout-test.c b/tests/timeout-test.c
index 17977434..b3325e42 100644
--- a/tests/timeout-test.c
+++ b/tests/timeout-test.c
@@ -287,16 +287,15 @@ timeout_finish_message (gpointer msg)
 
 static void
 server_handler (SoupServer        *server,
-		SoupMessage       *msg, 
+		SoupServerMessage *msg,
 		const char        *path,
 		GHashTable        *query,
-		SoupClientContext *client,
 		gpointer           user_data)
 {
-	soup_message_set_status (msg, SOUP_STATUS_OK);
-	soup_message_set_response (msg, "text/plain",
-				   SOUP_MEMORY_STATIC,
-				   "ok\r\n", 4);
+	soup_server_message_set_status (msg, SOUP_STATUS_OK, NULL);
+	soup_server_message_set_response (msg, "text/plain",
+					  SOUP_MEMORY_STATIC,
+					  "ok\r\n", 4);
 
 	if (!strcmp (path, "/slow")) {
 		soup_server_pause_message (server, msg);
diff --git a/tests/websocket-test.c b/tests/websocket-test.c
index 5e40cf36..c3a401ce 100644
--- a/tests/websocket-test.c
+++ b/tests/websocket-test.c
@@ -19,7 +19,7 @@
  */
 
 #include "test-utils.h"
-
+#include "soup-server-message-private.h"
 #include <zlib.h>
 
 typedef struct {
@@ -291,9 +291,9 @@ client_connect (Test *test,
 
 static void
 got_server_connection (SoupServer              *server,
-		       SoupWebsocketConnection *connection,
+		       SoupServerMessage       *msg,
 		       const char              *path,
-		       SoupClientContext       *client,
+		       SoupWebsocketConnection *connection,
 		       gpointer                 user_data)
 {
 	Test *test = user_data;
@@ -415,10 +415,12 @@ test_handshake (Test *test,
 }
 
 static void
-websocket_server_request_started (SoupServer *server, SoupMessage *msg,
-				  SoupClientContext *client, gpointer user_data)
+websocket_server_request_started (SoupServer        *server,
+				  SoupServerMessage *msg,
+				  gpointer           user_data)
 {
-	soup_message_headers_append (msg->response_headers, "Sec-WebSocket-Extensions", "x-foo");
+	soup_message_headers_append (soup_server_message_get_response_headers (msg),
+				     "Sec-WebSocket-Extensions", "x-foo");
 }
 
 static void
@@ -639,6 +641,11 @@ test_protocol_negotiate_direct (Test *test,
 				gconstpointer unused)
 {
 	SoupMessage *msg;
+	SoupServerMessage *server_msg;
+	SoupMessageHeaders *request_headers;
+	SoupMessageHeaders *response_headers;
+	SoupMessageHeadersIter iter;
+	const char *name, *value;
 	gboolean ok;
 	const char *protocol;
 	GError *error = NULL;
@@ -647,16 +654,28 @@ test_protocol_negotiate_direct (Test *test,
 	soup_websocket_client_prepare_handshake (msg, NULL,
 						 (char **) negotiate_client_protocols);
 
-	ok = soup_websocket_server_check_handshake (msg, NULL,
+	server_msg = g_object_new (SOUP_TYPE_SERVER_MESSAGE, NULL);
+	soup_server_message_set_method (server_msg, msg->method);
+	soup_server_message_set_uri (server_msg, soup_message_get_uri (msg));
+	request_headers = soup_server_message_get_request_headers (server_msg);
+	soup_message_headers_iter_init (&iter, msg->request_headers);
+	while (soup_message_headers_iter_next (&iter, &name, &value))
+		soup_message_headers_append (request_headers, name, value);
+	ok = soup_websocket_server_check_handshake (server_msg, NULL,
 						    (char **) negotiate_server_protocols,
 						    &error);
 	g_assert_no_error (error);
 	g_assert_true (ok);
 
-	ok = soup_websocket_server_process_handshake (msg, NULL,
+	ok = soup_websocket_server_process_handshake (server_msg, NULL,
 						      (char **) negotiate_server_protocols);
 	g_assert_true (ok);
 
+	msg->status_code = soup_server_message_get_status (server_msg, NULL);
+	response_headers = soup_server_message_get_response_headers (server_msg);
+	soup_message_headers_iter_init (&iter, response_headers);
+	while (soup_message_headers_iter_next (&iter, &name, &value))
+		soup_message_headers_append (msg->response_headers, name, value);
 	protocol = soup_message_headers_get_one (msg->response_headers, "Sec-WebSocket-Protocol");
 	g_assert_cmpstr (protocol, ==, negotiated_protocol);
 
@@ -665,6 +684,7 @@ test_protocol_negotiate_direct (Test *test,
 	g_assert_true (ok);
 
 	g_object_unref (msg);
+	g_object_unref (server_msg);
 }
 
 static void
@@ -689,6 +709,11 @@ test_protocol_mismatch_direct (Test *test,
 			       gconstpointer unused)
 {
 	SoupMessage *msg;
+	SoupServerMessage *server_msg;
+	SoupMessageHeaders *request_headers;
+	SoupMessageHeaders *response_headers;
+	SoupMessageHeadersIter iter;
+	const char *name, *value;
 	gboolean ok;
 	const char *protocol;
 	GError *error = NULL;
@@ -697,18 +722,30 @@ test_protocol_mismatch_direct (Test *test,
 	soup_websocket_client_prepare_handshake (msg, NULL,
 						 (char **) mismatch_client_protocols);
 
-	ok = soup_websocket_server_check_handshake (msg, NULL,
+	server_msg = g_object_new (SOUP_TYPE_SERVER_MESSAGE, NULL);
+	soup_server_message_set_method (server_msg, msg->method);
+	soup_server_message_set_uri (server_msg, soup_message_get_uri (msg));
+	request_headers = soup_server_message_get_request_headers (server_msg);
+	soup_message_headers_iter_init (&iter, msg->request_headers);
+	while (soup_message_headers_iter_next (&iter, &name, &value))
+		soup_message_headers_append (request_headers, name, value);
+	ok = soup_websocket_server_check_handshake (server_msg, NULL,
 						    (char **) mismatch_server_protocols,
 						    &error);
 	g_assert_error (error, SOUP_WEBSOCKET_ERROR, SOUP_WEBSOCKET_ERROR_BAD_HANDSHAKE);
 	g_clear_error (&error);
 	g_assert_false (ok);
 
-	ok = soup_websocket_server_process_handshake (msg, NULL,
+	ok = soup_websocket_server_process_handshake (server_msg, NULL,
 						      (char **) mismatch_server_protocols);
 	g_assert_false (ok);
+	msg->status_code = soup_server_message_get_status (server_msg, NULL);
 	soup_test_assert_message_status (msg, SOUP_STATUS_BAD_REQUEST);
 
+	response_headers = soup_server_message_get_response_headers (server_msg);
+	soup_message_headers_iter_init (&iter, response_headers);
+	while (soup_message_headers_iter_next (&iter, &name, &value))
+		soup_message_headers_append (msg->response_headers, name, value);
 	protocol = soup_message_headers_get_one (msg->response_headers, "Sec-WebSocket-Protocol");
 	g_assert_cmpstr (protocol, ==, NULL);
 
@@ -718,6 +755,7 @@ test_protocol_mismatch_direct (Test *test,
 	g_assert_false (ok);
 
 	g_object_unref (msg);
+	g_object_unref (server_msg);
 }
 
 static void
@@ -738,6 +776,11 @@ test_protocol_server_any_direct (Test *test,
 				 gconstpointer unused)
 {
 	SoupMessage *msg;
+	SoupServerMessage *server_msg;
+	SoupMessageHeaders *request_headers;
+	SoupMessageHeaders *response_headers;
+	SoupMessageHeadersIter iter;
+	const char *name, *value;
 	gboolean ok;
 	const char *protocol;
 	GError *error = NULL;
@@ -745,13 +788,25 @@ test_protocol_server_any_direct (Test *test,
 	msg = soup_message_new ("GET", "http://127.0.0.1");
 	soup_websocket_client_prepare_handshake (msg, NULL, (char **) all_protocols);
 
-	ok = soup_websocket_server_check_handshake (msg, NULL, NULL, &error);
+	server_msg = g_object_new (SOUP_TYPE_SERVER_MESSAGE, NULL);
+	soup_server_message_set_method (server_msg, msg->method);
+	soup_server_message_set_uri (server_msg, soup_message_get_uri (msg));
+	request_headers = soup_server_message_get_request_headers (server_msg);
+	soup_message_headers_iter_init (&iter, msg->request_headers);
+	while (soup_message_headers_iter_next (&iter, &name, &value))
+		soup_message_headers_append (request_headers, name, value);
+	ok = soup_websocket_server_check_handshake (server_msg, NULL, NULL, &error);
 	g_assert_no_error (error);
 	g_assert_true (ok);
 
-	ok = soup_websocket_server_process_handshake (msg, NULL, NULL);
+	ok = soup_websocket_server_process_handshake (server_msg, NULL, NULL);
 	g_assert_true (ok);
 
+	msg->status_code = soup_server_message_get_status (server_msg, NULL);
+	response_headers = soup_server_message_get_response_headers (server_msg);
+	soup_message_headers_iter_init (&iter, response_headers);
+	while (soup_message_headers_iter_next (&iter, &name, &value))
+		soup_message_headers_append (msg->response_headers, name, value);
 	protocol = soup_message_headers_get_one (msg->response_headers, "Sec-WebSocket-Protocol");
 	g_assert_cmpstr (protocol, ==, NULL);
 
@@ -760,6 +815,7 @@ test_protocol_server_any_direct (Test *test,
 	g_assert_true (ok);
 
 	g_object_unref (msg);
+	g_object_unref (server_msg);
 }
 
 static void
@@ -782,6 +838,11 @@ test_protocol_client_any_direct (Test *test,
 				 gconstpointer unused)
 {
 	SoupMessage *msg;
+	SoupServerMessage *server_msg;
+	SoupMessageHeaders *request_headers;
+	SoupMessageHeaders *response_headers;
+	SoupMessageHeadersIter iter;
+	const char *name, *value;
 	gboolean ok;
 	const char *protocol;
 	GError *error = NULL;
@@ -789,13 +850,25 @@ test_protocol_client_any_direct (Test *test,
 	msg = soup_message_new ("GET", "http://127.0.0.1");
 	soup_websocket_client_prepare_handshake (msg, NULL, NULL);
 
-	ok = soup_websocket_server_check_handshake (msg, NULL, (char **) all_protocols, &error);
+	server_msg = g_object_new (SOUP_TYPE_SERVER_MESSAGE, NULL);
+	soup_server_message_set_method (server_msg, msg->method);
+	soup_server_message_set_uri (server_msg, soup_message_get_uri (msg));
+	request_headers = soup_server_message_get_request_headers (server_msg);
+	soup_message_headers_iter_init (&iter, msg->request_headers);
+	while (soup_message_headers_iter_next (&iter, &name, &value))
+		soup_message_headers_append (request_headers, name, value);
+	ok = soup_websocket_server_check_handshake (server_msg, NULL, (char **) all_protocols, &error);
 	g_assert_no_error (error);
 	g_assert_true (ok);
 
-	ok = soup_websocket_server_process_handshake (msg, NULL, (char **) all_protocols);
+	ok = soup_websocket_server_process_handshake (server_msg, NULL, (char **) all_protocols);
 	g_assert_true (ok);
 
+	msg->status_code = soup_server_message_get_status (server_msg, NULL);
+	response_headers = soup_server_message_get_response_headers (server_msg);
+	soup_message_headers_iter_init (&iter, response_headers);
+	while (soup_message_headers_iter_next (&iter, &name, &value))
+		soup_message_headers_append (msg->response_headers, name, value);
 	protocol = soup_message_headers_get_one (msg->response_headers, "Sec-WebSocket-Protocol");
 	g_assert_cmpstr (protocol, ==, NULL);
 
@@ -804,6 +877,7 @@ test_protocol_client_any_direct (Test *test,
 	g_assert_true (ok);
 
 	g_object_unref (msg);
+	g_object_unref (server_msg);
 }
 
 static void
@@ -1431,9 +1505,9 @@ test_server_receive_unmasked_frame (Test *test,
 
 static void
 test_client_context_got_server_connection (SoupServer              *server,
-					   SoupWebsocketConnection *connection,
+					   SoupServerMessage       *msg,
 					   const char              *path,
-					   SoupClientContext       *client,
+					   SoupWebsocketConnection *connection,
 					   gpointer                 user_data)
 {
 	Test *test = user_data;
@@ -1442,7 +1516,7 @@ test_client_context_got_server_connection (SoupServer              *server,
 	char *str;
 	const char *remote_ip;
 
-	addr = soup_client_context_get_local_address (client);
+	addr = soup_server_message_get_local_address (msg);
 	iaddr = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (addr));
 	str = g_inet_address_to_string (iaddr);
 	if (g_inet_address_get_family (iaddr) == G_SOCKET_FAMILY_IPV4)
@@ -1451,7 +1525,7 @@ test_client_context_got_server_connection (SoupServer              *server,
 		g_assert_cmpstr (str, ==, "::1");
 	g_free (str);
 
-	addr = soup_client_context_get_remote_address (client);
+	addr = soup_server_message_get_remote_address (msg);
 	iaddr = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (addr));
 	str = g_inet_address_to_string (iaddr);
 	if (g_inet_address_get_family (iaddr) == G_SOCKET_FAMILY_IPV4)
@@ -1459,7 +1533,7 @@ test_client_context_got_server_connection (SoupServer              *server,
 	else
 		g_assert_cmpstr (str, ==, "::1");
 
-	remote_ip = soup_client_context_get_host (client);
+	remote_ip = soup_server_message_get_remote_host (msg);
 	g_assert_cmpstr (remote_ip, ==, str);
 	g_free (str);
 
@@ -1610,6 +1684,11 @@ test_deflate_negotiate_direct (Test *test,
 
 	for (i = 0; i < G_N_ELEMENTS (deflate_negotiate_tests); i++) {
 		SoupMessage *msg;
+		SoupServerMessage *server_msg;
+		SoupMessageHeaders *request_headers;
+		SoupMessageHeaders *response_headers;
+		SoupMessageHeadersIter iter;
+		const char *name, *value;
 		gboolean result;
 		GList *accepted_extensions = NULL;
 		GError *error = NULL;
@@ -1618,7 +1697,15 @@ test_deflate_negotiate_direct (Test *test,
 
 		soup_websocket_client_prepare_handshake (msg, NULL, NULL);
 		soup_message_headers_append (msg->request_headers, "Sec-WebSocket-Extensions", deflate_negotiate_tests[i].client_extension);
-		result = soup_websocket_server_check_handshake_with_extensions (msg, NULL, NULL,
+
+		server_msg = g_object_new (SOUP_TYPE_SERVER_MESSAGE, NULL);
+		soup_server_message_set_method (server_msg, msg->method);
+		soup_server_message_set_uri (server_msg, soup_message_get_uri (msg));
+		request_headers = soup_server_message_get_request_headers (server_msg);
+		soup_message_headers_iter_init (&iter, msg->request_headers);
+		while (soup_message_headers_iter_next (&iter, &name, &value))
+			soup_message_headers_append (request_headers, name, value);
+		result = soup_websocket_server_check_handshake_with_extensions (server_msg, NULL, NULL,
 										deflate_negotiate_tests[i].server_supports_extensions ?
 										supported_extensions : NULL,
 										&error);
@@ -1630,11 +1717,17 @@ test_deflate_negotiate_direct (Test *test,
 			g_clear_error (&error);
 		}
 
-		result = soup_websocket_server_process_handshake_with_extensions (msg, NULL, NULL,
+		result = soup_websocket_server_process_handshake_with_extensions (server_msg, NULL, NULL,
 										  deflate_negotiate_tests[i].server_supports_extensions ?
 										  supported_extensions : NULL,
 										  &accepted_extensions);
 		g_assert (result == deflate_negotiate_tests[i].expected_check_result);
+
+		msg->status_code = soup_server_message_get_status (server_msg, NULL);
+		response_headers = soup_server_message_get_response_headers (server_msg);
+		soup_message_headers_iter_init (&iter, response_headers);
+                while (soup_message_headers_iter_next (&iter, &name, &value))
+                        soup_message_headers_append (msg->response_headers, name, value);
 		if (deflate_negotiate_tests[i].expected_accepted_extension) {
 			const char *extension;
 
@@ -1668,6 +1761,7 @@ test_deflate_negotiate_direct (Test *test,
                 }
 
 		g_object_unref (msg);
+		g_object_unref (server_msg);
         }
 
 	g_ptr_array_unref (supported_extensions);
@@ -1678,6 +1772,11 @@ test_deflate_disabled_in_message_direct (Test *test,
 					 gconstpointer unused)
 {
 	SoupMessage *msg;
+	SoupServerMessage *server_msg;
+	SoupMessageHeaders *request_headers;
+	SoupMessageHeaders *response_headers;
+	SoupMessageHeadersIter iter;
+	const char *name, *value;
 	GPtrArray *supported_extensions;
 	GList *accepted_extensions = NULL;
 	GError *error = NULL;
@@ -1690,11 +1789,24 @@ test_deflate_disabled_in_message_direct (Test *test,
 	soup_websocket_client_prepare_handshake_with_extensions (msg, NULL, NULL, supported_extensions);
 	g_assert_cmpstr (soup_message_headers_get_one (msg->request_headers, "Sec-WebSocket-Extensions"), ==, NULL);
 
-	g_assert_true (soup_websocket_server_check_handshake_with_extensions (msg, NULL, NULL, supported_extensions, &error));
+	server_msg = g_object_new (SOUP_TYPE_SERVER_MESSAGE, NULL);
+	soup_server_message_set_method (server_msg, msg->method);
+	soup_server_message_set_uri (server_msg, soup_message_get_uri (msg));
+	request_headers = soup_server_message_get_request_headers (server_msg);
+	soup_message_headers_iter_init (&iter, msg->request_headers);
+	while (soup_message_headers_iter_next (&iter, &name, &value))
+		soup_message_headers_append (request_headers, name, value);
+
+	g_assert_true (soup_websocket_server_check_handshake_with_extensions (server_msg, NULL, NULL, supported_extensions, &error));
 	g_assert_no_error (error);
 
-	g_assert_true (soup_websocket_server_process_handshake_with_extensions (msg, NULL, NULL, supported_extensions, &accepted_extensions));
+	g_assert_true (soup_websocket_server_process_handshake_with_extensions (server_msg, NULL, NULL, supported_extensions, &accepted_extensions));
 	g_assert_null (accepted_extensions);
+	msg->status_code = soup_server_message_get_status (server_msg, NULL);
+	response_headers = soup_server_message_get_response_headers (server_msg);
+	soup_message_headers_iter_init (&iter, response_headers);
+	while (soup_message_headers_iter_next (&iter, &name, &value))
+		soup_message_headers_append (msg->response_headers, name, value);
 	g_assert_cmpstr (soup_message_headers_get_one (msg->response_headers, "Sec-WebSocket-Extensions"), ==, NULL);
 
 	g_assert_true (soup_websocket_client_verify_handshake_with_extensions (msg, supported_extensions, &accepted_extensions, &error));
@@ -1702,6 +1814,7 @@ test_deflate_disabled_in_message_direct (Test *test,
 	g_assert_null (accepted_extensions);
 
 	g_object_unref (msg);
+	g_object_unref (server_msg);
 	g_ptr_array_unref (supported_extensions);
 }
 
@@ -1828,10 +1941,12 @@ test_cookies_in_request (Test *test,
 }
 
 static void
-cookies_test_websocket_server_request_started (SoupServer *server, SoupMessage *msg,
-                                               SoupClientContext *client, gpointer user_data)
+cookies_test_websocket_server_request_started (SoupServer        *server,
+					       SoupServerMessage *msg,
+                                               gpointer           user_data)
 {
-        soup_message_headers_append (msg->response_headers, "Set-Cookie", "foo=bar; Path=/");
+        soup_message_headers_append (soup_server_message_get_response_headers (msg),
+				     "Set-Cookie", "foo=bar; Path=/");
 }
 
 static void