2 * WPA Supplicant / dbus-based control interface
3 * Copyright (c) 2006, Dan Williams <dcbw@redhat.com> and Red Hat, Inc.
4 * Copyright (c) 2009, Witold Sowa <witold.sowa@gmail.com>
6 * This software may be distributed under the terms of the BSD license.
7 * See README for more details.
10 #include "utils/includes.h"
12 #include "utils/common.h"
13 #include "utils/eloop.h"
14 #include "dbus_common.h"
15 #include "dbus_common_i.h"
17 #include "dbus_new_helpers.h"
18 #include "dbus_new_handlers.h"
19 #include "dbus_dict_helpers.h"
22 static dbus_bool_t fill_dict_with_properties(
23 DBusMessageIter *dict_iter,
24 const struct wpa_dbus_property_desc *props,
25 const char *interface, void *user_data, DBusError *error)
27 DBusMessageIter entry_iter;
28 const struct wpa_dbus_property_desc *dsc;
30 for (dsc = props; dsc && dsc->dbus_property; dsc++) {
31 /* Only return properties for the requested D-Bus interface */
32 if (os_strncmp(dsc->dbus_interface, interface,
33 WPAS_DBUS_INTERFACE_MAX) != 0)
36 /* Skip write-only properties */
37 if (dsc->getter == NULL)
40 if (!dbus_message_iter_open_container(dict_iter,
43 !dbus_message_iter_append_basic(&entry_iter,
48 /* An error getting a property fails the request entirely */
49 if (!dsc->getter(dsc, &entry_iter, error, user_data)) {
51 "dbus: %s dbus_interface=%s dbus_property=%s getter failed",
52 __func__, dsc->dbus_interface,
57 if (!dbus_message_iter_close_container(dict_iter, &entry_iter))
64 dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
70 * get_all_properties - Responds for GetAll properties calls on object
71 * @message: Message with GetAll call
72 * @interface: interface name which properties will be returned
73 * @property_dsc: list of object's properties
74 * Returns: Message with dict of variants as argument with properties values
76 * Iterates over all properties registered with object and execute getters
77 * of those, which are readable and which interface matches interface
78 * specified as argument. Returned message contains one dict argument
79 * with properties names as keys and theirs values as values.
81 static DBusMessage * get_all_properties(DBusMessage *message, char *interface,
82 struct wpa_dbus_object_desc *obj_dsc)
85 DBusMessageIter iter, dict_iter;
88 reply = dbus_message_new_method_return(message);
90 return wpas_dbus_error_no_memory(message);
92 dbus_message_iter_init_append(reply, &iter);
93 if (!wpa_dbus_dict_open_write(&iter, &dict_iter)) {
94 dbus_message_unref(reply);
95 return wpas_dbus_error_no_memory(message);
98 dbus_error_init(&error);
99 if (!fill_dict_with_properties(&dict_iter, obj_dsc->properties,
100 interface, obj_dsc->user_data, &error)) {
101 dbus_message_unref(reply);
102 reply = wpas_dbus_reply_new_from_error(
103 message, &error, DBUS_ERROR_INVALID_ARGS,
104 "No readable properties in this interface");
105 dbus_error_free(&error);
109 if (!wpa_dbus_dict_close_write(&iter, &dict_iter)) {
110 dbus_message_unref(reply);
111 return wpas_dbus_error_no_memory(message);
118 static int is_signature_correct(DBusMessage *message,
119 const struct wpa_dbus_method_desc *method_dsc)
121 /* According to DBus documentation max length of signature is 255 */
122 #define MAX_SIG_LEN 256
123 char registered_sig[MAX_SIG_LEN], *pos;
124 const char *sig = dbus_message_get_signature(message);
126 const struct wpa_dbus_argument *arg;
128 pos = registered_sig;
131 for (arg = method_dsc->args; arg && arg->name; arg++) {
132 if (arg->dir == ARG_IN) {
133 size_t blen = registered_sig + MAX_SIG_LEN - pos;
135 ret = os_snprintf(pos, blen, "%s", arg->type);
136 if (os_snprintf_error(blen, ret))
142 return !os_strncmp(registered_sig, sig, MAX_SIG_LEN);
146 static DBusMessage * properties_get_all(DBusMessage *message, char *interface,
147 struct wpa_dbus_object_desc *obj_dsc)
149 if (os_strcmp(dbus_message_get_signature(message), "s") != 0)
150 return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
153 return get_all_properties(message, interface, obj_dsc);
157 static DBusMessage * properties_get(DBusMessage *message,
158 const struct wpa_dbus_property_desc *dsc,
162 DBusMessageIter iter;
165 if (os_strcmp(dbus_message_get_signature(message), "ss")) {
166 return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
170 if (dsc->getter == NULL) {
171 return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
172 "Property is write-only");
175 reply = dbus_message_new_method_return(message);
176 dbus_message_iter_init_append(reply, &iter);
178 dbus_error_init(&error);
179 if (dsc->getter(dsc, &iter, &error, user_data) == FALSE) {
180 dbus_message_unref(reply);
181 reply = wpas_dbus_reply_new_from_error(
182 message, &error, DBUS_ERROR_FAILED,
183 "Failed to read property");
184 dbus_error_free(&error);
191 static DBusMessage * properties_set(DBusMessage *message,
192 const struct wpa_dbus_property_desc *dsc,
196 DBusMessageIter iter;
199 if (os_strcmp(dbus_message_get_signature(message), "ssv")) {
200 return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
204 if (dsc->setter == NULL) {
205 return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
206 "Property is read-only");
209 dbus_message_iter_init(message, &iter);
210 /* Skip the interface name and the property name */
211 dbus_message_iter_next(&iter);
212 dbus_message_iter_next(&iter);
214 /* Iter will now point to the property's new value */
215 dbus_error_init(&error);
216 if (dsc->setter(dsc, &iter, &error, user_data) == TRUE) {
218 reply = dbus_message_new_method_return(message);
220 reply = wpas_dbus_reply_new_from_error(
221 message, &error, DBUS_ERROR_FAILED,
222 "Failed to set property");
223 dbus_error_free(&error);
231 properties_get_or_set(DBusMessage *message, DBusMessageIter *iter,
233 struct wpa_dbus_object_desc *obj_dsc)
235 const struct wpa_dbus_property_desc *property_dsc;
239 method = dbus_message_get_member(message);
240 property_dsc = obj_dsc->properties;
242 /* Second argument: property name (DBUS_TYPE_STRING) */
243 if (!dbus_message_iter_next(iter) ||
244 dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_STRING) {
245 return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
248 dbus_message_iter_get_basic(iter, &property);
250 while (property_dsc && property_dsc->dbus_property) {
251 /* compare property names and
253 if (!os_strncmp(property_dsc->dbus_property, property,
254 WPAS_DBUS_METHOD_SIGNAL_PROP_MAX) &&
255 !os_strncmp(property_dsc->dbus_interface, interface,
256 WPAS_DBUS_INTERFACE_MAX))
261 if (property_dsc == NULL || property_dsc->dbus_property == NULL) {
262 wpa_printf(MSG_DEBUG, "no property handler for %s.%s on %s",
264 dbus_message_get_path(message));
265 return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
269 if (os_strncmp(WPA_DBUS_PROPERTIES_GET, method,
270 WPAS_DBUS_METHOD_SIGNAL_PROP_MAX) == 0) {
271 wpa_printf(MSG_MSGDUMP, "%s: Get(%s)", __func__, property);
272 return properties_get(message, property_dsc,
276 wpa_printf(MSG_MSGDUMP, "%s: Set(%s)", __func__, property);
277 return properties_set(message, property_dsc, obj_dsc->user_data);
281 static DBusMessage * properties_handler(DBusMessage *message,
282 struct wpa_dbus_object_desc *obj_dsc)
284 DBusMessageIter iter;
288 method = dbus_message_get_member(message);
289 dbus_message_iter_init(message, &iter);
291 if (!os_strncmp(WPA_DBUS_PROPERTIES_GET, method,
292 WPAS_DBUS_METHOD_SIGNAL_PROP_MAX) ||
293 !os_strncmp(WPA_DBUS_PROPERTIES_SET, method,
294 WPAS_DBUS_METHOD_SIGNAL_PROP_MAX) ||
295 !os_strncmp(WPA_DBUS_PROPERTIES_GETALL, method,
296 WPAS_DBUS_METHOD_SIGNAL_PROP_MAX)) {
297 /* First argument: interface name (DBUS_TYPE_STRING) */
298 if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) {
299 return dbus_message_new_error(message,
300 DBUS_ERROR_INVALID_ARGS,
304 dbus_message_iter_get_basic(&iter, &interface);
306 if (!os_strncmp(WPA_DBUS_PROPERTIES_GETALL, method,
307 WPAS_DBUS_METHOD_SIGNAL_PROP_MAX)) {
309 return properties_get_all(message, interface, obj_dsc);
312 return properties_get_or_set(message, &iter, interface,
315 return dbus_message_new_error(message, DBUS_ERROR_UNKNOWN_METHOD,
320 static DBusMessage * msg_method_handler(DBusMessage *message,
321 struct wpa_dbus_object_desc *obj_dsc)
323 const struct wpa_dbus_method_desc *method_dsc = obj_dsc->methods;
325 const char *msg_interface;
327 method = dbus_message_get_member(message);
328 msg_interface = dbus_message_get_interface(message);
330 /* try match call to any registered method */
331 while (method_dsc && method_dsc->dbus_method) {
332 /* compare method names and interfaces */
333 if (!os_strncmp(method_dsc->dbus_method, method,
334 WPAS_DBUS_METHOD_SIGNAL_PROP_MAX) &&
335 !os_strncmp(method_dsc->dbus_interface, msg_interface,
336 WPAS_DBUS_INTERFACE_MAX))
341 if (method_dsc == NULL || method_dsc->dbus_method == NULL) {
342 wpa_printf(MSG_DEBUG, "no method handler for %s.%s on %s",
343 msg_interface, method,
344 dbus_message_get_path(message));
345 return dbus_message_new_error(message,
346 DBUS_ERROR_UNKNOWN_METHOD, NULL);
349 if (!is_signature_correct(message, method_dsc)) {
350 return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
354 return method_dsc->method_handler(message, obj_dsc->user_data);
359 * message_handler - Handles incoming DBus messages
360 * @connection: DBus connection on which message was received
361 * @message: Received message
362 * @user_data: pointer to description of object to which message was sent
363 * Returns: Returns information whether message was handled or not
365 * Reads message interface and method name, then checks if they matches one
366 * of the special cases i.e. introspection call or properties get/getall/set
367 * methods and handles it. Else it iterates over registered methods list
368 * and tries to match method's name and interface to those read from message
369 * If appropriate method was found its handler function is called and
370 * response is sent. Otherwise, the DBUS_ERROR_UNKNOWN_METHOD error message
373 static DBusHandlerResult message_handler(DBusConnection *connection,
374 DBusMessage *message, void *user_data)
376 struct wpa_dbus_object_desc *obj_dsc = user_data;
379 const char *msg_interface;
382 /* get method, interface and path the message is addressed to */
383 method = dbus_message_get_member(message);
384 path = dbus_message_get_path(message);
385 msg_interface = dbus_message_get_interface(message);
386 if (!method || !path || !msg_interface)
387 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
389 wpa_printf(MSG_MSGDUMP, "dbus: %s.%s (%s) [%s]",
390 msg_interface, method, path,
391 dbus_message_get_signature(message));
393 /* if message is introspection method call */
394 if (!os_strncmp(WPA_DBUS_INTROSPECTION_METHOD, method,
395 WPAS_DBUS_METHOD_SIGNAL_PROP_MAX) &&
396 !os_strncmp(WPA_DBUS_INTROSPECTION_INTERFACE, msg_interface,
397 WPAS_DBUS_INTERFACE_MAX)) {
398 #ifdef CONFIG_CTRL_IFACE_DBUS_INTRO
399 reply = wpa_dbus_introspect(message, obj_dsc);
400 #else /* CONFIG_CTRL_IFACE_DBUS_INTRO */
401 reply = dbus_message_new_error(
402 message, DBUS_ERROR_UNKNOWN_METHOD,
403 "wpa_supplicant was compiled without introspection support.");
404 #endif /* CONFIG_CTRL_IFACE_DBUS_INTRO */
405 } else if (!os_strncmp(WPA_DBUS_PROPERTIES_INTERFACE, msg_interface,
406 WPAS_DBUS_INTERFACE_MAX)) {
407 /* if message is properties method call */
408 reply = properties_handler(message, obj_dsc);
410 reply = msg_method_handler(message, obj_dsc);
413 /* If handler succeed returning NULL, reply empty message */
415 reply = dbus_message_new_method_return(message);
417 if (!dbus_message_get_no_reply(message))
418 dbus_connection_send(connection, reply, NULL);
419 dbus_message_unref(reply);
422 wpa_dbus_flush_all_changed_properties(connection);
424 return DBUS_HANDLER_RESULT_HANDLED;
429 * free_dbus_object_desc - Frees object description data structure
430 * @connection: DBus connection
431 * @obj_dsc: Object description to free
433 * Frees each of properties, methods and signals description lists and
434 * the object description structure itself.
436 void free_dbus_object_desc(struct wpa_dbus_object_desc *obj_dsc)
441 /* free handler's argument */
442 if (obj_dsc->user_data_free_func)
443 obj_dsc->user_data_free_func(obj_dsc->user_data);
445 os_free(obj_dsc->path);
446 os_free(obj_dsc->prop_changed_flags);
451 static void free_dbus_object_desc_cb(DBusConnection *connection, void *obj_dsc)
453 free_dbus_object_desc(obj_dsc);
458 * wpa_dbus_ctrl_iface_init - Initialize dbus control interface
459 * @application_data: Pointer to application specific data structure
460 * @dbus_path: DBus path to interface object
461 * @dbus_service: DBus service name to register with
462 * @messageHandler: a pointer to function which will handle dbus messages
463 * coming on interface
464 * Returns: 0 on success, -1 on failure
466 * Initialize the dbus control interface and start receiving commands from
467 * external programs over the bus.
469 int wpa_dbus_ctrl_iface_init(struct wpas_dbus_priv *iface,
470 char *dbus_path, char *dbus_service,
471 struct wpa_dbus_object_desc *obj_desc)
475 DBusObjectPathVTable wpa_vtable = {
476 &free_dbus_object_desc_cb, &message_handler,
477 NULL, NULL, NULL, NULL
480 obj_desc->connection = iface->con;
481 obj_desc->path = os_strdup(dbus_path);
483 /* Register the message handler for the global dbus interface */
484 if (!dbus_connection_register_object_path(iface->con, dbus_path,
485 &wpa_vtable, obj_desc)) {
486 wpa_printf(MSG_ERROR, "dbus: Could not set up message handler");
490 /* Register our service with the message bus */
491 dbus_error_init(&error);
492 switch (dbus_bus_request_name(iface->con, dbus_service, 0, &error)) {
493 case DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER:
496 case DBUS_REQUEST_NAME_REPLY_EXISTS:
497 case DBUS_REQUEST_NAME_REPLY_IN_QUEUE:
498 case DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER:
499 wpa_printf(MSG_ERROR,
500 "dbus: Could not request service name: already registered");
503 wpa_printf(MSG_ERROR,
504 "dbus: Could not request service name: %s %s",
505 error.name, error.message);
508 dbus_error_free(&error);
513 wpa_printf(MSG_DEBUG, "Providing DBus service '%s'.", dbus_service);
520 * wpa_dbus_register_object_per_iface - Register a new object with dbus
521 * @ctrl_iface: pointer to dbus private data
522 * @path: DBus path to object
523 * @ifname: interface name
524 * @obj_desc: description of object's methods, signals and properties
525 * Returns: 0 on success, -1 on error
527 * Registers a new interface with dbus and assigns it a dbus object path.
529 int wpa_dbus_register_object_per_iface(struct wpas_dbus_priv *ctrl_iface,
530 const char *path, const char *ifname,
531 struct wpa_dbus_object_desc *obj_desc)
535 DBusObjectPathVTable vtable = {
536 &free_dbus_object_desc_cb, &message_handler,
537 NULL, NULL, NULL, NULL
540 /* Do nothing if the control interface is not turned on */
541 if (ctrl_iface == NULL)
544 con = ctrl_iface->con;
545 obj_desc->connection = con;
546 obj_desc->path = os_strdup(path);
548 dbus_error_init(&error);
549 /* Register the message handler for the interface functions */
550 if (!dbus_connection_try_register_object_path(con, path, &vtable,
552 if (os_strcmp(error.name, DBUS_ERROR_OBJECT_PATH_IN_USE) == 0) {
553 wpa_printf(MSG_DEBUG, "dbus: %s", error.message);
555 wpa_printf(MSG_ERROR,
556 "dbus: Could not set up message handler for interface %s object %s (error: %s message: %s)",
557 ifname, path, error.name, error.message);
559 dbus_error_free(&error);
563 dbus_error_free(&error);
568 static void flush_object_timeout_handler(void *eloop_ctx, void *timeout_ctx);
572 * wpa_dbus_unregister_object_per_iface - Unregisters DBus object
573 * @ctrl_iface: Pointer to dbus private data
574 * @path: DBus path to object which will be unregistered
575 * Returns: Zero on success and -1 on failure
577 * Unregisters DBus object given by its path
579 int wpa_dbus_unregister_object_per_iface(
580 struct wpas_dbus_priv *ctrl_iface, const char *path)
582 DBusConnection *con = ctrl_iface->con;
583 struct wpa_dbus_object_desc *obj_desc = NULL;
585 dbus_connection_get_object_path_data(con, path, (void **) &obj_desc);
587 wpa_printf(MSG_ERROR,
588 "dbus: %s: Could not obtain object's private data: %s",
593 eloop_cancel_timeout(flush_object_timeout_handler, con, obj_desc);
595 if (!dbus_connection_unregister_object_path(con, path))
602 static dbus_bool_t put_changed_properties(
603 const struct wpa_dbus_object_desc *obj_dsc, const char *interface,
604 DBusMessageIter *dict_iter, int clear_changed)
606 DBusMessageIter entry_iter;
607 const struct wpa_dbus_property_desc *dsc;
611 for (dsc = obj_dsc->properties, i = 0; dsc && dsc->dbus_property;
613 if (obj_dsc->prop_changed_flags == NULL ||
614 !obj_dsc->prop_changed_flags[i])
616 if (os_strcmp(dsc->dbus_interface, interface) != 0)
619 obj_dsc->prop_changed_flags[i] = 0;
621 if (!dbus_message_iter_open_container(dict_iter,
622 DBUS_TYPE_DICT_ENTRY,
623 NULL, &entry_iter) ||
624 !dbus_message_iter_append_basic(&entry_iter,
626 &dsc->dbus_property))
629 dbus_error_init(&error);
630 if (!dsc->getter(dsc, &entry_iter, &error, obj_dsc->user_data))
632 if (dbus_error_is_set(&error)) {
633 wpa_printf(MSG_ERROR,
634 "dbus: %s: Cannot get new value of property %s: (%s) %s",
635 __func__, dsc->dbus_property,
636 error.name, error.message);
638 wpa_printf(MSG_ERROR,
639 "dbus: %s: Cannot get new value of property %s",
640 __func__, dsc->dbus_property);
642 dbus_error_free(&error);
646 if (!dbus_message_iter_close_container(dict_iter, &entry_iter))
654 static void do_send_prop_changed_signal(
655 DBusConnection *con, const char *path, const char *interface,
656 const struct wpa_dbus_object_desc *obj_dsc)
659 DBusMessageIter signal_iter, dict_iter;
661 msg = dbus_message_new_signal(path, DBUS_INTERFACE_PROPERTIES,
662 "PropertiesChanged");
666 dbus_message_iter_init_append(msg, &signal_iter);
668 if (!dbus_message_iter_append_basic(&signal_iter, DBUS_TYPE_STRING,
670 /* Changed properties dict */
671 !dbus_message_iter_open_container(&signal_iter, DBUS_TYPE_ARRAY,
672 "{sv}", &dict_iter) ||
673 !put_changed_properties(obj_dsc, interface, &dict_iter, 0) ||
674 !dbus_message_iter_close_container(&signal_iter, &dict_iter) ||
675 /* Invalidated properties array (empty) */
676 !dbus_message_iter_open_container(&signal_iter, DBUS_TYPE_ARRAY,
678 !dbus_message_iter_close_container(&signal_iter, &dict_iter)) {
679 wpa_printf(MSG_DEBUG, "dbus: %s: Failed to construct signal",
682 dbus_connection_send(con, msg, NULL);
685 dbus_message_unref(msg);
689 static void do_send_deprecated_prop_changed_signal(
690 DBusConnection *con, const char *path, const char *interface,
691 const struct wpa_dbus_object_desc *obj_dsc)
694 DBusMessageIter signal_iter, dict_iter;
696 msg = dbus_message_new_signal(path, interface, "PropertiesChanged");
700 dbus_message_iter_init_append(msg, &signal_iter);
702 if (!dbus_message_iter_open_container(&signal_iter, DBUS_TYPE_ARRAY,
703 "{sv}", &dict_iter) ||
704 !put_changed_properties(obj_dsc, interface, &dict_iter, 1) ||
705 !dbus_message_iter_close_container(&signal_iter, &dict_iter)) {
706 wpa_printf(MSG_DEBUG, "dbus: %s: Failed to construct signal",
709 dbus_connection_send(con, msg, NULL);
712 dbus_message_unref(msg);
716 static void send_prop_changed_signal(
717 DBusConnection *con, const char *path, const char *interface,
718 const struct wpa_dbus_object_desc *obj_dsc)
721 * First, send property change notification on the standardized
722 * org.freedesktop.DBus.Properties interface. This call will not
723 * clear the property change bits, so that they are preserved for
724 * the call that follows.
726 do_send_prop_changed_signal(con, path, interface, obj_dsc);
729 * Now send PropertiesChanged on our own interface for backwards
730 * compatibility. This is deprecated and will be removed in a future
733 do_send_deprecated_prop_changed_signal(con, path, interface, obj_dsc);
735 /* Property change bits have now been cleared. */
739 static void flush_object_timeout_handler(void *eloop_ctx, void *timeout_ctx)
741 DBusConnection *con = eloop_ctx;
742 struct wpa_dbus_object_desc *obj_desc = timeout_ctx;
744 wpa_printf(MSG_DEBUG,
745 "dbus: %s: Timeout - sending changed properties of object %s",
746 __func__, obj_desc->path);
747 wpa_dbus_flush_object_changed_properties(con, obj_desc->path);
751 static void recursive_flush_changed_properties(DBusConnection *con,
754 char **objects = NULL;
755 char subobj_path[WPAS_DBUS_OBJECT_PATH_MAX];
758 wpa_dbus_flush_object_changed_properties(con, path);
760 if (!dbus_connection_list_registered(con, path, &objects))
763 for (i = 0; objects[i]; i++) {
764 os_snprintf(subobj_path, WPAS_DBUS_OBJECT_PATH_MAX,
765 "%s/%s", path, objects[i]);
766 recursive_flush_changed_properties(con, subobj_path);
770 dbus_free_string_array(objects);
775 * wpa_dbus_flush_all_changed_properties - Send all PropertiesChanged signals
776 * @con: DBus connection
778 * Traverses through all registered objects and sends PropertiesChanged for
781 void wpa_dbus_flush_all_changed_properties(DBusConnection *con)
783 recursive_flush_changed_properties(con, WPAS_DBUS_NEW_PATH);
788 * wpa_dbus_flush_object_changed_properties - Send PropertiesChanged for object
789 * @con: DBus connection
790 * @path: path to a DBus object for which PropertiesChanged will be sent.
792 * Iterates over all properties registered with object and for each interface
793 * containing properties marked as changed, sends a PropertiesChanged signal
794 * containing names and new values of properties that have changed.
796 * You need to call this function after wpa_dbus_mark_property_changed()
797 * if you want to send PropertiesChanged signal immediately (i.e., without
798 * waiting timeout to expire). PropertiesChanged signal for an object is sent
799 * automatically short time after first marking property as changed. All
800 * PropertiesChanged signals are sent automatically after responding on DBus
801 * message, so if you marked a property changed as a result of DBus call
802 * (e.g., param setter), you usually do not need to call this function.
804 void wpa_dbus_flush_object_changed_properties(DBusConnection *con,
807 struct wpa_dbus_object_desc *obj_desc = NULL;
808 const struct wpa_dbus_property_desc *dsc;
811 dbus_connection_get_object_path_data(con, path, (void **) &obj_desc);
814 eloop_cancel_timeout(flush_object_timeout_handler, con, obj_desc);
816 for (dsc = obj_desc->properties, i = 0; dsc && dsc->dbus_property;
818 if (obj_desc->prop_changed_flags == NULL ||
819 !obj_desc->prop_changed_flags[i])
821 send_prop_changed_signal(con, path, dsc->dbus_interface,
827 #define WPA_DBUS_SEND_PROP_CHANGED_TIMEOUT 5000
831 * wpa_dbus_mark_property_changed - Mark a property as changed and
832 * @iface: dbus priv struct
833 * @path: path to DBus object which property has changed
834 * @interface: interface containing changed property
835 * @property: property name which has changed
837 * Iterates over all properties registered with an object and marks the one
838 * given in parameters as changed. All parameters registered for an object
839 * within a single interface will be aggregated together and sent in one
840 * PropertiesChanged signal when function
841 * wpa_dbus_flush_object_changed_properties() is called.
843 void wpa_dbus_mark_property_changed(struct wpas_dbus_priv *iface,
844 const char *path, const char *interface,
845 const char *property)
847 struct wpa_dbus_object_desc *obj_desc = NULL;
848 const struct wpa_dbus_property_desc *dsc;
854 dbus_connection_get_object_path_data(iface->con, path,
855 (void **) &obj_desc);
857 wpa_printf(MSG_ERROR,
858 "dbus: wpa_dbus_property_changed: could not obtain object's private data: %s",
863 for (dsc = obj_desc->properties; dsc && dsc->dbus_property; dsc++, i++)
864 if (os_strcmp(property, dsc->dbus_property) == 0 &&
865 os_strcmp(interface, dsc->dbus_interface) == 0) {
866 if (obj_desc->prop_changed_flags)
867 obj_desc->prop_changed_flags[i] = 1;
871 if (!dsc || !dsc->dbus_property) {
872 wpa_printf(MSG_ERROR,
873 "dbus: wpa_dbus_property_changed: no property %s in object %s",
878 if (!eloop_is_timeout_registered(flush_object_timeout_handler,
879 iface->con, obj_desc)) {
880 eloop_register_timeout(0, WPA_DBUS_SEND_PROP_CHANGED_TIMEOUT,
881 flush_object_timeout_handler,
882 iface->con, obj_desc);
888 * wpa_dbus_get_object_properties - Put object's properties into dictionary
889 * @iface: dbus priv struct
890 * @path: path to DBus object which properties will be obtained
891 * @interface: interface name which properties will be obtained
892 * @iter: DBus message iter at which to append property dictionary.
894 * Iterates over all properties registered with object and execute getters
895 * of those, which are readable and which interface matches interface
896 * specified as argument. Obtained properties values are stored in
897 * dict_iter dictionary.
899 dbus_bool_t wpa_dbus_get_object_properties(struct wpas_dbus_priv *iface,
901 const char *interface,
902 DBusMessageIter *iter)
904 struct wpa_dbus_object_desc *obj_desc = NULL;
905 DBusMessageIter dict_iter;
908 dbus_connection_get_object_path_data(iface->con, path,
909 (void **) &obj_desc);
911 wpa_printf(MSG_ERROR,
912 "dbus: %s: could not obtain object's private data: %s",
917 if (!wpa_dbus_dict_open_write(iter, &dict_iter)) {
918 wpa_printf(MSG_ERROR, "dbus: %s: failed to open message dict",
923 dbus_error_init(&error);
924 if (!fill_dict_with_properties(&dict_iter, obj_desc->properties,
925 interface, obj_desc->user_data,
927 wpa_printf(MSG_ERROR,
928 "dbus: %s: failed to get object properties: (%s) %s",
930 dbus_error_is_set(&error) ? error.name : "none",
931 dbus_error_is_set(&error) ? error.message : "none");
932 dbus_error_free(&error);
936 return wpa_dbus_dict_close_write(iter, &dict_iter);
940 * wpas_dbus_new_decompose_object_path - Decompose an interface object path into parts
941 * @path: The dbus object path
942 * @sep: Separating part (e.g., "Networks" or "PersistentGroups")
943 * @item: (out) The part following the specified separator, if any
944 * Returns: The object path of the interface this path refers to
946 * For a given object path, decomposes the object path into object id and
947 * requested part, if those parts exist. The caller is responsible for freeing
948 * the returned value. The *item pointer points to that allocated value and must
949 * not be freed separately.
951 * As an example, path = "/fi/w1/wpa_supplicant1/Interfaces/1/Networks/0" and
952 * sep = "Networks" would result in "/fi/w1/wpa_supplicant1/Interfaces/1"
953 * getting returned and *items set to point to "0".
955 char * wpas_dbus_new_decompose_object_path(const char *path, const char *sep,
958 const unsigned int dev_path_prefix_len =
959 os_strlen(WPAS_DBUS_NEW_PATH_INTERFACES "/");
966 /* Verify that this starts with our interface prefix */
967 if (os_strncmp(path, WPAS_DBUS_NEW_PATH_INTERFACES "/",
968 dev_path_prefix_len) != 0)
969 return NULL; /* not our path */
971 /* Ensure there's something at the end of the path */
972 if ((path + dev_path_prefix_len)[0] == '\0')
975 obj_path_only = os_strdup(path);
976 if (obj_path_only == NULL)
979 pos = obj_path_only + dev_path_prefix_len;
980 pos = os_strchr(pos, '/');
982 return obj_path_only; /* no next item on the path */
984 /* Separate network interface prefix from the path */
987 sep_len = os_strlen(sep);
988 if (os_strncmp(pos, sep, sep_len) != 0 || pos[sep_len] != '/')
989 return obj_path_only; /* no match */
991 /* return a pointer to the requested item */
992 *item = pos + sep_len + 1;
993 return obj_path_only;
998 * wpas_dbus_reply_new_from_error - Create a new D-Bus error message from a
999 * dbus error structure
1000 * @message: The original request message for which the error is a reply
1001 * @error: The error containing a name and a descriptive error cause
1002 * @fallback_name: A generic error name if @error was not set
1003 * @fallback_string: A generic error string if @error was not set
1004 * Returns: A new D-Bus error message
1006 * Given a DBusMessage structure, creates a new D-Bus error message using
1007 * the error name and string contained in that structure.
1009 DBusMessage * wpas_dbus_reply_new_from_error(DBusMessage *message,
1011 const char *fallback_name,
1012 const char *fallback_string)
1014 if (error && error->name && error->message) {
1015 return dbus_message_new_error(message, error->name,
1018 if (fallback_name && fallback_string) {
1019 return dbus_message_new_error(message, fallback_name,