/* GIO - GLib Input, Output and Streaming Library * * Copyright © 2008 Christian Kellner, Samuel Cormier-Iijima * © 2008 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 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, write to the * Free Software Foundation, Inc., 59 Temple Place, Suite 330, * Boston, MA 02111-1307, USA. * * Authors: Christian Kellner * Samuel Cormier-Iijima * Ryan Lortie * Alexander Larsson */ #include "config.h" #include "gsocketconnection.h" #include "gsocketoutputstream.h" #include "gsocketinputstream.h" #include #include #include "gunixconnection.h" #include "gtcpconnection.h" #include "glibintl.h" /** * SECTION:gsocketconnection * @short_description: A socket connection * @include: gio/gio.h * @see_also: #GIOStream, #GSocketClient, #GSocketListener * * #GSocketConnection is a #GIOStream for a connected socket. They * can be created either by #GSocketClient when connecting to a host, * or by #GSocketListener when accepting a new client. * * The type of the #GSocketConnection object returned from these calls * depends on the type of the underlying socket that is in use. For * instance, for a TCP/IP connection it will be a #GTcpConnection. * * Chosing what type of object to construct is done with the socket * connection factory, and it is possible for 3rd parties to register * custom socket connection types for specific combination of socket * family/type/protocol using g_socket_connection_factory_register_type(). * * Since: 2.22 */ G_DEFINE_TYPE (GSocketConnection, g_socket_connection, G_TYPE_IO_STREAM); enum { PROP_NONE, PROP_SOCKET, }; struct _GSocketConnectionPrivate { GSocket *socket; GInputStream *input_stream; GOutputStream *output_stream; gboolean in_dispose; }; static gboolean g_socket_connection_close (GIOStream *stream, GCancellable *cancellable, GError **error); static void g_socket_connection_close_async (GIOStream *stream, int io_priority, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); static gboolean g_socket_connection_close_finish (GIOStream *stream, GAsyncResult *result, GError **error); static GInputStream * g_socket_connection_get_input_stream (GIOStream *io_stream) { GSocketConnection *connection = G_SOCKET_CONNECTION (io_stream); if (connection->priv->input_stream == NULL) connection->priv->input_stream = (GInputStream *) _g_socket_input_stream_new (connection->priv->socket); return connection->priv->input_stream; } static GOutputStream * g_socket_connection_get_output_stream (GIOStream *io_stream) { GSocketConnection *connection = G_SOCKET_CONNECTION (io_stream); if (connection->priv->output_stream == NULL) connection->priv->output_stream = (GOutputStream *) _g_socket_output_stream_new (connection->priv->socket); return connection->priv->output_stream; } /** * g_socket_connection_get_socket: * @connection: a #GSocketConnection * * Gets the underlying #GSocket object of the connection. * This can be useful if you want to do something unusual on it * not supported by the #GSocketConnection APIs. * * Returns: (transfer none): a #GSocketAddress or %NULL on error. * * Since: 2.22 */ GSocket * g_socket_connection_get_socket (GSocketConnection *connection) { g_return_val_if_fail (G_IS_SOCKET_CONNECTION (connection), NULL); return connection->priv->socket; } /** * g_socket_connection_get_local_address: * @connection: a #GSocketConnection * @error: #GError for error reporting, or %NULL to ignore. * * Try to get the local address of a socket connection. * * Returns: (transfer full): a #GSocketAddress or %NULL on error. * Free the returned object with g_object_unref(). * * Since: 2.22 */ GSocketAddress * g_socket_connection_get_local_address (GSocketConnection *connection, GError **error) { return g_socket_get_local_address (connection->priv->socket, error); } /** * g_socket_connection_get_remote_address: * @connection: a #GSocketConnection * @error: #GError for error reporting, or %NULL to ignore. * * Try to get the remote address of a socket connection. * * Returns: (transfer full): a #GSocketAddress or %NULL on error. * Free the returned object with g_object_unref(). * * Since: 2.22 */ GSocketAddress * g_socket_connection_get_remote_address (GSocketConnection *connection, GError **error) { return g_socket_get_remote_address (connection->priv->socket, error); } static void g_socket_connection_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { GSocketConnection *connection = G_SOCKET_CONNECTION (object); switch (prop_id) { case PROP_SOCKET: g_value_set_object (value, connection->priv->socket); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); } } static void g_socket_connection_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { GSocketConnection *connection = G_SOCKET_CONNECTION (object); switch (prop_id) { case PROP_SOCKET: connection->priv->socket = G_SOCKET (g_value_dup_object (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); } } static void g_socket_connection_constructed (GObject *object) { GSocketConnection *connection = G_SOCKET_CONNECTION (object); g_assert (connection->priv->socket != NULL); } static void g_socket_connection_dispose (GObject *object) { GSocketConnection *connection = G_SOCKET_CONNECTION (object); connection->priv->in_dispose = TRUE; G_OBJECT_CLASS (g_socket_connection_parent_class) ->dispose (object); connection->priv->in_dispose = FALSE; } static void g_socket_connection_finalize (GObject *object) { GSocketConnection *connection = G_SOCKET_CONNECTION (object); if (connection->priv->input_stream) g_object_unref (connection->priv->input_stream); if (connection->priv->output_stream) g_object_unref (connection->priv->output_stream); g_object_unref (connection->priv->socket); G_OBJECT_CLASS (g_socket_connection_parent_class) ->finalize (object); } static void g_socket_connection_class_init (GSocketConnectionClass *klass) { GObjectClass *gobject_class = G_OBJECT_CLASS (klass); GIOStreamClass *stream_class = G_IO_STREAM_CLASS (klass); g_type_class_add_private (klass, sizeof (GSocketConnectionPrivate)); gobject_class->set_property = g_socket_connection_set_property; gobject_class->get_property = g_socket_connection_get_property; gobject_class->constructed = g_socket_connection_constructed; gobject_class->finalize = g_socket_connection_finalize; gobject_class->dispose = g_socket_connection_dispose; stream_class->get_input_stream = g_socket_connection_get_input_stream; stream_class->get_output_stream = g_socket_connection_get_output_stream; stream_class->close_fn = g_socket_connection_close; stream_class->close_async = g_socket_connection_close_async; stream_class->close_finish = g_socket_connection_close_finish; g_object_class_install_property (gobject_class, PROP_SOCKET, g_param_spec_object ("socket", P_("Socket"), P_("The underlying GSocket"), G_TYPE_SOCKET, G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); } static void g_socket_connection_init (GSocketConnection *connection) { connection->priv = G_TYPE_INSTANCE_GET_PRIVATE (connection, G_TYPE_SOCKET_CONNECTION, GSocketConnectionPrivate); } static gboolean g_socket_connection_close (GIOStream *stream, GCancellable *cancellable, GError **error) { GSocketConnection *connection = G_SOCKET_CONNECTION (stream); if (connection->priv->output_stream) g_output_stream_close (connection->priv->output_stream, cancellable, NULL); if (connection->priv->input_stream) g_input_stream_close (connection->priv->input_stream, cancellable, NULL); /* Don't close the underlying socket if this is being called * as part of dispose(); when destroying the GSocketConnection, * we only want to close the socket if we're holding the last * reference on it, and in that case it will close itself when * we unref it in finalize(). */ if (connection->priv->in_dispose) return TRUE; return g_socket_close (connection->priv->socket, error); } static void g_socket_connection_close_async (GIOStream *stream, int io_priority, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GSimpleAsyncResult *res; GIOStreamClass *class; GError *error; class = G_IO_STREAM_GET_CLASS (stream); /* socket close is not blocked, just do it! */ error = NULL; if (class->close_fn && !class->close_fn (stream, cancellable, &error)) { g_simple_async_report_take_gerror_in_idle (G_OBJECT (stream), callback, user_data, error); return; } res = g_simple_async_result_new (G_OBJECT (stream), callback, user_data, g_socket_connection_close_async); g_simple_async_result_complete_in_idle (res); g_object_unref (res); } static gboolean g_socket_connection_close_finish (GIOStream *stream, GAsyncResult *result, GError **error) { return TRUE; } typedef struct { GSocketFamily socket_family; GSocketType socket_type; int protocol; GType implementation; } ConnectionFactory; static guint connection_factory_hash (gconstpointer key) { const ConnectionFactory *factory = key; guint h; h = factory->socket_family ^ (factory->socket_type << 4) ^ (factory->protocol << 8); /* This is likely to be small, so spread over whole hash space to get some distribution */ h = h ^ (h << 8) ^ (h << 16) ^ (h << 24); return h; } static gboolean connection_factory_equal (gconstpointer _a, gconstpointer _b) { const ConnectionFactory *a = _a; const ConnectionFactory *b = _b; if (a->socket_family != b->socket_family) return FALSE; if (a->socket_type != b->socket_type) return FALSE; if (a->protocol != b->protocol) return FALSE; return TRUE; } static GHashTable *connection_factories = NULL; G_LOCK_DEFINE_STATIC(connection_factories); /** * g_socket_connection_factory_register_type: * @g_type: a #GType, inheriting from %G_TYPE_SOCKET_CONNECTION * @family: a #GSocketFamily * @type: a #GSocketType * @protocol: a protocol id * * Looks up the #GType to be used when creating socket connections on * sockets with the specified @family,@type and @protocol. * * If no type is registered, the #GSocketConnection base type is returned. * * Since: 2.22 */ void g_socket_connection_factory_register_type (GType g_type, GSocketFamily family, GSocketType type, gint protocol) { ConnectionFactory *factory; g_return_if_fail (g_type_is_a (g_type, G_TYPE_SOCKET_CONNECTION)); G_LOCK (connection_factories); if (connection_factories == NULL) connection_factories = g_hash_table_new_full (connection_factory_hash, connection_factory_equal, (GDestroyNotify)g_free, NULL); factory = g_new0 (ConnectionFactory, 1); factory->socket_family = family; factory->socket_type = type; factory->protocol = protocol; factory->implementation = g_type; g_hash_table_insert (connection_factories, factory, factory); G_UNLOCK (connection_factories); } static void init_builtin_types (void) { volatile GType a_type; #ifndef G_OS_WIN32 a_type = g_unix_connection_get_type (); #endif a_type = g_tcp_connection_get_type (); (a_type); /* To avoid -Wunused-but-set-variable */ } /** * g_socket_connection_factory_lookup_type: * @family: a #GSocketFamily * @type: a #GSocketType * @protocol_id: a protocol id * * Looks up the #GType to be used when creating socket connections on * sockets with the specified @family,@type and @protocol_id. * * If no type is registered, the #GSocketConnection base type is returned. * * Returns: a #GType * * Since: 2.22 */ GType g_socket_connection_factory_lookup_type (GSocketFamily family, GSocketType type, gint protocol_id) { ConnectionFactory *factory, key; GType g_type; init_builtin_types (); G_LOCK (connection_factories); g_type = G_TYPE_SOCKET_CONNECTION; if (connection_factories) { key.socket_family = family; key.socket_type = type; key.protocol = protocol_id; factory = g_hash_table_lookup (connection_factories, &key); if (factory) g_type = factory->implementation; } G_UNLOCK (connection_factories); return g_type; } /** * g_socket_connection_factory_create_connection: * @socket: a #GSocket * * Creates a #GSocketConnection subclass of the right type for * @socket. * * Returns: (transfer full): a #GSocketConnection * * Since: 2.22 */ GSocketConnection * g_socket_connection_factory_create_connection (GSocket *socket) { GType type; type = g_socket_connection_factory_lookup_type (g_socket_get_family (socket), g_socket_get_socket_type (socket), g_socket_get_protocol (socket)); return g_object_new (type, "socket", socket, NULL); }