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 "../wpa_supplicant_i.h" 20 21 22 #ifndef SIGPOLL 23 #ifdef SIGIO 24 /* 25 * If we do not have SIGPOLL, try to use SIGIO instead. This is needed for 26 * FreeBSD. 27 */ 28 #define SIGPOLL SIGIO 29 #endif 30 #endif 31 32 33 static void dispatch_data(DBusConnection *con) 34 { 35 while (dbus_connection_get_dispatch_status(con) == 36 DBUS_DISPATCH_DATA_REMAINS) 37 dbus_connection_dispatch(con); 38 } 39 40 41 /** 42 * dispatch_initial_dbus_messages - Dispatch initial dbus messages after 43 * claiming bus name 44 * @eloop_ctx: the DBusConnection to dispatch on 45 * @timeout_ctx: unused 46 * 47 * If clients are quick to notice that service claimed its bus name, 48 * there may have been messages that came in before initialization was 49 * all finished. Dispatch those here. 50 */ 51 static void dispatch_initial_dbus_messages(void *eloop_ctx, void *timeout_ctx) 52 { 53 DBusConnection *con = eloop_ctx; 54 dispatch_data(con); 55 } 56 57 58 static void process_watch(struct wpas_dbus_priv *priv, 59 DBusWatch *watch, eloop_event_type type) 60 { 61 dbus_connection_ref(priv->con); 62 63 priv->should_dispatch = 0; 64 65 if (type == EVENT_TYPE_READ) 66 dbus_watch_handle(watch, DBUS_WATCH_READABLE); 67 else if (type == EVENT_TYPE_WRITE) 68 dbus_watch_handle(watch, DBUS_WATCH_WRITABLE); 69 else if (type == EVENT_TYPE_EXCEPTION) 70 dbus_watch_handle(watch, DBUS_WATCH_ERROR); 71 72 if (priv->should_dispatch) { 73 dispatch_data(priv->con); 74 priv->should_dispatch = 0; 75 } 76 77 dbus_connection_unref(priv->con); 78 } 79 80 81 static void process_watch_exception(int sock, void *eloop_ctx, void *sock_ctx) 82 { 83 process_watch(eloop_ctx, sock_ctx, EVENT_TYPE_EXCEPTION); 84 } 85 86 87 static void process_watch_read(int sock, void *eloop_ctx, void *sock_ctx) 88 { 89 process_watch(eloop_ctx, sock_ctx, EVENT_TYPE_READ); 90 } 91 92 93 static void process_watch_write(int sock, void *eloop_ctx, void *sock_ctx) 94 { 95 process_watch(eloop_ctx, sock_ctx, EVENT_TYPE_WRITE); 96 } 97 98 99 static dbus_bool_t add_watch(DBusWatch *watch, void *data) 100 { 101 struct wpas_dbus_priv *priv = data; 102 unsigned int flags; 103 int fd; 104 105 if (!dbus_watch_get_enabled(watch)) 106 return TRUE; 107 108 flags = dbus_watch_get_flags(watch); 109 fd = dbus_watch_get_unix_fd(watch); 110 111 if (eloop_register_sock(fd, EVENT_TYPE_EXCEPTION, 112 process_watch_exception, priv, watch) < 0) 113 return FALSE; 114 115 if ((flags & DBUS_WATCH_READABLE) && 116 eloop_register_sock(fd, EVENT_TYPE_READ, process_watch_read, 117 priv, watch) < 0) 118 return FALSE; 119 if ((flags & DBUS_WATCH_WRITABLE) && 120 eloop_register_sock(fd, EVENT_TYPE_WRITE, process_watch_write, 121 priv, watch) < 0) 122 return FALSE; 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 wpas_dbus_init_common_finish(priv) < 0) { 355 wpas_dbus_deinit(priv); 356 return NULL; 357 } 358 359 return priv; 360 } 361 362 363 void wpas_dbus_deinit(struct wpas_dbus_priv *priv) 364 { 365 if (priv == NULL) 366 return; 367 368 #ifdef CONFIG_CTRL_IFACE_DBUS_NEW 369 wpas_dbus_ctrl_iface_deinit(priv); 370 #endif /* CONFIG_CTRL_IFACE_DBUS_NEW */ 371 372 wpas_dbus_deinit_common(priv); 373 } 374