1 /* GIO - GLib Input, Output and Streaming Library
3 * Copyright © 2009 Codethink Limited
4 * Copyright © 2009 Red Hat, Inc
6 * This program is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU Lesser General Public License as published
8 * by the Free Software Foundation; either version 2 of the licence or (at
9 * your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General
17 * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
19 * Authors: Ryan Lortie <desrt@desrt.ca>
20 * Alexander Larsson <alexl@redhat.com>
24 * SECTION:gsocketservice
25 * @title: GSocketService
26 * @short_description: Make it easy to implement a network service
28 * @see_also: #GThreadedSocketService, #GSocketListener.
30 * A #GSocketService is an object that represents a service that
31 * is provided to the network or over local sockets. When a new
32 * connection is made to the service the #GSocketService::incoming
35 * A #GSocketService is a subclass of #GSocketListener and you need
36 * to add the addresses you want to accept connections on with the
37 * #GSocketListener APIs.
39 * There are two options for implementing a network service based on
40 * #GSocketService. The first is to create the service using
41 * g_socket_service_new() and to connect to the #GSocketService::incoming
42 * signal. The second is to subclass #GSocketService and override the
43 * default signal handler implementation.
45 * In either case, the handler must immediately return, or else it
46 * will block additional incoming connections from being serviced.
47 * If you are interested in writing connection handlers that contain
48 * blocking code then see #GThreadedSocketService.
50 * The socket service runs on the main loop of the
51 * [thread-default context][g-main-context-push-thread-default-context]
52 * of the thread it is created in, and is not
53 * threadsafe in general. However, the calls to start and stop the
54 * service are thread-safe so these can be used from threads that
55 * handle incoming clients.
61 #include "gsocketservice.h"
64 #include "gsocketlistener.h"
65 #include "gsocketconnection.h"
67 struct _GSocketServicePrivate
69 GCancellable *cancellable;
71 guint outstanding_accept : 1;
74 static guint g_socket_service_incoming_signal;
76 G_LOCK_DEFINE_STATIC(active);
78 G_DEFINE_TYPE_WITH_PRIVATE (GSocketService, g_socket_service, G_TYPE_SOCKET_LISTENER)
80 static void g_socket_service_ready (GObject *object,
85 g_socket_service_real_incoming (GSocketService *service,
86 GSocketConnection *connection,
87 GObject *source_object)
93 g_socket_service_init (GSocketService *service)
95 service->priv = g_socket_service_get_instance_private (service);
96 service->priv->cancellable = g_cancellable_new ();
97 service->priv->active = TRUE;
101 g_socket_service_finalize (GObject *object)
103 GSocketService *service = G_SOCKET_SERVICE (object);
105 g_object_unref (service->priv->cancellable);
107 G_OBJECT_CLASS (g_socket_service_parent_class)
112 do_accept (GSocketService *service)
114 g_socket_listener_accept_async (G_SOCKET_LISTENER (service),
115 service->priv->cancellable,
116 g_socket_service_ready, NULL);
117 service->priv->outstanding_accept = TRUE;
121 g_socket_service_changed (GSocketListener *listener)
123 GSocketService *service = G_SOCKET_SERVICE (listener);
127 if (service->priv->active)
129 if (service->priv->outstanding_accept)
130 g_cancellable_cancel (service->priv->cancellable);
133 g_socket_listener_accept_async (listener, service->priv->cancellable,
134 g_socket_service_ready, NULL);
135 service->priv->outstanding_accept = TRUE;
143 * g_socket_service_is_active:
144 * @service: a #GSocketService
146 * Check whether the service is active or not. An active
147 * service will accept new clients that connect, while
148 * a non-active service will let connecting clients queue
149 * up until the service is started.
151 * Returns: %TRUE if the service is active, %FALSE otherwise
156 g_socket_service_is_active (GSocketService *service)
161 active = service->priv->active;
167 * g_socket_service_start:
168 * @service: a #GSocketService
170 * Starts the service, i.e. start accepting connections
171 * from the added sockets when the mainloop runs.
173 * This call is thread-safe, so it may be called from a thread
174 * handling an incoming client request.
179 g_socket_service_start (GSocketService *service)
183 if (!service->priv->active)
185 service->priv->active = TRUE;
187 if (service->priv->outstanding_accept)
188 g_cancellable_cancel (service->priv->cancellable);
197 * g_socket_service_stop:
198 * @service: a #GSocketService
200 * Stops the service, i.e. stops accepting connections
201 * from the added sockets when the mainloop runs.
203 * This call is thread-safe, so it may be called from a thread
204 * handling an incoming client request.
206 * Note that this only stops accepting new connections; it does not
207 * close the listening sockets, and you can call
208 * g_socket_service_start() again later to begin listening again. To
209 * close the listening sockets, call g_socket_listener_close(). (This
210 * will happen automatically when the #GSocketService is finalized.)
215 g_socket_service_stop (GSocketService *service)
219 if (service->priv->active)
221 service->priv->active = FALSE;
223 if (service->priv->outstanding_accept)
224 g_cancellable_cancel (service->priv->cancellable);
232 g_socket_service_incoming (GSocketService *service,
233 GSocketConnection *connection,
234 GObject *source_object)
238 g_signal_emit (service, g_socket_service_incoming_signal,
239 0, connection, source_object, &result);
244 g_socket_service_class_init (GSocketServiceClass *class)
246 GObjectClass *gobject_class = G_OBJECT_CLASS (class);
247 GSocketListenerClass *listener_class = G_SOCKET_LISTENER_CLASS (class);
249 gobject_class->finalize = g_socket_service_finalize;
250 listener_class->changed = g_socket_service_changed;
251 class->incoming = g_socket_service_real_incoming;
254 * GSocketService::incoming:
255 * @service: the #GSocketService
256 * @connection: a new #GSocketConnection object
257 * @source_object: (allow-none): the source_object passed to
258 * g_socket_listener_add_address()
260 * The ::incoming signal is emitted when a new incoming connection
261 * to @service needs to be handled. The handler must initiate the
262 * handling of @connection, but may not block; in essence,
263 * asynchronous operations must be used.
265 * @connection will be unreffed once the signal handler returns,
266 * so you need to ref it yourself if you are planning to use it.
268 * Returns: %TRUE to stop other handlers from being called
272 g_socket_service_incoming_signal =
273 g_signal_new ("incoming", G_TYPE_FROM_CLASS (class), G_SIGNAL_RUN_LAST,
274 G_STRUCT_OFFSET (GSocketServiceClass, incoming),
275 g_signal_accumulator_true_handled, NULL,
276 NULL, G_TYPE_BOOLEAN,
277 2, G_TYPE_SOCKET_CONNECTION, G_TYPE_OBJECT);
281 g_socket_service_ready (GObject *object,
282 GAsyncResult *result,
285 GSocketListener *listener = G_SOCKET_LISTENER (object);
286 GSocketService *service = G_SOCKET_SERVICE (object);
287 GSocketConnection *connection;
288 GObject *source_object;
289 GError *error = NULL;
291 connection = g_socket_listener_accept_finish (listener, result, &source_object, &error);
294 if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
295 g_warning ("fail: %s", error->message);
296 g_error_free (error);
300 g_socket_service_incoming (service, connection, source_object);
301 g_object_unref (connection);
306 g_cancellable_reset (service->priv->cancellable);
309 service->priv->outstanding_accept = FALSE;
310 if (service->priv->active)
318 * g_socket_service_new:
320 * Creates a new #GSocketService with no sockets to listen for.
321 * New listeners can be added with e.g. g_socket_listener_add_address()
322 * or g_socket_listener_add_inet_port().
324 * Returns: a new #GSocketService.
329 g_socket_service_new (void)
331 return g_object_new (G_TYPE_SOCKET_SERVICE, NULL);