/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */

/*

 * soup-socket.c: Socket networking code.

 *

 * Copyright (C) 2000-2003, Ximian, Inc.

 */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include <string.h>

#include <glib/gi18n-lib.h>

#include <gio/gnetworking.h>

#include "soup-socket.h"

#include "soup-socket-private.h"

#include "soup.h"

#include "soup-filter-input-stream.h"

#include "soup-io-stream.h"

/**

 * SECTION:soup-socket

 * @short_description: A network socket

 *

 * #SoupSocket is libsoup's TCP socket type. While it is primarily

 * intended for internal use, #SoupSockets are exposed in the

 * API in various places, and some of their methods (eg,

 * soup_socket_get_remote_address()) may be useful to applications.

 **/

enum {

	READABLE,

	WRITABLE,

	DISCONNECTED,

	NEW_CONNECTION,

	EVENT,

	LAST_SIGNAL

};

static guint signals[LAST_SIGNAL] = { 0 };

enum {

	PROP_0,

	PROP_FD,

	PROP_GSOCKET,

	PROP_IOSTREAM,

	PROP_LOCAL_ADDRESS,

	PROP_REMOTE_ADDRESS,

	PROP_NON_BLOCKING,

	PROP_IPV6_ONLY,

	PROP_IS_SERVER,

	PROP_SSL_CREDENTIALS,

	PROP_SSL_STRICT,

	PROP_SSL_FALLBACK,

	PROP_ASYNC_CONTEXT,

	PROP_USE_THREAD_CONTEXT,

	PROP_TIMEOUT,

	PROP_TRUSTED_CERTIFICATE,

	PROP_TLS_CERTIFICATE,

	PROP_TLS_ERRORS,

	PROP_SOCKET_PROPERTIES,

	LAST_PROP

};

typedef struct {

	SoupAddress *local_addr, *remote_addr;

	GIOStream *conn, *iostream;

	GSocket *gsock;

	GInputStream *istream;

	GOutputStream *ostream;

	GTlsCertificateFlags tls_errors;

	GTlsInteraction *tls_interaction;

	GProxyResolver *proxy_resolver;

	guint non_blocking:1;

	guint ipv6_only:1;

	guint is_server:1;

	guint ssl:1;

	guint ssl_strict:1;

	guint ssl_fallback:1;

	guint clean_dispose:1;

	guint use_thread_context:1;

	gpointer ssl_creds;

	GMainContext   *async_context;

	GSource        *watch_src;

	GSource        *read_src, *write_src;

	GMutex iolock, addrlock;

	guint timeout;

	GCancellable *connect_cancel;

	int fd;

} SoupSocketPrivate;

static void soup_socket_initable_interface_init (GInitableIface *initable_interface);

G_DEFINE_TYPE_WITH_CODE (SoupSocket, soup_socket, G_TYPE_OBJECT,

                         G_ADD_PRIVATE (SoupSocket)

			 G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE,

						soup_socket_initable_interface_init))

static void soup_socket_peer_certificate_changed (GObject *conn,

						  GParamSpec *pspec,

						  gpointer user_data);

static void finish_socket_setup (SoupSocket *sock);

static void finish_listener_setup (SoupSocket *sock);

static void

soup_socket_init (SoupSocket *sock)

{

	SoupSocketPrivate *priv = soup_socket_get_instance_private (sock);

	priv->non_blocking = TRUE;

	priv->fd = -1;

	g_mutex_init (&priv->addrlock);

	g_mutex_init (&priv->iolock);

}

static gboolean

soup_socket_initable_init (GInitable     *initable,

			   GCancellable  *cancellable,

			   GError       **error)

