/*  GIO - GLib Input, Output and Streaming Library

 *

 * Copyright © 2008, 2009 codethink

 * Copyright © 2009 Red Hat, Inc

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General

 * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.

 *

 * Authors: Ryan Lortie <desrt@desrt.ca>

 *          Alexander Larsson <alexl@redhat.com>

 */

#include "config.h"

#include "gsocketclient.h"

#include <stdlib.h>

#include <string.h>

#include <gio/gioenumtypes.h>

#include <gio/gsocketaddressenumerator.h>

#include <gio/gsocketconnectable.h>

#include <gio/gsocketconnection.h>

#include <gio/gioprivate.h>

#include <gio/gproxyaddressenumerator.h>

#include <gio/gproxyaddress.h>

#include <gio/gtask.h>

#include <gio/gcancellable.h>

#include <gio/gioerror.h>

#include <gio/gsocket.h>

#include <gio/gnetworkaddress.h>

#include <gio/gnetworkservice.h>

#include <gio/gproxy.h>

#include <gio/gproxyresolver.h>

#include <gio/gsocketaddress.h>

#include <gio/gtcpconnection.h>

#include <gio/gtcpwrapperconnection.h>

#include <gio/gtlscertificate.h>

#include <gio/gtlsclientconnection.h>

#include <gio/ginetaddress.h>

#include "glibintl.h"

/**

 * SECTION:gsocketclient

 * @short_description: Helper for connecting to a network service

 * @include: gio/gio.h

 * @see_also: #GSocketConnection, #GSocketListener

 *

 * #GSocketClient is a lightweight high-level utility class for connecting to

 * a network host using a connection oriented socket type.

 *

 * You create a #GSocketClient object, set any options you want, and then

 * call a sync or async connect operation, which returns a #GSocketConnection

 * subclass on success.

 *

 * The type of the #GSocketConnection object returned depends on the type of

 * the underlying socket that is in use. For instance, for a TCP/IP connection

 * it will be a #GTcpConnection.

 *

 * As #GSocketClient is a lightweight object, you don't need to cache it. You

 * can just create a new one any time you need one.

 *

 * Since: 2.22

 */

enum

{

  EVENT,

  LAST_SIGNAL

};

static guint signals[LAST_SIGNAL] = { 0 };

enum

{

  PROP_NONE,

  PROP_FAMILY,

  PROP_TYPE,

  PROP_PROTOCOL,

  PROP_LOCAL_ADDRESS,

  PROP_TIMEOUT,

  PROP_ENABLE_PROXY,

  PROP_TLS,

  PROP_TLS_VALIDATION_FLAGS,

  PROP_PROXY_RESOLVER

};

struct _GSocketClientPrivate

{

  GSocketFamily family;

  GSocketType type;

  GSocketProtocol protocol;

  GSocketAddress *local_address;

  guint timeout;

  gboolean enable_proxy;

  GHashTable *app_proxies;

  gboolean tls;

  GTlsCertificateFlags tls_validation_flags;

  GProxyResolver *proxy_resolver;

};

G_DEFINE_TYPE_WITH_PRIVATE (GSocketClient, g_socket_client, G_TYPE_OBJECT)

static GSocket *

create_socket (GSocketClient  *client,

	       GSocketAddress *dest_address,

	       GError        **error)

{

  GSocketFamily family;

  GSocket *socket;

  family = client->priv->family;

  if (family == G_SOCKET_FAMILY_INVALID &&

      client->priv->local_address != NULL)

    family = g_socket_address_get_family (client->priv->local_address);

  if (family == G_SOCKET_FAMILY_INVALID)

    family = g_socket_address_get_family (dest_address);

  socket = g_socket_new (family,

			 client->priv->type,

			 client->priv->protocol,

			 error);

  if (socket == NULL)

    return NULL;

  if (client->priv->local_address)

    {

      if (!g_socket_bind (socket,

			  client->priv->local_address,

			  FALSE,

			  error))

	{

	  g_object_unref (socket);

	  return NULL;

	}

    }

  if (client->priv->timeout)

    g_socket_set_timeout (socket, client->priv->timeout);

  return socket;

}

static gboolean

can_use_proxy (GSocketClient *client)

{

  GSocketClientPrivate *priv = client->priv;

  return priv->enable_proxy

          && priv->type == G_SOCKET_TYPE_STREAM;

}

