1 /* GIO - GLib Input, Output and Streaming Library
3 * Copyright © 2008 Christian Kellner, Samuel Cormier-Iijima
5 * Copyright © 2009 Red Hat, Inc
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General
18 * Public License along with this library; if not, write to the
19 * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
20 * Boston, MA 02111-1307, USA.
22 * Authors: Christian Kellner <gicmo@gnome.org>
23 * Samuel Cormier-Iijima <sciyoshi@gmail.com>
24 * Ryan Lortie <desrt@desrt.ca>
25 * Alexander Larsson <alexl@redhat.com>
30 #include "gsocketconnection.h"
32 #include "gsocketoutputstream.h"
33 #include "gsocketinputstream.h"
34 #include <gio/giostream.h>
35 #include <gio/gtask.h>
36 #include "gunixconnection.h"
37 #include "gtcpconnection.h"
42 * SECTION:gsocketconnection
43 * @short_description: A socket connection
45 * @see_also: #GIOStream, #GSocketClient, #GSocketListener
47 * #GSocketConnection is a #GIOStream for a connected socket. They
48 * can be created either by #GSocketClient when connecting to a host,
49 * or by #GSocketListener when accepting a new client.
51 * The type of the #GSocketConnection object returned from these calls
52 * depends on the type of the underlying socket that is in use. For
53 * instance, for a TCP/IP connection it will be a #GTcpConnection.
55 * Choosing what type of object to construct is done with the socket
56 * connection factory, and it is possible for 3rd parties to register
57 * custom socket connection types for specific combination of socket
58 * family/type/protocol using g_socket_connection_factory_register_type().
69 struct _GSocketConnectionPrivate
72 GInputStream *input_stream;
73 GOutputStream *output_stream;
78 static gboolean g_socket_connection_close (GIOStream *stream,
79 GCancellable *cancellable,
81 static void g_socket_connection_close_async (GIOStream *stream,
83 GCancellable *cancellable,
84 GAsyncReadyCallback callback,
86 static gboolean g_socket_connection_close_finish (GIOStream *stream,
90 G_DEFINE_TYPE_WITH_PRIVATE (GSocketConnection, g_socket_connection, G_TYPE_IO_STREAM)
93 g_socket_connection_get_input_stream (GIOStream *io_stream)
95 GSocketConnection *connection = G_SOCKET_CONNECTION (io_stream);
97 if (connection->priv->input_stream == NULL)
98 connection->priv->input_stream = (GInputStream *)
99 _g_socket_input_stream_new (connection->priv->socket);
101 return connection->priv->input_stream;
104 static GOutputStream *
105 g_socket_connection_get_output_stream (GIOStream *io_stream)
107 GSocketConnection *connection = G_SOCKET_CONNECTION (io_stream);
109 if (connection->priv->output_stream == NULL)
110 connection->priv->output_stream = (GOutputStream *)
111 _g_socket_output_stream_new (connection->priv->socket);
113 return connection->priv->output_stream;
117 * g_socket_connection_is_connected:
118 * @connection: a #GSocketConnection
120 * Checks if @connection is connected. This is equivalent to calling
121 * g_socket_is_connected() on @connection's underlying #GSocket.
123 * Returns: whether @connection is connected
128 g_socket_connection_is_connected (GSocketConnection *connection)
130 return g_socket_is_connected (connection->priv->socket);
134 * g_socket_connection_connect:
135 * @connection: a #GSocketConnection
136 * @address: a #GSocketAddress specifying the remote address.
137 * @cancellable: (allow-none): a %GCancellable or %NULL
138 * @error: #GError for error reporting, or %NULL to ignore.
140 * Connect @connection to the specified remote address.
142 * Returns: %TRUE if the connection succeeded, %FALSE on error
147 g_socket_connection_connect (GSocketConnection *connection,
148 GSocketAddress *address,
149 GCancellable *cancellable,
152 g_return_val_if_fail (G_IS_SOCKET_CONNECTION (connection), FALSE);
153 g_return_val_if_fail (G_IS_SOCKET_ADDRESS (address), FALSE);
155 return g_socket_connect (connection->priv->socket, address,
159 static gboolean g_socket_connection_connect_callback (GSocket *socket,
160 GIOCondition condition,
164 * g_socket_connection_connect_async:
165 * @connection: a #GSocketConnection
166 * @address: a #GSocketAddress specifying the remote address.
167 * @cancellable: (allow-none): a %GCancellable or %NULL
168 * @callback: (scope async): a #GAsyncReadyCallback
169 * @user_data: (closure): user data for the callback
171 * Asynchronously connect @connection to the specified remote address.
173 * This clears the #GSocket:blocking flag on @connection's underlying
174 * socket if it is currently set.
176 * Use g_socket_connection_connect_finish() to retrieve the result.
181 g_socket_connection_connect_async (GSocketConnection *connection,
182 GSocketAddress *address,
183 GCancellable *cancellable,
184 GAsyncReadyCallback callback,
188 GError *tmp_error = NULL;
190 g_return_if_fail (G_IS_SOCKET_CONNECTION (connection));
191 g_return_if_fail (G_IS_SOCKET_ADDRESS (address));
193 task = g_task_new (connection, cancellable, callback, user_data);
195 g_socket_set_blocking (connection->priv->socket, FALSE);
197 if (g_socket_connect (connection->priv->socket, address,
198 cancellable, &tmp_error))
200 g_task_return_boolean (task, TRUE);
201 g_object_unref (task);
203 else if (g_error_matches (tmp_error, G_IO_ERROR, G_IO_ERROR_PENDING))
207 g_error_free (tmp_error);
208 source = g_socket_create_source (connection->priv->socket,
209 G_IO_OUT, cancellable);
210 g_task_attach_source (task, source,
211 (GSourceFunc) g_socket_connection_connect_callback);
212 g_source_unref (source);
216 g_task_return_error (task, tmp_error);
217 g_object_unref (task);
222 g_socket_connection_connect_callback (GSocket *socket,
223 GIOCondition condition,
226 GTask *task = user_data;
227 GSocketConnection *connection = g_task_get_source_object (task);
228 GError *error = NULL;
230 if (g_socket_check_connect_result (connection->priv->socket, &error))
231 g_task_return_boolean (task, TRUE);
233 g_task_return_error (task, error);
235 g_object_unref (task);
240 * g_socket_connection_connect_finish:
241 * @connection: a #GSocketConnection
242 * @result: the #GAsyncResult
243 * @error: #GError for error reporting, or %NULL to ignore.
245 * Gets the result of a g_socket_connection_connect_async() call.
247 * Returns: %TRUE if the connection succeeded, %FALSE on error
252 g_socket_connection_connect_finish (GSocketConnection *connection,
253 GAsyncResult *result,
256 g_return_val_if_fail (G_IS_SOCKET_CONNECTION (connection), FALSE);
257 g_return_val_if_fail (g_task_is_valid (result, connection), FALSE);
259 return g_task_propagate_boolean (G_TASK (result), error);
263 * g_socket_connection_get_socket:
264 * @connection: a #GSocketConnection
266 * Gets the underlying #GSocket object of the connection.
267 * This can be useful if you want to do something unusual on it
268 * not supported by the #GSocketConnection APIs.
270 * Returns: (transfer none): a #GSocketAddress or %NULL on error.
275 g_socket_connection_get_socket (GSocketConnection *connection)
277 g_return_val_if_fail (G_IS_SOCKET_CONNECTION (connection), NULL);
279 return connection->priv->socket;
283 * g_socket_connection_get_local_address:
284 * @connection: a #GSocketConnection
285 * @error: #GError for error reporting, or %NULL to ignore.
287 * Try to get the local address of a socket connection.
289 * Returns: (transfer full): a #GSocketAddress or %NULL on error.
290 * Free the returned object with g_object_unref().
295 g_socket_connection_get_local_address (GSocketConnection *connection,
298 return g_socket_get_local_address (connection->priv->socket, error);
302 * g_socket_connection_get_remote_address:
303 * @connection: a #GSocketConnection
304 * @error: #GError for error reporting, or %NULL to ignore.
306 * Try to get the remote address of a socket connection.
308 * Returns: (transfer full): a #GSocketAddress or %NULL on error.
309 * Free the returned object with g_object_unref().
314 g_socket_connection_get_remote_address (GSocketConnection *connection,
317 return g_socket_get_remote_address (connection->priv->socket, error);
321 g_socket_connection_get_property (GObject *object,
326 GSocketConnection *connection = G_SOCKET_CONNECTION (object);
331 g_value_set_object (value, connection->priv->socket);
335 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
340 g_socket_connection_set_property (GObject *object,
345 GSocketConnection *connection = G_SOCKET_CONNECTION (object);
350 connection->priv->socket = G_SOCKET (g_value_dup_object (value));
354 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
359 g_socket_connection_constructed (GObject *object)
361 GSocketConnection *connection = G_SOCKET_CONNECTION (object);
363 g_assert (connection->priv->socket != NULL);
367 g_socket_connection_dispose (GObject *object)
369 GSocketConnection *connection = G_SOCKET_CONNECTION (object);
371 connection->priv->in_dispose = TRUE;
373 G_OBJECT_CLASS (g_socket_connection_parent_class)
376 connection->priv->in_dispose = FALSE;
380 g_socket_connection_finalize (GObject *object)
382 GSocketConnection *connection = G_SOCKET_CONNECTION (object);
384 if (connection->priv->input_stream)
385 g_object_unref (connection->priv->input_stream);
387 if (connection->priv->output_stream)
388 g_object_unref (connection->priv->output_stream);
390 g_object_unref (connection->priv->socket);
392 G_OBJECT_CLASS (g_socket_connection_parent_class)
397 g_socket_connection_class_init (GSocketConnectionClass *klass)
399 GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
400 GIOStreamClass *stream_class = G_IO_STREAM_CLASS (klass);
402 gobject_class->set_property = g_socket_connection_set_property;
403 gobject_class->get_property = g_socket_connection_get_property;
404 gobject_class->constructed = g_socket_connection_constructed;
405 gobject_class->finalize = g_socket_connection_finalize;
406 gobject_class->dispose = g_socket_connection_dispose;
408 stream_class->get_input_stream = g_socket_connection_get_input_stream;
409 stream_class->get_output_stream = g_socket_connection_get_output_stream;
410 stream_class->close_fn = g_socket_connection_close;
411 stream_class->close_async = g_socket_connection_close_async;
412 stream_class->close_finish = g_socket_connection_close_finish;
414 g_object_class_install_property (gobject_class,
416 g_param_spec_object ("socket",
418 P_("The underlying GSocket"),
420 G_PARAM_CONSTRUCT_ONLY |
422 G_PARAM_STATIC_STRINGS));
426 g_socket_connection_init (GSocketConnection *connection)
428 connection->priv = g_socket_connection_get_instance_private (connection);
432 g_socket_connection_close (GIOStream *stream,
433 GCancellable *cancellable,
436 GSocketConnection *connection = G_SOCKET_CONNECTION (stream);
438 if (connection->priv->output_stream)
439 g_output_stream_close (connection->priv->output_stream,
441 if (connection->priv->input_stream)
442 g_input_stream_close (connection->priv->input_stream,
445 /* Don't close the underlying socket if this is being called
446 * as part of dispose(); when destroying the GSocketConnection,
447 * we only want to close the socket if we're holding the last
448 * reference on it, and in that case it will close itself when
449 * we unref it in finalize().
451 if (connection->priv->in_dispose)
454 return g_socket_close (connection->priv->socket, error);
459 g_socket_connection_close_async (GIOStream *stream,
461 GCancellable *cancellable,
462 GAsyncReadyCallback callback,
466 GIOStreamClass *class;
469 class = G_IO_STREAM_GET_CLASS (stream);
471 task = g_task_new (stream, cancellable, callback, user_data);
473 /* socket close is not blocked, just do it! */
475 if (class->close_fn &&
476 !class->close_fn (stream, cancellable, &error))
477 g_task_return_error (task, error);
479 g_task_return_boolean (task, TRUE);
481 g_object_unref (task);
485 g_socket_connection_close_finish (GIOStream *stream,
486 GAsyncResult *result,
489 return g_task_propagate_boolean (G_TASK (result), error);
493 GSocketFamily socket_family;
494 GSocketType socket_type;
496 GType implementation;
500 connection_factory_hash (gconstpointer key)
502 const ConnectionFactory *factory = key;
505 h = factory->socket_family ^ (factory->socket_type << 4) ^ (factory->protocol << 8);
506 /* This is likely to be small, so spread over whole
507 hash space to get some distribution */
508 h = h ^ (h << 8) ^ (h << 16) ^ (h << 24);
514 connection_factory_equal (gconstpointer _a,
517 const ConnectionFactory *a = _a;
518 const ConnectionFactory *b = _b;
520 if (a->socket_family != b->socket_family)
523 if (a->socket_type != b->socket_type)
526 if (a->protocol != b->protocol)
532 static GHashTable *connection_factories = NULL;
533 G_LOCK_DEFINE_STATIC(connection_factories);
536 * g_socket_connection_factory_register_type:
537 * @g_type: a #GType, inheriting from %G_TYPE_SOCKET_CONNECTION
538 * @family: a #GSocketFamily
539 * @type: a #GSocketType
540 * @protocol: a protocol id
542 * Looks up the #GType to be used when creating socket connections on
543 * sockets with the specified @family, @type and @protocol.
545 * If no type is registered, the #GSocketConnection base type is returned.
550 g_socket_connection_factory_register_type (GType g_type,
551 GSocketFamily family,
555 ConnectionFactory *factory;
557 g_return_if_fail (g_type_is_a (g_type, G_TYPE_SOCKET_CONNECTION));
559 G_LOCK (connection_factories);
561 if (connection_factories == NULL)
562 connection_factories = g_hash_table_new_full (connection_factory_hash,
563 connection_factory_equal,
564 (GDestroyNotify)g_free,
567 factory = g_new0 (ConnectionFactory, 1);
568 factory->socket_family = family;
569 factory->socket_type = type;
570 factory->protocol = protocol;
571 factory->implementation = g_type;
573 g_hash_table_insert (connection_factories,
576 G_UNLOCK (connection_factories);
580 init_builtin_types (void)
583 g_type_ensure (G_TYPE_UNIX_CONNECTION);
585 g_type_ensure (G_TYPE_TCP_CONNECTION);
589 * g_socket_connection_factory_lookup_type:
590 * @family: a #GSocketFamily
591 * @type: a #GSocketType
592 * @protocol_id: a protocol id
594 * Looks up the #GType to be used when creating socket connections on
595 * sockets with the specified @family, @type and @protocol_id.
597 * If no type is registered, the #GSocketConnection base type is returned.
604 g_socket_connection_factory_lookup_type (GSocketFamily family,
608 ConnectionFactory *factory, key;
611 init_builtin_types ();
613 G_LOCK (connection_factories);
615 g_type = G_TYPE_SOCKET_CONNECTION;
617 if (connection_factories)
619 key.socket_family = family;
620 key.socket_type = type;
621 key.protocol = protocol_id;
623 factory = g_hash_table_lookup (connection_factories, &key);
625 g_type = factory->implementation;
628 G_UNLOCK (connection_factories);
634 * g_socket_connection_factory_create_connection:
635 * @socket: a #GSocket
637 * Creates a #GSocketConnection subclass of the right type for
640 * Returns: (transfer full): a #GSocketConnection
645 g_socket_connection_factory_create_connection (GSocket *socket)
649 type = g_socket_connection_factory_lookup_type (g_socket_get_family (socket),
650 g_socket_get_socket_type (socket),
651 g_socket_get_protocol (socket));
652 return g_object_new (type, "socket", socket, NULL);