* See README and COPYING for more details.
*/
-#include "includes.h"
+#include "utils/includes.h"
-#include "common.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"
int type;
/* iterate over iterator to copy */
- while ((type = dbus_message_iter_get_arg_type (from)) !=
+ while ((type = dbus_message_iter_get_arg_type(from)) !=
DBUS_TYPE_INVALID) {
/* simply copy basic type entries */
* 8 bytes
*/
dbus_uint64_t v;
- dbus_message_iter_get_basic (from, &v);
- dbus_message_iter_append_basic (to, type, &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);
+ dbus_message_iter_get_basic(from, &v);
+ dbus_message_iter_append_basic(to, type, &v);
}
} else {
/* recursively copy container type entries */
static unsigned int fill_dict_with_properties(
- DBusMessageIter *dict_iter, struct wpa_dbus_property_desc *props,
+ DBusMessageIter *dict_iter, const 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;
+ const struct wpa_dbus_property_desc *dsc;
- for (property_dsc = props; property_dsc;
- property_dsc = property_dsc->next) {
- if (!os_strncmp(property_dsc->dbus_interface, interface,
+ for (dsc = props; dsc && dsc->dbus_property; dsc++) {
+ if (!os_strncmp(dsc->dbus_interface, interface,
WPAS_DBUS_INTERFACE_MAX) &&
- property_dsc->access != W && property_dsc->getter) {
- reply = property_dsc->getter(NULL, user_data);
+ dsc->access != W && dsc->getter) {
+ reply = dsc->getter(NULL, user_data);
if (!reply)
continue;
NULL, &entry_iter);
dbus_message_iter_append_basic(
&entry_iter, DBUS_TYPE_STRING,
- &(property_dsc->dbus_property));
+ &dsc->dbus_property);
recursive_iter_copy(&ret_iter, &entry_iter);
DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
&dict_iter);
- props_num = fill_dict_with_properties(&dict_iter,obj_dsc->properties,
+ props_num = fill_dict_with_properties(&dict_iter, obj_dsc->properties,
interface, obj_dsc->user_data);
dbus_message_iter_close_container(&iter, &dict_iter);
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);
+ ret = os_snprintf(pos, blen, "%s", arg->type);
if (ret < 0 || (size_t) ret >= blen)
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"))
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"))
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));
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));
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);
}
};
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.");
+ wpa_printf(MSG_ERROR, "dbus: Could not set up message "
+ "handler");
return -1;
}
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);
con = ctrl_iface->con;
obj_desc->connection = con;
+ obj_desc->path = os_strdup(path);
/* 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);
+ wpa_printf(MSG_ERROR, "dbus: Could not set up message "
+ "handler for interface %s object %s", ifname, path);
return -1;
}
}
+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);
+ } else {
+ 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 void put_changed_properties(const struct wpa_dbus_object_desc *obj_dsc,
+ const char *interface,
+ DBusMessageIter *dict_iter)
{
- struct wpa_dbus_method_desc *method_dsc = obj_dsc->methods;
- struct wpa_dbus_method_desc *prev_desc;
- int args_num = 0;
- int i, 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++;
- }
-
- 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 */
- method_dsc->dbus_interface = os_strdup(dbus_interface);
- if (!method_dsc->dbus_interface)
- goto err;
-
- /* copy method name */
- method_dsc->dbus_method = os_strdup(dbus_method);
- if (!method_dsc->dbus_method)
- goto err;
+ DBusMessage *getter_reply;
+ DBusMessageIter prop_iter, entry_iter;
+ const struct wpa_dbus_property_desc *dsc;
+ int i;
- /* copy arguments */
- error = 0;
- method_dsc->args_num = args_num;
- for (i = 0; i < args_num; i++) {
- method_dsc->args[i].name = os_strdup(args[i].name);
- 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;
- }
-
- method_dsc->args[i].type = os_strdup(args[i].type);
- if (!method_dsc->args[i].type) {
- error = 1;
+ if (os_strcmp(dsc->dbus_interface, interface) != 0)
+ continue;
+ obj_dsc->prop_changed_flags[i] = 0;
+
+ getter_reply = dsc->getter(NULL, obj_dsc->user_data);
+ if (!getter_reply ||
+ dbus_message_get_type(getter_reply) ==
+ DBUS_MESSAGE_TYPE_ERROR) {
+ wpa_printf(MSG_ERROR, "dbus: %s: Cannot get new value "
+ "of property %s", __func__,
+ dsc->dbus_property);
continue;
}
- method_dsc->args[i].dir = args[i].dir;
- }
- if (error)
- goto err;
-
- method_dsc->method_handler = method_handler;
- method_dsc->next = NULL;
+ if (!dbus_message_iter_init(getter_reply, &prop_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,
+ &dsc->dbus_property))
+ goto err;
- 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);
- }
+ recursive_iter_copy(&prop_iter, &entry_iter);
- if (prev_desc == NULL)
- obj_dsc->methods = NULL;
- else
- prev_desc->next = NULL;
+ if (!dbus_message_iter_close_container(dict_iter, &entry_iter))
+ goto err;
- os_free(method_dsc);
+ dbus_message_unref(getter_reply);
}
- return -1;
+ return;
+
+err:
+ wpa_printf(MSG_ERROR, "dbus: %s: Cannot construct signal", __func__);
}
-/**
- * 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 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;
- struct wpa_dbus_signal_desc *signal_dsc = obj_dsc->signals;
- struct wpa_dbus_signal_desc *prev_desc;
- int args_num = 0;
- int i, error = 0;
-
- prev_desc = NULL;
- while (signal_dsc) {
- prev_desc = signal_dsc;
- signal_dsc = signal_dsc->next;
- }
+ msg = dbus_message_new_signal(path, interface, "PropertiesChanged");
+ if (msg == NULL)
+ return;
- /* count args */
- if (args) {
- while (args[args_num].name && args[args_num].type)
- args_num++;
- }
+ dbus_message_iter_init_append(msg, &signal_iter);
- signal_dsc = os_zalloc(sizeof(struct wpa_dbus_signal_desc) +
- args_num * sizeof(struct wpa_dbus_argument));
- if (!signal_dsc)
+ if (!dbus_message_iter_open_container(&signal_iter, DBUS_TYPE_ARRAY,
+ "{sv}", &dict_iter))
goto err;
- if (prev_desc == NULL)
- obj_dsc->signals = signal_dsc;
- else
- prev_desc->next = signal_dsc;
+ put_changed_properties(obj_dsc, interface, &dict_iter);
- /* copy interface name */
- signal_dsc->dbus_interface = os_strdup(dbus_interface);
- if (!signal_dsc->dbus_interface)
+ if (!dbus_message_iter_close_container(&signal_iter, &dict_iter))
goto err;
- /* copy signal name */
- signal_dsc->dbus_signal = os_strdup(dbus_signal);
- if (!signal_dsc->dbus_signal)
- goto err;
+ dbus_connection_send(con, msg, NULL);
- /* copy arguments */
- signal_dsc->args_num = args_num;
- for (i = 0; i < args_num; i++) {
- signal_dsc->args[i].name = os_strdup(args[i].name);
- if (!signal_dsc->args[i].name) {
- error = 1;
- continue;
- }
-
- signal_dsc->args[i].type = os_strdup(args[i].type);
- if (!signal_dsc->args[i].type) {
- error = 1;
- continue;
- }
- }
- if (error)
- goto err;
-
- signal_dsc->next = NULL;
-
- return 0;
+out:
+ dbus_message_unref(msg);
+ return;
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);
- }
-
- if (prev_desc == NULL)
- obj_dsc->signals = NULL;
- else
- prev_desc->next = NULL;
-
- os_free(signal_dsc);
- }
-
- return -1;
+ wpa_printf(MSG_DEBUG, "dbus: %s: Failed to construct signal",
+ __func__);
+ goto out;
}
-/**
- * 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 flush_object_timeout_handler(void *eloop_ctx, void *timeout_ctx)
{
- struct wpa_dbus_property_desc *property_dsc = obj_dsc->properties;
- struct wpa_dbus_property_desc *prev_desc;
-
- 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;
+ DBusConnection *con = eloop_ctx;
+ struct wpa_dbus_object_desc *obj_desc = timeout_ctx;
- /* copy interface name */
- property_dsc->dbus_interface = os_strdup(dbus_interface);
- if (!property_dsc->dbus_interface)
- goto err;
+ 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);
+}
- /* copy property name */
- property_dsc->dbus_property = os_strdup(dbus_property);
- if (!property_dsc->dbus_property)
- goto err;
- /* copy property type */
- property_dsc->type = os_strdup(type);
- if (!property_dsc->type)
- goto err;
+static void recursive_flush_changed_properties(DBusConnection *con,
+ const char *path)
+{
+ char **objects = NULL;
+ char subobj_path[WPAS_DBUS_OBJECT_PATH_MAX];
+ int i;
- property_dsc->getter = getter;
- property_dsc->setter = setter;
- property_dsc->access = _access;
- property_dsc->next = NULL;
+ wpa_dbus_flush_object_changed_properties(con, path);
- return 0;
+ if (!dbus_connection_list_registered(con, path, &objects))
+ goto out;
-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);
-
- if (prev_desc == NULL)
- obj_dsc->properties = NULL;
- else
- prev_desc->next = NULL;
-
- 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;
+ dsc = obj_desc->properties;
+ 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->path)) {
+ 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);
-
}
projects / mech_eap.orig / blobdiff