static void

clarify_connect_error (GError             *error,

		       GSocketConnectable *connectable,

		       GSocketAddress     *address)

{

  const char *name;

  char *tmp_name = NULL;

  if (G_IS_PROXY_ADDRESS (address))

    {

      name = tmp_name = g_inet_address_to_string (g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (address)));

      g_prefix_error (&error, _("Could not connect to proxy server %s: "), name);

    }

  else

    {

      if (G_IS_NETWORK_ADDRESS (connectable))

	name = g_network_address_get_hostname (G_NETWORK_ADDRESS (connectable));

      else if (G_IS_NETWORK_SERVICE (connectable))

	name = g_network_service_get_domain (G_NETWORK_SERVICE (connectable));

      else if (G_IS_INET_SOCKET_ADDRESS (connectable))

	name = tmp_name = g_inet_address_to_string (g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (connectable)));

      else

	name = NULL;

      if (name)

	g_prefix_error (&error, _("Could not connect to %s: "), name);

      else

	g_prefix_error (&error, _("Could not connect: "));

    }

  g_free (tmp_name);

}

static void

g_socket_client_init (GSocketClient *client)

{

  client->priv = g_socket_client_get_instance_private (client);

  client->priv->type = G_SOCKET_TYPE_STREAM;

  client->priv->app_proxies = g_hash_table_new_full (g_str_hash,

						     g_str_equal,

						     g_free,

						     NULL);

}

/**

 * g_socket_client_new:

 *

 * Creates a new #GSocketClient with the default options.

 *

 * Returns: a #GSocketClient.

 *     Free the returned object with g_object_unref().

 *

 * Since: 2.22

 */

GSocketClient *

g_socket_client_new (void)

{

  return g_object_new (G_TYPE_SOCKET_CLIENT, NULL);

}

static void

g_socket_client_finalize (GObject *object)

{

  GSocketClient *client = G_SOCKET_CLIENT (object);

  g_clear_object (&client->priv->local_address);

  g_clear_object (&client->priv->proxy_resolver);

  G_OBJECT_CLASS (g_socket_client_parent_class)->finalize (object);

  g_hash_table_unref (client->priv->app_proxies);

}

static void

g_socket_client_get_property (GObject    *object,

			      guint       prop_id,

			      GValue     *value,

			      GParamSpec *pspec)

{

  GSocketClient *client = G_SOCKET_CLIENT (object);

  switch (prop_id)

    {

      case PROP_FAMILY:

	g_value_set_enum (value, client->priv->family);

	break;

      case PROP_TYPE:

	g_value_set_enum (value, client->priv->type);

	break;

      case PROP_PROTOCOL:

	g_value_set_enum (value, client->priv->protocol);

	break;

      case PROP_LOCAL_ADDRESS:

	g_value_set_object (value, client->priv->local_address);

	break;

      case PROP_TIMEOUT:

	g_value_set_uint (value, client->priv->timeout);

	break;

      case PROP_ENABLE_PROXY:

	g_value_set_boolean (value, client->priv->enable_proxy);

	break;

      case PROP_TLS:

	g_value_set_boolean (value, g_socket_client_get_tls (client));

	break;

      case PROP_TLS_VALIDATION_FLAGS:

	g_value_set_flags (value, g_socket_client_get_tls_validation_flags (client));

	break;

      case PROP_PROXY_RESOLVER:

	g_value_set_object (value, g_socket_client_get_proxy_resolver (client));

	break;

      default:

	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

    }

}

static void

g_socket_client_set_property (GObject      *object,

			      guint         prop_id,

			      const GValue *value,

			      GParamSpec   *pspec)

{

  GSocketClient *client = G_SOCKET_CLIENT (object);

  switch (prop_id)

    {

    case PROP_FAMILY:

      g_socket_client_set_family (client, g_value_get_enum (value));

      break;

    case PROP_TYPE:

      g_socket_client_set_socket_type (client, g_value_get_enum (value));

      break;

    case PROP_PROTOCOL:

      g_socket_client_set_protocol (client, g_value_get_enum (value));

      break;

    case PROP_LOCAL_ADDRESS:

      g_socket_client_set_local_address (client, g_value_get_object (value));

      break;

    case PROP_TIMEOUT:

      g_socket_client_set_timeout (client, g_value_get_uint (value));

      break;

    case PROP_ENABLE_PROXY:

      g_socket_client_set_enable_proxy (client, g_value_get_boolean (value));

      break;

    case PROP_TLS:

      g_socket_client_set_tls (client, g_value_get_boolean (value));

      break;

    case PROP_TLS_VALIDATION_FLAGS:

      g_socket_client_set_tls_validation_flags (client, g_value_get_flags (value));

      break;

    case PROP_PROXY_RESOLVER:

      g_socket_client_set_proxy_resolver (client, g_value_get_object (value));

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

    }

}

