* Copyright © 2009 Codethink Limited
* Copyright © 2009 Red Hat, Inc
*
- * This program 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 licence or (at
- * your option) any later version.
+ * 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.1 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
* 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.
+ * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
*
* Authors: Ryan Lortie <desrt@desrt.ca>
* Alexander Larsson <alexl@redhat.com>
*/
/**
- * SECTION: gsocketservice
+ * SECTION:gsocketservice
* @title: GSocketService
* @short_description: Make it easy to implement a network service
+ * @include: gio/gio.h
* @see_also: #GThreadedSocketService, #GSocketListener.
*
- * A #GSocketService is an object that represents a service that is
- * provided to the network or over local sockets. When a new
- * connection is made to the service the ::incoming signal is emitted.
+ * A #GSocketService is an object that represents a service that
+ * is provided to the network or over local sockets. When a new
+ * connection is made to the service the #GSocketService::incoming
+ * signal is emitted.
*
* A #GSocketService is a subclass of #GSocketListener and you need
- * to add the addresses you want to accept connections on to the
- * with the #GSocketListener APIs.
+ * to add the addresses you want to accept connections on with the
+ * #GSocketListener APIs.
*
* There are two options for implementing a network service based on
- * #GSocketService. The first is to create the service using
- * g_socket_service_new() and to connect to the ::incoming signal.
- * The second is to subclass #GSocketService and override the default
- * signal handler implementation.
+ * #GSocketService. The first is to create the service using
+ * g_socket_service_new() and to connect to the #GSocketService::incoming
+ * signal. The second is to subclass #GSocketService and override the
+ * default signal handler implementation.
*
* In either case, the handler must immediately return, or else it
- * will block additional incoming connections from being serviced. If
- * you are interested in writing connection handlers that contain
+ * will block additional incoming connections from being serviced.
+ * If you are interested in writing connection handlers that contain
* blocking code then see #GThreadedSocketService.
*
- * The socket service runs on the main loop in the main thread, and is
- * not threadsafe in general. However, the calls to start and stop
- * the service are threadsafe so these can be used from threads that
- * handle incomming clients.
+ * The socket service runs on the main loop of the
+ * [thread-default context][g-main-context-push-thread-default-context]
+ * of the thread it is created in, and is not
+ * threadsafe in general. However, the calls to start and stop the
+ * service are thread-safe so these can be used from threads that
+ * handle incoming clients.
*
* Since: 2.22
*/
#include "config.h"
#include "gsocketservice.h"
-#include "gio-marshal.h"
#include <gio/gio.h>
#include "gsocketlistener.h"
#include "gsocketconnection.h"
+#include "glibintl.h"
+#include "gmarshal-internal.h"
-#include "gioalias.h"
+struct _GSocketServicePrivate
+{
+ GCancellable *cancellable;
+ guint active : 1;
+ guint outstanding_accept : 1;
+};
static guint g_socket_service_incoming_signal;
-G_DEFINE_TYPE (GSocketService, g_socket_service, G_TYPE_SOCKET_LISTENER);
-
G_LOCK_DEFINE_STATIC(active);
-struct _GSocketServicePrivate
+G_DEFINE_TYPE_WITH_PRIVATE (GSocketService, g_socket_service, G_TYPE_SOCKET_LISTENER)
+
+enum
{
- GCancellable *cancellable;
- guint active : 1;
- guint outstanding_accept : 1;
+ PROP_0,
+ PROP_ACTIVE
};
static void g_socket_service_ready (GObject *object,
static void
g_socket_service_init (GSocketService *service)
{
- service->priv = G_TYPE_INSTANCE_GET_PRIVATE (service,
- G_TYPE_SOCKET_SERVICE,
- GSocketServicePrivate);
+ service->priv = g_socket_service_get_instance_private (service);
service->priv->cancellable = g_cancellable_new ();
service->priv->active = TRUE;
}
service->priv->outstanding_accept = TRUE;
}
+static gboolean
+get_active (GSocketService *service)
+{
+ gboolean active;
+
+ G_LOCK (active);
+ active = service->priv->active;
+ G_UNLOCK (active);
+
+ return active;
+}
+
+static void
+set_active (GSocketService *service, gboolean active)
+{
+ gboolean notify = FALSE;
+
+ active = !!active;
+
+ G_LOCK (active);
+
+ if (active != service->priv->active)
+ {
+ service->priv->active = active;
+ notify = TRUE;
+
+ if (active)
+ {
+ if (service->priv->outstanding_accept)
+ g_cancellable_cancel (service->priv->cancellable);
+ else
+ do_accept (service);
+ }
+ else
+ {
+ if (service->priv->outstanding_accept)
+ g_cancellable_cancel (service->priv->cancellable);
+ }
+ }
+
+ G_UNLOCK (active);
+
+ if (notify)
+ g_object_notify (G_OBJECT (service), "active");
+}
+
+static void
+g_socket_service_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GSocketService *service = G_SOCKET_SERVICE (object);
+
+ switch (prop_id)
+ {
+ case PROP_ACTIVE:
+ g_value_set_boolean (value, get_active (service));
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+g_socket_service_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ GSocketService *service = G_SOCKET_SERVICE (object);
+
+ switch (prop_id)
+ {
+ case PROP_ACTIVE:
+ set_active (service, g_value_get_boolean (value));
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
static void
g_socket_service_changed (GSocketListener *listener)
{
if (service->priv->outstanding_accept)
g_cancellable_cancel (service->priv->cancellable);
else
- {
- g_socket_listener_accept_async (listener, service->priv->cancellable,
- g_socket_service_ready, NULL);
- service->priv->outstanding_accept = TRUE;
- }
+ do_accept (service);
}
G_UNLOCK (active);
* Returns: %TRUE if the service is active, %FALSE otherwise
*
* Since: 2.22
- **/
+ */
gboolean
g_socket_service_is_active (GSocketService *service)
{
- gboolean active;
+ g_return_val_if_fail (G_IS_SOCKET_SERVICE (service), FALSE);
- G_LOCK (active);
- active = service->priv->active;
- G_UNLOCK (active);
- return active;
+ return get_active (service);
}
/**
* g_socket_service_start:
* @service: a #GSocketService
*
- * Starts the service, i.e. start accepting connections
- * from the added sockets when the mainloop runs.
+ * Restarts the service, i.e. start accepting connections
+ * from the added sockets when the mainloop runs. This only needs
+ * to be called after the service has been stopped from
+ * g_socket_service_stop().
*
- * This call is threadsafe, so it may be called from a thread
- * handling an incomming client request.
+ * This call is thread-safe, so it may be called from a thread
+ * handling an incoming client request.
*
* Since: 2.22
- **/
+ */
void
g_socket_service_start (GSocketService *service)
{
- G_LOCK (active);
-
- if (!service->priv->active)
- {
- service->priv->active = TRUE;
-
- if (service->priv->outstanding_accept)
- g_cancellable_cancel (service->priv->cancellable);
- else
- do_accept (service);
- }
+ g_return_if_fail (G_IS_SOCKET_SERVICE (service));
- G_UNLOCK (active);
+ set_active (service, TRUE);
}
/**
* Stops the service, i.e. stops accepting connections
* from the added sockets when the mainloop runs.
*
- * This call is threadsafe, so it may be called from a thread
- * handling an incomming client request.
+ * This call is thread-safe, so it may be called from a thread
+ * handling an incoming client request.
+ *
+ * Note that this only stops accepting new connections; it does not
+ * close the listening sockets, and you can call
+ * g_socket_service_start() again later to begin listening again. To
+ * close the listening sockets, call g_socket_listener_close(). (This
+ * will happen automatically when the #GSocketService is finalized.)
+ *
+ * This must be called before calling g_socket_listener_close() as
+ * the socket service will start accepting connections immediately
+ * when a new socket is added.
*
* Since: 2.22
- **/
+ */
void
-g_socket_service_stop (GSocketService *service)
+g_socket_service_stop (GSocketService *service)
{
- G_LOCK (active);
-
- if (service->priv->active)
- {
- service->priv->active = FALSE;
-
- if (service->priv->outstanding_accept)
- g_cancellable_cancel (service->priv->cancellable);
- }
+ g_return_if_fail (G_IS_SOCKET_SERVICE (service));
- G_UNLOCK (active);
+ set_active (service, FALSE);
}
-
static gboolean
g_socket_service_incoming (GSocketService *service,
GSocketConnection *connection,
GObjectClass *gobject_class = G_OBJECT_CLASS (class);
GSocketListenerClass *listener_class = G_SOCKET_LISTENER_CLASS (class);
- g_type_class_add_private (class, sizeof (GSocketServicePrivate));
-
gobject_class->finalize = g_socket_service_finalize;
+ gobject_class->set_property = g_socket_service_set_property;
+ gobject_class->get_property = g_socket_service_get_property;
listener_class->changed = g_socket_service_changed;
class->incoming = g_socket_service_real_incoming;
/**
* GSocketService::incoming:
- * @service: the #GSocketService.
- * @connection: a new #GSocketConnection object.
- * @source_object: the source_object passed to g_socket_listener_add_address().
- * @returns: %TRUE if @connection has been handled.
+ * @service: the #GSocketService
+ * @connection: a new #GSocketConnection object
+ * @source_object: (nullable): the source_object passed to
+ * g_socket_listener_add_address()
*
* The ::incoming signal is emitted when a new incoming connection
- * to @service needs to be handled. The handler must initiate the
+ * to @service needs to be handled. The handler must initiate the
* handling of @connection, but may not block; in essence,
* asynchronous operations must be used.
*
- * If %TRUE is returned then no other handlers are called.
- **/
+ * @connection will be unreffed once the signal handler returns,
+ * so you need to ref it yourself if you are planning to use it.
+ *
+ * Returns: %TRUE to stop other handlers from being called
+ *
+ * Since: 2.22
+ */
g_socket_service_incoming_signal =
- g_signal_new ("incoming", G_TYPE_FROM_CLASS (class), G_SIGNAL_RUN_LAST,
+ g_signal_new (I_("incoming"), G_TYPE_FROM_CLASS (class), G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GSocketServiceClass, incoming),
g_signal_accumulator_true_handled, NULL,
- _gio_marshal_BOOLEAN__OBJECT_OBJECT, G_TYPE_BOOLEAN,
+ _g_cclosure_marshal_BOOLEAN__OBJECT_OBJECT,
+ G_TYPE_BOOLEAN,
2, G_TYPE_SOCKET_CONNECTION, G_TYPE_OBJECT);
+ g_signal_set_va_marshaller (g_socket_service_incoming_signal,
+ G_TYPE_FROM_CLASS (class),
+ _g_cclosure_marshal_BOOLEAN__OBJECT_OBJECTv);
+
+ /**
+ * GSocketService:active:
+ *
+ * Whether the service is currently accepting connections.
+ *
+ * Since: 2.46
+ */
+ g_object_class_install_property (gobject_class, PROP_ACTIVE,
+ g_param_spec_boolean ("active",
+ P_("Active"),
+ P_("Whether the service is currently accepting connections"),
+ TRUE,
+ G_PARAM_CONSTRUCT | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
}
static void
G_UNLOCK (active);
}
-
/**
* g_socket_service_new:
*
* New listeners can be added with e.g. g_socket_listener_add_address()
* or g_socket_listener_add_inet_port().
*
+ * New services are created active, there is no need to call
+ * g_socket_service_start(), unless g_socket_service_stop() has been
+ * called before.
+ *
* Returns: a new #GSocketService.
*
* Since: 2.22
- **/
+ */
GSocketService *
g_socket_service_new (void)
{
return g_object_new (G_TYPE_SOCKET_SERVICE, NULL);
}
-
-#define __G_SOCKET_SERVICE_C__
-#include "gioaliasdef.c"
projects / platform / upstream / glib.git / blobdiff