Home | History | Annotate | Download | only in dbus
      1 /*
      2  * wpa_supplicant D-Bus control interface - common functionality
      3  * Copyright (c) 2006, Dan Williams <dcbw (at) redhat.com> and Red Hat, Inc.
      4  * Copyright (c) 2009, Witold Sowa <witold.sowa (at) gmail.com>
      5  * Copyright (c) 2009, Jouni Malinen <j (at) 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 }
    391