libeap/wpa_supplicant/dbus/dbus_common.c

   1 /*
   2  * wpa_supplicant D-Bus control interface - common functionality
   3  * Copyright (c) 2006, Dan Williams <dcbw@redhat.com> and Red Hat, Inc.
   4  * Copyright (c) 2009, Witold Sowa <witold.sowa@gmail.com>
   5  * Copyright (c) 2009, Jouni Malinen <j@w1.fi>
   6  *
   7  * This software may be distributed under the terms of the BSD license.
   8  * See README for more details.
   9  */
  10
  11 #include "utils/includes.h"
  12 #include <dbus/dbus.h>
  13
  14 #include "utils/common.h"
  15 #include "utils/eloop.h"
  16 #include "dbus_common.h"
  17 #include "dbus_common_i.h"
  18 #include "dbus_new.h"
  19 #include "dbus_old.h"
  20 #include "../wpa_supplicant_i.h"
  21
  22
  23 #ifndef SIGPOLL
  24 #ifdef SIGIO
  25 /*
  26  * If we do not have SIGPOLL, try to use SIGIO instead. This is needed for
  27  * FreeBSD.
  28  */
  29 #define SIGPOLL SIGIO
  30 #endif
  31 #endif
  32
  33
  34 static void dispatch_data(DBusConnection *con)
  35 {
  36         while (dbus_connection_get_dispatch_status(con) ==
  37                DBUS_DISPATCH_DATA_REMAINS)
  38                 dbus_connection_dispatch(con);
  39 }
  40
  41
  42 /**
  43  * dispatch_initial_dbus_messages - Dispatch initial dbus messages after
  44  *     claiming bus name
  45  * @eloop_ctx: the DBusConnection to dispatch on
  46  * @timeout_ctx: unused
  47  *
  48  * If clients are quick to notice that service claimed its bus name,
  49  * there may have been messages that came in before initialization was
  50  * all finished.  Dispatch those here.
  51  */
  52 static void dispatch_initial_dbus_messages(void *eloop_ctx, void *timeout_ctx)
  53 {
  54         DBusConnection *con = eloop_ctx;
  55         dispatch_data(con);
  56 }
  57
  58
  59 static void process_watch(struct wpas_dbus_priv *priv,
  60                           DBusWatch *watch, eloop_event_type type)
  61 {
  62         dbus_connection_ref(priv->con);
  63
  64         priv->should_dispatch = 0;
  65
  66         if (type == EVENT_TYPE_READ)
  67                 dbus_watch_handle(watch, DBUS_WATCH_READABLE);
  68         else if (type == EVENT_TYPE_WRITE)
  69                 dbus_watch_handle(watch, DBUS_WATCH_WRITABLE);
  70         else if (type == EVENT_TYPE_EXCEPTION)
  71                 dbus_watch_handle(watch, DBUS_WATCH_ERROR);
  72
  73         if (priv->should_dispatch) {
  74                 dispatch_data(priv->con);
  75                 priv->should_dispatch = 0;
  76         }
  77
  78         dbus_connection_unref(priv->con);
  79 }
  80
  81
  82 static void process_watch_exception(int sock, void *eloop_ctx, void *sock_ctx)
  83 {
  84         process_watch(eloop_ctx, sock_ctx, EVENT_TYPE_EXCEPTION);
  85 }
  86
  87
  88 static void process_watch_read(int sock, void *eloop_ctx, void *sock_ctx)
  89 {
  90         process_watch(eloop_ctx, sock_ctx, EVENT_TYPE_READ);
  91 }
  92
  93
  94 static void process_watch_write(int sock, void *eloop_ctx, void *sock_ctx)
  95 {
  96         process_watch(eloop_ctx, sock_ctx, EVENT_TYPE_WRITE);
  97 }
  98
  99
 100 static dbus_bool_t add_watch(DBusWatch *watch, void *data)
 101 {
 102         struct wpas_dbus_priv *priv = data;
 103         unsigned int flags;
 104         int fd;
 105
 106         if (!dbus_watch_get_enabled(watch))
 107                 return TRUE;
 108
 109         flags = dbus_watch_get_flags(watch);
 110         fd = dbus_watch_get_unix_fd(watch);
 111
 112         eloop_register_sock(fd, EVENT_TYPE_EXCEPTION, process_watch_exception,
 113                             priv, watch);
 114
 115         if (flags & DBUS_WATCH_READABLE) {
 116                 eloop_register_sock(fd, EVENT_TYPE_READ, process_watch_read,
 117                                     priv, watch);
 118         }
 119         if (flags & DBUS_WATCH_WRITABLE) {
 120                 eloop_register_sock(fd, EVENT_TYPE_WRITE, process_watch_write,
 121                                     priv, watch);
 122         }
 123
 124         dbus_watch_set_data(watch, priv, NULL);
 125
 126         return TRUE;
 127 }
 128
 129
 130 static void remove_watch(DBusWatch *watch, void *data)
 131 {
 132         unsigned int flags;
 133         int fd;
 134
 135         flags = dbus_watch_get_flags(watch);
 136         fd = dbus_watch_get_unix_fd(watch);
 137
 138         eloop_unregister_sock(fd, EVENT_TYPE_EXCEPTION);
 139
 140         if (flags & DBUS_WATCH_READABLE)
 141                 eloop_unregister_sock(fd, EVENT_TYPE_READ);
 142         if (flags & DBUS_WATCH_WRITABLE)
 143                 eloop_unregister_sock(fd, EVENT_TYPE_WRITE);
 144
 145         dbus_watch_set_data(watch, NULL, NULL);
 146 }
 147
 148
 149 static void watch_toggled(DBusWatch *watch, void *data)
 150 {
 151         if (dbus_watch_get_enabled(watch))
 152                 add_watch(watch, data);
 153         else
 154                 remove_watch(watch, data);
 155 }
 156
 157
 158 static void process_timeout(void *eloop_ctx, void *sock_ctx)
 159 {
 160         DBusTimeout *timeout = sock_ctx;
 161         dbus_timeout_handle(timeout);
 162 }
 163
 164
 165 static dbus_bool_t add_timeout(DBusTimeout *timeout, void *data)
 166 {
 167         struct wpas_dbus_priv *priv = data;
 168
 169         if (!dbus_timeout_get_enabled(timeout))
 170                 return TRUE;
 171
 172         eloop_register_timeout(0, dbus_timeout_get_interval(timeout) * 1000,
 173                                process_timeout, priv, timeout);
 174
 175         dbus_timeout_set_data(timeout, priv, NULL);
 176
 177         return TRUE;
 178 }
 179
 180
 181 static void remove_timeout(DBusTimeout *timeout, void *data)
 182 {
 183         struct wpas_dbus_priv *priv = data;
 184
 185         eloop_cancel_timeout(process_timeout, priv, timeout);
 186         dbus_timeout_set_data(timeout, NULL, NULL);
 187 }
 188
 189
 190 static void timeout_toggled(DBusTimeout *timeout, void *data)
 191 {
 192         if (dbus_timeout_get_enabled(timeout))
 193                 add_timeout(timeout, data);
 194         else
 195                 remove_timeout(timeout, data);
 196 }
 197
 198
 199 static void process_wakeup_main(int sig, void *signal_ctx)
 200 {
 201         struct wpas_dbus_priv *priv = signal_ctx;
 202
 203         if (sig != SIGPOLL || !priv->con)
 204                 return;
 205
 206         if (dbus_connection_get_dispatch_status(priv->con) !=
 207             DBUS_DISPATCH_DATA_REMAINS)
 208                 return;
 209
 210         /* Only dispatch once - we do not want to starve other events */
 211         dbus_connection_ref(priv->con);
 212         dbus_connection_dispatch(priv->con);
 213         dbus_connection_unref(priv->con);
 214 }
 215
 216
 217 /**
 218  * wakeup_main - Attempt to wake our mainloop up
 219  * @data: dbus control interface private data
 220  *
 221  * Try to wake up the main eloop so it will process
 222  * dbus events that may have happened.
 223  */
 224 static void wakeup_main(void *data)
 225 {
 226         struct wpas_dbus_priv *priv = data;
 227
 228         /* Use SIGPOLL to break out of the eloop select() */
 229         raise(SIGPOLL);
 230         priv->should_dispatch = 1;
 231 }
 232
 233
 234 /**
 235  * integrate_with_eloop - Register our mainloop integration with dbus
 236  * @connection: connection to the system message bus
 237  * @priv: a dbus control interface data structure
 238  * Returns: 0 on success, -1 on failure
 239  */
 240 static int integrate_with_eloop(struct wpas_dbus_priv *priv)
 241 {
 242         if (!dbus_connection_set_watch_functions(priv->con, add_watch,
 243                                                  remove_watch, watch_toggled,
 244                                                  priv, NULL) ||
 245             !dbus_connection_set_timeout_functions(priv->con, add_timeout,
 246                                                    remove_timeout,
 247                                                    timeout_toggled, priv,
 248                                                    NULL)) {
 249                 wpa_printf(MSG_ERROR, "dbus: Failed to set callback functions");
 250                 return -1;
 251         }
 252
 253         if (eloop_register_signal(SIGPOLL, process_wakeup_main, priv))
 254                 return -1;
 255         dbus_connection_set_wakeup_main_function(priv->con, wakeup_main,
 256                                                  priv, NULL);
 257
 258         return 0;
 259 }
 260
 261
 262 static DBusHandlerResult disconnect_filter(DBusConnection *conn,
 263                                            DBusMessage *message, void *data)
 264 {
 265         struct wpas_dbus_priv *priv = data;
 266
 267         if (dbus_message_is_signal(message, DBUS_INTERFACE_LOCAL,
 268                                    "Disconnected")) {
 269                 wpa_printf(MSG_DEBUG, "dbus: bus disconnected, terminating");
 270                 dbus_connection_set_exit_on_disconnect(conn, FALSE);
 271                 wpa_supplicant_terminate_proc(priv->global);
 272                 return DBUS_HANDLER_RESULT_HANDLED;
 273         } else
 274                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 275 }
 276
 277
 278 static int wpas_dbus_init_common(struct wpas_dbus_priv *priv)
 279 {
 280         DBusError error;
 281         int ret = 0;
 282
 283         /* Get a reference to the system bus */
 284         dbus_error_init(&error);
 285         priv->con = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
 286         if (priv->con) {
 287                 dbus_connection_add_filter(priv->con, disconnect_filter, priv,
 288                                            NULL);
 289         } else {
 290                 wpa_printf(MSG_ERROR,
 291                            "dbus: Could not acquire the system bus: %s - %s",
 292                            error.name, error.message);
 293                 ret = -1;
 294         }
 295         dbus_error_free(&error);
 296
 297         return ret;
 298 }
 299
 300
 301 static int wpas_dbus_init_common_finish(struct wpas_dbus_priv *priv)
 302 {
 303         /* Tell dbus about our mainloop integration functions */
 304         integrate_with_eloop(priv);
 305
 306         /*
 307          * Dispatch initial DBus messages that may have come in since the bus
 308          * name was claimed above. Happens when clients are quick to notice the
 309          * service.
 310          *
 311          * FIXME: is there a better solution to this problem?
 312          */
 313         eloop_register_timeout(0, 50, dispatch_initial_dbus_messages,
 314                                priv->con, NULL);
 315
 316         return 0;
 317 }
 318
 319
 320 static void wpas_dbus_deinit_common(struct wpas_dbus_priv *priv)
 321 {
 322         if (priv->con) {
 323                 eloop_cancel_timeout(dispatch_initial_dbus_messages,
 324                                      priv->con, NULL);
 325                 eloop_cancel_timeout(process_timeout, priv, ELOOP_ALL_CTX);
 326
 327                 dbus_connection_set_watch_functions(priv->con, NULL, NULL,
 328                                                     NULL, NULL, NULL);
 329                 dbus_connection_set_timeout_functions(priv->con, NULL, NULL,
 330                                                       NULL, NULL, NULL);
 331                 dbus_connection_remove_filter(priv->con, disconnect_filter,
 332                                               priv);
 333
 334                 dbus_connection_unref(priv->con);
 335         }
 336
 337         os_free(priv);
 338 }
 339
 340
 341 struct wpas_dbus_priv * wpas_dbus_init(struct wpa_global *global)
 342 {
 343         struct wpas_dbus_priv *priv;
 344
 345         priv = os_zalloc(sizeof(*priv));
 346         if (priv == NULL)
 347                 return NULL;
 348         priv->global = global;
 349
 350         if (wpas_dbus_init_common(priv) < 0 ||
 351 #ifdef CONFIG_CTRL_IFACE_DBUS_NEW
 352             wpas_dbus_ctrl_iface_init(priv) < 0 ||
 353 #endif /* CONFIG_CTRL_IFACE_DBUS_NEW */
 354 #ifdef CONFIG_CTRL_IFACE_DBUS
 355             wpa_supplicant_dbus_ctrl_iface_init(priv) < 0 ||
 356 #endif /* CONFIG_CTRL_IFACE_DBUS */
 357             wpas_dbus_init_common_finish(priv) < 0) {
 358                 wpas_dbus_deinit(priv);
 359                 return NULL;
 360         }
 361
 362         return priv;
 363 }
 364
 365
 366 void wpas_dbus_deinit(struct wpas_dbus_priv *priv)
 367 {
 368         if (priv == NULL)
 369                 return;
 370
 371 #ifdef CONFIG_CTRL_IFACE_DBUS_NEW
 372         wpas_dbus_ctrl_iface_deinit(priv);
 373 #endif /* CONFIG_CTRL_IFACE_DBUS_NEW */
 374
 375 #ifdef CONFIG_CTRL_IFACE_DBUS
 376         /* TODO: is any deinit needed? */
 377 #endif /* CONFIG_CTRL_IFACE_DBUS */
 378
 379         wpas_dbus_deinit_common(priv);
 380 }