/**

 * g_socket_client_get_family:

 * @client: a #GSocketClient.

 *

 * Gets the socket family of the socket client.

 *

 * See g_socket_client_set_family() for details.

 *

 * Returns: a #GSocketFamily

 *

 * Since: 2.22

 */

GSocketFamily

g_socket_client_get_family (GSocketClient *client)

{

  return client->priv->family;

}

/**

 * g_socket_client_set_family:

 * @client: a #GSocketClient.

 * @family: a #GSocketFamily

 *

 * Sets the socket family of the socket client.

 * If this is set to something other than %G_SOCKET_FAMILY_INVALID

 * then the sockets created by this object will be of the specified

 * family.

 *

 * This might be useful for instance if you want to force the local

 * connection to be an ipv4 socket, even though the address might

 * be an ipv6 mapped to ipv4 address.

 *

 * Since: 2.22

 */

void

g_socket_client_set_family (GSocketClient *client,

			    GSocketFamily  family)

{

  if (client->priv->family == family)

    return;

  client->priv->family = family;

  g_object_notify (G_OBJECT (client), "family");

}

/**

 * g_socket_client_get_socket_type:

 * @client: a #GSocketClient.

 *

 * Gets the socket type of the socket client.

 *

 * See g_socket_client_set_socket_type() for details.

 *

 * Returns: a #GSocketFamily

 *

 * Since: 2.22

 */

GSocketType

g_socket_client_get_socket_type (GSocketClient *client)

{

  return client->priv->type;

}

/**

 * g_socket_client_set_socket_type:

 * @client: a #GSocketClient.

 * @type: a #GSocketType

 *

 * Sets the socket type of the socket client.

 * The sockets created by this object will be of the specified

 * type.

 *

 * It doesn't make sense to specify a type of %G_SOCKET_TYPE_DATAGRAM,

 * as GSocketClient is used for connection oriented services.

 *

 * Since: 2.22

 */

void

g_socket_client_set_socket_type (GSocketClient *client,

				 GSocketType    type)

{

  if (client->priv->type == type)

    return;

  client->priv->type = type;

  g_object_notify (G_OBJECT (client), "type");

}

/**

 * g_socket_client_get_protocol:

 * @client: a #GSocketClient

 *

 * Gets the protocol name type of the socket client.

 *

 * See g_socket_client_set_protocol() for details.

 *

 * Returns: a #GSocketProtocol

 *

 * Since: 2.22

 */

GSocketProtocol

g_socket_client_get_protocol (GSocketClient *client)

{

  return client->priv->protocol;

}

/**

 * g_socket_client_set_protocol:

 * @client: a #GSocketClient.

 * @protocol: a #GSocketProtocol

 *

 * Sets the protocol of the socket client.

 * The sockets created by this object will use of the specified

 * protocol.

 *

 * If @protocol is %0 that means to use the default

 * protocol for the socket family and type.

 *

 * Since: 2.22

 */

void

g_socket_client_set_protocol (GSocketClient   *client,

			      GSocketProtocol  protocol)

{

  if (client->priv->protocol == protocol)

    return;

  client->priv->protocol = protocol;

  g_object_notify (G_OBJECT (client), "protocol");

}

/**

 * g_socket_client_get_local_address:

 * @client: a #GSocketClient.

 *

 * Gets the local address of the socket client.

 *

 * See g_socket_client_set_local_address() for details.

 *

 * Returns: (transfer none): a #GSocketAddress or %NULL. Do not free.

 *

 * Since: 2.22

 */

GSocketAddress *

g_socket_client_get_local_address (GSocketClient *client)

{

  return client->priv->local_address;

}

/**

 * g_socket_client_set_local_address:

 * @client: a #GSocketClient.

 * @address: (nullable): a #GSocketAddress, or %NULL

 *

 * Sets the local address of the socket client.

 * The sockets created by this object will bound to the

 * specified address (if not %NULL) before connecting.

 *

 * This is useful if you want to ensure that the local

 * side of the connection is on a specific port, or on

 * a specific interface.

 *

 * Since: 2.22

 */