{

	SoupSocket *sock = SOUP_SOCKET (initable);

	SoupSocketPrivate *priv = soup_socket_get_instance_private (sock);

	if (priv->conn) {

		g_warn_if_fail (priv->gsock == NULL);

		g_warn_if_fail (priv->fd == -1);

		finish_socket_setup (sock);

	}

	if (priv->fd != -1) {

		guint type, len = sizeof (type);

		g_warn_if_fail (priv->gsock == NULL);

		/* GSocket will g_error() this, so we have to check ourselves. */

		if (getsockopt (priv->fd, SOL_SOCKET, SO_TYPE,

				(gpointer)&type, (gpointer)&len) == -1) {

			g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED,

					     _("Can’t import non-socket as SoupSocket"));

			return FALSE;

		}

		priv->gsock = g_socket_new_from_fd (priv->fd, error);

		if (!priv->gsock)

			return FALSE;

	}

	if (priv->gsock != NULL) {

		int listening;

		g_warn_if_fail (priv->local_addr == NULL);

		g_warn_if_fail (priv->remote_addr == NULL);

		if (!g_socket_get_option (priv->gsock,

					  SOL_SOCKET, SO_ACCEPTCONN,

					  &listening, error)) {

			g_prefix_error (error, _("Could not import existing socket: "));

			return FALSE;

		}

		finish_socket_setup (sock);

		if (listening)

			finish_listener_setup (sock);

		else if (!g_socket_is_connected (priv->gsock)) {

			g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED,

					     _("Can’t import unconnected socket"));

			return FALSE;

		}

	}

	return TRUE;

}

static void

disconnect_internal (SoupSocket *sock, gboolean close)

{

	SoupSocketPrivate *priv = soup_socket_get_instance_private (sock);

	g_clear_object (&priv->gsock);

	if (priv->conn && close) {

		g_io_stream_close (priv->conn, NULL, NULL);

		g_signal_handlers_disconnect_by_data (priv->conn, sock);

		g_clear_object (&priv->conn);

	}

	if (priv->read_src) {

		g_source_destroy (priv->read_src);

		priv->read_src = NULL;

	}

	if (priv->write_src) {

		g_source_destroy (priv->write_src);

		priv->write_src = NULL;

	}

}

static void

soup_socket_finalize (GObject *object)

{

	SoupSocket *sock = SOUP_SOCKET (object);

	SoupSocketPrivate *priv = soup_socket_get_instance_private (sock);

	if (priv->connect_cancel) {

		if (priv->clean_dispose)

			g_warning ("Disposing socket %p during connect", object);

		g_object_unref (priv->connect_cancel);

	}

	if (priv->conn) {

		if (priv->clean_dispose)

			g_warning ("Disposing socket %p while still connected", object);

		disconnect_internal (SOUP_SOCKET (object), TRUE);

	}

	g_clear_object (&priv->conn);

	g_clear_object (&priv->iostream);

	g_clear_object (&priv->istream);

	g_clear_object (&priv->ostream);

	g_clear_object (&priv->local_addr);

	g_clear_object (&priv->remote_addr);

	g_clear_object (&priv->tls_interaction);

	g_clear_object (&priv->proxy_resolver);

	g_clear_object (&priv->ssl_creds);

	if (priv->watch_src) {

		if (priv->clean_dispose && !priv->is_server)

			g_warning ("Disposing socket %p during async op", object);

		g_source_destroy (priv->watch_src);

	}

	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);

}

static void

finish_socket_setup (SoupSocket *sock)

{

	SoupSocketPrivate *priv = soup_socket_get_instance_private (sock);

	if (priv->gsock) {

		if (!priv->conn)

			priv->conn = (GIOStream *)g_socket_connection_factory_create_connection (priv->gsock);

		g_socket_set_timeout (priv->gsock, priv->timeout);

		g_socket_set_option (priv->gsock, IPPROTO_TCP, TCP_NODELAY, TRUE, NULL);

	}

	if (!priv->conn)

		return;

	if (!priv->iostream)

		priv->iostream = soup_io_stream_new (priv->conn, FALSE);

	if (!priv->istream)

		priv->istream = g_object_ref (g_io_stream_get_input_stream (priv->iostream));

	if (!priv->ostream)

		priv->ostream = g_object_ref (g_io_stream_get_output_stream (priv->iostream));

}

static void

soup_socket_set_property (GObject *object, guint prop_id,

			  const GValue *value, GParamSpec *pspec)

