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, write to the
18 * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
19 * Boston, MA 02111-1307, USA.
21 * Authors: Ryan Lortie <desrt@desrt.ca>
22 * Alexander Larsson <alexl@redhat.com>
26 * SECTION: gsocketservice
27 * @title: GSocketService
28 * @short_description: Make it easy to implement a network service
29 * @see_also: #GThreadedSocketService, #GSocketListener.
31 * A #GSocketService is an object that represents a service that is
32 * provided to the network or over local sockets. When a new
33 * connection is made to the service the ::incoming signal is emitted.
35 * A #GSocketService is a subclass of #GSocketListener and you need
36 * to add the addresses you want to accept connections on to the
37 * with the #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 ::incoming signal.
42 * The second is to subclass #GSocketService and override the default
43 * signal handler implementation.
45 * In either case, the handler must immediately return, or else it
46 * will block additional incoming connections from being serviced. If
47 * you are interested in writing connection handlers that contain
48 * blocking code then see #GThreadedSocketService.
50 * The socket service runs on the main loop in the main thread, and is
51 * not threadsafe in general. However, the calls to start and stop
52 * the service are threadsafe so these can be used from threads that
53 * handle incomming clients.
59 #include "gsocketservice.h"
61 #include "gio-marshal.h"
63 #include "gsocketlistener.h"
64 #include "gsocketconnection.h"
68 static guint g_socket_service_incoming_signal;
70 G_DEFINE_TYPE (GSocketService, g_socket_service, G_TYPE_SOCKET_LISTENER);
72 G_LOCK_DEFINE_STATIC(active);
74 struct _GSocketServicePrivate
76 GCancellable *cancellable;
78 guint outstanding_accept : 1;
81 static void g_socket_service_ready (GObject *object,
86 g_socket_service_real_incoming (GSocketService *service,
87 GSocketConnection *connection,
88 GObject *source_object)
94 g_socket_service_init (GSocketService *service)
96 service->priv = G_TYPE_INSTANCE_GET_PRIVATE (service,
97 G_TYPE_SOCKET_SERVICE,
98 GSocketServicePrivate);
99 service->priv->cancellable = g_cancellable_new ();
100 service->priv->active = TRUE;
104 g_socket_service_finalize (GObject *object)
106 GSocketService *service = G_SOCKET_SERVICE (object);
108 g_object_unref (service->priv->cancellable);
110 G_OBJECT_CLASS (g_socket_service_parent_class)
115 do_accept (GSocketService *service)
117 g_socket_listener_accept_async (G_SOCKET_LISTENER (service),
118 service->priv->cancellable,
119 g_socket_service_ready, NULL);
120 service->priv->outstanding_accept = TRUE;
124 g_socket_service_changed (GSocketListener *listener)
126 GSocketService *service = G_SOCKET_SERVICE (listener);
130 if (service->priv->active)
132 if (service->priv->outstanding_accept)
133 g_cancellable_cancel (service->priv->cancellable);
136 g_socket_listener_accept_async (listener, service->priv->cancellable,
137 g_socket_service_ready, NULL);
138 service->priv->outstanding_accept = TRUE;
146 * g_socket_service_is_active:
147 * @service: a #GSocketService
149 * Check whether the service is active or not. An active
150 * service will accept new clients that connect, while
151 * a non-active service will let connecting clients queue
152 * up until the service is started.
154 * Returns: %TRUE if the service is active, %FALSE otherwise
159 g_socket_service_is_active (GSocketService *service)
164 active = service->priv->active;
170 * g_socket_service_start:
171 * @service: a #GSocketService
173 * Starts the service, i.e. start accepting connections
174 * from the added sockets when the mainloop runs.
176 * This call is threadsafe, so it may be called from a thread
177 * handling an incomming client request.
182 g_socket_service_start (GSocketService *service)
186 if (!service->priv->active)
188 service->priv->active = TRUE;
190 if (service->priv->outstanding_accept)
191 g_cancellable_cancel (service->priv->cancellable);
200 * g_socket_service_stop:
201 * @service: a #GSocketService
203 * Stops the service, i.e. stops accepting connections
204 * from the added sockets when the mainloop runs.
206 * This call is threadsafe, so it may be called from a thread
207 * handling an incomming client request.
212 g_socket_service_stop (GSocketService *service)
216 if (service->priv->active)
218 service->priv->active = FALSE;
220 if (service->priv->outstanding_accept)
221 g_cancellable_cancel (service->priv->cancellable);
229 g_socket_service_incoming (GSocketService *service,
230 GSocketConnection *connection,
231 GObject *source_object)
235 g_signal_emit (service, g_socket_service_incoming_signal,
236 0, connection, source_object, &result);
241 g_socket_service_class_init (GSocketServiceClass *class)
243 GObjectClass *gobject_class = G_OBJECT_CLASS (class);
244 GSocketListenerClass *listener_class = G_SOCKET_LISTENER_CLASS (class);
246 g_type_class_add_private (class, sizeof (GSocketServicePrivate));
248 gobject_class->finalize = g_socket_service_finalize;
249 listener_class->changed = g_socket_service_changed;
250 class->incoming = g_socket_service_real_incoming;
253 * GSocketService::incoming:
254 * @service: the #GSocketService.
255 * @connection: a new #GSocketConnection object.
256 * @source_object: the source_object passed to g_socket_listener_add_address().
257 * @returns: %TRUE if @connection has been handled.
259 * The ::incoming signal is emitted when a new incoming connection
260 * to @service needs to be handled. The handler must initiate the
261 * handling of @connection, but may not block; in essence,
262 * asynchronous operations must be used.
264 * If %TRUE is returned then no other handlers are called.
266 g_socket_service_incoming_signal =
267 g_signal_new ("incoming", G_TYPE_FROM_CLASS (class), G_SIGNAL_RUN_LAST,
268 G_STRUCT_OFFSET (GSocketServiceClass, incoming),
269 g_signal_accumulator_true_handled, NULL,
270 _gio_marshal_BOOLEAN__OBJECT_OBJECT, G_TYPE_BOOLEAN,
271 2, G_TYPE_SOCKET_CONNECTION, G_TYPE_OBJECT);
275 g_socket_service_ready (GObject *object,
276 GAsyncResult *result,
279 GSocketListener *listener = G_SOCKET_LISTENER (object);
280 GSocketService *service = G_SOCKET_SERVICE (object);
281 GSocketConnection *connection;
282 GObject *source_object;
283 GError *error = NULL;
285 connection = g_socket_listener_accept_finish (listener, result, &source_object, &error);
288 if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
289 g_warning ("fail: %s", error->message);
290 g_error_free (error);
294 g_socket_service_incoming (service, connection, source_object);
295 g_object_unref (connection);
300 g_cancellable_reset (service->priv->cancellable);
303 service->priv->outstanding_accept = FALSE;
304 if (service->priv->active)
312 * g_socket_service_new:
314 * Creates a new #GSocketService with no sockets to listen for.
315 * New listeners can be added with e.g. g_socket_listener_add_address()
316 * or g_socket_listener_add_inet_port().
318 * Returns: a new #GSocketService.
323 g_socket_service_new (void)
325 return g_object_new (G_TYPE_SOCKET_SERVICE, NULL);
328 #define __G_SOCKET_SERVICE_C__
329 #include "gioaliasdef.c"