void

g_socket_client_set_local_address (GSocketClient  *client,

				   GSocketAddress *address)

{

  if (address)

    g_object_ref (address);

  if (client->priv->local_address)

    {

      g_object_unref (client->priv->local_address);

    }

  client->priv->local_address = address;

  g_object_notify (G_OBJECT (client), "local-address");

}

/**

 * g_socket_client_get_timeout:

 * @client: a #GSocketClient

 *

 * Gets the I/O timeout time for sockets created by @client.

 *

 * See g_socket_client_set_timeout() for details.

 *

 * Returns: the timeout in seconds

 *

 * Since: 2.26

 */

guint

g_socket_client_get_timeout (GSocketClient *client)

{

  return client->priv->timeout;

}

/**

 * g_socket_client_set_timeout:

 * @client: a #GSocketClient.

 * @timeout: the timeout

 *

 * Sets the I/O timeout for sockets created by @client. @timeout is a

 * time in seconds, or 0 for no timeout (the default).

 *

 * The timeout value affects the initial connection attempt as well,

 * so setting this may cause calls to g_socket_client_connect(), etc,

 * to fail with %G_IO_ERROR_TIMED_OUT.

 *

 * Since: 2.26

 */

void

g_socket_client_set_timeout (GSocketClient *client,

			     guint          timeout)

{

  if (client->priv->timeout == timeout)

    return;

  client->priv->timeout = timeout;

  g_object_notify (G_OBJECT (client), "timeout");

}

/**

 * g_socket_client_get_enable_proxy:

 * @client: a #GSocketClient.

 *

 * Gets the proxy enable state; see g_socket_client_set_enable_proxy()

 *

 * Returns: whether proxying is enabled

 *

 * Since: 2.26

 */

gboolean

g_socket_client_get_enable_proxy (GSocketClient *client)

{

  return client->priv->enable_proxy;

}

/**

 * g_socket_client_set_enable_proxy:

 * @client: a #GSocketClient.

 * @enable: whether to enable proxies

 *

 * Sets whether or not @client attempts to make connections via a

 * proxy server. When enabled (the default), #GSocketClient will use a

 * #GProxyResolver to determine if a proxy protocol such as SOCKS is

 * needed, and automatically do the necessary proxy negotiation.

 *

 * See also g_socket_client_set_proxy_resolver().

 *

 * Since: 2.26

 */

void

g_socket_client_set_enable_proxy (GSocketClient *client,

				  gboolean       enable)

{

  enable = !!enable;

  if (client->priv->enable_proxy == enable)

    return;

  client->priv->enable_proxy = enable;

  g_object_notify (G_OBJECT (client), "enable-proxy");

}

/**

 * g_socket_client_get_tls:

 * @client: a #GSocketClient.

 *

 * Gets whether @client creates TLS connections. See

 * g_socket_client_set_tls() for details.

 *

 * Returns: whether @client uses TLS

 *

 * Since: 2.28

 */

gboolean

g_socket_client_get_tls (GSocketClient *client)

{

  return client->priv->tls;

}

/**

 * g_socket_client_set_tls:

 * @client: a #GSocketClient.

 * @tls: whether to use TLS

 *

 * Sets whether @client creates TLS (aka SSL) connections. If @tls is

 * %TRUE, @client will wrap its connections in a #GTlsClientConnection

 * and perform a TLS handshake when connecting.

 *

 * Note that since #GSocketClient must return a #GSocketConnection,

 * but #GTlsClientConnection is not a #GSocketConnection, this

 * actually wraps the resulting #GTlsClientConnection in a

 * #GTcpWrapperConnection when returning it. You can use

 * g_tcp_wrapper_connection_get_base_io_stream() on the return value

 * to extract the #GTlsClientConnection.

 *

 * If you need to modify the behavior of the TLS handshake (eg, by

 * setting a client-side certificate to use, or connecting to the

 * #GTlsConnection::accept-certificate signal), you can connect to

 * @client's #GSocketClient::event signal and wait for it to be

 * emitted with %G_SOCKET_CLIENT_TLS_HANDSHAKING, which will give you

 * a chance to see the #GTlsClientConnection before the handshake

 * starts.

 *

 * Since: 2.28

 */

