| /* GIO - GLib Input, Output and Streaming Library |
| * |
| * Copyright © 2008 Christian Kellner, Samuel Cormier-Iijima |
| * Copyright © 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 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: Christian Kellner <gicmo@gnome.org> |
| * Samuel Cormier-Iijima <sciyoshi@gmail.com> |
| * Ryan Lortie <desrt@desrt.ca> |
| * Alexander Larsson <alexl@redhat.com> |
| */ |
| |
| #include "config.h" |
| #include "gsocketlistener.h" |
| |
| #include <gio/gioenumtypes.h> |
| #include <gio/gtask.h> |
| #include <gio/gcancellable.h> |
| #include <gio/gsocketaddress.h> |
| #include <gio/ginetaddress.h> |
| #include <gio/gioerror.h> |
| #include <gio/gsocket.h> |
| #include <gio/gsocketconnection.h> |
| #include <gio/ginetsocketaddress.h> |
| #include "glibintl.h" |
| |
| |
| /** |
| * SECTION:gsocketlistener |
| * @title: GSocketListener |
| * @short_description: Helper for accepting network client connections |
| * @include: gio/gio.h |
| * @see_also: #GThreadedSocketService, #GSocketService. |
| * |
| * A #GSocketListener is an object that keeps track of a set |
| * of server sockets and helps you accept sockets from any of the |
| * socket, either sync or async. |
| * |
| * If you want to implement a network server, also look at #GSocketService |
| * and #GThreadedSocketService which are subclass of #GSocketListener |
| * that makes this even easier. |
| * |
| * Since: 2.22 |
| */ |
| |
| enum |
| { |
| PROP_0, |
| PROP_LISTEN_BACKLOG |
| }; |
| |
| enum |
| { |
| EVENT, |
| LAST_SIGNAL |
| }; |
| |
| static guint signals[LAST_SIGNAL] = { 0 }; |
| |
| static GQuark source_quark = 0; |
| |
| struct _GSocketListenerPrivate |
| { |
| GPtrArray *sockets; |
| GMainContext *main_context; |
| int listen_backlog; |
| guint closed : 1; |
| }; |
| |
| G_DEFINE_TYPE_WITH_PRIVATE (GSocketListener, g_socket_listener, G_TYPE_OBJECT) |
| |
| static void |
| g_socket_listener_finalize (GObject *object) |
| { |
| GSocketListener *listener = G_SOCKET_LISTENER (object); |
| |
| if (listener->priv->main_context) |
| g_main_context_unref (listener->priv->main_context); |
| |
| /* Do not explicitly close the sockets. Instead, let them close themselves if |
| * their final reference is dropped, but keep them open if a reference is |
| * held externally to the GSocketListener (which is possible if |
| * g_socket_listener_add_socket() was used). |
| */ |
| g_ptr_array_free (listener->priv->sockets, TRUE); |
| |
| G_OBJECT_CLASS (g_socket_listener_parent_class) |
| ->finalize (object); |
| } |
| |
| static void |
| g_socket_listener_get_property (GObject *object, |
| guint prop_id, |
| GValue *value, |
| GParamSpec *pspec) |
| { |
| GSocketListener *listener = G_SOCKET_LISTENER (object); |
| |
| switch (prop_id) |
| { |
| case PROP_LISTEN_BACKLOG: |
| g_value_set_int (value, listener->priv->listen_backlog); |
| break; |
| |
| default: |
| G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); |
| } |
| } |
| |
| static void |
| g_socket_listener_set_property (GObject *object, |
| guint prop_id, |
| const GValue *value, |
| GParamSpec *pspec) |
| { |
| GSocketListener *listener = G_SOCKET_LISTENER (object); |
| |
| switch (prop_id) |
| { |
| case PROP_LISTEN_BACKLOG: |
| g_socket_listener_set_backlog (listener, g_value_get_int (value)); |
| break; |
| |
| default: |
| G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); |
| } |
| } |
| |
| static void |
| g_socket_listener_class_init (GSocketListenerClass *klass) |
| { |
| GObjectClass *gobject_class G_GNUC_UNUSED = G_OBJECT_CLASS (klass); |
| |
| gobject_class->finalize = g_socket_listener_finalize; |
| gobject_class->set_property = g_socket_listener_set_property; |
| gobject_class->get_property = g_socket_listener_get_property; |
| g_object_class_install_property (gobject_class, PROP_LISTEN_BACKLOG, |
| g_param_spec_int ("listen-backlog", |
| P_("Listen backlog"), |
| P_("outstanding connections in the listen queue"), |
| 0, |
| 2000, |
| 10, |
| G_PARAM_CONSTRUCT | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); |
| |
| /** |
| * GSocketListener::event: |
| * @listener: the #GSocketListener |
| * @event: the event that is occurring |
| * @socket: the #GSocket the event is occurring on |
| * |
| * Emitted when @listener's activity on @socket changes state. |
| * Note that when @listener is used to listen on both IPv4 and |
| * IPv6, a separate set of signals will be emitted for each, and |
| * the order they happen in is undefined. |
| * |
| * Since: 2.46 |
| */ |
| signals[EVENT] = |
| g_signal_new (I_("event"), |
| G_TYPE_FROM_CLASS (gobject_class), |
| G_SIGNAL_RUN_LAST, |
| G_STRUCT_OFFSET (GSocketListenerClass, event), |
| NULL, NULL, NULL, |
| G_TYPE_NONE, 2, |
| G_TYPE_SOCKET_LISTENER_EVENT, |
| G_TYPE_SOCKET); |
| |
| source_quark = g_quark_from_static_string ("g-socket-listener-source"); |
| } |
| |
| static void |
| g_socket_listener_init (GSocketListener *listener) |
| { |
| listener->priv = g_socket_listener_get_instance_private (listener); |
| listener->priv->sockets = |
| g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref); |
| listener->priv->listen_backlog = 10; |
| } |
| |
| /** |
| * g_socket_listener_new: |
| * |
| * Creates a new #GSocketListener with no sockets to listen for. |
| * New listeners can be added with e.g. g_socket_listener_add_address() |
| * or g_socket_listener_add_inet_port(). |
| * |
| * Returns: a new #GSocketListener. |
| * |
| * Since: 2.22 |
| */ |
| GSocketListener * |
| g_socket_listener_new (void) |
| { |
| return g_object_new (G_TYPE_SOCKET_LISTENER, NULL); |
| } |
| |
| static gboolean |
| check_listener (GSocketListener *listener, |
| GError **error) |
| { |
| if (listener->priv->closed) |
| { |
| g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_CLOSED, |
| _("Listener is already closed")); |
| return FALSE; |
| } |
| |
| return TRUE; |
| } |
| |
| /** |
| * g_socket_listener_add_socket: |
| * @listener: a #GSocketListener |
| * @socket: a listening #GSocket |
| * @source_object: (allow-none): Optional #GObject identifying this source |
| * @error: #GError for error reporting, or %NULL to ignore. |
| * |
| * Adds @socket to the set of sockets that we try to accept |
| * new clients from. The socket must be bound to a local |
| * address and listened to. |
| * |
| * @source_object will be passed out in the various calls |
| * to accept to identify this particular source, which is |
| * useful if you're listening on multiple addresses and do |
| * different things depending on what address is connected to. |
| * |
| * The @socket will not be automatically closed when the @listener is finalized |
| * unless the listener held the final reference to the socket. Before GLib 2.42, |
| * the @socket was automatically closed on finalization of the @listener, even |
| * if references to it were held elsewhere. |
| * |
| * Returns: %TRUE on success, %FALSE on error. |
| * |
| * Since: 2.22 |
| */ |
| gboolean |
| g_socket_listener_add_socket (GSocketListener *listener, |
| GSocket *socket, |
| GObject *source_object, |
| GError **error) |
| { |
| if (!check_listener (listener, error)) |
| return FALSE; |
| |
| /* TODO: Check that socket it is bound & not closed? */ |
| |
| if (g_socket_is_closed (socket)) |
| { |
| g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED, |
| _("Added socket is closed")); |
| return FALSE; |
| } |
| |
| g_object_ref (socket); |
| g_ptr_array_add (listener->priv->sockets, socket); |
| |
| if (source_object) |
| g_object_set_qdata_full (G_OBJECT (socket), source_quark, |
| g_object_ref (source_object), g_object_unref); |
| |
| |
| if (G_SOCKET_LISTENER_GET_CLASS (listener)->changed) |
| G_SOCKET_LISTENER_GET_CLASS (listener)->changed (listener); |
| |
| return TRUE; |
| } |
| |
| /** |
| * g_socket_listener_add_address: |
| * @listener: a #GSocketListener |
| * @address: a #GSocketAddress |
| * @type: a #GSocketType |
| * @protocol: a #GSocketProtocol |
| * @source_object: (allow-none): Optional #GObject identifying this source |
| * @effective_address: (out) (allow-none): location to store the address that was bound to, or %NULL. |
| * @error: #GError for error reporting, or %NULL to ignore. |
| * |
| * Creates a socket of type @type and protocol @protocol, binds |
| * it to @address and adds it to the set of sockets we're accepting |
| * sockets from. |
| * |
| * Note that adding an IPv6 address, depending on the platform, |
| * may or may not result in a listener that also accepts IPv4 |
| * connections. For more deterministic behavior, see |
| * g_socket_listener_add_inet_port(). |
| * |
| * @source_object will be passed out in the various calls |
| * to accept to identify this particular source, which is |
| * useful if you're listening on multiple addresses and do |
| * different things depending on what address is connected to. |
| * |
| * If successful and @effective_address is non-%NULL then it will |
| * be set to the address that the binding actually occurred at. This |
| * is helpful for determining the port number that was used for when |
| * requesting a binding to port 0 (ie: "any port"). This address, if |
| * requested, belongs to the caller and must be freed. |
| * |
| * Returns: %TRUE on success, %FALSE on error. |
| * |
| * Since: 2.22 |
| */ |
| gboolean |
| g_socket_listener_add_address (GSocketListener *listener, |
| GSocketAddress *address, |
| GSocketType type, |
| GSocketProtocol protocol, |
| GObject *source_object, |
| GSocketAddress **effective_address, |
| GError **error) |
| { |
| GSocketAddress *local_address; |
| GSocketFamily family; |
| GSocket *socket; |
| |
| if (!check_listener (listener, error)) |
| return FALSE; |
| |
| family = g_socket_address_get_family (address); |
| socket = g_socket_new (family, type, protocol, error); |
| if (socket == NULL) |
| return FALSE; |
| |
| g_socket_set_listen_backlog (socket, listener->priv->listen_backlog); |
| |
| g_signal_emit (listener, signals[EVENT], 0, |
| G_SOCKET_LISTENER_BINDING, socket); |
| |
| if (!g_socket_bind (socket, address, TRUE, error)) |
| { |
| g_object_unref (socket); |
| return FALSE; |
| } |
| |
| g_signal_emit (listener, signals[EVENT], 0, |
| G_SOCKET_LISTENER_BOUND, socket); |
| g_signal_emit (listener, signals[EVENT], 0, |
| G_SOCKET_LISTENER_LISTENING, socket); |
| |
| if (!g_socket_listen (socket, error)) |
| { |
| g_object_unref (socket); |
| return FALSE; |
| } |
| |
| g_signal_emit (listener, signals[EVENT], 0, |
| G_SOCKET_LISTENER_LISTENED, socket); |
| |
| local_address = NULL; |
| if (effective_address) |
| { |
| local_address = g_socket_get_local_address (socket, error); |
| if (local_address == NULL) |
| { |
| g_object_unref (socket); |
| return FALSE; |
| } |
| } |
| |
| if (!g_socket_listener_add_socket (listener, socket, |
| source_object, |
| error)) |
| { |
| if (local_address) |
| g_object_unref (local_address); |
| g_object_unref (socket); |
| return FALSE; |
| } |
| |
| if (effective_address) |
| *effective_address = local_address; |
| |
| g_object_unref (socket); /* add_socket refs this */ |
| |
| return TRUE; |
| } |
| |
| /** |
| * g_socket_listener_add_inet_port: |
| * @listener: a #GSocketListener |
| * @port: an IP port number (non-zero) |
| * @source_object: (allow-none): Optional #GObject identifying this source |
| * @error: #GError for error reporting, or %NULL to ignore. |
| * |
| * Helper function for g_socket_listener_add_address() that |
| * creates a TCP/IP socket listening on IPv4 and IPv6 (if |
| * supported) on the specified port on all interfaces. |
| * |
| * @source_object will be passed out in the various calls |
| * to accept to identify this particular source, which is |
| * useful if you're listening on multiple addresses and do |
| * different things depending on what address is connected to. |
| * |
| * Returns: %TRUE on success, %FALSE on error. |
| * |
| * Since: 2.22 |
| */ |
| gboolean |
| g_socket_listener_add_inet_port (GSocketListener *listener, |
| guint16 port, |
| GObject *source_object, |
| GError **error) |
| { |
| gboolean need_ipv4_socket = TRUE; |
| GSocket *socket4 = NULL; |
| GSocket *socket6; |
| |
| g_return_val_if_fail (listener != NULL, FALSE); |
| g_return_val_if_fail (port != 0, FALSE); |
| |
| if (!check_listener (listener, error)) |
| return FALSE; |
| |
| /* first try to create an IPv6 socket */ |
| socket6 = g_socket_new (G_SOCKET_FAMILY_IPV6, |
| G_SOCKET_TYPE_STREAM, |
| G_SOCKET_PROTOCOL_DEFAULT, |
| NULL); |
| |
| if (socket6 != NULL) |
| /* IPv6 is supported on this platform, so if we fail now it is |
| * a result of being unable to bind to our port. Don't fail |
| * silently as a result of this! |
| */ |
| { |
| GInetAddress *inet_address; |
| GSocketAddress *address; |
| |
| inet_address = g_inet_address_new_any (G_SOCKET_FAMILY_IPV6); |
| address = g_inet_socket_address_new (inet_address, port); |
| g_object_unref (inet_address); |
| |
| g_socket_set_listen_backlog (socket6, listener->priv->listen_backlog); |
| |
| g_signal_emit (listener, signals[EVENT], 0, |
| G_SOCKET_LISTENER_BINDING, socket6); |
| |
| if (!g_socket_bind (socket6, address, TRUE, error)) |
| { |
| g_object_unref (address); |
| g_object_unref (socket6); |
| return FALSE; |
| } |
| |
| g_object_unref (address); |
| |
| g_signal_emit (listener, signals[EVENT], 0, |
| G_SOCKET_LISTENER_BOUND, socket6); |
| g_signal_emit (listener, signals[EVENT], 0, |
| G_SOCKET_LISTENER_LISTENING, socket6); |
| |
| if (!g_socket_listen (socket6, error)) |
| { |
| g_object_unref (socket6); |
| return FALSE; |
| } |
| |
| g_signal_emit (listener, signals[EVENT], 0, |
| G_SOCKET_LISTENER_LISTENED, socket6); |
| |
| if (source_object) |
| g_object_set_qdata_full (G_OBJECT (socket6), source_quark, |
| g_object_ref (source_object), |
| g_object_unref); |
| |
| /* If this socket already speaks IPv4 then we are done. */ |
| if (g_socket_speaks_ipv4 (socket6)) |
| need_ipv4_socket = FALSE; |
| } |
| |
| if (need_ipv4_socket) |
| /* We are here for exactly one of the following reasons: |
| * |
| * - our platform doesn't support IPv6 |
| * - we successfully created an IPv6 socket but it's V6ONLY |
| * |
| * In either case, we need to go ahead and create an IPv4 socket |
| * and fail the call if we can't bind to it. |
| */ |
| { |
| socket4 = g_socket_new (G_SOCKET_FAMILY_IPV4, |
| G_SOCKET_TYPE_STREAM, |
| G_SOCKET_PROTOCOL_DEFAULT, |
| error); |
| |
| if (socket4 != NULL) |
| /* IPv4 is supported on this platform, so if we fail now it is |
| * a result of being unable to bind to our port. Don't fail |
| * silently as a result of this! |
| */ |
| { |
| GInetAddress *inet_address; |
| GSocketAddress *address; |
| |
| inet_address = g_inet_address_new_any (G_SOCKET_FAMILY_IPV4); |
| address = g_inet_socket_address_new (inet_address, port); |
| g_object_unref (inet_address); |
| |
| g_socket_set_listen_backlog (socket4, |
| listener->priv->listen_backlog); |
| |
| g_signal_emit (listener, signals[EVENT], 0, |
| G_SOCKET_LISTENER_BINDING, socket4); |
| |
| if (!g_socket_bind (socket4, address, TRUE, error)) |
| { |
| g_object_unref (address); |
| g_object_unref (socket4); |
| if (socket6 != NULL) |
| g_object_unref (socket6); |
| |
| return FALSE; |
| } |
| |
| g_object_unref (address); |
| |
| g_signal_emit (listener, signals[EVENT], 0, |
| G_SOCKET_LISTENER_BOUND, socket4); |
| g_signal_emit (listener, signals[EVENT], 0, |
| G_SOCKET_LISTENER_LISTENING, socket4); |
| |
| if (!g_socket_listen (socket4, error)) |
| { |
| g_object_unref (socket4); |
| if (socket6 != NULL) |
| g_object_unref (socket6); |
| |
| return FALSE; |
| } |
| |
| g_signal_emit (listener, signals[EVENT], 0, |
| G_SOCKET_LISTENER_LISTENED, socket4); |
| |
| if (source_object) |
| g_object_set_qdata_full (G_OBJECT (socket4), source_quark, |
| g_object_ref (source_object), |
| g_object_unref); |
| } |
| else |
| /* Ok. So IPv4 is not supported on this platform. If we |
| * succeeded at creating an IPv6 socket then that's OK, but |
| * otherwise we need to tell the user we failed. |
| */ |
| { |
| if (socket6 != NULL) |
| g_clear_error (error); |
| else |
| return FALSE; |
| } |
| } |
| |
| g_assert (socket6 != NULL || socket4 != NULL); |
| |
| if (socket6 != NULL) |
| g_ptr_array_add (listener->priv->sockets, socket6); |
| |
| if (socket4 != NULL) |
| g_ptr_array_add (listener->priv->sockets, socket4); |
| |
| if (G_SOCKET_LISTENER_GET_CLASS (listener)->changed) |
| G_SOCKET_LISTENER_GET_CLASS (listener)->changed (listener); |
| |
| return TRUE; |
| } |
| |
| static GList * |
| add_sources (GSocketListener *listener, |
| GSocketSourceFunc callback, |
| gpointer callback_data, |
| GCancellable *cancellable, |
| GMainContext *context) |
| { |
| GSocket *socket; |
| GSource *source; |
| GList *sources; |
| int i; |
| |
| sources = NULL; |
| for (i = 0; i < listener->priv->sockets->len; i++) |
| { |
| socket = listener->priv->sockets->pdata[i]; |
| |
| source = g_socket_create_source (socket, G_IO_IN, cancellable); |
| g_source_set_callback (source, |
| (GSourceFunc) callback, |
| callback_data, NULL); |
| g_source_attach (source, context); |
| |
| sources = g_list_prepend (sources, source); |
| } |
| |
| return sources; |
| } |
| |
| static void |
| free_sources (GList *sources) |
| { |
| GSource *source; |
| while (sources != NULL) |
| { |
| source = sources->data; |
| sources = g_list_delete_link (sources, sources); |
| g_source_destroy (source); |
| g_source_unref (source); |
| } |
| } |
| |
| struct AcceptData { |
| GMainLoop *loop; |
| GSocket *socket; |
| }; |
| |
| static gboolean |
| accept_callback (GSocket *socket, |
| GIOCondition condition, |
| gpointer user_data) |
| { |
| struct AcceptData *data = user_data; |
| |
| data->socket = socket; |
| g_main_loop_quit (data->loop); |
| |
| return TRUE; |
| } |
| |
| /** |
| * g_socket_listener_accept_socket: |
| * @listener: a #GSocketListener |
| * @source_object: (out) (transfer none) (allow-none): location where #GObject pointer will be stored, or %NULL. |
| * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore. |
| * @error: #GError for error reporting, or %NULL to ignore. |
| * |
| * Blocks waiting for a client to connect to any of the sockets added |
| * to the listener. Returns the #GSocket that was accepted. |
| * |
| * If you want to accept the high-level #GSocketConnection, not a #GSocket, |
| * which is often the case, then you should use g_socket_listener_accept() |
| * instead. |
| * |
| * If @source_object is not %NULL it will be filled out with the source |
| * object specified when the corresponding socket or address was added |
| * to the listener. |
| * |
| * If @cancellable is not %NULL, then the operation can be cancelled by |
| * triggering the cancellable object from another thread. If the operation |
| * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. |
| * |
| * Returns: (transfer full): a #GSocket on success, %NULL on error. |
| * |
| * Since: 2.22 |
| */ |
| GSocket * |
| g_socket_listener_accept_socket (GSocketListener *listener, |
| GObject **source_object, |
| GCancellable *cancellable, |
| GError **error) |
| { |
| GSocket *accept_socket, *socket; |
| |
| g_return_val_if_fail (G_IS_SOCKET_LISTENER (listener), NULL); |
| |
| if (!check_listener (listener, error)) |
| return NULL; |
| |
| if (listener->priv->sockets->len == 1) |
| { |
| accept_socket = listener->priv->sockets->pdata[0]; |
| if (!g_socket_condition_wait (accept_socket, G_IO_IN, |
| cancellable, error)) |
| return NULL; |
| } |
| else |
| { |
| GList *sources; |
| struct AcceptData data; |
| GMainLoop *loop; |
| |
| if (listener->priv->main_context == NULL) |
| listener->priv->main_context = g_main_context_new (); |
| |
| loop = g_main_loop_new (listener->priv->main_context, FALSE); |
| data.loop = loop; |
| sources = add_sources (listener, |
| accept_callback, |
| &data, |
| cancellable, |
| listener->priv->main_context); |
| g_main_loop_run (loop); |
| accept_socket = data.socket; |
| free_sources (sources); |
| g_main_loop_unref (loop); |
| } |
| |
| if (!(socket = g_socket_accept (accept_socket, cancellable, error))) |
| return NULL; |
| |
| if (source_object) |
| *source_object = g_object_get_qdata (G_OBJECT (accept_socket), source_quark); |
| |
| return socket; |
| } |
| |
| /** |
| * g_socket_listener_accept: |
| * @listener: a #GSocketListener |
| * @source_object: (out) (transfer none) (allow-none): location where #GObject pointer will be stored, or %NULL |
| * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore. |
| * @error: #GError for error reporting, or %NULL to ignore. |
| * |
| * Blocks waiting for a client to connect to any of the sockets added |
| * to the listener. Returns a #GSocketConnection for the socket that was |
| * accepted. |
| * |
| * If @source_object is not %NULL it will be filled out with the source |
| * object specified when the corresponding socket or address was added |
| * to the listener. |
| * |
| * If @cancellable is not %NULL, then the operation can be cancelled by |
| * triggering the cancellable object from another thread. If the operation |
| * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. |
| * |
| * Returns: (transfer full): a #GSocketConnection on success, %NULL on error. |
| * |
| * Since: 2.22 |
| */ |
| GSocketConnection * |
| g_socket_listener_accept (GSocketListener *listener, |
| GObject **source_object, |
| GCancellable *cancellable, |
| GError **error) |
| { |
| GSocketConnection *connection; |
| GSocket *socket; |
| |
| socket = g_socket_listener_accept_socket (listener, |
| source_object, |
| cancellable, |
| error); |
| if (socket == NULL) |
| return NULL; |
| |
| connection = g_socket_connection_factory_create_connection (socket); |
| g_object_unref (socket); |
| |
| return connection; |
| } |
| |
| static gboolean |
| accept_ready (GSocket *accept_socket, |
| GIOCondition condition, |
| gpointer user_data) |
| { |
| GTask *task = user_data; |
| GError *error = NULL; |
| GSocket *socket; |
| GObject *source_object; |
| |
| socket = g_socket_accept (accept_socket, g_task_get_cancellable (task), &error); |
| if (socket) |
| { |
| source_object = g_object_get_qdata (G_OBJECT (accept_socket), source_quark); |
| if (source_object) |
| g_object_set_qdata_full (G_OBJECT (task), |
| source_quark, |
| g_object_ref (source_object), g_object_unref); |
| g_task_return_pointer (task, socket, g_object_unref); |
| } |
| else |
| { |
| g_task_return_error (task, error); |
| } |
| |
| g_object_unref (task); |
| return FALSE; |
| } |
| |
| /** |
| * g_socket_listener_accept_socket_async: |
| * @listener: a #GSocketListener |
| * @cancellable: (allow-none): a #GCancellable, or %NULL |
| * @callback: (scope async): a #GAsyncReadyCallback |
| * @user_data: (closure): user data for the callback |
| * |
| * This is the asynchronous version of g_socket_listener_accept_socket(). |
| * |
| * When the operation is finished @callback will be |
| * called. You can then call g_socket_listener_accept_socket_finish() |
| * to get the result of the operation. |
| * |
| * Since: 2.22 |
| */ |
| void |
| g_socket_listener_accept_socket_async (GSocketListener *listener, |
| GCancellable *cancellable, |
| GAsyncReadyCallback callback, |
| gpointer user_data) |
| { |
| GTask *task; |
| GList *sources; |
| GError *error = NULL; |
| |
| task = g_task_new (listener, cancellable, callback, user_data); |
| g_task_set_source_tag (task, g_socket_listener_accept_socket_async); |
| |
| if (!check_listener (listener, &error)) |
| { |
| g_task_return_error (task, error); |
| g_object_unref (task); |
| return; |
| } |
| |
| sources = add_sources (listener, |
| accept_ready, |
| task, |
| cancellable, |
| g_main_context_get_thread_default ()); |
| g_task_set_task_data (task, sources, (GDestroyNotify) free_sources); |
| } |
| |
| /** |
| * g_socket_listener_accept_socket_finish: |
| * @listener: a #GSocketListener |
| * @result: a #GAsyncResult. |
| * @source_object: (out) (transfer none) (allow-none): Optional #GObject identifying this source |
| * @error: a #GError location to store the error occurring, or %NULL to |
| * ignore. |
| * |
| * Finishes an async accept operation. See g_socket_listener_accept_socket_async() |
| * |
| * Returns: (transfer full): a #GSocket on success, %NULL on error. |
| * |
| * Since: 2.22 |
| */ |
| GSocket * |
| g_socket_listener_accept_socket_finish (GSocketListener *listener, |
| GAsyncResult *result, |
| GObject **source_object, |
| GError **error) |
| { |
| g_return_val_if_fail (G_IS_SOCKET_LISTENER (listener), NULL); |
| g_return_val_if_fail (g_task_is_valid (result, listener), NULL); |
| |
| if (source_object) |
| *source_object = g_object_get_qdata (G_OBJECT (result), source_quark); |
| |
| return g_task_propagate_pointer (G_TASK (result), error); |
| } |
| |
| /** |
| * g_socket_listener_accept_async: |
| * @listener: a #GSocketListener |
| * @cancellable: (allow-none): a #GCancellable, or %NULL |
| * @callback: (scope async): a #GAsyncReadyCallback |
| * @user_data: (closure): user data for the callback |
| * |
| * This is the asynchronous version of g_socket_listener_accept(). |
| * |
| * When the operation is finished @callback will be |
| * called. You can then call g_socket_listener_accept_socket() |
| * to get the result of the operation. |
| * |
| * Since: 2.22 |
| */ |
| void |
| g_socket_listener_accept_async (GSocketListener *listener, |
| GCancellable *cancellable, |
| GAsyncReadyCallback callback, |
| gpointer user_data) |
| { |
| g_socket_listener_accept_socket_async (listener, |
| cancellable, |
| callback, |
| user_data); |
| } |
| |
| /** |
| * g_socket_listener_accept_finish: |
| * @listener: a #GSocketListener |
| * @result: a #GAsyncResult. |
| * @source_object: (out) (transfer none) (allow-none): Optional #GObject identifying this source |
| * @error: a #GError location to store the error occurring, or %NULL to |
| * ignore. |
| * |
| * Finishes an async accept operation. See g_socket_listener_accept_async() |
| * |
| * Returns: (transfer full): a #GSocketConnection on success, %NULL on error. |
| * |
| * Since: 2.22 |
| */ |
| GSocketConnection * |
| g_socket_listener_accept_finish (GSocketListener *listener, |
| GAsyncResult *result, |
| GObject **source_object, |
| GError **error) |
| { |
| GSocket *socket; |
| GSocketConnection *connection; |
| |
| socket = g_socket_listener_accept_socket_finish (listener, |
| result, |
| source_object, |
| error); |
| if (socket == NULL) |
| return NULL; |
| |
| connection = g_socket_connection_factory_create_connection (socket); |
| g_object_unref (socket); |
| return connection; |
| } |
| |
| /** |
| * g_socket_listener_set_backlog: |
| * @listener: a #GSocketListener |
| * @listen_backlog: an integer |
| * |
| * Sets the listen backlog on the sockets in the listener. |
| * |
| * See g_socket_set_listen_backlog() for details |
| * |
| * Since: 2.22 |
| */ |
| void |
| g_socket_listener_set_backlog (GSocketListener *listener, |
| int listen_backlog) |
| { |
| GSocket *socket; |
| int i; |
| |
| if (listener->priv->closed) |
| return; |
| |
| listener->priv->listen_backlog = listen_backlog; |
| |
| for (i = 0; i < listener->priv->sockets->len; i++) |
| { |
| socket = listener->priv->sockets->pdata[i]; |
| g_socket_set_listen_backlog (socket, listen_backlog); |
| } |
| } |
| |
| /** |
| * g_socket_listener_close: |
| * @listener: a #GSocketListener |
| * |
| * Closes all the sockets in the listener. |
| * |
| * Since: 2.22 |
| */ |
| void |
| g_socket_listener_close (GSocketListener *listener) |
| { |
| GSocket *socket; |
| int i; |
| |
| g_return_if_fail (G_IS_SOCKET_LISTENER (listener)); |
| |
| if (listener->priv->closed) |
| return; |
| |
| for (i = 0; i < listener->priv->sockets->len; i++) |
| { |
| socket = listener->priv->sockets->pdata[i]; |
| g_socket_close (socket, NULL); |
| } |
| listener->priv->closed = TRUE; |
| } |
| |
| /** |
| * g_socket_listener_add_any_inet_port: |
| * @listener: a #GSocketListener |
| * @source_object: (allow-none): Optional #GObject identifying this source |
| * @error: a #GError location to store the error occurring, or %NULL to |
| * ignore. |
| * |
| * Listens for TCP connections on any available port number for both |
| * IPv6 and IPv4 (if each is available). |
| * |
| * This is useful if you need to have a socket for incoming connections |
| * but don't care about the specific port number. |
| * |
| * @source_object will be passed out in the various calls |
| * to accept to identify this particular source, which is |
| * useful if you're listening on multiple addresses and do |
| * different things depending on what address is connected to. |
| * |
| * Returns: the port number, or 0 in case of failure. |
| * |
| * Since: 2.24 |
| **/ |
| guint16 |
| g_socket_listener_add_any_inet_port (GSocketListener *listener, |
| GObject *source_object, |
| GError **error) |
| { |
| GSList *sockets_to_close = NULL; |
| guint16 candidate_port = 0; |
| GSocket *socket6 = NULL; |
| GSocket *socket4 = NULL; |
| gint attempts = 37; |
| |
| /* |
| * multi-step process: |
| * - first, create an IPv6 socket. |
| * - if that fails, create an IPv4 socket and bind it to port 0 and |
| * that's it. no retries if that fails (why would it?). |
| * - if our IPv6 socket also speaks IPv4 then we are done. |
| * - if not, then we need to create a IPv4 socket with the same port |
| * number. this might fail, of course. so we try this a bunch of |
| * times -- leaving the old IPv6 sockets open so that we get a |
| * different port number to try each time. |
| * - if all that fails then just give up. |
| */ |
| |
| while (attempts--) |
| { |
| GInetAddress *inet_address; |
| GSocketAddress *address; |
| gboolean result; |
| |
| g_assert (socket6 == NULL); |
| socket6 = g_socket_new (G_SOCKET_FAMILY_IPV6, |
| G_SOCKET_TYPE_STREAM, |
| G_SOCKET_PROTOCOL_DEFAULT, |
| NULL); |
| |
| if (socket6 != NULL) |
| { |
| inet_address = g_inet_address_new_any (G_SOCKET_FAMILY_IPV6); |
| address = g_inet_socket_address_new (inet_address, 0); |
| g_object_unref (inet_address); |
| |
| g_signal_emit (listener, signals[EVENT], 0, |
| G_SOCKET_LISTENER_BINDING, socket6); |
| |
| result = g_socket_bind (socket6, address, TRUE, error); |
| g_object_unref (address); |
| |
| if (!result || |
| !(address = g_socket_get_local_address (socket6, error))) |
| { |
| g_object_unref (socket6); |
| socket6 = NULL; |
| break; |
| } |
| |
| g_signal_emit (listener, signals[EVENT], 0, |
| G_SOCKET_LISTENER_BOUND, socket6); |
| |
| g_assert (G_IS_INET_SOCKET_ADDRESS (address)); |
| candidate_port = |
| g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (address)); |
| g_assert (candidate_port != 0); |
| g_object_unref (address); |
| |
| if (g_socket_speaks_ipv4 (socket6)) |
| break; |
| } |
| |
| g_assert (socket4 == NULL); |
| socket4 = g_socket_new (G_SOCKET_FAMILY_IPV4, |
| G_SOCKET_TYPE_STREAM, |
| G_SOCKET_PROTOCOL_DEFAULT, |
| socket6 ? NULL : error); |
| |
| if (socket4 == NULL) |
| /* IPv4 not supported. |
| * if IPv6 is supported then candidate_port will be non-zero |
| * (and the error parameter above will have been NULL) |
| * if IPv6 is unsupported then candidate_port will be zero |
| * (and error will have been set by the above call) |
| */ |
| break; |
| |
| inet_address = g_inet_address_new_any (G_SOCKET_FAMILY_IPV4); |
| address = g_inet_socket_address_new (inet_address, candidate_port); |
| g_object_unref (inet_address); |
| |
| g_signal_emit (listener, signals[EVENT], 0, |
| G_SOCKET_LISTENER_BINDING, socket4); |
| |
| /* a note on the 'error' clause below: |
| * |
| * if candidate_port is 0 then we report the error right away |
| * since it is strange that this binding would fail at all. |
| * otherwise, we ignore the error message (ie: NULL). |
| * |
| * the exception to this rule is the last time through the loop |
| * (ie: attempts == 0) in which case we want to set the error |
| * because failure here means that the entire call will fail and |
| * we need something to show to the user. |
| * |
| * an english summary of the situation: "if we gave a candidate |
| * port number AND we have more attempts to try, then ignore the |
| * error for now". |
| */ |
| result = g_socket_bind (socket4, address, TRUE, |
| (candidate_port && attempts) ? NULL : error); |
| g_object_unref (address); |
| |
| if (candidate_port) |
| { |
| g_assert (socket6 != NULL); |
| |
| if (result) |
| /* got our candidate port successfully */ |
| { |
| g_signal_emit (listener, signals[EVENT], 0, |
| G_SOCKET_LISTENER_BOUND, socket4); |
| break; |
| } |
| else |
| /* we failed to bind to the specified port. try again. */ |
| { |
| g_object_unref (socket4); |
| socket4 = NULL; |
| |
| /* keep this open so we get a different port number */ |
| sockets_to_close = g_slist_prepend (sockets_to_close, |
| socket6); |
| candidate_port = 0; |
| socket6 = NULL; |
| } |
| } |
| else |
| /* we didn't tell it a port. this means two things. |
| * - if we failed, then something really bad happened. |
| * - if we succeeded, then we need to find out the port number. |
| */ |
| { |
| g_assert (socket6 == NULL); |
| |
| if (!result || |
| !(address = g_socket_get_local_address (socket4, error))) |
| { |
| g_object_unref (socket4); |
| socket4 = NULL; |
| break; |
| } |
| |
| g_signal_emit (listener, signals[EVENT], 0, |
| G_SOCKET_LISTENER_BOUND, socket4); |
| |
| g_assert (G_IS_INET_SOCKET_ADDRESS (address)); |
| candidate_port = |
| g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (address)); |
| g_assert (candidate_port != 0); |
| g_object_unref (address); |
| break; |
| } |
| } |
| |
| /* should only be non-zero if we have a socket */ |
| g_assert ((candidate_port != 0) == (socket4 || socket6)); |
| |
| while (sockets_to_close) |
| { |
| g_object_unref (sockets_to_close->data); |
| sockets_to_close = g_slist_delete_link (sockets_to_close, |
| sockets_to_close); |
| } |
| |
| /* now we actually listen() the sockets and add them to the listener */ |
| if (socket6 != NULL) |
| { |
| g_socket_set_listen_backlog (socket6, listener->priv->listen_backlog); |
| |
| g_signal_emit (listener, signals[EVENT], 0, |
| G_SOCKET_LISTENER_LISTENING, socket6); |
| |
| if (!g_socket_listen (socket6, error)) |
| { |
| g_object_unref (socket6); |
| if (socket4) |
| g_object_unref (socket4); |
| |
| return 0; |
| } |
| |
| g_signal_emit (listener, signals[EVENT], 0, |
| G_SOCKET_LISTENER_LISTENED, socket6); |
| |
| if (source_object) |
| g_object_set_qdata_full (G_OBJECT (socket6), source_quark, |
| g_object_ref (source_object), |
| g_object_unref); |
| |
| g_ptr_array_add (listener->priv->sockets, socket6); |
| } |
| |
| if (socket4 != NULL) |
| { |
| g_socket_set_listen_backlog (socket4, listener->priv->listen_backlog); |
| |
| g_signal_emit (listener, signals[EVENT], 0, |
| G_SOCKET_LISTENER_LISTENING, socket4); |
| |
| if (!g_socket_listen (socket4, error)) |
| { |
| g_object_unref (socket4); |
| if (socket6) |
| g_object_unref (socket6); |
| |
| return 0; |
| } |
| |
| g_signal_emit (listener, signals[EVENT], 0, |
| G_SOCKET_LISTENER_LISTENED, socket4); |
| |
| if (source_object) |
| g_object_set_qdata_full (G_OBJECT (socket4), source_quark, |
| g_object_ref (source_object), |
| g_object_unref); |
| |
| g_ptr_array_add (listener->priv->sockets, socket4); |
| } |
| |
| if ((socket4 != NULL || socket6 != NULL) && |
| G_SOCKET_LISTENER_GET_CLASS (listener)->changed) |
| G_SOCKET_LISTENER_GET_CLASS (listener)->changed (listener); |
| |
| return candidate_port; |
| } |
