gdbus/mainloop.c

   1 /*
   2  *
   3  *  D-Bus helper library
   4  *
   5  *  Copyright (C) 2004-2011  Marcel Holtmann <marcel@holtmann.org>
   6  *
   7  *
   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.
  12  *
  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.
  17  *
  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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  21  *
  22  */
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include <config.h>
  26 #endif
  27
  28 #include <glib.h>
  29 #include <dbus/dbus.h>
  30
  31 #include "gdbus.h"
  32
  33 #define DISPATCH_TIMEOUT  0
  34
  35 #define info(fmt...)
  36 #define error(fmt...)
  37 #define debug(fmt...)
  38
  39 struct timeout_handler {
  40         guint id;
  41         DBusTimeout *timeout;
  42 };
  43
  44 struct watch_info {
  45         guint id;
  46         DBusWatch *watch;
  47         DBusConnection *conn;
  48 };
  49
  50 struct disconnect_data {
  51         GDBusWatchFunction function;
  52         void *user_data;
  53 };
  54
  55 static gboolean disconnected_signal(DBusConnection *conn,
  56                                                 DBusMessage *msg, void *data)
  57 {
  58         struct disconnect_data *dc_data = data;
  59
  60         error("Got disconnected from the system message bus");
  61
  62         dc_data->function(conn, dc_data->user_data);
  63
  64         dbus_connection_unref(conn);
  65
  66         return TRUE;
  67 }
  68
  69 static gboolean message_dispatch(void *data)
  70 {
  71         DBusConnection *conn = data;
  72
  73         dbus_connection_ref(conn);
  74
  75         /* Dispatch messages */
  76         while (dbus_connection_dispatch(conn) == DBUS_DISPATCH_DATA_REMAINS);
  77
  78         dbus_connection_unref(conn);
  79
  80         return FALSE;
  81 }
  82
  83 static inline void queue_dispatch(DBusConnection *conn,
  84                                                 DBusDispatchStatus status)
  85 {
  86         if (status == DBUS_DISPATCH_DATA_REMAINS)
  87                 g_timeout_add(DISPATCH_TIMEOUT, message_dispatch, conn);
  88 }
  89
  90 static gboolean watch_func(GIOChannel *chan, GIOCondition cond, gpointer data)
  91 {
  92         struct watch_info *info = data;
  93         unsigned int flags = 0;
  94         DBusDispatchStatus status;
  95
  96         dbus_connection_ref(info->conn);
  97
  98         if (cond & G_IO_IN)  flags |= DBUS_WATCH_READABLE;
  99         if (cond & G_IO_OUT) flags |= DBUS_WATCH_WRITABLE;
 100         if (cond & G_IO_HUP) flags |= DBUS_WATCH_HANGUP;
 101         if (cond & G_IO_ERR) flags |= DBUS_WATCH_ERROR;
 102
 103         dbus_watch_handle(info->watch, flags);
 104
 105         status = dbus_connection_get_dispatch_status(info->conn);
 106         queue_dispatch(info->conn, status);
 107
 108         dbus_connection_unref(info->conn);
 109
 110         return TRUE;
 111 }
 112
 113 static void watch_info_free(void *data)
 114 {
 115         struct watch_info *info = data;
 116
 117         if (info->id > 0) {
 118                 g_source_remove(info->id);
 119                 info->id = 0;
 120         }
 121
 122         dbus_connection_unref(info->conn);
 123
 124         g_free(info);
 125 }
 126
 127 static dbus_bool_t add_watch(DBusWatch *watch, void *data)
 128 {
 129         DBusConnection *conn = data;
 130         GIOCondition cond = G_IO_HUP | G_IO_ERR;
 131         GIOChannel *chan;
 132         struct watch_info *info;
 133         unsigned int flags;
 134         int fd;
 135
 136         if (!dbus_watch_get_enabled(watch))
 137                 return TRUE;
 138
 139         info = g_new0(struct watch_info, 1);
 140
 141         fd = dbus_watch_get_unix_fd(watch);
 142         chan = g_io_channel_unix_new(fd);
 143
 144         info->watch = watch;
 145         info->conn = dbus_connection_ref(conn);
 146
 147         dbus_watch_set_data(watch, info, watch_info_free);
 148
 149         flags = dbus_watch_get_flags(watch);
 150
 151         if (flags & DBUS_WATCH_READABLE) cond |= G_IO_IN;
 152         if (flags & DBUS_WATCH_WRITABLE) cond |= G_IO_OUT;
 153
 154         info->id = g_io_add_watch(chan, cond, watch_func, info);
 155
 156         g_io_channel_unref(chan);
 157
 158         return TRUE;
 159 }
 160
 161 static void remove_watch(DBusWatch *watch, void *data)
 162 {
 163         if (dbus_watch_get_enabled(watch))
 164                 return;
 165
 166         /* will trigger watch_info_free() */
 167         dbus_watch_set_data(watch, NULL, NULL);
 168 }
 169
 170 static void watch_toggled(DBusWatch *watch, void *data)
 171 {
 172         /* Because we just exit on OOM, enable/disable is
 173          * no different from add/remove */
 174         if (dbus_watch_get_enabled(watch))
 175                 add_watch(watch, data);
 176         else
 177                 remove_watch(watch, data);
 178 }
 179
 180 static gboolean timeout_handler_dispatch(gpointer data)
 181 {
 182         struct timeout_handler *handler = data;
 183
 184         handler->id = 0;
 185
 186         /* if not enabled should not be polled by the main loop */
 187         if (!dbus_timeout_get_enabled(handler->timeout))
 188                 return FALSE;
 189
 190         dbus_timeout_handle(handler->timeout);
 191
 192         return FALSE;
 193 }
 194
 195 static void timeout_handler_free(void *data)
 196 {
 197         struct timeout_handler *handler = data;
 198
 199         if (handler->id > 0) {
 200                 g_source_remove(handler->id);
 201                 handler->id = 0;
 202         }
 203
 204         g_free(handler);
 205 }
 206
 207 static dbus_bool_t add_timeout(DBusTimeout *timeout, void *data)
 208 {
 209         int interval = dbus_timeout_get_interval(timeout);
 210         struct timeout_handler *handler;
 211
 212         if (!dbus_timeout_get_enabled(timeout))
 213                 return TRUE;
 214
 215         handler = g_new0(struct timeout_handler, 1);
 216
 217         handler->timeout = timeout;
 218
 219         dbus_timeout_set_data(timeout, handler, timeout_handler_free);
 220
 221         handler->id = g_timeout_add(interval, timeout_handler_dispatch,
 222                                                                 handler);
 223
 224         return TRUE;
 225 }
 226
 227 static void remove_timeout(DBusTimeout *timeout, void *data)
 228 {
 229         /* will trigger timeout_handler_free() */
 230         dbus_timeout_set_data(timeout, NULL, NULL);
 231 }
 232
 233 static void timeout_toggled(DBusTimeout *timeout, void *data)
 234 {
 235         if (dbus_timeout_get_enabled(timeout))
 236                 add_timeout(timeout, data);
 237         else
 238                 remove_timeout(timeout, data);
 239 }
 240
 241 static void dispatch_status(DBusConnection *conn,
 242                                         DBusDispatchStatus status, void *data)
 243 {
 244         if (!dbus_connection_get_is_connected(conn))
 245                 return;
 246
 247         queue_dispatch(conn, status);
 248 }
 249
 250 static inline void setup_dbus_with_main_loop(DBusConnection *conn)
 251 {
 252         dbus_connection_set_watch_functions(conn, add_watch, remove_watch,
 253                                                 watch_toggled, conn, NULL);
 254
 255         dbus_connection_set_timeout_functions(conn, add_timeout, remove_timeout,
 256                                                 timeout_toggled, NULL, NULL);
 257
 258         dbus_connection_set_dispatch_status_function(conn, dispatch_status,
 259                                                                 NULL, NULL);
 260 }
 261
 262 static gboolean setup_bus(DBusConnection *conn, const char *name,
 263                                                 DBusError *error)
 264 {
 265         gboolean result;
 266         DBusDispatchStatus status;
 267
 268         if (name != NULL) {
 269                 result = g_dbus_request_name(conn, name, error);
 270
 271                 if (error != NULL) {
 272                         if (dbus_error_is_set(error) == TRUE)
 273                                 return FALSE;
 274                 }
 275
 276                 if (result == FALSE)
 277                         return FALSE;
 278         }
 279
 280         setup_dbus_with_main_loop(conn);
 281
 282         status = dbus_connection_get_dispatch_status(conn);
 283         queue_dispatch(conn, status);
 284
 285         return TRUE;
 286 }
 287
 288 DBusConnection *g_dbus_setup_bus(DBusBusType type, const char *name,
 289                                                         DBusError *error)
 290 {
 291         DBusConnection *conn;
 292
 293         conn = dbus_bus_get(type, error);
 294
 295         if (error != NULL) {
 296                 if (dbus_error_is_set(error) == TRUE)
 297                         return NULL;
 298         }
 299
 300         if (conn == NULL)
 301                 return NULL;
 302
 303         if (setup_bus(conn, name, error) == FALSE) {
 304                 dbus_connection_unref(conn);
 305                 return NULL;
 306         }
 307
 308         return conn;
 309 }
 310
 311 DBusConnection *g_dbus_setup_private(DBusBusType type, const char *name,
 312                                                         DBusError *error)
 313 {
 314         DBusConnection *conn;
 315
 316         conn = dbus_bus_get_private(type, error);
 317
 318         if (error != NULL) {
 319                 if (dbus_error_is_set(error) == TRUE)
 320                         return NULL;
 321         }
 322
 323         if (conn == NULL)
 324                 return NULL;
 325
 326         if (setup_bus(conn, name, error) == FALSE) {
 327                 dbus_connection_unref(conn);
 328                 return NULL;
 329         }
 330
 331         return conn;
 332 }
 333
 334 gboolean g_dbus_request_name(DBusConnection *connection, const char *name,
 335                                                         DBusError *error)
 336 {
 337         int result;
 338
 339         result = dbus_bus_request_name(connection, name,
 340                                         DBUS_NAME_FLAG_DO_NOT_QUEUE, error);
 341
 342         if (error != NULL) {
 343                 if (dbus_error_is_set(error) == TRUE)
 344                         return FALSE;
 345         }
 346
 347         if (result != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
 348                 if (error != NULL)
 349                         dbus_set_error(error, name, "Name already in use");
 350
 351                 return FALSE;
 352         }
 353
 354         return TRUE;
 355 }
 356
 357 gboolean g_dbus_set_disconnect_function(DBusConnection *connection,
 358                                 GDBusWatchFunction function,
 359                                 void *user_data, DBusFreeFunction destroy)
 360 {
 361         struct disconnect_data *dc_data;
 362
 363         dc_data = g_new0(struct disconnect_data, 1);
 364
 365         dc_data->function = function;
 366         dc_data->user_data = user_data;
 367
 368         dbus_connection_set_exit_on_disconnect(connection, FALSE);
 369
 370         if (g_dbus_add_signal_watch(connection, NULL, NULL,
 371                                 DBUS_INTERFACE_LOCAL, "Disconnected",
 372                                 disconnected_signal, dc_data, g_free) == 0) {
 373                 error("Failed to add watch for D-Bus Disconnected signal");
 374                 g_free(dc_data);
 375                 return FALSE;
 376         }
 377
 378         return TRUE;
 379 }