* Copyright (c) 2006, Dan Williams <dcbw@redhat.com> and Red Hat, Inc.
* Copyright (c) 2009, Witold Sowa <witold.sowa@gmail.com>
*
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * Alternatively, this software may be distributed under the terms of BSD
- * license.
- *
- * See README and COPYING for more details.
+ * This software may be distributed under the terms of the BSD license.
+ * See README for more details.
*/
-#include "includes.h"
+#include "utils/includes.h"
-#include "common.h"
-#include "eloop.h"
+#include "utils/common.h"
+#include "utils/eloop.h"
#include "dbus_common.h"
#include "dbus_common_i.h"
+#include "dbus_new.h"
#include "dbus_new_helpers.h"
+#include "dbus_new_handlers.h"
+#include "dbus_dict_helpers.h"
-/**
- * struct wpa_dbus_method_desc - DBus method description
- */
-struct wpa_dbus_method_desc {
- /* pointer to next description in list */
- struct wpa_dbus_method_desc *next;
-
- /* method interface */
- char *dbus_interface;
- /* method name */
- char *dbus_method;
-
- /* method handling function */
- WPADBusMethodHandler method_handler;
-
- /* number of method arguments */
- int args_num;
- /* array of arguments */
- struct wpa_dbus_argument args[];
-};
-
-
-/**
- * struct wpa_dbus_signal_desc - DBus signal description
- */
-struct wpa_dbus_signal_desc {
- /* pointer to next description in list */
- struct wpa_dbus_signal_desc *next;
-
- /* signal interface */
- char *dbus_interface;
- /* signal name */
- char *dbus_signal;
-
- /* number of signal arguments */
- int args_num;
- /* array of arguments */
- struct wpa_dbus_argument args[0];
-};
-
-
-/**
- * struct wpa_dbus_property_desc - DBus property description
- */
-struct wpa_dbus_property_desc {
- /* pointer to next description in list */
- struct wpa_dbus_property_desc *next;
-
- /* property interface */
- char *dbus_interface;
- /* property name */
- char *dbus_property;
- /* property type signature in DBus type notation */
- char *type;
-
- /* property access permissions */
- enum dbus_prop_access access;
-
- /* property getter function */
- WPADBusPropertyAccessor getter;
- /* property setter function */
- WPADBusPropertyAccessor setter;
-};
-
-
-#ifdef CONFIG_CTRL_IFACE_DBUS_INTRO
-#include <libxml/tree.h>
-struct interfaces {
- struct interfaces *next;
- char *dbus_interface;
- xmlNodePtr interface_node;
-};
-#endif /* CONFIG_CTRL_IFACE_DBUS_INTRO */
-
-
-#ifdef CONFIG_CTRL_IFACE_DBUS_INTRO
-
-/**
- * extract_interfaces - Extract interfaces from methods, signals and props
- * @obj_dsc: Description of object from which interfaces will be extracted
- * @root_node: root node of XML introspection document
- * Returns: List of interfaces found in object description
- *
- * Iterates over all methods, signals and properties registered with
- * object and collects all declared DBus interfaces and create interface's
- * node in XML root node for each. Returned list elements contains interface
- * name and XML node of corresponding interface.
- */
-static struct interfaces * extract_interfaces(
- struct wpa_dbus_object_desc *obj_dsc, xmlNodePtr root_node)
+static dbus_bool_t fill_dict_with_properties(
+ DBusMessageIter *dict_iter,
+ const struct wpa_dbus_property_desc *props,
+ const char *interface, void *user_data, DBusError *error)
{
- struct wpa_dbus_method_desc *method_dsc = obj_dsc->methods;
- struct wpa_dbus_signal_desc *signal_dsc = obj_dsc->signals;
- struct wpa_dbus_property_desc *property_dsc = obj_dsc->properties;
- struct interfaces *head = NULL;
- struct interfaces *iface, *last;
- int len;
-
- /* extract interfaces from methods */
- while (method_dsc) {
- iface = head;
- last = NULL;
-
- /* go to next method if its interface is already extracted */
- while (iface) {
- if (!os_strcmp(iface->dbus_interface,
- method_dsc->dbus_interface))
- break;
- last = iface;
- iface = iface->next;
- }
- if (iface) {
- method_dsc = method_dsc->next;
- continue;
- }
+ DBusMessageIter entry_iter;
+ const struct wpa_dbus_property_desc *dsc;
- iface = os_zalloc(sizeof(struct interfaces));
- if (!iface) {
- wpa_printf(MSG_ERROR, "Not enough memory to create "
- "interface introspection data");
- method_dsc = method_dsc->next;
+ for (dsc = props; dsc && dsc->dbus_property; dsc++) {
+ /* Only return properties for the requested D-Bus interface */
+ if (os_strncmp(dsc->dbus_interface, interface,
+ WPAS_DBUS_INTERFACE_MAX) != 0)
continue;
- }
-
- if (last)
- last->next = iface;
- else
- head = iface;
-
- len = os_strlen(method_dsc->dbus_interface) + 1;
- iface->dbus_interface = os_malloc(len);
- if (!iface->dbus_interface) {
- wpa_printf(MSG_ERROR, "Not enough memory to create "
- "interface introspection data (interface "
- "name)");
- method_dsc = method_dsc->next;
- continue;
- }
- os_strncpy(iface->dbus_interface, method_dsc->dbus_interface,
- len);
-
- iface->interface_node = xmlNewChild(root_node, NULL,
- BAD_CAST "interface",
- NULL);
- xmlNewProp(iface->interface_node, BAD_CAST "name",
- BAD_CAST method_dsc->dbus_interface);
-
- method_dsc = method_dsc->next;
- }
-
- /* extract interfaces from signals */
- while (signal_dsc) {
- iface = head;
- last = NULL;
-
- /* go to next signal if its interface is already extracted */
- while (iface) {
- if (!os_strcmp(iface->dbus_interface,
- signal_dsc->dbus_interface))
- break;
- last = iface;
- iface = iface->next;
- }
- if (iface) {
- signal_dsc = signal_dsc->next;
- continue;
- }
- iface = os_zalloc(sizeof(struct interfaces));
- if (!iface) {
- wpa_printf(MSG_ERROR, "Not enough memory to create "
- "interface introspection data");
- signal_dsc = signal_dsc->next;
+ /* Skip write-only properties */
+ if (dsc->getter == NULL)
continue;
- }
- if (last)
- last->next = iface;
- else
- head = iface;
-
- len = os_strlen(signal_dsc->dbus_interface) + 1;
- iface->dbus_interface = os_malloc(len);
- if (!iface->dbus_interface) {
- wpa_printf(MSG_ERROR, "Not enough memory to create "
- "interface introspection data (interface "
- "name)");
- signal_dsc = signal_dsc->next;
- continue;
+ if (!dbus_message_iter_open_container(dict_iter,
+ DBUS_TYPE_DICT_ENTRY,
+ NULL, &entry_iter) ||
+ !dbus_message_iter_append_basic(&entry_iter,
+ DBUS_TYPE_STRING,
+ &dsc->dbus_property))
+ goto error;
+
+ /* An error getting a property fails the request entirely */
+ if (!dsc->getter(dsc, &entry_iter, error, user_data)) {
+ wpa_printf(MSG_INFO,
+ "dbus: %s dbus_interface=%s dbus_property=%s getter failed",
+ __func__, dsc->dbus_interface,
+ dsc->dbus_property);
+ return FALSE;
}
- os_strncpy(iface->dbus_interface, signal_dsc->dbus_interface,
- len);
-
- iface->interface_node = xmlNewChild(root_node, NULL,
- BAD_CAST "interface",
- NULL);
- xmlNewProp(iface->interface_node, BAD_CAST "name",
- BAD_CAST signal_dsc->dbus_interface);
- signal_dsc = signal_dsc->next;
+ if (!dbus_message_iter_close_container(dict_iter, &entry_iter))
+ goto error;
}
- /* extract interfaces from properties */
- while (property_dsc) {
- iface = head;
- last = NULL;
-
- /* go to next property if its interface is already extracted */
- while (iface) {
- if (!os_strcmp(iface->dbus_interface,
- property_dsc->dbus_interface))
- break;
- last = iface;
- iface = iface->next;
- }
- if (iface) {
- property_dsc = property_dsc->next;
- continue;
- }
-
- iface = os_zalloc(sizeof(struct interfaces));
- if (!iface) {
- wpa_printf(MSG_ERROR, "Not enough memory to create "
- "interface introspection data");
- property_dsc = property_dsc->next;
- continue;
- }
-
- if (last)
- last->next = iface;
- else
- head = iface;
-
- len = os_strlen(property_dsc->dbus_interface) + 1;
- iface->dbus_interface = os_malloc(len);
- if (!iface->dbus_interface) {
- wpa_printf(MSG_ERROR, "Not enough memory to create "
- "interface introspection data (interface "
- "name)");
- property_dsc = property_dsc->next;
- continue;
- }
- os_strncpy(iface->dbus_interface, property_dsc->dbus_interface,
- len);
+ return TRUE;
- iface->interface_node = xmlNewChild(root_node, NULL,
- BAD_CAST "interface",
- NULL);
- xmlNewProp(iface->interface_node, BAD_CAST "name",
- BAD_CAST property_dsc->dbus_interface);
-
- property_dsc = property_dsc->next;
- }
-
- return head;
-}
-
-
-/**
- * introspect - Responds for Introspect calls on object
- * @message: Message with Introspect call
- * @obj_dsc: Object description on which Introspect was called
- * Returns: Message with introspection result XML string as only argument
- *
- * Iterates over all methods, signals and properties registered with
- * object and generates introspection data for the object as XML string.
- */
-static DBusMessage * introspect(DBusMessage *message,
- struct wpa_dbus_object_desc *obj_dsc)
-{
-
- DBusMessage *reply;
- struct interfaces *ifaces, *tmp;
- struct wpa_dbus_signal_desc *signal_dsc;
- struct wpa_dbus_method_desc *method_dsc;
- struct wpa_dbus_property_desc *property_dsc;
- xmlChar *intro_str;
- char **children;
- int i, s;
-
- xmlDocPtr doc = NULL;
- xmlNodePtr root_node = NULL, node = NULL, iface_node = NULL;
- xmlNodePtr method_node = NULL, signal_node = NULL;
- xmlNodePtr property_node = NULL, arg_node = NULL;
-
- /* root node and dtd */
- doc = xmlNewDoc(BAD_CAST "1.0");
- root_node = xmlNewNode(NULL, BAD_CAST "node");
- xmlDocSetRootElement(doc, root_node);
- xmlCreateIntSubset(doc, BAD_CAST "node",
- BAD_CAST DBUS_INTROSPECT_1_0_XML_PUBLIC_IDENTIFIER,
- BAD_CAST DBUS_INTROSPECT_1_0_XML_SYSTEM_IDENTIFIER);
-
- /* Add Introspectable interface */
- iface_node = xmlNewChild(root_node, NULL, BAD_CAST "interface", NULL);
- xmlNewProp(iface_node, BAD_CAST "name",
- BAD_CAST WPA_DBUS_INTROSPECTION_INTERFACE);
-
- /* Add Introspect method */
- method_node = xmlNewChild(iface_node, NULL, BAD_CAST "method", NULL);
- xmlNewProp(method_node, BAD_CAST "name",
- BAD_CAST WPA_DBUS_INTROSPECTION_METHOD);
- arg_node = xmlNewChild(method_node, NULL, BAD_CAST "arg", NULL);
- xmlNewProp(arg_node, BAD_CAST "name", BAD_CAST "data");
- xmlNewProp(arg_node, BAD_CAST "type", BAD_CAST "s");
- xmlNewProp(arg_node, BAD_CAST "direction", BAD_CAST "out");
-
-
- /* Add Properties interface */
- iface_node = xmlNewChild(root_node, NULL,
- BAD_CAST "interface", NULL);
- xmlNewProp(iface_node, BAD_CAST "name",
- BAD_CAST WPA_DBUS_PROPERTIES_INTERFACE);
-
- /* Add Get method */
- method_node = xmlNewChild(iface_node, NULL, BAD_CAST "method", NULL);
- xmlNewProp(method_node, BAD_CAST "name",
- BAD_CAST WPA_DBUS_PROPERTIES_GET);
- arg_node = xmlNewChild(method_node, NULL, BAD_CAST "arg", NULL);
- xmlNewProp(arg_node, BAD_CAST "name", BAD_CAST "interface");
- xmlNewProp(arg_node, BAD_CAST "type", BAD_CAST "s");
- xmlNewProp(arg_node, BAD_CAST "direction", BAD_CAST "in");
- arg_node = xmlNewChild(method_node, NULL, BAD_CAST "arg", NULL);
- xmlNewProp(arg_node, BAD_CAST "name", BAD_CAST "propname");
- xmlNewProp(arg_node, BAD_CAST "type", BAD_CAST "s");
- xmlNewProp(arg_node, BAD_CAST "direction", BAD_CAST "in");
- arg_node = xmlNewChild(method_node, NULL, BAD_CAST "arg", NULL);
- xmlNewProp(arg_node, BAD_CAST "name", BAD_CAST "value");
- xmlNewProp(arg_node, BAD_CAST "type", BAD_CAST "v");
- xmlNewProp(arg_node, BAD_CAST "direction", BAD_CAST "out");
- method_node = xmlNewChild(iface_node, NULL, BAD_CAST "method", NULL);
-
- /* Add GetAll method */
- xmlNewProp(method_node, BAD_CAST "name",
- BAD_CAST WPA_DBUS_PROPERTIES_GETALL);
- arg_node = xmlNewChild(method_node, NULL, BAD_CAST "arg", NULL);
- xmlNewProp(arg_node, BAD_CAST "name", BAD_CAST "interface");
- xmlNewProp(arg_node, BAD_CAST "type", BAD_CAST "s");
- xmlNewProp(arg_node, BAD_CAST "direction", BAD_CAST "in");
- arg_node = xmlNewChild(method_node, NULL, BAD_CAST "arg", NULL);
- xmlNewProp(arg_node, BAD_CAST "name", BAD_CAST "props");
- xmlNewProp(arg_node, BAD_CAST "type", BAD_CAST "a{sv}");
- xmlNewProp(arg_node, BAD_CAST "direction", BAD_CAST "out");
- method_node = xmlNewChild(iface_node, NULL, BAD_CAST "method", NULL);
-
- /* Add Set method */
- xmlNewProp(method_node, BAD_CAST "name",
- BAD_CAST WPA_DBUS_PROPERTIES_SET);
- arg_node = xmlNewChild(method_node, NULL, BAD_CAST "arg", NULL);
- xmlNewProp(arg_node, BAD_CAST "name", BAD_CAST "interface");
- xmlNewProp(arg_node, BAD_CAST "type", BAD_CAST "s");
- xmlNewProp(arg_node, BAD_CAST "direction", BAD_CAST "in");
- arg_node = xmlNewChild(method_node, NULL, BAD_CAST "arg", NULL);
- xmlNewProp(arg_node, BAD_CAST "name", BAD_CAST "propname");
- xmlNewProp(arg_node, BAD_CAST "type", BAD_CAST "s");
- xmlNewProp(arg_node, BAD_CAST "direction", BAD_CAST "in");
- arg_node = xmlNewChild(method_node, NULL, BAD_CAST "arg", NULL);
- xmlNewProp(arg_node, BAD_CAST "name", BAD_CAST "value");
- xmlNewProp(arg_node, BAD_CAST "type", BAD_CAST "v");
- xmlNewProp(arg_node, BAD_CAST "direction", BAD_CAST "in");
-
- /* get all interfaces registered with object */
- ifaces = extract_interfaces(obj_dsc, root_node);
-
- /* create methods' nodes */
- method_dsc = obj_dsc->methods;
- while (method_dsc) {
-
- struct interfaces *iface = ifaces;
- while (iface) {
- if (!os_strcmp(iface->dbus_interface,
- method_dsc->dbus_interface))
- break;
- iface = iface->next;
- }
- if (!iface)
- continue;
-
- iface_node = iface->interface_node;
- method_node = xmlNewChild(iface_node, NULL, BAD_CAST "method",
- NULL);
- xmlNewProp(method_node, BAD_CAST "name",
- BAD_CAST method_dsc->dbus_method);
-
- /* create args' nodes */
- for (i = 0; i < method_dsc->args_num; i++) {
- struct wpa_dbus_argument arg = method_dsc->args[i];
- arg_node = xmlNewChild(method_node, NULL,
- BAD_CAST "arg", NULL);
- if (arg.name && strlen(arg.name)) {
- xmlNewProp(arg_node, BAD_CAST "name",
- BAD_CAST arg.name);
- }
- xmlNewProp(arg_node, BAD_CAST "type",
- BAD_CAST arg.type);
- xmlNewProp(arg_node, BAD_CAST "direction",
- BAD_CAST (arg.dir == ARG_IN ?
- "in" : "out"));
- }
- method_dsc = method_dsc->next;
- }
-
- /* create signals' nodes */
- signal_dsc = obj_dsc->signals;
- while (signal_dsc) {
-
- struct interfaces *iface = ifaces;
- while (iface) {
- if (!os_strcmp(iface->dbus_interface,
- signal_dsc->dbus_interface))
- break;
- iface = iface->next;
- }
- if (!iface)
- continue;
-
- iface_node = iface->interface_node;
- signal_node = xmlNewChild(iface_node, NULL, BAD_CAST "signal",
- NULL);
- xmlNewProp(signal_node, BAD_CAST "name",
- BAD_CAST signal_dsc->dbus_signal);
-
- /* create args' nodes */
- for (i = 0; i < signal_dsc->args_num; i++) {
- struct wpa_dbus_argument arg = signal_dsc->args[i];
- arg_node = xmlNewChild(signal_node, NULL,
- BAD_CAST "arg", NULL);
- if (arg.name && strlen(arg.name)) {
- xmlNewProp(arg_node, BAD_CAST "name",
- BAD_CAST arg.name);
- }
- xmlNewProp(arg_node, BAD_CAST "type",
- BAD_CAST arg.type);
- }
- signal_dsc = signal_dsc->next;
- }
-
- /* create properties' nodes */
- property_dsc = obj_dsc->properties;
- while (property_dsc) {
-
- struct interfaces *iface = ifaces;
- while (iface) {
- if (!os_strcmp(iface->dbus_interface,
- property_dsc->dbus_interface))
- break;
- iface = iface->next;
- }
- if (!iface)
- continue;
-
- iface_node = iface->interface_node;
- property_node = xmlNewChild(iface_node, NULL,
- BAD_CAST "property", NULL);
- xmlNewProp(property_node, BAD_CAST "name",
- BAD_CAST property_dsc->dbus_property);
- xmlNewProp(property_node, BAD_CAST "type",
- BAD_CAST property_dsc->type);
- xmlNewProp(property_node, BAD_CAST "access", BAD_CAST
- (property_dsc->access == R ? "read" :
- (property_dsc->access == W ?
- "write" : "readwrite")));
-
- property_dsc = property_dsc->next;
- }
-
- /* add child nodes to introspection tree; */
- dbus_connection_list_registered(obj_dsc->connection,
- dbus_message_get_path(message),
- &children);
- for (i = 0; children[i]; i++) {
- node = xmlNewChild(root_node, NULL, BAD_CAST "node", NULL);
- xmlNewProp(node, BAD_CAST "name", BAD_CAST children[i]);
- }
- dbus_free_string_array(children);
-
-
- xmlDocDumpFormatMemory(doc, &intro_str, &s, 1);
-
- xmlFreeDoc(doc);
-
- while (ifaces) {
- tmp = ifaces;
- ifaces = ifaces->next;
- os_free(tmp->dbus_interface);
- os_free(tmp);
- }
-
- reply = dbus_message_new_method_return(message);
- if (reply == NULL) {
- xmlFree(intro_str);
- return NULL;
- }
-
- dbus_message_append_args(reply, DBUS_TYPE_STRING, &intro_str,
- DBUS_TYPE_INVALID);
-
- xmlFree(intro_str);
-
- return reply;
-}
-
-#else /* CONFIG_CTRL_IFACE_DBUS_INTRO */
-
-/**
- * introspect - Responds for Introspect calls on object
- * @message: Message with Introspect call
- * @obj_dsc: Object description on which Introspect was called
- * Returns: Message with introspection result XML string as only argument
- *
- * Returns error informing that introspection support was not compiled.
- */
-static DBusMessage * introspect(DBusMessage *message,
- struct wpa_dbus_object_desc *obj_dsc)
-{
- return dbus_message_new_error(message, DBUS_ERROR_UNKNOWN_METHOD,
- "wpa_supplicant was compiled without "
- "introspection support.");
-}
-
-#endif /* CONFIG_CTRL_IFACE_DBUS_INTRO */
-
-
-/**
- * recursive_iter_copy - Reads arguments from one iterator and
- * writes to another recursively
- * @from: iterator to read from
- * @to: iterator to write to
- *
- * Copies one iterator's elements to another. If any element in
- * iterator is of container type, its content is copied recursively
- */
-static void recursive_iter_copy(DBusMessageIter *from, DBusMessageIter *to)
-{
-
- char *subtype = NULL;
- int type;
-
- /* iterate over iterator to copy */
- while ((type = dbus_message_iter_get_arg_type (from)) !=
- DBUS_TYPE_INVALID) {
-
- /* simply copy basic type entries */
- if (dbus_type_is_basic(type)) {
- if (dbus_type_is_fixed(type)) {
- /*
- * According to DBus documentation all
- * fixed-length types are guaranteed to fit
- * 8 bytes
- */
- dbus_uint64_t v;
- dbus_message_iter_get_basic (from, &v);
- dbus_message_iter_append_basic (to, type, &v);
- } else {
- char *v;
- dbus_message_iter_get_basic (from, &v);
- dbus_message_iter_append_basic (to, type, &v);
- }
- } else {
- /* recursively copy container type entries */
- DBusMessageIter write_subiter, read_subiter;
-
- dbus_message_iter_recurse(from, &read_subiter);
-
- if (type == DBUS_TYPE_VARIANT ||
- type == DBUS_TYPE_ARRAY) {
- subtype = dbus_message_iter_get_signature(
- &read_subiter);
- }
-
- dbus_message_iter_open_container(to, type, subtype,
- &write_subiter);
-
- recursive_iter_copy(&read_subiter, &write_subiter);
-
- dbus_message_iter_close_container(to, &write_subiter);
- if (subtype)
- dbus_free(subtype);
- }
-
- dbus_message_iter_next(from);
- }
-}
-
-
-static unsigned int fill_dict_with_properties(
- DBusMessageIter *dict_iter, struct wpa_dbus_property_desc *props,
- const char *interface, const void *user_data)
-{
- DBusMessage *reply;
- DBusMessageIter entry_iter, ret_iter;
- unsigned int counter = 0;
- struct wpa_dbus_property_desc *property_dsc;
-
- for (property_dsc = props; property_dsc;
- property_dsc = property_dsc->next) {
- if (!os_strncmp(property_dsc->dbus_interface, interface,
- WPAS_DBUS_INTERFACE_MAX) &&
- property_dsc->access != W && property_dsc->getter) {
- reply = property_dsc->getter(NULL, user_data);
- if (!reply)
- continue;
-
- if (dbus_message_get_type(reply) ==
- DBUS_MESSAGE_TYPE_ERROR) {
- dbus_message_unref(reply);
- continue;
- }
-
- dbus_message_iter_init(reply, &ret_iter);
-
- dbus_message_iter_open_container(dict_iter,
- DBUS_TYPE_DICT_ENTRY,
- NULL, &entry_iter);
- dbus_message_iter_append_basic(
- &entry_iter, DBUS_TYPE_STRING,
- &(property_dsc->dbus_property));
-
- recursive_iter_copy(&ret_iter, &entry_iter);
-
- dbus_message_iter_close_container(dict_iter,
- &entry_iter);
- dbus_message_unref(reply);
- counter++;
- }
- }
-
- return counter;
+error:
+ dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
+ return FALSE;
}
* specified as argument. Returned message contains one dict argument
* with properties names as keys and theirs values as values.
*/
-static DBusMessage * get_all_properties(
- DBusMessage *message, char *interface,
- struct wpa_dbus_object_desc *obj_dsc)
+static DBusMessage * get_all_properties(DBusMessage *message, char *interface,
+ struct wpa_dbus_object_desc *obj_dsc)
{
- /* Create and initialize the return message */
- DBusMessage *reply = dbus_message_new_method_return(message);
+ DBusMessage *reply;
DBusMessageIter iter, dict_iter;
- int props_num;
-
- dbus_message_iter_init_append(reply, &iter);
+ DBusError error;
- dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
- DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
- DBUS_TYPE_STRING_AS_STRING
- DBUS_TYPE_VARIANT_AS_STRING
- DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
- &dict_iter);
+ reply = dbus_message_new_method_return(message);
+ if (reply == NULL)
+ return wpas_dbus_error_no_memory(message);
- props_num = fill_dict_with_properties(&dict_iter,obj_dsc->properties,
- interface, obj_dsc->user_data);
+ dbus_message_iter_init_append(reply, &iter);
+ if (!wpa_dbus_dict_open_write(&iter, &dict_iter)) {
+ dbus_message_unref(reply);
+ return wpas_dbus_error_no_memory(message);
+ }
- dbus_message_iter_close_container(&iter, &dict_iter);
+ dbus_error_init(&error);
+ if (!fill_dict_with_properties(&dict_iter, obj_dsc->properties,
+ interface, obj_dsc->user_data, &error)) {
+ dbus_message_unref(reply);
+ reply = wpas_dbus_reply_new_from_error(
+ message, &error, DBUS_ERROR_INVALID_ARGS,
+ "No readable properties in this interface");
+ dbus_error_free(&error);
+ return reply;
+ }
- if (props_num == 0) {
+ if (!wpa_dbus_dict_close_write(&iter, &dict_iter)) {
dbus_message_unref(reply);
- reply = dbus_message_new_error(message,
- DBUS_ERROR_INVALID_ARGS,
- "No readable properties in "
- "this interface");
+ return wpas_dbus_error_no_memory(message);
}
return reply;
static int is_signature_correct(DBusMessage *message,
- struct wpa_dbus_method_desc *method_dsc)
+ const struct wpa_dbus_method_desc *method_dsc)
{
/* According to DBus documentation max length of signature is 255 */
#define MAX_SIG_LEN 256
char registered_sig[MAX_SIG_LEN], *pos;
const char *sig = dbus_message_get_signature(message);
- int i, ret;
+ int ret;
+ const struct wpa_dbus_argument *arg;
pos = registered_sig;
*pos = '\0';
- for (i = 0; i < method_dsc->args_num; i++) {
- struct wpa_dbus_argument arg = method_dsc->args[i];
- if (arg.dir == ARG_IN) {
+ for (arg = method_dsc->args; arg && arg->name; arg++) {
+ if (arg->dir == ARG_IN) {
size_t blen = registered_sig + MAX_SIG_LEN - pos;
- ret = os_snprintf(pos, blen, "%s", arg.type);
- if (ret < 0 || (size_t) ret >= blen)
+
+ ret = os_snprintf(pos, blen, "%s", arg->type);
+ if (os_snprintf_error(blen, ret))
return 0;
pos += ret;
}
static DBusMessage * properties_get(DBusMessage *message,
- struct wpa_dbus_property_desc *dsc,
+ const struct wpa_dbus_property_desc *dsc,
void *user_data)
{
- if (os_strcmp(dbus_message_get_signature(message), "ss"))
+ DBusMessage *reply;
+ DBusMessageIter iter;
+ DBusError error;
+
+ if (os_strcmp(dbus_message_get_signature(message), "ss")) {
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
NULL);
+ }
+
+ if (dsc->getter == NULL) {
+ return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
+ "Property is write-only");
+ }
- if (dsc->access != W && dsc->getter)
- return dsc->getter(message, user_data);
+ reply = dbus_message_new_method_return(message);
+ dbus_message_iter_init_append(reply, &iter);
- return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
- "Property is write-only");
+ dbus_error_init(&error);
+ if (dsc->getter(dsc, &iter, &error, user_data) == FALSE) {
+ dbus_message_unref(reply);
+ reply = wpas_dbus_reply_new_from_error(
+ message, &error, DBUS_ERROR_FAILED,
+ "Failed to read property");
+ dbus_error_free(&error);
+ }
+
+ return reply;
}
static DBusMessage * properties_set(DBusMessage *message,
- struct wpa_dbus_property_desc *dsc,
+ const struct wpa_dbus_property_desc *dsc,
void *user_data)
{
- if (os_strcmp(dbus_message_get_signature(message), "ssv"))
+ DBusMessage *reply;
+ DBusMessageIter iter;
+ DBusError error;
+
+ if (os_strcmp(dbus_message_get_signature(message), "ssv")) {
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
NULL);
+ }
+
+ if (dsc->setter == NULL) {
+ return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
+ "Property is read-only");
+ }
+
+ dbus_message_iter_init(message, &iter);
+ /* Skip the interface name and the property name */
+ dbus_message_iter_next(&iter);
+ dbus_message_iter_next(&iter);
- if (dsc->access != R && dsc->setter)
- return dsc->setter(message, user_data);
+ /* Iter will now point to the property's new value */
+ dbus_error_init(&error);
+ if (dsc->setter(dsc, &iter, &error, user_data) == TRUE) {
+ /* Success */
+ reply = dbus_message_new_method_return(message);
+ } else {
+ reply = wpas_dbus_reply_new_from_error(
+ message, &error, DBUS_ERROR_FAILED,
+ "Failed to set property");
+ dbus_error_free(&error);
+ }
- return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
- "Property is read-only");
+ return reply;
}
char *interface,
struct wpa_dbus_object_desc *obj_dsc)
{
- struct wpa_dbus_property_desc *property_dsc;
+ const struct wpa_dbus_property_desc *property_dsc;
char *property;
const char *method;
}
dbus_message_iter_get_basic(iter, &property);
- while (property_dsc) {
+ while (property_dsc && property_dsc->dbus_property) {
/* compare property names and
* interfaces */
if (!os_strncmp(property_dsc->dbus_property, property,
WPAS_DBUS_INTERFACE_MAX))
break;
- property_dsc = property_dsc->next;
+ property_dsc++;
}
- if (property_dsc == NULL) {
+ if (property_dsc == NULL || property_dsc->dbus_property == NULL) {
wpa_printf(MSG_DEBUG, "no property handler for %s.%s on %s",
interface, property,
dbus_message_get_path(message));
}
if (os_strncmp(WPA_DBUS_PROPERTIES_GET, method,
- WPAS_DBUS_METHOD_SIGNAL_PROP_MAX) == 0)
+ WPAS_DBUS_METHOD_SIGNAL_PROP_MAX) == 0) {
+ wpa_printf(MSG_MSGDUMP, "%s: Get(%s)", __func__, property);
return properties_get(message, property_dsc,
obj_dsc->user_data);
+ }
+ wpa_printf(MSG_MSGDUMP, "%s: Set(%s)", __func__, property);
return properties_set(message, property_dsc, obj_dsc->user_data);
}
!os_strncmp(WPA_DBUS_PROPERTIES_GETALL, method,
WPAS_DBUS_METHOD_SIGNAL_PROP_MAX)) {
/* First argument: interface name (DBUS_TYPE_STRING) */
- if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
- {
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) {
return dbus_message_new_error(message,
DBUS_ERROR_INVALID_ARGS,
NULL);
static DBusMessage * msg_method_handler(DBusMessage *message,
struct wpa_dbus_object_desc *obj_dsc)
{
- struct wpa_dbus_method_desc *method_dsc = obj_dsc->methods;
+ const struct wpa_dbus_method_desc *method_dsc = obj_dsc->methods;
const char *method;
const char *msg_interface;
msg_interface = dbus_message_get_interface(message);
/* try match call to any registered method */
- while (method_dsc) {
+ while (method_dsc && method_dsc->dbus_method) {
/* compare method names and interfaces */
if (!os_strncmp(method_dsc->dbus_method, method,
WPAS_DBUS_METHOD_SIGNAL_PROP_MAX) &&
WPAS_DBUS_INTERFACE_MAX))
break;
- method_dsc = method_dsc->next;
+ method_dsc++;
}
- if (method_dsc == NULL) {
+ if (method_dsc == NULL || method_dsc->dbus_method == NULL) {
wpa_printf(MSG_DEBUG, "no method handler for %s.%s on %s",
msg_interface, method,
dbus_message_get_path(message));
NULL);
}
- return method_dsc->method_handler(message,
- obj_dsc->user_data);
+ return method_dsc->method_handler(message, obj_dsc->user_data);
}
if (!method || !path || !msg_interface)
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
- wpa_printf(MSG_MSGDUMP, "dbus: %s.%s (%s)",
- msg_interface, method, path);
+ wpa_printf(MSG_MSGDUMP, "dbus: %s.%s (%s) [%s]",
+ msg_interface, method, path,
+ dbus_message_get_signature(message));
/* if message is introspection method call */
if (!os_strncmp(WPA_DBUS_INTROSPECTION_METHOD, method,
WPAS_DBUS_METHOD_SIGNAL_PROP_MAX) &&
!os_strncmp(WPA_DBUS_INTROSPECTION_INTERFACE, msg_interface,
- WPAS_DBUS_INTERFACE_MAX))
- reply = introspect(message, obj_dsc);
- else if (!os_strncmp(WPA_DBUS_PROPERTIES_INTERFACE, msg_interface,
+ WPAS_DBUS_INTERFACE_MAX)) {
+#ifdef CONFIG_CTRL_IFACE_DBUS_INTRO
+ reply = wpa_dbus_introspect(message, obj_dsc);
+#else /* CONFIG_CTRL_IFACE_DBUS_INTRO */
+ reply = dbus_message_new_error(
+ message, DBUS_ERROR_UNKNOWN_METHOD,
+ "wpa_supplicant was compiled without introspection support.");
+#endif /* CONFIG_CTRL_IFACE_DBUS_INTRO */
+ } else if (!os_strncmp(WPA_DBUS_PROPERTIES_INTERFACE, msg_interface,
WPAS_DBUS_INTERFACE_MAX)) {
/* if message is properties method call */
reply = properties_handler(message, obj_dsc);
dbus_connection_send(connection, reply, NULL);
dbus_message_unref(reply);
}
+
+ wpa_dbus_flush_all_changed_properties(connection);
+
return DBUS_HANDLER_RESULT_HANDLED;
}
*/
void free_dbus_object_desc(struct wpa_dbus_object_desc *obj_dsc)
{
- struct wpa_dbus_method_desc *method_dsc, *tmp_met_dsc;
- struct wpa_dbus_signal_desc *signal_dsc, *tmp_sig_dsc;
- struct wpa_dbus_property_desc *property_dsc, *tmp_prop_dsc;
- int i;
-
if (!obj_dsc)
return;
- /* free methods */
- method_dsc = obj_dsc->methods;
-
- while (method_dsc) {
- tmp_met_dsc = method_dsc;
- method_dsc = method_dsc->next;
-
- os_free(tmp_met_dsc->dbus_interface);
- os_free(tmp_met_dsc->dbus_method);
-
- for (i = 0; i < tmp_met_dsc->args_num; i++) {
- os_free(tmp_met_dsc->args[i].name);
- os_free(tmp_met_dsc->args[i].type);
- }
-
- os_free(tmp_met_dsc);
- }
-
- /* free signals */
- signal_dsc = obj_dsc->signals;
-
- while (signal_dsc) {
- tmp_sig_dsc = signal_dsc;
- signal_dsc = signal_dsc->next;
-
- os_free(tmp_sig_dsc->dbus_interface);
- os_free(tmp_sig_dsc->dbus_signal);
-
- for (i = 0; i < tmp_sig_dsc->args_num; i++) {
- os_free(tmp_sig_dsc->args[i].name);
- os_free(tmp_sig_dsc->args[i].type);
- }
-
- os_free(tmp_sig_dsc);
- }
-
- /* free properties */
- property_dsc = obj_dsc->properties;
-
- while (property_dsc) {
- tmp_prop_dsc = property_dsc;
- property_dsc = property_dsc->next;
-
- os_free(tmp_prop_dsc->dbus_interface);
- os_free(tmp_prop_dsc->dbus_property);
- os_free(tmp_prop_dsc->type);
-
- os_free(tmp_prop_dsc);
- }
-
/* free handler's argument */
if (obj_dsc->user_data_free_func)
obj_dsc->user_data_free_func(obj_dsc->user_data);
+ os_free(obj_dsc->path);
+ os_free(obj_dsc->prop_changed_flags);
os_free(obj_dsc);
}
free_dbus_object_desc(obj_dsc);
}
+
/**
* wpa_dbus_ctrl_iface_init - Initialize dbus control interface
* @application_data: Pointer to application specific data structure
};
obj_desc->connection = iface->con;
+ obj_desc->path = os_strdup(dbus_path);
/* Register the message handler for the global dbus interface */
- if (!dbus_connection_register_object_path(iface->con,
- dbus_path, &wpa_vtable,
- obj_desc)) {
- perror("dbus_connection_register_object_path[dbus]");
- wpa_printf(MSG_ERROR, "Could not set up DBus message "
- "handler.");
+ if (!dbus_connection_register_object_path(iface->con, dbus_path,
+ &wpa_vtable, obj_desc)) {
+ wpa_printf(MSG_ERROR, "dbus: Could not set up message handler");
return -1;
}
/* Register our service with the message bus */
dbus_error_init(&error);
- switch (dbus_bus_request_name(iface->con, dbus_service,
- 0, &error)) {
+ switch (dbus_bus_request_name(iface->con, dbus_service, 0, &error)) {
case DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER:
ret = 0;
break;
case DBUS_REQUEST_NAME_REPLY_EXISTS:
case DBUS_REQUEST_NAME_REPLY_IN_QUEUE:
case DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER:
- perror("dbus_bus_request_name[dbus]");
- wpa_printf(MSG_ERROR, "Could not request DBus service name: "
- "already registered.");
+ wpa_printf(MSG_ERROR,
+ "dbus: Could not request service name: already registered");
break;
default:
- perror("dbus_bus_request_name[dbus]");
- wpa_printf(MSG_ERROR, "Could not request DBus service name: "
- "%s %s.", error.name, error.message);
+ wpa_printf(MSG_ERROR,
+ "dbus: Could not request service name: %s %s",
+ error.name, error.message);
break;
}
dbus_error_free(&error);
*
* Registers a new interface with dbus and assigns it a dbus object path.
*/
-int wpa_dbus_register_object_per_iface(
- struct wpas_dbus_priv *ctrl_iface,
- const char *path, const char *ifname,
- struct wpa_dbus_object_desc *obj_desc)
+int wpa_dbus_register_object_per_iface(struct wpas_dbus_priv *ctrl_iface,
+ const char *path, const char *ifname,
+ struct wpa_dbus_object_desc *obj_desc)
{
DBusConnection *con;
-
+ DBusError error;
DBusObjectPathVTable vtable = {
&free_dbus_object_desc_cb, &message_handler,
NULL, NULL, NULL, NULL
con = ctrl_iface->con;
obj_desc->connection = con;
+ obj_desc->path = os_strdup(path);
+ dbus_error_init(&error);
/* Register the message handler for the interface functions */
- if (!dbus_connection_register_object_path(con, path, &vtable,
- obj_desc)) {
- perror("wpa_dbus_register_iface [dbus]");
- wpa_printf(MSG_ERROR, "Could not set up DBus message "
- "handler for interface %s\n"
- "and object %s.", ifname, path);
+ if (!dbus_connection_try_register_object_path(con, path, &vtable,
+ obj_desc, &error)) {
+ if (os_strcmp(error.name, DBUS_ERROR_OBJECT_PATH_IN_USE) == 0) {
+ wpa_printf(MSG_DEBUG, "dbus: %s", error.message);
+ } else {
+ wpa_printf(MSG_ERROR,
+ "dbus: Could not set up message handler for interface %s object %s (error: %s message: %s)",
+ ifname, path, error.name, error.message);
+ }
+ dbus_error_free(&error);
return -1;
}
+ dbus_error_free(&error);
return 0;
}
+static void flush_object_timeout_handler(void *eloop_ctx, void *timeout_ctx);
+
+
/**
* wpa_dbus_unregister_object_per_iface - Unregisters DBus object
* @ctrl_iface: Pointer to dbus private data
struct wpas_dbus_priv *ctrl_iface, const char *path)
{
DBusConnection *con = ctrl_iface->con;
+ struct wpa_dbus_object_desc *obj_desc = NULL;
+
+ dbus_connection_get_object_path_data(con, path, (void **) &obj_desc);
+ if (!obj_desc) {
+ wpa_printf(MSG_ERROR,
+ "dbus: %s: Could not obtain object's private data: %s",
+ __func__, path);
+ return 0;
+ }
+
+ eloop_cancel_timeout(flush_object_timeout_handler, con, obj_desc);
+
if (!dbus_connection_unregister_object_path(con, path))
return -1;
}
-/**
- * wpa_dbus_method_register - Registers DBus method for given object
- * @obj_dsc: Object description for which a method will be registered
- * @dbus_interface: DBus interface under which method will be registered
- * @dbus_method: a name the method will be registered with
- * @method_handler: a function which will be called to handle this method call
- * @args: method arguments list
- * Returns: Zero on success and -1 on failure
- *
- * Registers DBus method under given name and interface for the object.
- * Method calls will be handled with given handling function.
- * Handler function is required to return a DBusMessage pointer which
- * will be response to method call. Any method call before being handled
- * must have registered appropriate handler by using this function.
- */
-int wpa_dbus_method_register(struct wpa_dbus_object_desc *obj_dsc,
- const char *dbus_interface,
- const char *dbus_method,
- WPADBusMethodHandler method_handler,
- const struct wpa_dbus_argument args[])
+static dbus_bool_t put_changed_properties(
+ const struct wpa_dbus_object_desc *obj_dsc, const char *interface,
+ DBusMessageIter *dict_iter, int clear_changed)
{
- struct wpa_dbus_method_desc *method_dsc = obj_dsc->methods;
- struct wpa_dbus_method_desc *prev_desc;
- int args_num = 0;
- int interface_len, method_len, i, len, error;
-
- prev_desc = NULL;
- while (method_dsc) {
- prev_desc = method_dsc;
- method_dsc = method_dsc->next;
- }
-
- /* count args */
- if (args) {
- while (args[args_num].name && args[args_num].type)
- args_num++;
- }
+ DBusMessageIter entry_iter;
+ const struct wpa_dbus_property_desc *dsc;
+ int i;
+ DBusError error;
- method_dsc = os_zalloc(sizeof(struct wpa_dbus_method_desc) +
- args_num * sizeof(struct wpa_dbus_argument));
- if (!method_dsc)
- goto err;
-
- if (prev_desc == NULL)
- obj_dsc->methods = method_dsc;
- else
- prev_desc->next = method_dsc;
-
- /* copy interface name */
- interface_len = os_strlen(dbus_interface) + 1;
- method_dsc->dbus_interface = os_malloc(interface_len);
- if (!method_dsc->dbus_interface)
- goto err;
- os_strncpy(method_dsc->dbus_interface, dbus_interface, interface_len);
-
- /* copy method name */
- method_len = os_strlen(dbus_method) + 1;
- method_dsc->dbus_method = os_malloc(method_len);
- if (!method_dsc->dbus_method)
- goto err;
- os_strncpy(method_dsc->dbus_method, dbus_method, method_len);
-
- /* copy arguments */
- error = 0;
- method_dsc->args_num = args_num;
- for (i = 0; i < args_num; i++) {
- len = os_strlen(args[i].name) + 1;
- method_dsc->args[i].name = os_malloc(len);
- if (!method_dsc->args[i].name) {
- error = 1;
+ for (dsc = obj_dsc->properties, i = 0; dsc && dsc->dbus_property;
+ dsc++, i++) {
+ if (obj_dsc->prop_changed_flags == NULL ||
+ !obj_dsc->prop_changed_flags[i])
continue;
- }
- os_strncpy(method_dsc->args[i].name, args[i].name, len);
-
- len = os_strlen(args[i].type) + 1;
- method_dsc->args[i].type = os_malloc(len);
- if (!method_dsc->args[i].type) {
- error = 1;
+ if (os_strcmp(dsc->dbus_interface, interface) != 0)
continue;
+ if (clear_changed)
+ obj_dsc->prop_changed_flags[i] = 0;
+
+ if (!dbus_message_iter_open_container(dict_iter,
+ DBUS_TYPE_DICT_ENTRY,
+ NULL, &entry_iter) ||
+ !dbus_message_iter_append_basic(&entry_iter,
+ DBUS_TYPE_STRING,
+ &dsc->dbus_property))
+ return FALSE;
+
+ dbus_error_init(&error);
+ if (!dsc->getter(dsc, &entry_iter, &error, obj_dsc->user_data))
+ {
+ if (dbus_error_is_set(&error)) {
+ wpa_printf(MSG_ERROR,
+ "dbus: %s: Cannot get new value of property %s: (%s) %s",
+ __func__, dsc->dbus_property,
+ error.name, error.message);
+ } else {
+ wpa_printf(MSG_ERROR,
+ "dbus: %s: Cannot get new value of property %s",
+ __func__, dsc->dbus_property);
+ }
+ dbus_error_free(&error);
+ return FALSE;
}
- os_strncpy(method_dsc->args[i].type, args[i].type, len);
- method_dsc->args[i].dir = args[i].dir;
+ if (!dbus_message_iter_close_container(dict_iter, &entry_iter))
+ return FALSE;
}
- if (error)
- goto err;
- method_dsc->method_handler = method_handler;
- method_dsc->next = NULL;
+ return TRUE;
+}
- return 0;
-err:
- wpa_printf(MSG_WARNING, "Failed to register dbus method %s in "
- "interface %s", dbus_method, dbus_interface);
- if (method_dsc) {
- os_free(method_dsc->dbus_interface);
- os_free(method_dsc->dbus_method);
- for (i = 0; i < method_dsc->args_num; i++) {
- os_free(method_dsc->args[i].name);
- os_free(method_dsc->args[i].type);
- }
+static void do_send_prop_changed_signal(
+ DBusConnection *con, const char *path, const char *interface,
+ const struct wpa_dbus_object_desc *obj_dsc)
+{
+ DBusMessage *msg;
+ DBusMessageIter signal_iter, dict_iter;
- if (prev_desc == NULL)
- obj_dsc->methods = NULL;
- else
- prev_desc->next = NULL;
+ msg = dbus_message_new_signal(path, DBUS_INTERFACE_PROPERTIES,
+ "PropertiesChanged");
+ if (msg == NULL)
+ return;
- os_free(method_dsc);
+ dbus_message_iter_init_append(msg, &signal_iter);
+
+ if (!dbus_message_iter_append_basic(&signal_iter, DBUS_TYPE_STRING,
+ &interface) ||
+ /* Changed properties dict */
+ !dbus_message_iter_open_container(&signal_iter, DBUS_TYPE_ARRAY,
+ "{sv}", &dict_iter) ||
+ !put_changed_properties(obj_dsc, interface, &dict_iter, 0) ||
+ !dbus_message_iter_close_container(&signal_iter, &dict_iter) ||
+ /* Invalidated properties array (empty) */
+ !dbus_message_iter_open_container(&signal_iter, DBUS_TYPE_ARRAY,
+ "s", &dict_iter) ||
+ !dbus_message_iter_close_container(&signal_iter, &dict_iter)) {
+ wpa_printf(MSG_DEBUG, "dbus: %s: Failed to construct signal",
+ __func__);
+ } else {
+ dbus_connection_send(con, msg, NULL);
}
- return -1;
+ dbus_message_unref(msg);
}
-/**
- * wpa_dbus_signal_register - Registers DBus signal for given object
- * @obj_dsc: Object description for which a signal will be registered
- * @dbus_interface: DBus interface under which signal will be registered
- * @dbus_signal: a name the signal will be registered with
- * @args: signal arguments list
- * Returns: Zero on success and -1 on failure
- *
- * Registers DBus signal under given name and interface for the object.
- * Signal registration is NOT required in order to send signals, but not
- * registered signals will not be respected in introspection data
- * therefore it is highly recommended to register every signal before
- * using it.
- */
-int wpa_dbus_signal_register(struct wpa_dbus_object_desc *obj_dsc,
- const char *dbus_interface,
- const char *dbus_signal,
- const struct wpa_dbus_argument args[])
+static void do_send_deprecated_prop_changed_signal(
+ DBusConnection *con, const char *path, const char *interface,
+ const struct wpa_dbus_object_desc *obj_dsc)
{
+ DBusMessage *msg;
+ DBusMessageIter signal_iter, dict_iter;
- struct wpa_dbus_signal_desc *signal_dsc = obj_dsc->signals;
- struct wpa_dbus_signal_desc *prev_desc;
- int args_num = 0;
- int interface_len, signal_len, i, len, error = 0;
-
- prev_desc = NULL;
- while (signal_dsc) {
- prev_desc = signal_dsc;
- signal_dsc = signal_dsc->next;
- }
-
- /* count args */
- if (args) {
- while (args[args_num].name && args[args_num].type)
- args_num++;
- }
+ msg = dbus_message_new_signal(path, interface, "PropertiesChanged");
+ if (msg == NULL)
+ return;
- signal_dsc = os_zalloc(sizeof(struct wpa_dbus_signal_desc) +
- args_num * sizeof(struct wpa_dbus_argument));
- if (!signal_dsc)
- goto err;
-
- if (prev_desc == NULL)
- obj_dsc->signals = signal_dsc;
- else
- prev_desc->next = signal_dsc;
-
- /* copy interface name */
- interface_len = strlen(dbus_interface) + 1;
- signal_dsc->dbus_interface = os_malloc(interface_len);
- if (!signal_dsc->dbus_interface)
- goto err;
- os_strncpy(signal_dsc->dbus_interface, dbus_interface, interface_len);
-
- /* copy signal name */
- signal_len = strlen(dbus_signal) + 1;
- signal_dsc->dbus_signal = os_malloc(signal_len);
- if (!signal_dsc->dbus_signal)
- goto err;
- os_strncpy(signal_dsc->dbus_signal, dbus_signal, signal_len);
-
- /* copy arguments */
- signal_dsc->args_num = args_num;
- for (i = 0; i < args_num; i++) {
- len = os_strlen(args[i].name) + 1;
- signal_dsc->args[i].name = os_malloc(len);
- if (!signal_dsc->args[i].name) {
- error = 1;
- continue;
- }
- os_strncpy(signal_dsc->args[i].name, args[i].name, len);
+ dbus_message_iter_init_append(msg, &signal_iter);
- len = strlen(args[i].type) + 1;
- signal_dsc->args[i].type = os_malloc(len);
- if (!signal_dsc->args[i].type) {
- error = 1;
- continue;
- }
- os_strncpy(signal_dsc->args[i].type, args[i].type, len);
+ if (!dbus_message_iter_open_container(&signal_iter, DBUS_TYPE_ARRAY,
+ "{sv}", &dict_iter) ||
+ !put_changed_properties(obj_dsc, interface, &dict_iter, 1) ||
+ !dbus_message_iter_close_container(&signal_iter, &dict_iter)) {
+ wpa_printf(MSG_DEBUG, "dbus: %s: Failed to construct signal",
+ __func__);
+ } else {
+ dbus_connection_send(con, msg, NULL);
}
- if (error)
- goto err;
- signal_dsc->next = NULL;
+ dbus_message_unref(msg);
+}
- return 0;
-err:
- wpa_printf(MSG_WARNING, "Failed to register dbus signal %s in "
- "interface %s", dbus_signal, dbus_interface);
- if (signal_dsc) {
- os_free(signal_dsc->dbus_interface);
- os_free(signal_dsc->dbus_signal);
- for (i = 0; i < signal_dsc->args_num; i++) {
- os_free(signal_dsc->args[i].name);
- os_free(signal_dsc->args[i].type);
- }
+static void send_prop_changed_signal(
+ DBusConnection *con, const char *path, const char *interface,
+ const struct wpa_dbus_object_desc *obj_dsc)
+{
+ /*
+ * First, send property change notification on the standardized
+ * org.freedesktop.DBus.Properties interface. This call will not
+ * clear the property change bits, so that they are preserved for
+ * the call that follows.
+ */
+ do_send_prop_changed_signal(con, path, interface, obj_dsc);
+
+ /*
+ * Now send PropertiesChanged on our own interface for backwards
+ * compatibility. This is deprecated and will be removed in a future
+ * release.
+ */
+ do_send_deprecated_prop_changed_signal(con, path, interface, obj_dsc);
+
+ /* Property change bits have now been cleared. */
+}
- if (prev_desc == NULL)
- obj_dsc->signals = NULL;
- else
- prev_desc->next = NULL;
- os_free(signal_dsc);
- }
+static void flush_object_timeout_handler(void *eloop_ctx, void *timeout_ctx)
+{
+ DBusConnection *con = eloop_ctx;
+ struct wpa_dbus_object_desc *obj_desc = timeout_ctx;
- return -1;
+ wpa_printf(MSG_DEBUG,
+ "dbus: %s: Timeout - sending changed properties of object %s",
+ __func__, obj_desc->path);
+ wpa_dbus_flush_object_changed_properties(con, obj_desc->path);
}
-/**
- * wpa_dbus_property_register - Registers DBus property for given object
- * @obj_dsc: Object description for which a property will be registered
- * @dbus_interface: DBus interface under which method will be registered
- * @dbus_property: a name the property will be registered with
- * @type: a property type signature in form of DBus type description
- * @getter: a function called in order to get property value
- * @setter: a function called in order to set property value
- * @access: property access permissions specifier (R, W or RW)
- * Returns: Zero on success and -1 on failure
- *
- * Registers DBus property under given name and interface for the object.
- * Properties are set with giver setter function and get with getter.Getter
- * or setter are required to return DBusMessage which is response to Set/Get
- * method calls. Every property must be registered by this function before
- * being used.
- */
-int wpa_dbus_property_register(struct wpa_dbus_object_desc *obj_dsc,
- const char *dbus_interface,
- const char *dbus_property,
- const char *type,
- WPADBusPropertyAccessor getter,
- WPADBusPropertyAccessor setter,
- enum dbus_prop_access _access)
+static void recursive_flush_changed_properties(DBusConnection *con,
+ const char *path)
{
- struct wpa_dbus_property_desc *property_dsc = obj_dsc->properties;
- struct wpa_dbus_property_desc *prev_desc;
- int interface_len, property_len, type_len;
-
- prev_desc = NULL;
- while (property_dsc) {
- prev_desc = property_dsc;
- property_dsc = property_dsc->next;
- }
-
- property_dsc = os_zalloc(sizeof(struct wpa_dbus_property_desc));
- if (!property_dsc)
- goto err;
-
- if (prev_desc == NULL)
- obj_dsc->properties = property_dsc;
- else
- prev_desc->next = property_dsc;
-
- /* copy interface name */
- interface_len = os_strlen(dbus_interface) + 1;
- property_dsc->dbus_interface = os_malloc(interface_len);
- if (!property_dsc->dbus_interface)
- goto err;
- os_strncpy(property_dsc->dbus_interface, dbus_interface,
- interface_len);
-
- /* copy property name */
- property_len = os_strlen(dbus_property) + 1;
- property_dsc->dbus_property = os_malloc(property_len);
- if (!property_dsc->dbus_property)
- goto err;
- os_strncpy(property_dsc->dbus_property, dbus_property, property_len);
-
- /* copy property type */
- type_len = os_strlen(type) + 1;
- property_dsc->type = os_malloc(type_len);
- if (!property_dsc->type)
- goto err;
- os_strncpy(property_dsc->type, type, type_len);
-
- property_dsc->getter = getter;
- property_dsc->setter = setter;
- property_dsc->access = _access;
- property_dsc->next = NULL;
-
- return 0;
+ char **objects = NULL;
+ char subobj_path[WPAS_DBUS_OBJECT_PATH_MAX];
+ int i;
-err:
- wpa_printf(MSG_WARNING, "Failed to register dbus property %s in "
- "interface %s", dbus_property, dbus_interface);
- if (property_dsc) {
- os_free(property_dsc->dbus_interface);
- os_free(property_dsc->dbus_property);
- os_free(property_dsc->type);
+ wpa_dbus_flush_object_changed_properties(con, path);
- if (prev_desc == NULL)
- obj_dsc->properties = NULL;
- else
- prev_desc->next = NULL;
+ if (!dbus_connection_list_registered(con, path, &objects))
+ goto out;
- os_free(property_dsc);
+ for (i = 0; objects[i]; i++) {
+ os_snprintf(subobj_path, WPAS_DBUS_OBJECT_PATH_MAX,
+ "%s/%s", path, objects[i]);
+ recursive_flush_changed_properties(con, subobj_path);
}
- return -1;
+out:
+ dbus_free_string_array(objects);
}
/**
- * wpas_dbus_signal_network_added - Send a property changed signal
- * @iface: dbus priv struct
- * @property_getter: propperty getter used to fetch new property value
- * @getter_arg: argument passed to property getter
- * @path: path to object which property has changed
- * @interface_name: signal and property interface
- * @property_name: name of property which has changed
+ * wpa_dbus_flush_all_changed_properties - Send all PropertiesChanged signals
+ * @con: DBus connection
*
- * Notify listeners about changing value of some property. Signal
- * contains property name and its value fetched using given property
- * getter.
+ * Traverses through all registered objects and sends PropertiesChanged for
+ * each properties.
*/
-void wpa_dbus_signal_property_changed(struct wpas_dbus_priv *iface,
- WPADBusPropertyAccessor property_getter,
- void *getter_arg,
- const char *path,
- const char *interface_name,
- const char *property_name)
+void wpa_dbus_flush_all_changed_properties(DBusConnection *con)
{
+ recursive_flush_changed_properties(con, WPAS_DBUS_NEW_PATH);
+}
- DBusConnection *connection;
- DBusMessage *_signal, *getter_reply;
- DBusMessageIter prop_iter, signal_iter, dict_iter, entry_iter;
- if (!iface)
- return;
- connection = iface->con;
+/**
+ * wpa_dbus_flush_object_changed_properties - Send PropertiesChanged for object
+ * @con: DBus connection
+ * @path: path to a DBus object for which PropertiesChanged will be sent.
+ *
+ * Iterates over all properties registered with object and for each interface
+ * containing properties marked as changed, sends a PropertiesChanged signal
+ * containing names and new values of properties that have changed.
+ *
+ * You need to call this function after wpa_dbus_mark_property_changed()
+ * if you want to send PropertiesChanged signal immediately (i.e., without
+ * waiting timeout to expire). PropertiesChanged signal for an object is sent
+ * automatically short time after first marking property as changed. All
+ * PropertiesChanged signals are sent automatically after responding on DBus
+ * message, so if you marked a property changed as a result of DBus call
+ * (e.g., param setter), you usually do not need to call this function.
+ */
+void wpa_dbus_flush_object_changed_properties(DBusConnection *con,
+ const char *path)
+{
+ struct wpa_dbus_object_desc *obj_desc = NULL;
+ const struct wpa_dbus_property_desc *dsc;
+ int i;
- if (!property_getter) {
- wpa_printf(MSG_ERROR, "wpa_dbus_signal_property_changed"
- "[dbus]: property getter not specified");
+ dbus_connection_get_object_path_data(con, path, (void **) &obj_desc);
+ if (!obj_desc)
return;
- }
+ eloop_cancel_timeout(flush_object_timeout_handler, con, obj_desc);
- if (!path || !interface_name || !property_name) {
- wpa_printf(MSG_ERROR, "wpa_dbus_signal_property_changed"
- "[dbus]: path interface of property not specified");
- return;
+ for (dsc = obj_desc->properties, i = 0; dsc && dsc->dbus_property;
+ dsc++, i++) {
+ if (obj_desc->prop_changed_flags == NULL ||
+ !obj_desc->prop_changed_flags[i])
+ continue;
+ send_prop_changed_signal(con, path, dsc->dbus_interface,
+ obj_desc);
}
+}
- getter_reply = property_getter(NULL, getter_arg);
- if (!getter_reply ||
- dbus_message_get_type(getter_reply) == DBUS_MESSAGE_TYPE_ERROR) {
- wpa_printf(MSG_ERROR, "wpa_dbus_signal_property_changed"
- "[dbus]: cannot get new value of property %s",
- property_name);
- return;
- }
- _signal = dbus_message_new_signal(path, interface_name,
- "PropertiesChanged");
- if (!_signal) {
- wpa_printf(MSG_ERROR, "wpa_dbus_signal_property_changed"
- "[dbus]: cannot allocate signal");
- dbus_message_unref(getter_reply);
- return;
- }
+#define WPA_DBUS_SEND_PROP_CHANGED_TIMEOUT 5000
- dbus_message_iter_init(getter_reply, &prop_iter);
- dbus_message_iter_init_append(_signal, &signal_iter);
- if (!dbus_message_iter_open_container(&signal_iter, DBUS_TYPE_ARRAY,
- "{sv}", &dict_iter)) {
- wpa_printf(MSG_ERROR, "wpa_dbus_signal_property_changed"
- "[dbus]: out of memory. cannot open dictionary");
- goto err;
- }
+/**
+ * wpa_dbus_mark_property_changed - Mark a property as changed and
+ * @iface: dbus priv struct
+ * @path: path to DBus object which property has changed
+ * @interface: interface containing changed property
+ * @property: property name which has changed
+ *
+ * Iterates over all properties registered with an object and marks the one
+ * given in parameters as changed. All parameters registered for an object
+ * within a single interface will be aggregated together and sent in one
+ * PropertiesChanged signal when function
+ * wpa_dbus_flush_object_changed_properties() is called.
+ */
+void wpa_dbus_mark_property_changed(struct wpas_dbus_priv *iface,
+ const char *path, const char *interface,
+ const char *property)
+{
+ struct wpa_dbus_object_desc *obj_desc = NULL;
+ const struct wpa_dbus_property_desc *dsc;
+ int i = 0;
- if (!dbus_message_iter_open_container(&dict_iter, DBUS_TYPE_DICT_ENTRY,
- NULL, &entry_iter)) {
- wpa_printf(MSG_ERROR, "iwpa_dbus_signal_property_changed"
- "[dbus]: out of memory. cannot open dictionary "
- "element");
- goto err;
- }
+ if (iface == NULL)
+ return;
- if (!dbus_message_iter_append_basic(&entry_iter, DBUS_TYPE_STRING,
- &property_name)) {
- wpa_printf(MSG_ERROR, "wpa_dbus_signal_property_changed"
- "[dbus]: out of memory. cannot open add property "
- "name");
- goto err;
+ dbus_connection_get_object_path_data(iface->con, path,
+ (void **) &obj_desc);
+ if (!obj_desc) {
+ wpa_printf(MSG_ERROR,
+ "dbus: wpa_dbus_property_changed: could not obtain object's private data: %s",
+ path);
+ return;
}
- recursive_iter_copy(&prop_iter, &entry_iter);
+ for (dsc = obj_desc->properties; dsc && dsc->dbus_property; dsc++, i++)
+ if (os_strcmp(property, dsc->dbus_property) == 0 &&
+ os_strcmp(interface, dsc->dbus_interface) == 0) {
+ if (obj_desc->prop_changed_flags)
+ obj_desc->prop_changed_flags[i] = 1;
+ break;
+ }
- if (!dbus_message_iter_close_container(&dict_iter, &entry_iter)) {
- wpa_printf(MSG_ERROR, "wpa_dbus_signal_property_changed"
- "[dbus]: out of memory. cannot close dictionary "
- "element");
- goto err;
+ if (!dsc || !dsc->dbus_property) {
+ wpa_printf(MSG_ERROR,
+ "dbus: wpa_dbus_property_changed: no property %s in object %s",
+ property, path);
+ return;
}
- if (!dbus_message_iter_close_container(&signal_iter, &dict_iter)) {
- wpa_printf(MSG_ERROR, "wpa_dbus_signal_property_changed"
- "[dbus]: out of memory. cannot close dictionary");
- goto err;
+ if (!eloop_is_timeout_registered(flush_object_timeout_handler,
+ iface->con, obj_desc)) {
+ eloop_register_timeout(0, WPA_DBUS_SEND_PROP_CHANGED_TIMEOUT,
+ flush_object_timeout_handler,
+ iface->con, obj_desc);
}
-
- dbus_connection_send(connection, _signal, NULL);
-
-err:
- dbus_message_unref(getter_reply);
- dbus_message_unref(_signal);
-
}
* @iface: dbus priv struct
* @path: path to DBus object which properties will be obtained
* @interface: interface name which properties will be obtained
- * @dict_iter: correct, open DBus dictionary iterator.
+ * @iter: DBus message iter at which to append property dictionary.
*
* Iterates over all properties registered with object and execute getters
* of those, which are readable and which interface matches interface
* specified as argument. Obtained properties values are stored in
* dict_iter dictionary.
*/
-void wpa_dbus_get_object_properties(struct wpas_dbus_priv *iface,
- const char *path, const char *interface,
- DBusMessageIter *dict_iter)
+dbus_bool_t wpa_dbus_get_object_properties(struct wpas_dbus_priv *iface,
+ const char *path,
+ const char *interface,
+ DBusMessageIter *iter)
{
struct wpa_dbus_object_desc *obj_desc = NULL;
+ DBusMessageIter dict_iter;
+ DBusError error;
dbus_connection_get_object_path_data(iface->con, path,
(void **) &obj_desc);
if (!obj_desc) {
- wpa_printf(MSG_ERROR, "dbus: wpa_dbus_get_object_properties: "
- "could not obtain object's private data: %s", path);
- return;
+ wpa_printf(MSG_ERROR,
+ "dbus: %s: could not obtain object's private data: %s",
+ __func__, path);
+ return FALSE;
+ }
+
+ if (!wpa_dbus_dict_open_write(iter, &dict_iter)) {
+ wpa_printf(MSG_ERROR, "dbus: %s: failed to open message dict",
+ __func__);
+ return FALSE;
}
- fill_dict_with_properties(dict_iter, obj_desc->properties,
- interface, obj_desc->user_data);
+ dbus_error_init(&error);
+ if (!fill_dict_with_properties(&dict_iter, obj_desc->properties,
+ interface, obj_desc->user_data,
+ &error)) {
+ wpa_printf(MSG_ERROR,
+ "dbus: %s: failed to get object properties: (%s) %s",
+ __func__,
+ dbus_error_is_set(&error) ? error.name : "none",
+ dbus_error_is_set(&error) ? error.message : "none");
+ dbus_error_free(&error);
+ return FALSE;
+ }
+
+ return wpa_dbus_dict_close_write(iter, &dict_iter);
+}
+
+/**
+ * wpas_dbus_new_decompose_object_path - Decompose an interface object path into parts
+ * @path: The dbus object path
+ * @sep: Separating part (e.g., "Networks" or "PersistentGroups")
+ * @item: (out) The part following the specified separator, if any
+ * Returns: The object path of the interface this path refers to
+ *
+ * For a given object path, decomposes the object path into object id and
+ * requested part, if those parts exist. The caller is responsible for freeing
+ * the returned value. The *item pointer points to that allocated value and must
+ * not be freed separately.
+ *
+ * As an example, path = "/fi/w1/wpa_supplicant1/Interfaces/1/Networks/0" and
+ * sep = "Networks" would result in "/fi/w1/wpa_supplicant1/Interfaces/1"
+ * getting returned and *items set to point to "0".
+ */
+char * wpas_dbus_new_decompose_object_path(const char *path, const char *sep,
+ char **item)
+{
+ const unsigned int dev_path_prefix_len =
+ os_strlen(WPAS_DBUS_NEW_PATH_INTERFACES "/");
+ char *obj_path_only;
+ char *pos;
+ size_t sep_len;
+
+ *item = NULL;
+
+ /* Verify that this starts with our interface prefix */
+ if (os_strncmp(path, WPAS_DBUS_NEW_PATH_INTERFACES "/",
+ dev_path_prefix_len) != 0)
+ return NULL; /* not our path */
+
+ /* Ensure there's something at the end of the path */
+ if ((path + dev_path_prefix_len)[0] == '\0')
+ return NULL;
+
+ obj_path_only = os_strdup(path);
+ if (obj_path_only == NULL)
+ return NULL;
+
+ pos = obj_path_only + dev_path_prefix_len;
+ pos = os_strchr(pos, '/');
+ if (pos == NULL)
+ return obj_path_only; /* no next item on the path */
+
+ /* Separate network interface prefix from the path */
+ *pos++ = '\0';
+
+ sep_len = os_strlen(sep);
+ if (os_strncmp(pos, sep, sep_len) != 0 || pos[sep_len] != '/')
+ return obj_path_only; /* no match */
+
+ /* return a pointer to the requested item */
+ *item = pos + sep_len + 1;
+ return obj_path_only;
+}
+
+
+/**
+ * wpas_dbus_reply_new_from_error - Create a new D-Bus error message from a
+ * dbus error structure
+ * @message: The original request message for which the error is a reply
+ * @error: The error containing a name and a descriptive error cause
+ * @fallback_name: A generic error name if @error was not set
+ * @fallback_string: A generic error string if @error was not set
+ * Returns: A new D-Bus error message
+ *
+ * Given a DBusMessage structure, creates a new D-Bus error message using
+ * the error name and string contained in that structure.
+ */
+DBusMessage * wpas_dbus_reply_new_from_error(DBusMessage *message,
+ DBusError *error,
+ const char *fallback_name,
+ const char *fallback_string)
+{
+ if (error && error->name && error->message) {
+ return dbus_message_new_error(message, error->name,
+ error->message);
+ }
+ if (fallback_name && fallback_string) {
+ return dbus_message_new_error(message, fallback_name,
+ fallback_string);
+ }
+ return NULL;
}
projects / mech_eap.git / blobdiff