void

g_socket_client_set_tls (GSocketClient *client,

			 gboolean       tls)

{

  tls = !!tls;

  if (tls == client->priv->tls)

    return;

  client->priv->tls = tls;

  g_object_notify (G_OBJECT (client), "tls");

}

/**

 * g_socket_client_get_tls_validation_flags:

 * @client: a #GSocketClient.

 *

 * Gets the TLS validation flags used creating TLS connections via

 * @client.

 *

 * Returns: the TLS validation flags

 *

 * Since: 2.28

 */

GTlsCertificateFlags

g_socket_client_get_tls_validation_flags (GSocketClient *client)

{

  return client->priv->tls_validation_flags;

}

/**

 * g_socket_client_set_tls_validation_flags:

 * @client: a #GSocketClient.

 * @flags: the validation flags

 *

 * Sets the TLS validation flags used when creating TLS connections

 * via @client. The default value is %G_TLS_CERTIFICATE_VALIDATE_ALL.

 *

 * Since: 2.28

 */

void

g_socket_client_set_tls_validation_flags (GSocketClient        *client,

					  GTlsCertificateFlags  flags)

{

  if (client->priv->tls_validation_flags != flags)

    {

      client->priv->tls_validation_flags = flags;

      g_object_notify (G_OBJECT (client), "tls-validation-flags");

    }

}

/**

 * g_socket_client_get_proxy_resolver:

 * @client: a #GSocketClient.

 *

 * Gets the #GProxyResolver being used by @client. Normally, this will

 * be the resolver returned by g_proxy_resolver_get_default(), but you

 * can override it with g_socket_client_set_proxy_resolver().

 *

 * Returns: (transfer none): The #GProxyResolver being used by

 *   @client.

 *

 * Since: 2.36

 */

GProxyResolver *

g_socket_client_get_proxy_resolver (GSocketClient *client)

{

  if (client->priv->proxy_resolver)

    return client->priv->proxy_resolver;

  else

    return g_proxy_resolver_get_default ();

}

/**

 * g_socket_client_set_proxy_resolver:

 * @client: a #GSocketClient.

 * @proxy_resolver: (nullable): a #GProxyResolver, or %NULL for the

 *   default.

 *

 * Overrides the #GProxyResolver used by @client. You can call this if

 * you want to use specific proxies, rather than using the system

 * default proxy settings.

 *

 * Note that whether or not the proxy resolver is actually used

 * depends on the setting of #GSocketClient:enable-proxy, which is not

 * changed by this function (but which is %TRUE by default)

 *

 * Since: 2.36

 */

void

g_socket_client_set_proxy_resolver (GSocketClient  *client,

                                    GProxyResolver *proxy_resolver)

{

  /* We have to be careful to avoid calling

   * g_proxy_resolver_get_default() until we're sure we need it,

   * because trying to load the default proxy resolver module will

   * break some test programs that aren't expecting it (eg,

   * tests/gsettings).

   */

  if (client->priv->proxy_resolver)

    g_object_unref (client->priv->proxy_resolver);

  client->priv->proxy_resolver = proxy_resolver;

  if (client->priv->proxy_resolver)

    g_object_ref (client->priv->proxy_resolver);

}

static void

g_socket_client_class_init (GSocketClientClass *class)

