Delete SoupAddress

22 files changed, 226 insertions, 1736 deletions

diff --git a/docs/reference/libsoup-2.4-sections.txt b/docs/reference/libsoup-2.4-sections.txt
index f3c051d3..d826077e 100644
--- a/docs/reference/libsoup-2.4-sections.txt
+++ b/docs/reference/libsoup-2.4-sections.txt
@@ -14,7 +14,6 @@ soup_message_set_http_version
 soup_message_get_http_version
 soup_message_get_uri
 soup_message_set_uri
-soup_message_get_address
 <SUBSECTION>
 soup_message_set_status
 soup_message_set_status_full
@@ -368,49 +367,6 @@ SoupAuthDomainDigestClass
 </SECTION>
 
 <SECTION>
-<FILE>soup-address</FILE>
-<TITLE>SoupAddress</TITLE>
-SoupAddress
-SoupAddressFamily
-SOUP_ADDRESS_ANY_PORT
-soup_address_new
-soup_address_new_from_sockaddr
-soup_address_new_any
-<SUBSECTION>
-SoupAddressCallback
-soup_address_resolve_async
-soup_address_resolve_sync
-soup_address_is_resolved
-<SUBSECTION>
-soup_address_get_name
-soup_address_get_sockaddr
-soup_address_get_gsockaddr
-soup_address_get_physical
-soup_address_get_port
-<SUBSECTION>
-soup_address_equal_by_name
-soup_address_hash_by_name
-soup_address_equal_by_ip
-soup_address_hash_by_ip
-<SUBSECTION>
-SOUP_ADDRESS_FAMILY
-SOUP_ADDRESS_NAME
-SOUP_ADDRESS_PHYSICAL
-SOUP_ADDRESS_PORT
-SOUP_ADDRESS_SOCKADDR
-SOUP_ADDRESS_PROTOCOL
-<SUBSECTION Standard>
-SOUP_ADDRESS
-SOUP_IS_ADDRESS
-SOUP_TYPE_ADDRESS
-soup_address_get_type
-SOUP_ADDRESS_CLASS
-SOUP_IS_ADDRESS_CLASS
-SOUP_ADDRESS_GET_CLASS
-SoupAddressClass
-</SECTION>
-
-<SECTION>
 <FILE>soup-session</FILE>
 <TITLE>SoupSession</TITLE>
 SoupSession