{

	SoupSocket *sock = SOUP_SOCKET (object);

	SoupSocketPrivate *priv = soup_socket_get_instance_private (sock);

	SoupSocketProperties *props;

	switch (prop_id) {

	case PROP_FD:

		priv->fd = g_value_get_int (value);

		break;

	case PROP_GSOCKET:

		priv->gsock = g_value_dup_object (value);

		break;

	case PROP_IOSTREAM:

		priv->conn = g_value_dup_object (value);

		break;

	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);

		break;

	case PROP_NON_BLOCKING:

		priv->non_blocking = g_value_get_boolean (value);

		break;

	case PROP_IPV6_ONLY:

		priv->ipv6_only = g_value_get_boolean (value);

		break;

	case PROP_SSL_CREDENTIALS:

		priv->ssl_creds = g_value_get_pointer (value);

		if (priv->ssl_creds)

			g_object_ref (priv->ssl_creds);

		break;

	case PROP_SSL_STRICT:

		priv->ssl_strict = g_value_get_boolean (value);

		break;

	case PROP_SSL_FALLBACK:

		priv->ssl_fallback = g_value_get_boolean (value);

		break;

	case PROP_ASYNC_CONTEXT:

		if (!priv->use_thread_context) {

			priv->async_context = g_value_get_pointer (value);

			if (priv->async_context)

				g_main_context_ref (priv->async_context);

		}

		break;

	case PROP_USE_THREAD_CONTEXT:

		priv->use_thread_context = g_value_get_boolean (value);

		if (priv->use_thread_context) {

			g_clear_pointer (&priv->async_context, g_main_context_unref);

			priv->async_context = g_main_context_ref_thread_default ();

		}

		break;

	case PROP_TIMEOUT:

		priv->timeout = g_value_get_uint (value);

		if (priv->conn)

			g_socket_set_timeout (priv->gsock, priv->timeout);

		break;

	case PROP_SOCKET_PROPERTIES:

		props = g_value_get_boxed (value);

		if (props) {

			g_clear_pointer (&priv->async_context, g_main_context_unref);

			if (props->use_thread_context) {

				priv->use_thread_context = TRUE;

				priv->async_context = g_main_context_ref_thread_default ();

			} else {

				priv->use_thread_context = FALSE;

				if (props->async_context)

					priv->async_context = g_main_context_ref (props->async_context);

			}

			g_clear_object (&priv->proxy_resolver);

			if (props->proxy_resolver)

				priv->proxy_resolver = g_object_ref (props->proxy_resolver);

			g_clear_object (&priv->local_addr);

			if (props->local_addr)

				priv->local_addr = g_object_ref (props->local_addr);

			g_clear_object (&priv->ssl_creds);

			if (props->tlsdb)

				priv->ssl_creds = g_object_ref (props->tlsdb);

			g_clear_object (&priv->tls_interaction);

			if (props->tls_interaction)

				priv->tls_interaction = g_object_ref (props->tls_interaction);

			priv->ssl_strict = props->ssl_strict;

			priv->timeout = props->io_timeout;

			if (priv->conn)

				g_socket_set_timeout (priv->gsock, priv->timeout);

			priv->clean_dispose = TRUE;

		}

		break;

	default:

		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

		break;

	}

}

static void

soup_socket_get_property (GObject *object, guint prop_id,

			  GValue *value, GParamSpec *pspec)

{

	SoupSocket *sock = SOUP_SOCKET (object);

	SoupSocketPrivate *priv = soup_socket_get_instance_private (sock);

	switch (prop_id) {

	case PROP_FD:

		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)));

		break;

	case PROP_REMOTE_ADDRESS:

		g_value_set_object (value, soup_socket_get_remote_address (SOUP_SOCKET (object)));

		break;

	case PROP_NON_BLOCKING:

		g_value_set_boolean (value, priv->non_blocking);

		break;

	case PROP_IPV6_ONLY:

		g_value_set_boolean (value, priv->ipv6_only);

		break;

	case PROP_IS_SERVER:

		g_value_set_boolean (value, priv->is_server);

		break;

	case PROP_SSL_CREDENTIALS:

		g_value_set_pointer (value, priv->ssl_creds);

		break;

	case PROP_SSL_STRICT:

		g_value_set_boolean (value, priv->ssl_strict);

		break;

	case PROP_SSL_FALLBACK:

		g_value_set_boolean (value, priv->ssl_fallback);

		break;

	case PROP_TRUSTED_CERTIFICATE:

		g_value_set_boolean (value, priv->tls_errors == 0);

		break;

	case PROP_ASYNC_CONTEXT:

		g_value_set_pointer (value, priv->async_context ? g_main_context_ref (priv->async_context) : NULL);

		break;

	case PROP_USE_THREAD_CONTEXT:

		g_value_set_boolean (value, priv->use_thread_context);

		break;

	case PROP_TIMEOUT:

		g_value_set_uint (value, priv->timeout);

		break;

	case PROP_TLS_CERTIFICATE:

		if (G_IS_TLS_CONNECTION (priv->conn))

			g_value_set_object (value, g_tls_connection_get_peer_certificate (G_TLS_CONNECTION (priv->conn)));

		else

			g_value_set_object (value, NULL);

		break;

	case PROP_TLS_ERRORS:

		g_value_set_flags (value, priv->tls_errors);

		break;

	default:

		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

		break;

	}

}