{

  GObjectClass *gobject_class = G_OBJECT_CLASS (class);

  gobject_class->finalize = g_socket_client_finalize;

  gobject_class->set_property = g_socket_client_set_property;

  gobject_class->get_property = g_socket_client_get_property;

  /**

   * GSocketClient::event:

   * @client: the #GSocketClient

   * @event: the event that is occurring

   * @connectable: the #GSocketConnectable that @event is occurring on

   * @connection: (nullable): the current representation of the connection

   *

   * Emitted when @client's activity on @connectable changes state.

   * Among other things, this can be used to provide progress

   * information about a network connection in the UI. The meanings of

   * the different @event values are as follows:

   *

   * - %G_SOCKET_CLIENT_RESOLVING: @client is about to look up @connectable

   *   in DNS. @connection will be %NULL.

   *

   * - %G_SOCKET_CLIENT_RESOLVED:  @client has successfully resolved

   *   @connectable in DNS. @connection will be %NULL.

   *

   * - %G_SOCKET_CLIENT_CONNECTING: @client is about to make a connection

   *   to a remote host; either a proxy server or the destination server

   *   itself. @connection is the #GSocketConnection, which is not yet

   *   connected.  Since GLib 2.40, you can access the remote

   *   address via g_socket_connection_get_remote_address().

   *

   * - %G_SOCKET_CLIENT_CONNECTED: @client has successfully connected

   *   to a remote host. @connection is the connected #GSocketConnection.

   *

   * - %G_SOCKET_CLIENT_PROXY_NEGOTIATING: @client is about to negotiate

   *   with a proxy to get it to connect to @connectable. @connection is

   *   the #GSocketConnection to the proxy server.

   *

   * - %G_SOCKET_CLIENT_PROXY_NEGOTIATED: @client has negotiated a

   *   connection to @connectable through a proxy server. @connection is

   *   the stream returned from g_proxy_connect(), which may or may not

   *   be a #GSocketConnection.

   *

   * - %G_SOCKET_CLIENT_TLS_HANDSHAKING: @client is about to begin a TLS

   *   handshake. @connection is a #GTlsClientConnection.

   *

   * - %G_SOCKET_CLIENT_TLS_HANDSHAKED: @client has successfully completed

   *   the TLS handshake. @connection is a #GTlsClientConnection.

   *

   * - %G_SOCKET_CLIENT_COMPLETE: @client has either successfully connected

   *   to @connectable (in which case @connection is the #GSocketConnection

   *   that it will be returning to the caller) or has failed (in which

   *   case @connection is %NULL and the client is about to return an error).

   *

   * Each event except %G_SOCKET_CLIENT_COMPLETE may be emitted

   * multiple times (or not at all) for a given connectable (in

   * particular, if @client ends up attempting to connect to more than

   * one address). However, if @client emits the #GSocketClient::event

   * signal at all for a given connectable, that it will always emit

   * it with %G_SOCKET_CLIENT_COMPLETE when it is done.

   *

   * Note that there may be additional #GSocketClientEvent values in

   * the future; unrecognized @event values should be ignored.

   *

   * Since: 2.32

   */

  signals[EVENT] =

    g_signal_new (I_("event"),

		  G_TYPE_FROM_CLASS (gobject_class),

		  G_SIGNAL_RUN_LAST,

		  G_STRUCT_OFFSET (GSocketClientClass, event),

		  NULL, NULL,

		  NULL,

		  G_TYPE_NONE, 3,

		  G_TYPE_SOCKET_CLIENT_EVENT,

		  G_TYPE_SOCKET_CONNECTABLE,

		  G_TYPE_IO_STREAM);

  g_object_class_install_property (gobject_class, PROP_FAMILY,

				   g_param_spec_enum ("family",

						      P_("Socket family"),

						      P_("The sockets address family to use for socket construction"),

						      G_TYPE_SOCKET_FAMILY,

						      G_SOCKET_FAMILY_INVALID,

						      G_PARAM_CONSTRUCT |

                                                      G_PARAM_READWRITE |

                                                      G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_TYPE,

				   g_param_spec_enum ("type",

						      P_("Socket type"),

						      P_("The sockets type to use for socket construction"),

						      G_TYPE_SOCKET_TYPE,

						      G_SOCKET_TYPE_STREAM,

						      G_PARAM_CONSTRUCT |

                                                      G_PARAM_READWRITE |

                                                      G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_PROTOCOL,

				   g_param_spec_enum ("protocol",

						      P_("Socket protocol"),

						      P_("The protocol to use for socket construction, or 0 for default"),

						      G_TYPE_SOCKET_PROTOCOL,

						      G_SOCKET_PROTOCOL_DEFAULT,

						      G_PARAM_CONSTRUCT |

                                                      G_PARAM_READWRITE |

                                                      G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_LOCAL_ADDRESS,

				   g_param_spec_object ("local-address",

							P_("Local address"),

							P_("The local address constructed sockets will be bound to"),

							G_TYPE_SOCKET_ADDRESS,

							G_PARAM_CONSTRUCT |

                                                        G_PARAM_READWRITE |

                                                        G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_TIMEOUT,

				   g_param_spec_uint ("timeout",

						      P_("Socket timeout"),

						      P_("The I/O timeout for sockets, or 0 for none"),

						      0, G_MAXUINT, 0,

						      G_PARAM_CONSTRUCT |