diff --git a/libsoup/include/soup-installed.h b/libsoup/include/soup-installed.h
index 24bec683..320e056d 100644
--- a/libsoup/include/soup-installed.h
+++ b/libsoup/include/soup-installed.h
@@ -12,7 +12,6 @@ extern "C" {
 
 #define __SOUP_H_INSIDE__
 
-#include <libsoup/soup-address.h>
 #include <libsoup/soup-auth.h>
 #include <libsoup/soup-auth-domain.h>
 #include <libsoup/soup-auth-domain-basic.h>
diff --git a/libsoup/meson.build b/libsoup/meson.build
index 59326216..4ca0e379 100644
--- a/libsoup/meson.build
+++ b/libsoup/meson.build
@@ -48,7 +48,6 @@ soup_sources = [
 
   'xmlrpc/soup-xmlrpc.c',
 
-  'soup-address.c',
   'soup-body-input-stream.c',
   'soup-body-output-stream.c',
   'soup-client-input-stream.c',
@@ -157,7 +156,6 @@ soup_introspection_headers = [
 
   'xmlrpc/soup-xmlrpc.h',
 
-  'soup-address.h',
   'soup-autocleanups.h',
 
   'soup-date.h',
diff --git a/libsoup/soup-address.c b/libsoup/soup-address.c
deleted file mode 100644
index 2157ed06..00000000
--- a/libsoup/soup-address.c
+++ /dev/null
@@ -1,1297 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
-/*
- * soup-address.c: Internet address handing
- *
- * Copyright (C) 2010 Red Hat, Inc.
- */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <string.h>
-
-#include <gio/gnetworking.h>
-
-#include "soup-address.h"
-#include "soup.h"
-#include "soup-misc.h"
-
-/**
- * SECTION:soup-address
- * @short_description: DNS support
- *
- * #SoupAddress represents the address of a TCP connection endpoint:
- * both the IP address and the port. (It is somewhat like an
- * object-oriented version of struct sockaddr.)
- *
- * Although #SoupAddress is still used in some libsoup API's, it
- * should not be used in new code; use GLib's #GNetworkAddress or
- * #GSocketAddress instead.
- **/
-
-enum {
-	PROP_0,
-
-	PROP_NAME,
-	PROP_FAMILY,
-	PROP_PORT,
-	PROP_PROTOCOL,
-	PROP_PHYSICAL,
-	PROP_SOCKADDR,
-
-	LAST_PROP
-};
-
-typedef struct {
-	struct sockaddr_storage *sockaddr;
-	int n_addrs, offset;
-
-	char *name, *physical;
-	guint port;
-	const char *protocol;
-
-	GMutex lock;
-} SoupAddressPrivate;
-
-/* sockaddr generic macros */
-#define SOUP_SIN(priv) ((struct sockaddr_in *)priv->sockaddr)
-#define SOUP_SIN6(priv) ((struct sockaddr_in6 *)priv->sockaddr)
-
-/* sockaddr family macros */
-#define SOUP_ADDRESS_GET_FAMILY(priv) (priv->sockaddr->ss_family)
-#define SOUP_ADDRESS_SET_FAMILY(priv, family) \
-	(priv->sockaddr->ss_family = family)
-#define SOUP_ADDRESS_FAMILY_IS_VALID(family) \
-	(family == AF_INET || family == AF_INET6)
-#define SOUP_ADDRESS_FAMILY_SOCKADDR_SIZE(family) \
-	(family == AF_INET ? sizeof (struct sockaddr_in) : \
-			     sizeof (struct sockaddr_in6))
-#define SOUP_ADDRESS_FAMILY_DATA_SIZE(family) \
-	(family == AF_INET ? sizeof (struct in_addr) : \
-			     sizeof (struct in6_addr))
-
-/* sockaddr port macros */
-#define SOUP_ADDRESS_PORT_IS_VALID(port) (((gint) port) >= 0 && port <= 65535)
-#define SOUP_ADDRESS_GET_PORT(priv) \
-	(priv->sockaddr->ss_family == AF_INET ? \
-		SOUP_SIN(priv)->sin_port : \
-		SOUP_SIN6(priv)->sin6_port)
-#define SOUP_ADDRESS_SET_PORT(priv, port) \
-	G_STMT_START {					\
-	if (priv->sockaddr->ss_family == AF_INET)	\
-		SOUP_SIN(priv)->sin_port = port;	\
-	else						\
-		SOUP_SIN6(priv)->sin6_port = port;	\
-	} G_STMT_END
-
-/* sockaddr data macros */
-#define SOUP_ADDRESS_GET_DATA(priv) \
-	(priv->sockaddr->ss_family == AF_INET ? \
-		(gpointer)&SOUP_SIN(priv)->sin_addr : \
-		(gpointer)&SOUP_SIN6(priv)->sin6_addr)
-#define SOUP_ADDRESS_SET_DATA(priv, data, length) \
-	memcpy (SOUP_ADDRESS_GET_DATA (priv), data, length)
-
-
-static void soup_address_connectable_iface_init (GSocketConnectableIface *connectable_iface);
-
-G_DEFINE_TYPE_WITH_CODE (SoupAddress, soup_address, G_TYPE_OBJECT,
-                         G_ADD_PRIVATE (SoupAddress)
-			 G_IMPLEMENT_INTERFACE (G_TYPE_SOCKET_CONNECTABLE,
-						soup_address_connectable_iface_init))
-
-static void
-soup_address_init (SoupAddress *addr)
-{
-	SoupAddressPrivate *priv = soup_address_get_instance_private (addr);
-
-	g_mutex_init (&priv->lock);
-}
-
-static void
-soup_address_finalize (GObject *object)
-{
-	SoupAddress *addr = SOUP_ADDRESS (object);
-	SoupAddressPrivate *priv = soup_address_get_instance_private (addr);
-
-	g_free (priv->sockaddr);
-	g_free (priv->name);
-	g_free (priv->physical);
-
-	g_mutex_clear (&priv->lock);
-
-	G_OBJECT_CLASS (soup_address_parent_class)->finalize (object);
-}
-
-static GObject *
-soup_address_constructor (GType                  type,
-			  guint                  n_construct_properties,
-			  GObjectConstructParam *construct_properties)
-{
-	GObject *addr;
-	SoupAddressPrivate *priv;
-
-	addr = G_OBJECT_CLASS (soup_address_parent_class)->constructor (
-		type, n_construct_properties, construct_properties);
-	if (!addr)
-		return NULL;
-	priv = soup_address_get_instance_private (SOUP_ADDRESS (addr));
-
-	if (!priv->name && !priv->sockaddr) {
-		g_object_unref (addr);
-		return NULL;
-	}
-
-	return addr;
-}
-
-static void
-soup_address_set_property (GObject *object, guint prop_id,
-			   const GValue *value, GParamSpec *pspec)
-{
-	SoupAddressPrivate *priv = soup_address_get_instance_private (SOUP_ADDRESS (object));
-	SoupAddressFamily family;
-	struct sockaddr *sa;
-	int len, port;
-
-	/* This is a mess because the properties are mostly orthogonal,
-	 * but g_object_constructor wants to set a default value for each
-	 * of them.
-	 */
-
-	switch (prop_id) {
-	case PROP_NAME:
-		priv->name = g_value_dup_string (value);
-		break;
-
-	case PROP_FAMILY:
-		family = g_value_get_enum (value);
-		if (family == SOUP_ADDRESS_FAMILY_INVALID)
-			return;
-		g_return_if_fail (SOUP_ADDRESS_FAMILY_IS_VALID (family));
-		g_return_if_fail (priv->sockaddr == NULL);
-
-		priv->sockaddr = g_malloc0 (SOUP_ADDRESS_FAMILY_SOCKADDR_SIZE (family));
-		SOUP_ADDRESS_SET_FAMILY (priv, family);
-		SOUP_ADDRESS_SET_PORT (priv, htons (priv->port));
-		priv->n_addrs = 1;
-		break;
-
-	case PROP_PORT:
-		port = g_value_get_int (value);
-		if (port == -1)
-			return;
-		g_return_if_fail (SOUP_ADDRESS_PORT_IS_VALID (port));
-
-		priv->port = port;
-		if (priv->sockaddr)
-			SOUP_ADDRESS_SET_PORT (priv, htons (port));
-		break;
-
-	case PROP_PROTOCOL:
-		priv->protocol = g_intern_string (g_value_get_string (value));
-		break;
-
-	case PROP_SOCKADDR:
-		sa = g_value_get_pointer (value);
-		if (!sa)
-			return;
-		g_return_if_fail (priv->sockaddr == NULL);
-
-		len = SOUP_ADDRESS_FAMILY_SOCKADDR_SIZE (sa->sa_family);
-		priv->sockaddr = g_memdup (sa, len);
-		priv->n_addrs = 1;
-		priv->port = ntohs (SOUP_ADDRESS_GET_PORT (priv));
-		break;
-	default:
-		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-		break;
-	}
-}
-
-static void
-soup_address_get_property (GObject *object, guint prop_id,
-			   GValue *value, GParamSpec *pspec)
-{
-	SoupAddressPrivate *priv = soup_address_get_instance_private (SOUP_ADDRESS (object));
-
-	switch (prop_id) {
-	case PROP_NAME:
-		g_value_set_string (value, priv->name);
-		break;
-	case PROP_FAMILY:
-		if (priv->sockaddr)
-			g_value_set_enum (value, SOUP_ADDRESS_GET_FAMILY (priv));
-		else
-			g_value_set_enum (value, 0);
-		break;
-	case PROP_PORT:
-		g_value_set_int (value, priv->port);
-		break;
-	case PROP_PHYSICAL:
-		g_value_set_string (value, soup_address_get_physical (SOUP_ADDRESS (object)));
-		break;
-	case PROP_PROTOCOL:
-		g_value_set_string (value, priv->protocol);
-		break;
-	case PROP_SOCKADDR:
-		g_value_set_pointer (value, priv->sockaddr);
-		break;
-	default:
-		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-		break;
-	}
-}
-
-static void
-soup_address_class_init (SoupAddressClass *address_class)
-{
-	GObjectClass *object_class = G_OBJECT_CLASS (address_class);
-
-	/* virtual method override */
-	object_class->constructor  = soup_address_constructor;
-	object_class->finalize     = soup_address_finalize;
-	object_class->set_property = soup_address_set_property;
-	object_class->get_property = soup_address_get_property;
-
-	/* properties */
-	/**
-	 * SOUP_ADDRESS_NAME:
-	 *
-	 * Alias for the #SoupAddress:name property. (The hostname for
-	 * this address.)
-	 **/
-	g_object_class_install_property (
-		object_class, PROP_NAME,
-		g_param_spec_string (SOUP_ADDRESS_NAME,
-				     "Name",
-				     "Hostname for this address",
-				     NULL,
-				     G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
-				     G_PARAM_STATIC_STRINGS));
-	/**
-	 * SOUP_ADDRESS_FAMILY:
-	 *
-	 * Alias for the #SoupAddress:family property. (The
-	 * #SoupAddressFamily for this address.)
-	 **/
-	g_object_class_install_property (
-		object_class, PROP_FAMILY,
-		g_param_spec_enum (SOUP_ADDRESS_FAMILY,
-				   "Family",
-				   "Address family for this address",
-				   SOUP_TYPE_ADDRESS_FAMILY,
-				   SOUP_ADDRESS_FAMILY_INVALID,
-				   G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
-				   G_PARAM_STATIC_STRINGS));
-	/**
-	 * SOUP_ADDRESS_PORT:
-	 *
-	 * An alias for the #SoupAddress:port property. (The port for
-	 * this address.)
-	 **/
-	g_object_class_install_property (
-		object_class, PROP_PORT,
-		g_param_spec_int (SOUP_ADDRESS_PORT,
-				  "Port",
-				  "Port for this address",
-				  -1, 65535, -1,
-				  G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
-				  G_PARAM_STATIC_STRINGS));
-	/**
-	 * SOUP_ADDRESS_PROTOCOL:
-	 *
-	 * Alias for the #SoupAddress:protocol property. (The URI scheme
-	 * used with this address.)
-	 **/
-	g_object_class_install_property (
-		object_class, PROP_PROTOCOL,
-		g_param_spec_string (SOUP_ADDRESS_PROTOCOL,
-				     "Protocol",
-				     "URI scheme for this address",
-				     NULL,
-				     G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
-				     G_PARAM_STATIC_STRINGS));
-	/**
-	 * SOUP_ADDRESS_PHYSICAL:
-	 *
-	 * An alias for the #SoupAddress:physical property. (The
-	 * stringified IP address for this address.)
-	 **/
-	g_object_class_install_property (
-		object_class, PROP_PHYSICAL,
-		g_param_spec_string (SOUP_ADDRESS_PHYSICAL,
-				     "Physical address",
-				     "IP address for this address",
-				     NULL,
-				     G_PARAM_READABLE |
-				     G_PARAM_STATIC_STRINGS));
-	/**
-	 * SOUP_ADDRESS_SOCKADDR:
-	 *
-	 * An alias for the #SoupAddress:sockaddr property. (A pointer
-	 * to the struct sockaddr for this address.)
-	 **/
-	g_object_class_install_property (
-		object_class, PROP_SOCKADDR,
-		g_param_spec_pointer (SOUP_ADDRESS_SOCKADDR,
-				      "sockaddr",
-				      "struct sockaddr for this address",
-				      G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
-				      G_PARAM_STATIC_STRINGS));
-}
-
-/**
- * soup_address_new:
- * @name: a hostname or physical address
- * @port: a port number
- *
- * Creates a #SoupAddress from @name and @port. The #SoupAddress's IP
- * address may not be available right away; the caller can call
- * soup_address_resolve_async() or soup_address_resolve_sync() to
- * force a DNS resolution.
- *
- * Return value: a #SoupAddress
- **/
-SoupAddress *
-soup_address_new (const char *name, guint port)
-{
-	g_return_val_if_fail (name != NULL, NULL);
-	g_return_val_if_fail (SOUP_ADDRESS_PORT_IS_VALID (port), NULL);
-
-	return g_object_new (SOUP_TYPE_ADDRESS,
-			     SOUP_ADDRESS_NAME, name,
-			     SOUP_ADDRESS_PORT, port,
-			     NULL);
-}
-
-/**
- * soup_address_new_from_sockaddr:
- * @sa: a pointer to a sockaddr
- * @len: size of @sa
- *
- * Returns a #SoupAddress equivalent to @sa (or %NULL if @sa's
- * address family isn't supported)
- *
- * Return value: (nullable): the new #SoupAddress
- **/
-SoupAddress *
-soup_address_new_from_sockaddr (struct sockaddr *sa, int len)
-{
-	g_return_val_if_fail (sa != NULL, NULL);
-	g_return_val_if_fail (SOUP_ADDRESS_FAMILY_IS_VALID (sa->sa_family), NULL);
-	g_return_val_if_fail (len == SOUP_ADDRESS_FAMILY_SOCKADDR_SIZE (sa->sa_family), NULL);
-
-	return g_object_new (SOUP_TYPE_ADDRESS,
-			     SOUP_ADDRESS_SOCKADDR, sa,
-			     NULL);
-}
-
-SoupAddress *
-soup_address_new_from_gsockaddr (GSocketAddress *addr)
-{
-	struct sockaddr_storage sa;
-
-	g_socket_address_to_native (addr, &sa, sizeof (sa), NULL);
-	return g_object_new (SOUP_TYPE_ADDRESS,
-			     SOUP_ADDRESS_SOCKADDR, &sa,
-			     NULL);
-}
-
-/**
- * SoupAddressFamily:
- * @SOUP_ADDRESS_FAMILY_INVALID: an invalid %SoupAddress
- * @SOUP_ADDRESS_FAMILY_IPV4: an IPv4 address
- * @SOUP_ADDRESS_FAMILY_IPV6: an IPv6 address
- *
- * The supported address families.
- **/
-
-/**
- * SOUP_ADDRESS_ANY_PORT:
- *
- * This can be passed to any #SoupAddress method that expects a port,
- * to indicate that you don't care what port is used.
- **/
-
-/**
- * soup_address_new_any:
- * @family: the address family
- * @port: the port number (usually %SOUP_ADDRESS_ANY_PORT)
- *
- * Returns a #SoupAddress corresponding to the "any" address
- * for @family (or %NULL if @family isn't supported), suitable for
- * using as a listening #SoupSocket.
- *
- * Return value: (nullable): the new #SoupAddress
- **/
-SoupAddress *
-soup_address_new_any (SoupAddressFamily family, guint port)
-{
-	g_return_val_if_fail (SOUP_ADDRESS_FAMILY_IS_VALID (family), NULL);
-	g_return_val_if_fail (SOUP_ADDRESS_PORT_IS_VALID (port), NULL);
-
-	return g_object_new (SOUP_TYPE_ADDRESS,
-			     SOUP_ADDRESS_FAMILY, family,
-			     SOUP_ADDRESS_PORT, port,
-			     NULL);
-}
-
-/**
- * soup_address_get_name:
- * @addr: a #SoupAddress
- *
- * Returns the hostname associated with @addr.
- *
- * This method is not thread-safe; if you call it while @addr is being
- * resolved in another thread, it may return garbage. You can use
- * soup_address_is_resolved() to safely test whether or not an address
- * is resolved before fetching its name or address.
- *
- * Return value: (nullable): the hostname, or %NULL if it is not known.
- **/
-const char *
-soup_address_get_name (SoupAddress *addr)
-{
-	SoupAddressPrivate *priv;
-
-	g_return_val_if_fail (SOUP_IS_ADDRESS (addr), NULL);
-	priv = soup_address_get_instance_private (addr);
-
-	return priv->name;
-}
-
-/**
- * soup_address_get_sockaddr:
- * @addr: a #SoupAddress
- * @len: return location for sockaddr length
- *
- * Returns the sockaddr associated with @addr, with its length in
- * *@len. If the sockaddr is not yet known, returns %NULL.
- *
- * This method is not thread-safe; if you call it while @addr is being
- * resolved in another thread, it may return garbage. You can use
- * soup_address_is_resolved() to safely test whether or not an address
- * is resolved before fetching its name or address.
- *
- * Return value: (nullable) (transfer none): the sockaddr, or %NULL
- **/
-struct sockaddr *
-soup_address_get_sockaddr (SoupAddress *addr, int *len)
-{
-	SoupAddressPrivate *priv;
-
-	g_return_val_if_fail (SOUP_IS_ADDRESS (addr), NULL);
-	priv = soup_address_get_instance_private (addr);
-
-	if (priv->sockaddr && len)
-		*len = SOUP_ADDRESS_FAMILY_SOCKADDR_SIZE (SOUP_ADDRESS_GET_FAMILY (priv));
-	return (struct sockaddr *)priv->sockaddr;
-}
-
-/**
- * soup_address_get_gsockaddr:
- * @addr: a #SoupAddress
- *
- * Creates a new #GSocketAddress corresponding to @addr (which is assumed
- * to only have one socket address associated with it).
- *
- * Return value: (transfer full): a new #GSocketAddress
- *
- * Since: 2.32
- */
-GSocketAddress *
-soup_address_get_gsockaddr (SoupAddress *addr)
-{
-	SoupAddressPrivate *priv = soup_address_get_instance_private (addr);
-
-	return g_socket_address_new_from_native (priv->sockaddr,
-						 SOUP_ADDRESS_FAMILY_SOCKADDR_SIZE (SOUP_ADDRESS_GET_FAMILY (priv)));
-}
-
-static GInetAddress *
-soup_address_make_inet_address (SoupAddress *addr)
-{
-	SoupAddressPrivate *priv = soup_address_get_instance_private (addr);
-	GSocketAddress *gsa;
-	GInetAddress *gia;
-
-	gsa = g_socket_address_new_from_native (priv->sockaddr,
-						SOUP_ADDRESS_FAMILY_SOCKADDR_SIZE (SOUP_ADDRESS_GET_FAMILY (priv)));
-	gia = g_inet_socket_address_get_address ((GInetSocketAddress *)gsa);
-	g_object_ref (gia);
-	g_object_unref (gsa);
-	return gia;
-}
-
-/**
- * soup_address_get_physical:
- * @addr: a #SoupAddress
- *
- * Returns the physical address associated with @addr as a string.
- * (Eg, "127.0.0.1"). If the address is not yet known, returns %NULL.
- *
- * This method is not thread-safe; if you call it while @addr is being
- * resolved in another thread, it may return garbage. You can use
- * soup_address_is_resolved() to safely test whether or not an address
- * is resolved before fetching its name or address.
- *
- * Return value: (nullable): the physical address, or %NULL
- **/
-const char *
-soup_address_get_physical (SoupAddress *addr)
-{
-	SoupAddressPrivate *priv;
-
-	g_return_val_if_fail (SOUP_IS_ADDRESS (addr), NULL);
-	priv = soup_address_get_instance_private (addr);
-
-	if (!priv->sockaddr)
-		return NULL;
-
-	if (!priv->physical) {
-		GInetAddress *gia;
-
-		gia = soup_address_make_inet_address (addr);
-		priv->physical = g_inet_address_to_string (gia);
-		g_object_unref (gia);
-	}
-
-	return priv->physical;
-}
-
-/**
- * soup_address_get_port:
- * @addr: a #SoupAddress
- *
- * Returns the port associated with @addr.
- *
- * Return value: the port
- **/
-guint
-soup_address_get_port (SoupAddress *addr)
-{
-	SoupAddressPrivate *priv;
-
-	g_return_val_if_fail (SOUP_IS_ADDRESS (addr), 0);
-	priv = soup_address_get_instance_private (addr);
-
-	return priv->port;
-}
-
-
-/* Tries to resolve priv->name as an IP address, possibly including an
- * IPv6 scope id.
- */
-static void
-maybe_resolve_ip (SoupAddress *addr)
-{
-	SoupAddressPrivate *priv = soup_address_get_instance_private (addr);
-	const char *pct, *ip;
-	char *tmp = NULL;
-	GSocketConnectable *gaddr;
-	GSocketAddressEnumerator *sa_enum;
-	GSocketAddress *saddr;
-
-	if (priv->sockaddr || !priv->name)
-		return;
-
-	pct = strchr (priv->name, '%');
-	if (pct)
-		ip = tmp = g_strndup (priv->name, pct - priv->name);
-	else
-		ip = priv->name;
-
-	if (!g_hostname_is_ip_address (ip)) {
-		g_free (tmp);
-		return;
-	}
-	g_free (tmp);
-
-	gaddr = g_network_address_new (priv->name, priv->port);
-	if (!gaddr)
-		return;
-
-	sa_enum = g_socket_connectable_enumerate (gaddr);
-	saddr = g_socket_address_enumerator_next (sa_enum, NULL, NULL);
-	if (saddr) {
-		priv->n_addrs = 1;
-		priv->sockaddr = g_new (struct sockaddr_storage, 1);
-		if (!g_socket_address_to_native (saddr, priv->sockaddr,
-						 sizeof (struct sockaddr_storage),
-						 NULL)) {
-			/* can't happen: We know the address format is supported
-			 * and the buffer is large enough
-			 */
-			g_warn_if_reached ();
-		}
-		g_object_unref (saddr);
-	}
-
-	g_object_unref (sa_enum);
-	g_object_unref (gaddr);
-}
-
-
-static guint
-update_addrs (SoupAddress *addr, GList *addrs, GError *error)
-{
-	SoupAddressPrivate *priv = soup_address_get_instance_private (addr);
-	GInetAddress *gia;
-	GSocketAddress *gsa;
-	int i;
-
-	if (error) {
-		if (error->domain == G_IO_ERROR &&
-		    error->code == G_IO_ERROR_CANCELLED)
-			return SOUP_STATUS_CANCELLED;
-		else
-			return SOUP_STATUS_CANT_RESOLVE;
-	} else if (!addrs)
-		return SOUP_STATUS_CANT_RESOLVE;
-	else if (priv->sockaddr)
-		return SOUP_STATUS_OK;
-
-	priv->n_addrs = g_list_length (addrs);
-	priv->sockaddr = g_new (struct sockaddr_storage, priv->n_addrs);
-	for (i = 0; addrs; addrs = addrs->next, i++) {
-		gia = addrs->data;
-		gsa = g_inet_socket_address_new (gia, priv->port);
-
-		if (!g_socket_address_to_native (gsa, &priv->sockaddr[i],
-						 sizeof (struct sockaddr_storage),
-						 NULL)) {
-			/* can't happen: We know the address format is supported
-			 * and the buffer is large enough
-			 */
-			g_warn_if_reached ();
-		}
-		g_object_unref (gsa);
-	}
-
-	return SOUP_STATUS_OK;
-}
-
-static guint
-update_name (SoupAddress *addr, const char *name, GError *error)
-{
-	SoupAddressPrivate *priv = soup_address_get_instance_private (addr);
-
-	if (error) {
-		if (error->domain == G_IO_ERROR &&
-		    error->code == G_IO_ERROR_CANCELLED)
-			return SOUP_STATUS_CANCELLED;
-		else
-			return SOUP_STATUS_CANT_RESOLVE;
-	} else if (!name)
-		return SOUP_STATUS_CANT_RESOLVE;
-	else if (priv->name)
-		return SOUP_STATUS_OK;
-
-	priv->name = g_strdup (name);
-	return SOUP_STATUS_OK;
-}
-
-typedef struct {
-	SoupAddress         *addr;
-	SoupAddressCallback  callback;
-	gpointer             callback_data;
-} SoupAddressResolveAsyncData;
-
-static void
-complete_resolve_async (SoupAddressResolveAsyncData *res_data, guint status)
-{
-	GSource *current_source;
-	GMainContext *current_context;
-
-	if (res_data->callback) {
-		/* Awful hack; to make soup_socket_connect_async()
-		 * with an non-default async_context work correctly,
-		 * we need to ensure that the non-default context
-		 * (which we're now running in) is the thread-default
-		 * when the callbacks are run...
-		 */
-		current_source = g_main_current_source ();
-		if (current_source && !g_source_is_destroyed (current_source))
-			current_context = g_source_get_context (current_source);
-		else
-			current_context = NULL;
-		g_main_context_push_thread_default (current_context);
-
-		res_data->callback (res_data->addr, status,
-				    res_data->callback_data);
-
-		g_main_context_pop_thread_default (current_context);
-	}
-
-	g_object_unref (res_data->addr);
-	g_slice_free (SoupAddressResolveAsyncData, res_data);
-}
-
-static void
-lookup_resolved (GObject *source, GAsyncResult *result, gpointer user_data)
-{
-	GResolver *resolver = G_RESOLVER (source);
-	SoupAddressResolveAsyncData *res_data = user_data;
-	SoupAddress *addr = res_data->addr;
-	SoupAddressPrivate *priv = soup_address_get_instance_private (addr);
-	GError *error = NULL;
-	guint status;
-
-	if (!priv->sockaddr) {
-		GList *addrs;
-
-		addrs = g_resolver_lookup_by_name_finish (resolver, result,
-							  &error);
-		status = update_addrs (addr, addrs, error);
-		g_resolver_free_addresses (addrs);
-	} else if (!priv->name) {
-		char *name;
-
-		name = g_resolver_lookup_by_address_finish (resolver, result,
-							    &error);
-		status = update_name (addr, name, error);
-		g_free (name);
-	} else
-		status = SOUP_STATUS_OK;
-
-	/* For the enumerator impl, below */
-	g_object_ref (addr);
-	g_object_set_data (G_OBJECT (addr), "async-resolved-error", error);
-
-	complete_resolve_async (res_data, status);
-
-	g_object_set_data (G_OBJECT (addr), "async-resolved-error", NULL);
-	g_object_unref (addr);
-	if (error)
-		g_error_free (error);
-}
-
-static gboolean
-idle_complete_resolve (gpointer res_data)
-{
-	complete_resolve_async (res_data, SOUP_STATUS_OK);
-	return FALSE;
-}
-
-/**
- * SoupAddressCallback:
- * @addr: the #SoupAddress that was resolved
- * @status: %SOUP_STATUS_OK, %SOUP_STATUS_CANT_RESOLVE, or
- * %SOUP_STATUS_CANCELLED
- * @user_data: the user data that was passed to
- * soup_address_resolve_async()
- *
- * The callback function passed to soup_address_resolve_async().
- **/
-
-/**
- * soup_address_resolve_async:
- * @addr: a #SoupAddress
- * @async_context: (allow-none): the #GMainContext to call @callback from
- * @cancellable: a #GCancellable object, or %NULL
- * @callback: (scope async): callback to call with the result
- * @user_data: data for @callback
- *
- * Asynchronously resolves the missing half of @addr (its IP address
- * if it was created with soup_address_new(), or its hostname if it
- * was created with soup_address_new_from_sockaddr() or
- * soup_address_new_any().)
- *
- * If @cancellable is non-%NULL, it can be used to cancel the
- * resolution. @callback will still be invoked in this case, with a
- * status of %SOUP_STATUS_CANCELLED.
- *
- * It is safe to call this more than once on a given address, from the
- * same thread, with the same @async_context (and doing so will not
- * result in redundant DNS queries being made). But it is not safe to
- * call from multiple threads, or with different @async_contexts, or
- * mixed with calls to soup_address_resolve_sync().
- **/
-void
-soup_address_resolve_async (SoupAddress *addr, GMainContext *async_context,
-			    GCancellable *cancellable,
-			    SoupAddressCallback callback, gpointer user_data)
-{
-	SoupAddressPrivate *priv;
-	SoupAddressResolveAsyncData *res_data;
-	GResolver *resolver;
-
-	g_return_if_fail (SOUP_IS_ADDRESS (addr));
-	priv = soup_address_get_instance_private (addr);
-	g_return_if_fail (priv->name || priv->sockaddr);
-
-	/* We don't need to do locking here because the async case is
-	 * not intended to be thread-safe.
-	 */
-
-	if (priv->name && !priv->sockaddr)
-		maybe_resolve_ip (addr);
-	if (priv->name && priv->sockaddr && !callback)
-		return;
-
-	res_data = g_slice_new0 (SoupAddressResolveAsyncData);
-	res_data->addr = g_object_ref (addr);
-	res_data->callback = callback;
-	res_data->callback_data = user_data;
-
-	if (async_context)
-		g_main_context_push_thread_default (async_context);
-
-	if (priv->name && priv->sockaddr)
-		soup_add_completion (async_context, idle_complete_resolve, res_data);
-	else {
-		resolver = g_resolver_get_default ();
-
-		if (priv->name) {
-			g_resolver_lookup_by_name_async (resolver, priv->name,
-							 cancellable,
-							 lookup_resolved, res_data);
-		} else {
-			GInetAddress *gia;
-
-			gia = soup_address_make_inet_address (addr);
-			g_resolver_lookup_by_address_async (resolver, gia,
-							    cancellable,
-							    lookup_resolved, res_data);
-			g_object_unref (gia);
-		}
-
-		g_object_unref (resolver);
-	}
-
-	if (async_context)
-		g_main_context_pop_thread_default (async_context);
-}
-
-static guint
-resolve_sync_internal (SoupAddress *addr, GCancellable *cancellable, GError **error)
-{
-	SoupAddressPrivate *priv = soup_address_get_instance_private (addr);
-	GResolver *resolver;
-	guint status;
-	GError *my_err = NULL;
-
-	resolver = g_resolver_get_default ();
-
-	/* We could optimize this to avoid multiple lookups the same
-	 * way _resolve_async does, but we don't currently. So, first
-	 * lock the mutex to ensure we have a consistent view of
-	 * priv->sockaddr and priv->name, unlock it around the
-	 * blocking op, and then re-lock it to modify @addr.
-	 */
-	g_mutex_lock (&priv->lock);
-
-	if (priv->name && !priv->sockaddr)
-		maybe_resolve_ip (addr);
-
-	if (!priv->sockaddr) {
-		GList *addrs;
-
-		g_mutex_unlock (&priv->lock);
-		addrs = g_resolver_lookup_by_name (resolver, priv->name,
-						   cancellable, &my_err);
-		g_mutex_lock (&priv->lock);
-
-		status = update_addrs (addr, addrs, my_err);
-		g_resolver_free_addresses (addrs);
-	} else if (!priv->name) {
-		GInetAddress *gia;
-		char *name;
-
-		g_mutex_unlock (&priv->lock);
-		gia = soup_address_make_inet_address (addr);
-		name = g_resolver_lookup_by_address (resolver, gia,
-						     cancellable, &my_err);
-		g_object_unref (gia);
-		g_mutex_lock (&priv->lock);
-
-		status = update_name (addr, name, my_err);
-		g_free (name);
-	} else
-		status = SOUP_STATUS_OK;
-
-	g_mutex_unlock (&priv->lock);
-
-	if (my_err)
-		g_propagate_error (error, my_err);
-	g_object_unref (resolver);
-
-	return status;
-}
-
-/**
- * soup_address_resolve_sync:
- * @addr: a #SoupAddress
- * @cancellable: a #GCancellable object, or %NULL
- *
- * Synchronously resolves the missing half of @addr, as with
- * soup_address_resolve_async().
- *
- * If @cancellable is non-%NULL, it can be used to cancel the
- * resolution. soup_address_resolve_sync() will then return a status
- * of %SOUP_STATUS_CANCELLED.
- *
- * It is safe to call this more than once, even from different
- * threads, but it is not safe to mix calls to
- * soup_address_resolve_sync() with calls to
- * soup_address_resolve_async() on the same address.
- *
- * Return value: %SOUP_STATUS_OK, %SOUP_STATUS_CANT_RESOLVE, or
- * %SOUP_STATUS_CANCELLED.
- **/
-guint
-soup_address_resolve_sync (SoupAddress *addr, GCancellable *cancellable)
-{
-	SoupAddressPrivate *priv;
-
-	g_return_val_if_fail (SOUP_IS_ADDRESS (addr), SOUP_STATUS_MALFORMED);
-	priv = soup_address_get_instance_private (addr);
-	g_return_val_if_fail (priv->name || priv->sockaddr, SOUP_STATUS_MALFORMED);
-
-	return resolve_sync_internal (addr, cancellable, NULL);
-}
-
-/**
- * soup_address_is_resolved:
- * @addr: a #SoupAddress
- *
- * Tests if @addr has already been resolved. Unlike the other
- * #SoupAddress "get" methods, this is safe to call when @addr might
- * be being resolved in another thread.
- *
- * Return value: %TRUE if @addr has been resolved.
- **/
-gboolean
-soup_address_is_resolved (SoupAddress *addr)
-{
-	SoupAddressPrivate *priv;
-	gboolean resolved;
-
-	g_return_val_if_fail (SOUP_IS_ADDRESS (addr), FALSE);
-	priv = soup_address_get_instance_private (addr);
-
-	g_mutex_lock (&priv->lock);
-	resolved = priv->sockaddr && priv->name;
-	g_mutex_unlock (&priv->lock);
-
-	return resolved;
-}
-
-/**
- * soup_address_hash_by_name:
- * @addr: (type Soup.Address): a #SoupAddress
- *
- * A hash function (for #GHashTable) that corresponds to
- * soup_address_equal_by_name(), qv
- *
- * Return value: the named-based hash value for @addr.
- *
- * Since: 2.26
- **/
-guint
-soup_address_hash_by_name (gconstpointer addr)
-{
-	SoupAddressPrivate *priv = soup_address_get_instance_private (SOUP_ADDRESS (addr));
-
-	g_return_val_if_fail (priv->name != NULL, 0);
-	return g_str_hash (priv->name);
-}
-
-/**
- * soup_address_equal_by_name:
- * @addr1: (type Soup.Address): a #SoupAddress with a resolved name
- * @addr2: (type Soup.Address): another #SoupAddress with a resolved
- *   name
- *
- * Tests if @addr1 and @addr2 have the same "name". This method can be
- * used with soup_address_hash_by_name() to create a #GHashTable that
- * hashes on address "names".
- *
- * Comparing by name normally means comparing the addresses by their
- * hostnames. But if the address was originally created using an IP
- * address literal, then it will be compared by that instead.
- *
- * In particular, if "www.example.com" has the IP address 10.0.0.1,
- * and @addr1 was created with the name "www.example.com" and @addr2
- * was created with the name "10.0.0.1", then they will compare as
- * unequal for purposes of soup_address_equal_by_name().
- *
- * This would be used to distinguish hosts in situations where
- * different virtual hosts on the same IP address should be considered
- * different. Eg, for purposes of HTTP authentication or cookies, two
- * hosts with the same IP address but different names are considered
- * to be different hosts.
- *
- * See also soup_address_equal_by_ip(), which compares by IP address
- * rather than by name.
- *
- * Return value: whether or not @addr1 and @addr2 have the same name
- *
- * Since: 2.26
- **/
-gboolean
-soup_address_equal_by_name (gconstpointer addr1, gconstpointer addr2)
-{
-	SoupAddressPrivate *priv1 = soup_address_get_instance_private (SOUP_ADDRESS (addr1));
-	SoupAddressPrivate *priv2 = soup_address_get_instance_private (SOUP_ADDRESS (addr2));
-
-	g_return_val_if_fail (priv1->name != NULL, FALSE);
-	g_return_val_if_fail (priv2->name != NULL, FALSE);
-	return !g_ascii_strcasecmp (priv1->name, priv2->name);
-}
-
-/**
- * soup_address_hash_by_ip:
- * @addr: (type Soup.Address): a #SoupAddress
- *
- * A hash function (for #GHashTable) that corresponds to
- * soup_address_equal_by_ip(), qv
- *
- * Return value: the IP-based hash value for @addr.
- *
- * Since: 2.26
- **/
-guint
-soup_address_hash_by_ip (gconstpointer addr)
-{
-	SoupAddressPrivate *priv = soup_address_get_instance_private (SOUP_ADDRESS (addr));
-	guint hash;
-
-	g_return_val_if_fail (priv->sockaddr != NULL, 0);
-
-	memcpy (&hash, SOUP_ADDRESS_GET_DATA (priv),
-		MIN (sizeof (hash), SOUP_ADDRESS_FAMILY_DATA_SIZE (priv->sockaddr->ss_family)));
-	return hash;
-}
-
-/**
- * soup_address_equal_by_ip:
- * @addr1: (type Soup.Address): a #SoupAddress with a resolved IP
- *   address
- * @addr2: (type Soup.Address): another #SoupAddress with a resolved
- *   IP address
- *
- * Tests if @addr1 and @addr2 have the same IP address. This method
- * can be used with soup_address_hash_by_ip() to create a
- * #GHashTable that hashes on IP address.
- *
- * This would be used to distinguish hosts in situations where
- * different virtual hosts on the same IP address should be considered
- * the same. Eg, if "www.example.com" and "www.example.net" have the
- * same IP address, then a single connection can be used to talk
- * to either of them.
- *
- * See also soup_address_equal_by_name(), which compares by name
- * rather than by IP address.
- *
- * Return value: whether or not @addr1 and @addr2 have the same IP
- * address.
- *
- * Since: 2.26
- **/
-gboolean
-soup_address_equal_by_ip (gconstpointer addr1, gconstpointer addr2)
-{
-	SoupAddressPrivate *priv1 = soup_address_get_instance_private (SOUP_ADDRESS (addr1));
-	SoupAddressPrivate *priv2 = soup_address_get_instance_private (SOUP_ADDRESS (addr2));
-	int size;
-
-	g_return_val_if_fail (priv1->sockaddr != NULL, FALSE);
-	g_return_val_if_fail (priv2->sockaddr != NULL, FALSE);
-
-	size = SOUP_ADDRESS_FAMILY_SOCKADDR_SIZE (priv1->sockaddr->ss_family);
-	return (priv1->sockaddr->ss_family ==
-		priv2->sockaddr->ss_family &&
-		!memcmp (priv1->sockaddr, priv2->sockaddr, size));
-}
-
-
-#define SOUP_TYPE_ADDRESS_ADDRESS_ENUMERATOR (_soup_address_address_enumerator_get_type ())
-#define SOUP_ADDRESS_ADDRESS_ENUMERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOUP_TYPE_ADDRESS_ADDRESS_ENUMERATOR, SoupAddressAddressEnumerator))
-
-typedef struct {
-	GSocketAddressEnumerator parent_instance;
-
-	SoupAddress *addr;
-	int orig_offset;
-	int n;
-} SoupAddressAddressEnumerator;
-
-typedef struct {
-	GSocketAddressEnumeratorClass parent_class;
-
-} SoupAddressAddressEnumeratorClass;
-
-GType _soup_address_address_enumerator_get_type (void);
-G_DEFINE_TYPE (SoupAddressAddressEnumerator, _soup_address_address_enumerator, G_TYPE_SOCKET_ADDRESS_ENUMERATOR)
-
-static void
-soup_address_address_enumerator_finalize (GObject *object)
-{
-	SoupAddressAddressEnumerator *addr_enum =
-		SOUP_ADDRESS_ADDRESS_ENUMERATOR (object);
-
-	g_object_unref (addr_enum->addr);
-
-	G_OBJECT_CLASS (_soup_address_address_enumerator_parent_class)->finalize (object);
-}
-
-static GSocketAddress *
-next_address (SoupAddressAddressEnumerator *addr_enum)
-{
-	SoupAddressPrivate *priv = soup_address_get_instance_private (addr_enum->addr);
-	struct sockaddr_storage *ss;
-	int next_addr;
-
-	/* If there are two addresses but the first one is unusable
-	 * (eg, it's IPv6 and we can only do IPv4), then we don't want to
-	 * try the bad one every time. So we use priv->offset to remember
-	 * the offset of the first usable address (ie, the first address
-	 * that we weren't called again after returning).
-	 */
-	next_addr = (addr_enum->orig_offset + addr_enum->n) % priv->n_addrs;
-	priv->offset = next_addr;
-
-	if (addr_enum->n >= priv->n_addrs)
-		return NULL;
-	addr_enum->n++;
-
-	ss = &priv->sockaddr[next_addr];
-	return g_socket_address_new_from_native (ss, SOUP_ADDRESS_FAMILY_SOCKADDR_SIZE (ss->ss_family));
-}
-
-static GSocketAddress *
-soup_address_address_enumerator_next (GSocketAddressEnumerator  *enumerator,
-				      GCancellable              *cancellable,
-				      GError                   **error)
-{
-	SoupAddressAddressEnumerator *addr_enum =
-		SOUP_ADDRESS_ADDRESS_ENUMERATOR (enumerator);
-	SoupAddressPrivate *priv = soup_address_get_instance_private (addr_enum->addr);
-
-	if (!priv->sockaddr) {
-		if (resolve_sync_internal (addr_enum->addr, cancellable, error) != SOUP_STATUS_OK)
-			return NULL;
-	}
-
-	return next_address (addr_enum);
-}
-
-static void
-got_addresses (SoupAddress *addr, guint status, gpointer user_data)
-{
-	GTask *task = user_data;
-	GError *error;
-
-	error = g_object_get_data (G_OBJECT (addr), "async-resolved-error");
-	if (error)
-		g_task_return_error (task, g_error_copy (error));
-	else {
-		GSocketAddress *socket_addr;
-
-		socket_addr = next_address (g_task_get_source_object (task));
-		g_task_return_pointer (task, socket_addr, g_object_unref);
-	}
-	g_object_unref (task);
-}
-
-static void
-soup_address_address_enumerator_next_async (GSocketAddressEnumerator  *enumerator,
-					    GCancellable              *cancellable,
-					    GAsyncReadyCallback        callback,
-					    gpointer                   user_data)
-{
-	SoupAddressAddressEnumerator *addr_enum =
-		SOUP_ADDRESS_ADDRESS_ENUMERATOR (enumerator);
-	SoupAddressPrivate *priv = soup_address_get_instance_private (addr_enum->addr);
-	GTask *task;
-
-	task = g_task_new (enumerator, cancellable, callback, user_data);
-	if (!priv->sockaddr) {
-		soup_address_resolve_async (addr_enum->addr,
-					    g_main_context_get_thread_default (),
-					    cancellable, got_addresses, task);
-	} else {
-		g_task_return_pointer (task, next_address (addr_enum), g_object_unref);
-		g_object_unref (task);
-	}
-}
-
-static GSocketAddress *
-soup_address_address_enumerator_next_finish (GSocketAddressEnumerator  *enumerator,
-					     GAsyncResult              *result,
-					     GError                   **error)
-{
-	return g_task_propagate_pointer (G_TASK (result), error);
-}
-
-static void
-_soup_address_address_enumerator_init (SoupAddressAddressEnumerator *enumerator)
-{
-}
-
-static void
-_soup_address_address_enumerator_class_init (SoupAddressAddressEnumeratorClass *addrenum_class)
-{
-	GObjectClass *object_class = G_OBJECT_CLASS (addrenum_class);
-	GSocketAddressEnumeratorClass *enumerator_class =
-		G_SOCKET_ADDRESS_ENUMERATOR_CLASS (addrenum_class);
-
-	enumerator_class->next = soup_address_address_enumerator_next;
-	enumerator_class->next_async = soup_address_address_enumerator_next_async;
-	enumerator_class->next_finish = soup_address_address_enumerator_next_finish;
-	object_class->finalize = soup_address_address_enumerator_finalize;
-}
-
-static GSocketAddressEnumerator *
-soup_address_connectable_enumerate (GSocketConnectable *connectable)
-{
-	SoupAddressAddressEnumerator *addr_enum;
-	SoupAddressPrivate *priv;
-
-	addr_enum = g_object_new (SOUP_TYPE_ADDRESS_ADDRESS_ENUMERATOR, NULL);
-	addr_enum->addr = g_object_ref (SOUP_ADDRESS (connectable));
-
-	priv = soup_address_get_instance_private (addr_enum->addr);
-	addr_enum->orig_offset = priv->offset;
-
-	return (GSocketAddressEnumerator *)addr_enum;
-}
-
-static GSocketAddressEnumerator *
-soup_address_connectable_proxy_enumerate (GSocketConnectable *connectable)
-{
-	SoupAddress *addr = SOUP_ADDRESS (connectable);
-	SoupAddressPrivate *priv = soup_address_get_instance_private (addr);
-	GSocketAddressEnumerator *proxy_enum;
-	SoupURI *uri;
-	char *uri_string;
-
-	/* We cheerily assume "http" here because you shouldn't be
-	 * using SoupAddress any more if you're not doing HTTP anyway.
-	 */
-	uri = soup_uri_new (NULL);
-	soup_uri_set_scheme (uri, priv->protocol ? priv->protocol : "http");
-	soup_uri_set_host (uri, priv->name ? priv->name : soup_address_get_physical (addr));
-	soup_uri_set_port (uri, priv->port);
-	soup_uri_set_path (uri, "");
-	uri_string = soup_uri_to_string_internal (uri, FALSE, FALSE, TRUE);
-
-	proxy_enum = g_object_new (G_TYPE_PROXY_ADDRESS_ENUMERATOR,
-				   "connectable", connectable,
-				   "uri", uri_string,
-				   NULL);
-	g_free (uri_string);
-	soup_uri_free (uri);
-
-	return proxy_enum;
-}
-
-static void
-soup_address_connectable_iface_init (GSocketConnectableIface *connectable_iface)
-{
-  connectable_iface->enumerate       = soup_address_connectable_enumerate;
-  connectable_iface->proxy_enumerate = soup_address_connectable_proxy_enumerate;
-}
diff --git a/libsoup/soup-address.h b/libsoup/soup-address.h
deleted file mode 100644
index 7c71fda6..00000000
--- a/libsoup/soup-address.h
+++ /dev/null
@@ -1,110 +0,0 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
-/*
- * Copyright (C) 2000-2003, Ximian, Inc.
- */
-
-#ifndef __SOUP_ADDRESS_H__
-#define __SOUP_ADDRESS_H__
-
-#include <sys/types.h>
-
-#include "soup-types.h"
-
-G_BEGIN_DECLS
-
-#define SOUP_TYPE_ADDRESS            (soup_address_get_type ())
-#define SOUP_ADDRESS(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOUP_TYPE_ADDRESS, SoupAddress))
-#define SOUP_ADDRESS_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_ADDRESS, SoupAddressClass))
-#define SOUP_IS_ADDRESS(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SOUP_TYPE_ADDRESS))
-#define SOUP_IS_ADDRESS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_ADDRESS))
-#define SOUP_ADDRESS_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_ADDRESS, SoupAddressClass))
-
-struct _SoupAddress {
-	GObject parent;
-
-};
-
-typedef struct {
-	GObjectClass parent_class;
-
-	/* Padding for future expansion */
-	void (*_libsoup_reserved1) (void);
-	void (*_libsoup_reserved2) (void);
-	void (*_libsoup_reserved3) (void);
-	void (*_libsoup_reserved4) (void);
-} SoupAddressClass;
-
-#define SOUP_ADDRESS_NAME     "name"
-#define SOUP_ADDRESS_FAMILY   "family"
-#define SOUP_ADDRESS_PORT     "port"
-#define SOUP_ADDRESS_PROTOCOL "protocol"
-#define SOUP_ADDRESS_PHYSICAL "physical"
-#define SOUP_ADDRESS_SOCKADDR "sockaddr"
-
-typedef enum {
-	SOUP_ADDRESS_FAMILY_INVALID = -1,
-
-	SOUP_ADDRESS_FAMILY_IPV4 = G_SOCKET_FAMILY_IPV4,
-	SOUP_ADDRESS_FAMILY_IPV6 = G_SOCKET_FAMILY_IPV6
-} SoupAddressFamily;
-
-#define SOUP_ADDRESS_ANY_PORT 0
-
-struct sockaddr;
-
-typedef void   (*SoupAddressCallback)            (SoupAddress         *addr,
-						  guint                status,
-						  gpointer             user_data);
-
-SOUP_AVAILABLE_IN_2_4
-GType soup_address_get_type (void);
-
-SOUP_AVAILABLE_IN_2_4
-SoupAddress     *soup_address_new                (const char          *name,
-						  guint                port);
-SOUP_AVAILABLE_IN_2_4
-SoupAddress     *soup_address_new_from_sockaddr  (struct sockaddr     *sa,
-						  int                  len);
-SOUP_AVAILABLE_IN_2_4
-SoupAddress     *soup_address_new_any            (SoupAddressFamily    family,
-						  guint                port);
-
-SOUP_AVAILABLE_IN_2_4
-void             soup_address_resolve_async      (SoupAddress         *addr,
-						  GMainContext        *async_context,
-						  GCancellable        *cancellable,
-						  SoupAddressCallback  callback,
-						  gpointer             user_data);
-SOUP_AVAILABLE_IN_2_4
-guint            soup_address_resolve_sync       (SoupAddress         *addr,
-						  GCancellable        *cancellable);
-
-SOUP_AVAILABLE_IN_2_4
-const char      *soup_address_get_name           (SoupAddress         *addr);
-SOUP_AVAILABLE_IN_2_4
-const char      *soup_address_get_physical       (SoupAddress         *addr);
-SOUP_AVAILABLE_IN_2_4
-guint            soup_address_get_port           (SoupAddress         *addr);
-SOUP_AVAILABLE_IN_2_4
-struct sockaddr *soup_address_get_sockaddr       (SoupAddress         *addr,
-						  int                 *len);
-SOUP_AVAILABLE_IN_2_32
-GSocketAddress  *soup_address_get_gsockaddr      (SoupAddress         *addr);
-SOUP_AVAILABLE_IN_2_4
-gboolean         soup_address_is_resolved        (SoupAddress         *addr);
-
-SOUP_AVAILABLE_IN_2_26
-guint            soup_address_hash_by_name       (gconstpointer        addr);
-SOUP_AVAILABLE_IN_2_26
-gboolean         soup_address_equal_by_name      (gconstpointer        addr1,
-						  gconstpointer        addr2);
-SOUP_AVAILABLE_IN_2_26
-guint            soup_address_hash_by_ip         (gconstpointer        addr);
-SOUP_AVAILABLE_IN_2_26
-gboolean         soup_address_equal_by_ip        (gconstpointer        addr1,
-						  gconstpointer        addr2);
-
-
-G_END_DECLS
-
-#endif /* __SOUP_ADDRESS_H__ */
diff --git a/libsoup/soup-autocleanups.h b/libsoup/soup-autocleanups.h
index 18b5c72e..9566c4ae 100644
--- a/libsoup/soup-autocleanups.h
+++ b/libsoup/soup-autocleanups.h
@@ -26,7 +26,6 @@
 #ifndef __GI_SCANNER__
 #ifdef G_DEFINE_AUTOPTR_CLEANUP_FUNC
 
-G_DEFINE_AUTOPTR_CLEANUP_FUNC(SoupAddress, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(SoupAuth, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(SoupAuthDomain, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(SoupAuthDomainBasic, g_object_unref)
diff --git a/libsoup/soup-connection.c b/libsoup/soup-connection.c
index 490ea4fb..fb6eac40 100644
--- a/libsoup/soup-connection.c
+++ b/libsoup/soup-connection.c
@@ -390,7 +390,7 @@ soup_connection_connect_async (SoupConnection      *conn,
 			       gpointer             user_data)
 {
 	SoupConnectionPrivate *priv;
-	SoupAddress *remote_addr;
+	GInetSocketAddress *remote_addr;
 	GTask *task;
 
 	g_return_if_fail (SOUP_IS_CONNECTION (conn));
@@ -401,14 +401,14 @@ soup_connection_connect_async (SoupConnection      *conn,
 
 	/* Set the protocol to ensure correct proxy resolution. */
 	remote_addr =
-		g_object_new (SOUP_TYPE_ADDRESS,
-			      SOUP_ADDRESS_NAME, priv->remote_uri->host,
-			      SOUP_ADDRESS_PORT, priv->remote_uri->port,
-			      SOUP_ADDRESS_PROTOCOL, priv->remote_uri->scheme,
+		g_object_new (G_TYPE_NETWORK_ADDRESS,
+			      "hostname", priv->remote_uri->host,
+			      "port", priv->remote_uri->port,
+			      "scheme", priv->remote_uri->scheme,
 			      NULL);
 
 	priv->socket =
-		soup_socket_new (SOUP_SOCKET_REMOTE_ADDRESS, remote_addr,
+		soup_socket_new (SOUP_SOCKET_REMOTE_CONNECTABLE, remote_addr,
 				 SOUP_SOCKET_SOCKET_PROPERTIES, priv->socket_props,
 				 NULL);
 	g_object_unref (remote_addr);
@@ -436,7 +436,7 @@ soup_connection_connect_sync (SoupConnection  *conn,
 			      GError         **error)
 {
 	SoupConnectionPrivate *priv;
-	SoupAddress *remote_addr;
+	GNetworkAddress *remote_addr;
 
 	g_return_val_if_fail (SOUP_IS_CONNECTION (conn), FALSE);
 	priv = soup_connection_get_instance_private (conn);
@@ -446,14 +446,14 @@ soup_connection_connect_sync (SoupConnection  *conn,
 
 	/* Set the protocol to ensure correct proxy resolution. */
 	remote_addr =
-		g_object_new (SOUP_TYPE_ADDRESS,
-			      SOUP_ADDRESS_NAME, priv->remote_uri->host,
-			      SOUP_ADDRESS_PORT, priv->remote_uri->port,
-			      SOUP_ADDRESS_PROTOCOL, priv->remote_uri->scheme,
+		g_object_new (G_TYPE_NETWORK_ADDRESS,
+			      "hostname", priv->remote_uri->host,
+			      "port", priv->remote_uri->port,
+			      "scheme", priv->remote_uri->scheme,
 			      NULL);
 
 	priv->socket =
-		soup_socket_new (SOUP_SOCKET_REMOTE_ADDRESS, remote_addr,
+		soup_socket_new (SOUP_SOCKET_REMOTE_CONNECTABLE, remote_addr,
 				 SOUP_SOCKET_SOCKET_PROPERTIES, priv->socket_props,
 				 SOUP_SOCKET_FLAG_NONBLOCKING, FALSE,
 				 NULL);
diff --git a/libsoup/soup-message-private.h b/libsoup/soup-message-private.h
index 2dac8fc7..f9ed82d0 100644
--- a/libsoup/soup-message-private.h
+++ b/libsoup/soup-message-private.h
@@ -24,7 +24,6 @@ typedef struct {
 	SoupHTTPVersion    http_version, orig_http_version;
 
 	SoupURI           *uri;
-	SoupAddress       *addr;
 
 	SoupAuth          *auth, *proxy_auth;
 	SoupConnection    *connection;
diff --git a/libsoup/soup-message-server-io.c b/libsoup/soup-message-server-io.c
index 196690a7..3e00f3ea 100644
--- a/libsoup/soup-message-server-io.c
+++ b/libsoup/soup-message-server-io.c
@@ -110,15 +110,18 @@ parse_request_headers (SoupMessage *msg, char *headers, guint headers_len,
 		g_free (url);
 	} else if (soup_message_get_http_version (msg) == SOUP_HTTP_1_0) {
 		/* No Host header, no AbsoluteUri */
-		SoupAddress *addr = soup_socket_get_local_address (sock);
+		GInetSocketAddress *addr = soup_socket_get_local_address (sock);
+                GInetAddress *inet_addr = g_inet_socket_address_get_address (addr);
+                char *local_ip = g_inet_address_to_string (inet_addr);
 
 		uri = soup_uri_new (NULL);
 		soup_uri_set_scheme (uri, soup_socket_is_ssl (sock) ?
 				     SOUP_URI_SCHEME_HTTPS :
 				     SOUP_URI_SCHEME_HTTP);
-		soup_uri_set_host (uri, soup_address_get_physical (addr));
-		soup_uri_set_port (uri, soup_address_get_port (addr));
+		soup_uri_set_host (uri, local_ip);
+		soup_uri_set_port (uri, g_inet_socket_address_get_port (addr));
 		soup_uri_set_path (uri, req_path);
+		g_free (local_ip);
 	} else
 		uri = NULL;
 
diff --git a/libsoup/soup-message.c b/libsoup/soup-message.c
index ae0bb0bc..cf494709 100644
--- a/libsoup/soup-message.c
+++ b/libsoup/soup-message.c
@@ -175,7 +175,6 @@ soup_message_finalize (GObject *object)
 	g_clear_pointer (&priv->uri, soup_uri_free);
 	g_clear_pointer (&priv->first_party, soup_uri_free);
 	g_clear_pointer (&priv->site_for_cookies, soup_uri_free);
-	g_clear_object (&priv->addr);
 
 	g_clear_object (&priv->auth);
 	g_clear_object (&priv->proxy_auth);
@@ -1668,10 +1667,6 @@ soup_message_set_uri (SoupMessage *msg, SoupURI *uri)
 
 	if (priv->uri)
 		soup_uri_free (priv->uri);
-	if (priv->addr) {
-		g_object_unref (priv->addr);
-		priv->addr = NULL;
-	}
 	priv->uri = soup_uri_copy (uri);
 
 	g_object_notify (G_OBJECT (msg), SOUP_MESSAGE_URI);
@@ -1698,33 +1693,6 @@ soup_message_get_uri (SoupMessage *msg)
 }
 
 /**
- * soup_message_get_address:
- * @msg: a #SoupMessage
- *
- * Gets the address @msg's URI points to. After first setting the
- * URI on a message, this will be unresolved, although the message's
- * session will resolve it before sending the message.
- *
- * Return value: (transfer none): the address @msg's URI points to
- *
- * Since: 2.26
- **/
-SoupAddress *
-soup_message_get_address (SoupMessage *msg)
-{
-	SoupMessagePrivate *priv;
-
-	g_return_val_if_fail (SOUP_IS_MESSAGE (msg), NULL);
-
-	priv = soup_message_get_instance_private (msg);
-	if (!priv->addr) {
-		priv->addr = soup_address_new (priv->uri->host,
-					       priv->uri->port);
-	}
-	return priv->addr;
-}
-
-/**
  * soup_message_set_status:
  * @msg: a #SoupMessage
  * @status_code: an HTTP status code
diff --git a/libsoup/soup-message.h b/libsoup/soup-message.h
index bfc2651d..c4cd49e8 100644
--- a/libsoup/soup-message.h
+++ b/libsoup/soup-message.h
@@ -120,9 +120,6 @@ SoupURI         *soup_message_get_uri             (SoupMessage       *msg);
 SOUP_AVAILABLE_IN_2_4
 void             soup_message_set_uri             (SoupMessage       *msg,
 						   SoupURI           *uri);
-SOUP_AVAILABLE_IN_2_26
-SoupAddress     *soup_message_get_address         (SoupMessage       *msg);
-
 SOUP_AVAILABLE_IN_2_30
 SoupURI         *soup_message_get_first_party     (SoupMessage       *msg);
 SOUP_AVAILABLE_IN_2_30
diff --git a/libsoup/soup-misc.h b/libsoup/soup-misc.h
index 7627012b..770ecf54 100644
--- a/libsoup/soup-misc.h
+++ b/libsoup/soup-misc.h
@@ -84,8 +84,6 @@ guint soup_message_headers_get_ranges_internal (SoupMessageHeaders  *hdrs,
 						SoupRange          **ranges,
 						int                 *length);
 
-SoupAddress *soup_address_new_from_gsockaddr (GSocketAddress *addr);
-
 gboolean           soup_host_matches_host    (const gchar *host,
 					      const gchar *compare_with);
 
diff --git a/libsoup/soup-server.c b/libsoup/soup-server.c
index 34f9cb8d..eb2c3530 100644
--- a/libsoup/soup-server.c
+++ b/libsoup/soup-server.c
@@ -181,9 +181,6 @@ typedef struct {
 
 	char             **http_aliases, **https_aliases;
 
-	SoupAddress       *legacy_iface;
-	int                legacy_port;
-
 	GPtrArray         *websocket_extension_types;
 
 	gboolean           disposed;
@@ -1217,22 +1214,13 @@ soup_server_accept_iostream   (SoupServer     *server,
 			       GError        **error)
 {
 	SoupSocket *sock;
-	SoupAddress *local = NULL, *remote = NULL;
-
-	if (local_addr)
-		local = soup_address_new_from_gsockaddr (local_addr);
-	if (remote_addr)
-		remote = soup_address_new_from_gsockaddr (remote_addr);
 
 	sock = g_initable_new (SOUP_TYPE_SOCKET, NULL, error,
 			       "iostream", stream,
-			       "local-address", local,
-			       "remote-address", remote,
+			       SOUP_SOCKET_LOCAL_ADDRESS, local_addr,
+			       SOUP_SOCKET_REMOTE_CONNECTABLE, remote_addr,
 			       NULL);
 
-	g_clear_object (&local);
-	g_clear_object (&remote);
-
 	if (!sock)
 		return FALSE;
 
@@ -1340,12 +1328,15 @@ soup_server_listen_internal (SoupServer *server, SoupSocket *listener,
 		      NULL);
 	if (!is_listening) {
 		if (!soup_socket_listen_full (listener, error)) {
-			SoupAddress *saddr = soup_socket_get_local_address (listener);
+			GInetSocketAddress *addr =  soup_socket_get_local_address (listener);
+			GInetAddress *inet_addr = g_inet_socket_address_get_address (addr);
+			char *local_ip = g_inet_address_to_string (inet_addr);
 
 			g_prefix_error (error,
 					_("Could not listen on address %s, port %d: "),
-					soup_address_get_physical (saddr),
-					soup_address_get_port (saddr));
+					local_ip,
+					g_inet_socket_address_get_port (addr));
+			g_free (local_ip);
 			return FALSE;
 		}
 	}
@@ -1399,7 +1390,6 @@ soup_server_listen (SoupServer *server, GSocketAddress *address,
 {
 	SoupServerPrivate *priv;
 	SoupSocket *listener;
-	SoupAddress *saddr;
 	gboolean success;
 
 	g_return_val_if_fail (SOUP_IS_SERVER (server), FALSE);
@@ -1409,14 +1399,12 @@ soup_server_listen (SoupServer *server, GSocketAddress *address,
 	priv = soup_server_get_instance_private (server);
 	g_return_val_if_fail (priv->disposed == FALSE, FALSE);
 
-	saddr = soup_address_new_from_gsockaddr (address);
-	listener = soup_socket_new (SOUP_SOCKET_LOCAL_ADDRESS, saddr,
+	listener = soup_socket_new (SOUP_SOCKET_LOCAL_ADDRESS, address,
 				    SOUP_SOCKET_IPV6_ONLY, TRUE,
 				    NULL);
 
 	success = soup_server_listen_internal (server, listener, options, error);
 	g_object_unref (listener);
-	g_object_unref (saddr);
 
 	return success;
 }
@@ -1449,7 +1437,7 @@ soup_server_listen_ipv4_ipv6 (SoupServer *server,
 		g_object_unref (addr4);
 
 		v4sock = priv->listeners->data;
-		v4port = soup_address_get_port (soup_socket_get_local_address (v4sock));
+		v4port = g_inet_socket_address_get_port (soup_socket_get_local_address (v4sock));
 	} else {
 		v4sock = NULL;
 		v4port = port;
@@ -1723,7 +1711,9 @@ soup_server_get_uris (SoupServer *server)
 	SoupServerPrivate *priv;
 	GSList *uris, *l;
 	SoupSocket *listener;
-	SoupAddress *addr;
+	GInetSocketAddress *addr;
+	GInetAddress *inet_addr;
+	char *ip;
 	SoupURI *uri;
 	gpointer creds;
 
@@ -1733,15 +1723,19 @@ soup_server_get_uris (SoupServer *server)
 	for (l = priv->listeners, uris = NULL; l; l = l->next) {
 		listener = l->data;
 		addr = soup_socket_get_local_address (listener);
+		inet_addr = g_inet_socket_address_get_address (addr);
+		ip = g_inet_address_to_string (inet_addr);
 		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_host (uri, ip);
+		soup_uri_set_port (uri, g_inet_socket_address_get_port (addr));
 		soup_uri_set_path (uri, "/");
 
 		uris = g_slist_prepend (uris, uri);
+
+		g_free (ip);
 	}
 
 	return uris;
@@ -1841,7 +1835,7 @@ soup_client_context_get_remote_address (SoupClientContext *client)
 
 	client->remote_addr = client->gsock ?
 		g_socket_get_remote_address (client->gsock, NULL) :
-		soup_address_get_gsockaddr (soup_socket_get_remote_address (client->sock));
+		G_SOCKET_ADDRESS (g_object_ref (soup_socket_get_remote_address (client->sock)));
 
 	return client->remote_addr;
 }
@@ -1869,7 +1863,7 @@ soup_client_context_get_local_address (SoupClientContext *client)
 
 	client->local_addr = client->gsock ?
 		g_socket_get_local_address (client->gsock, NULL) :
-		soup_address_get_gsockaddr (soup_socket_get_local_address (client->sock));
+		G_SOCKET_ADDRESS (g_object_ref (soup_socket_get_local_address (client->sock)));
 
 	return client->local_addr;
 }
@@ -1902,12 +1896,9 @@ soup_client_context_get_host (SoupClientContext *client)
 		iaddr = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (addr));
 		client->remote_ip = g_inet_address_to_string (iaddr);
 	} else {
-		SoupAddress *addr;
-
-		G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
-		addr = soup_socket_get_remote_address (client->sock);
-		G_GNUC_END_IGNORE_DEPRECATIONS;
-		client->remote_ip = g_strdup (soup_address_get_physical (addr));
+		GInetSocketAddress *addr = G_INET_SOCKET_ADDRESS (soup_socket_get_remote_address (client->sock));
+                GInetAddress *inet_addr = g_inet_socket_address_get_address (addr);
+		client->remote_ip = g_inet_address_to_string (inet_addr);
 	}
 
 	return client->remote_ip;
diff --git a/libsoup/soup-session.c b/libsoup/soup-session.c
index a4b03aa5..1f08a269 100644
--- a/libsoup/soup-session.c
+++ b/libsoup/soup-session.c
@@ -67,8 +67,8 @@
  **/
 
 typedef struct {
-	SoupURI     *uri;
-	SoupAddress *addr;
+	SoupURI         *uri;
+	GNetworkAddress *addr;
 
 	GSList      *connections;      /* CONTAINS: SoupConnection */
 	guint        num_conns;
@@ -90,7 +90,7 @@ typedef struct {
 	gboolean tlsdb_use_default;
 
 	guint io_timeout, idle_timeout;
-	SoupAddress *local_addr;
+	GInetSocketAddress *local_addr;
 
 	GResolver *resolver;
 	GProxyResolver *proxy_resolver;
@@ -702,10 +702,10 @@ soup_session_host_new (SoupSession *session, SoupURI *uri)
 			host->uri->scheme = SOUP_URI_SCHEME_HTTP;
 	}
 
-	host->addr = g_object_new (SOUP_TYPE_ADDRESS,
-				   SOUP_ADDRESS_NAME, host->uri->host,
-				   SOUP_ADDRESS_PORT, host->uri->port,
-				   SOUP_ADDRESS_PROTOCOL, host->uri->scheme,
+	host->addr = g_object_new (G_TYPE_NETWORK_ADDRESS,
+				   "hostname", host->uri->host,
+				   "port", host->uri->port,
+				   "scheme", host->uri->scheme,
 				   NULL);
 	host->keep_alive_src = NULL;
 	host->session = session;
@@ -1128,7 +1128,7 @@ drop_connection (SoupSession *session, SoupSessionHost *host, SoupConnection *co
 		host->connections = g_slist_remove (host->connections, conn);
 		host->num_conns--;
 
-		/* Free the SoupHost (and its SoupAddress) if there
+		/* Free the SoupHost (and its GNetworkAddress) if there
 		 * has not been any new connection to the host during
 		 * the last HOST_KEEP_ALIVE msecs.
 		 */
@@ -2193,25 +2193,10 @@ soup_session_abort (SoupSession *session)
 }
 
 static void
-prefetch_uri (SoupSession *session, SoupURI *uri,
-	      GCancellable *cancellable,
-	      SoupAddressCallback callback, gpointer user_data)
+on_prefetch_finish (GObject *source, GAsyncResult *result, gpointer user_data)
 {
-	SoupSessionPrivate *priv;
-	SoupSessionHost *host;
-	SoupAddress *addr;
-
-	priv = soup_session_get_instance_private (session);
-
-	g_mutex_lock (&priv->conn_lock);
-	host = get_host_for_uri (session, uri);
-	addr = g_object_ref (host->addr);
-	g_mutex_unlock (&priv->conn_lock);
-
-	soup_address_resolve_async (addr,
-				    priv->async_context,
-				    cancellable, callback, user_data);
-	g_object_unref (addr);
+        GList *addresses = g_resolver_lookup_by_name_finish (G_RESOLVER (source), result, NULL);
+        g_clear_pointer (&addresses, g_resolver_free_addresses);
 }
 
 /**
@@ -2219,9 +2204,6 @@ prefetch_uri (SoupSession *session, SoupURI *uri,
 * @session: a #SoupSession
 * @hostname: a hostname to be resolved
 * @cancellable: (allow-none): a #GCancellable object, or %NULL
-* @callback: (scope async) (allow-none): callback to call with the
-*     result, or %NULL
-* @user_data: data for @callback
 *
 * Tells @session that an URI from the given @hostname may be requested
 * shortly, and so the session can try to prepare by resolving the
@@ -2229,29 +2211,21 @@ prefetch_uri (SoupSession *session, SoupURI *uri,
 * is actually requested.
 *
 * If @cancellable is non-%NULL, it can be used to cancel the
-* resolution. @callback will still be invoked in this case, with a
-* status of %SOUP_STATUS_CANCELLED.
+* resolution.
 *
 * Since: 2.38
 **/
 void
-soup_session_prefetch_dns (SoupSession *session, const char *hostname,
-			   GCancellable *cancellable,
-			   SoupAddressCallback callback, gpointer user_data)
+soup_session_prefetch_dns (SoupSession *session,
+                           const char *hostname,
+			   GCancellable *cancellable)
 {
-	SoupURI *uri;
-
-	g_return_if_fail (SOUP_IS_SESSION (session));
-	g_return_if_fail (hostname != NULL);
-
-	/* FIXME: Prefetching should work for both HTTP and HTTPS */
-	uri = soup_uri_new (NULL);
-	soup_uri_set_scheme (uri, SOUP_URI_SCHEME_HTTP);
-	soup_uri_set_host (uri, hostname);
-	soup_uri_set_path (uri, "");
+        g_return_if_fail (SOUP_IS_SESSION (session));
+        g_return_if_fail (hostname);
 
-	prefetch_uri (session, uri, cancellable, callback, user_data);
-	soup_uri_free (uri);
+        GResolver *resolver = g_resolver_get_default ();
+        g_resolver_lookup_by_name_async (resolver, hostname, cancellable, on_prefetch_finish, NULL);
+        g_object_unref (resolver);
 }
 
 /**
@@ -3224,7 +3198,7 @@ soup_session_class_init (SoupSessionClass *session_class)
 	/**
 	 * SoupSession:local-address:
 	 *
-	 * Sets the #SoupAddress to use for the client side of
+	 * Sets the #GInetSocketAddress to use for the client side of
 	 * the connection.
 	 *
 	 * Use this property if you want for instance to bind the
@@ -3237,7 +3211,7 @@ soup_session_class_init (SoupSessionClass *session_class)
 		g_param_spec_object (SOUP_SESSION_LOCAL_ADDRESS,
 				     "Local address",
 				     "Address of local end of socket",
-				     SOUP_TYPE_ADDRESS,
+				     G_TYPE_INET_SOCKET_ADDRESS,
 				     G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
 				     G_PARAM_STATIC_STRINGS));
 
diff --git a/libsoup/soup-session.h b/libsoup/soup-session.h
index d4496e63..af2d42ca 100644
--- a/libsoup/soup-session.h
+++ b/libsoup/soup-session.h
@@ -7,7 +7,6 @@
 #define __SOUP_SESSION_H__ 1
 
 #include "soup-types.h"
-#include "soup-address.h"
 #include "soup-message.h"
 #include "websocket/soup-websocket-connection.h"
 
@@ -121,9 +120,7 @@ GInputStream   *soup_session_send             (SoupSession           *session,
 SOUP_AVAILABLE_IN_2_38
 void            soup_session_prefetch_dns     (SoupSession           *session,
 					       const char            *hostname,
-					       GCancellable          *cancellable,
-					       SoupAddressCallback    callback,
-					       gpointer               user_data);
+					       GCancellable          *cancellable);
 
 SOUP_AVAILABLE_IN_2_38
 gboolean        soup_session_would_redirect   (SoupSession           *session,
diff --git a/libsoup/soup-socket-private.h b/libsoup/soup-socket-private.h
index 1d4d6f45..cae424f5 100644
--- a/libsoup/soup-socket-private.h
+++ b/libsoup/soup-socket-private.h
@@ -52,7 +52,7 @@ gboolean   soup_socket_listen_full             (SoupSocket           *sock,
 
 typedef struct {
 	GProxyResolver *proxy_resolver;
-	SoupAddress *local_addr;
+	GInetSocketAddress *local_addr;
 
 	GTlsDatabase *tlsdb;
 	GTlsInteraction *tls_interaction;
@@ -68,13 +68,13 @@ typedef struct {
 GType soup_socket_properties_get_type (void);
 #define SOUP_TYPE_SOCKET_PROPERTIES (soup_socket_properties_get_type ())
 
-SoupSocketProperties *soup_socket_properties_new   (GProxyResolver  *proxy_resolver,
-						    SoupAddress     *local_addr,
-						    GTlsDatabase    *tlsdb,
-						    GTlsInteraction *tls_interaction,
-						    gboolean         ssl_strict,
-						    guint            io_timeout,
-						    guint            idle_timeout);
+SoupSocketProperties *soup_socket_properties_new   (GProxyResolver     *proxy_resolver,
+			                            GInetSocketAddress *local_addr,
+						    GTlsDatabase       *tlsdb,
+						    GTlsInteraction    *tls_interaction,
+						    gboolean            ssl_strict,
+						    guint               io_timeout,
+						    guint               idle_timeout);
 
 SoupSocketProperties *soup_socket_properties_ref   (SoupSocketProperties *props);
 void                  soup_socket_properties_unref (SoupSocketProperties *props);
diff --git a/libsoup/soup-socket-properties.c b/libsoup/soup-socket-properties.c
index 38bfea3c..8e132435 100644
--- a/libsoup/soup-socket-properties.c
+++ b/libsoup/soup-socket-properties.c
@@ -11,13 +11,13 @@
 #include "soup.h"
 
 SoupSocketProperties *
-soup_socket_properties_new (GProxyResolver  *proxy_resolver,
-			    SoupAddress     *local_addr,
-			    GTlsDatabase    *tlsdb,
-			    GTlsInteraction *tls_interaction,
-			    gboolean         ssl_strict,
-			    guint            io_timeout,
-			    guint            idle_timeout)
+soup_socket_properties_new (GProxyResolver     *proxy_resolver,
+			    GInetSocketAddress *local_addr,
+			    GTlsDatabase       *tlsdb,
+			    GTlsInteraction    *tls_interaction,
+			    gboolean            ssl_strict,
+			    guint               io_timeout,
+			    guint               idle_timeout)
 {
 	SoupSocketProperties *props;
 
diff --git a/libsoup/soup-socket.c b/libsoup/soup-socket.c
index 686d8eec..21964efc 100644
--- a/libsoup/soup-socket.c
+++ b/libsoup/soup-socket.c
@@ -48,7 +48,8 @@ enum {
 	PROP_GSOCKET,
 	PROP_IOSTREAM,
 	PROP_LOCAL_ADDRESS,
-	PROP_REMOTE_ADDRESS,
+        PROP_REMOTE_ADDRESS,
+	PROP_REMOTE_CONNECTABLE,
 	PROP_NON_BLOCKING,
 	PROP_IPV6_ONLY,
 	PROP_IS_SERVER,
@@ -65,7 +66,8 @@ enum {
 };
 
 typedef struct {
-	SoupAddress *local_addr, *remote_addr;
+	GInetSocketAddress *local_addr, *remote_addr;
+        GSocketConnectable *remote_connectable;
 	GIOStream *conn, *iostream;
 	GSocket *gsock;
 	GInputStream *istream;
@@ -87,7 +89,7 @@ typedef struct {
 	GSource        *watch_src;
 	GSource        *read_src, *write_src;
 
-	GMutex iolock, addrlock;
+	GMutex iolock;
 	guint timeout;
 
 	GCancellable *connect_cancel;
@@ -114,7 +116,6 @@ soup_socket_init (SoupSocket *sock)
 
 	priv->non_blocking = TRUE;
 	priv->fd = -1;
-	g_mutex_init (&priv->addrlock);
 	g_mutex_init (&priv->iolock);
 
         priv->async_context = g_main_context_ref_thread_default ();
@@ -225,6 +226,7 @@ soup_socket_finalize (GObject *object)
 
 	g_clear_object (&priv->local_addr);
 	g_clear_object (&priv->remote_addr);
+        g_clear_object (&priv->remote_connectable);
 
 	g_clear_object (&priv->tls_interaction);
 	g_clear_object (&priv->proxy_resolver);
@@ -237,7 +239,6 @@ soup_socket_finalize (GObject *object)
 	}
 	g_clear_pointer (&priv->async_context, g_main_context_unref);
 
-	g_mutex_clear (&priv->addrlock);
 	g_mutex_clear (&priv->iolock);
 
 	G_OBJECT_CLASS (soup_socket_parent_class)->finalize (object);
@@ -288,8 +289,11 @@ soup_socket_set_property (GObject *object, guint prop_id,
 	case PROP_LOCAL_ADDRESS:
 		priv->local_addr = g_value_dup_object (value);
 		break;
-	case PROP_REMOTE_ADDRESS:
-		priv->remote_addr = g_value_dup_object (value);
+        case PROP_REMOTE_ADDRESS:
+                priv->remote_addr = g_value_dup_object (value);
+                break;
+	case PROP_REMOTE_CONNECTABLE:
+		priv->remote_connectable = g_value_dup_object (value);
 		break;
 	case PROP_NON_BLOCKING:
 		priv->non_blocking = g_value_get_boolean (value);
@@ -358,10 +362,13 @@ soup_socket_get_property (GObject *object, guint prop_id,
 		g_value_set_int (value, priv->fd);
 		break;
 	case PROP_LOCAL_ADDRESS:
-		g_value_set_object (value, soup_socket_get_local_address (SOUP_SOCKET (object)));
+		g_value_set_object (value, soup_socket_get_local_address (sock));
 		break;
-	case PROP_REMOTE_ADDRESS:
-		g_value_set_object (value, soup_socket_get_remote_address (SOUP_SOCKET (object)));
+        case PROP_REMOTE_ADDRESS:
+                g_value_set_object (value, soup_socket_get_remote_address (sock));
+                break;
+	case PROP_REMOTE_CONNECTABLE:
+		g_value_set_object (value, priv->remote_connectable);
 		break;
 	case PROP_NON_BLOCKING:
 		g_value_set_boolean (value, priv->non_blocking);
@@ -543,7 +550,7 @@ soup_socket_class_init (SoupSocketClass *socket_class)
 		g_param_spec_object (SOUP_SOCKET_LOCAL_ADDRESS,
 				     "Local address",
 				     "Address of local end of socket",
-				     SOUP_TYPE_ADDRESS,
+				     G_TYPE_INET_SOCKET_ADDRESS,
 				     G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
 				     G_PARAM_STATIC_STRINGS));
 	/**
@@ -557,7 +564,22 @@ soup_socket_class_init (SoupSocketClass *socket_class)
 		g_param_spec_object (SOUP_SOCKET_REMOTE_ADDRESS,
 				     "Remote address",
 				     "Address of remote end of socket",
-				     SOUP_TYPE_ADDRESS,
+				     G_TYPE_SOCKET_ADDRESS,
+				     G_PARAM_READABLE |
+				     G_PARAM_STATIC_STRINGS));
+
+	/**
+	 * SOUP_SOCKET_REMOTE_CONNECTABLE:
+	 *
+	 * Alias for the #SoupSocket:remote-connectable property. (Address
+	 * to connect to.)
+	 **/
+	g_object_class_install_property (
+		object_class, PROP_REMOTE_CONNECTABLE,
+		g_param_spec_object (SOUP_SOCKET_REMOTE_CONNECTABLE,
+				     "Remote address",
+				     "Address to connect to",
+				     G_TYPE_SOCKET_CONNECTABLE,
 				     G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
 				     G_PARAM_STATIC_STRINGS));
 	/**
@@ -797,6 +819,22 @@ re_emit_socket_client_event (GSocketClient       *client,
 			     gpointer             user_data)
 {
 	SoupSocket *sock = user_data;
+	SoupSocketPrivate *priv = soup_socket_get_instance_private (sock);
+
+        switch (event) {
+        case G_SOCKET_CLIENT_CONNECTING: {
+                GError *error = NULL;
+                g_clear_object (&priv->remote_addr);
+                priv->remote_addr = G_INET_SOCKET_ADDRESS (g_socket_connection_get_remote_address (G_SOCKET_CONNECTION (connection), &error));
+                if (error) {
+                        g_warning ("Failed to set remote address: %s", error->message);
+                        g_error_free (error);
+                }
+                break;
+        }
+        default:
+                break;
+        }
 
 	soup_socket_event (sock, event, connection);
 }
@@ -848,14 +886,8 @@ new_socket_client (SoupSocket *sock)
 		g_socket_client_set_enable_proxy (client, FALSE);
 	if (priv->timeout)
 		g_socket_client_set_timeout (client, priv->timeout);
-
-	if (priv->local_addr) {
-		GSocketAddress *addr;
-
-		addr = soup_address_get_gsockaddr (priv->local_addr);
-		g_socket_client_set_local_address (client, addr);
-		g_object_unref (addr);
-	}
+	if (priv->local_addr)
+		g_socket_client_set_local_address (client, G_SOCKET_ADDRESS (priv->local_addr));
 
 	return client;
 }
@@ -899,14 +931,14 @@ soup_socket_connect_async_internal (SoupSocket          *sock,
 	priv = soup_socket_get_instance_private (sock);
 	g_return_if_fail (!priv->is_server);
 	g_return_if_fail (priv->gsock == NULL);
-	g_return_if_fail (priv->remote_addr != NULL);
+	g_return_if_fail (priv->remote_connectable != NULL);
 
 	priv->connect_cancel = cancellable ? g_object_ref (cancellable) : g_cancellable_new ();
 	task = g_task_new (sock, priv->connect_cancel, callback, user_data);
 
 	client = new_socket_client (sock);
 	g_socket_client_connect_async (client,
-				       G_SOCKET_CONNECTABLE (priv->remote_addr),
+				       G_SOCKET_CONNECTABLE (priv->remote_connectable),
 				       priv->connect_cancel,
 				       async_connected, task);
 	g_object_unref (client);
@@ -973,7 +1005,7 @@ soup_socket_connect_async (SoupSocket *sock, GCancellable *cancellable,
 	priv = soup_socket_get_instance_private (sock);
 	g_return_if_fail (!priv->is_server);
 	g_return_if_fail (priv->gsock == NULL);
-	g_return_if_fail (priv->remote_addr != NULL);
+	g_return_if_fail (priv->remote_connectable != NULL);
 
 	sacd = g_slice_new0 (SoupSocketAsyncConnectData);
 	sacd->sock = g_object_ref (sock);
@@ -998,13 +1030,13 @@ soup_socket_connect_sync_internal (SoupSocket    *sock,
 	priv = soup_socket_get_instance_private (sock);
 	g_return_val_if_fail (!priv->is_server, SOUP_STATUS_MALFORMED);
 	g_return_val_if_fail (priv->gsock == NULL, SOUP_STATUS_MALFORMED);
-	g_return_val_if_fail (priv->remote_addr != NULL, SOUP_STATUS_MALFORMED);
+	g_return_val_if_fail (priv->remote_connectable != NULL, SOUP_STATUS_MALFORMED);
 
 	priv->connect_cancel = cancellable ? g_object_ref (cancellable) : g_cancellable_new ();
 
 	client = new_socket_client (sock);
 	conn = g_socket_client_connect (client,
-					G_SOCKET_CONNECTABLE (priv->remote_addr),
+					G_SOCKET_CONNECTABLE (priv->remote_connectable),
 					priv->connect_cancel, error);
 	g_object_unref (client);
 
@@ -1034,7 +1066,7 @@ soup_socket_connect_sync (SoupSocket *sock, GCancellable *cancellable)
 	priv = soup_socket_get_instance_private (sock);
 	g_return_val_if_fail (!priv->is_server, SOUP_STATUS_MALFORMED);
 	g_return_val_if_fail (priv->gsock == NULL, SOUP_STATUS_MALFORMED);
-	g_return_val_if_fail (priv->remote_addr != NULL, SOUP_STATUS_MALFORMED);
+	g_return_val_if_fail (priv->remote_connectable != NULL, SOUP_STATUS_MALFORMED);
 
 	if (soup_socket_connect_sync_internal (sock, cancellable, &error))
 		return SOUP_STATUS_OK;
@@ -1086,8 +1118,7 @@ soup_socket_steal_gsocket (SoupSocket *sock)
 	g_return_val_if_fail (SOUP_IS_SOCKET (sock), NULL);
 	priv = soup_socket_get_instance_private (sock);
 
-	gsock = priv->gsock;
-	priv->gsock = NULL;
+	gsock = g_steal_pointer (&priv->gsock);
 	g_clear_object (&priv->conn);
 	g_clear_object (&priv->iostream);
 
@@ -1216,7 +1247,6 @@ soup_socket_listen_full (SoupSocket *sock,
 
 {
 	SoupSocketPrivate *priv;
-	GSocketAddress *addr;
 
 	g_return_val_if_fail (SOUP_IS_SOCKET (sock), FALSE);
 	priv = soup_socket_get_instance_private (sock);
@@ -1229,10 +1259,9 @@ soup_socket_listen_full (SoupSocket *sock,
 	 * have to make a new addr by calling getsockname(), which
 	 * will have the right port number.
 	 */
-	addr = soup_address_get_gsockaddr (priv->local_addr);
-	g_return_val_if_fail (addr != NULL, FALSE);
+	g_return_val_if_fail (priv->local_addr != NULL, FALSE);
 
-	priv->gsock = g_socket_new (g_socket_address_get_family (addr),
+	priv->gsock = g_socket_new (g_socket_address_get_family (G_SOCKET_ADDRESS (priv->local_addr)),
 				    G_SOCKET_TYPE_STREAM,
 				    G_SOCKET_PROTOCOL_DEFAULT,
 				    error);
@@ -1252,24 +1281,20 @@ soup_socket_listen_full (SoupSocket *sock,
 #endif
 
 	/* Bind */
-	if (!g_socket_bind (priv->gsock, addr, TRUE, error))
+	if (!g_socket_bind (priv->gsock, G_SOCKET_ADDRESS (priv->local_addr), TRUE, error))
 		goto cant_listen;
 	/* Force local_addr to be re-resolved now */
-	g_object_unref (priv->local_addr);
-	priv->local_addr = NULL;
+        g_clear_object (&priv->local_addr);
 
 	/* Listen */
 	if (!g_socket_listen (priv->gsock, error))
 		goto cant_listen;
 	finish_listener_setup (sock);
-
-	g_object_unref (addr);
 	return TRUE;
 
  cant_listen:
 	if (priv->conn)
 		disconnect_internal (sock, TRUE);
-	g_object_unref (addr);
 
 	return FALSE;
 }
@@ -1387,9 +1412,20 @@ gboolean
 soup_socket_start_ssl (SoupSocket *sock, GCancellable *cancellable)
 {
 	SoupSocketPrivate *priv = soup_socket_get_instance_private (sock);
-
-	return soup_socket_setup_ssl (sock, soup_address_get_name (priv->remote_addr),
-				      cancellable, NULL);
+        char *hostname = NULL;
+        gboolean ret;
+
+        if (G_IS_NETWORK_ADDRESS (priv->remote_connectable))
+                hostname = g_strdup (g_network_address_get_hostname (G_NETWORK_ADDRESS (priv->remote_connectable)));
+        else if (G_IS_INET_SOCKET_ADDRESS (priv->remote_connectable)) {
+                GInetAddress *addr = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (priv->remote_connectable));
+                hostname = g_inet_address_to_string (addr);
+        } else
+                g_assert_not_reached ();
+
+	ret = soup_socket_setup_ssl (sock, hostname, cancellable, NULL);
+        g_free (hostname);
+        return ret;
 }
 
 /**
@@ -1580,14 +1616,14 @@ soup_socket_is_connected (SoupSocket *sock)
  * soup_socket_get_local_address:
  * @sock: a #SoupSocket
  *
- * Returns the #SoupAddress corresponding to the local end of @sock.
+ * Returns the #GInetSocketAddress corresponding to the local end of @sock.
  *
  * Calling this method on an unconnected socket is considered to be
  * an error, and produces undefined results.
  *
- * Return value: (transfer none): the #SoupAddress
+ * Return value: (transfer none): the #GInetSocketAddress
  **/
-SoupAddress *
+GInetSocketAddress *
 soup_socket_get_local_address (SoupSocket *sock)
 {
 	SoupSocketPrivate *priv;
@@ -1595,31 +1631,21 @@ soup_socket_get_local_address (SoupSocket *sock)
 	g_return_val_if_fail (SOUP_IS_SOCKET (sock), NULL);
 	priv = soup_socket_get_instance_private (sock);
 
-	g_mutex_lock (&priv->addrlock);
 	if (!priv->local_addr) {
-		GSocketAddress *addr;
-		struct sockaddr_storage sa;
-		gssize sa_len;
 		GError *error = NULL;
 
 		if (priv->gsock == NULL) {
 			g_warning ("%s: socket not connected", G_STRLOC);
-			goto unlock;
+			return NULL;
 		}
 
-		addr = g_socket_get_local_address (priv->gsock, &error);
-		if (addr == NULL) {
+		priv->local_addr = G_INET_SOCKET_ADDRESS (g_socket_get_local_address (priv->gsock, &error));
+		if (priv->local_addr == NULL) {
 			g_warning ("%s: %s", G_STRLOC, error->message);
 			g_error_free (error);
-			goto unlock;
+                        return NULL;
 		}
-		sa_len = g_socket_address_get_native_size (addr);
-		g_socket_address_to_native (addr, &sa, sa_len, NULL);
-		priv->local_addr = soup_address_new_from_sockaddr ((struct sockaddr *)&sa, sa_len);
-		g_object_unref (addr);
 	}
-unlock:
-	g_mutex_unlock (&priv->addrlock);
 
 	return priv->local_addr;
 }
@@ -1628,14 +1654,14 @@ unlock:
  * soup_socket_get_remote_address:
  * @sock: a #SoupSocket
  *
- * Returns the #SoupAddress corresponding to the remote end of @sock.
+ * Returns the #GInetSocketAddress corresponding to the remote end of @sock.
  *
  * Calling this method on an unconnected socket is considered to be
  * an error, and produces undefined results.
  *
- * Return value: (transfer none): the #SoupAddress
+ * Return value: (transfer none): the #GInetSocketAddress
  **/
-SoupAddress *
+GInetSocketAddress *
 soup_socket_get_remote_address (SoupSocket *sock)
 {
 	SoupSocketPrivate *priv;
@@ -1643,33 +1669,29 @@ soup_socket_get_remote_address (SoupSocket *sock)
 	g_return_val_if_fail (SOUP_IS_SOCKET (sock), NULL);
 	priv = soup_socket_get_instance_private (sock);
 
-	g_mutex_lock (&priv->addrlock);
-	if (!priv->remote_addr) {
-		GSocketAddress *addr;
-		struct sockaddr_storage sa;
-		gssize sa_len;
-		GError *error = NULL;
-
-		if (priv->gsock == NULL) {
-			g_warning ("%s: socket not connected", G_STRLOC);
-			goto unlock;
-		}
-
-		addr = g_socket_get_remote_address (priv->gsock, &error);
-		if (addr == NULL) {
-			g_warning ("%s: %s", G_STRLOC, error->message);
-			g_error_free (error);
-			goto unlock;
-		}
-		sa_len = g_socket_address_get_native_size (addr);
-		g_socket_address_to_native (addr, &sa, sa_len, NULL);
-		priv->remote_addr = soup_address_new_from_sockaddr ((struct sockaddr *)&sa, sa_len);
-		g_object_unref (addr);
-	}
-unlock:
-	g_mutex_unlock (&priv->addrlock);
-
-	return priv->remote_addr;
+        if (!priv->remote_addr) {
+                GError *error = NULL;
+
+                // We may be conencting to a socket address rather than a network address
+                if (G_IS_INET_SOCKET_ADDRESS (priv->remote_connectable)) {
+                        priv->remote_addr = g_object_ref (G_INET_SOCKET_ADDRESS (priv->remote_connectable));
+                        return priv->remote_addr;
+                }
+
+                if (priv->gsock == NULL) {
+		        g_warning ("%s: socket not connected", G_STRLOC);
+                        return NULL;
+                }
+
+                priv->remote_addr = G_INET_SOCKET_ADDRESS (g_socket_get_remote_address (priv->gsock, &error));
+                if (priv->remote_addr == NULL) {
+                        g_warning ("%s: %s", G_STRLOC, error->message);
+                        g_error_free (error);
+                        return NULL;
+                }
+        }
+
+        return priv->remote_addr;
 }
 
 SoupURI *
diff --git a/libsoup/soup-socket.h b/libsoup/soup-socket.h
index 1e70d906..808719de 100644
--- a/libsoup/soup-socket.h
+++ b/libsoup/soup-socket.h
@@ -41,6 +41,7 @@ typedef struct {
 
 #define SOUP_SOCKET_LOCAL_ADDRESS       "local-address"
 #define SOUP_SOCKET_REMOTE_ADDRESS      "remote-address"
+#define SOUP_SOCKET_REMOTE_CONNECTABLE  "remote-connectable"
 #define SOUP_SOCKET_FLAG_NONBLOCKING    "non-blocking"
 #define SOUP_SOCKET_IS_SERVER           "is-server"
 #define SOUP_SOCKET_SSL_CREDENTIALS     "ssl-creds"
@@ -92,9 +93,9 @@ SOUP_AVAILABLE_IN_2_4
 gboolean       soup_socket_is_connected       (SoupSocket         *sock);
 
 SOUP_AVAILABLE_IN_2_4
-SoupAddress   *soup_socket_get_local_address  (SoupSocket         *sock);
+GInetSocketAddress   *soup_socket_get_local_address  (SoupSocket         *sock);
 SOUP_AVAILABLE_IN_2_4
-SoupAddress   *soup_socket_get_remote_address (SoupSocket         *sock);
+GInetSocketAddress   *soup_socket_get_remote_address (SoupSocket         *sock);
 
 typedef enum {
 	SOUP_SOCKET_OK,
diff --git a/libsoup/soup-types.h b/libsoup/soup-types.h
index 6106d9c4..c4cc55b0 100644
--- a/libsoup/soup-types.h
+++ b/libsoup/soup-types.h
@@ -15,7 +15,6 @@ G_BEGIN_DECLS
 
 #define _SOUP_ATOMIC_INTERN_STRING(variable, value) ((const char *)(g_atomic_pointer_get (&(variable)) ? (variable) : (g_atomic_pointer_set (&(variable), (gpointer)g_intern_static_string (value)), (variable))))
 
-typedef struct _SoupAddress             SoupAddress;
 typedef struct _SoupAuth                SoupAuth;
 typedef struct _SoupAuthDomain          SoupAuthDomain;
 typedef struct _SoupCookie              SoupCookie;
diff --git a/libsoup/soup.h b/libsoup/soup.h
index a41c9c1c..f023565c 100644
--- a/libsoup/soup.h
+++ b/libsoup/soup.h
@@ -12,7 +12,6 @@ extern "C" {
 
 #define __SOUP_H_INSIDE__
 
-#include "soup-address.h"
 #include "auth/soup-auth.h"
 #include "auth/soup-auth-domain.h"
 #include "auth/soup-auth-domain-basic.h"
diff --git a/tests/socket-test.c b/tests/socket-test.c
index 10229ffc..f4e51d6c 100644
--- a/tests/socket-test.c
+++ b/tests/socket-test.c
@@ -15,26 +15,25 @@
 #endif
 
 static void
+assert_host_equals (GInetSocketAddress *addr, const char *host)
+{
+        char *addr_host = g_inet_address_to_string (g_inet_socket_address_get_address (addr));
+        g_assert_cmpstr (addr_host, ==, host);
+        g_free (addr_host);
+}
+
+static void
 do_unconnected_socket_test (void)
 {
-	SoupAddress *localhost;
+	GInetSocketAddress *addr;
+        GSocketAddress *localhost;
 	SoupSocket *sock;
 	SoupSocket *client;
-	SoupAddress *addr;
 	guint res;
-	struct sockaddr_in in_localhost;
 
 	g_test_bug ("673083");
 
-	in_localhost.sin_family = AF_INET;
-	in_localhost.sin_port = 0;
-	in_localhost.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
-
-	localhost = soup_address_new_from_sockaddr (
-		(struct sockaddr *) &in_localhost, sizeof (in_localhost));
-	g_assert_true (localhost != NULL);
-	res = soup_address_resolve_sync (localhost, NULL);
-	g_assert_cmpuint (res, ==, SOUP_STATUS_OK);
+        localhost = g_inet_socket_address_new_from_string ("127.0.0.1", 0);
 
 	sock = soup_socket_new (SOUP_SOCKET_LOCAL_ADDRESS, localhost,
 				NULL);
@@ -42,8 +41,8 @@ do_unconnected_socket_test (void)
 
 	addr = soup_socket_get_local_address (sock);
 	g_assert_true (addr != NULL);
-	g_assert_cmpstr (soup_address_get_physical (addr), ==, "127.0.0.1");
-	g_assert_cmpuint (soup_address_get_port (addr), ==, 0);
+	assert_host_equals (addr, "127.0.0.1");
+	g_assert_cmpuint (g_inet_socket_address_get_port (addr), ==, 0);
 
 	/* fails with ENOTCONN */
 	g_test_expect_message ("libsoup", G_LOG_LEVEL_WARNING,
@@ -57,11 +56,10 @@ do_unconnected_socket_test (void)
 
 	addr = soup_socket_get_local_address (sock);
 	g_assert_true (addr != NULL);
-	g_assert_cmpstr (soup_address_get_physical (addr), ==, "127.0.0.1");
-	g_assert_cmpuint (soup_address_get_port (addr), >, 0);
+	assert_host_equals (addr, "127.0.0.1");
+	g_assert_cmpuint (g_inet_socket_address_get_port (addr), >, 0);
 
-	client = soup_socket_new (SOUP_SOCKET_REMOTE_ADDRESS,
-				  soup_socket_get_local_address (sock),
+	client = soup_socket_new (SOUP_SOCKET_REMOTE_CONNECTABLE, soup_socket_get_local_address (sock),
 				  NULL);
 	res = soup_socket_connect_sync (client, NULL);
 	g_assert_cmpuint (res, ==, SOUP_STATUS_OK);
@@ -69,12 +67,11 @@ do_unconnected_socket_test (void)
 	g_assert_true (addr != NULL);
 	addr = soup_socket_get_remote_address (client);
 	g_assert_true (addr != NULL);
-	g_assert_cmpstr (soup_address_get_physical (addr), ==, "127.0.0.1");
-	g_assert_cmpuint (soup_address_get_port (addr), >, 0);
+	assert_host_equals (addr, "127.0.0.1");
+	g_assert_cmpuint (g_inet_socket_address_get_port (addr), >, 0);
 	g_object_unref (client);
 
-	client = soup_socket_new (SOUP_SOCKET_REMOTE_ADDRESS,
-				  soup_socket_get_local_address (sock),
+	client = soup_socket_new (SOUP_SOCKET_REMOTE_CONNECTABLE, soup_socket_get_local_address (sock),
 				  NULL);
 	/* save it for later */
 
@@ -125,7 +122,7 @@ do_socket_from_fd_client_test (void)
 	SoupURI *uri;
 	GSocket *gsock;
 	SoupSocket *sock;
-	SoupAddress *local, *remote;
+	GInetSocketAddress *local, *remote;
 	GSocketAddress *gaddr;
 	gboolean is_server;
 	GError *error = NULL;
@@ -149,7 +146,7 @@ do_socket_from_fd_client_test (void)
 	g_assert_no_error (error);
 
 	sock = g_initable_new (SOUP_TYPE_SOCKET, NULL, &error,
-			       SOUP_SOCKET_FD, g_socket_get_fd (gsock),
+                               SOUP_SOCKET_GSOCKET, gsock,
 			       NULL);
 	g_assert_no_error (error);
 	g_assert_nonnull (sock);
@@ -163,10 +160,10 @@ do_socket_from_fd_client_test (void)
 	g_assert_false (is_server);
 	g_assert_true (soup_socket_is_connected (sock));
 
-	g_assert_cmpstr (soup_address_get_physical (local), ==, "127.0.0.1");
-	g_assert_cmpint (soup_address_get_port (local), ==, g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (gaddr)));
-	g_assert_cmpstr (soup_address_get_physical (remote), ==, "127.0.0.1");
-	g_assert_cmpint (soup_address_get_port (remote), ==, uri->port);
+	assert_host_equals (local, "127.0.0.1");
+	g_assert_cmpint (g_inet_socket_address_get_port (local), ==, g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (gaddr)));
+        assert_host_equals (remote, "127.0.0.1");
+	g_assert_cmpint (g_inet_socket_address_get_port (remote), ==, uri->port);
 
 	g_object_unref (local);
 	g_object_unref (remote);
@@ -184,7 +181,7 @@ do_socket_from_fd_server_test (void)
 {
 	GSocket *gsock;
 	SoupSocket *sock;
-	SoupAddress *local;
+	GInetSocketAddress *local;
 	GSocketAddress *gaddr;
 	gboolean is_server;
 	GError *error = NULL;
@@ -220,8 +217,8 @@ do_socket_from_fd_server_test (void)
 	g_assert_true (is_server);
 	g_assert_true (soup_socket_is_connected (sock));
 
-	g_assert_cmpstr (soup_address_get_physical (local), ==, "127.0.0.1");
-	g_assert_cmpint (soup_address_get_port (local), ==, g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (gaddr)));
+	assert_host_equals (local, "127.0.0.1");
+	g_assert_cmpint (g_inet_socket_address_get_port (local), ==, g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (gaddr)));
 	g_object_unref (local);
 	g_object_unref (gaddr);
 
@@ -238,7 +235,7 @@ do_socket_from_fd_bad_test (void)
 {
 	GSocket *gsock, *gsock2, *gsockcli;
 	SoupSocket *sock, *sock2;
-	SoupAddress *local, *remote;
+	GInetSocketAddress *local, *remote;
 	GSocketAddress *gaddr;
 	gboolean is_server;
 	int fd;
@@ -322,14 +319,14 @@ do_socket_from_fd_bad_test (void)
 	/* This is wrong, but can't be helped. */
 	g_assert_false (is_server);
 
-	g_assert_cmpstr (soup_address_get_physical (local), ==, "127.0.0.1");
-	g_assert_cmpint (soup_address_get_port (local), ==, g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (gaddr)));
+	assert_host_equals (local, "127.0.0.1");
+	g_assert_cmpint (g_inet_socket_address_get_port (local), ==, g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (gaddr)));
 	g_object_unref (gaddr);
 
 	gaddr = g_socket_get_local_address (gsockcli, &error);
 	g_assert_no_error (error);
-	g_assert_cmpstr (soup_address_get_physical (remote), ==, "127.0.0.1");
-	g_assert_cmpint (soup_address_get_port (remote), ==, g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (gaddr)));
+	assert_host_equals (remote, "127.0.0.1");
+	g_assert_cmpint (g_inet_socket_address_get_port (remote), ==, g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (gaddr)));
 	g_object_unref (gaddr);
 
 	g_object_unref (local);