SoupServer: add exciting new APIs, deprecate musty old oneswip/server

FIXME: server-howto

1 files changed, 873 insertions, 167 deletions

diff --git a/libsoup/soup-server.c b/libsoup/soup-server.c
index 07d801d1..8afd7bdc 100644
--- a/libsoup/soup-server.c
+++ b/libsoup/soup-server.c
@@ -11,6 +11,8 @@
 
 #include <string.h>
 
+#include <glib/gi18n-lib.h>
+
 #include "soup-server.h"
 #include "soup.h"
 #include "soup-message-private.h"
@@ -44,16 +46,28 @@
  * Additional processing options are available via #SoupServer's
  * signals; Connect to #SoupServer::request-started to be notified
  * every time a new request is being processed. (This gives you a
- * chance to connect to the #SoupMessage "got-" signals in case you
- * want to do processing before the body has been fully read.)
+ * chance to connect to the #SoupMessage "<literal>got-</literal>"
+ * signals in case you want to do processing before the body has been
+ * fully read.)
  * 
- * Once the server is set up, start it processing connections by
- * calling soup_server_run_async() or soup_server_run(). #SoupServer
- * runs via the glib main loop; if you need to have a server that runs
- * in another thread (or merely isn't bound to the default main loop),
- * create a #GMainContext for it to use, and set that via the
- * #SOUP_SERVER_ASYNC_CONTEXT property.
- **/
+ * If you want to process https connections in addition to (or instead
+ * of) http connections, you can either set the
+ * %SOUP_SERVER_TLS_CERTIFICATE property when creating the server, or
+ * else call soup_server_set_ssl_certificate() after creating it.
+
+ * Once the server is set up, make one or more calls to
+ * soup_server_listen(), soup_server_listen_local(), or
+ * soup_server_listen_all() to tell it where to listen for
+ * connections. (All ports on a #SoupServer use the same handlers; if
+ * you need to handle some ports differently, such as returning
+ * different data for http and https, you'll need to create multiple
+ * #SoupServers, or else check the passed-in URI in the handler
+ * function.).
+ *
+ * #SoupServer will begin processing connections as soon as you return
+ * to (or start) the main loop for the current thread-default
+ * #GMainContext.
+ */
 
 G_DEFINE_TYPE (SoupServer, soup_server, G_TYPE_OBJECT)
 
@@ -74,6 +88,9 @@ struct SoupClientContext {
 	SoupAuthDomain *auth_domain;
 	char           *auth_user;
 
+	GSocketAddress *remote_addr;
+	GSocketAddress *local_addr;
+
 	int             ref_count;
 };
 
@@ -86,28 +103,30 @@ typedef struct {
 } SoupServerHandler;
 
 typedef struct {
-	SoupAddress       *iface;
-	guint              port;
+	GSList            *listeners;
+	GSList            *clients;
 
 	char              *ssl_cert_file, *ssl_key_file;
-	GTlsCertificate   *ssl_cert;
+	GTlsCertificate   *tls_cert;
 
 	char              *server_header;
 
+	GMainContext      *async_context;
 	GMainLoop         *loop;
 
-	SoupSocket        *listen_sock;
-	GSList            *clients;
-
 	gboolean           raw_paths;
 	SoupPathMap       *handlers;
 	SoupServerHandler *default_handler;
 	
 	GSList            *auth_domains;
 
-	GMainContext      *async_context;
-
 	char             **http_aliases, **https_aliases;
+
+	SoupAddress       *legacy_iface;
+	int                legacy_port;
+
+	gboolean           disposed;
+
 } SoupServerPrivate;
 #define SOUP_SERVER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_SERVER, SoupServerPrivate))
 
@@ -120,6 +139,8 @@ enum {
 	PROP_INTERFACE,
 	PROP_SSL_CERT_FILE,
 	PROP_SSL_KEY_FILE,
+	PROP_TLS_CERT_FILE,
+	PROP_TLS_KEY_FILE,
 	PROP_TLS_CERTIFICATE,
 	PROP_ASYNC_CONTEXT,
 	PROP_RAW_PATHS,
@@ -150,6 +171,20 @@ soup_server_init (SoupServer *server)
 	priv->http_aliases = g_new (char *, 2);
 	priv->http_aliases[0] = (char *)g_intern_string ("*");
 	priv->http_aliases[1] = NULL;
+
+	priv->legacy_port = -1;
+}
+
+static void
+soup_server_dispose (GObject *object)
+{
+	SoupServer *server = SOUP_SERVER (object);
+	SoupServerPrivate *priv = SOUP_SERVER_GET_PRIVATE (server);
+
+	priv->disposed = TRUE;
+	soup_server_disconnect (server);
+
+	G_OBJECT_CLASS (soup_server_parent_class)->finalize (object);
 }
 
 static void
@@ -158,16 +193,14 @@ soup_server_finalize (GObject *object)
 	SoupServer *server = SOUP_SERVER (object);
 	SoupServerPrivate *priv = SOUP_SERVER_GET_PRIVATE (server);
 
-	g_clear_object (&priv->iface);
+	g_clear_object (&priv->legacy_iface);
 
 	g_free (priv->ssl_cert_file);
 	g_free (priv->ssl_key_file);
-	g_clear_object (&priv->ssl_cert);
+	g_clear_object (&priv->tls_cert);
 
 	g_free (priv->server_header);
 
-	g_clear_object (&priv->listen_sock);
-
 	while (priv->clients) {
 		SoupClientContext *client = priv->clients->data;
 		SoupSocket *sock = g_object_ref (client->sock);
@@ -206,6 +239,34 @@ soup_server_finalize (GObject *object)
 	G_OBJECT_CLASS (soup_server_parent_class)->finalize (object);
 }
 
+static gboolean
+soup_server_ensure_listening (SoupServer *server)
+{
+	SoupServerPrivate *priv = SOUP_SERVER_GET_PRIVATE (server);
+	SoupSocket *listener;
+
+	if (priv->listeners)
+		return TRUE;
+
+	if (!priv->legacy_iface) {
+		priv->legacy_iface =
+			soup_address_new_any (SOUP_ADDRESS_FAMILY_IPV4,
+					      priv->legacy_port);
+	}
+
+	listener = soup_socket_new (SOUP_SOCKET_LOCAL_ADDRESS, priv->legacy_iface,
+				    SOUP_SOCKET_SSL_CREDENTIALS, priv->tls_cert,
+				    SOUP_SOCKET_ASYNC_CONTEXT, priv->async_context,
+				    NULL);
+	if (!soup_socket_listen (listener)) {
+		g_object_unref (listener);
+		return FALSE;
+	}
+
+	priv->listeners = g_slist_prepend (priv->listeners, listener);
+	return TRUE;
+}
+
 static GObject *
 soup_server_constructor (GType                  type,
 			 guint                  n_construct_properties,
@@ -213,6 +274,7 @@ soup_server_constructor (GType                  type,
 {
 	GObject *server;
 	SoupServerPrivate *priv;
+	gboolean legacy_port_set;
 
 	server = G_OBJECT_CLASS (soup_server_parent_class)->constructor (
 		type, n_construct_properties, construct_properties);
@@ -220,20 +282,19 @@ soup_server_constructor (GType                  type,
 		return NULL;
 	priv = SOUP_SERVER_GET_PRIVATE (server);
 
-	if (!priv->iface) {
-		priv->iface =
-			soup_address_new_any (SOUP_ADDRESS_FAMILY_IPV4,
-					      priv->port);
-	}
-
+	/* For backward compatibility, we have to process the
+	 * :ssl-cert-file, :ssl-key-file, :interface, and :port
+	 * properties now, and return NULL if they are
+	 * invalid/unsatisfiable.
+	 */
 	if (priv->ssl_cert_file && priv->ssl_key_file) {
 		GError *error = NULL;
 
-		if (priv->ssl_cert)
-			g_object_unref (priv->ssl_cert);
-		priv->ssl_cert = g_tls_certificate_new_from_files (priv->ssl_cert_file, priv->ssl_key_file, &error);
-		if (!priv->ssl_cert) {
-			g_warning ("Could not read SSL certificate from '%s': %s",
+		if (priv->tls_cert)
+			g_object_unref (priv->tls_cert);
+		priv->tls_cert = g_tls_certificate_new_from_files (priv->ssl_cert_file, priv->ssl_key_file, &error);
+		if (!priv->tls_cert) {
+			g_warning ("Could not read TLS certificate from '%s': %s",
 				   priv->ssl_cert_file, error->message);
 			g_error_free (error);
 			g_object_unref (server);
@@ -241,23 +302,33 @@ soup_server_constructor (GType                  type,
 		}
 	}
 
-	priv->listen_sock =
-		soup_socket_new (SOUP_SOCKET_LOCAL_ADDRESS, priv->iface,
-				 SOUP_SOCKET_SSL_CREDENTIALS, priv->ssl_cert,
-				 SOUP_SOCKET_ASYNC_CONTEXT, priv->async_context,
-				 NULL);
-	if (!soup_socket_listen (priv->listen_sock)) {
-		g_object_unref (server);
-		return NULL;
+	if (priv->legacy_port != -1)
+		legacy_port_set = TRUE;
+	else {
+		legacy_port_set = FALSE;
+		priv->legacy_port = 0;
 	}
 
-	/* Re-resolve the interface address, in particular in case
-	 * the passed-in address had SOUP_ADDRESS_ANY_PORT.
-	 */
-	g_object_unref (priv->iface);
-	priv->iface = soup_socket_get_local_address (priv->listen_sock);
-	g_object_ref (priv->iface);
-	priv->port = soup_address_get_port (priv->iface);
+	if (legacy_port_set || priv->legacy_iface) {
+		if (!soup_server_ensure_listening (SOUP_SERVER (server))) {
+			g_object_unref (server);
+			return NULL;
+		}
+	} else {
+		/* If neither port nor iface was specified, then
+		 * either: (a) the caller is planning to use the new
+		 * listen APIs, so we don't have to do anything now,
+		 * or (b) the caller is using the legacy APIs but
+		 * wants the default values for interface and port
+		 * (address 0.0.0.0, port 0), in which case a later
+		 * call to soup_server_ensure_listening() will set it
+		 * up just-in-time; we don't have to worry about it
+		 * failing in that case, because it can't (unless you
+		 * have no IPv4 addresses configured [even localhost],
+		 * or there are already listeners on all 65,535 ports.
+		 * We assume neither of these will happen.)
+		 */
+	}
 
 	return server;
 }
@@ -294,27 +365,28 @@ soup_server_set_property (GObject *object, guint prop_id,
 
 	switch (prop_id) {
 	case PROP_PORT:
-		priv->port = g_value_get_uint (value);
+		if (g_value_get_uint (value) != 0)
+			priv->legacy_port = g_value_get_uint (value);
 		break;
 	case PROP_INTERFACE:
-		if (priv->iface)
-			g_object_unref (priv->iface);
-		priv->iface = g_value_get_object (value);
-		if (priv->iface)
-			g_object_ref (priv->iface);
+		if (priv->legacy_iface)
+			g_object_unref (priv->legacy_iface);
+		priv->legacy_iface = g_value_get_object (value);
+		if (priv->legacy_iface)
+			g_object_ref (priv->legacy_iface);
 		break;
 	case PROP_SSL_CERT_FILE:
-		priv->ssl_cert_file =
-			g_strdup (g_value_get_string (value));
+		g_free (priv->ssl_cert_file);
+		priv->ssl_cert_file = g_value_dup_string (value);
 		break;
 	case PROP_SSL_KEY_FILE:
-		priv->ssl_key_file =
-			g_strdup (g_value_get_string (value));
+		g_free (priv->ssl_key_file);
+		priv->ssl_key_file = g_value_dup_string (value);
 		break;
 	case PROP_TLS_CERTIFICATE:
-		if (priv->ssl_cert)
-			g_object_unref (priv->ssl_cert);
-		priv->ssl_cert = g_value_dup_object (value);
+		if (priv->tls_cert)
+			g_object_unref (priv->tls_cert);
+		priv->tls_cert = g_value_dup_object (value);
 		break;
 	case PROP_ASYNC_CONTEXT:
 		priv->async_context = g_value_get_pointer (value);
@@ -355,14 +427,17 @@ static void
 soup_server_get_property (GObject *object, guint prop_id,
 			  GValue *value, GParamSpec *pspec)
 {
-	SoupServerPrivate *priv = SOUP_SERVER_GET_PRIVATE (object);
+	SoupServer *server = SOUP_SERVER (object);
+	SoupServerPrivate *priv = SOUP_SERVER_GET_PRIVATE (server);
 
 	switch (prop_id) {
 	case PROP_PORT:
-		g_value_set_uint (value, priv->port);
+		soup_server_ensure_listening (server);
+		g_value_set_uint (value, priv->legacy_port > 0 ? priv->legacy_port : 0);
 		break;
 	case PROP_INTERFACE:
-		g_value_set_object (value, priv->iface);
+		soup_server_ensure_listening (server);
+		g_value_set_object (value, priv->legacy_iface);
 		break;
 	case PROP_SSL_CERT_FILE:
 		g_value_set_string (value, priv->ssl_cert_file);
@@ -371,7 +446,7 @@ soup_server_get_property (GObject *object, guint prop_id,
 		g_value_set_string (value, priv->ssl_key_file);
 		break;
 	case PROP_TLS_CERTIFICATE:
-		g_value_set_object (value, priv->ssl_cert);
+		g_value_set_object (value, priv->tls_cert);
 		break;
 	case PROP_ASYNC_CONTEXT:
 		g_value_set_pointer (value, priv->async_context ? g_main_context_ref (priv->async_context) : NULL);
@@ -403,6 +478,7 @@ soup_server_class_init (SoupServerClass *server_class)
 
 	/* virtual method override */
 	object_class->constructor = soup_server_constructor;
+	object_class->dispose = soup_server_dispose;
 	object_class->finalize = soup_server_finalize;
 	object_class->set_property = soup_server_set_property;
 	object_class->get_property = soup_server_get_property;
@@ -514,92 +590,143 @@ soup_server_class_init (SoupServerClass *server_class)
 
 	/* properties */
 	/**
+	 * SoupServer:port:
+	 *
+	 * The port the server is listening on, if you are using the
+	 * old #SoupServer API. (This will not be set if you use
+	 * soup_server_listen(), etc.)
+	 *
+	 * Deprecated: #SoupServers can listen on multiple interfaces
+	 * at once now. Use soup_server_listen(), etc, to listen on a
+	 * port, and soup_server_get_uris() to see what ports are
+	 * being listened on.
+	 */
+	/**
 	 * SOUP_SERVER_PORT:
 	 *
-	 * Alias for the #SoupServer:port property. (The port the
-	 * server listens on.)
+	 * Alias for the deprecated #SoupServer:port property, qv.
+	 *
+	 * Deprecated: #SoupServers can listen on multiple interfaces
+	 * at once now. Use soup_server_listen(), etc, to listen on a
+	 * port, and soup_server_get_uris() to see what ports are
+	 * being listened on.
 	 **/
 	g_object_class_install_property (
 		object_class, PROP_PORT,
 		g_param_spec_uint (SOUP_SERVER_PORT,
 				   "Port",
-				   "Port to listen on",
+				   "Port to listen on (Deprecated)",
 				   0, 65536, 0,
-				   G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
+				   G_PARAM_READWRITE |
+				   G_PARAM_CONSTRUCT_ONLY |
+				   G_PARAM_DEPRECATED));
+	/**
+	 * SoupServer:interface:
+	 *
+	 * The address of the network interface the server is
+	 * listening on, if you are using the old #SoupServer API.
+	 * (This will not be set if you use soup_server_listen(),
+	 * etc.)
+	 *
+	 * Deprecated: #SoupServers can listen on multiple interfaces
+	 * at once now. Use soup_server_listen(), etc, to listen on an
+	 * interface, and soup_server_get_uris() to see what addresses
+	 * are being listened on.
+	 */
 	/**
 	 * SOUP_SERVER_INTERFACE:
 	 *
-	 * Alias for the #SoupServer:interface property. (The address
-	 * of the network interface the server listens on.)
+	 * Alias for the #SoupServer:interface property, qv.
+	 *
+	 * Deprecated: #SoupServers can listen on multiple interfaces
+	 * at once now. Use soup_server_listen(), etc, to listen on an
+	 * interface, and soup_server_get_uris() to see what addresses
+	 * are being listened on.
 	 **/
 	g_object_class_install_property (
 		object_class, PROP_INTERFACE,
 		g_param_spec_object (SOUP_SERVER_INTERFACE,
 				     "Interface",
-				     "Address of interface to listen on",
+				     "Address of interface to listen on (Deprecated)",
 				     SOUP_TYPE_ADDRESS,
-				     G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
+				     G_PARAM_READWRITE |
+				     G_PARAM_CONSTRUCT_ONLY |
+				     G_PARAM_DEPRECATED));
 	/**
 	 * SOUP_SERVER_SSL_CERT_FILE:
 	 *
 	 * Alias for the #SoupServer:ssl-cert-file property, qv.
+	 *
+	 * Deprecated: use #SoupServer:tls-certificate or
+	 * soup_server_set_ssl_certificate().
 	 */
 	/**
 	 * SoupServer:ssl-cert-file:
 	 *
-	 * Path to a file containing a PEM-encoded certificate. If
-	 * this and #SoupServer:ssl-key-file are both set, then the
-	 * server will speak https rather than plain http.
+	 * Path to a file containing a PEM-encoded certificate.
 	 *
-	 * Alternatively, you can use #SoupServer:tls-certificate
-	 * to provide an arbitrary #GTlsCertificate.
+	 * If you set this property and #SoupServer:ssl-key-file at
+	 * construct time, then soup_server_new() will try to read the
+	 * files; if it cannot, it will return %NULL, with no explicit
+	 * indication of what went wrong (and logging a warning with
+	 * newer versions of glib, since returning %NULL from a
+	 * constructor is illegal).
+	 *
+	 * Deprecated: use #SoupServer:tls-certificate or
+	 * soup_server_set_ssl_certificate().
 	 */
 	g_object_class_install_property (
 		object_class, PROP_SSL_CERT_FILE,
 		g_param_spec_string (SOUP_SERVER_SSL_CERT_FILE,
-				     "SSL certificate file",
-				     "File containing server SSL certificate",
+				     "TLS (aka SSL) certificate file",
+				     "File containing server TLS (aka SSL) certificate",
 				     NULL,
-				     G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
+				     G_PARAM_READWRITE |
+				     G_PARAM_CONSTRUCT_ONLY));
 	/**
 	 * SOUP_SERVER_SSL_KEY_FILE:
 	 *
 	 * Alias for the #SoupServer:ssl-key-file property, qv.
+	 *
+	 * Deprecated: use #SoupServer:tls-certificate or
+	 * soup_server_set_ssl_certificate().
 	 */
 	/**
 	 * SoupServer:ssl-key-file:
 	 *
-	 * Path to a file containing a PEM-encoded private key. If
-	 * this and #SoupServer:ssl-key-file are both set, then the
-	 * server will speak https rather than plain http. Note that
-	 * you are allowed to set them to the same value, if you have
-	 * a single file containing both the certificate and the key.
+	 * Path to a file containing a PEM-encoded private key. See
+	 * #SoupServer:ssl-cert-file for more information about how this
+	 * is used.
 	 *
-	 * Alternatively, you can use #SoupServer:tls-certificate
-	 * to provide an arbitrary #GTlsCertificate.
+	 * Deprecated: use #SoupServer:tls-certificate or
+	 * soup_server_set_ssl_certificate().
 	 */
 	g_object_class_install_property (
 		object_class, PROP_SSL_KEY_FILE,
 		g_param_spec_string (SOUP_SERVER_SSL_KEY_FILE,
-				     "SSL key file",
-				     "File containing server SSL key",
+				     "TLS (aka SSL) key file",
+				     "File containing server TLS (aka SSL) key",
 				     NULL,
-				     G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
+				     G_PARAM_READWRITE |
+				     G_PARAM_CONSTRUCT_ONLY));
 	/**
 	 * SOUP_SERVER_TLS_CERTIFICATE:
 	 *
 	 * Alias for the #SoupServer:tls-certificate property, qv.
+	 *
+	 * Since: 2.38
 	 */
 	/**
 	 * SoupServer:tls-certificate:
 	 *
 	 * A #GTlsCertificate that has a #GTlsCertificate:private-key
-	 * set. If this is set, then the server will speak https
-	 * rather than plain http.
+	 * set. If this is set, then the server will be able to speak
+	 * https in addition to (or instead of) plain http.
 	 *
-	 * Alternatively, you can use #SoupServer:ssl-cert-file and
-	 * #SoupServer:ssl-key-file properties, to have #SoupServer
-	 * read in a a certificate from a file.
+	 * Alternatively, you can call soup_server_set_ssl_cert_file()
+	 * to have #SoupServer read in a a certificate from a file.
+	 *
+	 * Since: 2.38
 	 */
 	g_object_class_install_property (
 		object_class, PROP_TLS_CERTIFICATE,
@@ -609,17 +736,33 @@ soup_server_class_init (SoupServerClass *server_class)
 				     G_TYPE_TLS_CERTIFICATE,
 				     G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 	/**
+	 * SoupServer:async-context:
+	 *
+	 * The server's #GMainContext, if you are using the old API.
+	 * Servers created using soup_server_listen() will listen on
+	 * the #GMainContext that was the thread-default context at
+	 * the time soup_server_listen() was called.
+	 *
+	 * Deprecated: The new API uses the thread-default #GMainContext
+	 * rather than having an explicitly-specified one.
+	 */
+	/**
 	 * SOUP_SERVER_ASYNC_CONTEXT:
 	 *
-	 * Alias for the #SoupServer:async-context property. (The
-	 * server's #GMainContext.)
+	 * Alias for the deprecated #SoupServer:async-context
+	 * property, qv.
+	 *
+	 * Deprecated: The new API uses the thread-default #GMainContext
+	 * rather than having an explicitly-specified one.
 	 **/
 	g_object_class_install_property (
 		object_class, PROP_ASYNC_CONTEXT,
 		g_param_spec_pointer (SOUP_SERVER_ASYNC_CONTEXT,
 				      "Async GMainContext",
 				      "The GMainContext to dispatch async I/O in",
-				      G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
+				      G_PARAM_READWRITE |
+				      G_PARAM_CONSTRUCT_ONLY |
+				      G_PARAM_DEPRECATED));
 	/**
 	 * SOUP_SERVER_RAW_PATHS:
 	 *
@@ -744,9 +887,11 @@ soup_server_class_init (SoupServerClass *server_class)
  * @optname1: name of first property to set
  * @...: value of @optname1, followed by additional property/value pairs
  *
- * Creates a new #SoupServer.
+ * Creates a new #SoupServer. This is exactly equivalent to calling
+ * g_object_new() and specifying %SOUP_TYPE_SERVER as the type.
  *
- * Return value: a new #SoupServer
+ * Return value: a new #SoupServer. If you are using certain legacy
+ * properties, this may also return %NULL if an error occurs.
  **/
 SoupServer *
 soup_server_new (const char *optname1, ...)
@@ -766,32 +911,86 @@ soup_server_new (const char *optname1, ...)
  * soup_server_get_port:
  * @server: a #SoupServer
  *
- * Gets the TCP port that @server is listening on. This is most useful
- * when you did not request a specific port (or explicitly requested
- * %SOUP_ADDRESS_ANY_PORT).
+ * Gets the TCP port that @server is listening on, if you are using
+ * the old API.
  *
  * Return value: the port @server is listening on.
+ *
+ * Deprecated: If you are using soup_server_listen(), etc, then use
+ * soup_server_get_uris() to get a list of all listening addresses.
  **/
 guint
 soup_server_get_port (SoupServer *server)
 {
+	SoupServerPrivate *priv;
+
 	g_return_val_if_fail (SOUP_IS_SERVER (server), 0);
+	priv = SOUP_SERVER_GET_PRIVATE (server);
+
+	soup_server_ensure_listening (server);
+	g_return_val_if_fail (priv->legacy_iface != NULL, 0);
+
+	return priv->legacy_port;
+}
+
+/**
+ * soup_server_set_ssl_cert_file:
+ * @server: a #SoupServer
+ * @ssl_cert_file: path to a file containing a PEM-encoded SSL/TLS
+ *   certificate.
+ * @ssl_key_file: path to a file containing a PEM-encoded private key.
+ * @error: return location for a #GError
+ *
+ * Sets @server up to do https, using the SSL/TLS certificate
+ * specified by @ssl_cert_file and @ssl_key_file (which may point to
+ * the same file).
+ *
+ * Alternatively, you can set the #SoupServer:tls-certificate property
+ * at construction time, if you already have a #GTlsCertificate.
+ *
+ * Return value: success or failure.
+ *
+ * Since: 2.46
+ */
+gboolean
+soup_server_set_ssl_cert_file  (SoupServer  *server,
+				const char  *ssl_cert_file,
+				const char  *ssl_key_file,
+				GError     **error)
+{
+	SoupServerPrivate *priv;
+
+	g_return_val_if_fail (SOUP_IS_SERVER (server), FALSE);
+	priv = SOUP_SERVER_GET_PRIVATE (server);
 
-	return SOUP_SERVER_GET_PRIVATE (server)->port;
+	if (priv->tls_cert)
+		g_object_unref (priv->tls_cert);
+	priv->tls_cert = g_tls_certificate_new_from_files (priv->ssl_cert_file,
+							   priv->ssl_key_file,
+							   error);
+	return priv->tls_cert != NULL;
 }
 
 /**
  * soup_server_is_https:
  * @server: a #SoupServer
  *
- * Checks whether @server is running plain http or https.
+ * Checks whether @server is capable of https.
  *
- * In order for a server to run https, you must set the
- * %SOUP_SERVER_SSL_CERT_FILE and %SOUP_SERVER_SSL_KEY_FILE properties
- * or %SOUP_SERVER_TLS_CERTIFICATE property to provide it with an SSL
+ * In order for a server to run https, you must call
+ * soup_server_set_ssl_cert_file(), or set the
+ * #SoupServer:tls-certificate property, to provide it with a
  * certificate to use.
  *
- * Return value: %TRUE if @server is serving https.
+ * If you are using the deprecated single-listener APIs, then a return
+ * value of %TRUE indicates that the #SoupServer serves https
+ * exclusively. If you are using soup_server_listen(), etc, then a
+ * %TRUE return value merely indicates that the server is
+ * <emphasis>able</emphasis> to do https, regardless of whether it
+ * actually currently is or not. Use soup_server_get_uris() to see if
+ * it currently has any https listeners.
+ *
+ * Return value: %TRUE if @server is configured to serve https.
  **/
 gboolean
 soup_server_is_https (SoupServer *server)
@@ -801,18 +1000,23 @@ soup_server_is_https (SoupServer *server)
 	g_return_val_if_fail (SOUP_IS_SERVER (server), 0);
 	priv = SOUP_SERVER_GET_PRIVATE (server);
 
-	return priv->ssl_cert != NULL;
+	return priv->tls_cert != NULL;
 }
 
 /**
  * soup_server_get_listener:
  * @server: a #SoupServer
  *
- * Gets @server's listening socket. You should treat this as
- * read-only; writing to it or modifiying it may cause @server to
- * malfunction.
+ * Gets @server's listening socket, if you are using the old API.
+ *
+ * You should treat this socket as read-only; writing to it or
+ * modifiying it may cause @server to malfunction.
  *
  * Return value: (transfer none): the listening socket.
+ *
+ * Deprecated: If you are using soup_server_listen(), etc, then use
+ * soup_server_get_listeners() to get a list of all listening sockets,
+ * but note that that function returns #GSockets, not #SoupSockets.
  **/
 SoupSocket *
 soup_server_get_listener (SoupServer *server)
@@ -822,7 +1026,45 @@ soup_server_get_listener (SoupServer *server)
 	g_return_val_if_fail (SOUP_IS_SERVER (server), NULL);
 	priv = SOUP_SERVER_GET_PRIVATE (server);
 
-	return priv->listen_sock;
+	soup_server_ensure_listening (server);
+	g_return_val_if_fail (priv->legacy_iface != NULL, NULL);
+
+	return priv->listeners ? priv->listeners->data : NULL;
+}
+
+/**
+ * soup_server_get_listeners:
+ * @server: a #SoupServer
+ *
+ * Gets @server's list of listening sockets.
+ *
+ * You should treat these sockets as read-only; writing to or
+ * modifiying any of these sockets may cause @server to malfunction.
+ *
+ * (Beware that in contrast to the old soup_server_get_listener(), this
+ * function returns #GSockets, not #SoupSockets.)
+ *
+ * Return value: (transfer container) (element-type Gio.Socket): a
+ * list of listening sockets.
+ **/
+GSList *
+soup_server_get_listeners (SoupServer *server)
+{
+	SoupServerPrivate *priv;
+	GSList *listeners, *iter;
+
+	g_return_val_if_fail (SOUP_IS_SERVER (server), NULL);
+	priv = SOUP_SERVER_GET_PRIVATE (server);
+
+	listeners = NULL;
+	for (iter = priv->listeners; iter; iter = iter->next)
+		listeners = g_slist_prepend (listeners, soup_socket_get_gsocket (iter->data));
+
+	/* priv->listeners has the sockets in reverse order from how
+	 * they were added, so listeners now has them back in the
+	 * original order.
+	 */
+	return listeners;
 }
 
 static void start_request (SoupServer *, SoupClientContext *);
@@ -842,14 +1084,11 @@ soup_client_context_new (SoupServer *server, SoupSocket *sock)
 static void
 soup_client_context_cleanup (SoupClientContext *client)
 {
-	if (client->auth_domain) {
-		g_object_unref (client->auth_domain);
-		client->auth_domain = NULL;
-	}
-	if (client->auth_user) {
-		g_free (client->auth_user);
-		client->auth_user = NULL;
-	}
+	g_clear_object (&client->auth_domain);
+	g_clear_pointer (&client->auth_user, g_free);
+	g_clear_object (&client->remote_addr);
+	g_clear_object (&client->local_addr);
+
 	client->msg = NULL;
 }
 
@@ -927,8 +1166,8 @@ got_headers (SoupMessage *msg, SoupClientContext *client)
 	char *auth_user;
 
 	uri = soup_message_get_uri (msg);
-	if ((soup_server_is_https (server) && !soup_uri_is_https (uri, priv->https_aliases)) ||
-	    (!soup_server_is_https (server) && !soup_uri_is_http (uri, priv->http_aliases))) {
+	if ((soup_socket_is_ssl (client->sock) && !soup_uri_is_https (uri, priv->https_aliases)) ||
+	    (!soup_socket_is_ssl (client->sock) && !soup_uri_is_http (uri, priv->http_aliases))) {
 		soup_message_set_status (msg, SOUP_STATUS_BAD_REQUEST);
 		return;
 	}
@@ -1054,12 +1293,9 @@ start_request (SoupServer *server, SoupClientContext *client)
 
 	g_object_ref (client->sock);
 
-	if (priv->async_context)
-		g_main_context_push_thread_default (priv->async_context);
 	soup_message_read_request (msg, client->sock,
+				   priv->legacy_iface == NULL,
 				   request_finished, client);
-	if (priv->async_context)
-		g_main_context_pop_thread_default (priv->async_context);
 }
 
 static void
@@ -1073,7 +1309,7 @@ socket_disconnected (SoupSocket *sock, SoupClientContext *client)
 }
 
 static void
-new_connection (SoupSocket *listner, SoupSocket *sock, gpointer user_data)
+new_connection (SoupSocket *listener, SoupSocket *sock, gpointer user_data)
 {
 	SoupServer *server = user_data;
 	SoupServerPrivate *priv = SOUP_SERVER_GET_PRIVATE (server);
@@ -1090,24 +1326,33 @@ new_connection (SoupSocket *listner, SoupSocket *sock, gpointer user_data)
  * soup_server_run_async:
  * @server: a #SoupServer
  *
- * Starts @server, causing it to listen for and process incoming
- * connections.
+ * Starts @server, if you are using the old API, causing it to listen
+ * for and process incoming connections.
  *
- * The server actually runs in @server's #GMainContext. It will not
- * actually perform any processing unless the appropriate main loop is
- * running. In the simple case where you did not set the server's
+ * The server runs in @server's #GMainContext. It will not actually
+ * perform any processing unless the appropriate main loop is running.
+ * In the simple case where you did not set the server's
  * %SOUP_SERVER_ASYNC_CONTEXT property, this means the server will run
  * whenever the glib main loop is running.
+ *
+ * Deprecated: When using soup_server_listen(), etc, the server will
+ * always listen for connections, and will process them whenever the
+ * thread-default #GMainContext is running.
  **/
 void
 soup_server_run_async (SoupServer *server)
 {
 	SoupServerPrivate *priv;
+	SoupSocket *listener;
 
 	g_return_if_fail (SOUP_IS_SERVER (server));
 	priv = SOUP_SERVER_GET_PRIVATE (server);
 
-	if (!priv->listen_sock) {
+	soup_server_ensure_listening (server);
+
+	g_return_if_fail (priv->legacy_iface != NULL);
+
+	if (!priv->listeners) {
 		if (priv->loop) {
 			g_main_loop_unref (priv->loop);
 			priv->loop = NULL;
@@ -1115,21 +1360,26 @@ soup_server_run_async (SoupServer *server)
 		return;
 	}
 
-	g_signal_connect (priv->listen_sock, "new_connection",
+	listener = priv->listeners->data;
+	g_signal_connect (listener, "new_connection",
 			  G_CALLBACK (new_connection), server);
 
 	return;
-
 }
 
 /**
  * soup_server_run:
  * @server: a #SoupServer
  *
- * Starts @server, causing it to listen for and process incoming
- * connections. Unlike soup_server_run_async(), this creates a
- * #GMainLoop and runs it, and it will not return until someone calls
- * soup_server_quit() to stop the server.
+ * Starts @server, if you are using the old API, causing it to listen
+ * for and process incoming connections. Unlike
+ * soup_server_run_async(), this creates a #GMainLoop and runs it, and
+ * it will not return until someone calls soup_server_quit() to stop
+ * the server.
+ *
+ * Deprecated: When using soup_server_listen(), etc, the server will
+ * always listen for connections, and will process them whenever the
+ * thread-default #GMainContext is running.
  **/
 void
 soup_server_run (SoupServer *server)
@@ -1141,7 +1391,9 @@ soup_server_run (SoupServer *server)
 
 	if (!priv->loop) {
 		priv->loop = g_main_loop_new (priv->async_context, TRUE);
+		G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
 		soup_server_run_async (server);
+		G_GNUC_END_IGNORE_DEPRECATIONS;
 	}
 
 	if (priv->loop)
@@ -1152,21 +1404,34 @@ soup_server_run (SoupServer *server)
  * soup_server_quit:
  * @server: a #SoupServer
  *
- * Stops processing for @server. Call this to clean up after
- * soup_server_run_async(), or to terminate a call to soup_server_run().
+ * Stops processing for @server, if you are using the old API. Call
+ * this to clean up after soup_server_run_async(), or to terminate a
+ * call to soup_server_run().
+ *
+ * Note that messages currently in progress will continue to be
+ * handled, if the main loop associated with the server is resumed or
+ * kept running.
  *
  * @server is still in a working state after this call; you can start
  * and stop a server as many times as you want.
+ *
+ * Deprecated: When using soup_server_listen(), etc, the server will
+ * always listen for connections, and will process them whenever the
+ * thread-default #GMainContext is running.
  **/
 void
 soup_server_quit (SoupServer *server)
 {
 	SoupServerPrivate *priv;
+	SoupSocket *listener;
 
 	g_return_if_fail (SOUP_IS_SERVER (server));
 	priv = SOUP_SERVER_GET_PRIVATE (server);
+	g_return_if_fail (priv->legacy_iface != NULL);
+	g_return_if_fail (priv->listeners != NULL);
 
-	g_signal_handlers_disconnect_by_func (priv->listen_sock,
+	listener = priv->listeners->data;
+	g_signal_handlers_disconnect_by_func (listener,
 					      G_CALLBACK (new_connection),
 					      server);
 	if (priv->loop)
@@ -1177,43 +1442,408 @@ soup_server_quit (SoupServer *server)
  * soup_server_disconnect:
  * @server: a #SoupServer
  *
- * Stops processing for @server and closes its socket. This implies
- * the effects of soup_server_quit(), but additionally closes the
- * listening socket.  Note that messages currently in progress will
- * continue to be handled, if the main loop associated with the
- * server is resumed or kept running.
+ * Closes and frees @server's listening sockets. If you are using the
+ * old #SoupServer APIs, this also includes the effect of
+ * soup_server_quit().
  *
- * After calling this function, @server is no longer functional, so it
- * has nearly the same effect as destroying @server entirely. The
- * function is thus useful mainly for language bindings without
- * explicit control over object lifetime.
+ * Note that if there are currently requests in progress on @server,
+ * that they will continue to be processed if @server's #GMainContext
+ * is still running.
+ *
+ * You can call soup_server_listen(), etc, after calling this function
+ * if you want to start listening again.
  **/
 void
 soup_server_disconnect (SoupServer *server)
 {
 	SoupServerPrivate *priv;
+	GSList *listeners, *iter;
+	SoupSocket *listener;
 
 	g_return_if_fail (SOUP_IS_SERVER (server));
 	priv = SOUP_SERVER_GET_PRIVATE (server);
 
-	soup_server_quit (server);
+	if (priv->legacy_iface) {
+		G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
+		soup_server_quit (server);
+		G_GNUC_END_IGNORE_DEPRECATIONS;
+	}
 
-	if (priv->listen_sock) {
-		soup_socket_disconnect (priv->listen_sock);
-		g_object_unref (priv->listen_sock);
-		priv->listen_sock = NULL;
+	listeners = priv->listeners;
+	priv->listeners = NULL;
+	for (iter = listeners; iter; iter = iter->next) {
+		listener = iter->data;
+		soup_socket_disconnect (listener);
+		g_object_unref (listener);
 	}
+	g_slist_free (listeners);
+}
+
+static gboolean 
+soup_server_listen_ipv4_ipv6 (SoupServer *server,
+			      GInetAddress *iaddr4,
+			      GInetAddress *iaddr6,
+			      guint port,
+			      SoupServerListenOptions options,
+			      GError **error)
+{
+	SoupServerPrivate *priv = SOUP_SERVER_GET_PRIVATE (server);
+	GSocketAddress *addr4, *addr6;
+	GError *my_error = NULL;
+	SoupSocket *v4sock;
+	guint v4port;
+
+	options &= ~(SOUP_SERVER_LISTEN_IPV4_ONLY | SOUP_SERVER_LISTEN_IPV6_ONLY);
+
+	if (iaddr4) {
+		addr4 = g_inet_socket_address_new (iaddr4, port);
+		if (!soup_server_listen (server, addr4, options, error)) {
+			g_object_unref (addr4);
+			return FALSE;
+		}
+		g_object_unref (addr4);
+
+		v4sock = priv->listeners->data;
+		v4port = soup_address_get_port (soup_socket_get_local_address (v4sock));
+	} else {
+		v4sock = NULL;
+		v4port = port;
+	}
+
+	if (iaddr6) {
+		addr6 = g_inet_socket_address_new (iaddr6, v4port);
+		if (soup_server_listen (server, addr6, options, &my_error)) {
+			g_object_unref (addr6);
+			return TRUE;
+		}
+		g_object_unref (addr6);
+
+		/* FIXME: this isn't right. Need to translate EAFNOSUPPORT */
+		if (!g_error_matches (my_error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED)) {
+			g_propagate_error (error, my_error);
+
+			/* Close the IPv4 socket if IPv6 failed */
+			if (v4sock) {
+				priv->listeners = g_slist_remove (priv->listeners, v4sock);
+				soup_socket_disconnect (v4sock);
+				g_object_unref (v4sock);
+			}
+
+			return FALSE;
+		}
+
+		g_error_free (my_error);
+	}
+
+	return TRUE;
+}
+
+/**
+ * SoupServerListenOptions:
+ * @SOUP_SERVER_LISTEN_HTTPS: Listen for https connections rather
+ *   than plain http.
+ * @SOUP_SERVER_LISTEN_IPV4_ONLY: Only listen on IPv4 interfaces.
+ * @SOUP_SERVER_LISTEN_IPV6_ONLY: Only listen on IPv6 interfaces.
+ *
+ * Options to pass to soup_server_listen(), etc.
+ *
+ * %SOUP_SERVER_LISTEN_IPV4_ONLY and %SOUP_SERVER_LISTEN_IPV6_ONLY
+ * only make sense with soup_server_listen_all() and
+ * soup_server_listen_local(), not plain soup_server_listen() (which
+ * simply listens on whatever kind of socket you give it). And you
+ * cannot specify both of them in a single call.
+ *
+ * Since: 2.46
+ */
+
+/**
+ * soup_server_listen_all:
+ * @server: a #SoupServer
+ * @port: the port to listen on, or 0
+ * @options: listening options for this server
+ * @error: return location for a #GError
+ *
+ * This attempts to set up @server to listen for connections on all
+ * interfaces on the system. (That is, it listens on the addresses
+ * <literal>0.0.0.0</literal> and/or <literal>::</literal>, depending
+ * on whether @options includes %SOUP_SERVER_LISTEN_IPV4_ONLY,
+ * %SOUP_SERVER_LISTEN_IPV6_ONLY, or neither.) If @port is specified,
+ * @server will listen on that port. If it is 0, @server will find an
+ * unused port to listen on. (In that case, you can use
+ * soup_server_get_uris() to find out what port it ended up choosing.)
+ *
+ * If @options includes %SOUP_SERVER_LISTEN_HTTPS, and @server has
+ * been configured for TLS, then @server will listen for https
+ * connections on these ports. Otherwise it will listen for plain
+ * http.
+ *
+ * You may call this method (along with soup_server_listen_local() and
+ * soup_server_listen()) any number of times on a server, if you want
+ * to listen on multiple ports, or set up both http and https service.
+ *
+ * After calling this method, @server will begin accepting and
+ * processing connections as soon as the appropriate #GMainContext is
+ * run.
+ *
+ * Return value: %TRUE on success, %FALSE if @port could not be bound
+ * or any other error occurred (in which case @error will be set).
+ *
+ * Since: 2.46
+ **/
+gboolean 
+soup_server_listen_all (SoupServer *server, guint port,
+			SoupServerListenOptions options,
+			GError **error)
+{
+	GInetAddress *iaddr4, *iaddr6;
+	gboolean success;
+
+	g_return_val_if_fail (SOUP_IS_SERVER (server), FALSE);
+	g_return_val_if_fail (!(options & SOUP_SERVER_LISTEN_IPV4_ONLY) ||
+			      !(options & SOUP_SERVER_LISTEN_IPV6_ONLY), FALSE);
+
+	if (options & SOUP_SERVER_LISTEN_IPV6_ONLY)
+		iaddr4 = NULL;
+	else
+		iaddr4 = g_inet_address_new_any (G_SOCKET_FAMILY_IPV4);
+
+	if (options & SOUP_SERVER_LISTEN_IPV4_ONLY)
+		iaddr6 = NULL;
+	else
+		iaddr6 = g_inet_address_new_any (G_SOCKET_FAMILY_IPV6);
+
+	success = soup_server_listen_ipv4_ipv6 (server, iaddr4, iaddr6,
+						port, options, error);
+
+	g_clear_object (&iaddr4);
+	g_clear_object (&iaddr6);
+
+	return success;
+}
+
+/**
+ * soup_server_listen_local:
+ * @server: a #SoupServer
+ * @port: the port to listen on, or 0
+ * @options: listening options for this server
+ * @error: return location for a #GError
+ *
+ * This attempts to set up @server to listen for connections on
+ * "localhost" (that is, <literal>127.0.0.1</literal> and/or
+ * <literal>::1</literal>, depending on whether @options includes
+ * %SOUP_SERVER_LISTEN_IPV4_ONLY, %SOUP_SERVER_LISTEN_IPV6_ONLY, or
+ * neither). If @port is specified, @server will listen on that port.
+ * If it is 0, @server will find an unused port to listen on. (In that
+ * case, you can use soup_server_get_uris() to find out what port it
+ * ended up choosing.)
+ *
+ * If @options includes %SOUP_SERVER_LISTEN_HTTPS, and @server has
+ * been configured for TLS, then @server will listen for https
+ * connections on these ports. Otherwise it will listen for plain
+ * http.
+ *
+ * You may call this method (along with soup_server_listen_all() and
+ * soup_server_listen()) any number of times on a server, if you want
+ * to listen on multiple ports, or set up both http and https service.
+ *
+ * After calling this method, @server will begin accepting and
+ * processing connections as soon as the appropriate #GMainContext is
+ * run.
+ *
+ * Return value: %TRUE on success, %FALSE if @port could not be bound
+ * or any other error occurred (in which case @error will be set).
+ *
+ * Since: 2.46
+ **/
+gboolean
+soup_server_listen_local (SoupServer *server, guint port,
+			  SoupServerListenOptions options,
+			  GError **error)
+{
+	GInetAddress *iaddr4, *iaddr6;
+	gboolean success;
+
+	g_return_val_if_fail (SOUP_IS_SERVER (server), FALSE);
+	g_return_val_if_fail (!(options & SOUP_SERVER_LISTEN_IPV4_ONLY) ||
+			      !(options & SOUP_SERVER_LISTEN_IPV6_ONLY), FALSE);
+
+	if (options & SOUP_SERVER_LISTEN_IPV6_ONLY)
+		iaddr4 = NULL;
+	else
+		iaddr4 = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
+
+	if (options & SOUP_SERVER_LISTEN_IPV4_ONLY)
+		iaddr6 = NULL;
+	else
+		iaddr6 = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV6);
+
+	success = soup_server_listen_ipv4_ipv6 (server, iaddr4, iaddr6,
+						port, options, error);
+
+	g_clear_object (&iaddr4);
+	g_clear_object (&iaddr6);
+
+	return success;
+}
+
+/**
+ * soup_server_listen:
+ * @server: a #SoupServer
+ * @address: the address of the interface to listen on
+ * @options: listening options for this server
+ * @error: return location for a #GError
+ *
+ * This attempts to set up @server to listen for connections on
+ * @address.
+ *
+ * If @options includes %SOUP_SERVER_LISTEN_HTTPS, and @server has
+ * been configured for TLS, then @server will listen for https
+ * connections on this port. Otherwise it will listen for plain http.
+ *
+ * You may call this method (along with soup_server_listen_all() and
+ * soup_server_listen_local()) any number of times on a server, if you
+ * want to listen on multiple ports, or set up both http and https
+ * service.n
+ *
+ * After calling this method, @server will begin accepting and
+ * processing connections as soon as the appropriate #GMainContext is
+ * run.
+ *
+ * Note that #SoupServer never makes use of dual IPv4/IPv6 sockets; if
+ * @address is an IPv6 address, it will only accept IPv6 connections.
+ * You must configure IPv4 listening separately.
+ *
+ * Return value: %TRUE on success, %FALSE if @address could not be
+ * bound or any other error occurred (in which case @error will be
+ * set).
+ *
+ * Since: 2.46
+ **/
+gboolean
+soup_server_listen (SoupServer *server, GSocketAddress *address,
+		    SoupServerListenOptions options,
+		    GError **error)
+{
+	SoupServerPrivate *priv;
+	SoupSocket *listener;
+	SoupAddress *saddr;
+	GTlsCertificate *tls_creds;
+
+	g_return_val_if_fail (SOUP_IS_SERVER (server), FALSE);
+	g_return_val_if_fail (!(options & SOUP_SERVER_LISTEN_IPV4_ONLY) &&
+			      !(options & SOUP_SERVER_LISTEN_IPV6_ONLY), FALSE);
+
+	priv = SOUP_SERVER_GET_PRIVATE (server);
+	g_return_val_if_fail (priv->disposed == FALSE, FALSE);
+
+	if (options & SOUP_SERVER_LISTEN_HTTPS) {
+		if (!priv->tls_cert) {
+			g_set_error_literal (error,
+					     G_IO_ERROR,
+					     G_IO_ERROR_INVALID_ARGUMENT,
+					     _("Can't create a TLS server without a TLS certificate"));
+			return FALSE;
+		}
+		tls_creds = priv->tls_cert;
+	} else
+		tls_creds = NULL;
+
+	saddr = soup_address_new_from_gsockaddr (address);
+	listener = soup_socket_new (SOUP_SOCKET_LOCAL_ADDRESS, saddr,
+				    SOUP_SOCKET_SSL_CREDENTIALS, tls_creds,
+				    SOUP_SOCKET_USE_THREAD_CONTEXT, TRUE,
+				    SOUP_SOCKET_IPV6_ONLY, TRUE,
+				    NULL);
+
+	if (!soup_socket_listen (listener)) {
+		g_set_error (error,
+			     G_IO_ERROR,
+			     G_IO_ERROR_FAILED,
+			     _("Could not listen on address %s, port %d"),
+			     soup_address_get_physical (saddr),
+			     soup_address_get_port (saddr));
+		g_object_unref (saddr);
+		g_object_unref (listener);
+		return FALSE;
+	}
+
+	g_object_unref (saddr);
+
+	g_signal_connect (listener, "new_connection",
+			  G_CALLBACK (new_connection), server);
+
+	/* Note: soup_server_listen_ipv4_ipv6() above relies on the
+	 * fact that this does g_slist_prepend().
+	 */
+	priv->listeners = g_slist_prepend (priv->listeners, listener);
+	return TRUE;
+}
+
+/**
+ * soup_server_get_uris:
+ * @server: a #SoupServer
+ *
+ * Gets a list of URIs corresponding to the interfaces @server is
+ * listening on. These will contain IP addresses, not hostnames, and
+ * will also indicate whether the given listener is http or https.
+ *
+ * Note that if you used soup_server_listen_all(), the returned URIs
+ * will use the addresses <literal>0.0.0.0</literal> and
+ * <literal>::</literal>, rather than actually returning separate URIs
+ * for each interface on the system.
+ *
+ * Return value: (transfer full) (element-type Soup.URI): a list of
+ * #SoupURIs, which you must free when you are done with it.
+ *
+ * Since: 2.46
+ */
+GSList *
+soup_server_get_uris (SoupServer *server)
+{
+	SoupServerPrivate *priv;
+	GSList *uris, *l;
+	SoupSocket *listener;
+	SoupAddress *addr;
+	SoupURI *uri;
+	gpointer creds;
+
+	g_return_val_if_fail (SOUP_IS_SERVER (server), NULL);
+	priv = SOUP_SERVER_GET_PRIVATE (server);
+
+	for (l = priv->listeners, uris = NULL; l; l = l->next) {
+		listener = l->data;
+		addr = soup_socket_get_local_address (listener);
+		g_object_get (G_OBJECT (listener), SOUP_SOCKET_SSL_CREDENTIALS, &creds, NULL);
+
+		uri = soup_uri_new (NULL);
+		soup_uri_set_scheme (uri, creds ? "https" : "http");
+		soup_uri_set_host (uri, soup_address_get_physical (addr));
+		soup_uri_set_port (uri, soup_address_get_port (addr));
+		soup_uri_set_path (uri, "/");
+
+		uris = g_slist_prepend (uris, uri);
+	}
+
+	return uris;
 }
 
 /**
  * soup_server_get_async_context:
  * @server: a #SoupServer
  *
- * Gets @server's async_context. This does not add a ref to the
- * context, so you will need to ref it yourself if you want it to
- * outlive its server.
+ * Gets @server's async_context, if you are using the old API. (With
+ * the new API, the server runs in the thread's thread-default
+ * #GMainContext, regardless of what this method returns.)
+ *
+ * This does not add a ref to the context, so you will need to ref it
+ * yourself if you want it to outlive its server.
  *
- * Return value: (transfer none): @server's #GMainContext, which may be %NULL
+ * Return value: (transfer none): @server's #GMainContext, which may
+ * be %NULL
+ *
+ * Deprecated: If you are using soup_server_listen(), etc, then
+ * the server listens on the thread-default #GMainContext, and this
+ * property is ignored.
  **/
 GMainContext *
 soup_server_get_async_context (SoupServer *server)
@@ -1235,9 +1865,9 @@ soup_server_get_async_context (SoupServer *server)
  * soup_client_context_get_auth_user() to determine if HTTP
  * authentication was used successfully.
  *
- * soup_client_context_get_address() and/or
+ * soup_client_context_get_remote_address() and/or
  * soup_client_context_get_host() can be used to get information for
- * logging or debugging purposes. soup_client_context_get_socket() may
+ * logging or debugging purposes. soup_client_context_get_gsocket() may
  * also be of use in some situations (eg, tracking when multiple
  * requests are made on the same connection).
  **/
@@ -1259,6 +1889,9 @@ G_DEFINE_BOXED_TYPE (SoupClientContext, soup_client_context, soup_client_context
  *
  * Return value: (transfer none): the #SoupSocket that @client is
  * associated with.
+ *
+ * Deprecated: use soup_client_context_get_gsocket(), which returns
+ * a #GSocket.
  **/
 SoupSocket *
 soup_client_context_get_socket (SoupClientContext *client)
@@ -1269,6 +1902,32 @@ soup_client_context_get_socket (SoupClientContext *client)
 }
 
 /**
+ * soup_client_context_get_gsocket:
+ * @client: a #SoupClientContext
+ *
+ * Retrieves the #GSocket that @client is associated with.
+ *
+ * If you are using this method to observe when multiple requests are
+ * made on the same persistent HTTP connection (eg, as the ntlm-test
+ * test program does), you will need to pay attention to socket
+ * destruction as well (eg, by using weak references), so that you do
+ * not get fooled when the allocator reuses the memory address of a
+ * previously-destroyed socket to represent a new socket.
+ *
+ * Return value: (transfer none): the #GSocket that @client is
+ * associated with.
+ *
+ * Since: 2.46
+ **/
+GSocket *
+soup_client_context_get_gsocket (SoupClientContext *client)
+{
+	g_return_val_if_fail (client != NULL, NULL);
+
+	return soup_socket_get_gsocket (client->sock);
+}
+
+/**
  * soup_client_context_get_address:
  * @client: a #SoupClientContext
  *
@@ -1277,6 +1936,9 @@ soup_client_context_get_socket (SoupClientContext *client)
  *
  * Return value: (transfer none): the #SoupAddress associated with the
  * remote end of a connection.
+ *
+ * Deprecated: Use soup_client_context_get_remote_address(), which returns
+ * a #GSocketAddress.
  **/
 SoupAddress *
 soup_client_context_get_address (SoupClientContext *client)
@@ -1287,13 +1949,55 @@ soup_client_context_get_address (SoupClientContext *client)
 }
 
 /**
+ * soup_client_context_get_remote_address:
+ * @client: a #SoupClientContext
+ *
+ * Retrieves the #GSocketAddress associated with the remote end
+ * of a connection.
+ *
+ * Return value: (transfer none): the #GSocketAddress associated with
+ * the remote end of a connection.
+ *
+ * Since: 2.46
+ **/
+GSocketAddress *
+soup_client_context_get_remote_address (SoupClientContext *client)
+{
+	g_return_val_if_fail (client != NULL, NULL);
+
+	if (!client->remote_addr)
+		client->remote_addr = g_socket_get_remote_address (soup_client_context_get_gsocket (client), NULL);
+	return client->remote_addr;
+}
+
+/**
+ * soup_client_context_get_local_address:
+ * @client: a #SoupClientContext
+ *
+ * Retrieves the #GSocketAddress associated with the local end
+ * of a connection.
+ *
+ * Return value: (transfer none): the #GSocketAddress associated with
+ * the local end of a connection.
+ *
+ * Since: 2.46
+ **/
+GSocketAddress *
+soup_client_context_get_local_address (SoupClientContext *client)
+{
+	g_return_val_if_fail (client != NULL, NULL);
+
+	if (!client->local_addr)
+		client->local_addr = g_socket_get_local_address (soup_client_context_get_gsocket (client), NULL);
+	return client->local_addr;
+}
+
+/**
  * soup_client_context_get_host:
  * @client: a #SoupClientContext
  *
  * Retrieves the IP address associated with the remote end of a
- * connection. (If you want the actual hostname, you'll have to call
- * soup_client_context_get_address() and then call the appropriate
- * #SoupAddress method to resolve it.)
+ * connection.
  *
  * Return value: the IP address associated with the remote end of a
  * connection.
@@ -1303,7 +2007,9 @@ soup_client_context_get_host (SoupClientContext *client)
 {
 	SoupAddress *address;
 
+	G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
 	address = soup_client_context_get_address (client);
+	G_GNUC_END_IGNORE_DEPRECATIONS;
 	return soup_address_get_physical (address);
 }