1 /* -*- mode: C; c-file-style: "gnu" -*- */
2 /* dbus-gmain.c GLib main loop integration
4 * Copyright (C) 2002, 2003 CodeFactory AB
6 * Licensed under the Academic Free License version 1.2
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 #include "dbus-glib.h"
28 * @defgroup DBusGLib GLib bindings
30 * @brief API for using D-BUS with GLib
32 * Convenience functions are provided for using D-BUS
33 * with the GLib library (see http://www.gtk.org for GLib
39 * @defgroup DBusGLibInternals GLib bindings implementation details
40 * @ingroup DBusInternals
41 * @brief Implementation details of GLib bindings
46 /** @typedef DBusGSource
47 * A GSource representing a #DBusConnection or #DBusServer
49 typedef struct DBusGSource DBusGSource;
53 GSource source; /**< the parent GSource */
55 GList *poll_fds; /**< descriptors we're watching */
56 GHashTable *watches; /**< hash of DBusWatch objects */
58 void *connection_or_server; /**< DBusConnection or DBusServer */
61 static GStaticMutex connection_slot_lock = G_STATIC_MUTEX_INIT;
62 static int connection_slot = -1;
63 static GStaticMutex server_slot_lock = G_STATIC_MUTEX_INIT;
64 static int server_slot = -1;
66 static gboolean gsource_connection_prepare (GSource *source,
68 static gboolean gsource_connection_check (GSource *source);
69 static gboolean gsource_connection_dispatch (GSource *source,
72 static gboolean gsource_server_prepare (GSource *source,
74 static gboolean gsource_server_check (GSource *source);
75 static gboolean gsource_server_dispatch (GSource *source,
79 static GSourceFuncs dbus_connection_funcs = {
80 gsource_connection_prepare,
81 gsource_connection_check,
82 gsource_connection_dispatch,
86 static GSourceFuncs dbus_server_funcs = {
87 gsource_server_prepare,
89 gsource_server_dispatch,
94 gsource_connection_prepare (GSource *source,
97 DBusConnection *connection = ((DBusGSource *)source)->connection_or_server;
101 return (dbus_connection_get_dispatch_status (connection) == DBUS_DISPATCH_DATA_REMAINS);
105 gsource_server_prepare (GSource *source,
114 dbus_gsource_check (GSource *source)
116 DBusGSource *dbus_source = (DBusGSource *)source;
119 list = dbus_source->poll_fds;
123 GPollFD *poll_fd = list->data;
125 if (poll_fd->revents != 0)
135 gsource_connection_check (GSource *source)
137 return dbus_gsource_check (source);
141 gsource_server_check (GSource *source)
143 return dbus_gsource_check (source);
147 dbus_gsource_dispatch (GSource *source,
148 GSourceFunc callback,
150 dbus_bool_t is_server)
152 DBusGSource *dbus_source = (DBusGSource *)source;
155 /* We need to traverse a copy of the list, since it can change in
156 dbus_connect_handle_watch. */
157 copy = g_list_copy (dbus_source->poll_fds);
162 GPollFD *poll_fd = list->data;
164 if (poll_fd->revents != 0)
166 DBusWatch *watch = g_hash_table_lookup (dbus_source->watches, poll_fd);
169 if (poll_fd->revents & G_IO_IN)
170 condition |= DBUS_WATCH_READABLE;
171 if (poll_fd->revents & G_IO_OUT)
172 condition |= DBUS_WATCH_WRITABLE;
173 if (poll_fd->revents & G_IO_ERR)
174 condition |= DBUS_WATCH_ERROR;
175 if (poll_fd->revents & G_IO_HUP)
176 condition |= DBUS_WATCH_HANGUP;
179 dbus_server_handle_watch (dbus_source->connection_or_server,
182 dbus_connection_handle_watch (dbus_source->connection_or_server,
195 gsource_connection_dispatch (GSource *source,
196 GSourceFunc callback,
199 DBusGSource *dbus_source = (DBusGSource *)source;
200 DBusConnection *connection = dbus_source->connection_or_server;
202 dbus_connection_ref (connection);
204 dbus_gsource_dispatch (source, callback, user_data,
207 /* Dispatch messages */
208 while (dbus_connection_dispatch (connection) == DBUS_DISPATCH_DATA_REMAINS)
211 dbus_connection_unref (connection);
217 gsource_server_dispatch (GSource *source,
218 GSourceFunc callback,
221 DBusGSource *dbus_source = (DBusGSource *)source;
222 DBusServer *server = dbus_source->connection_or_server;
224 dbus_server_ref (server);
226 dbus_gsource_dispatch (source, callback, user_data,
229 dbus_server_unref (server);
235 add_watch (DBusWatch *watch,
239 DBusGSource *dbus_source;
242 if (!dbus_watch_get_enabled (watch))
247 poll_fd = g_new (GPollFD, 1);
248 poll_fd->fd = dbus_watch_get_fd (watch);
250 flags = dbus_watch_get_flags (watch);
251 dbus_watch_set_data (watch, poll_fd, NULL);
253 if (flags & DBUS_WATCH_READABLE)
254 poll_fd->events |= G_IO_IN;
255 if (flags & DBUS_WATCH_WRITABLE)
256 poll_fd->events |= G_IO_OUT;
257 poll_fd->events |= G_IO_ERR | G_IO_HUP;
259 g_source_add_poll ((GSource *)dbus_source, poll_fd);
261 dbus_source->poll_fds = g_list_prepend (dbus_source->poll_fds, poll_fd);
262 g_hash_table_insert (dbus_source->watches, poll_fd, watch);
268 remove_watch (DBusWatch *watch,
271 DBusGSource *dbus_source = data;
274 poll_fd = dbus_watch_get_data (watch);
276 return; /* probably a not-enabled watch that was added */
278 dbus_source->poll_fds = g_list_remove (dbus_source->poll_fds, poll_fd);
279 g_hash_table_remove (dbus_source->watches, poll_fd);
280 g_source_remove_poll ((GSource *)dbus_source, poll_fd);
286 watch_toggled (DBusWatch *watch,
289 /* Because we just exit on OOM, enable/disable is
290 * no different from add/remove
292 if (dbus_watch_get_enabled (watch))
293 add_watch (watch, data);
295 remove_watch (watch, data);
299 timeout_handler (gpointer data)
301 DBusTimeout *timeout = data;
303 dbus_timeout_handle (timeout);
309 add_timeout (DBusTimeout *timeout,
314 if (!dbus_timeout_get_enabled (timeout))
317 timeout_tag = g_timeout_add (dbus_timeout_get_interval (timeout),
318 timeout_handler, timeout);
320 dbus_timeout_set_data (timeout, GUINT_TO_POINTER (timeout_tag), NULL);
326 remove_timeout (DBusTimeout *timeout,
331 timeout_tag = GPOINTER_TO_UINT (dbus_timeout_get_data (timeout));
333 if (timeout_tag != 0) /* if 0, probably timeout was disabled */
334 g_source_remove (timeout_tag);
338 timeout_toggled (DBusTimeout *timeout,
341 /* Because we just exit on OOM, enable/disable is
342 * no different from add/remove
344 if (dbus_timeout_get_enabled (timeout))
345 add_timeout (timeout, data);
347 remove_timeout (timeout, data);
352 free_source (GSource *source)
354 g_source_destroy (source);
358 wakeup_main (void *data)
360 g_main_context_wakeup (NULL);
364 /** @} */ /* End of GLib bindings internals */
366 /** @addtogroup DBusGLib
371 create_source (void *connection_or_server,
375 DBusGSource *dbus_source;
377 source = g_source_new (funcs, sizeof (DBusGSource));
379 dbus_source = (DBusGSource *)source;
380 dbus_source->watches = g_hash_table_new (NULL, NULL);
381 dbus_source->connection_or_server = connection_or_server;
387 * Sets the watch and timeout functions of a #DBusConnection
388 * to integrate the connection with the GLib main loop.
390 * @param connection the connection
393 dbus_connection_setup_with_g_main (DBusConnection *connection)
397 source = create_source (connection, &dbus_connection_funcs);
399 if (!dbus_connection_set_watch_functions (connection,
406 if (!dbus_connection_set_timeout_functions (connection,
413 dbus_connection_set_wakeup_main_function (connection,
417 g_source_attach (source, NULL);
419 g_static_mutex_lock (&connection_slot_lock);
420 if (connection_slot == -1 )
421 connection_slot = dbus_connection_allocate_data_slot ();
422 g_static_mutex_unlock (&connection_slot_lock);
424 if (connection_slot < 0)
427 if (!dbus_connection_set_data (connection, connection_slot, source,
428 (DBusFreeFunction)free_source))
434 g_error ("Not enough memory to set up DBusConnection for use with GLib");
438 * Sets the watch and timeout functions of a #DBusServer
439 * to integrate the server with the GLib main loop.
441 * @param server the server
444 dbus_server_setup_with_g_main (DBusServer *server)
448 source = create_source (server, &dbus_server_funcs);
450 dbus_server_set_watch_functions (server,
456 dbus_server_set_timeout_functions (server,
462 g_source_attach (source, NULL);
464 g_static_mutex_lock (&server_slot_lock);
465 if (server_slot == -1 )
466 server_slot = dbus_server_allocate_data_slot ();
467 g_static_mutex_unlock (&server_slot_lock);
472 if (!dbus_server_set_data (server, server_slot, source,
473 (DBusFreeFunction)free_source))
479 g_error ("Not enough memory to set up DBusServer for use with GLib");
482 /** @} */ /* end of public API */