2009-11-09 22:51:59 +01:00
|
|
|
/*
|
|
|
|
* WPA Supplicant / dbus-based control interface
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "includes.h"
|
|
|
|
|
|
|
|
#include "common.h"
|
|
|
|
#include "eloop.h"
|
|
|
|
#include "ctrl_iface_dbus_new_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;
|
|
|
|
/* handler function argument */
|
|
|
|
void *handler_argument;
|
|
|
|
/* function used to free handler argument */
|
|
|
|
WPADBusArgumentFreeFunction argument_free_func;
|
|
|
|
|
|
|
|
/* 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;
|
|
|
|
/* argument for getter and setter functions */
|
|
|
|
void *user_data;
|
|
|
|
/* function used to free accessors argument */
|
|
|
|
WPADBusArgumentFreeFunction user_data_free_func;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
#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 */
|
|
|
|
|
|
|
|
static void process_watch(struct ctrl_iface_dbus_new_priv *iface,
|
|
|
|
DBusWatch *watch, eloop_event_type type)
|
|
|
|
{
|
|
|
|
dbus_connection_ref(iface->con);
|
|
|
|
|
|
|
|
iface->should_dispatch = 0;
|
|
|
|
|
|
|
|
if (type == EVENT_TYPE_READ)
|
|
|
|
dbus_watch_handle(watch, DBUS_WATCH_READABLE);
|
|
|
|
else if (type == EVENT_TYPE_WRITE)
|
|
|
|
dbus_watch_handle(watch, DBUS_WATCH_WRITABLE);
|
|
|
|
else if (type == EVENT_TYPE_EXCEPTION)
|
|
|
|
dbus_watch_handle(watch, DBUS_WATCH_ERROR);
|
|
|
|
|
|
|
|
if (iface->should_dispatch) {
|
|
|
|
while (dbus_connection_get_dispatch_status(iface->con) ==
|
|
|
|
DBUS_DISPATCH_DATA_REMAINS)
|
|
|
|
dbus_connection_dispatch(iface->con);
|
|
|
|
iface->should_dispatch = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
dbus_connection_unref(iface->con);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void process_watch_exception(int sock, void *eloop_ctx, void *sock_ctx)
|
|
|
|
{
|
|
|
|
process_watch(eloop_ctx, sock_ctx, EVENT_TYPE_EXCEPTION);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void process_watch_read(int sock, void *eloop_ctx, void *sock_ctx)
|
|
|
|
{
|
|
|
|
process_watch(eloop_ctx, sock_ctx, EVENT_TYPE_READ);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void process_watch_write(int sock, void *eloop_ctx, void *sock_ctx)
|
|
|
|
{
|
|
|
|
process_watch(eloop_ctx, sock_ctx, EVENT_TYPE_WRITE);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void connection_setup_add_watch(struct ctrl_iface_dbus_new_priv *iface,
|
|
|
|
DBusWatch *watch)
|
|
|
|
{
|
|
|
|
unsigned int flags;
|
|
|
|
int fd;
|
|
|
|
|
|
|
|
if (!dbus_watch_get_enabled(watch))
|
|
|
|
return;
|
|
|
|
|
|
|
|
flags = dbus_watch_get_flags(watch);
|
|
|
|
fd = dbus_watch_get_unix_fd(watch);
|
|
|
|
|
|
|
|
eloop_register_sock(fd, EVENT_TYPE_EXCEPTION, process_watch_exception,
|
|
|
|
iface, watch);
|
|
|
|
|
|
|
|
if (flags & DBUS_WATCH_READABLE) {
|
|
|
|
eloop_register_sock(fd, EVENT_TYPE_READ, process_watch_read,
|
|
|
|
iface, watch);
|
|
|
|
}
|
|
|
|
if (flags & DBUS_WATCH_WRITABLE) {
|
|
|
|
eloop_register_sock(fd, EVENT_TYPE_WRITE, process_watch_write,
|
|
|
|
iface, watch);
|
|
|
|
}
|
|
|
|
|
|
|
|
dbus_watch_set_data(watch, iface, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void connection_setup_remove_watch(
|
|
|
|
struct ctrl_iface_dbus_new_priv *iface, DBusWatch *watch)
|
|
|
|
{
|
|
|
|
unsigned int flags;
|
|
|
|
int fd;
|
|
|
|
|
|
|
|
flags = dbus_watch_get_flags(watch);
|
|
|
|
fd = dbus_watch_get_unix_fd(watch);
|
|
|
|
|
|
|
|
eloop_unregister_sock(fd, EVENT_TYPE_EXCEPTION);
|
|
|
|
|
|
|
|
if (flags & DBUS_WATCH_READABLE)
|
|
|
|
eloop_unregister_sock(fd, EVENT_TYPE_READ);
|
|
|
|
if (flags & DBUS_WATCH_WRITABLE)
|
|
|
|
eloop_unregister_sock(fd, EVENT_TYPE_WRITE);
|
|
|
|
|
|
|
|
dbus_watch_set_data(watch, NULL, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static dbus_bool_t add_watch(DBusWatch *watch, void *data)
|
|
|
|
{
|
|
|
|
connection_setup_add_watch(data, watch);
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void remove_watch(DBusWatch *watch, void *data)
|
|
|
|
{
|
|
|
|
connection_setup_remove_watch(data, watch);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void watch_toggled(DBusWatch *watch, void *data)
|
|
|
|
{
|
|
|
|
if (dbus_watch_get_enabled(watch))
|
|
|
|
add_watch(watch, data);
|
|
|
|
else
|
|
|
|
remove_watch(watch, data);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void process_timeout(void *eloop_ctx, void *sock_ctx)
|
|
|
|
{
|
|
|
|
DBusTimeout *timeout = sock_ctx;
|
|
|
|
|
|
|
|
dbus_timeout_handle(timeout);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void connection_setup_add_timeout(
|
|
|
|
struct ctrl_iface_dbus_new_priv *iface, DBusTimeout *timeout)
|
|
|
|
{
|
|
|
|
if (!dbus_timeout_get_enabled(timeout))
|
|
|
|
return;
|
|
|
|
|
|
|
|
eloop_register_timeout(0, dbus_timeout_get_interval(timeout) * 1000,
|
|
|
|
process_timeout, iface, timeout);
|
|
|
|
|
|
|
|
dbus_timeout_set_data(timeout, iface, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void connection_setup_remove_timeout(
|
|
|
|
struct ctrl_iface_dbus_new_priv *iface, DBusTimeout *timeout)
|
|
|
|
{
|
|
|
|
eloop_cancel_timeout(process_timeout, iface, timeout);
|
|
|
|
dbus_timeout_set_data(timeout, NULL, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static dbus_bool_t add_timeout(DBusTimeout *timeout, void *data)
|
|
|
|
{
|
|
|
|
if (!dbus_timeout_get_enabled(timeout))
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
connection_setup_add_timeout(data, timeout);
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void remove_timeout(DBusTimeout *timeout, void *data)
|
|
|
|
{
|
|
|
|
connection_setup_remove_timeout(data, timeout);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void timeout_toggled(DBusTimeout *timeout, void *data)
|
|
|
|
{
|
|
|
|
if (dbus_timeout_get_enabled(timeout))
|
|
|
|
add_timeout(timeout, data);
|
|
|
|
else
|
|
|
|
remove_timeout(timeout, data);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void process_wakeup_main(int sig, void *eloop_ctx, void *signal_ctx)
|
|
|
|
{
|
|
|
|
struct ctrl_iface_dbus_new_priv *iface = signal_ctx;
|
|
|
|
|
|
|
|
if (sig != SIGPOLL || !iface->con)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (dbus_connection_get_dispatch_status(iface->con) !=
|
|
|
|
DBUS_DISPATCH_DATA_REMAINS)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Only dispatch once - we do not want to starve other events */
|
|
|
|
dbus_connection_ref(iface->con);
|
|
|
|
dbus_connection_dispatch(iface->con);
|
|
|
|
dbus_connection_unref(iface->con);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* wakeup_main - Attempt to wake our mainloop up
|
|
|
|
* @data: dbus control interface private data
|
|
|
|
*
|
|
|
|
* Try to wake up the main eloop so it will process
|
|
|
|
* dbus events that may have happened.
|
|
|
|
*/
|
|
|
|
static void wakeup_main(void *data)
|
|
|
|
{
|
|
|
|
struct ctrl_iface_dbus_new_priv *iface = data;
|
|
|
|
|
|
|
|
/* Use SIGPOLL to break out of the eloop select() */
|
|
|
|
raise(SIGPOLL);
|
|
|
|
iface->should_dispatch = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* connection_setup_wakeup_main - Tell dbus about our wakeup_main function
|
|
|
|
* @iface: dbus control interface private data
|
|
|
|
* Returns: 0 on success, -1 on failure
|
|
|
|
*
|
|
|
|
* Register our wakeup_main handler with dbus
|
|
|
|
*/
|
|
|
|
static int connection_setup_wakeup_main(struct ctrl_iface_dbus_new_priv *iface)
|
|
|
|
{
|
|
|
|
if (eloop_register_signal(SIGPOLL, process_wakeup_main, iface))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
dbus_connection_set_wakeup_main_function(iface->con, wakeup_main,
|
|
|
|
iface, NULL);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* wpa_dbus_next_objid - Return next available object id
|
|
|
|
* @iface: dbus control interface private data
|
|
|
|
* Returns: Object id
|
|
|
|
*/
|
|
|
|
u32 wpa_dbus_next_objid(struct ctrl_iface_dbus_new_priv *iface)
|
|
|
|
{
|
|
|
|
return iface->next_objid++;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* integrate_with_eloop - Register our mainloop integration with dbus
|
|
|
|
* @connection: connection to the system message bus
|
|
|
|
* @iface: a dbus control interface data structure
|
|
|
|
* Returns: 0 on success, -1 on failure
|
|
|
|
*
|
|
|
|
* We register our mainloop integration functions with dbus here.
|
|
|
|
*/
|
|
|
|
static int integrate_with_eloop(DBusConnection *connection,
|
|
|
|
struct ctrl_iface_dbus_new_priv *iface)
|
|
|
|
{
|
|
|
|
if (!dbus_connection_set_watch_functions(connection, add_watch,
|
|
|
|
remove_watch, watch_toggled,
|
|
|
|
iface, NULL)) {
|
|
|
|
perror("dbus_connection_set_watch_functions[dbus]");
|
|
|
|
wpa_printf(MSG_ERROR, "Not enough memory to set up dbus.");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!dbus_connection_set_timeout_functions(connection, add_timeout,
|
|
|
|
remove_timeout,
|
|
|
|
timeout_toggled, iface,
|
|
|
|
NULL)) {
|
|
|
|
perror("dbus_connection_set_timeout_functions[dbus]");
|
|
|
|
wpa_printf(MSG_ERROR, "Not enough memory to set up dbus.");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (connection_setup_wakeup_main(iface) < 0) {
|
|
|
|
perror("connection_setup_wakeup_main[dbus]");
|
|
|
|
wpa_printf(MSG_ERROR, "Could not setup main wakeup function.");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* dispatch_initial_dbus_messages - Dispatch initial dbus messages after
|
|
|
|
* claiming bus name
|
|
|
|
* @eloop_ctx: the DBusConnection to dispatch on
|
|
|
|
* @timeout_ctx: unused
|
|
|
|
*
|
|
|
|
* If clients are quick to notice that service claimed its bus name,
|
|
|
|
* there may have been messages that came in before initialization was
|
|
|
|
* all finished. Dispatch those here.
|
|
|
|
*/
|
|
|
|
static void dispatch_initial_dbus_messages(void *eloop_ctx, void *timeout_ctx)
|
|
|
|
{
|
|
|
|
DBusConnection *con = eloop_ctx;
|
|
|
|
|
|
|
|
while (dbus_connection_get_dispatch_status(con) ==
|
|
|
|
DBUS_DISPATCH_DATA_REMAINS)
|
|
|
|
dbus_connection_dispatch(con);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#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)
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
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;
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 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);
|
|
|
|
|
|
|
|
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 = NULL;
|
|
|
|
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;
|
2009-11-10 15:48:21 +01:00
|
|
|
xmlChar *intro_str;
|
2009-11-09 22:51:59 +01:00
|
|
|
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;
|
|
|
|
|
|
|
|
/* Create and initialize the return message */
|
|
|
|
reply = dbus_message_new_method_return(message);
|
|
|
|
|
|
|
|
/* 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);
|
|
|
|
|
|
|
|
|
2009-11-10 15:48:21 +01:00
|
|
|
xmlDocDumpFormatMemory(doc, &intro_str, &s, 1);
|
2009-11-09 22:51:59 +01:00
|
|
|
|
|
|
|
xmlFreeDoc(doc);
|
|
|
|
|
|
|
|
while (ifaces) {
|
|
|
|
tmp = ifaces;
|
|
|
|
ifaces = ifaces->next;
|
|
|
|
os_free(tmp->dbus_interface);
|
|
|
|
os_free(tmp);
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* get_all_properties - Responds for GetAll properties calls on object
|
|
|
|
* @message: Message with GetAll call
|
|
|
|
* @interface: interface name which properties will be returned
|
|
|
|
* @property_dsc: list of object's properties
|
|
|
|
* Returns: Message with dict of variants as argument with properties values
|
|
|
|
*
|
|
|
|
* Iterates over all properties registered with object and execute getters
|
|
|
|
* of those, which are readable and which interface matches interface
|
|
|
|
* 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_property_desc *property_dsc)
|
|
|
|
{
|
|
|
|
/* Create and initialize the return message */
|
|
|
|
DBusMessage *reply = dbus_message_new_method_return(message);
|
|
|
|
DBusMessage *getterReply = NULL;
|
|
|
|
DBusMessageIter iter, dict_iter, entry_iter, ret_iter;
|
|
|
|
int counter = 0;
|
|
|
|
|
|
|
|
dbus_message_iter_init_append(reply, &iter);
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
while (property_dsc) {
|
|
|
|
if (!os_strncmp(property_dsc->dbus_interface, interface,
|
|
|
|
WPAS_DBUS_INTERFACE_MAX) &&
|
|
|
|
property_dsc->access != W && property_dsc->getter) {
|
|
|
|
|
|
|
|
getterReply = property_dsc->getter(
|
|
|
|
message, property_dsc->user_data);
|
|
|
|
dbus_message_iter_init(getterReply, &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(getterReply);
|
|
|
|
counter++;
|
|
|
|
}
|
|
|
|
property_dsc = property_dsc->next;
|
|
|
|
}
|
|
|
|
dbus_message_iter_close_container(&iter, &dict_iter);
|
|
|
|
|
|
|
|
if (counter == 0) {
|
|
|
|
dbus_message_unref(reply);
|
|
|
|
reply = dbus_message_new_error(message,
|
|
|
|
DBUS_ERROR_INVALID_ARGS,
|
|
|
|
"No readable properties in "
|
|
|
|
"this interface");
|
|
|
|
}
|
|
|
|
|
|
|
|
return reply;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-11-10 17:29:38 +01:00
|
|
|
static int is_signature_correct(DBusMessage *message,
|
2009-11-09 22:51:59 +01:00
|
|
|
struct wpa_dbus_method_desc *method_dsc)
|
|
|
|
{
|
|
|
|
/* According to DBus documentation max length of signature is 255 */
|
2009-11-10 17:29:38 +01:00
|
|
|
#define MAX_SIG_LEN 256
|
|
|
|
char registered_sig[MAX_SIG_LEN], *pos;
|
2009-11-09 22:51:59 +01:00
|
|
|
const char *sig = dbus_message_get_signature(message);
|
2009-11-10 17:29:38 +01:00
|
|
|
int i, ret;
|
2009-11-09 22:51:59 +01:00
|
|
|
|
2009-11-10 17:29:38 +01:00
|
|
|
pos = registered_sig;
|
|
|
|
*pos = '\0';
|
2009-11-09 22:51:59 +01:00
|
|
|
|
|
|
|
for (i = 0; i < method_dsc->args_num; i++) {
|
|
|
|
struct wpa_dbus_argument arg = method_dsc->args[i];
|
2009-11-10 17:29:38 +01:00
|
|
|
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)
|
|
|
|
return 0;
|
|
|
|
pos += ret;
|
|
|
|
}
|
2009-11-09 22:51:59 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return !os_strncmp(registered_sig, sig, MAX_SIG_LEN);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* message_handler - Handles incoming DBus messages
|
|
|
|
* @connection: DBus connection on which message was received
|
|
|
|
* @message: Received message
|
|
|
|
* @user_data: pointer to description of object to which message was sent
|
|
|
|
* Returns: Returns information whether message was handled or not
|
|
|
|
*
|
|
|
|
* Reads message interface and method name, then checks if they matches one
|
|
|
|
* of the special cases i.e. introspection call or properties get/getall/set
|
|
|
|
* methods and handles it. Else it iterates over registered methods list
|
|
|
|
* and tries to match method's name and interface to those read from message
|
|
|
|
* If appropriate method was found it's handler function is called and
|
|
|
|
* response is sent. Otherwise the DBUS_ERROR_UNKNOWN_METHOD error message
|
|
|
|
* will be sent.
|
|
|
|
*/
|
|
|
|
static DBusHandlerResult message_handler(DBusConnection *connection,
|
|
|
|
DBusMessage *message, void *user_data)
|
|
|
|
{
|
|
|
|
struct wpa_dbus_object_desc *obj_dsc = user_data;
|
|
|
|
const char *method;
|
|
|
|
const char *path;
|
|
|
|
const char *msg_interface;
|
|
|
|
|
|
|
|
#define MESSAGE_UNHANDLED (DBusMessage *) 1
|
|
|
|
|
|
|
|
DBusMessage *reply = MESSAGE_UNHANDLED;
|
|
|
|
|
|
|
|
/* get method, interface and path the message is addressed to */
|
|
|
|
method = dbus_message_get_member(message);
|
|
|
|
path = dbus_message_get_path(message);
|
|
|
|
msg_interface = dbus_message_get_interface(message);
|
|
|
|
if (!method || !path || !msg_interface)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* 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 (!strncmp(WPA_DBUS_PROPERTIES_INTERFACE, msg_interface,
|
|
|
|
WPAS_DBUS_INTERFACE_MAX)) {
|
|
|
|
/* if message is properties method call */
|
|
|
|
DBusMessageIter iter;
|
|
|
|
char *interface;
|
|
|
|
char *property;
|
|
|
|
|
|
|
|
dbus_message_iter_init(message, &iter);
|
|
|
|
|
|
|
|
if (!os_strncmp(WPA_DBUS_PROPERTIES_GET, method,
|
|
|
|
WPAS_DBUS_METHOD_SIGNAL_PROP_MAX) ||
|
|
|
|
!os_strncmp(WPA_DBUS_PROPERTIES_SET, method,
|
|
|
|
WPAS_DBUS_METHOD_SIGNAL_PROP_MAX) ||
|
|
|
|
!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) {
|
|
|
|
reply = dbus_message_new_error(
|
|
|
|
message, DBUS_ERROR_INVALID_ARGS,
|
|
|
|
NULL);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
dbus_message_iter_get_basic(&iter, &interface);
|
|
|
|
|
|
|
|
/* GetAll */
|
|
|
|
if (!os_strncmp(WPA_DBUS_PROPERTIES_GETALL, method,
|
|
|
|
WPAS_DBUS_METHOD_SIGNAL_PROP_MAX)) {
|
|
|
|
if (os_strcmp(dbus_message_get_signature(
|
|
|
|
message), "s"))
|
|
|
|
reply = dbus_message_new_error(
|
|
|
|
message,
|
|
|
|
DBUS_ERROR_INVALID_ARGS, NULL);
|
|
|
|
else
|
|
|
|
reply = get_all_properties(
|
|
|
|
message, interface,
|
|
|
|
obj_dsc->properties);
|
|
|
|
} else {
|
|
|
|
/* Get or Set */
|
|
|
|
struct wpa_dbus_property_desc *property_dsc;
|
|
|
|
property_dsc = obj_dsc->properties;
|
|
|
|
|
|
|
|
/* Second argument: property name
|
|
|
|
* (DBUS_TYPE_STRING) */
|
|
|
|
if (!dbus_message_iter_next(&iter) ||
|
|
|
|
dbus_message_iter_get_arg_type(&iter) !=
|
|
|
|
DBUS_TYPE_STRING) {
|
|
|
|
reply = dbus_message_new_error(
|
|
|
|
message,
|
|
|
|
DBUS_ERROR_INVALID_ARGS, NULL);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
dbus_message_iter_get_basic(&iter, &property);
|
|
|
|
|
|
|
|
while (property_dsc) {
|
|
|
|
/* compare property names and
|
|
|
|
* interfaces */
|
|
|
|
if (!os_strncmp(property_dsc->dbus_property,
|
|
|
|
property,
|
|
|
|
WPAS_DBUS_METHOD_SIGNAL_PROP_MAX) &&
|
|
|
|
!os_strncmp(property_dsc->dbus_interface, interface,
|
|
|
|
WPAS_DBUS_INTERFACE_MAX))
|
|
|
|
break;
|
|
|
|
|
|
|
|
property_dsc = property_dsc->next;
|
|
|
|
}
|
|
|
|
if (property_dsc) {
|
|
|
|
/* Get */
|
|
|
|
if (!os_strncmp(WPA_DBUS_PROPERTIES_GET, method,
|
|
|
|
WPAS_DBUS_METHOD_SIGNAL_PROP_MAX)) {
|
|
|
|
if (os_strcmp(dbus_message_get_signature(message), "ss"))
|
|
|
|
reply = dbus_message_new_error(message,
|
|
|
|
DBUS_ERROR_INVALID_ARGS, NULL);
|
|
|
|
else if (property_dsc->access != W &&
|
|
|
|
property_dsc->getter)
|
|
|
|
reply = property_dsc->getter(message,
|
|
|
|
property_dsc->user_data);
|
|
|
|
else
|
|
|
|
reply = dbus_message_new_error(message,
|
|
|
|
DBUS_ERROR_INVALID_ARGS,
|
|
|
|
"Property is write-only");
|
|
|
|
} else {
|
|
|
|
/* Set */
|
|
|
|
if (os_strcmp(dbus_message_get_signature(message), "ssv"))
|
|
|
|
reply = dbus_message_new_error(message,
|
|
|
|
DBUS_ERROR_INVALID_ARGS, NULL);
|
|
|
|
else if (property_dsc->access != R &&
|
|
|
|
property_dsc->setter) {
|
|
|
|
reply = property_dsc->setter
|
|
|
|
(message, property_dsc->user_data);
|
|
|
|
} else {
|
|
|
|
reply = dbus_message_new_error(message,
|
|
|
|
DBUS_ERROR_INVALID_ARGS,
|
|
|
|
"Property is read-only");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
wpa_printf(MSG_DEBUG, "no property handler for %s.%s\n"
|
|
|
|
"on %s", interface, property, path);
|
|
|
|
reply = dbus_message_new_error(message,
|
|
|
|
DBUS_ERROR_INVALID_ARGS,
|
|
|
|
"No such property");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
reply = dbus_message_new_error(
|
|
|
|
message, DBUS_ERROR_UNKNOWN_METHOD, NULL);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
struct wpa_dbus_method_desc *method_dsc = obj_dsc->methods;
|
|
|
|
|
|
|
|
/* try match call to any registered method */
|
|
|
|
while (method_dsc) {
|
|
|
|
/* compare method names and interfaces */
|
|
|
|
if (!os_strncmp(method_dsc->dbus_method, method,
|
|
|
|
WPAS_DBUS_METHOD_SIGNAL_PROP_MAX) &&
|
|
|
|
!os_strncmp(method_dsc->dbus_interface,
|
|
|
|
msg_interface,
|
|
|
|
WPAS_DBUS_INTERFACE_MAX))
|
|
|
|
break;
|
|
|
|
|
|
|
|
method_dsc = method_dsc->next;
|
|
|
|
}
|
|
|
|
if (method_dsc) {
|
|
|
|
if (is_signature_correct(message, method_dsc)) {
|
|
|
|
reply = method_dsc->method_handler(
|
|
|
|
message, method_dsc->handler_argument);
|
|
|
|
} else {
|
|
|
|
reply = dbus_message_new_error(
|
|
|
|
message, DBUS_ERROR_INVALID_ARGS,
|
|
|
|
NULL);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
wpa_printf(MSG_DEBUG, "no method handler for %s.%s "
|
|
|
|
"on %s", msg_interface, method, path);
|
|
|
|
reply = dbus_message_new_error(
|
|
|
|
message, DBUS_ERROR_UNKNOWN_METHOD, NULL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
/* If the message was handled, send back the reply */
|
|
|
|
if (reply != MESSAGE_UNHANDLED) {
|
|
|
|
/* If handler succeed returning NULL, reply empty message */
|
|
|
|
if (!reply)
|
|
|
|
reply = dbus_message_new_method_return(message);
|
|
|
|
if (reply) {
|
|
|
|
if (!dbus_message_get_no_reply(message))
|
|
|
|
dbus_connection_send(connection, reply, NULL);
|
|
|
|
dbus_message_unref(reply);
|
|
|
|
}
|
|
|
|
return DBUS_HANDLER_RESULT_HANDLED;
|
|
|
|
} else
|
|
|
|
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* free_dbus_object_desc - Frees object description data structure
|
|
|
|
* @connection: DBus connection
|
|
|
|
* @obj_dsc: Object description to free
|
|
|
|
*
|
|
|
|
* Frees each of properties, methods and signals description lists and
|
|
|
|
* the object description structure itself.
|
|
|
|
*/
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tmp_met_dsc->argument_free_func)
|
|
|
|
tmp_met_dsc->argument_free_func(
|
|
|
|
tmp_met_dsc->handler_argument);
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
if (tmp_prop_dsc->user_data_free_func)
|
|
|
|
tmp_prop_dsc->user_data_free_func(
|
|
|
|
tmp_prop_dsc->user_data);
|
|
|
|
|
|
|
|
os_free(tmp_prop_dsc);
|
|
|
|
}
|
|
|
|
|
|
|
|
os_free(obj_dsc);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void free_dbus_object_desc_cb(DBusConnection *connection, void *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
|
|
|
|
* @dbus_path: DBus path to interface object
|
|
|
|
* @dbus_service: DBus service name to register with
|
|
|
|
* @messageHandler: a pointer to function which will handle dbus messages
|
|
|
|
* coming on interface
|
|
|
|
* Returns: Pointer to dbus_new_ctrl_iface date or %NULL on failure
|
|
|
|
*
|
|
|
|
* Initialize the dbus control interface and start receiving commands from
|
|
|
|
* external programs over the bus.
|
|
|
|
*/
|
|
|
|
struct ctrl_iface_dbus_new_priv *
|
|
|
|
wpa_dbus_ctrl_iface_init(void *application_data,
|
|
|
|
char *dbus_path, char *dbus_service,
|
|
|
|
struct wpa_dbus_object_desc *obj_desc)
|
|
|
|
{
|
|
|
|
struct ctrl_iface_dbus_new_priv *iface;
|
|
|
|
DBusError error;
|
|
|
|
int ret = -1;
|
|
|
|
DBusObjectPathVTable wpa_vtable = {
|
|
|
|
&free_dbus_object_desc_cb, &message_handler,
|
|
|
|
NULL, NULL, NULL, NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
iface = os_zalloc(sizeof(struct ctrl_iface_dbus_new_priv));
|
|
|
|
if (iface == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
iface->application_data = application_data;
|
|
|
|
|
|
|
|
/* Get a reference to the system bus */
|
|
|
|
dbus_error_init(&error);
|
|
|
|
iface->con = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
|
|
|
|
dbus_error_free(&error);
|
|
|
|
if (!iface->con) {
|
|
|
|
perror("dbus_bus_get[ctrl_iface_dbus]");
|
|
|
|
wpa_printf(MSG_ERROR, "Could not acquire the system bus.");
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
obj_desc->connection = iface->con;
|
|
|
|
|
|
|
|
/* Tell dbus about our mainloop integration functions */
|
|
|
|
if (integrate_with_eloop(iface->con, iface))
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
/* 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.");
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Register our service with the message bus */
|
|
|
|
dbus_error_init(&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.");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
perror("dbus_bus_request_name[dbus]");
|
|
|
|
wpa_printf(MSG_ERROR, "Could not request DBus service name: "
|
|
|
|
"%s %s.", error.name, error.message);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
dbus_error_free(&error);
|
|
|
|
|
|
|
|
if (ret != 0)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
wpa_printf(MSG_DEBUG, "Providing DBus service '%s'.", dbus_service);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Dispatch initial DBus messages that may have come in since the bus
|
|
|
|
* name was claimed above. Happens when clients are quick to notice the
|
|
|
|
* service.
|
|
|
|
*
|
|
|
|
* FIXME: is there a better solution to this problem?
|
|
|
|
*/
|
|
|
|
eloop_register_timeout(0, 50, dispatch_initial_dbus_messages,
|
|
|
|
iface->con, NULL);
|
|
|
|
|
|
|
|
return iface;
|
|
|
|
|
|
|
|
fail:
|
|
|
|
wpa_dbus_ctrl_iface_deinit(iface);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* wpa_dbus_ctrl_iface_deinit - Deinitialize dbus ctrl interface
|
|
|
|
* @iface: Pointer to dbus private data from wpa_dbus_ctrl_iface_init()
|
|
|
|
*
|
|
|
|
* Deinitialize the dbus control interface that was initialized with
|
|
|
|
* wpa_dbus_ctrl_iface_init().
|
|
|
|
*/
|
|
|
|
void wpa_dbus_ctrl_iface_deinit(struct ctrl_iface_dbus_new_priv *iface)
|
|
|
|
{
|
|
|
|
if (iface == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (iface->con) {
|
|
|
|
eloop_cancel_timeout(dispatch_initial_dbus_messages,
|
|
|
|
iface->con, NULL);
|
|
|
|
dbus_connection_set_watch_functions(iface->con, NULL, NULL,
|
|
|
|
NULL, NULL, NULL);
|
|
|
|
dbus_connection_set_timeout_functions(iface->con, NULL, NULL,
|
|
|
|
NULL, NULL, NULL);
|
|
|
|
dbus_connection_unref(iface->con);
|
|
|
|
}
|
|
|
|
|
|
|
|
os_memset(iface, 0, sizeof(struct ctrl_iface_dbus_new_priv));
|
|
|
|
os_free(iface);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* wpa_dbus_register_object_per_iface - Register a new object with dbus
|
|
|
|
* @ctrl_iface: pointer to dbus private data
|
|
|
|
* @path: DBus path to object
|
|
|
|
* @ifname: interface name
|
|
|
|
* @obj_desc: description of object's methods, signals and properties
|
|
|
|
* Returns: 0 on success, -1 on error
|
|
|
|
*
|
|
|
|
* Registers a new interface with dbus and assigns it a dbus object path.
|
|
|
|
*/
|
|
|
|
int wpa_dbus_register_object_per_iface(
|
|
|
|
struct ctrl_iface_dbus_new_priv *ctrl_iface,
|
|
|
|
const char *path, const char *ifname,
|
|
|
|
struct wpa_dbus_object_desc *obj_desc)
|
|
|
|
{
|
|
|
|
DBusConnection *con;
|
|
|
|
|
|
|
|
DBusObjectPathVTable vtable = {
|
|
|
|
&free_dbus_object_desc_cb, &message_handler,
|
|
|
|
NULL, NULL, NULL, NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Do nothing if the control interface is not turned on */
|
|
|
|
if (ctrl_iface == NULL)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
con = ctrl_iface->con;
|
|
|
|
obj_desc->connection = con;
|
|
|
|
|
|
|
|
/* 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);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* wpa_dbus_unregister_object_per_iface - Unregisters DBus object
|
|
|
|
* @ctrl_iface: Pointer to dbus private data
|
|
|
|
* @path: DBus path to object which will be unregistered
|
|
|
|
* Returns: Zero on success and -1 on failure
|
|
|
|
*
|
|
|
|
* Unregisters DBus object given by its path
|
|
|
|
*/
|
|
|
|
int wpa_dbus_unregister_object_per_iface(
|
|
|
|
struct ctrl_iface_dbus_new_priv *ctrl_iface, const char *path)
|
|
|
|
{
|
|
|
|
DBusConnection *con = ctrl_iface->con;
|
|
|
|
if (!dbus_connection_unregister_object_path(con, path))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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
|
|
|
|
* @handler_argument: an additional argument passed to handler function
|
|
|
|
* @argument_free_func: function used to free handler argument
|
|
|
|
* @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 and optional
|
|
|
|
* argument passed to this 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,
|
2009-11-14 15:57:07 +01:00
|
|
|
const char *dbus_interface,
|
|
|
|
const char *dbus_method,
|
2009-11-09 22:51:59 +01:00
|
|
|
WPADBusMethodHandler method_handler,
|
|
|
|
void *handler_argument,
|
|
|
|
WPADBusArgumentFreeFunction argument_free_func,
|
|
|
|
struct wpa_dbus_argument args[])
|
|
|
|
{
|
|
|
|
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++;
|
|
|
|
}
|
|
|
|
|
|
|
|
method_dsc = os_zalloc(sizeof(struct wpa_dbus_method_desc) +
|
|
|
|
args_num * sizeof(struct wpa_dbus_argument));
|
|
|
|
if (!method_dsc)
|
2009-11-14 15:57:07 +01:00
|
|
|
goto err;
|
2009-11-09 22:51:59 +01:00
|
|
|
|
|
|
|
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;
|
|
|
|
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;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
os_strncpy(method_dsc->args[i].type, args[i].type, len);
|
|
|
|
|
|
|
|
method_dsc->args[i].dir = args[i].dir;
|
|
|
|
}
|
|
|
|
if (error)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
method_dsc->method_handler = method_handler;
|
|
|
|
method_dsc->handler_argument = handler_argument;
|
|
|
|
method_dsc->argument_free_func = argument_free_func;
|
|
|
|
method_dsc->next = NULL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err:
|
2009-11-14 15:57:07 +01:00
|
|
|
wpa_printf(MSG_WARNING, "Failed to register dbus method %s in "
|
|
|
|
"interface %s", dbus_method, dbus_interface);
|
2009-11-09 22:51:59 +01:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (prev_desc == NULL)
|
|
|
|
obj_dsc->methods = NULL;
|
|
|
|
else
|
|
|
|
prev_desc->next = NULL;
|
|
|
|
|
|
|
|
os_free(method_dsc);
|
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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,
|
2009-11-14 15:57:07 +01:00
|
|
|
const char *dbus_interface,
|
|
|
|
const char *dbus_signal,
|
2009-11-09 22:51:59 +01:00
|
|
|
struct wpa_dbus_argument args[])
|
|
|
|
{
|
|
|
|
|
|
|
|
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++;
|
|
|
|
}
|
|
|
|
|
|
|
|
signal_dsc = os_zalloc(sizeof(struct wpa_dbus_signal_desc) +
|
2009-11-14 15:57:07 +01:00
|
|
|
args_num * sizeof(struct wpa_dbus_argument));
|
2009-11-09 22:51:59 +01:00
|
|
|
if (!signal_dsc)
|
2009-11-14 15:57:07 +01:00
|
|
|
goto err;
|
2009-11-09 22:51:59 +01:00
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
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 (error)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
signal_dsc->next = NULL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err:
|
2009-11-14 15:57:07 +01:00
|
|
|
wpa_printf(MSG_WARNING, "Failed to register dbus signal %s in "
|
|
|
|
"interface %s", dbus_signal, dbus_interface);
|
2009-11-09 22:51:59 +01:00
|
|
|
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_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
|
|
|
|
* @user_data: additional argument passed to setter or getter
|
|
|
|
* @user_data_free_func: function used to free additional argument
|
|
|
|
* @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.
|
|
|
|
* Property are set with giver setter function and get with getter.
|
|
|
|
* Additional argument is passed to getter or setter. 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,
|
2009-11-14 15:57:07 +01:00
|
|
|
const char *dbus_interface,
|
|
|
|
const char *dbus_property,
|
|
|
|
const char *type,
|
2009-11-09 22:51:59 +01:00
|
|
|
WPADBusPropertyAccessor getter,
|
|
|
|
WPADBusPropertyAccessor setter,
|
|
|
|
void *user_data,
|
|
|
|
WPADBusArgumentFreeFunction user_data_free_func,
|
|
|
|
enum dbus_prop_access _access)
|
|
|
|
{
|
|
|
|
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)
|
2009-11-14 15:57:07 +01:00
|
|
|
goto err;
|
2009-11-09 22:51:59 +01:00
|
|
|
|
|
|
|
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->user_data = user_data;
|
|
|
|
property_dsc->user_data_free_func = user_data_free_func;
|
|
|
|
property_dsc->access = _access;
|
|
|
|
property_dsc->next = NULL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err:
|
2009-11-14 15:57:07 +01:00
|
|
|
wpa_printf(MSG_WARNING, "Failed to register dbus property %s in "
|
|
|
|
"interface %s", dbus_property, dbus_interface);
|
2009-11-09 22:51:59 +01:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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
|
|
|
|
*
|
|
|
|
* Notify listeners about changing value of some property. Signal
|
|
|
|
* contains property name and its value fetched using given property
|
|
|
|
* getter.
|
|
|
|
*/
|
|
|
|
void wpa_dbus_signal_property_changed(struct ctrl_iface_dbus_new_priv *iface,
|
|
|
|
WPADBusPropertyAccessor property_getter,
|
|
|
|
void *getter_arg,
|
|
|
|
const char *path,
|
|
|
|
const char *interface_name,
|
|
|
|
const char *property_name)
|
|
|
|
{
|
|
|
|
|
|
|
|
DBusConnection *connection;
|
|
|
|
DBusMessage *_signal, *getter_reply;
|
|
|
|
DBusMessageIter prop_iter, signal_iter, dict_iter, entry_iter;
|
|
|
|
|
|
|
|
if (!iface)
|
|
|
|
return;
|
|
|
|
connection = iface->con;
|
|
|
|
|
|
|
|
if (!property_getter) {
|
|
|
|
wpa_printf(MSG_ERROR, "wpa_dbus_signal_property_changed"
|
|
|
|
"[dbus]: property getter not specified");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!path || !interface_name || !property_name) {
|
|
|
|
wpa_printf(MSG_ERROR, "wpa_dbus_signal_property_changed"
|
|
|
|
"[dbus]: path interface of property not specified");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
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 (!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;
|
|
|
|
}
|
|
|
|
|
|
|
|
recursive_iter_copy(&prop_iter, &entry_iter);
|
|
|
|
|
|
|
|
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 (!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;
|
|
|
|
}
|
|
|
|
|
|
|
|
dbus_connection_send(connection, _signal, NULL);
|
|
|
|
|
|
|
|
err:
|
|
|
|
dbus_message_unref(getter_reply);
|
|
|
|
dbus_message_unref(_signal);
|
|
|
|
|
|
|
|
}
|