#include <glib.h>
#include <gdbus.h>
+#include "supplicant-dbus.h"
#include "supplicant.h"
#define DBG(fmt, arg...) do { \
syslog(LOG_DEBUG, "%s() " fmt, __FUNCTION__ , ## arg); \
} while (0)
-#define SUPPLICANT_SERVICE "fi.w1.wpa_supplicant1"
-#define SUPPLICANT_INTERFACE "fi.w1.wpa_supplicant1"
-#define SUPPLICANT_PATH "/fi/w1/wpa_supplicant1"
-
#define TIMEOUT 5000
static DBusConnection *connection;
static const struct supplicant_callbacks *callbacks_pointer;
-static void show_property(const char *key, DBusMessageIter *iter)
-{
- DBusMessageIter array;
+static unsigned int eap_methods;
+
+static struct {
+ const char *str;
+ unsigned int val;
+} eap_method_map[] = {
+ { "MD5", SUPPLICANT_EAP_METHOD_MD5 },
+ { "TLS", SUPPLICANT_EAP_METHOD_TLS },
+ { "MSCHAPV2", SUPPLICANT_EAP_METHOD_MSCHAPV2 },
+ { "PEAP", SUPPLICANT_EAP_METHOD_PEAP },
+ { "TTLS", SUPPLICANT_EAP_METHOD_TTLS },
+ { "GTC", SUPPLICANT_EAP_METHOD_GTC },
+ { "OTP", SUPPLICANT_EAP_METHOD_OTP },
+ { "LEAP", SUPPLICANT_EAP_METHOD_LEAP },
+ { }
+};
+
+static struct {
const char *str;
- unsigned char byte;
+ unsigned int val;
+} scan_capa_map[] = {
+ { "active", SUPPLICANT_CAPABILITY_SCAN_ACTIVE },
+ { "passive", SUPPLICANT_CAPABILITY_SCAN_PASSIVE },
+ { "ssid", SUPPLICANT_CAPABILITY_SCAN_SSID },
+ { }
+};
+
+static GHashTable *interface_table;
+
+struct supplicant_interface {
+ char *path;
+ unsigned int scan_capa;
+ enum supplicant_state state;
+ dbus_bool_t scanning;
+ int apscan;
+ char *ifname;
+ char *driver;
+ char *bridge;
+ GHashTable *network_table;
+ GHashTable *bss_mapping;
+};
+
+struct supplicant_network {
+ struct supplicant_interface *interface;
+ char *group;
+ char *name;
+ enum supplicant_network_mode mode;
+ GHashTable *bss_table;
+};
+
+struct supplicant_bss {
+ struct supplicant_interface *interface;
+ char *path;
+ unsigned char bssid[6];
+ unsigned char ssid[32];
+ unsigned int ssid_len;
+ unsigned int frequency;
+};
+
+static enum supplicant_state string2state(const char *state)
+{
+ if (state == NULL)
+ return SUPPLICANT_STATE_UNKNOWN;
+
+ if (g_str_equal(state, "unknown") == TRUE)
+ return SUPPLICANT_STATE_UNKNOWN;
+ else if (g_str_equal(state, "disconnected") == TRUE)
+ return SUPPLICANT_STATE_DISCONNECTED;
+ else if (g_str_equal(state, "inactive") == TRUE)
+ return SUPPLICANT_STATE_INACTIVE;
+ else if (g_str_equal(state, "scanning") == TRUE)
+ return SUPPLICANT_STATE_SCANNING;
+ else if (g_str_equal(state, "authenticating") == TRUE)
+ return SUPPLICANT_STATE_AUTHENTICATING;
+ else if (g_str_equal(state, "associating") == TRUE)
+ return SUPPLICANT_STATE_ASSOCIATING;
+ else if (g_str_equal(state, "associated") == TRUE)
+ return SUPPLICANT_STATE_ASSOCIATED;
+ else if (g_str_equal(state, "group_handshake") == TRUE)
+ return SUPPLICANT_STATE_GROUP_HANDSHAKE;
+ else if (g_str_equal(state, "4way_handshake") == TRUE)
+ return SUPPLICANT_STATE_4WAY_HANDSHAKE;
+ else if (g_str_equal(state, "completed") == TRUE)
+ return SUPPLICANT_STATE_COMPLETED;
+
+ return SUPPLICANT_STATE_UNKNOWN;
+}
- switch (dbus_message_iter_get_arg_type(iter)) {
- case DBUS_TYPE_STRING:
- case DBUS_TYPE_OBJECT_PATH:
- dbus_message_iter_get_basic(iter, &str);
- DBG("%s = %s", key, str);
- break;
- case DBUS_TYPE_BYTE:
- case DBUS_TYPE_BOOLEAN:
- dbus_message_iter_get_basic(iter, &byte);
- DBG("%s = %u", key, byte);
- break;
- case DBUS_TYPE_ARRAY:
- DBG("%s = {array}", key);
- dbus_message_iter_recurse(iter, &array);
- while (dbus_message_iter_get_arg_type(&array) != DBUS_TYPE_INVALID) {
- dbus_message_iter_get_basic(&array, &str);
- DBG(" %s", str);
- dbus_message_iter_next(&array);
+static void callback_interface_added(struct supplicant_interface *interface)
+{
+ if (callbacks_pointer == NULL)
+ return;
+
+ if (callbacks_pointer->interface_added == NULL)
+ return;
+
+ callbacks_pointer->interface_added(interface);
+}
+
+static void callback_interface_removed(struct supplicant_interface *interface)
+{
+ if (callbacks_pointer == NULL)
+ return;
+
+ if (callbacks_pointer->interface_removed == NULL)
+ return;
+
+ callbacks_pointer->interface_removed(interface);
+}
+
+static void callback_network_added(struct supplicant_network *network)
+{
+ if (callbacks_pointer == NULL)
+ return;
+
+ if (callbacks_pointer->network_added == NULL)
+ return;
+
+ callbacks_pointer->network_added(network);
+}
+
+static void callback_network_removed(struct supplicant_network *network)
+{
+ if (callbacks_pointer == NULL)
+ return;
+
+ if (callbacks_pointer->network_removed == NULL)
+ return;
+
+ callbacks_pointer->network_removed(network);
+}
+
+static void remove_interface(gpointer data)
+{
+ struct supplicant_interface *interface = data;
+
+ callback_interface_removed(interface);
+
+ g_hash_table_destroy(interface->bss_mapping);
+ g_hash_table_destroy(interface->network_table);
+
+ g_free(interface->path);
+ g_free(interface->ifname);
+ g_free(interface->driver);
+ g_free(interface->bridge);
+ g_free(interface);
+}
+
+static void remove_network(gpointer data)
+{
+ struct supplicant_network *network = data;
+
+ callback_network_removed(network);
+
+ g_free(network->group);
+ g_free(network->name);
+ g_free(network);
+}
+
+static void remove_bss(gpointer data)
+{
+ struct supplicant_bss *bss = data;
+
+ g_free(bss->path);
+ g_free(bss);
+}
+
+static void debug_eap_methods(void)
+{
+ int i;
+
+ for (i = 0; eap_method_map[i].str != NULL; i++) {
+ if (eap_methods & eap_method_map[i].val)
+ DBG("EAP Method: %s", eap_method_map[i].str);
+ }
+}
+
+static void debug_scan_capabilities(struct supplicant_interface *interface)
+{
+ int i;
+
+ for (i = 0; scan_capa_map[i].str != NULL; i++) {
+ if (interface->scan_capa & scan_capa_map[i].val)
+ DBG("Scan Capability: %s", scan_capa_map[i].str);
+ }
+}
+
+static void interface_capability_scan(DBusMessageIter *iter, void *user_data)
+{
+ struct supplicant_interface *interface = user_data;
+ const char *str = NULL;
+ int i;
+
+ dbus_message_iter_get_basic(iter, &str);
+ if (str == NULL)
+ return;
+
+ for (i = 0; scan_capa_map[i].str != NULL; i++)
+ if (strcmp(str, scan_capa_map[i].str) == 0) {
+ interface->scan_capa |= scan_capa_map[i].val;
+ break;
}
- break;
- default:
- DBG("%s = ...", key);
- break;
+}
+
+static void interface_capability(const char *key, DBusMessageIter *iter,
+ void *user_data)
+{
+ struct supplicant_interface *interface = user_data;
+
+ if (key == NULL)
+ return;
+
+ if (g_strcmp0(key, "Scan") == 0)
+ supplicant_dbus_array_foreach(iter, interface_capability_scan,
+ interface);
+ else
+ DBG("key %s type %c",
+ key, dbus_message_iter_get_arg_type(iter));
+}
+
+const char *supplicant_interface_get_ifname(struct supplicant_interface *interface)
+{
+ if (interface == NULL)
+ return NULL;
+
+ return interface->ifname;
+}
+
+struct supplicant_interface *supplicant_network_get_interface(struct supplicant_network *network)
+{
+ if (network == NULL)
+ return NULL;
+
+ return network->interface;
+}
+
+const char *supplicant_network_get_name(struct supplicant_network *network)
+{
+ if (network == NULL || network->name == NULL)
+ return "";
+
+ return network->name;
+}
+
+enum supplicant_network_mode supplicant_network_get_mode(struct supplicant_network *network)
+{
+ if (network == NULL)
+ return SUPPLICANT_NETWORK_MODE_UNKNOWN;
+
+ return network->mode;
+}
+
+static void network_property(const char *key, DBusMessageIter *iter,
+ void *user_data)
+{
+ if (key == NULL)
+ return;
+
+ DBG("key %s type %c", key, dbus_message_iter_get_arg_type(iter));
+}
+
+static void interface_network_added(DBusMessageIter *iter, void *user_data)
+{
+ const char *path = NULL;
+
+ dbus_message_iter_get_basic(iter, &path);
+ if (path == NULL)
+ return;
+
+ supplicant_dbus_property_get_all(path,
+ SUPPLICANT_INTERFACE ".Interface.Network",
+ network_property, NULL);
+}
+
+static char *create_name(unsigned char *ssid, int ssid_len)
+{
+ char *name;
+ int i;
+
+ if (ssid_len < 1 || ssid[0] == '\0')
+ name = NULL;
+ else
+ name = g_try_malloc0(ssid_len + 1);
+
+ if (name == NULL)
+ return g_strdup("");
+
+ for (i = 0; i < ssid_len; i++) {
+ if (g_ascii_isprint(ssid[i]))
+ name[i] = ssid[i];
+ else
+ name[i] = ' ';
}
+
+ return name;
}
-static void properties_decode(DBusMessageIter *iter)
+static void add_bss_to_network(struct supplicant_bss *bss)
{
- DBusMessageIter dict;
+ struct supplicant_interface *interface = bss->interface;
+ struct supplicant_network *network;
+ GString *str;
+ char *group;
+ unsigned int i;
+
+ str = g_string_sized_new((bss->ssid_len * 2) + 24);
+ if (str == NULL)
+ return;
+
+ if (bss->ssid_len > 0 && bss->ssid[0] != '\0') {
+ for (i = 0; i < bss->ssid_len; i++)
+ g_string_append_printf(str, "%02x", bss->ssid[i]);
+ } else
+ g_string_append_printf(str, "hidden");
- if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_ARRAY) {
- syslog(LOG_ERR, "Invalid message type");
+ group = g_string_free(str, FALSE);
+
+ network = g_hash_table_lookup(interface->network_table, group);
+ if (network != NULL) {
+ g_free(group);
+ goto done;
+ }
+
+ network = g_try_new0(struct supplicant_network, 1);
+ if (network == NULL) {
+ g_free(group);
return;
}
- dbus_message_iter_recurse(iter, &dict);
+ network->group = group;
+ network->name = create_name(bss->ssid, bss->ssid_len);
- while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
- DBusMessageIter entry, value;
- const char *key;
+ network->bss_table = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, remove_bss);
- dbus_message_iter_recurse(&dict, &entry);
+ g_hash_table_replace(interface->network_table,
+ network->group, network);
- if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
- return;
+ callback_network_added(network);
- dbus_message_iter_get_basic(&entry, &key);
- dbus_message_iter_next(&entry);
+done:
+ g_hash_table_replace(interface->bss_mapping, bss->path, network);
+ g_hash_table_replace(network->bss_table, bss->path, bss);
+}
- if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT)
- return;
+static void bss_property(const char *key, DBusMessageIter *iter,
+ void *user_data)
+{
+ struct supplicant_bss *bss = user_data;
+
+ if (bss->interface == NULL)
+ return;
+
+ if (key == NULL) {
+ add_bss_to_network(bss);
+ return;
+ }
+
+ if (g_strcmp0(key, "BSSID") == 0) {
+ DBusMessageIter array;
+ unsigned char *addr;
+ int addr_len;
+
+ dbus_message_iter_recurse(iter, &array);
+ dbus_message_iter_get_fixed_array(&array, &addr, &addr_len);
+
+ if (addr_len == 6)
+ memcpy(bss->bssid, addr, addr_len);
+ } else if (g_strcmp0(key, "SSID") == 0) {
+ DBusMessageIter array;
+ unsigned char *ssid;
+ int ssid_len;
+
+ dbus_message_iter_recurse(iter, &array);
+ dbus_message_iter_get_fixed_array(&array, &ssid, &ssid_len);
+
+ if (ssid_len > 0 && ssid_len < 33) {
+ memcpy(bss->ssid, ssid, ssid_len);
+ bss->ssid_len = ssid_len;
+ } else {
+ memset(bss->ssid, 0, sizeof(bss->ssid));
+ bss->ssid_len = 0;
+ }
+ } else if (g_strcmp0(key, "Capabilities") == 0) {
+ unsigned char capabilities = 0x00;
+
+ dbus_message_iter_get_basic(iter, &capabilities);
+ } else if (g_strcmp0(key, "Frequency") == 0) {
+ dbus_int32_t frequency = 0;
+
+ dbus_message_iter_get_basic(iter, &frequency);
+ bss->frequency = frequency;
+ } else if (g_strcmp0(key, "Level") == 0) {
+ dbus_int32_t level = 0;
+
+ dbus_message_iter_get_basic(iter, &level);
+ } else if (g_strcmp0(key, "MaxRate") == 0) {
+ dbus_int32_t maxrate = 0;
+
+ dbus_message_iter_get_basic(iter, &maxrate);
+ } else if (g_strcmp0(key, "RSNIE") == 0) {
+ DBusMessageIter array;
+ unsigned char *ie;
+ int ie_len;
+
+ dbus_message_iter_recurse(iter, &array);
+ dbus_message_iter_get_fixed_array(&array, &ie, &ie_len);
+ } else if (g_strcmp0(key, "WPAIE") == 0) {
+ DBusMessageIter array;
+ unsigned char *ie;
+ int ie_len;
+
+ dbus_message_iter_recurse(iter, &array);
+ dbus_message_iter_get_fixed_array(&array, &ie, &ie_len);
+ } else if (g_strcmp0(key, "WPSIE") == 0) {
+ DBusMessageIter array;
+ unsigned char *ie;
+ int ie_len;
- dbus_message_iter_recurse(&entry, &value);
+ dbus_message_iter_recurse(iter, &array);
+ dbus_message_iter_get_fixed_array(&array, &ie, &ie_len);
+ } else
+ DBG("key %s type %c",
+ key, dbus_message_iter_get_arg_type(iter));
+}
- show_property(key, &value);
+static void interface_bss_added(DBusMessageIter *iter, void *user_data)
+{
+ struct supplicant_interface *interface = user_data;
+ struct supplicant_network *network;
+ struct supplicant_bss *bss;
+ const char *path = NULL;
- dbus_message_iter_next(&dict);
+ dbus_message_iter_get_basic(iter, &path);
+ if (path == NULL)
+ return;
+
+ network = g_hash_table_lookup(interface->bss_mapping, path);
+ if (network != NULL) {
+ bss = g_hash_table_lookup(network->bss_table, path);
+ if (bss != NULL)
+ return;
}
+
+ bss = g_try_new0(struct supplicant_bss, 1);
+ if (bss == NULL)
+ return;
+
+ bss->interface = interface;
+ bss->path = g_strdup(path);
+
+ supplicant_dbus_property_get_all(path,
+ SUPPLICANT_INTERFACE ".Interface.BSS",
+ bss_property, bss);
}
-static void properties_get_all_reply(DBusPendingCall *call, void *user_data)
+static void interface_bss_removed(DBusMessageIter *iter, void *user_data)
{
- DBusMessage *reply;
- DBusMessageIter iter;
+ struct supplicant_interface *interface = user_data;
+ struct supplicant_network *network;
+ const char *path = NULL;
- DBG("call %p", call);
+ dbus_message_iter_get_basic(iter, &path);
+ if (path == NULL)
+ return;
- reply = dbus_pending_call_steal_reply(call);
- if (reply == NULL)
+ network = g_hash_table_lookup(interface->bss_mapping, path);
+ if (network == NULL)
return;
- if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR)
- goto failed;
+ g_hash_table_remove(interface->bss_mapping, path);
+ g_hash_table_remove(network->bss_table, path);
- if (dbus_message_iter_init(reply, &iter) == FALSE)
- goto failed;
+ if (g_hash_table_size(network->bss_table) == 0)
+ g_hash_table_remove(interface->network_table, network->group);
+}
- DBG("success");
+static void interface_property(const char *key, DBusMessageIter *iter,
+ void *user_data)
+{
+ struct supplicant_interface *interface = user_data;
- properties_decode(&iter);
+ if (interface == NULL)
+ return;
+
+ if (key == NULL) {
+ debug_scan_capabilities(interface);
+
+ g_hash_table_replace(interface_table,
+ interface->path, interface);
+
+ callback_interface_added(interface);
+ return;
+ }
- dbus_message_unref(reply);
+ if (g_strcmp0(key, "Capabilities") == 0) {
+ supplicant_dbus_property_foreach(iter, interface_capability,
+ interface);
+ } else if (g_strcmp0(key, "State") == 0) {
+ const char *str = NULL;
+
+ dbus_message_iter_get_basic(iter, &str);
+ if (str != NULL)
+ interface->state = string2state(str);
+ } else if (g_strcmp0(key, "Scanning") == 0) {
+ dbus_bool_t scanning = FALSE;
+
+ dbus_message_iter_get_basic(iter, &scanning);
+ interface->scanning = scanning;
+ } else if (g_strcmp0(key, "ApScan") == 0) {
+ int apscan;
+
+ dbus_message_iter_get_basic(iter, &apscan);
+ interface->apscan = apscan;
+ } else if (g_strcmp0(key, "Ifname") == 0) {
+ const char *str = NULL;
+
+ dbus_message_iter_get_basic(iter, &str);
+ if (str != NULL)
+ interface->ifname = g_strdup(str);
+ } else if (g_strcmp0(key, "Driver") == 0) {
+ const char *str = NULL;
- return;
+ dbus_message_iter_get_basic(iter, &str);
+ if (str != NULL)
+ interface->driver = g_strdup(str);
+ } else if (g_strcmp0(key, "BridgeIfname") == 0) {
+ const char *str = NULL;
-failed:
- dbus_message_unref(reply);
+ dbus_message_iter_get_basic(iter, &str);
+ if (str != NULL)
+ interface->bridge = g_strdup(str);
+ } else if (g_strcmp0(key, "CurrentBSS") == 0) {
+ interface_bss_added(iter, interface);
+ } else if (g_strcmp0(key, "CurrentNetwork") == 0) {
+ interface_network_added(iter, interface);
+ } else if (g_strcmp0(key, "BSSs") == 0) {
+ supplicant_dbus_array_foreach(iter, interface_bss_added,
+ interface);
+ } else if (g_strcmp0(key, "Blobs") == 0) {
+ } else if (g_strcmp0(key, "Networks") == 0) {
+ supplicant_dbus_array_foreach(iter, interface_network_added,
+ interface);
+ } else
+ DBG("key %s type %c",
+ key, dbus_message_iter_get_arg_type(iter));
}
-static int properties_get_all(const char *path, const char *interface)
+static void interface_path(DBusMessageIter *iter, void *user_data)
{
- DBusMessage *message;
- DBusPendingCall *call;
+ struct supplicant_interface *interface;
+ const char *path = NULL;
- DBG("");
+ dbus_message_iter_get_basic(iter, &path);
+ if (path == NULL)
+ return;
- message = dbus_message_new_method_call(SUPPLICANT_SERVICE, path,
- DBUS_INTERFACE_PROPERTIES, "GetAll");
- if (message == NULL)
- return -ENOMEM;
+ interface = g_hash_table_lookup(interface_table, path);
+ if (interface != NULL)
+ return;
- dbus_message_set_auto_start(message, FALSE);
+ interface = g_try_new0(struct supplicant_interface, 1);
+ if (interface == NULL)
+ return;
- dbus_message_append_args(message, DBUS_TYPE_STRING, &interface, NULL);
+ interface->path = g_strdup(path);
- if (dbus_connection_send_with_reply(connection, message,
- &call, TIMEOUT) == FALSE) {
- syslog(LOG_ERR, "Failed to add interface");
- dbus_message_unref(message);
- return -EIO;
- }
+ interface->network_table = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, remove_network);
- if (call == NULL) {
- syslog(LOG_ERR, "D-Bus connection not available");
- dbus_message_unref(message);
- return -EIO;
+ interface->bss_mapping = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, NULL);
+
+ supplicant_dbus_property_get_all(path,
+ SUPPLICANT_INTERFACE ".Interface",
+ interface_property, interface);
+}
+
+static void eap_method(DBusMessageIter *iter, void *user_data)
+{
+ const char *str = NULL;
+ int i;
+
+ dbus_message_iter_get_basic(iter, &str);
+ if (str == NULL)
+ return;
+
+ for (i = 0; eap_method_map[i].str != NULL; i++)
+ if (strcmp(str, eap_method_map[i].str) == 0) {
+ eap_methods |= eap_method_map[i].val;
+ break;
+ }
+}
+
+static void service_property(const char *key, DBusMessageIter *iter,
+ void *user_data)
+{
+ if (key == NULL)
+ return;
+
+ if (g_strcmp0(key, "Interfaces") == 0)
+ supplicant_dbus_array_foreach(iter, interface_path, user_data);
+ else if (g_strcmp0(key, "EapMethods") == 0) {
+ supplicant_dbus_array_foreach(iter, eap_method, user_data);
+ debug_eap_methods();
+ } else if (g_strcmp0(key, "DebugParams") == 0) {
}
+}
- DBG("call %p", call);
+static void signal_interface_added(const char *path, DBusMessageIter *iter)
+{
+ interface_path(iter, NULL);
+}
- dbus_pending_call_set_notify(call, properties_get_all_reply,
- NULL, NULL);
+static void signal_interface_removed(const char *path, DBusMessageIter *iter)
+{
+ DBG("path %s", path);
+}
- dbus_message_unref(message);
+static void signal_bss_added(const char *path, DBusMessageIter *iter)
+{
+ struct supplicant_interface *interface;
- return 0;
+ interface = g_hash_table_lookup(interface_table, path);
+ if (interface == NULL)
+ return;
+
+ interface_bss_added(iter, interface);
}
-static DBusHandlerResult supplicant_filter(DBusConnection *conn,
- DBusMessage *msg, void *data)
+static void signal_bss_removed(const char *path, DBusMessageIter *iter)
{
- int prefixlen = strlen(SUPPLICANT_INTERFACE);
- const char *interface, *member, *path;
+ struct supplicant_interface *interface;
- interface = dbus_message_get_interface(msg);
+ interface = g_hash_table_lookup(interface_table, path);
if (interface == NULL)
- return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+ return;
- if (g_str_has_prefix(interface, SUPPLICANT_INTERFACE) == FALSE)
- return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+ interface_bss_removed(iter, interface);
+}
+
+static struct {
+ const char *interface;
+ const char *member;
+ void (*function) (const char *path, DBusMessageIter *iter);
+} signal_map[] = {
+ { SUPPLICANT_INTERFACE, "InterfaceAdded", signal_interface_added },
+ { SUPPLICANT_INTERFACE, "InterfaceRemoved", signal_interface_removed },
+ { SUPPLICANT_INTERFACE ".Interface", "BSSAdded", signal_bss_added },
+ { SUPPLICANT_INTERFACE ".Interface", "BSSRemoved", signal_bss_removed },
+ { }
+};
- member = dbus_message_get_member(msg);
- if (member == NULL)
+static DBusHandlerResult supplicant_filter(DBusConnection *conn,
+ DBusMessage *message, void *data)
+{
+ DBusMessageIter iter;
+ const char *path;
+ int i;
+
+ path = dbus_message_get_path(message);
+ if (path == NULL)
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
- path = dbus_message_get_path(msg);
+ if (dbus_message_iter_init(message, &iter) == FALSE)
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
- syslog(LOG_DEBUG, "[ %s ]%s.%s", path, interface + prefixlen, member);
+ for (i = 0; signal_map[i].interface != NULL; i++) {
+ if (dbus_message_has_interface(message,
+ signal_map[i].interface) == FALSE)
+ continue;
- if (g_str_equal(member, "PropertiesChanged") == TRUE) {
- DBusMessageIter iter;
+ if (dbus_message_has_member(message,
+ signal_map[i].member) == FALSE)
+ continue;
- if (dbus_message_iter_init(msg, &iter) == TRUE)
- properties_decode(&iter);
+ signal_map[i].function(path, &iter);
+ break;
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
int supplicant_register(const struct supplicant_callbacks *callbacks)
{
- DBG("");
-
connection = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
if (connection == NULL)
return -EIO;
}
callbacks_pointer = callbacks;
+ eap_methods = 0;
+
+ interface_table = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, remove_interface);
+
+ supplicant_dbus_setup(connection);
dbus_bus_add_match(connection, supplicant_rule1, NULL);
dbus_bus_add_match(connection, supplicant_rule2, NULL);
dbus_bus_add_match(connection, supplicant_rule6, NULL);
dbus_connection_flush(connection);
- properties_get_all(SUPPLICANT_PATH, SUPPLICANT_INTERFACE);
+ supplicant_dbus_property_get_all(SUPPLICANT_PATH,
+ SUPPLICANT_INTERFACE,
+ service_property, NULL);
return 0;
}
void supplicant_unregister(const struct supplicant_callbacks *callbacks)
{
- DBG("");
-
if (connection != NULL) {
dbus_bus_remove_match(connection, supplicant_rule6, NULL);
dbus_bus_remove_match(connection, supplicant_rule5, NULL);
dbus_connection_remove_filter(connection,
supplicant_filter, NULL);
+ }
+ if (interface_table != NULL) {
+ g_hash_table_destroy(interface_table);
+ interface_table = NULL;
+ }
+
+ if (connection != NULL) {
dbus_connection_unref(connection);
connection = NULL;
}
callbacks_pointer = NULL;
+ eap_methods = 0;
}
projects / platform / upstream / connman.git / commitdiff