5 * Copyright (C) 2007-2008 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
27 #include <dbus/dbus.h>
29 #include <connman/log.h>
31 #include "supplicant.h"
35 #define IEEE80211_CAP_ESS 0x0001
36 #define IEEE80211_CAP_IBSS 0x0002
37 #define IEEE80211_CAP_PRIVACY 0x0010
39 struct supplicant_task {
43 struct connman_element *element;
44 struct supplicant_callback *callback;
48 enum supplicant_state state;
51 static GStaticMutex task_mutex = G_STATIC_MUTEX_INIT;
52 static GSList *task_list = NULL;
54 static struct supplicant_task *find_task_by_index(int index)
58 for (list = task_list; list; list = list->next) {
59 struct supplicant_task *task = list->data;
61 if (task->ifindex == index)
68 static int get_interface(struct supplicant_task *task)
70 DBusMessage *message, *reply;
76 message = dbus_message_new_method_call(SUPPLICANT_NAME, SUPPLICANT_PATH,
77 SUPPLICANT_INTF, "getInterface");
81 dbus_message_append_args(message, DBUS_TYPE_STRING, &task->ifname,
84 dbus_error_init(&error);
86 reply = dbus_connection_send_with_reply_and_block(task->conn,
89 if (dbus_error_is_set(&error) == TRUE) {
90 connman_error("%s", error.message);
91 dbus_error_free(&error);
93 connman_error("Failed to get interface");
94 dbus_message_unref(message);
98 dbus_message_unref(message);
100 dbus_error_init(&error);
102 if (dbus_message_get_args(reply, &error, DBUS_TYPE_OBJECT_PATH, &path,
103 DBUS_TYPE_INVALID) == FALSE) {
104 if (dbus_error_is_set(&error) == TRUE) {
105 connman_error("%s", error.message);
106 dbus_error_free(&error);
108 connman_error("Wrong arguments for interface");
109 dbus_message_unref(reply);
113 DBG("path %s", path);
115 task->path = g_strdup(path);
116 task->created = FALSE;
118 dbus_message_unref(reply);
123 static int add_interface(struct supplicant_task *task)
125 DBusMessage *message, *reply;
129 DBG("task %p", task);
131 message = dbus_message_new_method_call(SUPPLICANT_NAME, SUPPLICANT_PATH,
132 SUPPLICANT_INTF, "addInterface");
136 dbus_error_init(&error);
138 dbus_message_append_args(message, DBUS_TYPE_STRING, &task->ifname,
141 reply = dbus_connection_send_with_reply_and_block(task->conn,
142 message, -1, &error);
144 if (dbus_error_is_set(&error) == TRUE) {
145 connman_error("%s", error.message);
146 dbus_error_free(&error);
148 connman_error("Failed to add interface");
149 dbus_message_unref(message);
153 dbus_message_unref(message);
155 dbus_error_init(&error);
157 if (dbus_message_get_args(reply, &error, DBUS_TYPE_OBJECT_PATH, &path,
158 DBUS_TYPE_INVALID) == FALSE) {
159 if (dbus_error_is_set(&error) == TRUE) {
160 connman_error("%s", error.message);
161 dbus_error_free(&error);
163 connman_error("Wrong arguments for interface");
164 dbus_message_unref(reply);
168 DBG("path %s", path);
170 task->path = g_strdup(path);
171 task->created = TRUE;
173 dbus_message_unref(reply);
178 static int remove_interface(struct supplicant_task *task)
180 DBusMessage *message, *reply;
183 DBG("task %p", task);
185 if (task->created == FALSE)
188 message = dbus_message_new_method_call(SUPPLICANT_NAME, SUPPLICANT_PATH,
189 SUPPLICANT_INTF, "removeInterface");
193 dbus_message_append_args(message, DBUS_TYPE_OBJECT_PATH, &task->path,
196 dbus_error_init(&error);
198 reply = dbus_connection_send_with_reply_and_block(task->conn,
199 message, -1, &error);
201 if (dbus_error_is_set(&error) == TRUE) {
202 connman_error("%s", error.message);
203 dbus_error_free(&error);
205 connman_error("Failed to remove interface");
206 dbus_message_unref(message);
210 dbus_message_unref(message);
212 dbus_message_unref(reply);
217 static int set_ap_scan(struct supplicant_task *task)
219 DBusMessage *message, *reply;
223 DBG("task %p", task);
225 message = dbus_message_new_method_call(SUPPLICANT_NAME, task->path,
226 SUPPLICANT_INTF ".Interface", "setAPScan");
230 dbus_message_append_args(message, DBUS_TYPE_UINT32, &ap_scan,
233 dbus_error_init(&error);
235 reply = dbus_connection_send_with_reply_and_block(task->conn,
236 message, -1, &error);
238 if (dbus_error_is_set(&error) == TRUE) {
239 connman_error("%s", error.message);
240 dbus_error_free(&error);
242 connman_error("Failed to set AP scan");
243 dbus_message_unref(message);
247 dbus_message_unref(message);
249 dbus_message_unref(reply);
254 static int add_network(struct supplicant_task *task)
256 DBusMessage *message, *reply;
260 DBG("task %p", task);
262 if (task->network != NULL)
265 message = dbus_message_new_method_call(SUPPLICANT_NAME, task->path,
266 SUPPLICANT_INTF ".Interface", "addNetwork");
270 dbus_error_init(&error);
272 reply = dbus_connection_send_with_reply_and_block(task->conn,
273 message, -1, &error);
275 if (dbus_error_is_set(&error) == TRUE) {
276 connman_error("%s", error.message);
277 dbus_error_free(&error);
279 connman_error("Failed to add network");
280 dbus_message_unref(message);
284 dbus_message_unref(message);
286 dbus_error_init(&error);
288 if (dbus_message_get_args(reply, &error, DBUS_TYPE_OBJECT_PATH, &path,
289 DBUS_TYPE_INVALID) == FALSE) {
290 if (dbus_error_is_set(&error) == TRUE) {
291 connman_error("%s", error.message);
292 dbus_error_free(&error);
294 connman_error("Wrong arguments for network");
295 dbus_message_unref(reply);
299 DBG("path %s", path);
301 task->network = g_strdup(path);
303 dbus_message_unref(reply);
308 static int remove_network(struct supplicant_task *task)
310 DBusMessage *message, *reply;
313 DBG("task %p", task);
315 if (task->network == NULL)
318 message = dbus_message_new_method_call(SUPPLICANT_NAME, task->path,
319 SUPPLICANT_INTF ".Interface", "removeNetwork");
323 dbus_message_append_args(message, DBUS_TYPE_OBJECT_PATH, &task->network,
326 dbus_error_init(&error);
328 reply = dbus_connection_send_with_reply_and_block(task->conn,
329 message, -1, &error);
331 if (dbus_error_is_set(&error) == TRUE) {
332 connman_error("%s", error.message);
333 dbus_error_free(&error);
335 connman_error("Failed to remove network");
336 dbus_message_unref(message);
340 dbus_message_unref(message);
342 dbus_message_unref(reply);
344 g_free(task->network);
345 task->network = NULL;
350 static int select_network(struct supplicant_task *task)
352 DBusMessage *message, *reply;
355 DBG("task %p", task);
357 if (task->network == NULL)
360 message = dbus_message_new_method_call(SUPPLICANT_NAME, task->path,
361 SUPPLICANT_INTF ".Interface", "selectNetwork");
365 dbus_message_append_args(message, DBUS_TYPE_OBJECT_PATH, &task->network,
368 dbus_error_init(&error);
370 reply = dbus_connection_send_with_reply_and_block(task->conn,
371 message, -1, &error);
373 if (dbus_error_is_set(&error) == TRUE) {
374 connman_error("%s", error.message);
375 dbus_error_free(&error);
377 connman_error("Failed to select network");
378 dbus_message_unref(message);
382 dbus_message_unref(message);
384 dbus_message_unref(reply);
389 static int enable_network(struct supplicant_task *task)
391 DBusMessage *message, *reply;
394 DBG("task %p", task);
396 if (task->network == NULL)
399 message = dbus_message_new_method_call(SUPPLICANT_NAME, task->network,
400 SUPPLICANT_INTF ".Network", "enable");
404 dbus_error_init(&error);
406 reply = dbus_connection_send_with_reply_and_block(task->conn,
407 message, -1, &error);
409 if (dbus_error_is_set(&error) == TRUE) {
410 connman_error("%s", error.message);
411 dbus_error_free(&error);
413 connman_error("Failed to enable network");
414 dbus_message_unref(message);
418 dbus_message_unref(message);
420 dbus_message_unref(reply);
425 static int disable_network(struct supplicant_task *task)
427 DBusMessage *message, *reply;
430 DBG("task %p", task);
432 if (task->network == NULL)
435 message = dbus_message_new_method_call(SUPPLICANT_NAME, task->network,
436 SUPPLICANT_INTF ".Network", "disable");
440 dbus_error_init(&error);
442 reply = dbus_connection_send_with_reply_and_block(task->conn,
443 message, -1, &error);
445 if (dbus_error_is_set(&error) == TRUE) {
446 connman_error("%s", error.message);
447 dbus_error_free(&error);
449 connman_error("Failed to disable network");
450 dbus_message_unref(message);
454 dbus_message_unref(message);
456 dbus_message_unref(reply);
461 static void append_entry(DBusMessageIter *dict,
462 const char *key, int type, void *val)
464 DBusMessageIter entry, value;
465 const char *signature;
467 dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
470 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
473 case DBUS_TYPE_STRING:
474 signature = DBUS_TYPE_STRING_AS_STRING;
476 case DBUS_TYPE_UINT16:
477 signature = DBUS_TYPE_UINT16_AS_STRING;
480 signature = DBUS_TYPE_VARIANT_AS_STRING;
484 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
486 dbus_message_iter_append_basic(&value, type, val);
487 dbus_message_iter_close_container(&entry, &value);
489 dbus_message_iter_close_container(dict, &entry);
492 static int set_network(struct supplicant_task *task, const char *network,
493 const char *passphrase)
495 DBusMessage *message, *reply;
496 DBusMessageIter array, dict;
499 DBG("task %p", task);
501 if (task->network == NULL)
504 message = dbus_message_new_method_call(SUPPLICANT_NAME, task->network,
505 SUPPLICANT_INTF ".Network", "set");
509 dbus_message_iter_init_append(message, &array);
511 dbus_message_iter_open_container(&array, DBUS_TYPE_ARRAY,
512 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
513 DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
514 DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
516 append_entry(&dict, "ssid", DBUS_TYPE_STRING, &network);
518 if (passphrase && strlen(passphrase) > 0) {
519 const char *key_mgmt = "WPA-PSK";
520 append_entry(&dict, "key_mgmt", DBUS_TYPE_STRING, &key_mgmt);
521 append_entry(&dict, "psk", DBUS_TYPE_STRING, &passphrase);
523 const char *key_mgmt = "NONE";
524 append_entry(&dict, "key_mgmt", DBUS_TYPE_STRING, &key_mgmt);
527 dbus_message_iter_close_container(&array, &dict);
529 dbus_error_init(&error);
531 reply = dbus_connection_send_with_reply_and_block(task->conn,
532 message, -1, &error);
534 if (dbus_error_is_set(&error) == TRUE) {
535 connman_error("%s", error.message);
536 dbus_error_free(&error);
538 connman_error("Failed to set network options");
539 dbus_message_unref(message);
543 dbus_message_unref(message);
545 dbus_message_unref(reply);
550 static int initiate_scan(struct supplicant_task *task)
552 DBusMessage *message;
553 DBusPendingCall *call;
555 DBG("task %p", task);
557 message = dbus_message_new_method_call(SUPPLICANT_NAME, task->path,
558 SUPPLICANT_INTF ".Interface", "scan");
562 if (dbus_connection_send_with_reply(task->conn, message,
563 &call, TIMEOUT) == FALSE) {
564 connman_error("Failed to initiate scan");
565 dbus_message_unref(message);
569 dbus_message_unref(message);
574 static void extract_ssid(struct supplicant_network *network,
575 DBusMessageIter *value)
577 DBusMessageIter array;
581 dbus_message_iter_recurse(value, &array);
582 dbus_message_iter_get_fixed_array(&array, &ssid, &ssid_len);
584 network->identifier = g_strdup((char *) ssid);
587 static void extract_wpaie(struct supplicant_network *network,
588 DBusMessageIter *value)
590 DBusMessageIter array;
594 dbus_message_iter_recurse(value, &array);
595 dbus_message_iter_get_fixed_array(&array, &ie, &ie_len);
598 network->has_wpa = TRUE;
601 static void extract_rsnie(struct supplicant_network *network,
602 DBusMessageIter *value)
604 DBusMessageIter array;
608 dbus_message_iter_recurse(value, &array);
609 dbus_message_iter_get_fixed_array(&array, &ie, &ie_len);
612 network->has_rsn = TRUE;
615 static void extract_capabilites(struct supplicant_network *network,
616 DBusMessageIter *value)
620 dbus_message_iter_get_basic(value, &capabilities);
622 network->capabilities = capabilities;
624 if (capabilities & IEEE80211_CAP_PRIVACY)
625 network->has_wep = TRUE;
628 static void properties_reply(DBusPendingCall *call, void *user_data)
630 struct supplicant_task *task = user_data;
631 struct supplicant_network *network;
633 DBusMessageIter array, dict;
635 DBG("task %p", task);
637 reply = dbus_pending_call_steal_reply(call);
639 network = g_try_new0(struct supplicant_network, 1);
643 dbus_message_iter_init(reply, &array);
645 dbus_message_iter_recurse(&array, &dict);
647 while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
648 DBusMessageIter entry, value;
651 dbus_message_iter_recurse(&dict, &entry);
652 dbus_message_iter_get_basic(&entry, &key);
654 dbus_message_iter_next(&entry);
656 dbus_message_iter_recurse(&entry, &value);
658 //type = dbus_message_iter_get_arg_type(&value);
659 //dbus_message_iter_get_basic(&value, &val);
661 if (g_str_equal(key, "ssid") == TRUE)
662 extract_ssid(network, &value);
663 else if (g_str_equal(key, "wpaie") == TRUE)
664 extract_wpaie(network, &value);
665 else if (g_str_equal(key, "rsnie") == TRUE)
666 extract_rsnie(network, &value);
667 else if (g_str_equal(key, "capabilities") == TRUE)
668 extract_capabilites(network, &value);
670 dbus_message_iter_next(&dict);
673 if (task->callback && task->callback->scan_result)
674 task->callback->scan_result(task->element, network);
679 dbus_message_unref(reply);
682 static int get_network_properties(struct supplicant_task *task,
685 DBusMessage *message;
686 DBusPendingCall *call;
688 message = dbus_message_new_method_call(SUPPLICANT_NAME, path,
689 SUPPLICANT_INTF ".BSSID",
694 if (dbus_connection_send_with_reply(task->conn, message,
695 &call, TIMEOUT) == FALSE) {
696 connman_error("Failed to get network properties");
697 dbus_message_unref(message);
701 dbus_pending_call_set_notify(call, properties_reply, task, NULL);
703 dbus_message_unref(message);
708 static void scan_results_reply(DBusPendingCall *call, void *user_data)
710 struct supplicant_task *task = user_data;
716 DBG("task %p", task);
718 reply = dbus_pending_call_steal_reply(call);
720 dbus_error_init(&error);
722 if (dbus_message_get_args(reply, &error,
723 DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH,
724 &results, &num_results,
725 DBUS_TYPE_INVALID) == FALSE) {
726 if (dbus_error_is_set(&error) == TRUE) {
727 connman_error("%s", error.message);
728 dbus_error_free(&error);
730 connman_error("Wrong arguments for scan result");
734 for (i = 0; i < num_results; i++)
735 get_network_properties(task, results[i]);
740 dbus_message_unref(reply);
743 static int scan_results_available(struct supplicant_task *task)
745 DBusMessage *message;
746 DBusPendingCall *call;
748 DBG("task %p", task);
750 message = dbus_message_new_method_call(SUPPLICANT_NAME, task->path,
751 SUPPLICANT_INTF ".Interface",
756 if (dbus_connection_send_with_reply(task->conn, message,
757 &call, TIMEOUT) == FALSE) {
758 connman_error("Failed to request scan result");
759 dbus_message_unref(message);
763 dbus_pending_call_set_notify(call, scan_results_reply, task, NULL);
765 dbus_message_unref(message);
770 static void state_change(struct supplicant_task *task, DBusMessage *msg)
773 const char *state, *previous;
775 dbus_error_init(&error);
777 if (dbus_message_get_args(msg, &error, DBUS_TYPE_STRING, &state,
778 DBUS_TYPE_STRING, &previous,
779 DBUS_TYPE_INVALID) == FALSE) {
780 if (dbus_error_is_set(&error) == TRUE) {
781 connman_error("%s", error.message);
782 dbus_error_free(&error);
784 connman_error("Wrong arguments for state change");
788 DBG("state %s ==> %s", previous, state);
790 if (g_str_equal(state, "INACTIVE") == TRUE)
791 task->state = STATE_INACTIVE;
792 else if (g_str_equal(state, "SCANNING") == TRUE)
793 task->state = STATE_SCANNING;
794 else if (g_str_equal(state, "ASSOCIATING") == TRUE)
795 task->state = STATE_ASSOCIATING;
796 else if (g_str_equal(state, "ASSOCIATED") == TRUE)
797 task->state = STATE_ASSOCIATED;
798 else if (g_str_equal(state, "GROUP_HANDSHAKE") == TRUE)
799 task->state = STATE_4WAY_HANDSHAKE;
800 else if (g_str_equal(state, "4WAY_HANDSHAKE") == TRUE)
801 task->state = STATE_4WAY_HANDSHAKE;
802 else if (g_str_equal(state, "COMPLETED") == TRUE)
803 task->state = STATE_COMPLETED;
804 else if (g_str_equal(state, "DISCONNECTED") == TRUE)
805 task->state = STATE_DISCONNECTED;
807 if (task->callback && task->callback->state_change)
808 task->callback->state_change(task->element, task->state);
810 switch (task->state) {
811 case STATE_COMPLETED:
814 case STATE_DISCONNECTED:
822 static DBusHandlerResult supplicant_filter(DBusConnection *conn,
823 DBusMessage *msg, void *data)
825 struct supplicant_task *task = data;
828 if (dbus_message_has_interface(msg,
829 SUPPLICANT_INTF ".Interface") == FALSE)
830 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
832 member = dbus_message_get_member(msg);
834 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
836 DBG("task %p member %s", task, member);
838 if (g_str_equal(member, "ScanResultsAvailable") == TRUE)
839 scan_results_available(task);
840 else if (g_str_equal(member, "StateChange") == TRUE)
841 state_change(task, msg);
843 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
846 static int add_filter(struct supplicant_task *task)
851 if (dbus_connection_add_filter(task->conn,
852 supplicant_filter, task, NULL) == FALSE)
855 filter = g_strdup_printf("type=signal,interface=%s.Interface,path=%s",
856 SUPPLICANT_INTF, task->path);
858 DBG("filter %s", filter);
860 dbus_error_init(&error);
862 dbus_bus_add_match(task->conn, filter, &error);
866 if (dbus_error_is_set(&error) == TRUE) {
867 connman_error("Can't add match: %s", error.message);
868 dbus_error_free(&error);
874 static int remove_filter(struct supplicant_task *task)
879 filter = g_strdup_printf("type=signal,interface=%s.Interface,path=%s",
880 SUPPLICANT_INTF, task->path);
882 DBG("filter %s", filter);
884 dbus_error_init(&error);
886 dbus_bus_add_match(task->conn, filter, &error);
890 if (dbus_error_is_set(&error) == TRUE) {
891 connman_error("Can't add match: %s", error.message);
892 dbus_error_free(&error);
895 dbus_connection_remove_filter(task->conn, supplicant_filter, task);
900 int __supplicant_start(struct connman_element *element,
901 struct supplicant_callback *callback)
903 struct supplicant_task *task;
906 DBG("element %p name %s", element, element->name);
908 task = g_try_new0(struct supplicant_task, 1);
912 task->ifindex = element->netdev.index;
913 task->ifname = g_strdup(element->netdev.name);
914 task->element = element;
915 task->callback = callback;
917 if (task->ifname == NULL) {
922 task->conn = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
923 if (task->conn == NULL) {
928 task->created = FALSE;
929 task->state = STATE_INACTIVE;
931 g_static_mutex_lock(&task_mutex);
932 task_list = g_slist_append(task_list, task);
933 g_static_mutex_unlock(&task_mutex);
935 err = get_interface(task);
937 err = add_interface(task);
951 int __supplicant_stop(struct connman_element *element)
953 struct supplicant_task *task;
955 DBG("element %p name %s", element, element->name);
957 task = find_task_by_index(element->netdev.index);
961 g_static_mutex_lock(&task_mutex);
962 task_list = g_slist_remove(task_list, task);
963 g_static_mutex_unlock(&task_mutex);
965 disable_network(task);
967 remove_network(task);
971 remove_interface(task);
973 dbus_connection_unref(task->conn);
975 g_free(task->ifname);
982 int __supplicant_scan(struct connman_element *element)
984 struct supplicant_task *task;
987 DBG("element %p name %s", element, element->name);
989 task = find_task_by_index(element->netdev.index);
993 switch (task->state) {
996 case STATE_ASSOCIATING:
997 case STATE_ASSOCIATED:
998 case STATE_4WAY_HANDSHAKE:
999 case STATE_GROUP_HANDSHAKE:
1005 err = initiate_scan(task);
1010 int __supplicant_connect(struct connman_element *element, const char *ssid)
1012 struct supplicant_task *task;
1014 DBG("element %p name %s", element, element->name);
1016 task = find_task_by_index(element->netdev.index);
1022 select_network(task);
1023 disable_network(task);
1025 set_network(task, ssid, NULL);
1027 enable_network(task);
1032 int __supplicant_disconnect(struct connman_element *element)
1034 struct supplicant_task *task;
1036 DBG("element %p name %s", element, element->name);
1038 task = find_task_by_index(element->netdev.index);
1042 disable_network(task);
1044 remove_network(task);