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         if (!dbus_timeout_get_enabled(timeout))
 169                 return TRUE;
 170
 171         eloop_register_timeout(0, dbus_timeout_get_interval(timeout) * 1000,
 172                                process_timeout, priv, timeout);
 173
 174         dbus_timeout_set_data(timeout, priv, NULL);
 175
 176         return TRUE;
 177 }
 178
 179
 180 static void remove_timeout(DBusTimeout *timeout, void *data)
 181 {
 182         struct wpas_dbus_priv *priv = data;
 183         eloop_cancel_timeout(process_timeout, priv, timeout);
 184         dbus_timeout_set_data(timeout, NULL, NULL);
 185 }
 186
 187
 188 static void timeout_toggled(DBusTimeout *timeout, void *data)
 189 {
 190         if (dbus_timeout_get_enabled(timeout))
 191                 add_timeout(timeout, data);
 192         else
 193                 remove_timeout(timeout, data);
 194 }
 195
 196
 197 static void process_wakeup_main(int sig, void *signal_ctx)
 198 {
 199         struct wpas_dbus_priv *priv = signal_ctx;
 200
 201         if (sig != SIGPOLL || !priv->con)
 202                 return;
 203
 204         if (dbus_connection_get_dispatch_status(priv->con) !=
 205             DBUS_DISPATCH_DATA_REMAINS)
 206                 return;
 207
 208         /* Only dispatch once - we do not want to starve other events */
 209         dbus_connection_ref(priv->con);
 210         dbus_connection_dispatch(priv->con);
 211         dbus_connection_unref(priv->con);
 212 }
 213
 214
 215 /**
 216  * wakeup_main - Attempt to wake our mainloop up
 217  * @data: dbus control interface private data
 218  *
 219  * Try to wake up the main eloop so it will process
 220  * dbus events that may have happened.
 221  */
 222 static void wakeup_main(void *data)
 223 {
 224         struct wpas_dbus_priv *priv = data;
 225
 226         /* Use SIGPOLL to break out of the eloop select() */
 227         raise(SIGPOLL);
 228         priv->should_dispatch = 1;
 229 }
 230
 231
 232 /**
 233  * integrate_with_eloop - Register our mainloop integration with dbus
 234  * @connection: connection to the system message bus
 235  * @priv: a dbus control interface data structure
 236  * Returns: 0 on success, -1 on failure
 237  */
 238 static int integrate_with_eloop(struct wpas_dbus_priv *priv)
 239 {
 240         if (!dbus_connection_set_watch_functions(priv->con, add_watch,
 241                                                  remove_watch, watch_toggled,
 242                                                  priv, NULL) ||
 243             !dbus_connection_set_timeout_functions(priv->con, add_timeout,
 244                                                    remove_timeout,
 245                                                    timeout_toggled, priv,
 246                                                    NULL)) {
 247                 wpa_printf(MSG_ERROR, "dbus: Failed to set callback "
 248                            "functions");
 249                 return -1;
 250         }
 251
 252         if (eloop_register_signal(SIGPOLL, process_wakeup_main, priv))
 253                 return -1;
 254         dbus_connection_set_wakeup_main_function(priv->con, wakeup_main,
 255                                                  priv, NULL);
 256
 257         return 0;
 258 }
 259
 260
 261 static DBusHandlerResult disconnect_filter(DBusConnection *conn,
 262                                            DBusMessage *message, void *data)
 263 {
 264         struct wpas_dbus_priv *priv = data;
 265
 266         if (dbus_message_is_signal(message, DBUS_INTERFACE_LOCAL,
 267                                    "Disconnected")) {
 268                 wpa_printf(MSG_DEBUG, "dbus: bus disconnected, terminating");
 269                 dbus_connection_set_exit_on_disconnect(conn, FALSE);
 270                 wpa_supplicant_terminate_proc(priv->global);
 271                 return DBUS_HANDLER_RESULT_HANDLED;
 272         } else
 273                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 274 }
 275
 276
 277 static int wpas_dbus_init_common(struct wpas_dbus_priv *priv)
 278 {
 279         DBusError error;
 280         int ret = 0;
 281
 282         /* Get a reference to the system bus */
 283         dbus_error_init(&error);
 284         priv->con = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
 285         if (priv->con) {
 286                 dbus_connection_add_filter(priv->con, disconnect_filter, priv,
 287                                            NULL);
 288         } else {
 289                 wpa_printf(MSG_ERROR, "dbus: Could not acquire the system "
 290                            "bus: %s - %s", error.name, error.message);
 291                 ret = -1;
 292         }
 293         dbus_error_free(&error);
 294
 295         return ret;
 296 }
 297
 298
 299 static int wpas_dbus_init_common_finish(struct wpas_dbus_priv *priv)
 300 {
 301         /* Tell dbus about our mainloop integration functions */
 302         integrate_with_eloop(priv);
 303
 304         /*
 305          * Dispatch initial DBus messages that may have come in since the bus
 306          * name was claimed above. Happens when clients are quick to notice the
 307          * service.
 308          *
 309          * FIXME: is there a better solution to this problem?
 310          */
 311         eloop_register_timeout(0, 50, dispatch_initial_dbus_messages,
 312                                priv->con, NULL);
 313
 314         return 0;
 315 }
 316
 317
 318 static void wpas_dbus_deinit_common(struct wpas_dbus_priv *priv)
 319 {
 320         if (priv->con) {
 321                 eloop_cancel_timeout(dispatch_initial_dbus_messages,
 322                                      priv->con, NULL);
 323                 eloop_cancel_timeout(process_timeout, priv, ELOOP_ALL_CTX);
 324
 325                 dbus_connection_set_watch_functions(priv->con, NULL, NULL,
 326                                                     NULL, NULL, NULL);
 327                 dbus_connection_set_timeout_functions(priv->con, NULL, NULL,
 328                                                       NULL, NULL, NULL);
 329                 dbus_connection_remove_filter(priv->con, disconnect_filter,
 330                                               priv);
 331
 332                 dbus_connection_unref(priv->con);
 333         }
 334
 335         os_free(priv);
 336 }
 337
 338
 339 struct wpas_dbus_priv * wpas_dbus_init(struct wpa_global *global)
 340 {
 341         struct wpas_dbus_priv *priv;
 342
 343         priv = os_zalloc(sizeof(*priv));
 344         if (priv == NULL)
 345                 return NULL;
 346         priv->global = global;
 347
 348         if (wpas_dbus_init_common(priv) < 0) {
 349                 wpas_dbus_deinit(priv);
 350                 return NULL;
 351         }
 352
 353 #ifdef CONFIG_CTRL_IFACE_DBUS_NEW
 354         if (wpas_dbus_ctrl_iface_init(priv) < 0) {
 355                 wpas_dbus_deinit(priv);
 356                 return NULL;
 357         }
 358 #endif /* CONFIG_CTRL_IFACE_DBUS_NEW */
 359
 360 #ifdef CONFIG_CTRL_IFACE_DBUS
 361         if (wpa_supplicant_dbus_ctrl_iface_init(priv) < 0) {
 362                 wpas_dbus_deinit(priv);
 363                 return NULL;
 364         }
 365 #endif /* CONFIG_CTRL_IFACE_DBUS */
 366
 367         if (wpas_dbus_init_common_finish(priv) < 0) {
 368                 wpas_dbus_deinit(priv);
 369                 return NULL;
 370         }
 371
 372         return priv;
 373 }
 374
 375
 376 void wpas_dbus_deinit(struct wpas_dbus_priv *priv)
 377 {
 378         if (priv == NULL)
 379                 return;
 380
 381 #ifdef CONFIG_CTRL_IFACE_DBUS_NEW
 382         wpas_dbus_ctrl_iface_deinit(priv);
 383 #endif /* CONFIG_CTRL_IFACE_DBUS_NEW */
 384
 385 #ifdef CONFIG_CTRL_IFACE_DBUS
 386         /* TODO: is any deinit needed? */
 387 #endif /* CONFIG_CTRL_IFACE_DBUS */
 388
 389         wpas_dbus_deinit_common(priv);
 390 }