static void

soup_socket_class_init (SoupSocketClass *socket_class)

{

	GObjectClass *object_class = G_OBJECT_CLASS (socket_class);

	/* virtual method override */

	object_class->finalize = soup_socket_finalize;

	object_class->set_property = soup_socket_set_property;

	object_class->get_property = soup_socket_get_property;

	/* signals */

	/**

	 * SoupSocket::readable:

	 * @sock: the socket

	 *

	 * Emitted when an async socket is readable. See

	 * soup_socket_read(), soup_socket_read_until() and

	 * #SoupSocket:non-blocking.

	 **/

	signals[READABLE] =

		g_signal_new ("readable",

			      G_OBJECT_CLASS_TYPE (object_class),

			      G_SIGNAL_RUN_LAST,

			      G_STRUCT_OFFSET (SoupSocketClass, readable),

			      NULL, NULL,

			      NULL,

			      G_TYPE_NONE, 0);

	/**

	 * SoupSocket::writable:

	 * @sock: the socket

	 *

	 * Emitted when an async socket is writable. See

	 * soup_socket_write() and #SoupSocket:non-blocking.

	 **/

	signals[WRITABLE] =

		g_signal_new ("writable",

			      G_OBJECT_CLASS_TYPE (object_class),

			      G_SIGNAL_RUN_LAST,

			      G_STRUCT_OFFSET (SoupSocketClass, writable),

			      NULL, NULL,

			      NULL,

			      G_TYPE_NONE, 0);

	/**

	 * SoupSocket::disconnected:

	 * @sock: the socket

	 *

	 * Emitted when the socket is disconnected, for whatever

	 * reason.

	 **/

	signals[DISCONNECTED] =

		g_signal_new ("disconnected",

			      G_OBJECT_CLASS_TYPE (object_class),

			      G_SIGNAL_RUN_LAST,

			      G_STRUCT_OFFSET (SoupSocketClass, disconnected),

			      NULL, NULL,

			      NULL,

			      G_TYPE_NONE, 0);

	/**

	 * SoupSocket::new-connection:

	 * @sock: the socket

	 * @new: the new socket

	 *

	 * Emitted when a listening socket (set up with

	 * soup_socket_listen()) receives a new connection.

	 *

	 * You must ref the @new if you want to keep it; otherwise it

	 * will be destroyed after the signal is emitted.

	 **/

	signals[NEW_CONNECTION] =

		g_signal_new ("new_connection",

			      G_OBJECT_CLASS_TYPE (object_class),

			      G_SIGNAL_RUN_FIRST,

			      G_STRUCT_OFFSET (SoupSocketClass, new_connection),

			      NULL, NULL,

			      NULL,

			      G_TYPE_NONE, 1,

			      SOUP_TYPE_SOCKET);

	/**

	 * SoupSocket::event:

	 * @sock: the socket

	 * @event: the event that occurred

	 * @connection: the current connection state

	 *

	 * Emitted when a network-related event occurs. See

	 * #GSocketClient::event for more details.

	 *

	 * Since: 2.38

	 **/

	signals[EVENT] =

		g_signal_new ("event",

			      G_OBJECT_CLASS_TYPE (object_class),

			      G_SIGNAL_RUN_LAST,

			      0,

			      NULL, NULL,

			      NULL,

			      G_TYPE_NONE, 2,

			      G_TYPE_SOCKET_CLIENT_EVENT,

			      G_TYPE_IO_STREAM);

	/* properties */

	g_object_class_install_property (

		 object_class, PROP_FD,

		 g_param_spec_int (SOUP_SOCKET_FD,

				   "FD",

				   "The socket's file descriptor",

				   -1, G_MAXINT, -1,

				   G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));

	g_object_class_install_property (

		 object_class, PROP_GSOCKET,

		 g_param_spec_object (SOUP_SOCKET_GSOCKET,

				      "GSocket",

				      "The socket's underlying GSocket",

				      G_TYPE_SOCKET,

				      G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));

	g_object_class_install_property (

		 object_class, PROP_IOSTREAM,

		 g_param_spec_object (SOUP_SOCKET_IOSTREAM,

				      "GIOStream",

				      "The socket's underlying GIOStream",

				      G_TYPE_IO_STREAM,

				      G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));

	/**

	 * SOUP_SOCKET_LOCAL_ADDRESS:

	 *

	 * Alias for the #SoupSocket:local-address property. (Address

	 * of local end of socket.)

	 **/

	g_object_class_install_property (

		object_class, PROP_LOCAL_ADDRESS,

		g_param_spec_object (SOUP_SOCKET_LOCAL_ADDRESS,

				     "Local address",

				     "Address of local end of socket",

				     SOUP_TYPE_ADDRESS,

				     G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));

	/**

	 * SOUP_SOCKET_REMOTE_ADDRESS:

	 *

	 * Alias for the #SoupSocket:remote-address property. (Address

	 * of remote end of socket.)

	 **/

	g_object_class_install_property (

		object_class, PROP_REMOTE_ADDRESS,

		g_param_spec_object (SOUP_SOCKET_REMOTE_ADDRESS,

				     "Remote address",

				     "Address of remote end of socket",

				     SOUP_TYPE_ADDRESS,

				     G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));

	/**

	 * SoupSocket:non-blocking:

	 *

	 * Whether or not the socket uses non-blocking I/O.

	 *

	 * #SoupSocket's I/O methods are designed around the idea of

	 * using a single codepath for both synchronous and

	 * asynchronous I/O. If you want to read off a #SoupSocket,

	 * the "correct" way to do it is to call soup_socket_read() or

	 * soup_socket_read_until() repeatedly until you have read

	 * everything you want. If it returns %SOUP_SOCKET_WOULD_BLOCK

	 * at any point, stop reading and wait for it to emit the

	 * #SoupSocket::readable signal. Then go back to the

	 * reading-as-much-as-you-can loop. Likewise, for writing to a

	 * #SoupSocket, you should call soup_socket_write() either

	 * until you have written everything, or it returns

	 * %SOUP_SOCKET_WOULD_BLOCK (in which case you wait for

	 * #SoupSocket::writable and then go back into the loop).

	 *

	 * Code written this way will work correctly with both

	 * blocking and non-blocking sockets; blocking sockets will

	 * simply never return %SOUP_SOCKET_WOULD_BLOCK, and so the

	 * code that handles that case just won't get used for them.

	 **/

	/**

	 * SOUP_SOCKET_FLAG_NONBLOCKING:

	 *

	 * Alias for the #SoupSocket:non-blocking property. (Whether

	 * or not the socket uses non-blocking I/O.)

	 **/

	g_object_class_install_property (

		object_class, PROP_NON_BLOCKING,

		g_param_spec_boolean (SOUP_SOCKET_FLAG_NONBLOCKING,

				      "Non-blocking",

				      "Whether or not the socket uses non-blocking I/O",

				      TRUE,

				      G_PARAM_READWRITE));

	g_object_class_install_property (

		object_class, PROP_IPV6_ONLY,

		g_param_spec_boolean (SOUP_SOCKET_IPV6_ONLY,

				      "IPv6 only",

				      "IPv6 only",

				      FALSE,

				      G_PARAM_READWRITE));

	/**

	 * SOUP_SOCKET_IS_SERVER:

	 *

	 * Alias for the #SoupSocket:is-server property, qv.

	 **/

	/**

	 * SoupSocket:is-server:

	 *

	 * Whether or not the socket is a server socket.

	 *

	 * Note that for "ordinary" #SoupSockets this will be set for

	 * both listening sockets and the sockets emitted by

	 * #SoupSocket::new-connection, but for sockets created by

	 * setting #SoupSocket:fd, it will only be set for listening

	 * sockets.

	 **/

	g_object_class_install_property (

		object_class, PROP_IS_SERVER,

		g_param_spec_boolean (SOUP_SOCKET_IS_SERVER,

				      "Server",

				      "Whether or not the socket is a server socket",

				      FALSE,

				      G_PARAM_READABLE));

	/**

	 * SOUP_SOCKET_SSL_CREDENTIALS:

	 *

	 * Alias for the #SoupSocket:ssl-creds property.

	 * (SSL credential information.)

	 **/

	/* For historical reasons, there's only a single property

	 * here, which is a GTlsDatabase for client sockets, and

	 * a GTlsCertificate for server sockets. Whee!

	 */

	g_object_class_install_property (

		object_class, PROP_SSL_CREDENTIALS,

		g_param_spec_pointer (SOUP_SOCKET_SSL_CREDENTIALS,

				      "SSL credentials",

				      "SSL credential information, passed from the session to the SSL implementation",

				      G_PARAM_READWRITE));

	/**

	 * SOUP_SOCKET_SSL_STRICT:

	 *

	 * Alias for the #SoupSocket:ssl-strict property.

	 **/

	g_object_class_install_property (

		object_class, PROP_SSL_STRICT,

		g_param_spec_boolean (SOUP_SOCKET_SSL_STRICT,

				      "Strictly validate SSL certificates",

				      "Whether certificate errors should be considered a connection error",

				      TRUE,

				      G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));

	/**

	 * SOUP_SOCKET_SSL_FALLBACK:

	 *

	 * Alias for the #SoupSocket:ssl-fallback property.

	 **/

	g_object_class_install_property (

		object_class, PROP_SSL_FALLBACK,

		g_param_spec_boolean (SOUP_SOCKET_SSL_FALLBACK,

				      "SSLv3 fallback",

				      "Use SSLv3 instead of TLS (client-side only)",

				      FALSE,

				      G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));

	/**

	 * SOUP_SOCKET_TRUSTED_CERTIFICATE:

	 *

	 * Alias for the #SoupSocket:trusted-certificate

	 * property.

	 **/

	g_object_class_install_property (

		object_class, PROP_TRUSTED_CERTIFICATE,

		g_param_spec_boolean (SOUP_SOCKET_TRUSTED_CERTIFICATE,

				     "Trusted Certificate",

				     "Whether the server certificate is trusted, if this is an SSL socket",

				     FALSE,

				     G_PARAM_READABLE));

	/**

	 * SOUP_SOCKET_ASYNC_CONTEXT:

	 *

	 * Alias for the #SoupSocket:async-context property. (The

	 * socket's #GMainContext.)

	 **/

	g_object_class_install_property (

		object_class, PROP_ASYNC_CONTEXT,

		g_param_spec_pointer (SOUP_SOCKET_ASYNC_CONTEXT,

				      "Async GMainContext",

				      "The GMainContext to dispatch this socket's async I/O in",

				      G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));

	/**

	 * SOUP_SOCKET_USE_THREAD_CONTEXT:

	 *

	 * Alias for the #SoupSocket:use-thread-context property. (Use

	 * g_main_context_get_thread_default())

	 *

	 * Since: 2.38

	 */

	/**

	 * SoupSocket:use-thread-context:

	 *

	 * Use g_main_context_get_thread_default().

	 *

	 * Since: 2.38

	 */

	g_object_class_install_property (

		object_class, PROP_USE_THREAD_CONTEXT,

		g_param_spec_boolean (SOUP_SOCKET_USE_THREAD_CONTEXT,

				      "Use thread context",

				      "Use g_main_context_get_thread_default",

				      FALSE,

				      G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));

	/**

	 * SOUP_SOCKET_TIMEOUT:

	 *

	 * Alias for the #SoupSocket:timeout property. (The timeout

	 * in seconds for blocking socket I/O operations.)

	 **/

	g_object_class_install_property (

		object_class, PROP_TIMEOUT,

		g_param_spec_uint (SOUP_SOCKET_TIMEOUT,

				   "Timeout value",

				   "Value in seconds to timeout a blocking I/O",

				   0, G_MAXUINT, 0,

				   G_PARAM_READWRITE));

	/**

	 * SOUP_SOCKET_TLS_CERTIFICATE:

	 *

	 * Alias for the #SoupSocket:tls-certificate

	 * property. Note that this property's value is only useful

	 * if the socket is for a TLS connection, and only reliable

	 * after some data has been transferred to or from it.

	 *

	 * Since: 2.34

	 **/

	g_object_class_install_property (

		object_class, PROP_TLS_CERTIFICATE,

		g_param_spec_object (SOUP_SOCKET_TLS_CERTIFICATE,

				     "TLS certificate",

				     "The peer's TLS certificate",

				     G_TYPE_TLS_CERTIFICATE,

				     G_PARAM_READABLE));

	/**

	 * SOUP_SOCKET_TLS_ERRORS:

	 *

	 * Alias for the #SoupSocket:tls-errors

	 * property. Note that this property's value is only useful

	 * if the socket is for a TLS connection, and only reliable

	 * after some data has been transferred to or from it.

	 *

	 * Since: 2.34

	 **/

	g_object_class_install_property (

		object_class, PROP_TLS_ERRORS,

		g_param_spec_flags (SOUP_SOCKET_TLS_ERRORS,

				    "TLS errors",

				    "Errors with the peer's TLS certificate",

				    G_TYPE_TLS_CERTIFICATE_FLAGS, 0,

				    G_PARAM_READABLE));

	g_object_class_install_property (

		 object_class, PROP_SOCKET_PROPERTIES,

		 g_param_spec_boxed (SOUP_SOCKET_SOCKET_PROPERTIES,

				     "Socket properties",

				     "Socket properties",

				     SOUP_TYPE_SOCKET_PROPERTIES,

				     G_PARAM_WRITABLE));

}

