3 * WPA supplicant library with GLib integration
5 * Copyright (C) 2010 Intel Corporation. All rights reserved.
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
37 #include "gsupplicant.h"
41 #define IEEE80211_CAP_ESS 0x0001
42 #define IEEE80211_CAP_IBSS 0x0002
43 #define IEEE80211_CAP_PRIVACY 0x0010
45 static DBusConnection *connection;
47 static const GSupplicantCallbacks *callbacks_pointer;
49 static dbus_bool_t system_available = FALSE;
50 static dbus_bool_t system_ready = FALSE;
52 static dbus_int32_t debug_level;
53 static dbus_bool_t debug_timestamp = FALSE;
54 static dbus_bool_t debug_showkeys = FALSE;
56 static const char *debug_strings[] = {
57 "msgdump", "debug", "info", "warning", "error", NULL
60 static unsigned int eap_methods;
67 static struct strvalmap eap_method_map[] = {
68 { "MD5", G_SUPPLICANT_EAP_METHOD_MD5 },
69 { "TLS", G_SUPPLICANT_EAP_METHOD_TLS },
70 { "MSCHAPV2", G_SUPPLICANT_EAP_METHOD_MSCHAPV2 },
71 { "PEAP", G_SUPPLICANT_EAP_METHOD_PEAP },
72 { "TTLS", G_SUPPLICANT_EAP_METHOD_TTLS },
73 { "GTC", G_SUPPLICANT_EAP_METHOD_GTC },
74 { "OTP", G_SUPPLICANT_EAP_METHOD_OTP },
75 { "LEAP", G_SUPPLICANT_EAP_METHOD_LEAP },
76 { "WSC", G_SUPPLICANT_EAP_METHOD_WSC },
80 static struct strvalmap keymgmt_map[] = {
81 { "none", G_SUPPLICANT_KEYMGMT_NONE },
82 { "ieee8021x", G_SUPPLICANT_KEYMGMT_IEEE8021X },
83 { "wpa-none", G_SUPPLICANT_KEYMGMT_WPA_NONE },
84 { "wpa-psk", G_SUPPLICANT_KEYMGMT_WPA_PSK },
85 { "wpa-psk-sha256", G_SUPPLICANT_KEYMGMT_WPA_PSK_256 },
86 { "wpa-ft-psk", G_SUPPLICANT_KEYMGMT_WPA_FT_PSK },
87 { "wpa-ft-eap", G_SUPPLICANT_KEYMGMT_WPA_FT_EAP },
88 { "wpa-eap", G_SUPPLICANT_KEYMGMT_WPA_EAP },
89 { "wpa-eap-sha256", G_SUPPLICANT_KEYMGMT_WPA_EAP_256 },
90 { "wps", G_SUPPLICANT_KEYMGMT_WPS },
94 static struct strvalmap authalg_capa_map[] = {
95 { "open", G_SUPPLICANT_CAPABILITY_AUTHALG_OPEN },
96 { "shared", G_SUPPLICANT_CAPABILITY_AUTHALG_SHARED },
97 { "leap", G_SUPPLICANT_CAPABILITY_AUTHALG_LEAP },
101 static struct strvalmap proto_capa_map[] = {
102 { "wpa", G_SUPPLICANT_CAPABILITY_PROTO_WPA },
103 { "rsn", G_SUPPLICANT_CAPABILITY_PROTO_RSN },
107 static struct strvalmap group_map[] = {
108 { "wep40", G_SUPPLICANT_GROUP_WEP40 },
109 { "wep104", G_SUPPLICANT_GROUP_WEP104 },
110 { "tkip", G_SUPPLICANT_GROUP_TKIP },
111 { "ccmp", G_SUPPLICANT_GROUP_CCMP },
115 static struct strvalmap pairwise_map[] = {
116 { "none", G_SUPPLICANT_PAIRWISE_NONE },
117 { "tkip", G_SUPPLICANT_PAIRWISE_TKIP },
118 { "ccmp", G_SUPPLICANT_PAIRWISE_CCMP },
122 static struct strvalmap scan_capa_map[] = {
123 { "active", G_SUPPLICANT_CAPABILITY_SCAN_ACTIVE },
124 { "passive", G_SUPPLICANT_CAPABILITY_SCAN_PASSIVE },
125 { "ssid", G_SUPPLICANT_CAPABILITY_SCAN_SSID },
129 static struct strvalmap mode_capa_map[] = {
130 { "infrastructure", G_SUPPLICANT_CAPABILITY_MODE_INFRA },
131 { "ad-hoc", G_SUPPLICANT_CAPABILITY_MODE_IBSS },
132 { "ap", G_SUPPLICANT_CAPABILITY_MODE_AP },
136 static GHashTable *interface_table;
137 static GHashTable *bss_mapping;
139 struct _GSupplicantWpsCredentials {
140 unsigned char ssid[32];
141 unsigned int ssid_len;
145 struct _GSupplicantInterface {
148 unsigned int keymgmt_capa;
149 unsigned int authalg_capa;
150 unsigned int proto_capa;
151 unsigned int group_capa;
152 unsigned int pairwise_capa;
153 unsigned int scan_capa;
154 unsigned int mode_capa;
156 GSupplicantState state;
157 dbus_bool_t scanning;
158 GSupplicantInterfaceCallback scan_callback;
164 struct _GSupplicantWpsCredentials wps_cred;
165 GSupplicantWpsState wps_state;
166 GHashTable *network_table;
167 GHashTable *net_mapping;
168 GHashTable *bss_mapping;
172 struct _GSupplicantNetwork {
173 GSupplicantInterface *interface;
177 unsigned char ssid[32];
178 unsigned int ssid_len;
180 GSupplicantMode mode;
181 GSupplicantSecurity security;
183 GHashTable *bss_table;
184 GHashTable *config_table;
187 struct g_supplicant_bss {
188 GSupplicantInterface *interface;
190 unsigned char bssid[6];
191 unsigned char ssid[32];
192 unsigned int ssid_len;
193 dbus_uint16_t frequency;
194 dbus_uint32_t maxrate;
196 GSupplicantMode mode;
197 GSupplicantSecurity security;
198 unsigned int keymgmt;
199 unsigned int pairwise;
203 dbus_bool_t ieee8021x;
206 static inline void debug(const char *format, ...)
211 if (callbacks_pointer->debug == NULL)
214 va_start(ap, format);
216 if (vsnprintf(str, sizeof(str), format, ap) > 0)
217 callbacks_pointer->debug(str);
222 #define SUPPLICANT_DBG(fmt, arg...) \
223 debug("%s:%s() " fmt, __FILE__, __FUNCTION__ , ## arg);
225 static GSupplicantMode string2mode(const char *mode)
228 return G_SUPPLICANT_MODE_UNKNOWN;
230 if (g_str_equal(mode, "infrastructure") == TRUE)
231 return G_SUPPLICANT_MODE_INFRA;
232 else if (g_str_equal(mode, "ad-hoc") == TRUE)
233 return G_SUPPLICANT_MODE_IBSS;
235 return G_SUPPLICANT_MODE_UNKNOWN;
238 static const char *mode2string(GSupplicantMode mode)
241 case G_SUPPLICANT_MODE_UNKNOWN:
243 case G_SUPPLICANT_MODE_INFRA:
245 case G_SUPPLICANT_MODE_IBSS:
247 case G_SUPPLICANT_MODE_MASTER:
254 static const char *security2string(GSupplicantSecurity security)
257 case G_SUPPLICANT_SECURITY_UNKNOWN:
259 case G_SUPPLICANT_SECURITY_NONE:
261 case G_SUPPLICANT_SECURITY_WEP:
263 case G_SUPPLICANT_SECURITY_PSK:
265 case G_SUPPLICANT_SECURITY_IEEE8021X:
272 static GSupplicantState string2state(const char *state)
275 return G_SUPPLICANT_STATE_UNKNOWN;
277 if (g_str_equal(state, "unknown") == TRUE)
278 return G_SUPPLICANT_STATE_UNKNOWN;
279 else if (g_str_equal(state, "disconnected") == TRUE)
280 return G_SUPPLICANT_STATE_DISCONNECTED;
281 else if (g_str_equal(state, "inactive") == TRUE)
282 return G_SUPPLICANT_STATE_INACTIVE;
283 else if (g_str_equal(state, "scanning") == TRUE)
284 return G_SUPPLICANT_STATE_SCANNING;
285 else if (g_str_equal(state, "authenticating") == TRUE)
286 return G_SUPPLICANT_STATE_AUTHENTICATING;
287 else if (g_str_equal(state, "associating") == TRUE)
288 return G_SUPPLICANT_STATE_ASSOCIATING;
289 else if (g_str_equal(state, "associated") == TRUE)
290 return G_SUPPLICANT_STATE_ASSOCIATED;
291 else if (g_str_equal(state, "group_handshake") == TRUE)
292 return G_SUPPLICANT_STATE_GROUP_HANDSHAKE;
293 else if (g_str_equal(state, "4way_handshake") == TRUE)
294 return G_SUPPLICANT_STATE_4WAY_HANDSHAKE;
295 else if (g_str_equal(state, "completed") == TRUE)
296 return G_SUPPLICANT_STATE_COMPLETED;
298 return G_SUPPLICANT_STATE_UNKNOWN;
301 static void callback_system_ready(void)
303 if (system_ready == TRUE)
308 if (callbacks_pointer == NULL)
311 if (callbacks_pointer->system_ready == NULL)
314 callbacks_pointer->system_ready();
317 static void callback_system_killed(void)
319 system_ready = FALSE;
321 if (callbacks_pointer == NULL)
324 if (callbacks_pointer->system_killed == NULL)
327 callbacks_pointer->system_killed();
330 static void callback_interface_added(GSupplicantInterface *interface)
334 if (callbacks_pointer == NULL)
337 if (callbacks_pointer->interface_added == NULL)
340 callbacks_pointer->interface_added(interface);
343 static void callback_interface_state(GSupplicantInterface *interface)
345 if (callbacks_pointer == NULL)
348 if (callbacks_pointer->interface_state == NULL)
351 callbacks_pointer->interface_state(interface);
354 static void callback_interface_removed(GSupplicantInterface *interface)
356 if (callbacks_pointer == NULL)
359 if (callbacks_pointer->interface_removed == NULL)
362 callbacks_pointer->interface_removed(interface);
365 static void callback_scan_started(GSupplicantInterface *interface)
367 if (callbacks_pointer == NULL)
370 if (callbacks_pointer->scan_started == NULL)
373 callbacks_pointer->scan_started(interface);
376 static void callback_scan_finished(GSupplicantInterface *interface)
378 if (callbacks_pointer == NULL)
381 if (callbacks_pointer->scan_finished == NULL)
384 callbacks_pointer->scan_finished(interface);
387 static void callback_network_added(GSupplicantNetwork *network)
389 if (callbacks_pointer == NULL)
392 if (callbacks_pointer->network_added == NULL)
395 callbacks_pointer->network_added(network);
398 static void callback_network_removed(GSupplicantNetwork *network)
400 if (callbacks_pointer == NULL)
403 if (callbacks_pointer->network_removed == NULL)
406 callbacks_pointer->network_removed(network);
409 static void remove_interface(gpointer data)
411 GSupplicantInterface *interface = data;
413 g_hash_table_destroy(interface->bss_mapping);
414 g_hash_table_destroy(interface->net_mapping);
415 g_hash_table_destroy(interface->network_table);
417 callback_interface_removed(interface);
419 g_free(interface->wps_cred.key);
420 g_free(interface->path);
421 g_free(interface->network_path);
422 g_free(interface->ifname);
423 g_free(interface->driver);
424 g_free(interface->bridge);
428 static void remove_network(gpointer data)
430 GSupplicantNetwork *network = data;
432 g_hash_table_destroy(network->bss_table);
434 callback_network_removed(network);
436 g_hash_table_destroy(network->config_table);
438 g_free(network->path);
439 g_free(network->group);
440 g_free(network->name);
444 static void remove_bss(gpointer data)
446 struct g_supplicant_bss *bss = data;
452 static void debug_strvalmap(const char *label, struct strvalmap *map,
457 for (i = 0; map[i].str != NULL; i++) {
458 if (val & map[i].val)
459 SUPPLICANT_DBG("%s: %s", label, map[i].str);
463 static void interface_capability_keymgmt(DBusMessageIter *iter, void *user_data)
465 GSupplicantInterface *interface = user_data;
466 const char *str = NULL;
469 dbus_message_iter_get_basic(iter, &str);
473 for (i = 0; keymgmt_map[i].str != NULL; i++)
474 if (strcmp(str, keymgmt_map[i].str) == 0) {
475 interface->keymgmt_capa |= keymgmt_map[i].val;
480 static void interface_capability_authalg(DBusMessageIter *iter, void *user_data)
482 GSupplicantInterface *interface = user_data;
483 const char *str = NULL;
486 dbus_message_iter_get_basic(iter, &str);
490 for (i = 0; authalg_capa_map[i].str != NULL; i++)
491 if (strcmp(str, authalg_capa_map[i].str) == 0) {
492 interface->authalg_capa |= authalg_capa_map[i].val;
497 static void interface_capability_proto(DBusMessageIter *iter, void *user_data)
499 GSupplicantInterface *interface = user_data;
500 const char *str = NULL;
503 dbus_message_iter_get_basic(iter, &str);
507 for (i = 0; proto_capa_map[i].str != NULL; i++)
508 if (strcmp(str, proto_capa_map[i].str) == 0) {
509 interface->proto_capa |= proto_capa_map[i].val;
514 static void interface_capability_pairwise(DBusMessageIter *iter,
517 GSupplicantInterface *interface = user_data;
518 const char *str = NULL;
521 dbus_message_iter_get_basic(iter, &str);
525 for (i = 0; pairwise_map[i].str != NULL; i++)
526 if (strcmp(str, pairwise_map[i].str) == 0) {
527 interface->pairwise_capa |= pairwise_map[i].val;
532 static void interface_capability_group(DBusMessageIter *iter, void *user_data)
534 GSupplicantInterface *interface = user_data;
535 const char *str = NULL;
538 dbus_message_iter_get_basic(iter, &str);
542 for (i = 0; group_map[i].str != NULL; i++)
543 if (strcmp(str, group_map[i].str) == 0) {
544 interface->group_capa |= group_map[i].val;
549 static void interface_capability_scan(DBusMessageIter *iter, void *user_data)
551 GSupplicantInterface *interface = user_data;
552 const char *str = NULL;
555 dbus_message_iter_get_basic(iter, &str);
559 for (i = 0; scan_capa_map[i].str != NULL; i++)
560 if (strcmp(str, scan_capa_map[i].str) == 0) {
561 interface->scan_capa |= scan_capa_map[i].val;
566 static void interface_capability_mode(DBusMessageIter *iter, void *user_data)
568 GSupplicantInterface *interface = user_data;
569 const char *str = NULL;
572 dbus_message_iter_get_basic(iter, &str);
576 for (i = 0; mode_capa_map[i].str != NULL; i++)
577 if (strcmp(str, mode_capa_map[i].str) == 0) {
578 interface->mode_capa |= mode_capa_map[i].val;
583 static void interface_capability(const char *key, DBusMessageIter *iter,
586 GSupplicantInterface *interface = user_data;
591 if (g_strcmp0(key, "KeyMgmt") == 0)
592 supplicant_dbus_array_foreach(iter,
593 interface_capability_keymgmt, interface);
594 else if (g_strcmp0(key, "AuthAlg") == 0)
595 supplicant_dbus_array_foreach(iter,
596 interface_capability_authalg, interface);
597 else if (g_strcmp0(key, "Protocol") == 0)
598 supplicant_dbus_array_foreach(iter,
599 interface_capability_proto, interface);
600 else if (g_strcmp0(key, "Pairwise") == 0)
601 supplicant_dbus_array_foreach(iter,
602 interface_capability_pairwise, interface);
603 else if (g_strcmp0(key, "Group") == 0)
604 supplicant_dbus_array_foreach(iter,
605 interface_capability_group, interface);
606 else if (g_strcmp0(key, "Scan") == 0)
607 supplicant_dbus_array_foreach(iter,
608 interface_capability_scan, interface);
609 else if (g_strcmp0(key, "Modes") == 0)
610 supplicant_dbus_array_foreach(iter,
611 interface_capability_mode, interface);
613 SUPPLICANT_DBG("key %s type %c",
614 key, dbus_message_iter_get_arg_type(iter));
617 void g_supplicant_interface_set_data(GSupplicantInterface *interface,
620 if (interface == NULL)
623 interface->data = data;
626 void *g_supplicant_interface_get_data(GSupplicantInterface *interface)
628 if (interface == NULL)
631 return interface->data;
634 const char *g_supplicant_interface_get_ifname(GSupplicantInterface *interface)
636 if (interface == NULL)
639 return interface->ifname;
642 const char *g_supplicant_interface_get_driver(GSupplicantInterface *interface)
644 if (interface == NULL)
647 return interface->driver;
650 GSupplicantState g_supplicant_interface_get_state(
651 GSupplicantInterface *interface)
653 if (interface == NULL)
654 return G_SUPPLICANT_STATE_UNKNOWN;
656 return interface->state;
659 const char *g_supplicant_interface_get_wps_key(GSupplicantInterface *interface)
661 if (interface == NULL)
664 return (const char *)interface->wps_cred.key;
667 const void *g_supplicant_interface_get_wps_ssid(GSupplicantInterface *interface,
668 unsigned int *ssid_len)
670 if (ssid_len == NULL)
673 if (interface == NULL || interface->wps_cred.ssid == NULL) {
678 *ssid_len = interface->wps_cred.ssid_len;
679 return interface->wps_cred.ssid;
682 GSupplicantWpsState g_supplicant_interface_get_wps_state(
683 GSupplicantInterface *interface)
685 if (interface == NULL)
686 return G_SUPPLICANT_WPS_STATE_UNKNOWN;
688 return interface->wps_state;
691 unsigned int g_supplicant_interface_get_mode(GSupplicantInterface *interface)
693 if (interface == NULL)
696 return interface->mode_capa;
699 GSupplicantInterface *g_supplicant_network_get_interface(
700 GSupplicantNetwork *network)
705 return network->interface;
708 const char *g_supplicant_network_get_name(GSupplicantNetwork *network)
710 if (network == NULL || network->name == NULL)
713 return network->name;
716 const char *g_supplicant_network_get_identifier(GSupplicantNetwork *network)
718 if (network == NULL || network->group == NULL)
721 return network->group;
724 const char *g_supplicant_network_get_path(GSupplicantNetwork *network)
726 if (network == NULL || network->path == NULL)
729 return network->path;
732 const char *g_supplicant_network_get_mode(GSupplicantNetwork *network)
735 return G_SUPPLICANT_MODE_UNKNOWN;
737 return mode2string(network->mode);
740 const char *g_supplicant_network_get_security(GSupplicantNetwork *network)
743 return G_SUPPLICANT_SECURITY_UNKNOWN;
745 return security2string(network->security);
748 const void *g_supplicant_network_get_ssid(GSupplicantNetwork *network,
749 unsigned int *ssid_len)
751 if (network == NULL || network->ssid == NULL) {
756 *ssid_len = network->ssid_len;
757 return network->ssid;
760 dbus_int16_t g_supplicant_network_get_signal(GSupplicantNetwork *network)
765 return network->signal;
768 dbus_bool_t g_supplicant_network_get_wps(GSupplicantNetwork *network)
776 static void merge_network(GSupplicantNetwork *network)
779 const char *ssid, *mode, *key_mgmt;
780 unsigned int i, ssid_len;
783 ssid = g_hash_table_lookup(network->config_table, "ssid");
784 mode = g_hash_table_lookup(network->config_table, "mode");
785 key_mgmt = g_hash_table_lookup(network->config_table, "key_mgmt");
787 SUPPLICANT_DBG("ssid %s mode %s", ssid, mode);
790 ssid_len = strlen(ssid);
794 str = g_string_sized_new((ssid_len * 2) + 24);
798 for (i = 0; i < ssid_len; i++)
799 g_string_append_printf(str, "%02x", ssid[i]);
801 if (g_strcmp0(mode, "0") == 0)
802 g_string_append_printf(str, "_managed");
803 else if (g_strcmp0(mode, "1") == 0)
804 g_string_append_printf(str, "_adhoc");
806 if (g_strcmp0(key_mgmt, "WPA-PSK") == 0)
807 g_string_append_printf(str, "_psk");
809 group = g_string_free(str, FALSE);
811 SUPPLICANT_DBG("%s", group);
815 g_hash_table_destroy(network->config_table);
817 g_free(network->path);
821 static void network_property(const char *key, DBusMessageIter *iter,
824 GSupplicantNetwork *network = user_data;
826 if (network->interface == NULL)
830 merge_network(network);
834 if (g_strcmp0(key, "Enabled") == 0) {
835 dbus_bool_t enabled = FALSE;
837 dbus_message_iter_get_basic(iter, &enabled);
838 } else if (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_STRING) {
839 const char *str = NULL;
841 dbus_message_iter_get_basic(iter, &str);
843 g_hash_table_replace(network->config_table,
844 g_strdup(key), g_strdup(str));
847 SUPPLICANT_DBG("key %s type %c",
848 key, dbus_message_iter_get_arg_type(iter));
851 static void interface_network_added(DBusMessageIter *iter, void *user_data)
853 GSupplicantInterface *interface = user_data;
854 GSupplicantNetwork *network;
855 const char *path = NULL;
859 dbus_message_iter_get_basic(iter, &path);
863 if (g_strcmp0(path, "/") == 0)
866 network = g_hash_table_lookup(interface->net_mapping, path);
870 network = g_try_new0(GSupplicantNetwork, 1);
874 network->interface = interface;
875 network->path = g_strdup(path);
877 network->config_table = g_hash_table_new_full(g_str_hash, g_str_equal,
880 dbus_message_iter_next(iter);
881 if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_INVALID) {
882 supplicant_dbus_property_foreach(iter, network_property,
884 network_property(NULL, NULL, network);
888 supplicant_dbus_property_get_all(path,
889 SUPPLICANT_INTERFACE ".Network",
890 network_property, network);
893 static void interface_network_removed(DBusMessageIter *iter, void *user_data)
895 GSupplicantInterface *interface = user_data;
896 GSupplicantNetwork *network;
897 const char *path = NULL;
899 dbus_message_iter_get_basic(iter, &path);
903 network = g_hash_table_lookup(interface->net_mapping, path);
907 g_hash_table_remove(interface->net_mapping, path);
910 static char *create_name(unsigned char *ssid, int ssid_len)
915 if (ssid_len < 1 || ssid[0] == '\0')
918 name = g_try_malloc0(ssid_len + 1);
923 for (i = 0; i < ssid_len; i++) {
924 if (g_ascii_isprint(ssid[i]))
933 static char *create_group(struct g_supplicant_bss *bss)
937 const char *mode, *security;
939 str = g_string_sized_new((bss->ssid_len * 2) + 24);
943 if (bss->ssid_len > 0 && bss->ssid[0] != '\0') {
944 for (i = 0; i < bss->ssid_len; i++)
945 g_string_append_printf(str, "%02x", bss->ssid[i]);
947 g_string_append_printf(str, "hidden");
949 mode = mode2string(bss->mode);
951 g_string_append_printf(str, "_%s", mode);
953 security = security2string(bss->security);
954 if (security != NULL)
955 g_string_append_printf(str, "_%s", security);
957 return g_string_free(str, FALSE);
960 static void add_bss_to_network(struct g_supplicant_bss *bss)
962 GSupplicantInterface *interface = bss->interface;
963 GSupplicantNetwork *network;
966 group = create_group(bss);
970 network = g_hash_table_lookup(interface->network_table, group);
971 if (network != NULL) {
976 network = g_try_new0(GSupplicantNetwork, 1);
977 if (network == NULL) {
982 network->interface = interface;
983 if (network->path == NULL)
984 network->path = g_strdup(bss->path);
985 network->group = group;
986 network->name = create_name(bss->ssid, bss->ssid_len);
987 network->mode = bss->mode;
988 network->security = bss->security;
989 network->ssid_len = bss->ssid_len;
990 memcpy(network->ssid, bss->ssid, bss->ssid_len);
991 network->signal = bss->signal;
993 network->wps = FALSE;
994 if ((bss->keymgmt & G_SUPPLICANT_KEYMGMT_WPS) != 0)
997 network->bss_table = g_hash_table_new_full(g_str_hash, g_str_equal,
1000 network->config_table = g_hash_table_new_full(g_str_hash, g_str_equal,
1003 g_hash_table_replace(interface->network_table,
1004 network->group, network);
1006 callback_network_added(network);
1009 g_hash_table_replace(interface->bss_mapping, bss->path, network);
1010 g_hash_table_replace(network->bss_table, bss->path, bss);
1012 g_hash_table_replace(bss_mapping, bss->path, interface);
1015 static void bss_rates(DBusMessageIter *iter, void *user_data)
1017 struct g_supplicant_bss *bss = user_data;
1018 dbus_uint32_t rate = 0;
1020 dbus_message_iter_get_basic(iter, &rate);
1024 if (rate > bss->maxrate)
1025 bss->maxrate = rate;
1028 static void bss_keymgmt(DBusMessageIter *iter, void *user_data)
1030 struct g_supplicant_bss *bss = user_data;
1031 const char *str = NULL;
1034 dbus_message_iter_get_basic(iter, &str);
1038 for (i = 0; keymgmt_map[i].str != NULL; i++)
1039 if (strcmp(str, keymgmt_map[i].str) == 0) {
1040 bss->keymgmt |= keymgmt_map[i].val;
1045 static void bss_group(DBusMessageIter *iter, void *user_data)
1047 struct g_supplicant_bss *bss = user_data;
1048 const char *str = NULL;
1051 dbus_message_iter_get_basic(iter, &str);
1055 for (i = 0; group_map[i].str != NULL; i++)
1056 if (strcmp(str, group_map[i].str) == 0) {
1057 bss->group |= group_map[i].val;
1062 static void bss_pairwise(DBusMessageIter *iter, void *user_data)
1064 struct g_supplicant_bss *bss = user_data;
1065 const char *str = NULL;
1068 dbus_message_iter_get_basic(iter, &str);
1072 for (i = 0; pairwise_map[i].str != NULL; i++)
1073 if (strcmp(str, pairwise_map[i].str) == 0) {
1074 bss->pairwise |= pairwise_map[i].val;
1079 static void bss_wpa(const char *key, DBusMessageIter *iter,
1082 if (g_strcmp0(key, "KeyMgmt") == 0)
1083 supplicant_dbus_array_foreach(iter, bss_keymgmt, user_data);
1084 else if (g_strcmp0(key, "Group") == 0)
1085 supplicant_dbus_array_foreach(iter, bss_group, user_data);
1086 else if (g_strcmp0(key, "Pairwise") == 0)
1087 supplicant_dbus_array_foreach(iter, bss_pairwise, user_data);
1091 static unsigned int get_tlv(unsigned char *ie, unsigned int ie_size,
1094 unsigned int len = 0;
1096 while (len + 4 < ie_size) {
1097 unsigned int hi = ie[len];
1098 unsigned int lo = ie[len + 1];
1099 unsigned int tmp_type = (hi << 8) + lo;
1100 unsigned int v_len = 0;
1102 /* hi and lo are used to recreate an unsigned int
1103 * based on 2 8bits length unsigned int. */
1107 v_len = (hi << 8) + lo;
1109 if (tmp_type == type) {
1110 unsigned int ret_value = 0;
1111 unsigned char *value = (unsigned char *)&ret_value;
1113 SUPPLICANT_DBG("IE: match type 0x%x", type);
1115 /* Verifying length relevance */
1116 if (v_len > sizeof(unsigned int) ||
1117 len + 4 + v_len > ie_size)
1120 memcpy(value, ie + len + 4, v_len);
1122 SUPPLICANT_DBG("returning 0x%x", ret_value);
1129 SUPPLICANT_DBG("returning 0");
1133 static void bss_process_ies(DBusMessageIter *iter, void *user_data)
1135 struct g_supplicant_bss *bss = user_data;
1136 const unsigned char WPS_OUI[] = { 0x00, 0x50, 0xf2, 0x04 };
1137 unsigned char *ie, *ie_end;
1138 DBusMessageIter array;
1141 #define WMM_WPA1_WPS_INFO 221
1142 #define WPS_INFO_MIN_LEN 6
1143 #define WPS_VERSION_TLV 0x104A
1144 #define WPS_STATE_TLV 0x1044
1145 #define WPS_VERSION 0x10
1147 dbus_message_iter_recurse(iter, &array);
1148 dbus_message_iter_get_fixed_array(&array, &ie, &ie_len);
1150 if (ie == NULL || ie_len < 2)
1153 for (ie_end = ie+ie_len; ie+ie[1]+1 <= ie_end; ie += ie[1]+2) {
1154 if (ie[0] != WMM_WPA1_WPS_INFO || ie[1] < WPS_INFO_MIN_LEN ||
1155 memcmp(ie+2, WPS_OUI, sizeof(WPS_OUI)) != 0)
1158 SUPPLICANT_DBG("IE: match WPS_OUI");
1160 if (get_tlv(&ie[6], ie[1],
1161 WPS_VERSION_TLV) == WPS_VERSION &&
1162 get_tlv(&ie[6], ie[1],
1163 WPS_STATE_TLV) != 0)
1164 bss->keymgmt |= G_SUPPLICANT_KEYMGMT_WPS;
1168 static void bss_property(const char *key, DBusMessageIter *iter,
1171 struct g_supplicant_bss *bss = user_data;
1173 if (bss->interface == NULL)
1176 SUPPLICANT_DBG("key %s", key);
1179 if (bss->ieee8021x == TRUE)
1180 bss->security = G_SUPPLICANT_SECURITY_IEEE8021X;
1181 else if (bss->psk == TRUE)
1182 bss->security = G_SUPPLICANT_SECURITY_PSK;
1183 else if (bss->privacy == TRUE)
1184 bss->security = G_SUPPLICANT_SECURITY_WEP;
1186 bss->security = G_SUPPLICANT_SECURITY_NONE;
1188 add_bss_to_network(bss);
1192 if (g_strcmp0(key, "BSSID") == 0) {
1193 DBusMessageIter array;
1194 unsigned char *addr;
1197 dbus_message_iter_recurse(iter, &array);
1198 dbus_message_iter_get_fixed_array(&array, &addr, &addr_len);
1201 memcpy(bss->bssid, addr, addr_len);
1202 } else if (g_strcmp0(key, "SSID") == 0) {
1203 DBusMessageIter array;
1204 unsigned char *ssid;
1207 dbus_message_iter_recurse(iter, &array);
1208 dbus_message_iter_get_fixed_array(&array, &ssid, &ssid_len);
1210 if (ssid_len > 0 && ssid_len < 33) {
1211 memcpy(bss->ssid, ssid, ssid_len);
1212 bss->ssid_len = ssid_len;
1214 memset(bss->ssid, 0, sizeof(bss->ssid));
1217 } else if (g_strcmp0(key, "Capabilities") == 0) {
1218 dbus_uint16_t capabilities = 0x0000;
1220 dbus_message_iter_get_basic(iter, &capabilities);
1222 if (capabilities & IEEE80211_CAP_ESS)
1223 bss->mode = G_SUPPLICANT_MODE_INFRA;
1224 else if (capabilities & IEEE80211_CAP_IBSS)
1225 bss->mode = G_SUPPLICANT_MODE_IBSS;
1227 if (capabilities & IEEE80211_CAP_PRIVACY)
1228 bss->privacy = TRUE;
1229 } else if (g_strcmp0(key, "Mode") == 0) {
1230 const char *mode = NULL;
1232 dbus_message_iter_get_basic(iter, &mode);
1233 bss->mode = string2mode(mode);
1234 } else if (g_strcmp0(key, "Frequency") == 0) {
1235 dbus_uint16_t frequency = 0;
1237 dbus_message_iter_get_basic(iter, &frequency);
1238 bss->frequency = frequency;
1239 } else if (g_strcmp0(key, "Signal") == 0) {
1240 dbus_int16_t signal = 0;
1242 dbus_message_iter_get_basic(iter, &signal);
1244 bss->signal = signal;
1245 } else if (g_strcmp0(key, "Level") == 0) {
1246 dbus_int32_t level = 0;
1248 dbus_message_iter_get_basic(iter, &level);
1249 } else if (g_strcmp0(key, "Rates") == 0) {
1250 supplicant_dbus_array_foreach(iter, bss_rates, bss);
1251 } else if (g_strcmp0(key, "MaxRate") == 0) {
1252 dbus_uint32_t maxrate = 0;
1254 dbus_message_iter_get_basic(iter, &maxrate);
1256 bss->maxrate = maxrate;
1257 } else if (g_strcmp0(key, "Privacy") == 0) {
1258 dbus_bool_t privacy = FALSE;
1260 dbus_message_iter_get_basic(iter, &privacy);
1261 bss->privacy = privacy;
1262 } else if ((g_strcmp0(key, "RSN") == 0) ||
1263 (g_strcmp0(key, "WPA") == 0)) {
1264 supplicant_dbus_property_foreach(iter, bss_wpa, bss);
1267 (G_SUPPLICANT_KEYMGMT_WPA_EAP |
1268 G_SUPPLICANT_KEYMGMT_WPA_FT_EAP |
1269 G_SUPPLICANT_KEYMGMT_WPA_EAP_256))
1270 bss->ieee8021x = TRUE;
1273 (G_SUPPLICANT_KEYMGMT_WPA_PSK |
1274 G_SUPPLICANT_KEYMGMT_WPA_FT_PSK |
1275 G_SUPPLICANT_KEYMGMT_WPA_PSK_256))
1277 } else if (g_strcmp0(key, "IEs") == 0)
1278 bss_process_ies(iter, bss);
1280 SUPPLICANT_DBG("key %s type %c",
1281 key, dbus_message_iter_get_arg_type(iter));
1284 static struct g_supplicant_bss *interface_bss_added(DBusMessageIter *iter,
1287 GSupplicantInterface *interface = user_data;
1288 GSupplicantNetwork *network;
1289 struct g_supplicant_bss *bss;
1290 const char *path = NULL;
1294 dbus_message_iter_get_basic(iter, &path);
1298 if (g_strcmp0(path, "/") == 0)
1301 SUPPLICANT_DBG("%s", path);
1303 network = g_hash_table_lookup(interface->bss_mapping, path);
1304 if (network != NULL) {
1305 bss = g_hash_table_lookup(network->bss_table, path);
1310 bss = g_try_new0(struct g_supplicant_bss, 1);
1314 bss->interface = interface;
1315 bss->path = g_strdup(path);
1320 static void interface_bss_added_with_keys(DBusMessageIter *iter,
1323 struct g_supplicant_bss *bss;
1327 bss = interface_bss_added(iter, user_data);
1331 dbus_message_iter_next(iter);
1333 if (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_INVALID)
1336 supplicant_dbus_property_foreach(iter, bss_property, bss);
1337 bss_property(NULL, NULL, bss);
1340 static void interface_bss_added_without_keys(DBusMessageIter *iter,
1343 struct g_supplicant_bss *bss;
1347 bss = interface_bss_added(iter, user_data);
1351 supplicant_dbus_property_get_all(bss->path,
1352 SUPPLICANT_INTERFACE ".BSS",
1356 static void interface_bss_removed(DBusMessageIter *iter, void *user_data)
1358 GSupplicantInterface *interface = user_data;
1359 GSupplicantNetwork *network;
1360 const char *path = NULL;
1362 dbus_message_iter_get_basic(iter, &path);
1366 network = g_hash_table_lookup(interface->bss_mapping, path);
1367 if (network == NULL)
1370 g_hash_table_remove(bss_mapping, path);
1372 g_hash_table_remove(interface->bss_mapping, path);
1373 g_hash_table_remove(network->bss_table, path);
1375 if (g_hash_table_size(network->bss_table) == 0)
1376 g_hash_table_remove(interface->network_table, network->group);
1379 static void interface_property(const char *key, DBusMessageIter *iter,
1382 GSupplicantInterface *interface = user_data;
1384 if (interface == NULL)
1387 SUPPLICANT_DBG("%s", key);
1390 debug_strvalmap("KeyMgmt capability", keymgmt_map,
1391 interface->keymgmt_capa);
1392 debug_strvalmap("AuthAlg capability", authalg_capa_map,
1393 interface->authalg_capa);
1394 debug_strvalmap("Protocol capability", proto_capa_map,
1395 interface->proto_capa);
1396 debug_strvalmap("Pairwise capability", pairwise_map,
1397 interface->pairwise_capa);
1398 debug_strvalmap("Group capability", group_map,
1399 interface->group_capa);
1400 debug_strvalmap("Scan capability", scan_capa_map,
1401 interface->scan_capa);
1402 debug_strvalmap("Mode capability", mode_capa_map,
1403 interface->mode_capa);
1405 interface->ready = TRUE;
1406 callback_interface_added(interface);
1410 if (g_strcmp0(key, "Capabilities") == 0) {
1411 supplicant_dbus_property_foreach(iter, interface_capability,
1413 } else if (g_strcmp0(key, "State") == 0) {
1414 const char *str = NULL;
1416 dbus_message_iter_get_basic(iter, &str);
1418 if (string2state(str) != interface->state) {
1419 interface->state = string2state(str);
1420 callback_interface_state(interface);
1423 SUPPLICANT_DBG("state %s (%d)", str, interface->state);
1424 } else if (g_strcmp0(key, "Scanning") == 0) {
1425 dbus_bool_t scanning = FALSE;
1427 dbus_message_iter_get_basic(iter, &scanning);
1428 interface->scanning = scanning;
1430 if (interface->ready == TRUE) {
1431 if (interface->scanning == TRUE)
1432 callback_scan_started(interface);
1434 callback_scan_finished(interface);
1436 } else if (g_strcmp0(key, "ApScan") == 0) {
1439 dbus_message_iter_get_basic(iter, &apscan);
1440 interface->apscan = apscan;
1441 } else if (g_strcmp0(key, "Ifname") == 0) {
1442 const char *str = NULL;
1444 dbus_message_iter_get_basic(iter, &str);
1446 g_free(interface->ifname);
1447 interface->ifname = g_strdup(str);
1449 } else if (g_strcmp0(key, "Driver") == 0) {
1450 const char *str = NULL;
1452 dbus_message_iter_get_basic(iter, &str);
1454 g_free(interface->driver);
1455 interface->driver = g_strdup(str);
1457 } else if (g_strcmp0(key, "BridgeIfname") == 0) {
1458 const char *str = NULL;
1460 dbus_message_iter_get_basic(iter, &str);
1462 g_free(interface->bridge);
1463 interface->bridge = g_strdup(str);
1465 } else if (g_strcmp0(key, "CurrentBSS") == 0) {
1466 interface_bss_added_without_keys(iter, interface);
1467 } else if (g_strcmp0(key, "CurrentNetwork") == 0) {
1468 interface_network_added(iter, interface);
1469 } else if (g_strcmp0(key, "BSSs") == 0) {
1470 supplicant_dbus_array_foreach(iter, interface_bss_added_without_keys,
1472 } else if (g_strcmp0(key, "Blobs") == 0) {
1474 } else if (g_strcmp0(key, "Networks") == 0) {
1475 supplicant_dbus_array_foreach(iter, interface_network_added,
1478 SUPPLICANT_DBG("key %s type %c",
1479 key, dbus_message_iter_get_arg_type(iter));
1482 static void scan_network_update(DBusMessageIter *iter, void *user_data)
1484 GSupplicantInterface *interface = user_data;
1485 GSupplicantNetwork *network;
1491 dbus_message_iter_get_basic(iter, &path);
1496 if (g_strcmp0(path, "/") == 0)
1499 /* Update the network details based on scan BSS data */
1500 network = g_hash_table_lookup(interface->bss_mapping, path);
1501 if (network != NULL)
1502 callback_network_added(network);
1505 static void scan_bss_data(const char *key, DBusMessageIter *iter,
1508 GSupplicantInterface *interface = user_data;
1511 supplicant_dbus_array_foreach(iter, scan_network_update,
1514 if (interface->scan_callback != NULL)
1515 interface->scan_callback(0, interface, interface->scan_data);
1517 interface->scan_callback = NULL;
1518 interface->scan_data = NULL;
1521 static GSupplicantInterface *interface_alloc(const char *path)
1523 GSupplicantInterface *interface;
1525 interface = g_try_new0(GSupplicantInterface, 1);
1526 if (interface == NULL)
1529 interface->path = g_strdup(path);
1531 interface->network_table = g_hash_table_new_full(g_str_hash,
1532 g_str_equal, NULL, remove_network);
1534 interface->net_mapping = g_hash_table_new_full(g_str_hash, g_str_equal,
1536 interface->bss_mapping = g_hash_table_new_full(g_str_hash, g_str_equal,
1539 g_hash_table_replace(interface_table, interface->path, interface);
1544 static void interface_added(DBusMessageIter *iter, void *user_data)
1546 GSupplicantInterface *interface;
1547 const char *path = NULL;
1551 dbus_message_iter_get_basic(iter, &path);
1555 if (g_strcmp0(path, "/") == 0)
1558 interface = g_hash_table_lookup(interface_table, path);
1559 if (interface != NULL)
1562 interface = interface_alloc(path);
1563 if (interface == NULL)
1566 dbus_message_iter_next(iter);
1567 if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_INVALID) {
1568 supplicant_dbus_property_foreach(iter, interface_property,
1570 interface_property(NULL, NULL, interface);
1574 supplicant_dbus_property_get_all(path,
1575 SUPPLICANT_INTERFACE ".Interface",
1576 interface_property, interface);
1579 static void interface_removed(DBusMessageIter *iter, void *user_data)
1581 const char *path = NULL;
1583 dbus_message_iter_get_basic(iter, &path);
1587 g_hash_table_remove(interface_table, path);
1590 static void eap_method(DBusMessageIter *iter, void *user_data)
1592 const char *str = NULL;
1595 dbus_message_iter_get_basic(iter, &str);
1599 for (i = 0; eap_method_map[i].str != NULL; i++)
1600 if (strcmp(str, eap_method_map[i].str) == 0) {
1601 eap_methods |= eap_method_map[i].val;
1606 static void service_property(const char *key, DBusMessageIter *iter,
1610 callback_system_ready();
1614 if (g_strcmp0(key, "DebugLevel") == 0) {
1615 const char *str = NULL;
1618 dbus_message_iter_get_basic(iter, &str);
1619 for (i = 0; debug_strings[i] != NULL; i++)
1620 if (g_strcmp0(debug_strings[i], str) == 0) {
1624 SUPPLICANT_DBG("Debug level %d", debug_level);
1625 } else if (g_strcmp0(key, "DebugTimestamp") == 0) {
1626 dbus_message_iter_get_basic(iter, &debug_timestamp);
1627 SUPPLICANT_DBG("Debug timestamp %u", debug_timestamp);
1628 } else if (g_strcmp0(key, "DebugShowKeys") == 0) {
1629 dbus_message_iter_get_basic(iter, &debug_showkeys);
1630 SUPPLICANT_DBG("Debug show keys %u", debug_showkeys);
1631 } else if (g_strcmp0(key, "Interfaces") == 0) {
1632 supplicant_dbus_array_foreach(iter, interface_added, NULL);
1633 } else if (g_strcmp0(key, "EapMethods") == 0) {
1634 supplicant_dbus_array_foreach(iter, eap_method, NULL);
1635 debug_strvalmap("EAP method", eap_method_map, eap_methods);
1636 } else if (g_strcmp0(key, "Country") == 0) {
1637 const char *country = NULL;
1639 dbus_message_iter_get_basic(iter, &country);
1640 SUPPLICANT_DBG("Country %s", country);
1642 SUPPLICANT_DBG("key %s type %c",
1643 key, dbus_message_iter_get_arg_type(iter));
1646 static void signal_name_owner_changed(const char *path, DBusMessageIter *iter)
1648 const char *name = NULL, *old = NULL, *new = NULL;
1652 if (g_strcmp0(path, DBUS_PATH_DBUS) != 0)
1655 dbus_message_iter_get_basic(iter, &name);
1659 if (g_strcmp0(name, SUPPLICANT_SERVICE) != 0)
1662 dbus_message_iter_next(iter);
1663 dbus_message_iter_get_basic(iter, &old);
1664 dbus_message_iter_next(iter);
1665 dbus_message_iter_get_basic(iter, &new);
1667 if (old == NULL || new == NULL)
1670 if (strlen(old) > 0 && strlen(new) == 0) {
1671 system_available = FALSE;
1672 g_hash_table_remove_all(bss_mapping);
1673 g_hash_table_remove_all(interface_table);
1674 callback_system_killed();
1677 if (strlen(new) > 0 && strlen(old) == 0) {
1678 system_available = TRUE;
1679 supplicant_dbus_property_get_all(SUPPLICANT_PATH,
1680 SUPPLICANT_INTERFACE,
1681 service_property, NULL);
1685 static void signal_properties_changed(const char *path, DBusMessageIter *iter)
1689 if (g_strcmp0(path, SUPPLICANT_PATH) != 0)
1692 supplicant_dbus_property_foreach(iter, service_property, NULL);
1695 static void signal_interface_added(const char *path, DBusMessageIter *iter)
1697 SUPPLICANT_DBG("path %s %s", path, SUPPLICANT_PATH);
1699 if (g_strcmp0(path, SUPPLICANT_PATH) == 0)
1700 interface_added(iter, NULL);
1703 static void signal_interface_removed(const char *path, DBusMessageIter *iter)
1707 if (g_strcmp0(path, SUPPLICANT_PATH) == 0)
1708 interface_removed(iter, NULL);
1711 static void signal_interface_changed(const char *path, DBusMessageIter *iter)
1713 GSupplicantInterface *interface;
1717 interface = g_hash_table_lookup(interface_table, path);
1718 if (interface == NULL)
1721 supplicant_dbus_property_foreach(iter, interface_property, interface);
1724 static void signal_scan_done(const char *path, DBusMessageIter *iter)
1726 GSupplicantInterface *interface;
1727 dbus_bool_t success = FALSE;
1731 interface = g_hash_table_lookup(interface_table, path);
1732 if (interface == NULL)
1735 dbus_message_iter_get_basic(iter, &success);
1738 * If scan is unsuccessful return -EIO else get the scanned BSSs
1739 * and update the network details accordingly
1741 if (success == FALSE) {
1742 if (interface->scan_callback != NULL)
1743 interface->scan_callback(-EIO, interface,
1744 interface->scan_data);
1746 interface->scan_callback = NULL;
1747 interface->scan_data = NULL;
1752 supplicant_dbus_property_get(path, SUPPLICANT_INTERFACE ".Interface",
1753 "BSSs", scan_bss_data, interface);
1756 static void signal_bss_added(const char *path, DBusMessageIter *iter)
1758 GSupplicantInterface *interface;
1762 interface = g_hash_table_lookup(interface_table, path);
1763 if (interface == NULL)
1766 interface_bss_added_with_keys(iter, interface);
1769 static void signal_bss_removed(const char *path, DBusMessageIter *iter)
1771 GSupplicantInterface *interface;
1775 interface = g_hash_table_lookup(interface_table, path);
1776 if (interface == NULL)
1779 interface_bss_removed(iter, interface);
1782 static void signal_network_added(const char *path, DBusMessageIter *iter)
1784 GSupplicantInterface *interface;
1788 interface = g_hash_table_lookup(interface_table, path);
1789 if (interface == NULL)
1792 interface_network_added(iter, interface);
1795 static void signal_network_removed(const char *path, DBusMessageIter *iter)
1797 GSupplicantInterface *interface;
1801 interface = g_hash_table_lookup(interface_table, path);
1802 if (interface == NULL)
1805 interface_network_removed(iter, interface);
1808 static void signal_bss_changed(const char *path, DBusMessageIter *iter)
1810 GSupplicantInterface *interface;
1811 GSupplicantNetwork *network;
1812 struct g_supplicant_bss *bss;
1816 interface = g_hash_table_lookup(bss_mapping, path);
1817 if (interface == NULL)
1820 network = g_hash_table_lookup(interface->bss_mapping, path);
1821 if (network == NULL)
1824 bss = g_hash_table_lookup(network->bss_table, path);
1828 supplicant_dbus_property_foreach(iter, bss_property, bss);
1831 static void wps_credentials(const char *key, DBusMessageIter *iter,
1834 GSupplicantInterface *interface = user_data;
1839 SUPPLICANT_DBG("key %s", key);
1841 if (g_strcmp0(key, "Key") == 0) {
1842 DBusMessageIter array;
1846 dbus_message_iter_recurse(iter, &array);
1847 dbus_message_iter_get_fixed_array(&array, &key, &key_len);
1849 g_free(interface->wps_cred.key);
1850 interface->wps_cred.key = g_try_malloc0(
1851 sizeof(char) * key_len+1);
1853 if (interface->wps_cred.key == NULL)
1856 memcpy(interface->wps_cred.key, key, sizeof(char) * key_len);
1858 SUPPLICANT_DBG("WPS key present");
1859 } else if (g_strcmp0(key, "SSID") == 0) {
1860 DBusMessageIter array;
1861 unsigned char *ssid;
1864 dbus_message_iter_recurse(iter, &array);
1865 dbus_message_iter_get_fixed_array(&array, &ssid, &ssid_len);
1867 if (ssid_len > 0 && ssid_len < 33) {
1868 memcpy(interface->wps_cred.ssid, ssid, ssid_len);
1869 interface->wps_cred.ssid_len = ssid_len;
1871 memset(interface->wps_cred.ssid, 0, 32);
1872 interface->wps_cred.ssid_len = 0;
1877 static void signal_wps_credentials(const char *path, DBusMessageIter *iter)
1879 GSupplicantInterface *interface;
1883 interface = g_hash_table_lookup(interface_table, path);
1884 if (interface == NULL)
1887 supplicant_dbus_property_foreach(iter, wps_credentials, interface);
1890 static void wps_event_args(const char *key, DBusMessageIter *iter,
1893 GSupplicantInterface *interface = user_data;
1895 if (key == NULL || interface == NULL)
1898 SUPPLICANT_DBG("Arg Key %s", key);
1901 static void signal_wps_event(const char *path, DBusMessageIter *iter)
1903 GSupplicantInterface *interface;
1904 const char *name = NULL;
1908 interface = g_hash_table_lookup(interface_table, path);
1909 if (interface == NULL)
1912 dbus_message_iter_get_basic(iter, &name);
1914 SUPPLICANT_DBG("Name: %s", name);
1916 if (g_strcmp0(name, "success") == 0)
1917 interface->wps_state = G_SUPPLICANT_WPS_STATE_SUCCESS;
1918 else if (g_strcmp0(name, "failed") == 0)
1919 interface->wps_state = G_SUPPLICANT_WPS_STATE_FAIL;
1921 interface->wps_state = G_SUPPLICANT_WPS_STATE_UNKNOWN;
1923 if (!dbus_message_iter_has_next(iter))
1926 dbus_message_iter_next(iter);
1928 supplicant_dbus_property_foreach(iter, wps_event_args, interface);
1932 const char *interface;
1934 void (*function) (const char *path, DBusMessageIter *iter);
1936 { DBUS_INTERFACE_DBUS, "NameOwnerChanged", signal_name_owner_changed },
1938 { SUPPLICANT_INTERFACE, "PropertiesChanged", signal_properties_changed },
1939 { SUPPLICANT_INTERFACE, "InterfaceAdded", signal_interface_added },
1940 { SUPPLICANT_INTERFACE, "InterfaceCreated", signal_interface_added },
1941 { SUPPLICANT_INTERFACE, "InterfaceRemoved", signal_interface_removed },
1943 { SUPPLICANT_INTERFACE ".Interface", "PropertiesChanged", signal_interface_changed },
1944 { SUPPLICANT_INTERFACE ".Interface", "ScanDone", signal_scan_done },
1945 { SUPPLICANT_INTERFACE ".Interface", "BSSAdded", signal_bss_added },
1946 { SUPPLICANT_INTERFACE ".Interface", "BSSRemoved", signal_bss_removed },
1947 { SUPPLICANT_INTERFACE ".Interface", "NetworkAdded", signal_network_added },
1948 { SUPPLICANT_INTERFACE ".Interface", "NetworkRemoved", signal_network_removed },
1950 { SUPPLICANT_INTERFACE ".BSS", "PropertiesChanged", signal_bss_changed },
1952 { SUPPLICANT_INTERFACE ".Interface.WPS", "Credentials", signal_wps_credentials },
1953 { SUPPLICANT_INTERFACE ".Interface.WPS", "Event", signal_wps_event },
1958 static DBusHandlerResult g_supplicant_filter(DBusConnection *conn,
1959 DBusMessage *message, void *data)
1961 DBusMessageIter iter;
1965 path = dbus_message_get_path(message);
1967 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1969 if (dbus_message_iter_init(message, &iter) == FALSE)
1970 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1972 for (i = 0; signal_map[i].interface != NULL; i++) {
1973 if (dbus_message_has_interface(message,
1974 signal_map[i].interface) == FALSE)
1977 if (dbus_message_has_member(message,
1978 signal_map[i].member) == FALSE)
1981 signal_map[i].function(path, &iter);
1985 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1988 struct supplicant_regdom {
1989 GSupplicantCountryCallback callback;
1990 const void *user_data;
1993 static void country_result(const char *error,
1994 DBusMessageIter *iter, void *user_data)
1996 struct supplicant_regdom *regdom = user_data;
1999 SUPPLICANT_DBG("Country setting result");
2001 if (user_data == NULL)
2004 if (error == NULL) {
2005 alpha2 = (char *)regdom->user_data;
2007 SUPPLICANT_DBG("Country setting failure %s", error);
2011 if (regdom->callback)
2012 regdom->callback(alpha2);
2017 static void country_params(DBusMessageIter *iter, void *user_data)
2019 struct supplicant_regdom *regdom = user_data;
2020 const char *country;
2022 country = regdom->user_data;
2024 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &country);
2027 int g_supplicant_set_country(const char *alpha2,
2028 GSupplicantCountryCallback callback,
2029 const void *user_data)
2031 struct supplicant_regdom *regdom;
2033 SUPPLICANT_DBG("Country setting %s", alpha2);
2035 if (system_available == FALSE)
2038 regdom = dbus_malloc0(sizeof(*regdom));
2042 regdom->callback = callback;
2043 regdom->user_data = user_data;
2045 return supplicant_dbus_property_set(SUPPLICANT_PATH, SUPPLICANT_INTERFACE,
2046 "Country", DBUS_TYPE_STRING_AS_STRING,
2047 country_params, country_result,
2051 struct interface_data {
2052 GSupplicantInterface *interface;
2053 GSupplicantInterfaceCallback callback;
2057 struct interface_create_data {
2060 GSupplicantInterface *interface;
2061 GSupplicantInterfaceCallback callback;
2065 struct interface_connect_data {
2066 GSupplicantInterface *interface;
2067 GSupplicantInterfaceCallback callback;
2068 GSupplicantSSID *ssid;
2072 static void interface_create_property(const char *key, DBusMessageIter *iter,
2075 struct interface_create_data *data = user_data;
2076 GSupplicantInterface *interface = data->interface;
2079 if (data->callback != NULL)
2080 data->callback(0, data->interface, data->user_data);
2085 interface_property(key, iter, interface);
2088 static void interface_create_result(const char *error,
2089 DBusMessageIter *iter, void *user_data)
2091 struct interface_create_data *data = user_data;
2092 const char *path = NULL;
2097 if (error != NULL) {
2098 g_critical("error %s", error);
2103 dbus_message_iter_get_basic(iter, &path);
2109 if (system_available == FALSE) {
2114 data->interface = g_hash_table_lookup(interface_table, path);
2115 if (data->interface == NULL) {
2116 data->interface = interface_alloc(path);
2117 if (data->interface == NULL) {
2123 err = supplicant_dbus_property_get_all(path,
2124 SUPPLICANT_INTERFACE ".Interface",
2125 interface_create_property, data);
2130 if (data->callback != NULL)
2131 data->callback(err, NULL, data->user_data);
2136 static void interface_create_params(DBusMessageIter *iter, void *user_data)
2138 struct interface_create_data *data = user_data;
2139 DBusMessageIter dict;
2143 supplicant_dbus_dict_open(iter, &dict);
2145 supplicant_dbus_dict_append_basic(&dict, "Ifname",
2146 DBUS_TYPE_STRING, &data->ifname);
2148 if (data->driver != NULL)
2149 supplicant_dbus_dict_append_basic(&dict, "Driver",
2150 DBUS_TYPE_STRING, &data->driver);
2152 supplicant_dbus_dict_close(iter, &dict);
2155 static void interface_get_result(const char *error,
2156 DBusMessageIter *iter, void *user_data)
2158 struct interface_create_data *data = user_data;
2159 GSupplicantInterface *interface;
2160 const char *path = NULL;
2165 if (error != NULL) {
2166 SUPPLICANT_DBG("Interface not created yet");
2171 dbus_message_iter_get_basic(iter, &path);
2177 interface = g_hash_table_lookup(interface_table, path);
2178 if (interface == NULL) {
2183 if (data->callback != NULL)
2184 data->callback(0, interface, data->user_data);
2191 if (system_available == FALSE) {
2196 SUPPLICANT_DBG("Creating interface");
2198 err = supplicant_dbus_method_call(SUPPLICANT_PATH,
2199 SUPPLICANT_INTERFACE,
2201 interface_create_params,
2202 interface_create_result, data);
2207 if (data->callback != NULL)
2208 data->callback(err, NULL, data->user_data);
2213 static void interface_get_params(DBusMessageIter *iter, void *user_data)
2215 struct interface_create_data *data = user_data;
2219 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &data->ifname);
2222 int g_supplicant_interface_create(const char *ifname, const char *driver,
2223 GSupplicantInterfaceCallback callback,
2226 struct interface_create_data *data;
2228 SUPPLICANT_DBG("ifname %s", ifname);
2233 if (system_available == FALSE)
2236 data = dbus_malloc0(sizeof(*data));
2240 data->ifname = ifname;
2241 data->driver = driver;
2242 data->callback = callback;
2243 data->user_data = user_data;
2245 return supplicant_dbus_method_call(SUPPLICANT_PATH,
2246 SUPPLICANT_INTERFACE,
2248 interface_get_params,
2249 interface_get_result, data);
2252 static void interface_remove_result(const char *error,
2253 DBusMessageIter *iter, void *user_data)
2255 struct interface_data *data = user_data;
2258 if (error != NULL) {
2263 if (system_available == FALSE) {
2269 * The gsupplicant interface is already freed by the InterfaceRemoved
2270 * signal callback. Simply invoke the interface_data callback.
2275 if (data->callback != NULL)
2276 data->callback(err, NULL, data->user_data);
2282 static void interface_remove_params(DBusMessageIter *iter, void *user_data)
2284 struct interface_data *data = user_data;
2286 dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
2287 &data->interface->path);
2291 int g_supplicant_interface_remove(GSupplicantInterface *interface,
2292 GSupplicantInterfaceCallback callback,
2295 struct interface_data *data;
2297 if (interface == NULL)
2300 if (system_available == FALSE)
2303 data = dbus_malloc0(sizeof(*data));
2307 data->interface = interface;
2308 data->callback = callback;
2309 data->user_data = user_data;
2311 return supplicant_dbus_method_call(SUPPLICANT_PATH,
2312 SUPPLICANT_INTERFACE,
2314 interface_remove_params,
2315 interface_remove_result, data);
2318 static void interface_scan_result(const char *error,
2319 DBusMessageIter *iter, void *user_data)
2321 struct interface_data *data = user_data;
2323 if (error != NULL) {
2324 if (data->callback != NULL)
2325 data->callback(-EIO, data->interface, data->user_data);
2327 data->interface->scan_callback = data->callback;
2328 data->interface->scan_data = data->user_data;
2334 static void interface_scan_params(DBusMessageIter *iter, void *user_data)
2336 DBusMessageIter dict;
2337 const char *type = "passive";
2339 supplicant_dbus_dict_open(iter, &dict);
2341 supplicant_dbus_dict_append_basic(&dict, "Type",
2342 DBUS_TYPE_STRING, &type);
2344 supplicant_dbus_dict_close(iter, &dict);
2347 int g_supplicant_interface_scan(GSupplicantInterface *interface,
2348 GSupplicantInterfaceCallback callback,
2351 struct interface_data *data;
2353 if (interface == NULL)
2356 if (system_available == FALSE)
2359 if (interface->scanning == TRUE)
2362 switch (interface->state) {
2363 case G_SUPPLICANT_STATE_AUTHENTICATING:
2364 case G_SUPPLICANT_STATE_ASSOCIATING:
2365 case G_SUPPLICANT_STATE_ASSOCIATED:
2366 case G_SUPPLICANT_STATE_4WAY_HANDSHAKE:
2367 case G_SUPPLICANT_STATE_GROUP_HANDSHAKE:
2369 case G_SUPPLICANT_STATE_UNKNOWN:
2370 case G_SUPPLICANT_STATE_DISCONNECTED:
2371 case G_SUPPLICANT_STATE_INACTIVE:
2372 case G_SUPPLICANT_STATE_SCANNING:
2373 case G_SUPPLICANT_STATE_COMPLETED:
2377 data = dbus_malloc0(sizeof(*data));
2381 data->interface = interface;
2382 data->callback = callback;
2383 data->user_data = user_data;
2385 return supplicant_dbus_method_call(interface->path,
2386 SUPPLICANT_INTERFACE ".Interface", "Scan",
2387 interface_scan_params, interface_scan_result, data);
2390 static void interface_select_network_result(const char *error,
2391 DBusMessageIter *iter, void *user_data)
2393 struct interface_connect_data *data = user_data;
2401 static void interface_select_network_params(DBusMessageIter *iter,
2404 struct interface_connect_data *data = user_data;
2405 GSupplicantInterface *interface = data->interface;
2407 dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
2408 &interface->network_path);
2411 static void interface_add_network_result(const char *error,
2412 DBusMessageIter *iter, void *user_data)
2414 struct interface_connect_data *data = user_data;
2415 GSupplicantInterface *interface = data->interface;
2421 dbus_message_iter_get_basic(iter, &path);
2425 SUPPLICANT_DBG("PATH: %s", path);
2427 g_free(interface->network_path);
2428 interface->network_path = g_strdup(path);
2430 supplicant_dbus_method_call(data->interface->path,
2431 SUPPLICANT_INTERFACE ".Interface", "SelectNetwork",
2432 interface_select_network_params,
2433 interface_select_network_result, data);
2438 g_free(interface->network_path);
2439 interface->network_path = NULL;
2444 static void add_network_security_wep(DBusMessageIter *dict,
2445 GSupplicantSSID *ssid)
2447 const char *auth_alg = "OPEN SHARED";
2448 const char *key_index = "0";
2450 supplicant_dbus_dict_append_basic(dict, "auth_alg",
2451 DBUS_TYPE_STRING, &auth_alg);
2453 if (ssid->passphrase) {
2454 int size = strlen(ssid->passphrase);
2455 if (size == 10 || size == 26) {
2456 unsigned char *key = g_try_malloc(13);
2460 memset(tmp, 0, sizeof(tmp));
2464 for (i = 0; i < size / 2; i++) {
2465 memcpy(tmp, ssid->passphrase + (i * 2), 2);
2466 key[i] = (unsigned char) strtol(tmp, NULL, 16);
2469 supplicant_dbus_dict_append_fixed_array(dict,
2474 } else if (size == 5 || size == 13) {
2475 unsigned char *key = g_try_malloc(13);
2481 for (i = 0; i < size; i++)
2482 key[i] = (unsigned char) ssid->passphrase[i];
2484 supplicant_dbus_dict_append_fixed_array(dict,
2490 supplicant_dbus_dict_append_basic(dict,
2495 supplicant_dbus_dict_append_basic(dict, "wep_tx_keyidx",
2496 DBUS_TYPE_STRING, &key_index);
2500 static void add_network_security_psk(DBusMessageIter *dict,
2501 GSupplicantSSID *ssid)
2503 if (ssid->passphrase && strlen(ssid->passphrase) > 0)
2504 supplicant_dbus_dict_append_basic(dict, "psk",
2509 static void add_network_security_tls(DBusMessageIter *dict,
2510 GSupplicantSSID *ssid)
2513 * For TLS, we at least need:
2514 * The client certificate
2515 * The client private key file
2516 * The client private key file password
2518 * The Authority certificate is optional.
2520 if (ssid->client_cert_path == NULL)
2523 if (ssid->private_key_path == NULL)
2526 if (ssid->private_key_passphrase == NULL)
2529 if (ssid->ca_cert_path)
2530 supplicant_dbus_dict_append_basic(dict, "ca_cert",
2531 DBUS_TYPE_STRING, &ssid->ca_cert_path);
2533 supplicant_dbus_dict_append_basic(dict, "private_key",
2535 &ssid->private_key_path);
2536 supplicant_dbus_dict_append_basic(dict, "private_key_passwd",
2538 &ssid->private_key_passphrase);
2539 supplicant_dbus_dict_append_basic(dict, "client_cert",
2541 &ssid->client_cert_path);
2544 static void add_network_security_peap(DBusMessageIter *dict,
2545 GSupplicantSSID *ssid)
2550 * For PEAP/TTLS, we at least need
2551 * The authority certificate
2552 * The 2nd phase authentication method
2553 * The 2nd phase passphrase
2555 * The Client certificate is optional although strongly required
2556 * When setting it, we need in addition
2557 * The Client private key file
2558 * The Client private key file password
2560 if (ssid->passphrase == NULL)
2563 if (ssid->ca_cert_path == NULL)
2566 if (ssid->phase2_auth == NULL)
2569 if (ssid->client_cert_path) {
2570 if (ssid->private_key_path == NULL)
2573 if (ssid->private_key_passphrase == NULL)
2576 supplicant_dbus_dict_append_basic(dict, "client_cert",
2578 &ssid->client_cert_path);
2580 supplicant_dbus_dict_append_basic(dict, "private_key",
2582 &ssid->private_key_path);
2584 supplicant_dbus_dict_append_basic(dict, "private_key_passwd",
2586 &ssid->private_key_passphrase);
2590 if (g_str_has_prefix(ssid->phase2_auth, "EAP-") == TRUE) {
2591 phase2_auth = g_strdup_printf("autheap=%s",
2592 ssid->phase2_auth + strlen("EAP-"));
2594 phase2_auth = g_strdup_printf("auth=%s", ssid->phase2_auth);
2596 supplicant_dbus_dict_append_basic(dict, "password",
2600 supplicant_dbus_dict_append_basic(dict, "ca_cert",
2602 &ssid->ca_cert_path);
2604 supplicant_dbus_dict_append_basic(dict, "phase2",
2608 g_free(phase2_auth);
2611 static void add_network_security_eap(DBusMessageIter *dict,
2612 GSupplicantSSID *ssid)
2616 if (ssid->eap == NULL || ssid->identity == NULL)
2619 if (g_strcmp0(ssid->eap, "tls") == 0) {
2620 add_network_security_tls(dict, ssid);
2621 } else if (g_strcmp0(ssid->eap, "peap") == 0 ||
2622 g_strcmp0(ssid->eap, "ttls") == 0) {
2623 add_network_security_peap(dict, ssid);
2627 eap_value = g_ascii_strup(ssid->eap, -1);
2629 supplicant_dbus_dict_append_basic(dict, "eap",
2632 supplicant_dbus_dict_append_basic(dict, "identity",
2639 static void add_network_security(DBusMessageIter *dict, GSupplicantSSID *ssid)
2643 switch (ssid->security) {
2644 case G_SUPPLICANT_SECURITY_UNKNOWN:
2645 case G_SUPPLICANT_SECURITY_NONE:
2646 case G_SUPPLICANT_SECURITY_WEP:
2648 add_network_security_wep(dict, ssid);
2650 case G_SUPPLICANT_SECURITY_PSK:
2651 key_mgmt = "WPA-PSK";
2652 add_network_security_psk(dict, ssid);
2654 case G_SUPPLICANT_SECURITY_IEEE8021X:
2655 key_mgmt = "WPA-EAP";
2656 add_network_security_eap(dict, ssid);
2660 supplicant_dbus_dict_append_basic(dict, "key_mgmt",
2661 DBUS_TYPE_STRING, &key_mgmt);
2664 static void add_network_mode(DBusMessageIter *dict, GSupplicantSSID *ssid)
2668 switch (ssid->mode) {
2669 case G_SUPPLICANT_MODE_UNKNOWN:
2670 case G_SUPPLICANT_MODE_INFRA:
2673 case G_SUPPLICANT_MODE_IBSS:
2676 case G_SUPPLICANT_MODE_MASTER:
2681 supplicant_dbus_dict_append_basic(dict, "mode",
2682 DBUS_TYPE_UINT32, &mode);
2685 static void interface_add_network_params(DBusMessageIter *iter, void *user_data)
2687 DBusMessageIter dict;
2688 struct interface_connect_data *data = user_data;
2689 GSupplicantSSID *ssid = data->ssid;
2691 supplicant_dbus_dict_open(iter, &dict);
2693 if (ssid->scan_ssid)
2694 supplicant_dbus_dict_append_basic(&dict, "scan_ssid",
2695 DBUS_TYPE_UINT32, &ssid->scan_ssid);
2698 supplicant_dbus_dict_append_basic(&dict, "frequency",
2699 DBUS_TYPE_UINT32, &ssid->freq);
2701 add_network_mode(&dict, ssid);
2703 add_network_security(&dict, ssid);
2705 supplicant_dbus_dict_append_fixed_array(&dict, "ssid",
2706 DBUS_TYPE_BYTE, &ssid->ssid,
2709 supplicant_dbus_dict_close(iter, &dict);
2712 static void interface_wps_start_result(const char *error,
2713 DBusMessageIter *iter, void *user_data)
2715 struct interface_connect_data *data = user_data;
2719 SUPPLICANT_DBG("error: %s", error);
2725 static void interface_add_wps_params(DBusMessageIter *iter, void *user_data)
2727 struct interface_connect_data *data = user_data;
2728 GSupplicantSSID *ssid = data->ssid;
2729 const char *role = "enrollee", *type;
2730 DBusMessageIter dict;
2734 supplicant_dbus_dict_open(iter, &dict);
2736 supplicant_dbus_dict_append_basic(&dict, "Role",
2737 DBUS_TYPE_STRING, &role);
2740 if (ssid->pin_wps != NULL) {
2742 supplicant_dbus_dict_append_basic(&dict, "Pin",
2743 DBUS_TYPE_STRING, &ssid->pin_wps);
2746 supplicant_dbus_dict_append_basic(&dict, "Type",
2747 DBUS_TYPE_STRING, &type);
2749 supplicant_dbus_dict_close(iter, &dict);
2752 static void wps_start(const char *error, DBusMessageIter *iter, void *user_data)
2754 struct interface_connect_data *data = user_data;
2758 if (error != NULL) {
2759 SUPPLICANT_DBG("error: %s", error);
2765 supplicant_dbus_method_call(data->interface->path,
2766 SUPPLICANT_INTERFACE ".Interface.WPS", "Start",
2767 interface_add_wps_params,
2768 interface_wps_start_result, data);
2771 static void wps_process_credentials(DBusMessageIter *iter, void *user_data)
2773 dbus_bool_t credentials = TRUE;
2777 dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &credentials);
2781 int g_supplicant_interface_connect(GSupplicantInterface *interface,
2782 GSupplicantSSID *ssid,
2783 GSupplicantInterfaceCallback callback,
2786 struct interface_connect_data *data;
2789 if (interface == NULL)
2792 if (system_available == FALSE)
2795 /* TODO: Check if we're already connected and switch */
2797 data = dbus_malloc0(sizeof(*data));
2801 data->interface = interface;
2802 data->callback = callback;
2804 data->user_data = user_data;
2806 if (ssid->use_wps == TRUE) {
2807 g_free(interface->wps_cred.key);
2808 memset(&interface->wps_cred, 0,
2809 sizeof(struct _GSupplicantWpsCredentials));
2811 ret = supplicant_dbus_property_set(interface->path,
2812 SUPPLICANT_INTERFACE ".Interface.WPS",
2813 "ProcessCredentials", DBUS_TYPE_BOOLEAN_AS_STRING,
2814 wps_process_credentials, wps_start, data);
2816 ret = supplicant_dbus_method_call(interface->path,
2817 SUPPLICANT_INTERFACE ".Interface", "AddNetwork",
2818 interface_add_network_params,
2819 interface_add_network_result, data);
2824 return -EINPROGRESS;
2827 static void network_remove_result(const char *error,
2828 DBusMessageIter *iter, void *user_data)
2830 struct interface_data *data = user_data;
2838 if (data->callback != NULL)
2839 data->callback(result, data->interface, data->user_data);
2844 static void network_remove_params(DBusMessageIter *iter, void *user_data)
2846 struct interface_data *data = user_data;
2847 const char *path = data->interface->network_path;
2849 SUPPLICANT_DBG("path %s", path);
2851 dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH, &path);
2854 static int network_remove(struct interface_data *data)
2856 GSupplicantInterface *interface = data->interface;
2860 return supplicant_dbus_method_call(interface->path,
2861 SUPPLICANT_INTERFACE ".Interface", "RemoveNetwork",
2862 network_remove_params, network_remove_result, data);
2865 static void interface_disconnect_result(const char *error,
2866 DBusMessageIter *iter, void *user_data)
2868 struct interface_data *data = user_data;
2872 if (error != NULL && data->callback != NULL)
2873 data->callback(-EIO, data->interface, data->user_data);
2875 /* If we are disconnecting from previous WPS successful
2876 * association. i.e.: it did not went through AddNetwork,
2877 * and interface->network_path was never set. */
2878 if (data->interface->network_path == NULL)
2881 network_remove(data);
2884 int g_supplicant_interface_disconnect(GSupplicantInterface *interface,
2885 GSupplicantInterfaceCallback callback,
2888 struct interface_data *data;
2892 if (interface == NULL)
2895 if (system_available == FALSE)
2898 data = dbus_malloc0(sizeof(*data));
2902 data->interface = interface;
2903 data->callback = callback;
2904 data->user_data = user_data;
2906 return supplicant_dbus_method_call(interface->path,
2907 SUPPLICANT_INTERFACE ".Interface", "Disconnect",
2908 NULL, interface_disconnect_result, data);
2912 static const char *g_supplicant_rule0 = "type=signal,"
2913 "path=" DBUS_PATH_DBUS ","
2914 "sender=" DBUS_SERVICE_DBUS ","
2915 "interface=" DBUS_INTERFACE_DBUS ","
2916 "member=NameOwnerChanged,"
2917 "arg0=" SUPPLICANT_SERVICE;
2918 static const char *g_supplicant_rule1 = "type=signal,"
2919 "interface=" SUPPLICANT_INTERFACE;
2920 static const char *g_supplicant_rule2 = "type=signal,"
2921 "interface=" SUPPLICANT_INTERFACE ".Interface";
2922 static const char *g_supplicant_rule3 = "type=signal,"
2923 "interface=" SUPPLICANT_INTERFACE ".Interface.WPS";
2924 static const char *g_supplicant_rule4 = "type=signal,"
2925 "interface=" SUPPLICANT_INTERFACE ".BSS";
2926 static const char *g_supplicant_rule5 = "type=signal,"
2927 "interface=" SUPPLICANT_INTERFACE ".Network";
2929 static void invoke_introspect_method(void)
2931 DBusMessage *message;
2933 message = dbus_message_new_method_call(SUPPLICANT_SERVICE,
2935 DBUS_INTERFACE_INTROSPECTABLE,
2938 if (message == NULL)
2941 dbus_message_set_no_reply(message, TRUE);
2942 dbus_connection_send(connection, message, NULL);
2943 dbus_message_unref(message);
2946 int g_supplicant_register(const GSupplicantCallbacks *callbacks)
2948 connection = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
2949 if (connection == NULL)
2952 if (dbus_connection_add_filter(connection,
2953 g_supplicant_filter, NULL, NULL) == FALSE) {
2954 dbus_connection_unref(connection);
2959 callbacks_pointer = callbacks;
2962 interface_table = g_hash_table_new_full(g_str_hash, g_str_equal,
2963 NULL, remove_interface);
2965 bss_mapping = g_hash_table_new_full(g_str_hash, g_str_equal,
2968 supplicant_dbus_setup(connection);
2970 dbus_bus_add_match(connection, g_supplicant_rule0, NULL);
2971 dbus_bus_add_match(connection, g_supplicant_rule1, NULL);
2972 dbus_bus_add_match(connection, g_supplicant_rule2, NULL);
2973 dbus_bus_add_match(connection, g_supplicant_rule3, NULL);
2974 dbus_bus_add_match(connection, g_supplicant_rule4, NULL);
2975 dbus_bus_add_match(connection, g_supplicant_rule5, NULL);
2976 dbus_connection_flush(connection);
2978 if (dbus_bus_name_has_owner(connection,
2979 SUPPLICANT_SERVICE, NULL) == TRUE) {
2980 system_available = TRUE;
2981 supplicant_dbus_property_get_all(SUPPLICANT_PATH,
2982 SUPPLICANT_INTERFACE,
2983 service_property, NULL);
2985 invoke_introspect_method();
2990 static void unregister_interface_remove_params(DBusMessageIter *iter,
2993 const char *path = user_data;
2995 dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
3000 static void unregister_remove_interface(gpointer key, gpointer value,
3003 GSupplicantInterface *interface = value;
3005 supplicant_dbus_method_call(SUPPLICANT_PATH,
3006 SUPPLICANT_INTERFACE,
3008 unregister_interface_remove_params,
3009 NULL, interface->path);
3012 void g_supplicant_unregister(const GSupplicantCallbacks *callbacks)
3016 if (connection != NULL) {
3017 dbus_bus_remove_match(connection, g_supplicant_rule5, NULL);
3018 dbus_bus_remove_match(connection, g_supplicant_rule4, NULL);
3019 dbus_bus_remove_match(connection, g_supplicant_rule3, NULL);
3020 dbus_bus_remove_match(connection, g_supplicant_rule2, NULL);
3021 dbus_bus_remove_match(connection, g_supplicant_rule1, NULL);
3022 dbus_bus_remove_match(connection, g_supplicant_rule0, NULL);
3023 dbus_connection_flush(connection);
3025 dbus_connection_remove_filter(connection,
3026 g_supplicant_filter, NULL);
3029 if (bss_mapping != NULL) {
3030 g_hash_table_destroy(bss_mapping);
3034 if (system_available == TRUE)
3035 callback_system_killed();
3037 if (interface_table != NULL) {
3038 g_hash_table_foreach(interface_table,
3039 unregister_remove_interface, NULL);
3040 g_hash_table_destroy(interface_table);
3041 interface_table = NULL;
3044 if (connection != NULL) {
3045 dbus_connection_unref(connection);
3049 callbacks_pointer = NULL;