static void

soup_socket_initable_interface_init (GInitableIface *initable_interface)

{

	initable_interface->init = soup_socket_initable_init;

}

/**

 * soup_socket_new:

 * @optname1: name of first property to set (or %NULL)

 * @...: value of @optname1, followed by additional property/value pairs

 *

 * Creates a new (disconnected) socket

 *

 * Return value: the new socket

 **/

SoupSocket *

soup_socket_new (const char *optname1, ...)

{

	SoupSocket *sock;

	va_list ap;

	va_start (ap, optname1);

	sock = (SoupSocket *)g_object_new_valist (SOUP_TYPE_SOCKET,

						  optname1, ap);

	va_end (ap);

	return sock;

}

static void

soup_socket_event (SoupSocket         *sock,

		   GSocketClientEvent  event,

		   GIOStream          *connection)

{

	g_signal_emit (sock, signals[EVENT], 0,

		       event, connection);

}

static void

re_emit_socket_client_event (GSocketClient       *client,

			     GSocketClientEvent   event,

			     GSocketConnectable  *connectable,

			     GIOStream           *connection,

			     gpointer             user_data)

{

	SoupSocket *sock = user_data;

	soup_socket_event (sock, event, connection);

}

static gboolean

socket_connect_finish (SoupSocket *sock, GSocketConnection *conn)

{

	SoupSocketPrivate *priv = soup_socket_get_instance_private (sock);

	g_clear_object (&priv->connect_cancel);

	if (conn) {

		priv->conn = (GIOStream *)conn;

		priv->gsock = g_object_ref (g_socket_connection_get_socket (conn));

		finish_socket_setup (sock);

		return TRUE;

	} else

		return FALSE;

}

static guint

socket_legacy_error (SoupSocket *sock, GError *error)

{

	guint status;

	if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))

		status = SOUP_STATUS_CANCELLED;

	else if (error->domain == G_RESOLVER_ERROR)

		status = SOUP_STATUS_CANT_RESOLVE;

	else

		status = SOUP_STATUS_CANT_CONNECT;