5 * Copyright (C) 2007-2014 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
31 #include <sys/ioctl.h>
32 #include <sys/socket.h>
33 #include <net/ethernet.h>
34 #include <linux/wireless.h>
37 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
41 #define IFF_LOWER_UP 0x10000
44 #include <dbus/dbus.h>
47 #define CONNMAN_API_SUBJECT_TO_CHANGE
48 #include <connman/plugin.h>
49 #include <connman/inet.h>
50 #include <connman/device.h>
51 #include <connman/rtnl.h>
52 #include <connman/technology.h>
53 #include <connman/service.h>
54 #include <connman/peer.h>
55 #include <connman/log.h>
56 #include <connman/storage.h>
57 #include <include/setting.h>
58 #include <connman/provision.h>
59 #include <connman/utsname.h>
60 #include <connman/machine.h>
61 #include <connman/tethering.h>
63 #include <gsupplicant/gsupplicant.h>
65 #include "src/shared/util.h"
67 #define CLEANUP_TIMEOUT 8 /* in seconds */
68 #define INACTIVE_TIMEOUT 12 /* in seconds */
69 #define FAVORITE_MAXIMUM_RETRIES 2
71 #define BGSCAN_DEFAULT "simple:30:-65:300"
72 #define AUTOSCAN_EXPONENTIAL "exponential:3:300"
73 #define AUTOSCAN_SINGLE "single:3"
74 #define SCAN_MAX_DURATION 10
76 #define P2P_FIND_TIMEOUT 30
77 #define P2P_CONNECTION_TIMEOUT 100
78 #define P2P_LISTEN_PERIOD 500
79 #define P2P_LISTEN_INTERVAL 2000
81 #define ASSOC_STATUS_AUTH_TIMEOUT 16
82 #define ASSOC_STATUS_NO_CLIENT 17
84 #define LOAD_SHAPING_MAX_RETRIES 7
86 #define LOAD_SHAPING_MAX_RETRIES 3
90 #define WIFI_EAP_FAST_PAC_FILE "/var/lib/wifi/wifi.pac" /* path of Pac file for EAP-FAST */
92 /* Wi-Fi Signal Strength (for 2.4G (dB))
96 * Very weak : -83 ~ -88
99 * Wi-Fi Signal Strength (for 5G (dB))
103 * Very weak : -83 ~ -88
106 * Wi-Fi Signal Strength (for 6G (dB))
111 * Very weak : -83 ~ -88
114 #define RSSI_LEVEL_2_6G -78
115 #define RSSI_LEVEL_2_5G -77
116 #define RSSI_LEVEL_2_2_4G -75
117 #define RSSI_LEVEL_3_6G -73
118 #define RSSI_LEVEL_3_5G -68
119 #define RSSI_LEVEL_3_2_4G -64
120 #define ROAM_SCAN_INTERVAL 60 /* 60 seconds */
121 #define FREQUENCY_5G_BASE 5000
122 #define FREQUENCY_6G_BASE 5925
124 static int min_snr = 0;
125 static int min_rssi_2_4GHz = 0;
126 static int min_rssi_5GHz = 0;
127 static int min_rssi_6GHz = 0;
130 static struct connman_technology *wifi_technology = NULL;
131 static struct connman_technology *p2p_technology = NULL;
133 #if defined TIZEN_EXT
134 static GSupplicantState assoc_last_state = G_SUPPLICANT_STATE_UNKNOWN;
137 enum wifi_ap_capability{
139 WIFI_AP_SUPPORTED = 1,
140 WIFI_AP_NOT_SUPPORTED = 2,
143 enum wifi_scanning_type {
144 WIFI_SCANNING_UNKNOWN = 0,
145 WIFI_SCANNING_PASSIVE = 1,
146 WIFI_SCANNING_ACTIVE = 2,
149 struct hidden_params {
151 unsigned int ssid_len;
153 char *anonymous_identity;
155 char *altsubject_match;
156 char *domain_suffix_match;
160 GSupplicantScanParams *scan_params;
165 * Used for autoscan "emulation".
166 * Should be removed when wpa_s autoscan support will be by default.
168 struct autoscan_params {
172 unsigned int timeout;
175 struct wifi_tethering_info {
176 struct wifi_data *wifi;
177 struct connman_technology *technology;
179 GSupplicantSSID *ssid;
184 struct connman_device *device;
185 struct connman_network *network;
186 struct connman_network *pending_network;
188 GSupplicantInterface *interface;
189 GSupplicantState state;
193 enum wifi_ap_capability ap_supported;
195 bool interface_ready;
201 int load_shaping_retries;
202 struct hidden_params *hidden;
203 bool postpone_hidden;
204 struct wifi_tethering_info *tethering_param;
206 * autoscan "emulation".
208 struct autoscan_params *autoscan;
209 enum wifi_scanning_type scanning_type;
210 GSupplicantScanParams *scan_params;
211 unsigned int p2p_find_timeout;
212 unsigned int p2p_connection_timeout;
213 struct connman_peer *pending_peer;
218 #if defined TIZEN_EXT
219 int assoc_retry_count;
220 struct connman_network *scan_pending_network;
221 bool allow_full_scan;
222 unsigned int automaxspeed_timeout;
223 GSupplicantScanParams *hidden_scan_params;
224 unsigned int mac_policy;
225 unsigned int preassoc_mac_policy;
226 unsigned int mac_lifetime;
230 #if defined TIZEN_EXT_WIFI_MESH
232 struct wifi_mesh_info *mesh_info;
236 struct wifi_network {
237 unsigned int keymgmt;
240 struct disconnect_data {
241 struct wifi_data *wifi;
242 struct connman_network *network;
245 #if defined TIZEN_EXT
249 #define TIZEN_ASSOC_RETRY_COUNT 4
251 static gboolean wifi_first_scan = false;
252 static gboolean found_with_first_scan = false;
253 static gboolean is_wifi_notifier_registered = false;
254 static GHashTable *failed_bssids = NULL;
255 static unsigned char buff_bssid[WIFI_BSSID_LEN_MAX] = { 0, };
258 static GList *iface_list = NULL;
260 static GList *pending_wifi_device = NULL;
261 static GList *p2p_iface_list = NULL;
262 static bool wfd_service_registered = false;
264 static void start_autoscan(struct connman_device *device);
265 static int tech_set_tethering(struct connman_technology *technology,
266 const char *bridge, bool enabled);
268 #if defined TIZEN_EXT
269 #define NETCONFIG_SERVICE "net.netconfig"
270 #define NETCONFIG_WIFI_PATH "/net/netconfig/wifi"
271 #define NETCONFIG_WIFI_INTERFACE NETCONFIG_SERVICE ".wifi"
273 struct enc_method_call_data {
274 DBusConnection *connection;
275 struct connman_network *network;
278 static struct enc_method_call_data encrypt_request_data;
280 static GSupplicantSecurity network_security(const char *security);
282 static void encryption_request_reply(DBusPendingCall *call,
287 DBusMessageIter args;
289 struct connman_service *service;
290 gchar* encrypted_value = NULL;
291 struct connman_network *network = encrypt_request_data.network;
295 reply = dbus_pending_call_steal_reply(call);
297 dbus_error_init(&error);
298 if (dbus_set_error_from_message(&error, reply)) {
299 DBG("send_encryption_request() %s %s", error.name, error.message);
300 dbus_error_free(&error);
304 if (dbus_message_iter_init(reply, &args) == FALSE)
307 dbus_message_iter_get_basic(&args, &out_data);
309 encrypted_value = g_strdup((const gchar *)out_data);
310 service = connman_service_lookup_from_network(network);
313 DBG("encryption result: no service");
317 if (connman_service_get_favorite(service)) {
318 __connman_service_set_passphrase(service, encrypted_value);
319 __connman_service_save(service);
321 connman_network_set_string(network, "WiFi.Passphrase",
324 DBG("encryption result: succeeded");
327 dbus_message_unref(reply);
328 dbus_pending_call_unref(call);
329 dbus_connection_unref(encrypt_request_data.connection);
330 g_free(encrypted_value);
332 encrypt_request_data.connection = NULL;
333 encrypt_request_data.network = NULL;
336 static int send_encryption_request(const char *passphrase,
337 struct connman_network *network)
339 DBusConnection *connection = NULL;
340 DBusMessage *msg = NULL;
341 DBusPendingCall *call;
344 DBG("Invalid parameter");
348 connection = connman_dbus_get_connection();
350 DBG("dbus connection does not exist");
354 msg = dbus_message_new_method_call(NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
355 NETCONFIG_WIFI_INTERFACE, "EncryptPassphrase");
357 dbus_connection_unref(connection);
361 dbus_message_append_args(msg, DBUS_TYPE_STRING, &passphrase,
364 if (!dbus_connection_send_with_reply(connection, msg,
365 &call, DBUS_TIMEOUT_USE_DEFAULT)) {
366 dbus_message_unref(msg);
367 dbus_connection_unref(connection);
372 dbus_message_unref(msg);
373 dbus_connection_unref(connection);
377 encrypt_request_data.connection = connection;
378 encrypt_request_data.network = network;
380 dbus_pending_call_set_notify(call, encryption_request_reply, NULL, NULL);
381 dbus_message_unref(msg);
387 static int p2p_tech_probe(struct connman_technology *technology)
389 p2p_technology = technology;
394 static void p2p_tech_remove(struct connman_technology *technology)
396 p2p_technology = NULL;
399 static struct connman_technology_driver p2p_tech_driver = {
401 .type = CONNMAN_SERVICE_TYPE_P2P,
402 .probe = p2p_tech_probe,
403 .remove = p2p_tech_remove,
406 static bool is_p2p_connecting(void)
410 for (list = iface_list; list; list = list->next) {
411 struct wifi_data *wifi = list->data;
413 if (wifi->p2p_connecting)
420 static void add_pending_wifi_device(struct wifi_data *wifi)
422 if (g_list_find(pending_wifi_device, wifi))
425 pending_wifi_device = g_list_append(pending_wifi_device, wifi);
428 #if defined TIZEN_EXT_WIFI_MESH
429 struct wifi_mesh_info {
430 struct wifi_data *wifi;
431 GSupplicantInterface *interface;
432 struct connman_mesh *mesh;
439 struct mesh_change_peer_status_info {
441 enum connman_mesh_peer_status peer_status;
442 mesh_change_peer_status_cb_t callback;
446 static struct connman_technology_driver mesh_tech_driver = {
448 .type = CONNMAN_SERVICE_TYPE_MESH,
451 static void mesh_interface_create_callback(int result,
452 GSupplicantInterface *interface,
455 struct wifi_mesh_info *mesh_info = user_data;
456 struct wifi_data *wifi;
457 bool success = false;
459 DBG("result %d ifname %s, mesh_info %p", result,
460 g_supplicant_interface_get_ifname(interface),
463 if (result < 0 || !mesh_info)
466 wifi = mesh_info->wifi;
468 mesh_info->interface = interface;
469 mesh_info->identifier = connman_inet_ifaddr(mesh_info->ifname);
470 mesh_info->index = connman_inet_ifindex(mesh_info->ifname);
471 DBG("Mesh Interface identifier %s", mesh_info->identifier);
472 wifi->mesh_interface = true;
473 wifi->mesh_info = mesh_info;
474 g_supplicant_interface_set_data(interface, wifi);
478 connman_mesh_notify_interface_create(success);
481 static int add_mesh_interface(const char *ifname, const char *parent_ifname)
484 struct wifi_data *wifi;
485 struct wifi_mesh_info *mesh_info;
486 const char *wifi_ifname;
487 bool parent_found = false;
488 const char *driver = "nl80211";
490 for (list = iface_list; list; list = list->next) {
493 if (!g_supplicant_interface_has_mesh(wifi->interface))
496 wifi_ifname = g_supplicant_interface_get_ifname(wifi->interface);
500 if (!g_strcmp0(wifi_ifname, parent_ifname)) {
507 DBG("Parent interface %s doesn't exist", parent_ifname);
511 mesh_info = g_try_malloc0(sizeof(struct wifi_mesh_info));
515 mesh_info->wifi = wifi;
516 mesh_info->ifname = g_strdup(ifname);
517 mesh_info->parent_ifname = g_strdup(parent_ifname);
519 g_supplicant_mesh_interface_create(ifname, driver, NULL, parent_ifname,
520 mesh_interface_create_callback, mesh_info);
524 static void mesh_interface_remove_callback(int result,
525 GSupplicantInterface *interface,
528 struct wifi_data *wifi = user_data;
529 struct wifi_mesh_info *mesh_info = wifi->mesh_info;
530 bool success = false;
532 DBG("result %d mesh_info %p", result, mesh_info);
534 if (result < 0 || !mesh_info)
537 mesh_info->interface = NULL;
538 g_free(mesh_info->parent_ifname);
539 g_free(mesh_info->ifname);
540 g_free(mesh_info->identifier);
542 wifi->mesh_interface = false;
543 wifi->mesh_info = NULL;
547 connman_mesh_notify_interface_remove(success);
550 static int remove_mesh_interface(const char *ifname)
553 struct wifi_data *wifi;
554 struct wifi_mesh_info *mesh_info;
555 bool mesh_if_found = false;
558 for (list = iface_list; list; list = list->next) {
561 if (wifi->mesh_interface) {
562 mesh_if_found = true;
567 if (!mesh_if_found) {
568 DBG("Mesh interface %s doesn't exist", ifname);
572 mesh_info = wifi->mesh_info;
573 ret = g_supplicant_interface_remove(mesh_info->interface,
574 mesh_interface_remove_callback, wifi);
581 static void mesh_disconnect_callback(int result,
582 GSupplicantInterface *interface, void *user_data)
584 struct connman_mesh *mesh = user_data;
586 DBG("result %d interface %p mesh %p", result, interface, mesh);
589 static int mesh_peer_disconnect(struct connman_mesh *mesh)
592 struct wifi_data *wifi;
593 struct wifi_mesh_info *mesh_info;
594 bool mesh_if_found = false;
595 GSupplicantInterface *interface;
597 for (list = iface_list; list; list = list->next) {
600 if (wifi->mesh_interface) {
601 mesh_if_found = true;
606 if (!mesh_if_found) {
607 DBG("Mesh interface is not created");
611 mesh_info = wifi->mesh_info;
613 interface = mesh_info->interface;
614 return g_supplicant_interface_disconnect(interface,
615 mesh_disconnect_callback, mesh);
618 static void mesh_connect_callback(int result, GSupplicantInterface *interface,
621 struct connman_mesh *mesh = user_data;
622 DBG("mesh %p result %d", mesh, result);
625 connman_mesh_peer_set_state(mesh, CONNMAN_MESH_STATE_FAILURE);
627 connman_mesh_peer_set_state(mesh, CONNMAN_MESH_STATE_ASSOCIATION);
630 static GSupplicantSecurity mesh_network_security(const char *security)
632 if (g_str_equal(security, "none"))
633 return G_SUPPLICANT_SECURITY_NONE;
634 else if (g_str_equal(security, "sae"))
635 return G_SUPPLICANT_SECURITY_SAE;
637 return G_SUPPLICANT_SECURITY_UNKNOWN;
640 static void mesh_ssid_init(GSupplicantSSID *ssid, struct connman_mesh *mesh)
643 const char *security;
648 memset(ssid, 0, sizeof(*ssid));
649 ssid->mode = G_SUPPLICANT_MODE_MESH;
651 security = connman_mesh_get_security(mesh);
652 ssid->security = mesh_network_security(security);
654 if (ssid->security == G_SUPPLICANT_SECURITY_SAE)
655 ssid->passphrase = connman_mesh_get_passphrase(mesh);
657 ssid->freq = connman_mesh_get_frequency(mesh);
658 name = connman_mesh_get_name(mesh);
660 ssid->ssid_len = strlen(name);
661 ssid->ssid = g_malloc0(ssid->ssid_len + 1);
662 memcpy(ssid->ssid, name, ssid->ssid_len);
667 static int mesh_peer_connect(struct connman_mesh *mesh)
670 struct wifi_data *wifi;
671 struct wifi_mesh_info *mesh_info;
672 bool mesh_if_found = false;
673 GSupplicantInterface *interface;
674 GSupplicantSSID *ssid;
676 for (list = iface_list; list; list = list->next) {
679 if (wifi->mesh_interface) {
680 mesh_if_found = true;
685 if (!mesh_if_found) {
686 DBG("Mesh interface is not created");
690 mesh_info = wifi->mesh_info;
692 interface = mesh_info->interface;
694 ssid = g_try_malloc0(sizeof(GSupplicantSSID));
698 mesh_info->mesh = mesh;
700 mesh_ssid_init(ssid, mesh);
701 return g_supplicant_interface_connect(interface, ssid,
702 mesh_connect_callback, mesh);
705 static void mesh_peer_change_status_callback(int result,
706 GSupplicantInterface *interface,
709 struct mesh_change_peer_status_info *data = user_data;
711 DBG("result %d Peer Status %d", result, data->peer_status);
713 if (result == 0 && data->peer_status == CONNMAN_MESH_PEER_REMOVE) {
714 /* WLAN_REASON_MESH_PEERING_CANCELLED = 52 */
715 connman_mesh_remove_connected_peer(data->peer_address, 52);
719 data->callback(result, data->user_data);
721 g_free(data->peer_address);
726 static int mesh_change_peer_status(const char *peer_address,
727 enum connman_mesh_peer_status status,
728 mesh_change_peer_status_cb_t callback, void *user_data)
731 struct wifi_data *wifi;
732 struct wifi_mesh_info *mesh_info;
733 bool mesh_if_found = false;
734 GSupplicantInterface *interface;
735 struct mesh_change_peer_status_info *data;
738 for (list = iface_list; list; list = list->next) {
741 if (wifi->mesh_interface) {
742 mesh_if_found = true;
747 if (!mesh_if_found) {
748 DBG("Mesh interface is not created");
752 mesh_info = wifi->mesh_info;
754 interface = mesh_info->interface;
757 case CONNMAN_MESH_PEER_ADD:
758 method = "MeshPeerAdd";
760 case CONNMAN_MESH_PEER_REMOVE:
761 method = "MeshPeerRemove";
764 DBG("Invalid method");
768 data = g_try_malloc0(sizeof(struct mesh_change_peer_status_info));
770 DBG("Memory allocation failed");
774 data->peer_address = g_strdup(peer_address);
775 data->peer_status = status;
776 data->callback = callback;
777 data->user_data = user_data;
779 return g_supplicant_interface_mesh_peer_change_status(interface,
780 mesh_peer_change_status_callback, peer_address, method,
784 static struct connman_mesh_driver mesh_driver = {
785 .add_interface = add_mesh_interface,
786 .remove_interface = remove_mesh_interface,
787 .connect = mesh_peer_connect,
788 .disconnect = mesh_peer_disconnect,
789 .change_peer_status = mesh_change_peer_status,
792 static void mesh_support(GSupplicantInterface *interface)
796 if (!g_supplicant_interface_has_mesh(interface))
799 if (connman_technology_driver_register(&mesh_tech_driver) < 0) {
800 DBG("Could not register Mesh technology driver");
804 connman_mesh_driver_register(&mesh_driver);
807 static void check_mesh_technology(void)
809 bool mesh_exists = false;
812 for (list = iface_list; list; list = list->next) {
813 struct wifi_data *w = list->data;
816 g_supplicant_interface_has_mesh(w->interface))
821 connman_technology_driver_unregister(&mesh_tech_driver);
822 connman_mesh_driver_unregister(&mesh_driver);
826 static void mesh_group_started(GSupplicantInterface *interface)
828 struct wifi_data *wifi;
829 struct wifi_mesh_info *mesh_info;
830 struct connman_mesh *mesh;
831 const unsigned char *ssid;
832 unsigned int ssid_len;
835 ssid = g_supplicant_interface_get_mesh_group_ssid(interface, &ssid_len);
836 memcpy(name, ssid, ssid_len);
837 name[ssid_len] = '\0';
838 DBG("name %s", name);
839 wifi = g_supplicant_interface_get_data(interface);
840 DBG("wifi %p", wifi);
845 mesh_info = wifi->mesh_info;
849 mesh = mesh_info->mesh;
853 connman_mesh_peer_set_state(mesh, CONNMAN_MESH_STATE_CONFIGURATION);
856 static void mesh_group_removed(GSupplicantInterface *interface)
858 struct wifi_data *wifi;
859 struct wifi_mesh_info *mesh_info;
860 struct connman_mesh *mesh;
861 const unsigned char *ssid;
862 unsigned int ssid_len;
863 int disconnect_reason;
866 ssid = g_supplicant_interface_get_mesh_group_ssid(interface, &ssid_len);
867 memcpy(name, ssid, ssid_len);
868 name[ssid_len] = '\0';
869 DBG("name %s", name);
871 disconnect_reason = g_supplicant_mesh_get_disconnect_reason(interface);
872 DBG("Disconnect Reason %d", disconnect_reason);
874 wifi = g_supplicant_interface_get_data(interface);
875 DBG("wifi %p", wifi);
880 mesh_info = wifi->mesh_info;
884 mesh = connman_get_connected_mesh_from_name(name);
886 DBG("%s is not connected", name);
887 mesh = connman_get_connecting_mesh_from_name(name);
889 DBG("%s is not connecting", name);
894 connman_mesh_peer_set_disconnect_reason(mesh, disconnect_reason);
895 connman_mesh_peer_set_state(mesh, CONNMAN_MESH_STATE_DISCONNECT);
898 static void mesh_peer_connected(GSupplicantMeshPeer *mesh_peer)
900 const char *peer_address;
902 peer_address = g_supplicant_mesh_peer_get_address(mesh_peer);
907 DBG("Peer %s connected", peer_address);
908 connman_mesh_add_connected_peer(peer_address);
911 static void mesh_peer_disconnected(GSupplicantMeshPeer *mesh_peer)
913 const char *peer_address;
916 peer_address = g_supplicant_mesh_peer_get_address(mesh_peer);
921 reason = g_supplicant_mesh_peer_get_disconnect_reason(mesh_peer);
923 DBG("Peer %s disconnected with reason %d", peer_address, reason);
924 connman_mesh_remove_connected_peer(peer_address, reason);
928 static struct wifi_data *get_pending_wifi_data(const char *ifname)
932 for (list = pending_wifi_device; list; list = list->next) {
933 struct wifi_data *wifi;
934 const char *dev_name;
937 if (!wifi || !wifi->device)
940 dev_name = connman_device_get_string(wifi->device, "Interface");
941 if (!g_strcmp0(ifname, dev_name)) {
942 pending_wifi_device = g_list_delete_link(
943 pending_wifi_device, list);
951 static void remove_pending_wifi_device(struct wifi_data *wifi)
955 link = g_list_find(pending_wifi_device, wifi);
960 pending_wifi_device = g_list_delete_link(pending_wifi_device, link);
963 static void peer_cancel_timeout(struct wifi_data *wifi)
965 if (wifi->p2p_connection_timeout > 0)
966 g_source_remove(wifi->p2p_connection_timeout);
968 wifi->p2p_connection_timeout = 0;
969 wifi->p2p_connecting = false;
971 if (wifi->pending_peer) {
972 connman_peer_unref(wifi->pending_peer);
973 wifi->pending_peer = NULL;
977 static gboolean peer_connect_timeout(gpointer data)
979 struct wifi_data *wifi = data;
983 if (wifi->p2p_connecting) {
984 enum connman_peer_state state = CONNMAN_PEER_STATE_FAILURE;
985 GSupplicantPeer *gs_peer =
986 g_supplicant_interface_peer_lookup(wifi->interface,
987 connman_peer_get_identifier(wifi->pending_peer));
989 if (g_supplicant_peer_has_requested_connection(gs_peer))
990 state = CONNMAN_PEER_STATE_IDLE;
992 connman_peer_set_state(wifi->pending_peer, state);
995 peer_cancel_timeout(wifi);
1000 static void peer_connect_callback(int result, GSupplicantInterface *interface,
1003 struct wifi_data *wifi = user_data;
1004 struct connman_peer *peer = wifi->pending_peer;
1006 DBG("peer %p - %d", peer, result);
1012 peer_connect_timeout(wifi);
1016 connman_peer_set_state(peer, CONNMAN_PEER_STATE_ASSOCIATION);
1018 wifi->p2p_connection_timeout = g_timeout_add_seconds(
1019 P2P_CONNECTION_TIMEOUT,
1020 peer_connect_timeout, wifi);
1023 static int peer_connect(struct connman_peer *peer,
1024 enum connman_peer_wps_method wps_method,
1025 const char *wps_pin)
1027 struct connman_device *device = connman_peer_get_device(peer);
1028 GSupplicantPeerParams *peer_params;
1029 GSupplicantPeer *gs_peer;
1030 struct wifi_data *wifi;
1034 DBG("peer %p", peer);
1039 wifi = connman_device_get_data(device);
1040 if (!wifi || !wifi->interface)
1043 if (wifi->p2p_connecting)
1046 gs_peer = g_supplicant_interface_peer_lookup(wifi->interface,
1047 connman_peer_get_identifier(peer));
1051 pbc = g_supplicant_peer_is_wps_pbc(gs_peer);
1052 pin = g_supplicant_peer_is_wps_pin(gs_peer);
1054 switch (wps_method) {
1055 case CONNMAN_PEER_WPS_UNKNOWN:
1056 if ((pbc && pin) || pin)
1059 case CONNMAN_PEER_WPS_PBC:
1064 case CONNMAN_PEER_WPS_PIN:
1065 if (!pin || !wps_pin)
1070 peer_params = g_try_malloc0(sizeof(GSupplicantPeerParams));
1074 peer_params->path = g_strdup(g_supplicant_peer_get_path(gs_peer));
1076 peer_params->wps_pin = g_strdup(wps_pin);
1078 peer_params->master = connman_peer_service_is_master();
1080 ret = g_supplicant_interface_p2p_connect(wifi->interface, peer_params,
1081 peer_connect_callback, wifi);
1082 if (ret == -EINPROGRESS) {
1083 wifi->pending_peer = connman_peer_ref(peer);
1084 wifi->p2p_connecting = true;
1085 } else if (ret < 0) {
1086 g_free(peer_params->path);
1087 g_free(peer_params->wps_pin);
1088 g_free(peer_params);
1094 static int peer_disconnect(struct connman_peer *peer)
1096 struct connman_device *device = connman_peer_get_device(peer);
1097 GSupplicantPeerParams peer_params = {};
1098 GSupplicantPeer *gs_peer;
1099 struct wifi_data *wifi;
1102 DBG("peer %p", peer);
1107 wifi = connman_device_get_data(device);
1111 gs_peer = g_supplicant_interface_peer_lookup(wifi->interface,
1112 connman_peer_get_identifier(peer));
1116 peer_params.path = g_strdup(g_supplicant_peer_get_path(gs_peer));
1118 ret = g_supplicant_interface_p2p_disconnect(wifi->interface,
1120 g_free(peer_params.path);
1122 if (ret == -EINPROGRESS) {
1123 peer_cancel_timeout(wifi);
1124 wifi->p2p_device = false;
1130 struct peer_service_registration {
1131 peer_service_registration_cb_t callback;
1135 static bool is_service_wfd(const unsigned char *specs, int length)
1137 if (length < 9 || specs[0] != 0 || specs[1] != 0 || specs[2] != 6)
1143 static void apply_p2p_listen_on_iface(gpointer data, gpointer user_data)
1145 struct wifi_data *wifi = data;
1147 if (!wifi->interface ||
1148 !g_supplicant_interface_has_p2p(wifi->interface))
1151 if (!wifi->servicing) {
1152 g_supplicant_interface_p2p_listen(wifi->interface,
1153 P2P_LISTEN_PERIOD, P2P_LISTEN_INTERVAL);
1159 static void register_wfd_service_cb(int result,
1160 GSupplicantInterface *iface, void *user_data)
1162 struct peer_service_registration *reg_data = user_data;
1167 g_list_foreach(iface_list, apply_p2p_listen_on_iface, NULL);
1169 if (reg_data && reg_data->callback) {
1170 reg_data->callback(result, reg_data->user_data);
1175 static GSupplicantP2PServiceParams *fill_in_peer_service_params(
1176 const unsigned char *spec,
1177 int spec_length, const unsigned char *query,
1178 int query_length, int version)
1180 GSupplicantP2PServiceParams *params;
1182 params = g_try_malloc0(sizeof(GSupplicantP2PServiceParams));
1187 params->version = version;
1188 if (spec_length > 0) {
1189 params->service = g_malloc(spec_length);
1190 memcpy(params->service, spec, spec_length);
1192 } else if (query_length > 0 && spec_length > 0) {
1193 params->query = g_malloc(query_length);
1194 memcpy(params->query, query, query_length);
1195 params->query_length = query_length;
1197 params->response = g_malloc(spec_length);
1198 memcpy(params->response, spec, spec_length);
1199 params->response_length = spec_length;
1201 if (spec_length > 0) {
1202 params->wfd_ies = g_malloc(spec_length);
1203 memcpy(params->wfd_ies, spec, spec_length);
1205 params->wfd_ies_length = spec_length;
1211 static void free_peer_service_params(GSupplicantP2PServiceParams *params)
1216 g_free(params->service);
1217 g_free(params->query);
1218 g_free(params->response);
1219 g_free(params->wfd_ies);
1224 static int peer_register_wfd_service(const unsigned char *specification,
1225 int specification_length,
1226 peer_service_registration_cb_t callback,
1229 struct peer_service_registration *reg_data = NULL;
1230 static GSupplicantP2PServiceParams *params;
1235 if (wfd_service_registered)
1238 params = fill_in_peer_service_params(specification,
1239 specification_length, NULL, 0, 0);
1243 reg_data = g_try_malloc0(sizeof(*reg_data));
1249 reg_data->callback = callback;
1250 reg_data->user_data = user_data;
1252 ret = g_supplicant_set_widi_ies(params,
1253 register_wfd_service_cb, reg_data);
1254 if (ret < 0 && ret != -EINPROGRESS)
1257 wfd_service_registered = true;
1261 free_peer_service_params(params);
1267 static void register_peer_service_cb(int result,
1268 GSupplicantInterface *iface, void *user_data)
1270 struct wifi_data *wifi = g_supplicant_interface_get_data(iface);
1271 struct peer_service_registration *reg_data = user_data;
1273 #if defined TIZEN_EXT
1281 apply_p2p_listen_on_iface(wifi, NULL);
1283 if (reg_data->callback)
1284 reg_data->callback(result, reg_data->user_data);
1289 static int peer_register_service(const unsigned char *specification,
1290 int specification_length,
1291 const unsigned char *query,
1292 int query_length, int version,
1293 peer_service_registration_cb_t callback,
1296 struct peer_service_registration *reg_data;
1297 GSupplicantP2PServiceParams *params;
1304 if (specification && !version && !query &&
1305 is_service_wfd(specification, specification_length)) {
1306 return peer_register_wfd_service(specification,
1307 specification_length, callback, user_data);
1310 reg_data = g_try_malloc0(sizeof(*reg_data));
1314 reg_data->callback = callback;
1315 reg_data->user_data = user_data;
1317 ret_f = -EOPNOTSUPP;
1319 for (list = iface_list; list; list = list->next) {
1320 struct wifi_data *wifi = list->data;
1321 GSupplicantInterface *iface = wifi->interface;
1323 if (!g_supplicant_interface_has_p2p(iface))
1326 params = fill_in_peer_service_params(specification,
1327 specification_length, query,
1328 query_length, version);
1333 ret_f = g_supplicant_interface_p2p_add_service(iface,
1334 register_peer_service_cb, params, reg_data);
1335 if (ret_f == 0 || ret_f == -EINPROGRESS)
1339 ret = g_supplicant_interface_p2p_add_service(iface,
1340 register_peer_service_cb, params, NULL);
1341 if (ret != 0 && ret != -EINPROGRESS)
1342 free_peer_service_params(params);
1345 if (ret_f != 0 && ret_f != -EINPROGRESS)
1351 static int peer_unregister_wfd_service(void)
1353 GSupplicantP2PServiceParams *params;
1356 if (!wfd_service_registered)
1359 params = fill_in_peer_service_params(NULL, 0, NULL, 0, 0);
1363 wfd_service_registered = false;
1365 g_supplicant_set_widi_ies(params, NULL, NULL);
1367 for (list = iface_list; list; list = list->next) {
1368 struct wifi_data *wifi = list->data;
1370 if (!g_supplicant_interface_has_p2p(wifi->interface))
1374 if (!wifi->servicing || wifi->servicing < 0) {
1375 g_supplicant_interface_p2p_listen(wifi->interface,
1377 wifi->servicing = 0;
1384 static int peer_unregister_service(const unsigned char *specification,
1385 int specification_length,
1386 const unsigned char *query,
1387 int query_length, int version)
1389 GSupplicantP2PServiceParams *params;
1394 if (specification && !version && !query &&
1395 is_service_wfd(specification, specification_length)) {
1396 ret = peer_unregister_wfd_service();
1397 if (ret != 0 && ret != -EINPROGRESS)
1402 for (list = iface_list; list; list = list->next) {
1403 struct wifi_data *wifi = list->data;
1404 GSupplicantInterface *iface = wifi->interface;
1407 goto stop_listening;
1409 if (!g_supplicant_interface_has_p2p(iface))
1412 params = fill_in_peer_service_params(specification,
1413 specification_length, query,
1414 query_length, version);
1418 ret = g_supplicant_interface_p2p_del_service(iface, params);
1419 if (ret != 0 && ret != -EINPROGRESS)
1420 free_peer_service_params(params);
1423 if (!wifi->servicing || wifi->servicing < 0) {
1424 g_supplicant_interface_p2p_listen(iface, 0, 0);
1425 wifi->servicing = 0;
1432 static struct connman_peer_driver peer_driver = {
1433 .connect = peer_connect,
1434 .disconnect = peer_disconnect,
1435 .register_service = peer_register_service,
1436 .unregister_service = peer_unregister_service,
1439 static void handle_tethering(struct wifi_data *wifi)
1441 if (!wifi->tethering)
1450 DBG("index %d bridge %s", wifi->index, wifi->bridge);
1452 if (connman_inet_add_to_bridge(wifi->index, wifi->bridge) < 0)
1455 wifi->bridged = true;
1458 static void wifi_newlink(unsigned flags, unsigned change, void *user_data)
1460 struct connman_device *device = user_data;
1461 struct wifi_data *wifi = connman_device_get_data(device);
1466 DBG("index %d flags %d change %d", wifi->index, flags, change);
1468 if ((wifi->flags & IFF_UP) != (flags & IFF_UP)) {
1470 DBG("interface up");
1472 DBG("interface down");
1475 if ((wifi->flags & IFF_LOWER_UP) != (flags & IFF_LOWER_UP)) {
1476 if (flags & IFF_LOWER_UP)
1482 if (flags & IFF_LOWER_UP)
1483 handle_tethering(wifi);
1485 wifi->flags = flags;
1488 static int wifi_probe(struct connman_device *device)
1490 struct wifi_data *wifi;
1492 DBG("device %p", device);
1494 wifi = g_try_new0(struct wifi_data, 1);
1498 wifi->state = G_SUPPLICANT_STATE_INACTIVE;
1499 wifi->ap_supported = WIFI_AP_UNKNOWN;
1500 wifi->tethering_param = NULL;
1502 connman_device_set_data(device, wifi);
1503 wifi->device = connman_device_ref(device);
1505 wifi->index = connman_device_get_index(device);
1508 wifi->watch = connman_rtnl_add_newlink_watch(wifi->index,
1509 wifi_newlink, device);
1510 if (is_p2p_connecting())
1511 add_pending_wifi_device(wifi);
1513 iface_list = g_list_append(iface_list, wifi);
1518 static void remove_networks(struct connman_device *device,
1519 struct wifi_data *wifi)
1523 for (list = wifi->networks; list; list = list->next) {
1524 struct connman_network *network = list->data;
1526 connman_device_remove_network(device, network);
1527 connman_network_unref(network);
1530 g_slist_free(wifi->networks);
1531 wifi->networks = NULL;
1534 static void remove_peers(struct wifi_data *wifi)
1538 for (list = wifi->peers; list; list = list->next) {
1539 struct connman_peer *peer = list->data;
1541 connman_peer_unregister(peer);
1542 connman_peer_unref(peer);
1545 g_slist_free(wifi->peers);
1549 static void reset_autoscan(struct connman_device *device)
1551 struct wifi_data *wifi = connman_device_get_data(device);
1552 struct autoscan_params *autoscan;
1556 if (!wifi || !wifi->autoscan)
1559 autoscan = wifi->autoscan;
1561 autoscan->interval = 0;
1563 if (autoscan->timeout == 0)
1566 g_source_remove(autoscan->timeout);
1567 autoscan->timeout = 0;
1569 connman_device_unref(device);
1572 static void stop_autoscan(struct connman_device *device)
1574 const struct wifi_data *wifi = connman_device_get_data(device);
1576 if (!wifi || !wifi->autoscan)
1579 reset_autoscan(device);
1581 connman_device_set_scanning(device, CONNMAN_SERVICE_TYPE_WIFI, false);
1584 static void check_p2p_technology(void)
1586 bool p2p_exists = false;
1589 for (list = iface_list; list; list = list->next) {
1590 struct wifi_data *w = list->data;
1593 g_supplicant_interface_has_p2p(w->interface))
1598 connman_technology_driver_unregister(&p2p_tech_driver);
1599 connman_peer_driver_unregister(&peer_driver);
1603 struct last_connected {
1609 static gint sort_entry(gconstpointer a, gconstpointer b, gpointer user_data)
1611 GTimeVal *aval = (GTimeVal *)a;
1612 GTimeVal *bval = (GTimeVal *)b;
1614 /* Note that the sort order is descending */
1615 if (aval->tv_sec < bval->tv_sec)
1618 if (aval->tv_sec > bval->tv_sec)
1624 static void free_entry(gpointer data)
1626 struct last_connected *entry = data;
1628 g_free(entry->ssid);
1632 static void wifi_remove(struct connman_device *device)
1634 struct wifi_data *wifi = connman_device_get_data(device);
1636 DBG("device %p wifi %p", device, wifi);
1641 stop_autoscan(device);
1643 if (wifi->p2p_device)
1644 p2p_iface_list = g_list_remove(p2p_iface_list, wifi);
1646 iface_list = g_list_remove(iface_list, wifi);
1648 check_p2p_technology();
1649 #if defined TIZEN_EXT_WIFI_MESH
1650 check_mesh_technology();
1653 remove_pending_wifi_device(wifi);
1655 if (connman_device_get_scanning(device, CONNMAN_SERVICE_TYPE_P2P)) {
1656 g_source_remove(wifi->p2p_find_timeout);
1657 connman_device_unref(wifi->device);
1660 if (wifi->p2p_connection_timeout)
1661 g_source_remove(wifi->p2p_connection_timeout);
1663 #if defined TIZEN_EXT
1664 if (wifi->automaxspeed_timeout != 0) {
1665 g_source_remove(wifi->automaxspeed_timeout);
1666 wifi->automaxspeed_timeout = 0;
1670 remove_networks(device, wifi);
1673 connman_device_set_powered(device, false);
1674 connman_device_set_data(device, NULL);
1675 connman_device_unref(wifi->device);
1676 connman_rtnl_remove_watch(wifi->watch);
1678 g_supplicant_interface_set_data(wifi->interface, NULL);
1680 g_supplicant_interface_cancel(wifi->interface);
1682 if (wifi->scan_params)
1683 g_supplicant_free_scan_params(wifi->scan_params);
1684 #if defined TIZEN_EXT
1685 if (wifi->hidden_scan_params) {
1686 while (wifi->hidden_scan_params->ssids) {
1687 struct scan_ssid *ssid;
1688 ssid = wifi->hidden_scan_params->ssids->data;
1689 wifi->hidden_scan_params->ssids = g_slist_remove(wifi->hidden_scan_params->ssids, ssid);
1691 g_supplicant_free_scan_params(wifi->hidden_scan_params);
1695 g_free(wifi->autoscan);
1696 g_free(wifi->identifier);
1700 static bool is_duplicate(GSList *list, gchar *ssid, int ssid_len)
1704 for (iter = list; iter; iter = g_slist_next(iter)) {
1705 struct scan_ssid *scan_ssid = iter->data;
1707 if (ssid_len == scan_ssid->ssid_len &&
1708 memcmp(ssid, scan_ssid->ssid, ssid_len) == 0)
1715 static int add_scan_param(gchar *hex_ssid, char *raw_ssid, int ssid_len,
1716 int freq, GSupplicantScanParams *scan_data,
1717 int driver_max_scan_ssids, char *ssid_name)
1720 struct scan_ssid *scan_ssid;
1722 if ((driver_max_scan_ssids == 0 ||
1723 driver_max_scan_ssids > scan_data->num_ssids) &&
1724 (hex_ssid || raw_ssid)) {
1726 unsigned int j = 0, hex;
1729 size_t hex_ssid_len = strlen(hex_ssid);
1731 ssid = g_try_malloc0(hex_ssid_len / 2);
1735 for (i = 0; i < hex_ssid_len; i += 2) {
1736 sscanf(hex_ssid + i, "%02x", &hex);
1745 * If we have already added hidden AP to the list,
1746 * then do not do it again. This might happen if you have
1747 * used or are using multiple wifi cards, so in that case
1748 * you might have multiple service files for same AP.
1750 if (is_duplicate(scan_data->ssids, ssid, j)) {
1756 scan_ssid = g_try_new(struct scan_ssid, 1);
1763 memcpy(scan_ssid->ssid, ssid, j);
1764 scan_ssid->ssid_len = j;
1765 scan_data->ssids = g_slist_prepend(scan_data->ssids,
1768 scan_data->num_ssids++;
1770 DBG("SSID %s added to scanned list of %d entries", ssid_name,
1771 scan_data->num_ssids);
1778 scan_data->ssids = g_slist_reverse(scan_data->ssids);
1780 if (!scan_data->freqs) {
1781 scan_data->freqs = g_try_malloc0(sizeof(uint16_t));
1782 if (!scan_data->freqs) {
1783 g_slist_free_full(scan_data->ssids, g_free);
1787 scan_data->num_freqs = 1;
1788 scan_data->freqs[0] = freq;
1790 bool duplicate = false;
1792 /* Don't add duplicate entries */
1793 for (i = 0; i < scan_data->num_freqs; i++) {
1794 if (scan_data->freqs[i] == freq) {
1801 scan_data->num_freqs++;
1802 scan_data->freqs = g_try_realloc(scan_data->freqs,
1803 sizeof(uint16_t) * scan_data->num_freqs);
1804 if (!scan_data->freqs) {
1805 g_slist_free_full(scan_data->ssids, g_free);
1808 scan_data->freqs[scan_data->num_freqs - 1] = freq;
1815 static int get_hidden_connections(GSupplicantScanParams *scan_data)
1817 struct connman_config_entry **entries;
1819 #if defined TIZEN_EXT
1820 gchar **services = NULL;
1823 #endif /* defined TIZEN_EXT */
1827 int num_ssids = 0, add_param_failed = 0;
1828 #if defined TIZEN_EXT
1829 GSequenceIter *iter;
1830 GSequence *latest_list;
1831 struct last_connected *entry;
1834 latest_list = g_sequence_new(free_entry);
1838 services = connman_storage_get_services();
1839 for (i = 0; services && services[i]; i++) {
1840 if (strncmp(services[i], "wifi_", 5) != 0)
1843 keyfile = connman_storage_load_service(services[i]);
1847 value = g_key_file_get_boolean(keyfile,
1848 services[i], "Hidden", NULL);
1850 g_key_file_free(keyfile);
1854 value = g_key_file_get_boolean(keyfile,
1855 services[i], "Favorite", NULL);
1857 g_key_file_free(keyfile);
1861 #if defined TIZEN_EXT
1862 value = g_key_file_get_boolean(keyfile,
1863 services[i], "AutoConnect", NULL);
1865 g_key_file_free(keyfile);
1869 gchar *str = g_key_file_get_string(keyfile,
1870 services[i], "Modified", NULL);
1872 g_key_file_free(keyfile);
1875 g_time_val_from_iso8601(str, &modified);
1879 ssid = g_key_file_get_string(keyfile,
1880 services[i], "SSID", NULL);
1882 name = g_key_file_get_string(keyfile, services[i], "Name",
1885 #if defined TIZEN_EXT
1886 entry = g_try_new(struct last_connected, 1);
1888 g_sequence_free(latest_list);
1891 g_key_file_free(keyfile);
1895 entry->modified = modified;
1898 g_sequence_insert_sorted(latest_list, entry,
1901 ret = add_scan_param(ssid, NULL, 0, 0, scan_data, 0, name);
1910 g_key_file_free(keyfile);
1913 #if defined TIZEN_EXT
1914 gint length = g_sequence_get_length(latest_list);
1915 iter = g_sequence_get_begin_iter(latest_list);
1917 for (i = 0; i < length; i++) {
1918 entry = g_sequence_get(iter);
1920 ret = add_scan_param(entry->ssid, NULL, 0, 0, scan_data, 0, entry->ssid);
1926 iter = g_sequence_iter_next(iter);
1929 g_sequence_free(latest_list);
1933 * Check if there are any hidden AP that needs to be provisioned.
1935 entries = connman_config_get_entries("wifi");
1936 for (i = 0; entries && entries[i]; i++) {
1939 if (!entries[i]->hidden)
1942 if (!entries[i]->ssid) {
1943 ssid = entries[i]->name;
1946 ssid = entries[i]->ssid;
1947 len = entries[i]->ssid_len;
1953 ret = add_scan_param(NULL, ssid, len, 0, scan_data, 0, ssid);
1960 connman_config_free_entries(entries);
1962 if (add_param_failed > 0)
1963 DBG("Unable to scan %d out of %d SSIDs",
1964 add_param_failed, num_ssids);
1966 g_strfreev(services);
1971 static int get_hidden_connections_params(struct wifi_data *wifi,
1972 GSupplicantScanParams *scan_params)
1974 int driver_max_ssids, i;
1975 GSupplicantScanParams *orig_params;
1978 * Scan hidden networks so that we can autoconnect to them.
1979 * We will assume 1 as a default number of ssid to scan.
1981 driver_max_ssids = g_supplicant_interface_get_max_scan_ssids(
1983 if (driver_max_ssids == 0)
1984 driver_max_ssids = 1;
1986 DBG("max ssids %d", driver_max_ssids);
1988 #if defined TIZEN_EXT
1989 if (!wifi->hidden_scan_params) {
1990 wifi->hidden_scan_params = g_try_malloc0(sizeof(GSupplicantScanParams));
1991 if (!wifi->hidden_scan_params)
1994 if (get_hidden_connections(wifi->hidden_scan_params) == 0) {
1995 g_supplicant_free_scan_params(wifi->hidden_scan_params);
1996 wifi->hidden_scan_params = NULL;
2002 orig_params = wifi->hidden_scan_params;
2004 if (!wifi->scan_params) {
2005 wifi->scan_params = g_try_malloc0(sizeof(GSupplicantScanParams));
2006 if (!wifi->scan_params)
2009 if (get_hidden_connections(wifi->scan_params) == 0) {
2010 g_supplicant_free_scan_params(wifi->scan_params);
2011 wifi->scan_params = NULL;
2017 orig_params = wifi->scan_params;
2020 /* Let's transfer driver_max_ssids params */
2021 for (i = 0; i < driver_max_ssids; i++) {
2022 struct scan_ssid *ssid;
2024 #if defined TIZEN_EXT
2025 if (!wifi->hidden_scan_params->ssids)
2027 if (!wifi->scan_params->ssids)
2031 ssid = orig_params->ssids->data;
2032 orig_params->ssids = g_slist_remove(orig_params->ssids, ssid);
2033 scan_params->ssids = g_slist_prepend(scan_params->ssids, ssid);
2037 scan_params->num_ssids = i;
2038 scan_params->ssids = g_slist_reverse(scan_params->ssids);
2040 if (orig_params->num_freqs <= 0)
2043 scan_params->freqs =
2044 g_malloc(sizeof(uint16_t) * orig_params->num_freqs);
2045 memcpy(scan_params->freqs, orig_params->freqs,
2046 sizeof(uint16_t) *orig_params->num_freqs);
2048 scan_params->num_freqs = orig_params->num_freqs;
2053 orig_params->num_ssids -= scan_params->num_ssids;
2055 return scan_params->num_ssids;
2058 g_slist_free_full(scan_params->ssids, g_free);
2059 #if defined TIZEN_EXT
2060 g_supplicant_free_scan_params(wifi->hidden_scan_params);
2061 wifi->hidden_scan_params = NULL;
2063 g_supplicant_free_scan_params(wifi->scan_params);
2064 wifi->scan_params = NULL;
2070 static int throw_wifi_scan(struct connman_device *device,
2071 GSupplicantInterfaceCallback callback)
2073 struct wifi_data *wifi = connman_device_get_data(device);
2079 DBG("device %p %p", device, wifi->interface);
2081 if (wifi->tethering)
2084 #if defined TIZEN_EXT
2085 if (connman_device_get_scanning(device, CONNMAN_SERVICE_TYPE_WIFI)
2086 && !wifi->allow_full_scan)
2088 if (connman_device_get_scanning(device, CONNMAN_SERVICE_TYPE_WIFI))
2092 connman_device_ref(device);
2094 ret = g_supplicant_interface_scan(wifi->interface, NULL,
2097 connman_device_set_scanning(device,
2098 CONNMAN_SERVICE_TYPE_WIFI, true);
2100 connman_device_unref(device);
2105 static void hidden_free(struct hidden_params *hidden)
2110 if (hidden->scan_params)
2111 g_supplicant_free_scan_params(hidden->scan_params);
2112 g_free(hidden->identity);
2113 g_free(hidden->passphrase);
2114 g_free(hidden->security);
2118 #if defined TIZEN_EXT
2119 static void service_state_changed(struct connman_service *service,
2120 enum connman_service_state state);
2122 static int network_connect(struct connman_network *network);
2124 static struct connman_notifier notifier = {
2126 .priority = CONNMAN_NOTIFIER_PRIORITY_DEFAULT,
2127 .service_state_changed = service_state_changed,
2130 static void service_state_changed(struct connman_service *service,
2131 enum connman_service_state state)
2133 enum connman_service_type type;
2135 type = connman_service_get_type(service);
2136 if (type != CONNMAN_SERVICE_TYPE_WIFI)
2139 DBG("service %p state %d", service, state);
2142 case CONNMAN_SERVICE_STATE_READY:
2143 case CONNMAN_SERVICE_STATE_ONLINE:
2144 case CONNMAN_SERVICE_STATE_FAILURE:
2145 connman_notifier_unregister(¬ifier);
2146 is_wifi_notifier_registered = FALSE;
2148 __connman_device_request_scan(type);
2156 static gboolean need_bss_transition(uint16_t freq, int snr, int strength)
2159 * Since bssid->strength is a positive value,
2160 * it need to be changed to its original value.
2162 int signal = strength - 120;
2165 * If the currently connected AP matches the following conditions,
2166 * scan for BSS transition is started.
2167 * - SNR is less than min_snr or RSSI is less than
2168 * min_rssi_2_4GHz, min_rssi_5GHz or min_rssi_6GHz.
2170 if (min_snr != 0 && snr != 0 && snr < min_snr)
2172 else if (freq > FREQUENCY_6G_BASE && signal <= min_rssi_6GHz)
2174 else if (freq > FREQUENCY_5G_BASE && signal <= min_rssi_5GHz)
2176 else if (signal <= min_rssi_2_4GHz)
2182 static gboolean check_bss_diff(int cur_level, int sel_level, int to_5ghz,
2183 unsigned int cur_est, unsigned int sel_est)
2188 /* This code is from wpa_supplicant. */
2189 if (cur_level < -85) /* ..-86 dBm */
2191 else if (cur_level < -80) /* -85..-81 dBm */
2193 else if (cur_level < -75) /* -80..-76 dBm */
2195 else if (cur_level < -70) /* -75..-71 dBm */
2197 else if (cur_level < 0) /* -70..-1 dBm */
2199 else /* unspecified units (not in dBm) */
2202 if (cur_est > sel_est * 1.5)
2204 else if (cur_est > sel_est * 1.2)
2206 else if (cur_est > sel_est * 1.1)
2208 else if (cur_est > sel_est)
2210 else if (sel_est > cur_est * 1.5)
2212 else if (sel_est > cur_est * 1.2)
2214 else if (sel_est > cur_est * 1.1)
2216 else if (sel_est > cur_est)
2222 diff = sel_level - cur_level;
2224 if (diff < min_diff)
2230 static gboolean check_bss_condition(uint16_t freq, uint16_t strength,
2231 unsigned int est_throughput, uint16_t cur_freq, uint16_t cur_strength,
2232 unsigned int cur_est_throughput)
2235 * Since bssid->strength is a positive value,
2236 * it need to be changed to its original value.
2238 int signal = strength - 120;
2239 int cur_signal = cur_strength - 120;
2240 int to_5ghz = freq > 4000 && cur_freq < 4000;
2242 DBG("cur_freq=%d cur_level=%d cur_est=%d sel_freq=%d sel_level=%d sel_est=%d",
2243 cur_freq, cur_strength, cur_est_throughput,
2244 freq, strength, est_throughput);
2247 * If the AP that matches the following conditions exists in the SCAN result,
2248 * BSS transition is started.
2251 if (est_throughput > cur_est_throughput + 5000)
2254 if (cur_signal > signal + to_5ghz * 2 &&
2255 est_throughput < cur_est_throughput * 1.2)
2258 if (cur_est_throughput > est_throughput + 5000)
2261 return check_bss_diff(cur_signal, signal,
2262 to_5ghz, cur_est_throughput, est_throughput);
2265 static void scan_callback_hidden(int result,
2266 GSupplicantInterface *interface, void *user_data);
2268 static int network_disconnect(struct connman_network *network);
2270 static void start_roaming(struct wifi_data *wifi)
2272 bool roaming_ap_found = false;
2273 GSList *bssid_list = NULL;
2275 if (!wifi || !wifi->network)
2278 if (!connman_setting_get_bool("WifiRoaming"))
2281 struct connman_network *network = wifi->network;
2282 bssid_list = connman_network_get_bssid_list(network);
2284 if (g_slist_length(bssid_list) <= 1)
2287 if (!connman_network_get_connected(network))
2290 if (connman_network_get_bool(network, "WiFi.Roaming"))
2293 uint16_t cur_freq = connman_network_get_frequency(network);
2294 uint8_t cur_strength = connman_network_get_strength(network);
2295 unsigned int cur_est_throughput = connman_network_get_est_throughput(network);
2297 if (!need_bss_transition(
2299 connman_network_get_snr(network),
2303 unsigned char *cur_bssid = connman_network_get_bssid(network);
2305 for (; bssid_list; bssid_list = bssid_list->next) {
2306 struct g_connman_bssids *bssid = bssid_list->data;
2308 if (memcmp(cur_bssid, bssid->bssid, WIFI_BSSID_LEN_MAX) == 0)
2311 if (check_bss_condition(
2312 bssid->frequency, bssid->strength, bssid->est_throughput,
2313 cur_freq, cur_strength, cur_est_throughput)) {
2314 roaming_ap_found = true;
2316 char bssid_buff[WIFI_BSSID_STR_LEN] = {0,};
2317 char *bssid_str = bssid_buff;
2319 snprintf(bssid_str, WIFI_BSSID_STR_LEN, MACSTR, MAC2STR(bssid->bssid));
2320 connman_network_set_string(network,
2321 "WiFi.RoamingDstBSSID", bssid_str);
2326 if (roaming_ap_found) {
2327 char bssid_buff[WIFI_BSSID_STR_LEN] = {0,};
2328 char *bssid_str = bssid_buff;
2329 unsigned char *bssid;
2331 bssid = connman_network_get_bssid(network);
2332 snprintf(bssid_str, WIFI_BSSID_STR_LEN, MACSTR, MAC2STR(bssid));
2333 connman_network_set_string(network,
2334 "WiFi.RoamingCurBSSID", bssid_str);
2336 network_disconnect(network);
2337 wifi->pending_network = network;
2338 connman_network_set_bool(network, "WiFi.Roaming", true);
2343 static void scan_callback(int result, GSupplicantInterface *interface,
2346 struct connman_device *device = user_data;
2347 struct wifi_data *wifi = connman_device_get_data(device);
2349 #if defined TIZEN_EXT
2350 GSList *list = NULL;
2351 bool favorite_exists = false;
2352 struct connman_network *network = NULL;
2353 struct connman_service *service = NULL;
2356 DBG("result %d wifi %p", result, wifi);
2359 if (wifi->hidden && !wifi->postpone_hidden) {
2360 connman_network_clear_hidden(wifi->hidden->user_data);
2361 hidden_free(wifi->hidden);
2362 wifi->hidden = NULL;
2365 if (wifi->scan_params) {
2366 g_supplicant_free_scan_params(wifi->scan_params);
2367 wifi->scan_params = NULL;
2370 #if defined TIZEN_EXT
2371 if (wifi->hidden_scan_params && !wifi->hidden_scan_params->ssids) {
2372 g_supplicant_free_scan_params(wifi->hidden_scan_params);
2373 wifi->hidden_scan_params = NULL;
2379 connman_device_reset_scanning(device);
2381 /* User is connecting to a hidden AP, let's wait for finished event */
2382 if (wifi && wifi->hidden && wifi->postpone_hidden) {
2383 GSupplicantScanParams *scan_params;
2386 wifi->postpone_hidden = false;
2387 scan_params = wifi->hidden->scan_params;
2388 wifi->hidden->scan_params = NULL;
2390 reset_autoscan(device);
2392 ret = g_supplicant_interface_scan(wifi->interface, scan_params,
2393 scan_callback, device);
2397 /* On error, let's recall scan_callback, which will cleanup */
2398 return scan_callback(ret, interface, user_data);
2401 #if defined TIZEN_EXT
2403 for (list = wifi->networks; list; list = list->next) {
2404 network = list->data;
2405 service = connman_service_lookup_from_network(network);
2407 if (service != NULL &&
2408 (connman_service_get_favorite(service) == true) &&
2409 (connman_service_get_autoconnect(service) == true)) {
2410 DBG("Favorite service exists [%s]",
2411 connman_network_get_string(network, "Name"));
2412 favorite_exists = true;
2418 if (favorite_exists == false) {
2419 if (wifi && wifi->allow_full_scan) {
2421 DBG("Trigger full channel scan");
2422 wifi->allow_full_scan = false;
2424 ret = g_supplicant_interface_scan(wifi->interface, NULL,
2425 scan_callback_hidden, device);
2429 /* On error, let's recall scan_callback, which will cleanup */
2430 return scan_callback(ret, interface, user_data);
2433 wifi->allow_full_scan = false;
2436 scanning = connman_device_get_scanning(device, CONNMAN_SERVICE_TYPE_WIFI);
2439 connman_device_set_scanning(device,
2440 CONNMAN_SERVICE_TYPE_WIFI, false);
2443 if (result != -ENOLINK)
2444 #if defined TIZEN_EXT
2447 start_autoscan(device);
2450 * If we are here then we were scanning; however, if we are
2451 * also mid-flight disabling the interface, then wifi_disable
2452 * has already cleared the device scanning state and
2453 * unreferenced the device, obviating the need to do it here.
2457 connman_device_unref(device);
2459 #if defined TIZEN_EXT
2463 if (wifi->scan_pending_network && result != -EIO) {
2464 network_connect(wifi->scan_pending_network);
2465 wifi->scan_pending_network = NULL;
2466 connman_network_set_connecting(wifi->network);
2468 start_roaming(wifi);
2472 if (is_wifi_notifier_registered != true &&
2473 wifi_first_scan == true && found_with_first_scan == true) {
2474 wifi_first_scan = false;
2475 found_with_first_scan = false;
2477 connman_notifier_register(¬ifier);
2478 is_wifi_notifier_registered = true;
2483 static void scan_callback_hidden(int result,
2484 GSupplicantInterface *interface, void *user_data)
2486 struct connman_device *device = user_data;
2487 struct wifi_data *wifi = connman_device_get_data(device);
2488 GSupplicantScanParams *scan_params;
2491 DBG("result %d wifi %p", result, wifi);
2496 /* User is trying to connect to a hidden AP */
2497 if (wifi->hidden && wifi->postpone_hidden)
2500 scan_params = g_try_malloc0(sizeof(GSupplicantScanParams));
2504 if (get_hidden_connections_params(wifi, scan_params) > 0) {
2505 ret = g_supplicant_interface_scan(wifi->interface,
2507 #if defined TIZEN_EXT
2510 scan_callback_hidden,
2517 g_supplicant_free_scan_params(scan_params);
2520 scan_callback(result, interface, user_data);
2523 static gboolean autoscan_timeout(gpointer data)
2525 struct connman_device *device = data;
2526 struct wifi_data *wifi = connman_device_get_data(device);
2527 struct autoscan_params *autoscan;
2533 autoscan = wifi->autoscan;
2535 #if defined TIZEN_EXT
2540 if (autoscan->interval <= 0) {
2541 interval = autoscan->base;
2544 interval = autoscan->interval * autoscan->base;
2546 #if defined TIZEN_EXT
2547 if (autoscan->interval >= autoscan->limit)
2549 if (interval > autoscan->limit)
2551 interval = autoscan->limit;
2553 throw_wifi_scan(wifi->device, scan_callback_hidden);
2556 * In case BackgroundScanning is disabled, interval will reach the
2557 * limit exactly after the very first passive scanning. It allows
2558 * to ensure at most one passive scan is performed in such cases.
2560 if (!connman_setting_get_bool("BackgroundScanning") &&
2561 interval == autoscan->limit) {
2562 g_source_remove(autoscan->timeout);
2563 autoscan->timeout = 0;
2565 connman_device_unref(device);
2571 DBG("interval %d", interval);
2573 autoscan->interval = interval;
2575 autoscan->timeout = g_timeout_add_seconds(interval,
2576 autoscan_timeout, device);
2581 static void start_autoscan(struct connman_device *device)
2583 struct wifi_data *wifi = connman_device_get_data(device);
2584 struct autoscan_params *autoscan;
2591 if (wifi->p2p_device)
2594 if (wifi->connected)
2597 autoscan = wifi->autoscan;
2601 if (autoscan->timeout > 0 || autoscan->interval > 0)
2604 connman_device_ref(device);
2606 autoscan_timeout(device);
2609 static struct autoscan_params *parse_autoscan_params(const char *params)
2611 struct autoscan_params *autoscan;
2618 list_params = g_strsplit(params, ":", 0);
2619 if (list_params == 0)
2622 if (!g_strcmp0(list_params[0], "exponential") &&
2623 g_strv_length(list_params) == 3) {
2624 base = atoi(list_params[1]);
2625 limit = atoi(list_params[2]);
2626 } else if (!g_strcmp0(list_params[0], "single") &&
2627 g_strv_length(list_params) == 2)
2628 base = limit = atoi(list_params[1]);
2630 g_strfreev(list_params);
2634 DBG("Setup %s autoscanning", list_params[0]);
2636 g_strfreev(list_params);
2638 autoscan = g_try_malloc0(sizeof(struct autoscan_params));
2640 DBG("Could not allocate memory for autoscan");
2644 DBG("base %d - limit %d", base, limit);
2645 autoscan->base = base;
2646 autoscan->limit = limit;
2651 static void setup_autoscan(struct wifi_data *wifi)
2654 * If BackgroundScanning is enabled, setup exponential
2655 * autoscanning if it has not been previously done.
2657 if (connman_setting_get_bool("BackgroundScanning")) {
2658 wifi->autoscan = parse_autoscan_params(AUTOSCAN_EXPONENTIAL);
2661 #if defined TIZEN_EXT
2663 if (wifi->autoscan) {
2664 g_free(wifi->autoscan);
2665 wifi->autoscan = NULL;
2668 DBG("BackgroundScanning is disabled");
2675 * On the contrary, if BackgroundScanning is disabled, update autoscan
2676 * parameters based on the type of scanning that is being performed.
2678 if (wifi->autoscan) {
2679 g_free(wifi->autoscan);
2680 wifi->autoscan = NULL;
2683 switch (wifi->scanning_type) {
2684 case WIFI_SCANNING_PASSIVE:
2685 /* Do not setup autoscan. */
2687 case WIFI_SCANNING_ACTIVE:
2688 /* Setup one single passive scan after active. */
2689 wifi->autoscan = parse_autoscan_params(AUTOSCAN_SINGLE);
2691 case WIFI_SCANNING_UNKNOWN:
2692 /* Setup autoscan in this case but we should never fall here. */
2693 wifi->autoscan = parse_autoscan_params(AUTOSCAN_SINGLE);
2699 static void finalize_interface_creation(struct wifi_data *wifi)
2701 DBG("interface is ready wifi %p tethering %d", wifi, wifi->tethering);
2703 if (!wifi->device) {
2704 connman_error("WiFi device not set");
2708 connman_device_set_powered(wifi->device, true);
2710 if (wifi->p2p_device)
2713 if (!wifi->autoscan)
2714 setup_autoscan(wifi);
2716 start_autoscan(wifi->device);
2719 static void interface_create_callback(int result,
2720 GSupplicantInterface *interface,
2723 struct wifi_data *wifi = user_data;
2724 char *bgscan_range_max;
2727 DBG("result %d ifname %s, wifi %p", result,
2728 g_supplicant_interface_get_ifname(interface),
2731 if (result < 0 || !wifi)
2734 wifi->interface = interface;
2735 g_supplicant_interface_set_data(interface, wifi);
2741 !connman_device_get_wifi_5ghz_supported(wifi->device) &&
2742 !connman_device_get_wifi_6ghz_supported(wifi->device)) {
2743 bool is_5_0_ghz_supported = g_supplicant_interface_get_is_5_0_ghz_supported(interface);
2744 bool is_6_0_ghz_supported = g_supplicant_interface_get_is_6_0_ghz_supported(interface);
2746 connman_device_set_wifi_5ghz_supported(wifi->device, is_5_0_ghz_supported);
2747 connman_device_set_wifi_6ghz_supported(wifi->device, is_6_0_ghz_supported);
2750 if (g_supplicant_interface_get_ready(interface)) {
2751 wifi->interface_ready = true;
2752 finalize_interface_creation(wifi);
2756 * Set the BSS expiration age to match the long scanning
2757 * interval to avoid the loss of unconnected networks between
2760 bgscan_range_max = strrchr(BGSCAN_DEFAULT, ':');
2761 if (!bgscan_range_max || strlen(bgscan_range_max) < 1)
2764 value = strtol(bgscan_range_max + 1, NULL, 10);
2765 if (value <= 0 || errno == ERANGE)
2768 if (g_supplicant_interface_set_bss_expiration_age(interface,
2769 value + SCAN_MAX_DURATION) < 0) {
2770 connman_warn("Failed to set bss expiration age");
2774 static int wifi_enable(struct connman_device *device)
2776 struct wifi_data *wifi = connman_device_get_data(device);
2779 const char *driver = connman_setting_get_string("wifi");
2782 DBG("device %p %p", device, wifi);
2784 index = connman_device_get_index(device);
2785 if (!wifi || index < 0)
2788 if (is_p2p_connecting())
2789 return -EINPROGRESS;
2791 interface = connman_inet_ifname(index);
2792 ret = g_supplicant_interface_create(interface, driver, NULL,
2794 connman_device_get_mac_policy(device),
2795 connman_device_get_preassoc_mac_policy(device),
2796 connman_device_get_random_mac_lifetime(device),
2797 #endif /* TIZEN_EXT */
2798 interface_create_callback,
2805 return -EINPROGRESS;
2808 static int wifi_disable(struct connman_device *device)
2810 struct wifi_data *wifi = connman_device_get_data(device);
2813 DBG("device %p wifi %p", device, wifi);
2818 wifi->connected = false;
2819 wifi->disconnecting = false;
2821 if (wifi->pending_network)
2822 wifi->pending_network = NULL;
2824 #if !defined TIZEN_EXT
2825 stop_autoscan(device);
2828 if (connman_device_get_scanning(device, CONNMAN_SERVICE_TYPE_P2P)) {
2829 g_source_remove(wifi->p2p_find_timeout);
2830 wifi->p2p_find_timeout = 0;
2831 connman_device_set_scanning(device, CONNMAN_SERVICE_TYPE_P2P, false);
2832 connman_device_unref(wifi->device);
2835 #if defined TIZEN_EXT
2836 if (wifi->automaxspeed_timeout != 0) {
2837 g_source_remove(wifi->automaxspeed_timeout);
2838 wifi->automaxspeed_timeout = 0;
2842 /* In case of a user scan, device is still referenced */
2843 if (connman_device_get_scanning(device, CONNMAN_SERVICE_TYPE_WIFI)) {
2844 connman_device_set_scanning(device,
2845 CONNMAN_SERVICE_TYPE_WIFI, false);
2846 connman_device_unref(wifi->device);
2849 #if defined TIZEN_EXT
2850 stop_autoscan(device);
2853 remove_networks(device, wifi);
2856 #if defined TIZEN_EXT
2857 wifi->scan_pending_network = NULL;
2859 if (is_wifi_notifier_registered == true) {
2860 connman_notifier_unregister(¬ifier);
2861 is_wifi_notifier_registered = false;
2865 ret = g_supplicant_interface_remove(wifi->interface, NULL, NULL);
2869 return -EINPROGRESS;
2872 static int get_latest_connections(int max_ssids,
2873 GSupplicantScanParams *scan_data)
2875 GSequenceIter *iter;
2876 GSequence *latest_list;
2877 struct last_connected *entry;
2886 latest_list = g_sequence_new(free_entry);
2890 services = connman_storage_get_services();
2891 for (i = 0; services && services[i]; i++) {
2892 if (strncmp(services[i], "wifi_", 5) != 0)
2895 keyfile = connman_storage_load_service(services[i]);
2899 str = g_key_file_get_string(keyfile,
2900 services[i], "Favorite", NULL);
2901 if (!str || g_strcmp0(str, "true")) {
2903 g_key_file_free(keyfile);
2908 str = g_key_file_get_string(keyfile,
2909 services[i], "AutoConnect", NULL);
2910 if (!str || g_strcmp0(str, "true")) {
2912 g_key_file_free(keyfile);
2917 str = g_key_file_get_string(keyfile,
2918 services[i], "Modified", NULL);
2920 g_key_file_free(keyfile);
2923 #if defined TIZEN_EXT
2925 util_iso8601_to_timeval(str, (struct timeval *)&modified);
2927 util_iso8601_to_timeval(str, &modified);
2931 ssid = g_key_file_get_string(keyfile,
2932 services[i], "SSID", NULL);
2934 freq = g_key_file_get_integer(keyfile, services[i],
2937 entry = g_try_new(struct last_connected, 1);
2939 g_sequence_free(latest_list);
2940 g_key_file_free(keyfile);
2942 #if defined TIZEN_EXT
2943 g_strfreev(services);
2949 entry->modified = modified;
2952 g_sequence_insert_sorted(latest_list, entry,
2958 g_key_file_free(keyfile);
2961 g_strfreev(services);
2963 num_ssids = num_ssids > max_ssids ? max_ssids : num_ssids;
2965 iter = g_sequence_get_begin_iter(latest_list);
2967 for (i = 0; i < num_ssids; i++) {
2968 entry = g_sequence_get(iter);
2970 DBG("ssid %s freq %d modified %lu", entry->ssid, entry->freq,
2971 entry->modified.tv_sec);
2973 add_scan_param(entry->ssid, NULL, 0, entry->freq, scan_data,
2974 max_ssids, entry->ssid);
2976 iter = g_sequence_iter_next(iter);
2979 g_sequence_free(latest_list);
2983 static void wifi_update_scanner_type(struct wifi_data *wifi,
2984 enum wifi_scanning_type new_type)
2988 if (!wifi || wifi->scanning_type == new_type)
2991 wifi->scanning_type = new_type;
2993 setup_autoscan(wifi);
2996 static int wifi_scan_simple(struct connman_device *device)
2998 struct wifi_data *wifi = connman_device_get_data(device);
3000 reset_autoscan(device);
3002 /* Distinguish between devices performing passive and active scanning */
3004 wifi_update_scanner_type(wifi, WIFI_SCANNING_PASSIVE);
3006 return throw_wifi_scan(device, scan_callback_hidden);
3009 static gboolean p2p_find_stop(gpointer data)
3011 struct connman_device *device = data;
3012 struct wifi_data *wifi = connman_device_get_data(device);
3017 wifi->p2p_find_timeout = 0;
3019 g_supplicant_interface_p2p_stop_find(wifi->interface);
3022 connman_device_set_scanning(device, CONNMAN_SERVICE_TYPE_P2P, false);
3024 connman_device_unref(device);
3025 start_autoscan(device);
3030 static void p2p_find_callback(int result, GSupplicantInterface *interface,
3033 struct connman_device *device = user_data;
3034 struct wifi_data *wifi = connman_device_get_data(device);
3036 DBG("result %d wifi %p", result, wifi);
3041 if (wifi->p2p_find_timeout) {
3042 g_source_remove(wifi->p2p_find_timeout);
3043 wifi->p2p_find_timeout = 0;
3049 wifi->p2p_find_timeout = g_timeout_add_seconds(P2P_FIND_TIMEOUT,
3050 p2p_find_stop, device);
3051 if (!wifi->p2p_find_timeout)
3056 p2p_find_stop(device);
3059 static int p2p_find(struct connman_device *device)
3061 struct wifi_data *wifi;
3066 if (!p2p_technology)
3069 wifi = connman_device_get_data(device);
3071 if (g_supplicant_interface_is_p2p_finding(wifi->interface))
3074 reset_autoscan(device);
3075 connman_device_ref(device);
3077 ret = g_supplicant_interface_p2p_find(wifi->interface,
3078 p2p_find_callback, device);
3080 connman_device_unref(device);
3081 start_autoscan(device);
3083 connman_device_set_scanning(device,
3084 CONNMAN_SERVICE_TYPE_P2P, true);
3090 #if defined TIZEN_EXT
3091 static void specific_scan_callback(int result, GSupplicantInterface *interface,
3094 struct connman_device *device = user_data;
3095 struct wifi_data *wifi = connman_device_get_data(device);
3098 DBG("result %d device %p wifi %p", result, device, wifi);
3100 if (wifi && wifi->scan_params) {
3101 g_supplicant_free_scan_params(wifi->scan_params);
3102 wifi->scan_params = NULL;
3105 scanning = connman_device_get_scanning(device,
3106 CONNMAN_SERVICE_TYPE_WIFI);
3108 connman_device_set_scanning(device,
3109 CONNMAN_SERVICE_TYPE_WIFI, false);
3110 connman_device_unref(device);
3113 start_roaming(wifi);
3116 static int wifi_specific_scan(enum connman_service_type type,
3117 struct connman_device *device, int scan_type,
3118 GSList *specific_scan_list, void *user_data)
3120 GSList *list = NULL;
3122 struct wifi_data *wifi = connman_device_get_data(device);
3123 GSupplicantScanParams *scan_params = NULL;
3124 struct scan_ssid *scan_ssid = NULL;
3133 if (wifi->p2p_device)
3136 if (type == CONNMAN_SERVICE_TYPE_P2P)
3137 return p2p_find(device);
3139 if (wifi->tethering)
3143 connman_device_get_scanning(device,
3144 CONNMAN_SERVICE_TYPE_WIFI);
3148 DBG("scan_type: %d", scan_type);
3149 if (scan_type == CONNMAN_MULTI_SCAN_SSID) { /* ssid based scan */
3150 scan_params = g_try_malloc0(sizeof(GSupplicantScanParams));
3152 DBG("Failed to allocate memory.");
3156 for (list = specific_scan_list; list; list = list->next) {
3157 ssid = (char *)list->data;
3158 int ssid_len = strlen(ssid);
3160 scan_ssid = g_try_new0(struct scan_ssid, 1);
3162 DBG("Failed to allocate memory.");
3163 g_supplicant_free_scan_params(scan_params);
3167 memcpy(scan_ssid->ssid, ssid, (ssid_len + 1));
3168 /* DBG("scan ssid %s len: %d", scan_ssid->ssid, ssid_len); */
3169 scan_ssid->ssid_len = ssid_len;
3170 scan_params->ssids = g_slist_prepend(scan_params->ssids, scan_ssid);
3173 scan_params->num_ssids = count;
3175 } else if (scan_type == CONNMAN_MULTI_SCAN_FREQ) { /* frequency based scan */
3177 scan_params = g_try_malloc0(sizeof(GSupplicantScanParams));
3179 DBG("Failed to allocate memory.");
3183 guint num_freqs = g_slist_length(specific_scan_list);
3184 DBG("num_freqs: %d", num_freqs);
3186 scan_params->freqs = g_try_new0(uint16_t, num_freqs);
3187 if (!scan_params->freqs) {
3188 DBG("Failed to allocate memory.");
3189 g_free(scan_params);
3194 for (list = specific_scan_list; list; list = list->next) {
3195 freq = GPOINTER_TO_INT(list->data);
3197 scan_params->freqs[count] = freq;
3198 DBG("scan_params->freqs[%d]: %d", count, scan_params->freqs[count]);
3201 scan_params->num_freqs = count;
3203 } else if (scan_type == CONNMAN_MULTI_SCAN_SSID_FREQ) { /* SSID & Frequency mixed scan */
3204 int freq_count, ap_count;
3205 scan_params = g_try_malloc0(sizeof(GSupplicantScanParams));
3207 DBG("Failed to allocate memory.");
3211 guint size = g_slist_length(specific_scan_list);
3213 scan_params->freqs = g_try_new0(uint16_t, size/2);
3214 if (!scan_params->freqs) {
3215 DBG("Failed to allocate memory.");
3216 g_free(scan_params);
3220 ap_count = freq_count = 0;
3221 for (list = specific_scan_list; list; list = list->next) {
3222 if (((connman_multi_scan_ap_s *)list->data)->flag == true) { /** ssid */
3223 ssid = ((connman_multi_scan_ap_s *)list->data)->str;
3224 int ssid_len = strlen(ssid);
3226 scan_ssid = g_try_new0(struct scan_ssid, 1);
3228 DBG("Failed to allocate memory.");
3229 g_supplicant_free_scan_params(scan_params);
3233 memcpy(scan_ssid->ssid, ssid, (ssid_len + 1));
3234 /* DBG("scan ssid %s len: %d", scan_ssid->ssid, ssid_len); */
3235 scan_ssid->ssid_len = ssid_len;
3236 scan_params->ssids = g_slist_prepend(scan_params->ssids, scan_ssid);
3240 freq = atoi(((connman_multi_scan_ap_s *)list->data)->str);
3241 scan_params->freqs[freq_count] = freq;
3242 DBG("scan_params->freqs[%d]: %d", freq_count, scan_params->freqs[freq_count]);
3246 scan_params->num_ssids = ap_count;
3247 scan_params->num_freqs = freq_count;
3249 DBG("Invalid scan");
3253 reset_autoscan(device);
3254 connman_device_ref(device);
3256 ret = g_supplicant_interface_scan(wifi->interface, scan_params,
3257 specific_scan_callback, device);
3260 connman_device_set_scanning(device,
3261 CONNMAN_SERVICE_TYPE_WIFI, true);
3263 g_supplicant_free_scan_params(scan_params);
3264 connman_device_unref(device);
3270 static void wifi_mac_policy_callback(int result,
3271 unsigned int policy,
3274 struct connman_device *device = user_data;
3277 connman_device_mac_policy_notify(device, result, policy);
3279 connman_device_unref(device);
3282 int wifi_set_mac_policy(struct connman_device *device, unsigned int policy)
3284 struct wifi_data *wifi = connman_device_get_data(device);
3290 connman_device_ref(device);
3292 ret = g_supplicant_interface_set_mac_policy(wifi->interface,
3293 wifi_mac_policy_callback,
3296 connman_device_unref(device);
3301 static void wifi_preassoc_mac_policy_callback(int result,
3302 unsigned int policy,
3305 struct connman_device *device = user_data;
3308 connman_device_preassoc_mac_policy_notify(device, result, policy);
3310 connman_device_unref(device);
3313 int wifi_set_preassoc_mac_policy(struct connman_device *device, unsigned int policy)
3315 struct wifi_data *wifi = connman_device_get_data(device);
3321 connman_device_ref(device);
3323 ret = g_supplicant_interface_set_preassoc_mac_policy(wifi->interface,
3324 wifi_preassoc_mac_policy_callback,
3327 connman_device_unref(device);
3332 static void wifi_random_mac_lifetime_callback(int result,
3333 unsigned int lifetime,
3336 struct connman_device *device = user_data;
3339 connman_device_random_mac_lifetime_notify(device, result, lifetime);
3341 connman_device_unref(device);
3344 int wifi_set_random_mac_lifetime(struct connman_device *device, unsigned int lifetime)
3346 struct wifi_data *wifi = connman_device_get_data(device);
3352 connman_device_ref(device);
3354 ret = g_supplicant_interface_set_random_mac_lifetime(wifi->interface,
3355 wifi_random_mac_lifetime_callback,
3358 connman_device_unref(device);
3364 #if defined TIZEN_EXT_WIFI_MESH
3365 static void mesh_scan_callback(int result, GSupplicantInterface *interface,
3368 struct connman_device *device = user_data;
3369 struct wifi_data *wifi = connman_device_get_data(device);
3372 DBG("result %d wifi %p", result, wifi);
3374 scanning = connman_device_get_scanning(device,
3375 CONNMAN_SERVICE_TYPE_MESH);
3377 connman_device_set_scanning(device,
3378 CONNMAN_SERVICE_TYPE_MESH, false);
3381 connman_device_unref(device);
3384 static int mesh_scan(struct connman_device *device)
3386 struct wifi_data *wifi;
3387 struct wifi_mesh_info *mesh_info;
3392 wifi = connman_device_get_data(device);
3394 if (!wifi || !wifi->mesh_interface)
3397 mesh_info = wifi->mesh_info;
3398 reset_autoscan(device);
3399 connman_device_ref(device);
3401 ret = g_supplicant_interface_scan(mesh_info->interface, NULL,
3402 mesh_scan_callback, device);
3404 connman_device_unref(device);
3406 connman_device_set_scanning(device,
3407 CONNMAN_SERVICE_TYPE_MESH, true);
3412 static void abort_scan_callback(int result, GSupplicantInterface *interface,
3415 struct connman_device *device = user_data;
3416 struct wifi_data *wifi = connman_device_get_data(device);
3418 DBG("result %d wifi %p", result, wifi);
3420 __connman_technology_notify_abort_scan(CONNMAN_SERVICE_TYPE_MESH, result);
3423 static int mesh_abort_scan(enum connman_service_type type,
3424 struct connman_device *device)
3426 struct wifi_data *wifi = connman_device_get_data(device);
3427 struct wifi_mesh_info *mesh_info;
3431 if (!wifi || !wifi->mesh_interface)
3434 if (type != CONNMAN_SERVICE_TYPE_MESH)
3437 mesh_info = wifi->mesh_info;
3439 scanning = connman_device_get_scanning(device,
3440 CONNMAN_SERVICE_TYPE_MESH);
3444 ret = g_supplicant_interface_abort_scan(mesh_info->interface,
3445 abort_scan_callback, device);
3450 static int mesh_specific_scan(enum connman_service_type type,
3451 struct connman_device *device, const char *ssid,
3452 unsigned int freq, void *user_data)
3454 struct wifi_data *wifi = connman_device_get_data(device);
3455 GSupplicantScanParams *scan_params = NULL;
3456 struct wifi_mesh_info *mesh_info;
3457 struct scan_ssid *scan_ssid;
3461 if (!wifi || !wifi->mesh_interface)
3464 if (type != CONNMAN_SERVICE_TYPE_MESH)
3467 if (wifi->p2p_device)
3470 mesh_info = wifi->mesh_info;
3472 scanning = connman_device_get_scanning(device,
3473 CONNMAN_SERVICE_TYPE_MESH);
3477 scan_params = g_try_malloc0(sizeof(GSupplicantScanParams));
3481 scan_ssid = g_try_new(struct scan_ssid, 1);
3483 g_free(scan_params);
3487 scan_ssid->ssid_len = strlen(ssid);
3488 memcpy(scan_ssid->ssid, ssid, scan_ssid->ssid_len);
3489 scan_params->ssids = g_slist_prepend(scan_params->ssids, scan_ssid);
3490 scan_params->num_ssids = 1;
3492 scan_params->freqs = g_try_new(uint16_t, 1);
3493 if (!scan_params->freqs) {
3494 g_slist_free_full(scan_params->ssids, g_free);
3495 g_free(scan_params);
3499 scan_params->freqs[0] = freq;
3500 scan_params->num_freqs = 1;
3502 reset_autoscan(device);
3503 connman_device_ref(device);
3505 ret = g_supplicant_interface_scan(mesh_info->interface, scan_params,
3506 mesh_scan_callback, device);
3509 connman_device_set_scanning(device,
3510 CONNMAN_SERVICE_TYPE_MESH, true);
3512 g_supplicant_free_scan_params(scan_params);
3513 connman_device_unref(device);
3521 * Note that the hidden scan is only used when connecting to this specific
3522 * hidden AP first time. It is not used when system autoconnects to hidden AP.
3524 static int wifi_scan(struct connman_device *device,
3525 struct connman_device_scan_params *params)
3527 struct wifi_data *wifi = connman_device_get_data(device);
3528 GSupplicantScanParams *scan_params = NULL;
3529 struct scan_ssid *scan_ssid;
3530 struct hidden_params *hidden;
3532 int driver_max_ssids = 0;
3539 if (wifi->p2p_device)
3542 if (wifi->tethering)
3545 if (params->type == CONNMAN_SERVICE_TYPE_P2P)
3546 return p2p_find(device);
3548 #if defined TIZEN_EXT_WIFI_MESH
3549 if (params->type == CONNMAN_SERVICE_TYPE_MESH)
3550 return mesh_scan(device);
3553 DBG("device %p wifi %p hidden ssid %s", device, wifi->interface,
3556 scanning = connman_device_get_scanning(device, CONNMAN_SERVICE_TYPE_WIFI);
3558 if (!params->ssid || params->ssid_len == 0 || params->ssid_len > 32) {
3562 driver_max_ssids = g_supplicant_interface_get_max_scan_ssids(
3564 DBG("max ssids %d", driver_max_ssids);
3565 if (driver_max_ssids == 0)
3566 return wifi_scan_simple(device);
3570 if (scanning && wifi->hidden && wifi->postpone_hidden)
3576 scan_params = g_try_malloc0(sizeof(GSupplicantScanParams));
3581 scan_ssid = g_try_new(struct scan_ssid, 1);
3583 g_free(scan_params);
3587 memcpy(scan_ssid->ssid, params->ssid, params->ssid_len);
3588 scan_ssid->ssid_len = params->ssid_len;
3589 scan_params->ssids = g_slist_prepend(scan_params->ssids,
3591 scan_params->num_ssids = 1;
3593 hidden = g_try_new0(struct hidden_params, 1);
3595 g_supplicant_free_scan_params(scan_params);
3600 hidden_free(wifi->hidden);
3601 wifi->hidden = NULL;
3604 memcpy(hidden->ssid, params->ssid, params->ssid_len);
3605 hidden->ssid_len = params->ssid_len;
3606 hidden->identity = g_strdup(params->identity);
3607 hidden->passphrase = g_strdup(params->passphrase);
3608 hidden->security = g_strdup(params->security);
3609 hidden->user_data = params->user_data;
3610 wifi->hidden = hidden;
3613 /* Let's keep this active scan for later,
3614 * when current scan will be over. */
3615 wifi->postpone_hidden = TRUE;
3616 hidden->scan_params = scan_params;
3620 } else if (wifi->connected) {
3621 g_supplicant_free_scan_params(scan_params);
3622 return wifi_scan_simple(device);
3623 } else if (!params->force_full_scan) {
3624 ret = get_latest_connections(driver_max_ssids, scan_params);
3626 g_supplicant_free_scan_params(scan_params);
3627 return wifi_scan_simple(device);
3631 /* Distinguish between devices performing passive and active scanning */
3632 wifi_update_scanner_type(wifi, WIFI_SCANNING_ACTIVE);
3634 connman_device_ref(device);
3636 reset_autoscan(device);
3637 #if defined TIZEN_EXT
3639 * When doing a full scan, stored hidden networks also need to be scanned
3640 * so that we can autoconnect to them.
3642 if (params->force_full_scan)
3643 ret = g_supplicant_interface_scan(wifi->interface, scan_params,
3644 scan_callback_hidden, device);
3647 ret = g_supplicant_interface_scan(wifi->interface, scan_params,
3648 scan_callback, device);
3650 connman_device_set_scanning(device,
3651 CONNMAN_SERVICE_TYPE_WIFI, true);
3652 #if defined TIZEN_EXT
3654 * To allow the Full Scan after ssid based scan, set the flag here
3655 * It is required because Tizen does not use the ConnMan specific
3656 * backgroung Scan feature.Tizen has added the BG Scan feature in
3657 * net-config. To sync with up ConnMan, we need to issue the Full Scan
3658 * after SSID specific scan.
3660 if (!params->force_full_scan && !do_hidden)
3661 wifi->allow_full_scan = TRUE;
3664 g_supplicant_free_scan_params(scan_params);
3665 connman_device_unref(device);
3668 hidden_free(wifi->hidden);
3669 wifi->hidden = NULL;
3676 static void wifi_stop_scan(enum connman_service_type type,
3677 struct connman_device *device)
3679 struct wifi_data *wifi = connman_device_get_data(device);
3681 DBG("device %p wifi %p", device, wifi);
3686 if (type == CONNMAN_SERVICE_TYPE_P2P) {
3687 if (connman_device_get_scanning(device, CONNMAN_SERVICE_TYPE_P2P)) {
3688 g_source_remove(wifi->p2p_find_timeout);
3689 p2p_find_stop(device);
3694 static void wifi_regdom_callback(int result,
3698 struct connman_device *device = user_data;
3700 connman_device_regdom_notify(device, result, alpha2);
3702 connman_device_unref(device);
3705 static int wifi_set_regdom(struct connman_device *device, const char *alpha2)
3707 struct wifi_data *wifi = connman_device_get_data(device);
3713 connman_device_ref(device);
3715 ret = g_supplicant_interface_set_country(wifi->interface,
3716 wifi_regdom_callback,
3719 connman_device_unref(device);
3724 static struct connman_device_driver wifi_ng_driver = {
3726 .type = CONNMAN_DEVICE_TYPE_WIFI,
3727 .priority = CONNMAN_DEVICE_PRIORITY_LOW,
3728 .probe = wifi_probe,
3729 .remove = wifi_remove,
3730 .enable = wifi_enable,
3731 .disable = wifi_disable,
3733 .stop_scan = wifi_stop_scan,
3734 .set_regdom = wifi_set_regdom,
3735 #if defined TIZEN_EXT
3736 .specific_scan = wifi_specific_scan,
3737 .set_mac_policy = wifi_set_mac_policy,
3738 .set_preassoc_mac_policy = wifi_set_preassoc_mac_policy,
3739 .set_random_mac_lifetime = wifi_set_random_mac_lifetime,
3741 #if defined TIZEN_EXT_WIFI_MESH
3742 .abort_scan = mesh_abort_scan,
3743 .mesh_specific_scan = mesh_specific_scan,
3747 static void system_ready(void)
3751 if (connman_device_driver_register(&wifi_ng_driver) < 0)
3752 connman_error("Failed to register WiFi driver");
3755 static void system_killed(void)
3759 connman_device_driver_unregister(&wifi_ng_driver);
3762 static int network_probe(struct connman_network *network)
3764 #if defined TIZEN_EXT
3765 if (!simplified_log)
3767 DBG("network %p", network);
3772 static void network_remove(struct connman_network *network)
3774 struct connman_device *device = connman_network_get_device(network);
3775 struct wifi_data *wifi;
3776 #if defined TIZEN_EXT
3777 GSupplicantSSID *ssid;
3778 const void *ssid_data;
3779 const char *security;
3782 DBG("network %p", network);
3784 wifi = connman_device_get_data(device);
3788 if (wifi->network != network)
3791 wifi->network = NULL;
3793 #if defined TIZEN_EXT
3794 wifi->disconnecting = false;
3796 if (wifi->pending_network == network)
3797 wifi->pending_network = NULL;
3799 if (wifi->scan_pending_network == network)
3800 wifi->scan_pending_network = NULL;
3803 * If this remove network is for the same network
3804 * for which wpa_supplicant already has a profile
3805 * then need to remove that profile.
3807 ssid = g_try_malloc0(sizeof(GSupplicantSSID));
3811 ssid_data = connman_network_get_blob(network, "WiFi.SSID",
3814 ssid->ssid = g_try_malloc0(ssid->ssid_len);
3820 memcpy(ssid->ssid, ssid_data, ssid->ssid_len);
3823 security = connman_network_get_string(network, "WiFi.Security");
3824 ssid->security = network_security(security);
3826 g_supplicant_interface_remove_network(wifi->interface, ssid);
3833 static void connect_callback(int result, GSupplicantInterface *interface,
3836 #if defined TIZEN_EXT
3838 struct wifi_data *wifi;
3840 struct connman_network *network = user_data;
3842 DBG("network %p result %d", network, result);
3844 #if defined TIZEN_EXT
3845 const char *ifname = g_supplicant_interface_get_ifname(interface);
3846 set_connman_bssid(RESET_BSSID, NULL, ifname);
3848 for (list = iface_list; list; list = list->next) {
3851 if (wifi && wifi->network == network)
3855 /* wifi_data may be invalid because wifi is already disabled */
3859 if (connman_network_get_bool(network, "WiFi.Roaming")) {
3861 connman_network_set_bool(network, "WiFi.Roaming", false);
3862 connman_network_set_string(network,
3863 "WiFi.RoamingCurBSSID", NULL);
3865 char bssid_buff[WIFI_BSSID_STR_LEN] = {0,};
3866 char *bssid_str = bssid_buff;
3867 unsigned char *bssid;
3868 const char *cur_bssid;
3870 bssid = g_supplicant_interface_get_add_network_bssid(interface);
3872 connman_network_set_bool(network, "WiFi.Roaming", false);
3873 connman_network_set_string(network,
3874 "WiFi.RoamingCurBSSID", NULL);
3878 MACSTR, MAC2STR(bssid));
3880 connman_network_set_string(network,
3881 "WiFi.RoamingDstBSSID", bssid_str);
3883 cur_bssid = connman_network_get_string(network,
3884 "WiFi.RoamingCurBSSID");
3886 __connman_technology_notify_roaming_state(ifname,
3887 "started", cur_bssid, bssid_str);
3892 if (result == -ENOKEY) {
3893 connman_network_set_error(network,
3894 CONNMAN_NETWORK_ERROR_INVALID_KEY);
3895 } else if (result < 0) {
3896 connman_network_set_error(network,
3897 CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL);
3900 connman_network_unref(network);
3903 static GSupplicantSecurity network_security(const char *security)
3905 if (g_str_equal(security, "none"))
3906 return G_SUPPLICANT_SECURITY_NONE;
3907 else if (g_str_equal(security, "wep"))
3908 return G_SUPPLICANT_SECURITY_WEP;
3909 else if (g_str_equal(security, "psk"))
3910 return G_SUPPLICANT_SECURITY_PSK;
3911 else if (g_str_equal(security, "wpa"))
3912 return G_SUPPLICANT_SECURITY_PSK;
3913 else if (g_str_equal(security, "rsn"))
3914 return G_SUPPLICANT_SECURITY_PSK;
3915 else if (g_str_equal(security, "ieee8021x"))
3916 return G_SUPPLICANT_SECURITY_IEEE8021X;
3917 #if defined TIZEN_EXT
3918 else if (g_str_equal(security, "ft_psk") == TRUE)
3919 return G_SUPPLICANT_SECURITY_FT_PSK;
3920 else if (g_str_equal(security, "ft_ieee8021x") == TRUE)
3921 return G_SUPPLICANT_SECURITY_FT_IEEE8021X;
3922 else if (g_str_equal(security, "sae"))
3923 return G_SUPPLICANT_SECURITY_SAE;
3924 else if (g_str_equal(security, "owe"))
3925 return G_SUPPLICANT_SECURITY_OWE;
3926 else if (g_str_equal(security, "dpp"))
3927 return G_SUPPLICANT_SECURITY_DPP;
3928 else if (g_str_equal(security, "psk_sha256") == TRUE)
3929 return G_SUPPLICANT_SECURITY_PSK_SHA256;
3932 return G_SUPPLICANT_SECURITY_UNKNOWN;
3935 #if defined TIZEN_EXT
3936 static GSupplicantEapKeymgmt network_eap_keymgmt(const char *security)
3938 if (security == NULL)
3939 return G_SUPPLICANT_EAP_KEYMGMT_NONE;
3941 if (g_str_equal(security, "FT") == TRUE)
3942 return G_SUPPLICANT_EAP_KEYMGMT_FT;
3943 else if (g_str_equal(security, "CCKM") == TRUE)
3944 return G_SUPPLICANT_EAP_KEYMGMT_CCKM;
3946 return G_SUPPLICANT_EAP_KEYMGMT_NONE;
3950 static void ssid_init(GSupplicantSSID *ssid, struct connman_network *network)
3952 struct wifi_network *network_data = connman_network_get_data(network);
3953 const char *security;
3954 #if defined TIZEN_EXT
3955 const void *ssid_data;
3958 memset(ssid, 0, sizeof(*ssid));
3959 ssid->mode = G_SUPPLICANT_MODE_INFRA;
3960 #if defined TIZEN_EXT
3961 ssid_data = connman_network_get_blob(network, "WiFi.SSID",
3963 ssid->ssid = g_try_malloc0(ssid->ssid_len);
3968 memcpy(ssid->ssid, ssid_data, ssid->ssid_len);
3970 ssid->ssid = connman_network_get_blob(network, "WiFi.SSID",
3973 ssid->scan_ssid = 1;
3974 security = connman_network_get_string(network, "WiFi.Security");
3975 #if defined TIZEN_EXT
3976 if (connman_network_get_psk_sha256(network))
3977 security = "psk_sha256";
3979 ssid->security = network_security(security);
3981 ssid->keymgmt = network_data->keymgmt;
3982 ssid->ieee80211w = G_SUPPLICANT_MFP_OPTIONAL;
3983 ssid->passphrase = connman_network_get_string(network,
3986 ssid->eap = connman_network_get_string(network, "WiFi.EAP");
3989 * If our private key password is unset,
3990 * we use the supplied passphrase. That is needed
3991 * for PEAP where 2 passphrases (identity and client
3992 * cert may have to be provided.
3994 if (!connman_network_get_string(network, "WiFi.PrivateKeyPassphrase"))
3995 connman_network_set_string(network,
3996 "WiFi.PrivateKeyPassphrase",
3998 /* We must have an identity for both PEAP and TLS */
3999 ssid->identity = connman_network_get_string(network, "WiFi.Identity");
4001 /* Use agent provided identity as a fallback */
4002 if (!ssid->identity || strlen(ssid->identity) == 0)
4003 ssid->identity = connman_network_get_string(network,
4004 "WiFi.AgentIdentity");
4006 ssid->anonymous_identity = connman_network_get_string(network,
4007 "WiFi.AnonymousIdentity");
4008 ssid->ca_cert_path = connman_network_get_string(network,
4010 ssid->subject_match = connman_network_get_string(network,
4011 "WiFi.SubjectMatch");
4012 ssid->altsubject_match = connman_network_get_string(network,
4013 "WiFi.AltSubjectMatch");
4014 ssid->domain_suffix_match = connman_network_get_string(network,
4015 "WiFi.DomainSuffixMatch");
4016 ssid->domain_match = connman_network_get_string(network,
4017 "WiFi.DomainMatch");
4018 ssid->client_cert_path = connman_network_get_string(network,
4019 "WiFi.ClientCertFile");
4020 ssid->private_key_path = connman_network_get_string(network,
4021 "WiFi.PrivateKeyFile");
4022 ssid->private_key_passphrase = connman_network_get_string(network,
4023 "WiFi.PrivateKeyPassphrase");
4024 ssid->phase2_auth = connman_network_get_string(network, "WiFi.Phase2");
4026 ssid->use_wps = connman_network_get_bool(network, "WiFi.UseWPS");
4027 ssid->pin_wps = connman_network_get_string(network, "WiFi.PinWPS");
4028 #if defined TIZEN_EXT
4029 ssid->connector = connman_network_get_string(network,
4031 ssid->c_sign_key = connman_network_get_string(network,
4033 ssid->net_access_key = connman_network_get_string(network,
4034 "WiFi.NetAccessKey");
4037 #if defined TIZEN_EXT
4038 const char *ifname = connman_device_get_string(
4039 connman_network_get_device(network), "Interface");
4040 if (set_connman_bssid(CHECK_BSSID, NULL, ifname) == 6) {
4041 ssid->bssid_for_connect_len = 6;
4042 set_connman_bssid(GET_BSSID, (char *)ssid->bssid_for_connect, ifname);
4043 DBG("BSSID : %02x:%02x:%02x:%02x:%02x:%02x",
4044 ssid->bssid_for_connect[0], ssid->bssid_for_connect[1],
4045 ssid->bssid_for_connect[2], ssid->bssid_for_connect[3],
4046 ssid->bssid_for_connect[4], ssid->bssid_for_connect[5]);
4048 ssid->freq = connman_network_get_frequency(network);
4051 GSList *bssid_list = (GSList *)connman_network_get_bssid_list(network);
4052 if (bssid_list && g_slist_length(bssid_list) > 1) {
4054 /* If there are more than one bssid,
4055 * the user-specified bssid is tried only once at the beginning.
4056 * After that, the bssids in the list are tried in order.
4058 if (set_connman_bssid(CHECK_BSSID, NULL, ifname) == 6) {
4059 set_connman_bssid(RESET_BSSID, NULL, ifname);
4064 char buff[WIFI_BSSID_STR_LEN];
4065 const char *dst_bssid = connman_network_get_string(network,
4066 "WiFi.RoamingDstBSSID");
4067 for (list = bssid_list; list; list = list->next) {
4068 struct connman_bssids * bssids = (struct connman_bssids *)list->data;
4070 g_snprintf(buff, WIFI_BSSID_STR_LEN, MACSTR, MAC2STR(bssids->bssid));
4071 buff[WIFI_BSSID_STR_LEN - 1] = '\0';
4074 if (g_strcmp0(dst_bssid, (const gchar *)buff) == 0) {
4075 memcpy(buff_bssid, bssids->bssid, WIFI_BSSID_LEN_MAX);
4076 ssid->bssid = buff_bssid;
4077 ssid->freq = (unsigned int)bssids->frequency;
4083 gchar *curr_bssid = g_strdup((const gchar *)buff);
4085 if (g_hash_table_contains(failed_bssids, curr_bssid)) {
4086 DBG("bssid match, try next bssid");
4090 g_hash_table_add(failed_bssids, curr_bssid);
4092 memcpy(buff_bssid, bssids->bssid, WIFI_BSSID_LEN_MAX);
4093 ssid->bssid = buff_bssid;
4094 ssid->freq = (unsigned int)bssids->frequency;
4100 connman_network_set_string(network, "WiFi.RoamingDstBSSID", NULL);
4103 ssid->bssid = connman_network_get_bssid(network);
4104 g_hash_table_remove_all(failed_bssids);
4107 ssid->bssid = connman_network_get_bssid(network);
4110 ssid->eap_keymgmt = network_eap_keymgmt(
4111 connman_network_get_string(network, "WiFi.KeymgmtType"));
4112 ssid->phase1 = connman_network_get_string(network, "WiFi.Phase1");
4114 if (g_strcmp0(ssid->eap, "fast") == 0)
4115 ssid->pac_file = g_strdup(WIFI_EAP_FAST_PAC_FILE);
4117 ssid->keymgmt = connman_network_get_keymgmt(network);
4120 if (connman_setting_get_bool("BackgroundScanning"))
4121 ssid->bgscan = BGSCAN_DEFAULT;
4124 static int network_connect(struct connman_network *network)
4126 struct connman_device *device = connman_network_get_device(network);
4127 struct wifi_data *wifi;
4128 GSupplicantInterface *interface;
4129 GSupplicantSSID *ssid;
4131 DBG("network %p", network);
4136 wifi = connman_device_get_data(device);
4140 ssid = g_try_malloc0(sizeof(GSupplicantSSID));
4144 interface = wifi->interface;
4146 ssid_init(ssid, network);
4148 if (wifi->disconnecting) {
4149 wifi->pending_network = network;
4150 #if defined TIZEN_EXT
4155 wifi->network = connman_network_ref(network);
4157 #if defined TIZEN_EXT
4158 wifi->scan_pending_network = NULL;
4161 return g_supplicant_interface_connect(interface, ssid,
4162 connect_callback, network);
4165 return -EINPROGRESS;
4168 static void disconnect_callback(int result, GSupplicantInterface *interface,
4171 struct disconnect_data *dd = user_data;
4172 struct connman_network *network = dd->network;
4173 #if defined TIZEN_EXT
4175 struct wifi_data *wifi = NULL;
4178 DBG("network %p result %d", network, result);
4180 for (list = iface_list; list; list = list->next) {
4186 if (wifi->network == NULL && wifi->disconnecting == true)
4187 wifi->disconnecting = false;
4189 if (wifi->network == network)
4193 if (wifi && network == wifi->pending_network)
4194 wifi->pending_network = NULL;
4196 /* wifi_data may be invalid because wifi is already disabled */
4201 struct wifi_data *wifi = dd->wifi;
4205 DBG("result %d supplicant interface %p wifi %p networks: current %p "
4206 "pending %p disconnected %p", result, interface, wifi,
4207 wifi->network, wifi->pending_network, network);
4209 if (result == -ECONNABORTED) {
4210 DBG("wifi interface no longer available");
4214 #if defined TIZEN_EXT
4215 if (g_slist_find(wifi->networks, network) &&
4216 wifi->network != wifi->pending_network)
4218 if (g_slist_find(wifi->networks, network))
4220 connman_network_set_connected(network, false);
4222 wifi->disconnecting = false;
4224 if (network != wifi->network) {
4225 if (network == wifi->pending_network)
4226 wifi->pending_network = NULL;
4227 DBG("current wifi network has changed since disconnection");
4231 wifi->network = NULL;
4233 wifi->connected = false;
4235 if (wifi->pending_network) {
4236 network_connect(wifi->pending_network);
4237 wifi->pending_network = NULL;
4240 start_autoscan(wifi->device);
4243 static int network_disconnect(struct connman_network *network)
4245 struct connman_device *device = connman_network_get_device(network);
4246 struct disconnect_data *dd;
4247 struct wifi_data *wifi;
4249 #if defined TIZEN_EXT
4250 struct connman_service *service;
4253 DBG("network %p", network);
4255 wifi = connman_device_get_data(device);
4256 if (!wifi || !wifi->interface)
4259 #if defined TIZEN_EXT
4260 if (connman_network_get_associating(network) == true) {
4261 connman_network_clear_associating(network);
4262 connman_network_set_bool(network, "WiFi.UseWPS", false);
4264 service = connman_service_lookup_from_network(network);
4266 if (service != NULL &&
4267 (__connman_service_is_connected_state(service,
4268 CONNMAN_IPCONFIG_TYPE_IPV4) == false &&
4269 __connman_service_is_connected_state(service,
4270 CONNMAN_IPCONFIG_TYPE_IPV6) == false) &&
4271 (connman_service_get_favorite(service) == false))
4272 __connman_service_set_passphrase(service, NULL);
4275 if (wifi->pending_network == network)
4276 wifi->pending_network = NULL;
4278 if (wifi->scan_pending_network == network)
4279 wifi->scan_pending_network = NULL;
4282 connman_network_set_associating(network, false);
4284 if (wifi->disconnecting)
4287 wifi->disconnecting = true;
4289 dd = g_malloc0(sizeof(*dd));
4291 dd->network = network;
4293 #if defined TIZEN_EXT
4294 err = g_supplicant_interface_disconnect(wifi->interface,
4295 disconnect_callback, dd, network);
4297 err = g_supplicant_interface_disconnect(wifi->interface,
4298 disconnect_callback, dd);
4302 wifi->disconnecting = false;
4309 #if defined TIZEN_EXT
4310 static void set_connection_mode(struct connman_network *network,
4313 ieee80211_modes_e phy_mode;
4314 connection_mode_e conn_mode;
4316 phy_mode = connman_network_get_phy_mode(network);
4318 case IEEE80211_MODE_B:
4319 if (linkspeed > 0 && linkspeed <= 11)
4320 conn_mode = CONNECTION_MODE_IEEE80211B;
4322 conn_mode = CONNECTION_MODE_IEEE80211_UNKNOWN;
4325 case IEEE80211_MODE_BG:
4326 if (linkspeed > 0 && linkspeed <= 11)
4327 conn_mode = CONNECTION_MODE_IEEE80211B;
4328 else if (linkspeed > 11 && linkspeed <= 54)
4329 conn_mode = CONNECTION_MODE_IEEE80211G;
4331 conn_mode = CONNECTION_MODE_IEEE80211_UNKNOWN;
4334 case IEEE80211_MODE_BGN:
4335 if (linkspeed > 0 && linkspeed <= 11)
4336 conn_mode = CONNECTION_MODE_IEEE80211B;
4337 else if (linkspeed > 11 && linkspeed <= 54)
4338 conn_mode = CONNECTION_MODE_IEEE80211G;
4339 else if (linkspeed > 54 && linkspeed <= 450)
4340 conn_mode = CONNECTION_MODE_IEEE80211N;
4342 conn_mode = CONNECTION_MODE_IEEE80211_UNKNOWN;
4345 case IEEE80211_MODE_A:
4346 if (linkspeed > 0 && linkspeed <= 54)
4347 conn_mode = CONNECTION_MODE_IEEE80211A;
4349 conn_mode = CONNECTION_MODE_IEEE80211_UNKNOWN;
4352 case IEEE80211_MODE_AN:
4353 if (linkspeed > 0 && linkspeed <= 54)
4354 conn_mode = CONNECTION_MODE_IEEE80211A;
4355 else if (linkspeed > 54 && linkspeed <= 450)
4356 conn_mode = CONNECTION_MODE_IEEE80211N;
4358 conn_mode = CONNECTION_MODE_IEEE80211_UNKNOWN;
4361 case IEEE80211_MODE_ANAC:
4362 if (linkspeed > 0 && linkspeed <= 54)
4363 conn_mode = CONNECTION_MODE_IEEE80211A;
4364 else if (linkspeed > 54 && linkspeed <= 450)
4365 conn_mode = CONNECTION_MODE_IEEE80211N;
4366 else if (linkspeed > 450 && linkspeed <= 1300)
4367 conn_mode = CONNECTION_MODE_IEEE80211AC;
4369 conn_mode = CONNECTION_MODE_IEEE80211_UNKNOWN;
4373 conn_mode = CONNECTION_MODE_IEEE80211_UNKNOWN;
4377 DBG("connection mode(%d)", conn_mode);
4378 connman_network_set_connection_mode(network, conn_mode);
4381 static void signalpoll_callback(int result, int maxspeed, int strength,
4382 int snr, void *user_data, unsigned int est_throughput)
4384 char bssid_buff[WIFI_BSSID_STR_LEN] = {0,};
4385 char *bssid_str = bssid_buff;
4386 unsigned char *bssid;
4387 struct timespec curr_time = {0};
4388 __time_t roam_scan_time;
4389 const char *interface = NULL;
4390 struct connman_device *device;
4391 struct connman_network *network = user_data;
4392 GSupplicantNetwork *supplicant_network;
4393 struct wifi_data *wifi = NULL;
4394 uint16_t freq = connman_network_get_frequency(network);
4395 const char *group = connman_network_get_group(network);
4398 DBG("Failed to get maxspeed from signalpoll !");
4399 connman_network_unref(network);
4403 device = connman_network_get_device(network);
4405 wifi = connman_device_get_data(device);
4407 if (group && wifi) {
4408 supplicant_network = g_supplicant_interface_get_network(wifi->interface, group);
4409 if (supplicant_network) {
4410 g_supplicant_network_set_signal(supplicant_network, strength);
4411 g_supplicant_network_set_bss_signal(supplicant_network, strength, snr);
4419 bssid = connman_network_get_bssid(network);
4420 snprintf(bssid_str, WIFI_BSSID_STR_LEN, MACSTR, MAC2STR(bssid));
4422 DBG("network %p, bssid %s, freq %u, maxspeed %d, strength %d, snr %d, est_throughput %u",
4423 network, bssid_str, freq, maxspeed, strength, snr, est_throughput);
4425 connman_network_set_strength(network, (uint8_t)strength);
4426 connman_network_set_snr(network, snr);
4427 connman_network_set_est_throughput(network, est_throughput);
4428 connman_network_set_maxspeed(network, maxspeed);
4429 set_connection_mode(network, maxspeed);
4431 if (connman_network_get_max_bssid_count(network) <= 1)
4434 clock_gettime(CLOCK_MONOTONIC, &curr_time);
4435 roam_scan_time = connman_network_get_roam_scan_time(network);
4436 if (curr_time.tv_sec <= roam_scan_time + ROAM_SCAN_INTERVAL)
4439 if (device && need_bss_transition(freq, snr, strength)) {
4441 interface = connman_device_get_string(device, "Interface");
4442 __connman_technology_notify_roaming_state(interface, "required", bssid_str, NULL);
4444 if (connman_setting_get_bool("WifiRoamingScan") == false)
4447 throw_wifi_scan(device, scan_callback);
4448 connman_network_set_roam_scan_time(network, curr_time.tv_sec);
4452 connman_network_unref(network);
4455 static int network_signalpoll(struct wifi_data *wifi)
4457 GSupplicantInterface *interface;
4458 struct connman_network *network;
4460 if (!wifi || !wifi->network)
4463 wifi->network = connman_network_ref(wifi->network);
4465 interface = wifi->interface;
4466 network = wifi->network;
4468 DBG("network %p", network);
4470 return g_supplicant_interface_signalpoll(interface, signalpoll_callback, network);
4473 static gboolean autosignalpoll_timeout(gpointer data)
4475 struct wifi_data *wifi = data;
4477 if (!wifi || !wifi->automaxspeed_timeout) {
4478 DBG("automaxspeed_timeout is found to be zero. i.e. currently in disconnected state. !!");
4482 int ret = network_signalpoll(wifi);
4484 DBG("Fail to get max speed !!");
4485 wifi->automaxspeed_timeout = 0;
4488 connman_network_unref(wifi->network);
4497 static struct connman_network_driver network_driver = {
4499 .type = CONNMAN_NETWORK_TYPE_WIFI,
4500 .priority = CONNMAN_NETWORK_PRIORITY_LOW,
4501 .probe = network_probe,
4502 .remove = network_remove,
4503 .connect = network_connect,
4504 .disconnect = network_disconnect,
4507 static void interface_added(GSupplicantInterface *interface)
4509 const char *ifname = g_supplicant_interface_get_ifname(interface);
4510 const char *driver = g_supplicant_interface_get_driver(interface);
4511 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
4513 * Note: If supplicant interface's driver is wired then skip it,
4514 * because it meanti only for ethernet not Wi-Fi.
4516 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
4518 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
4520 #if defined TIZEN_EXT
4521 bool is_5_0_ghz_supported = g_supplicant_interface_get_is_5_0_ghz_supported(interface);
4522 bool is_6_0_ghz_supported = g_supplicant_interface_get_is_6_0_ghz_supported(interface);
4525 struct wifi_data *wifi;
4527 wifi = g_supplicant_interface_get_data(interface);
4529 wifi = get_pending_wifi_data(ifname);
4533 wifi->interface = interface;
4534 g_supplicant_interface_set_data(interface, wifi);
4535 p2p_iface_list = g_list_append(p2p_iface_list, wifi);
4536 wifi->p2p_device = true;
4539 DBG("ifname %s driver %s wifi %p tethering %d",
4540 ifname, driver, wifi, wifi->tethering);
4542 if (!wifi->device) {
4543 connman_error("WiFi device not set");
4547 connman_device_set_powered(wifi->device, true);
4548 #if defined TIZEN_EXT
4549 connman_device_set_wifi_5ghz_supported(wifi->device, is_5_0_ghz_supported);
4550 connman_device_set_wifi_6ghz_supported(wifi->device, is_6_0_ghz_supported);
4551 /* Max number of SSIDs supported by wlan chipset that can be scanned */
4552 int max_scan_ssids = g_supplicant_interface_get_max_scan_ssids(interface);
4553 connman_device_set_max_scan_ssids(wifi->device, max_scan_ssids);
4557 static bool is_idle(struct wifi_data *wifi)
4559 DBG("state %d", wifi->state);
4561 switch (wifi->state) {
4562 case G_SUPPLICANT_STATE_UNKNOWN:
4563 case G_SUPPLICANT_STATE_DISABLED:
4564 case G_SUPPLICANT_STATE_DISCONNECTED:
4565 case G_SUPPLICANT_STATE_INACTIVE:
4566 case G_SUPPLICANT_STATE_SCANNING:
4569 case G_SUPPLICANT_STATE_AUTHENTICATING:
4570 case G_SUPPLICANT_STATE_ASSOCIATING:
4571 case G_SUPPLICANT_STATE_ASSOCIATED:
4572 case G_SUPPLICANT_STATE_4WAY_HANDSHAKE:
4573 case G_SUPPLICANT_STATE_GROUP_HANDSHAKE:
4574 case G_SUPPLICANT_STATE_COMPLETED:
4581 static bool is_idle_wps(GSupplicantInterface *interface,
4582 struct wifi_data *wifi)
4584 /* First, let's check if WPS processing did not went wrong */
4585 if (g_supplicant_interface_get_wps_state(interface) ==
4586 G_SUPPLICANT_WPS_STATE_FAIL)
4589 /* Unlike normal connection, being associated while processing wps
4590 * actually means that we are idling. */
4591 switch (wifi->state) {
4592 case G_SUPPLICANT_STATE_UNKNOWN:
4593 case G_SUPPLICANT_STATE_DISABLED:
4594 case G_SUPPLICANT_STATE_DISCONNECTED:
4595 case G_SUPPLICANT_STATE_INACTIVE:
4596 case G_SUPPLICANT_STATE_SCANNING:
4597 case G_SUPPLICANT_STATE_ASSOCIATED:
4599 case G_SUPPLICANT_STATE_AUTHENTICATING:
4600 case G_SUPPLICANT_STATE_ASSOCIATING:
4601 case G_SUPPLICANT_STATE_4WAY_HANDSHAKE:
4602 case G_SUPPLICANT_STATE_GROUP_HANDSHAKE:
4603 case G_SUPPLICANT_STATE_COMPLETED:
4610 static bool handle_wps_completion(GSupplicantInterface *interface,
4611 struct connman_network *network,
4612 struct connman_device *device,
4613 struct wifi_data *wifi)
4617 wps = connman_network_get_bool(network, "WiFi.UseWPS");
4619 const unsigned char *ssid, *wps_ssid;
4620 unsigned int ssid_len, wps_ssid_len;
4621 struct disconnect_data *dd;
4622 const char *wps_key;
4624 /* Checking if we got associated with requested
4626 ssid = connman_network_get_blob(network, "WiFi.SSID",
4629 wps_ssid = g_supplicant_interface_get_wps_ssid(
4630 interface, &wps_ssid_len);
4632 if (!wps_ssid || wps_ssid_len != ssid_len ||
4633 memcmp(ssid, wps_ssid, ssid_len) != 0) {
4634 dd = g_malloc0(sizeof(*dd));
4636 dd->network = network;
4638 connman_network_set_associating(network, false);
4639 #if defined TIZEN_EXT
4640 g_supplicant_interface_disconnect(wifi->interface,
4641 disconnect_callback, dd, network);
4643 g_supplicant_interface_disconnect(wifi->interface,
4644 disconnect_callback, dd);
4646 #if defined TIZEN_EXT
4647 connman_network_set_bool(network, "WiFi.UseWPS", false);
4648 connman_network_set_string(network, "WiFi.PinWPS", NULL);
4653 wps_key = g_supplicant_interface_get_wps_key(interface);
4654 #if defined TIZEN_EXT
4655 /* Check the passphrase and encrypt it
4658 gchar *passphrase = g_strdup(wps_key);
4660 connman_network_set_string(network, "WiFi.PinWPS", NULL);
4662 if (check_passphrase_ext(network, passphrase) < 0) {
4663 DBG("[WPS] Invalid passphrase");
4668 ret = send_encryption_request(passphrase, network);
4673 DBG("[WPS] Encryption request succeeded");
4675 DBG("[WPS] Encryption request failed %d", ret);
4678 connman_network_set_string(network, "WiFi.Passphrase",
4681 connman_network_set_string(network, "WiFi.PinWPS", NULL);
4688 static bool handle_assoc_status_code(GSupplicantInterface *interface,
4689 struct wifi_data *wifi)
4691 #if defined TIZEN_EXT
4692 if ((wifi->state == G_SUPPLICANT_STATE_ASSOCIATING ||
4693 wifi->state == G_SUPPLICANT_STATE_AUTHENTICATING ||
4694 wifi->state == G_SUPPLICANT_STATE_ASSOCIATED) &&
4696 if (wifi->state == G_SUPPLICANT_STATE_ASSOCIATING &&
4697 wifi->assoc_code == ASSOC_STATUS_NO_CLIENT &&
4699 wifi->load_shaping_retries < LOAD_SHAPING_MAX_RETRIES) {
4700 wifi->load_shaping_retries ++;
4703 wifi->load_shaping_retries = 0;
4707 static bool handle_4way_handshake_failure(GSupplicantInterface *interface,
4708 struct connman_network *network,
4709 struct wifi_data *wifi)
4711 struct connman_service *service;
4713 #if defined TIZEN_EXT
4714 const char *security;
4715 if (wifi->connected)
4718 security = connman_network_get_string(network, "WiFi.Security");
4720 if (security && g_str_equal(security, "ieee8021x") == true &&
4721 wifi->state == G_SUPPLICANT_STATE_ASSOCIATED) {
4723 connman_network_set_error(network, CONNMAN_NETWORK_ERROR_INVALID_KEY);
4728 if (wifi->state != G_SUPPLICANT_STATE_4WAY_HANDSHAKE)
4731 if ((wifi->state != G_SUPPLICANT_STATE_4WAY_HANDSHAKE) &&
4732 !((wifi->state == G_SUPPLICANT_STATE_ASSOCIATING) &&
4733 (wifi->assoc_code == ASSOC_STATUS_AUTH_TIMEOUT)))
4736 if (wifi->connected)
4740 service = connman_service_lookup_from_network(network);
4746 if (connman_service_get_favorite(service)) {
4747 if (wifi->retries < FAVORITE_MAXIMUM_RETRIES)
4752 connman_network_set_error(network, CONNMAN_NETWORK_ERROR_INVALID_KEY);
4757 #if defined TIZEN_EXT
4758 static bool handle_wifi_assoc_retry(struct connman_network *network,
4759 struct wifi_data *wifi)
4761 const char *security;
4763 if (!wifi->network || wifi->connected || wifi->disconnecting ||
4764 connman_network_get_connecting(network) != true) {
4765 wifi->assoc_retry_count = 0;
4769 if (wifi->state != G_SUPPLICANT_STATE_AUTHENTICATING &&
4770 wifi->state != G_SUPPLICANT_STATE_ASSOCIATING &&
4771 wifi->state != G_SUPPLICANT_STATE_ASSOCIATED) {
4772 wifi->assoc_retry_count = 0;
4776 security = connman_network_get_string(network, "WiFi.Security");
4777 if (security && g_str_equal(security, "ieee8021x") == true &&
4778 wifi->state == G_SUPPLICANT_STATE_ASSOCIATED) {
4779 wifi->assoc_retry_count = 0;
4783 if (wifi->state > assoc_last_state)
4784 assoc_last_state = wifi->state;
4786 if (++wifi->assoc_retry_count >= TIZEN_ASSOC_RETRY_COUNT) {
4787 wifi->assoc_retry_count = 0;
4789 /* Honestly it's not an invalid-key error,
4790 * however QA team recommends that the invalid-key error
4791 * might be better to display for user experience.
4793 switch (assoc_last_state) {
4794 case G_SUPPLICANT_STATE_AUTHENTICATING:
4795 connman_network_set_error(network, CONNMAN_NETWORK_ERROR_AUTHENTICATE_FAIL);
4797 case G_SUPPLICANT_STATE_ASSOCIATED:
4798 connman_network_set_error(network, CONNMAN_NETWORK_ERROR_INVALID_KEY);
4801 connman_network_set_error(network, CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
4811 static void handle_wifi_roaming_complete(struct connman_network *network)
4813 const char *cur_bssid;
4814 const char *dst_bssid;
4816 struct connman_device *device;
4817 struct connman_service *service;
4818 struct connman_ipconfig *ipconfig_ipv4;
4819 enum connman_ipconfig_type type;
4820 enum connman_ipconfig_method method;
4822 if (!connman_setting_get_bool("WifiRoaming") ||
4823 !connman_network_get_bool(network, "WiFi.Roaming"))
4826 device = connman_network_get_device(network);
4828 ifname = connman_device_get_string(device, "Interface");
4829 cur_bssid = connman_network_get_string(network,
4830 "WiFi.RoamingCurBSSID");
4831 dst_bssid = connman_network_get_string(network,
4832 "WiFi.RoamingDstBSSID");
4835 if (device && ifname && cur_bssid && dst_bssid) {
4836 __connman_technology_notify_roaming_state(ifname,
4837 "success", cur_bssid, dst_bssid);
4838 connman_network_set_bool(network,
4839 "WiFi.Roaming", false);
4840 connman_network_set_string(network,
4841 "WiFi.RoamingCurBSSID", NULL);
4842 connman_network_set_string(network,
4843 "WiFi.RoamingDstBSSID", NULL);
4845 service = connman_service_lookup_from_network(network);
4849 ipconfig_ipv4 = __connman_service_get_ip4config(service);
4850 if (!ipconfig_ipv4) {
4851 connman_error("Service has no IPv4 configuration");
4855 type = __connman_ipconfig_get_config_type(ipconfig_ipv4);
4856 if (type != CONNMAN_IPCONFIG_TYPE_IPV4)
4859 method = __connman_ipconfig_get_method(ipconfig_ipv4);
4860 if (method != CONNMAN_IPCONFIG_METHOD_DHCP)
4863 connman_network_set_bool(network, "WiFi.RoamingDHCP", true);
4865 if (set_connected_dhcp(network) != 0)
4866 connman_network_set_bool(network, "WiFi.RoamingDHCP", false);
4871 static void interface_state(GSupplicantInterface *interface)
4873 struct connman_network *network;
4874 struct connman_device *device;
4875 struct wifi_data *wifi;
4876 GSupplicantState state = g_supplicant_interface_get_state(interface);
4877 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
4879 * Note: If supplicant interface's driver is wired then skip it,
4880 * because it meanti only for ethernet not Wi-Fi.
4882 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
4884 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
4889 wifi = g_supplicant_interface_get_data(interface);
4891 DBG("wifi %p interface state %d", wifi, state);
4896 device = wifi->device;
4900 if (state == G_SUPPLICANT_STATE_COMPLETED) {
4901 if (wifi->tethering_param) {
4902 g_free(wifi->tethering_param->ssid);
4903 g_free(wifi->tethering_param);
4904 wifi->tethering_param = NULL;
4907 if (wifi->tethering)
4908 stop_autoscan(device);
4911 if (g_supplicant_interface_get_ready(interface) &&
4912 !wifi->interface_ready) {
4913 wifi->interface_ready = true;
4914 finalize_interface_creation(wifi);
4917 network = wifi->network;
4922 case G_SUPPLICANT_STATE_SCANNING:
4923 #if defined TIZEN_EXT
4924 if (wifi->automaxspeed_timeout != 0) {
4925 g_source_remove(wifi->automaxspeed_timeout);
4926 wifi->automaxspeed_timeout = 0;
4927 DBG("Remove signalpoll timer!!");
4930 if (!connman_network_get_bool(wifi->network, "WiFi.Roaming"))
4932 if (wifi->connected)
4933 connman_network_set_connected(network, false);
4937 case G_SUPPLICANT_STATE_AUTHENTICATING:
4938 case G_SUPPLICANT_STATE_ASSOCIATING:
4939 #if defined TIZEN_EXT
4940 reset_autoscan(device);
4942 stop_autoscan(device);
4944 #if defined TIZEN_EXT
4945 if (!connman_network_get_bool(wifi->network, "WiFi.Roaming"))
4947 if (!wifi->connected)
4948 connman_network_set_associating(network, true);
4952 case G_SUPPLICANT_STATE_COMPLETED:
4953 #if defined TIZEN_EXT
4954 /* though it should be already reset: */
4955 reset_autoscan(device);
4957 wifi->assoc_retry_count = 0;
4959 wifi->scan_pending_network = NULL;
4961 /* should be cleared scanning flag */
4962 bool scanning = connman_device_get_scanning(device,
4963 CONNMAN_SERVICE_TYPE_WIFI);
4965 connman_device_set_scanning(device,
4966 CONNMAN_SERVICE_TYPE_WIFI, false);
4967 connman_device_unref(device);
4970 if (!wifi->automaxspeed_timeout) {
4971 DBG("Going to start signalpoll timer!!");
4972 int ret = network_signalpoll(wifi);
4974 DBG("Fail to get max speed !!");
4976 wifi->automaxspeed_timeout = g_timeout_add_seconds(10, autosignalpoll_timeout, wifi);
4979 g_hash_table_remove_all(failed_bssids);
4980 handle_wifi_roaming_complete(network);
4982 /* though it should be already stopped: */
4983 stop_autoscan(device);
4986 if (!handle_wps_completion(interface, network, device, wifi))
4989 connman_network_set_connected(network, true);
4991 wifi->disconnect_code = 0;
4992 wifi->assoc_code = 0;
4993 wifi->load_shaping_retries = 0;
4996 case G_SUPPLICANT_STATE_DISCONNECTED:
4997 #if defined TIZEN_EXT
4998 connman_network_set_strength(network, 0);
4999 connman_network_set_maxspeed(network, 0);
5001 if (wifi->automaxspeed_timeout != 0) {
5002 g_source_remove(wifi->automaxspeed_timeout);
5003 wifi->automaxspeed_timeout = 0;
5004 DBG("Remove signalpoll timer!!");
5008 * If we're in one of the idle modes, we have
5009 * not started association yet and thus setting
5010 * those ones to FALSE could cancel an association
5013 wps = connman_network_get_bool(network, "WiFi.UseWPS");
5015 if (is_idle_wps(interface, wifi))
5021 #if defined TIZEN_EXT
5022 if (!wifi->connected && !wifi->disconnecting &&
5023 handle_assoc_status_code(interface, wifi)) {
5024 GSList *bssid_list = NULL;
5025 guint bssid_length = 0;
5027 if (TIZEN_INS_ENABLED) {
5028 const char *group = connman_network_get_group(network);
5029 GSupplicantNetwork *supplicant_network;
5032 supplicant_network = g_supplicant_interface_get_network(interface, group);
5034 connman_network_set_assoc_reject_table(network,
5035 g_supplicant_network_clone_assoc_reject_table(supplicant_network));
5037 g_supplicant_network_update_assoc_reject(interface, supplicant_network);
5041 bssid_list = (GSList *)connman_network_get_bssid_list(network);
5043 bssid_length = g_slist_length(bssid_list);
5045 if (bssid_length > 1 && bssid_length > g_hash_table_size(failed_bssids)) {
5046 network_connect(network);
5050 wifi->load_shaping_retries = 0;
5053 if (handle_assoc_status_code(interface, wifi))
5057 /* If previous state was 4way-handshake, then
5058 * it's either: psk was incorrect and thus we retry
5059 * or if we reach the maximum retries we declare the
5061 if (handle_4way_handshake_failure(interface,
5065 /* See table 8-36 Reason codes in IEEE Std 802.11 */
5066 switch (wifi->disconnect_code) {
5067 #if defined TIZEN_EXT
5068 case 1: /* Unspecified reason */
5069 /* Let's assume it's because we got blocked */
5071 case 6: /* Class 2 frame received from nonauthenticated STA */
5072 connman_network_set_error(network,
5073 CONNMAN_NETWORK_ERROR_BLOCKED);
5080 #if defined TIZEN_EXT
5081 if (wifi->assoc_retry_count == 0)
5082 assoc_last_state = G_SUPPLICANT_STATE_UNKNOWN;
5084 /* Some of Wi-Fi networks are not comply Wi-Fi specification.
5085 * Retry association until its retry count is expired */
5086 if (handle_wifi_assoc_retry(network, wifi) == true) {
5087 throw_wifi_scan(wifi->device, scan_callback);
5088 wifi->scan_pending_network = wifi->network;
5092 if (wifi->disconnect_code > 0){
5093 DBG("Set disconnect reason code(%d)", wifi->disconnect_code);
5094 connman_network_set_disconnect_reason(network, wifi->disconnect_code);
5098 if (network != wifi->pending_network) {
5099 connman_network_set_connected(network, false);
5100 connman_network_set_associating(network, false);
5102 wifi->disconnecting = false;
5104 start_autoscan(device);
5108 case G_SUPPLICANT_STATE_INACTIVE:
5109 #if defined TIZEN_EXT
5110 if (handle_wps_completion(interface, network, device, wifi) == false)
5113 connman_network_set_associating(network, false);
5114 start_autoscan(device);
5118 case G_SUPPLICANT_STATE_UNKNOWN:
5119 case G_SUPPLICANT_STATE_DISABLED:
5120 case G_SUPPLICANT_STATE_ASSOCIATED:
5121 case G_SUPPLICANT_STATE_4WAY_HANDSHAKE:
5122 case G_SUPPLICANT_STATE_GROUP_HANDSHAKE:
5126 old_connected = wifi->connected;
5127 wifi->state = state;
5129 /* Saving wpa_s state policy:
5130 * If connected and if the state changes are roaming related:
5131 * --> We stay connected
5133 * --> We are connected
5135 * --> We are not connected
5138 case G_SUPPLICANT_STATE_AUTHENTICATING:
5139 case G_SUPPLICANT_STATE_ASSOCIATING:
5140 case G_SUPPLICANT_STATE_ASSOCIATED:
5141 case G_SUPPLICANT_STATE_4WAY_HANDSHAKE:
5142 case G_SUPPLICANT_STATE_GROUP_HANDSHAKE:
5143 if (wifi->connected)
5144 connman_warn("Probably roaming right now!"
5145 " Staying connected...");
5147 case G_SUPPLICANT_STATE_SCANNING:
5148 wifi->connected = false;
5151 start_autoscan(device);
5153 case G_SUPPLICANT_STATE_COMPLETED:
5154 wifi->connected = true;
5157 wifi->connected = false;
5164 static void interface_removed(GSupplicantInterface *interface)
5166 const char *ifname = g_supplicant_interface_get_ifname(interface);
5167 struct wifi_data *wifi;
5168 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
5170 * Note: If supplicant interface's driver is wired then skip it,
5171 * because it meanti only for ethernet not Wi-Fi.
5173 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
5175 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
5178 DBG("ifname %s", ifname);
5180 wifi = g_supplicant_interface_get_data(interface);
5182 #if defined TIZEN_EXT_WIFI_MESH
5183 if (wifi && wifi->mesh_interface) {
5184 DBG("Notify mesh interface remove");
5185 connman_mesh_notify_interface_remove(true);
5186 struct wifi_mesh_info *mesh_info = wifi->mesh_info;
5187 g_free(mesh_info->parent_ifname);
5188 g_free(mesh_info->ifname);
5189 g_free(mesh_info->identifier);
5191 wifi->mesh_interface = false;
5192 wifi->mesh_info = NULL;
5198 wifi->interface = NULL;
5200 if (wifi && wifi->tethering)
5203 if (!wifi || !wifi->device) {
5204 DBG("wifi interface already removed");
5208 connman_device_set_powered(wifi->device, false);
5210 check_p2p_technology();
5211 #if defined TIZEN_EXT_WIFI_MESH
5212 check_mesh_technology();
5216 static void set_device_type(const char *type, char dev_type[17])
5218 const char *oui = "0050F204";
5219 const char *category = "0001";
5220 const char *sub_category = "0000";
5222 if (!g_strcmp0(type, "handset")) {
5224 sub_category = "0005";
5225 } else if (!g_strcmp0(type, "vm") || !g_strcmp0(type, "container"))
5226 sub_category = "0001";
5227 else if (!g_strcmp0(type, "server"))
5228 sub_category = "0002";
5229 else if (!g_strcmp0(type, "laptop"))
5230 sub_category = "0005";
5231 else if (!g_strcmp0(type, "desktop"))
5232 sub_category = "0006";
5233 else if (!g_strcmp0(type, "tablet"))
5234 sub_category = "0009";
5235 else if (!g_strcmp0(type, "watch"))
5238 snprintf(dev_type, 17, "%s%s%s", category, oui, sub_category);
5241 static void p2p_support(GSupplicantInterface *interface)
5243 char dev_type[17] = {};
5244 const char *hostname;
5245 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
5247 * Note: If supplicant interface's driver is wired then skip it,
5248 * because it meanti only for ethernet not Wi-Fi.
5250 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
5252 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
5260 if (!g_supplicant_interface_has_p2p(interface))
5263 if (connman_technology_driver_register(&p2p_tech_driver) < 0) {
5264 DBG("Could not register P2P technology driver");
5268 hostname = connman_utsname_get_hostname();
5270 hostname = "ConnMan";
5272 set_device_type(connman_machine_get_type(), dev_type);
5273 g_supplicant_interface_set_p2p_device_config(interface,
5274 hostname, dev_type);
5275 connman_peer_driver_register(&peer_driver);
5278 static void scan_started(GSupplicantInterface *interface)
5280 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
5282 * Note: If supplicant interface's driver is wired then skip it,
5283 * because it meanti only for ethernet not Wi-Fi.
5285 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
5287 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
5292 static void scan_finished(GSupplicantInterface *interface)
5294 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
5296 * Note: If supplicant interface's driver is wired then skip it,
5297 * because it meanti only for ethernet not Wi-Fi.
5299 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
5301 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
5303 #if defined TIZEN_EXT
5304 struct wifi_data *wifi;
5305 bool is_associating = false;
5306 static bool is_scanning = true;
5311 #if defined TIZEN_EXT
5312 wifi = g_supplicant_interface_get_data(interface);
5313 if (wifi && wifi->scan_pending_network) {
5314 network_connect(wifi->scan_pending_network);
5315 wifi->scan_pending_network = NULL;
5318 //service state - associating
5319 if(!wifi || !wifi->network)
5322 is_associating = connman_network_get_associating(wifi->network);
5323 if(is_associating && is_scanning){
5324 is_scanning = false;
5325 DBG("send scan for connecting");
5326 throw_wifi_scan(wifi->device, scan_callback);
5337 static void ap_create_fail(GSupplicantInterface *interface)
5339 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
5341 * Note: If supplicant interface's driver is wired then skip it,
5342 * because it meanti only for ethernet not Wi-Fi.
5344 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
5346 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
5348 struct wifi_data *wifi = g_supplicant_interface_get_data(interface);
5351 if ((wifi->tethering) && (wifi->tethering_param)) {
5352 DBG("%s create AP fail \n",
5353 g_supplicant_interface_get_ifname(wifi->interface));
5355 connman_inet_remove_from_bridge(wifi->index, wifi->bridge);
5356 wifi->ap_supported = WIFI_AP_NOT_SUPPORTED;
5357 wifi->tethering = false;
5359 ret = tech_set_tethering(wifi->tethering_param->technology,
5360 wifi->bridge, true);
5362 if ((ret == -EOPNOTSUPP) && (wifi_technology)) {
5363 connman_technology_tethering_notify(wifi_technology,false);
5366 g_free(wifi->tethering_param->ssid);
5367 g_free(wifi->tethering_param);
5368 wifi->tethering_param = NULL;
5372 static unsigned char calculate_strength(GSupplicantNetwork *supplicant_network)
5374 unsigned char strength;
5376 strength = 120 + g_supplicant_network_get_signal(supplicant_network);
5377 #if !defined TIZEN_EXT
5385 #if defined TIZEN_EXT_WIFI_MESH
5386 static void mesh_peer_added(GSupplicantNetwork *supplicant_network)
5388 GSupplicantInterface *interface;
5389 struct wifi_data *wifi;
5390 const char *name, *security;
5391 struct connman_mesh *connman_mesh;
5392 struct wifi_mesh_info *mesh_info;
5393 const unsigned char *bssid;
5394 const char *identifier;
5399 interface = g_supplicant_network_get_interface(supplicant_network);
5400 wifi = g_supplicant_interface_get_data(interface);
5401 if (!wifi || !wifi->mesh_interface) {
5402 DBG("Virtual Mesh interface not created");
5406 bssid = g_supplicant_network_get_bssid(supplicant_network);
5407 address = g_malloc0(19);
5408 snprintf(address, 19, "%02x:%02x:%02x:%02x:%02x:%02x", bssid[0], bssid[1],
5409 bssid[2], bssid[3], bssid[4], bssid[5]);
5411 identifier = g_supplicant_network_get_identifier(supplicant_network);
5412 name = g_supplicant_network_get_name(supplicant_network);
5413 security = g_supplicant_network_get_security(supplicant_network);
5414 frequency = g_supplicant_network_get_frequency(supplicant_network);
5416 mesh_info = wifi->mesh_info;
5417 connman_mesh = connman_mesh_get(mesh_info->identifier, identifier);
5421 DBG("Mesh Peer name %s identifier %s security %s added", name, identifier,
5423 connman_mesh = connman_mesh_create(mesh_info->identifier, identifier);
5424 connman_mesh_set_name(connman_mesh, name);
5425 connman_mesh_set_security(connman_mesh, security);
5426 connman_mesh_set_frequency(connman_mesh, frequency);
5427 connman_mesh_set_address(connman_mesh, address);
5428 connman_mesh_set_index(connman_mesh, mesh_info->index);
5429 connman_mesh_set_strength(connman_mesh,
5430 calculate_strength(supplicant_network));
5431 connman_mesh_set_peer_type(connman_mesh, CONNMAN_MESH_PEER_TYPE_DISCOVERED);
5433 ret = connman_mesh_register(connman_mesh);
5434 if (ret == -EALREADY)
5435 DBG("Mesh Peer is already registered");
5441 static void mesh_peer_removed(GSupplicantNetwork *supplicant_network)
5443 GSupplicantInterface *interface;
5444 struct wifi_data *wifi;
5445 struct connman_mesh *connman_mesh;
5446 struct wifi_mesh_info *mesh_info;
5447 const char *identifier;
5449 interface = g_supplicant_network_get_interface(supplicant_network);
5450 wifi = g_supplicant_interface_get_data(interface);
5451 if (!wifi || !wifi->mesh_interface) {
5452 DBG("Virtual Mesh interface not created");
5456 identifier = g_supplicant_network_get_identifier(supplicant_network);
5458 DBG("Failed to get Mesh Peer identifier");
5462 mesh_info = wifi->mesh_info;
5463 connman_mesh = connman_mesh_get(mesh_info->identifier, identifier);
5465 /* Do not unregister connected mesh peer */
5466 if (connman_mesh_peer_is_connected_state(connman_mesh)) {
5467 DBG("Mesh Peer %s is connected", identifier);
5470 DBG("Mesh Peer identifier %s removed", identifier);
5471 connman_mesh_unregister(connman_mesh);
5477 #if defined TIZEN_EXT
5478 static GSList *get_supported_security_list(unsigned int keymgmt,
5479 bool owe_transition_mode,
5480 GSupplicantNetwork *supplicant_network)
5482 GSList *sec_list = NULL;
5483 dbus_bool_t privacy = g_supplicant_network_get_privacy(supplicant_network);
5484 const char *enc_mode = g_supplicant_network_get_enc_mode(supplicant_network);
5487 (G_SUPPLICANT_KEYMGMT_WPA_EAP |
5488 G_SUPPLICANT_KEYMGMT_WPA_EAP_256))
5489 sec_list = g_slist_prepend (sec_list, "ieee8021x");
5490 else if (keymgmt & G_SUPPLICANT_KEYMGMT_WPA_FT_EAP)
5491 sec_list = g_slist_prepend (sec_list, "ft_ieee8021x");
5497 (G_SUPPLICANT_KEYMGMT_WPA_PSK |
5498 G_SUPPLICANT_KEYMGMT_WPA_PSK_256)) {
5499 if (!g_strcmp0(enc_mode, "aes"))
5500 sec_list = g_slist_prepend (sec_list, "rsn");
5501 else if (!g_strcmp0(enc_mode, "tkip"))
5502 sec_list = g_slist_prepend (sec_list, "psk");
5503 else if (!g_strcmp0(enc_mode, "mixed")) {
5504 sec_list = g_slist_prepend (sec_list, "psk");
5505 sec_list = g_slist_prepend (sec_list, "rsn");
5509 if (keymgmt & G_SUPPLICANT_KEYMGMT_WPA_FT_PSK)
5510 sec_list = g_slist_prepend (sec_list, "ft_psk");
5512 if (keymgmt & G_SUPPLICANT_KEYMGMT_SAE)
5513 sec_list = g_slist_prepend (sec_list, "sae");
5514 if (keymgmt & G_SUPPLICANT_KEYMGMT_FT_SAE)
5515 sec_list = g_slist_prepend (sec_list, "ft_sae");
5517 if (keymgmt & G_SUPPLICANT_KEYMGMT_OWE || owe_transition_mode)
5518 sec_list = g_slist_prepend (sec_list, "owe");
5519 if (keymgmt & G_SUPPLICANT_KEYMGMT_DPP)
5520 sec_list = g_slist_prepend (sec_list, "dpp");
5526 sec_list = g_slist_prepend (sec_list, "wep");
5528 sec_list = g_slist_prepend (sec_list, "none");
5534 static void network_added(GSupplicantNetwork *supplicant_network)
5536 struct connman_network *network;
5537 GSupplicantInterface *interface;
5538 struct wifi_data *wifi;
5539 struct wifi_network *network_data;
5540 const char *name, *identifier, *security, *group, *mode;
5541 const unsigned char *ssid;
5542 unsigned int ssid_len;
5546 bool wps_advertizing;
5548 #if defined TIZEN_EXT
5549 bool owe_transition_mode;
5550 const unsigned char *transition_mode_ssid;
5551 const unsigned char *transition_mode_bssid;
5552 unsigned int transition_mode_ssid_len;
5553 unsigned int keymgmt;
5554 GSList *vsie_list = NULL;
5555 GSList *sec_list = NULL;
5556 const unsigned char *country_code;
5557 ieee80211_modes_e phy_mode;
5560 mode = g_supplicant_network_get_mode(supplicant_network);
5561 identifier = g_supplicant_network_get_identifier(supplicant_network);
5562 #if defined TIZEN_EXT
5563 if (!simplified_log)
5565 DBG("%s", identifier);
5567 if (!g_strcmp0(mode, "adhoc"))
5570 #if defined TIZEN_EXT_WIFI_MESH
5571 if (!g_strcmp0(mode, "mesh")) {
5572 mesh_peer_added(supplicant_network);
5577 interface = g_supplicant_network_get_interface(supplicant_network);
5578 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
5580 * Note: If supplicant interface's driver is wired then skip it,
5581 * because it meanti only for ethernet not Wi-Fi.
5583 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
5585 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
5587 wifi = g_supplicant_interface_get_data(interface);
5588 name = g_supplicant_network_get_name(supplicant_network);
5589 security = g_supplicant_network_get_security(supplicant_network);
5590 group = g_supplicant_network_get_identifier(supplicant_network);
5591 wps = g_supplicant_network_get_wps(supplicant_network);
5592 wps_pbc = g_supplicant_network_is_wps_pbc(supplicant_network);
5593 wps_ready = g_supplicant_network_is_wps_active(supplicant_network);
5594 wps_advertizing = g_supplicant_network_is_wps_advertizing(
5595 supplicant_network);
5600 ssid = g_supplicant_network_get_ssid(supplicant_network, &ssid_len);
5602 network = connman_device_get_network(wifi->device, identifier);
5605 network = connman_network_create(identifier,
5606 CONNMAN_NETWORK_TYPE_WIFI);
5610 connman_network_set_index(network, wifi->index);
5612 if (connman_device_add_network(wifi->device, network) < 0) {
5613 connman_network_unref(network);
5617 wifi->networks = g_slist_prepend(wifi->networks, network);
5619 network_data = g_new0(struct wifi_network, 1);
5620 connman_network_set_data(network, network_data);
5623 network_data = connman_network_get_data(network);
5624 network_data->keymgmt =
5625 g_supplicant_network_get_keymgmt(supplicant_network);
5627 if (name && name[0] != '\0')
5628 connman_network_set_name(network, name);
5630 connman_network_set_blob(network, "WiFi.SSID",
5632 #if defined TIZEN_EXT
5633 vsie_list = (GSList *)g_supplicant_network_get_wifi_vsie(supplicant_network);
5635 connman_network_set_vsie_list(network, vsie_list);
5637 DBG("vsie_list is NULL");
5638 country_code = g_supplicant_network_get_countrycode(supplicant_network);
5639 connman_network_set_countrycode(network, country_code);
5640 phy_mode = g_supplicant_network_get_phy_mode(supplicant_network);
5641 connman_network_set_phy_mode(network, phy_mode);
5643 if (g_strcmp0(security, "psk_sha256") == 0) {
5644 connman_network_set_psk_sha256(network, true);
5648 connman_network_set_string(network, "WiFi.Security", security);
5649 connman_network_set_strength(network,
5650 calculate_strength(supplicant_network));
5651 connman_network_set_bool(network, "WiFi.WPS", wps);
5652 connman_network_set_bool(network, "WiFi.WPSAdvertising",
5656 /* Is AP advertizing for WPS association?
5657 * If so, we decide to use WPS by default */
5658 if (wps_ready && wps_pbc &&
5660 #if !defined TIZEN_EXT
5661 connman_network_set_bool(network, "WiFi.UseWPS", true);
5663 DBG("wps is activating by ap but ignore it.");
5667 connman_network_set_frequency(network,
5668 g_supplicant_network_get_frequency(supplicant_network));
5670 #if defined TIZEN_EXT
5671 keymgmt = g_supplicant_network_get_keymgmt(supplicant_network);
5672 connman_network_set_bssid(network,
5673 g_supplicant_network_get_bssid(supplicant_network));
5674 owe_transition_mode = (bool)g_supplicant_network_get_transition_mode(supplicant_network);
5675 connman_network_set_bool(network, "WiFi.TRANSITION_MODE", owe_transition_mode);
5676 if (owe_transition_mode) {
5677 transition_mode_ssid = (unsigned char *)g_supplicant_network_get_transition_mode_ssid(supplicant_network, &transition_mode_ssid_len);
5678 connman_network_set_blob(network, "WiFi.TRANSITION_MODE_SSID",
5679 transition_mode_ssid, transition_mode_ssid_len);
5680 transition_mode_bssid = g_supplicant_network_get_transition_mode_bssid(supplicant_network);
5681 connman_network_set_transition_mode_bssid(network, transition_mode_bssid);
5684 sec_list = get_supported_security_list(keymgmt,
5685 owe_transition_mode, supplicant_network);
5687 connman_network_set_sec_list(network, sec_list);
5688 connman_network_set_maxrate(network,
5689 g_supplicant_network_get_maxrate(supplicant_network));
5690 connman_network_set_enc_mode(network,
5691 g_supplicant_network_get_enc_mode(supplicant_network));
5692 connman_network_set_rsn_mode(network,
5693 g_supplicant_network_get_rsn_mode(supplicant_network));
5694 connman_network_set_bool(network, "WiFi.PMFRequired",
5695 (bool)g_supplicant_network_is_pmf_required(supplicant_network));
5696 connman_network_set_keymgmt(network, keymgmt);
5697 connman_network_set_bool(network, "WiFi.HS20AP",
5698 g_supplicant_network_is_hs20AP(supplicant_network));
5699 connman_network_set_bssid_list(network,
5700 (GSList *)g_supplicant_network_get_bssid_list(supplicant_network));
5702 if (TIZEN_INS_ENABLED) {
5703 connman_network_set_last_connected_bssid(network,
5704 g_supplicant_network_get_last_connected_bssid(supplicant_network));
5705 connman_network_set_assoc_reject_table(network,
5706 g_supplicant_network_clone_assoc_reject_table(supplicant_network));
5710 connman_network_set_available(network, true);
5711 connman_network_set_string(network, "WiFi.Mode", mode);
5713 #if defined TIZEN_EXT
5718 connman_network_set_group(network, group);
5720 #if defined TIZEN_EXT
5721 if (TIZEN_INS_ENABLED)
5722 g_supplicant_network_set_last_connected_bssid(supplicant_network,
5723 connman_network_get_last_connected_bssid(network));
5725 if (wifi_first_scan == true)
5726 found_with_first_scan = true;
5729 if (wifi->hidden && ssid) {
5730 #if defined TIZEN_EXT
5731 if (network_security(wifi->hidden->security) ==
5732 network_security(security) &&
5734 if (!g_strcmp0(wifi->hidden->security, security) &&
5736 wifi->hidden->ssid_len == ssid_len &&
5737 !memcmp(wifi->hidden->ssid, ssid, ssid_len)) {
5738 connman_network_connect_hidden(network,
5739 wifi->hidden->identity,
5740 wifi->hidden->passphrase,
5741 wifi->hidden->user_data);
5742 wifi->hidden->user_data = NULL;
5743 hidden_free(wifi->hidden);
5744 wifi->hidden = NULL;
5749 static void network_removed(GSupplicantNetwork *network)
5751 GSupplicantInterface *interface;
5752 struct wifi_data *wifi;
5753 const char *name, *identifier;
5754 struct connman_network *connman_network;
5756 #if defined TIZEN_EXT_WIFI_MESH
5758 mode = g_supplicant_network_get_mode(network);
5759 if (!g_strcmp0(mode, "mesh")) {
5760 mesh_peer_removed(network);
5765 interface = g_supplicant_network_get_interface(network);
5766 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
5768 * Note: If supplicant interface's driver is wired then skip it,
5769 * because it meanti only for ethernet not Wi-Fi.
5771 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
5773 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
5775 wifi = g_supplicant_interface_get_data(interface);
5776 identifier = g_supplicant_network_get_identifier(network);
5777 name = g_supplicant_network_get_name(network);
5779 DBG("name %s", name);
5784 connman_network = connman_device_get_network(wifi->device, identifier);
5785 if (!connman_network)
5788 #if defined TIZEN_EXT
5789 if (connman_network == wifi->scan_pending_network)
5790 wifi->scan_pending_network = NULL;
5792 if (connman_network == wifi->pending_network)
5793 wifi->pending_network = NULL;
5795 if(connman_network_get_connecting(connman_network) == true){
5796 connman_network_set_connected(connman_network, false);
5800 wifi->networks = g_slist_remove(wifi->networks, connman_network);
5802 g_free(connman_network_get_data(connman_network));
5803 connman_device_remove_network(wifi->device, connman_network);
5804 connman_network_unref(connman_network);
5807 static void network_changed(GSupplicantNetwork *network, const char *property)
5809 GSupplicantInterface *interface;
5810 struct wifi_data *wifi;
5811 const char *name, *identifier;
5812 struct connman_network *connman_network;
5815 #if defined TIZEN_EXT
5816 const unsigned char *bssid;
5817 unsigned int maxrate;
5820 const unsigned char *country_code;
5821 ieee80211_modes_e phy_mode;
5825 interface = g_supplicant_network_get_interface(network);
5826 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
5828 * Note: If supplicant interface's driver is wired then skip it,
5829 * because it meanti only for ethernet not Wi-Fi.
5831 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
5833 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
5835 wifi = g_supplicant_interface_get_data(interface);
5836 identifier = g_supplicant_network_get_identifier(network);
5837 name = g_supplicant_network_get_name(network);
5839 #if defined TIZEN_EXT
5840 if (!simplified_log)
5841 DBG("name %s property %s", name, property);
5843 DBG("name %s", name);
5849 connman_network = connman_device_get_network(wifi->device, identifier);
5850 if (!connman_network)
5853 if (g_str_equal(property, "WPSCapabilities")) {
5857 bool wps_advertizing;
5859 wps = g_supplicant_network_get_wps(network);
5860 wps_pbc = g_supplicant_network_is_wps_pbc(network);
5861 wps_ready = g_supplicant_network_is_wps_active(network);
5863 g_supplicant_network_is_wps_advertizing(network);
5865 connman_network_set_bool(connman_network, "WiFi.WPS", wps);
5866 connman_network_set_bool(connman_network,
5867 "WiFi.WPSAdvertising", wps_advertizing);
5871 * Is AP advertizing for WPS association?
5872 * If so, we decide to use WPS by default
5874 if (wps_ready && wps_pbc && wps_advertizing)
5875 connman_network_set_bool(connman_network,
5876 "WiFi.UseWPS", true);
5879 update_needed = true;
5880 } else if (g_str_equal(property, "Signal")) {
5881 connman_network_set_strength(connman_network,
5882 calculate_strength(network));
5883 update_needed = true;
5885 #if defined TIZEN_EXT
5886 else if (TIZEN_INS_ENABLED) {
5887 if (g_str_equal(property, "LastConnectedBSSID")) {
5888 const char *ident, *group;
5889 char *service_ident;
5892 ident = connman_device_get_ident(wifi->device);
5893 group = connman_network_get_group(connman_network);
5894 if (ident && group) {
5895 service_ident = g_strdup_printf("%s_%s_%s",
5896 __connman_network_get_type(connman_network), ident, group);
5898 need_save = connman_device_set_last_connected_ident(wifi->device, service_ident);
5900 connman_device_save_last_connected(wifi->device);
5902 g_free(service_ident);
5905 connman_network_set_last_connected_bssid(connman_network,
5906 g_supplicant_network_get_last_connected_bssid(network));
5908 update_needed = true;
5909 } else if (g_str_equal(property, "UpdateAssocReject")) {
5910 connman_network_set_assoc_reject_table(connman_network,
5911 g_supplicant_network_clone_assoc_reject_table(network));
5912 update_needed = true;
5914 update_needed = false;
5917 #endif /* defined TIZEN_EXT */
5919 update_needed = false;
5922 connman_network_update(connman_network);
5924 #if defined TIZEN_EXT
5925 bssid = g_supplicant_network_get_bssid(network);
5926 maxrate = g_supplicant_network_get_maxrate(network);
5927 frequency = g_supplicant_network_get_frequency(network);
5928 wps = g_supplicant_network_get_wps(network);
5929 phy_mode = g_supplicant_network_get_phy_mode(network);
5931 connman_network_set_bssid(connman_network, bssid);
5932 connman_network_set_maxrate(connman_network, maxrate);
5933 connman_network_set_frequency(connman_network, frequency);
5934 connman_network_set_bool(connman_network, "WiFi.WPS", wps);
5935 country_code = g_supplicant_network_get_countrycode(network);
5936 connman_network_set_countrycode(connman_network, country_code);
5937 bssid_list = (GSList *)g_supplicant_network_get_bssid_list(network);
5938 connman_network_set_bssid_list(connman_network, bssid_list);
5939 connman_network_set_phy_mode(connman_network, phy_mode);
5941 if (g_str_equal(property, "CheckMultiBssidConnect") &&
5942 connman_network_get_associating(connman_network))
5943 network_connect(connman_network);
5947 static void network_associated(GSupplicantNetwork *network)
5949 GSupplicantInterface *interface;
5950 struct wifi_data *wifi;
5951 struct connman_network *connman_network;
5952 const char *identifier;
5956 interface = g_supplicant_network_get_interface(network);
5959 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
5961 * Note: If supplicant interface's driver is wired then skip it,
5962 * because it meanti only for ethernet not Wi-Fi.
5964 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
5966 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
5969 wifi = g_supplicant_interface_get_data(interface);
5973 /* P2P networks must not be treated as WiFi networks */
5974 if (wifi->p2p_connecting || wifi->p2p_device)
5977 identifier = g_supplicant_network_get_identifier(network);
5979 connman_network = connman_device_get_network(wifi->device, identifier);
5980 if (!connman_network)
5983 if (wifi->network) {
5984 if (wifi->network == connman_network)
5987 unsigned int ssid_len;
5988 DBG("network1 ssid[%s] , OWE[%d],ssid[%s]",
5989 (char *)connman_network_get_blob(wifi->network,"WiFi.SSID", &ssid_len),
5990 connman_network_get_bool(wifi->network,"WiFi.TRANSITION_MODE"),
5991 (char *)connman_network_get_blob(wifi->network,"WiFi.TRANSITION_MODE_SSID", &ssid_len));
5993 DBG("network1 ssid[%s], OWE[%d], ssid[%s]",
5994 (char *)connman_network_get_blob(connman_network,"WiFi.SSID",&ssid_len),
5995 connman_network_get_bool(connman_network,"WiFi.TRANSITION_MODE"),
5996 (char *)connman_network_get_blob(connman_network,"WiFi.TRANSITION_MODE_SSID", &ssid_len));
5997 if (connman_network_check_transition_mode(wifi->network, connman_network)) {//OWE trasition mode check
5998 DBG("OWE transition mode is TRUE");
6003 * This should never happen, we got associated with
6004 * a network different than the one we were expecting.
6006 DBG("Associated to %p while expecting %p",
6007 connman_network, wifi->network);
6009 connman_network_set_associating(wifi->network, false);
6012 DBG("Reconnecting to previous network %p from wpa_s", connman_network);
6014 wifi->network = connman_network_ref(connman_network);
6018 * Interface state changes callback (interface_state) is always
6019 * called before network_associated callback thus we need to call
6020 * interface_state again in order to process the new state now that
6021 * we have the network properly set.
6023 interface_state(interface);
6026 static void sta_authorized(GSupplicantInterface *interface,
6029 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
6031 * Note: If supplicant interface's driver is wired then skip it,
6032 * because it meanti only for ethernet not Wi-Fi.
6034 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
6036 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
6038 struct wifi_data *wifi = g_supplicant_interface_get_data(interface);
6040 DBG("wifi %p station %s authorized", wifi, addr);
6042 if (!wifi || !wifi->tethering)
6045 __connman_tethering_client_register(addr);
6048 static void sta_deauthorized(GSupplicantInterface *interface,
6051 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
6053 * Note: If supplicant interface's driver is wired then skip it,
6054 * because it meanti only for ethernet not Wi-Fi.
6056 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
6058 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
6060 struct wifi_data *wifi = g_supplicant_interface_get_data(interface);
6062 DBG("wifi %p station %s deauthorized", wifi, addr);
6064 if (!wifi || !wifi->tethering)
6067 __connman_tethering_client_unregister(addr);
6070 static void apply_peer_services(GSupplicantPeer *peer,
6071 struct connman_peer *connman_peer)
6073 const unsigned char *data;
6078 connman_peer_reset_services(connman_peer);
6080 data = g_supplicant_peer_get_widi_ies(peer, &length);
6082 connman_peer_add_service(connman_peer,
6083 CONNMAN_PEER_SERVICE_WIFI_DISPLAY, data, length);
6087 static void peer_found(GSupplicantPeer *peer)
6089 GSupplicantInterface *iface = g_supplicant_peer_get_interface(peer);
6090 struct wifi_data *wifi = g_supplicant_interface_get_data(iface);
6091 struct connman_peer *connman_peer;
6092 const char *identifier, *name;
6095 #if defined TIZEN_EXT
6099 identifier = g_supplicant_peer_get_identifier(peer);
6100 name = g_supplicant_peer_get_name(peer);
6102 DBG("ident: %s", identifier);
6104 connman_peer = connman_peer_get(wifi->device, identifier);
6108 connman_peer = connman_peer_create(identifier);
6109 connman_peer_set_name(connman_peer, name);
6110 connman_peer_set_device(connman_peer, wifi->device);
6111 apply_peer_services(peer, connman_peer);
6113 ret = connman_peer_register(connman_peer);
6114 if (ret < 0 && ret != -EALREADY)
6115 connman_peer_unref(connman_peer);
6117 wifi->peers = g_slist_prepend(wifi->peers, connman_peer);
6120 static void peer_lost(GSupplicantPeer *peer)
6122 GSupplicantInterface *iface = g_supplicant_peer_get_interface(peer);
6123 struct wifi_data *wifi = g_supplicant_interface_get_data(iface);
6124 struct connman_peer *connman_peer;
6125 const char *identifier;
6130 identifier = g_supplicant_peer_get_identifier(peer);
6132 DBG("ident: %s", identifier);
6134 connman_peer = connman_peer_get(wifi->device, identifier);
6136 if (wifi->p2p_connecting &&
6137 wifi->pending_peer == connman_peer) {
6138 peer_connect_timeout(wifi);
6140 connman_peer_unregister(connman_peer);
6141 connman_peer_unref(connman_peer);
6144 wifi->peers = g_slist_remove(wifi->peers, connman_peer);
6147 static void peer_changed(GSupplicantPeer *peer, GSupplicantPeerState state)
6149 GSupplicantInterface *iface = g_supplicant_peer_get_interface(peer);
6150 struct wifi_data *wifi = g_supplicant_interface_get_data(iface);
6151 enum connman_peer_state p_state = CONNMAN_PEER_STATE_UNKNOWN;
6152 struct connman_peer *connman_peer;
6153 const char *identifier;
6155 identifier = g_supplicant_peer_get_identifier(peer);
6157 DBG("ident: %s", identifier);
6162 connman_peer = connman_peer_get(wifi->device, identifier);
6167 case G_SUPPLICANT_PEER_SERVICES_CHANGED:
6168 apply_peer_services(peer, connman_peer);
6169 connman_peer_services_changed(connman_peer);
6171 case G_SUPPLICANT_PEER_GROUP_CHANGED:
6172 if (!g_supplicant_peer_is_in_a_group(peer))
6173 p_state = CONNMAN_PEER_STATE_IDLE;
6175 p_state = CONNMAN_PEER_STATE_CONFIGURATION;
6177 case G_SUPPLICANT_PEER_GROUP_STARTED:
6179 case G_SUPPLICANT_PEER_GROUP_FINISHED:
6180 p_state = CONNMAN_PEER_STATE_IDLE;
6182 case G_SUPPLICANT_PEER_GROUP_JOINED:
6183 connman_peer_set_iface_address(connman_peer,
6184 g_supplicant_peer_get_iface_address(peer));
6186 case G_SUPPLICANT_PEER_GROUP_DISCONNECTED:
6187 p_state = CONNMAN_PEER_STATE_IDLE;
6189 case G_SUPPLICANT_PEER_GROUP_FAILED:
6190 if (g_supplicant_peer_has_requested_connection(peer))
6191 p_state = CONNMAN_PEER_STATE_IDLE;
6193 p_state = CONNMAN_PEER_STATE_FAILURE;
6197 if (p_state == CONNMAN_PEER_STATE_CONFIGURATION ||
6198 p_state == CONNMAN_PEER_STATE_FAILURE) {
6199 if (wifi->p2p_connecting
6200 && connman_peer == wifi->pending_peer)
6201 peer_cancel_timeout(wifi);
6203 p_state = CONNMAN_PEER_STATE_UNKNOWN;
6206 if (p_state == CONNMAN_PEER_STATE_UNKNOWN)
6209 if (p_state == CONNMAN_PEER_STATE_CONFIGURATION) {
6210 GSupplicantInterface *g_iface;
6211 struct wifi_data *g_wifi;
6213 g_iface = g_supplicant_peer_get_group_interface(peer);
6217 g_wifi = g_supplicant_interface_get_data(g_iface);
6221 connman_peer_set_as_master(connman_peer,
6222 !g_supplicant_peer_is_client(peer));
6223 connman_peer_set_sub_device(connman_peer, g_wifi->device);
6226 * If wpa_supplicant didn't create a dedicated p2p-group
6227 * interface then mark this interface as p2p_device to avoid
6228 * scan and auto-scan are launched on it while P2P is connected.
6230 if (!g_list_find(p2p_iface_list, g_wifi))
6231 wifi->p2p_device = true;
6234 connman_peer_set_state(connman_peer, p_state);
6237 static void peer_request(GSupplicantPeer *peer)
6239 GSupplicantInterface *iface = g_supplicant_peer_get_interface(peer);
6240 struct wifi_data *wifi = g_supplicant_interface_get_data(iface);
6241 struct connman_peer *connman_peer;
6242 const char *identifier;
6244 #if defined TIZEN_EXT
6249 identifier = g_supplicant_peer_get_identifier(peer);
6251 DBG("ident: %s", identifier);
6253 connman_peer = connman_peer_get(wifi->device, identifier);
6257 connman_peer_request_connection(connman_peer);
6260 #if defined TIZEN_EXT
6261 static void system_power_off(void)
6264 struct wifi_data *wifi;
6265 struct connman_service *service;
6266 struct connman_ipconfig *ipconfig_ipv4;
6268 if (connman_setting_get_bool("WiFiDHCPRelease") == true) {
6269 for (list = iface_list; list; list = list->next) {
6272 if (wifi->network != NULL) {
6273 service = connman_service_lookup_from_network(wifi->network);
6274 ipconfig_ipv4 = __connman_service_get_ip4config(service);
6275 __connman_dhcp_stop(ipconfig_ipv4);
6281 static void network_merged(GSupplicantNetwork *network)
6283 GSupplicantInterface *interface;
6284 GSupplicantState state;
6285 struct wifi_data *wifi;
6286 const char *identifier;
6287 struct connman_network *connman_network;
6291 interface = g_supplicant_network_get_interface(network);
6295 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
6297 * Note: If supplicant interface's driver is wired then skip it,
6298 * because it meanti only for ethernet not Wi-Fi.
6300 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
6302 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
6304 state = g_supplicant_interface_get_state(interface);
6305 if (state < G_SUPPLICANT_STATE_AUTHENTICATING)
6308 wifi = g_supplicant_interface_get_data(interface);
6312 identifier = g_supplicant_network_get_identifier(network);
6314 connman_network = connman_device_get_network(wifi->device, identifier);
6315 if (!connman_network)
6318 DBG("merged identifier %s", identifier);
6320 if (wifi->connected == FALSE) {
6322 case G_SUPPLICANT_STATE_AUTHENTICATING:
6323 case G_SUPPLICANT_STATE_ASSOCIATING:
6324 case G_SUPPLICANT_STATE_ASSOCIATED:
6325 case G_SUPPLICANT_STATE_4WAY_HANDSHAKE:
6326 case G_SUPPLICANT_STATE_GROUP_HANDSHAKE:
6327 connman_network_set_associating(connman_network, TRUE);
6329 case G_SUPPLICANT_STATE_COMPLETED:
6330 connman_network_set_connected(connman_network, TRUE);
6333 DBG("Not handled the state : %d", state);
6338 ishs20AP = g_supplicant_network_is_hs20AP(network);
6341 g_strcmp0(g_supplicant_network_get_security(network), "ieee8021x") == 0) {
6342 temp = g_ascii_strdown(g_supplicant_network_get_eap(network), -1);
6343 connman_network_set_string(connman_network, "WiFi.EAP",
6345 connman_network_set_string(connman_network, "WiFi.Identity",
6346 g_supplicant_network_get_identity(network));
6347 connman_network_set_string(connman_network, "WiFi.Phase2",
6348 g_supplicant_network_get_phase2(network));
6353 wifi->network = connman_network;
6356 static void assoc_failed(void *user_data)
6358 struct connman_network *network = user_data;
6359 connman_network_set_associating(network, false);
6362 static void scan_done(GSupplicantInterface *interface)
6364 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
6366 * Note: If supplicant interface's driver is wired then skip it,
6367 * because it meanti only for ethernet not Wi-Fi.
6369 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
6371 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
6374 int scan_type = CONNMAN_SCAN_TYPE_WPA_SUPPLICANT;
6375 struct wifi_data *wifi;
6378 for (list = iface_list; list; list = list->next) {
6381 if (interface == wifi->interface) {
6382 scanning = connman_device_get_scanning(wifi->device,
6383 CONNMAN_SERVICE_TYPE_WIFI);
6385 __connman_technology_notify_scan_done(
6386 connman_device_get_string(wifi->device, "Interface"), scan_type);
6393 static void debug(const char *str)
6395 #if defined TIZEN_EXT
6396 if (connman_setting_get_bool("ConnmanSupplicantDebug"))
6398 if (getenv("CONNMAN_SUPPLICANT_DEBUG"))
6400 connman_debug("%s", str);
6403 static void disconnect_reasoncode(GSupplicantInterface *interface,
6406 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
6408 * Note: If supplicant interface's driver is wired then skip it,
6409 * because it meanti only for ethernet not Wi-Fi.
6411 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
6413 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
6415 struct wifi_data *wifi = g_supplicant_interface_get_data(interface);
6418 wifi->disconnect_code = reasoncode;
6422 static void assoc_status_code(GSupplicantInterface *interface, int status_code)
6424 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
6426 * Note: If supplicant interface's driver is wired then skip it,
6427 * because it meanti only for ethernet not Wi-Fi.
6429 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
6431 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
6433 struct wifi_data *wifi = g_supplicant_interface_get_data(interface);
6436 wifi->assoc_code = status_code;
6440 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
6441 static GSupplicantCallbacks callbacks = {
6442 #else /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
6443 static const GSupplicantCallbacks callbacks = {
6444 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
6445 .system_ready = system_ready,
6446 .system_killed = system_killed,
6447 .interface_added = interface_added,
6448 .interface_state = interface_state,
6449 .interface_removed = interface_removed,
6450 .p2p_support = p2p_support,
6451 .scan_started = scan_started,
6452 .scan_finished = scan_finished,
6453 .ap_create_fail = ap_create_fail,
6454 .network_added = network_added,
6455 .network_removed = network_removed,
6456 .network_changed = network_changed,
6457 .network_associated = network_associated,
6458 .sta_authorized = sta_authorized,
6459 .sta_deauthorized = sta_deauthorized,
6460 .peer_found = peer_found,
6461 .peer_lost = peer_lost,
6462 .peer_changed = peer_changed,
6463 .peer_request = peer_request,
6464 #if defined TIZEN_EXT
6465 .system_power_off = system_power_off,
6466 .network_merged = network_merged,
6467 .assoc_failed = assoc_failed,
6468 .scan_done = scan_done,
6471 .disconnect_reasoncode = disconnect_reasoncode,
6472 .assoc_status_code = assoc_status_code,
6473 #if defined TIZEN_EXT_WIFI_MESH
6474 .mesh_support = mesh_support,
6475 .mesh_group_started = mesh_group_started,
6476 .mesh_group_removed = mesh_group_removed,
6477 .mesh_peer_connected = mesh_peer_connected,
6478 .mesh_peer_disconnected = mesh_peer_disconnected,
6483 static int tech_probe(struct connman_technology *technology)
6485 wifi_technology = technology;
6490 static void tech_remove(struct connman_technology *technology)
6492 wifi_technology = NULL;
6495 static GSupplicantSSID *ssid_ap_init(const struct connman_technology *technology)
6497 GSupplicantSSID *ap;
6498 const char *ssid, *passphrase;
6502 ap = g_try_malloc0(sizeof(GSupplicantSSID));
6506 ret = connman_technology_get_wifi_tethering(technology,
6510 #if defined TIZEN_EXT
6516 ap->mode = G_SUPPLICANT_MODE_MASTER;
6517 #if defined TIZEN_EXT
6518 ap->ssid = (void *) ssid;
6522 ap->ssid_len = strlen(ssid);
6529 if (!passphrase || strlen(passphrase) == 0) {
6530 ap->security = G_SUPPLICANT_SECURITY_NONE;
6531 ap->passphrase = NULL;
6533 ap->security = G_SUPPLICANT_SECURITY_PSK;
6534 ap->protocol = G_SUPPLICANT_PROTO_RSN;
6535 ap->pairwise_cipher = G_SUPPLICANT_PAIRWISE_CCMP;
6536 ap->group_cipher = G_SUPPLICANT_GROUP_CCMP;
6537 ap->passphrase = passphrase;
6543 static void ap_start_callback(int result, GSupplicantInterface *interface,
6546 struct wifi_tethering_info *info = user_data;
6548 DBG("result %d index %d bridge %s",
6549 result, info->wifi->index, info->wifi->bridge);
6551 if ((result < 0) || (info->wifi->ap_supported != WIFI_AP_SUPPORTED)) {
6552 connman_inet_remove_from_bridge(info->wifi->index,
6553 info->wifi->bridge);
6555 if (info->wifi->ap_supported == WIFI_AP_SUPPORTED) {
6556 connman_technology_tethering_notify(info->technology, false);
6557 g_free(info->wifi->tethering_param->ssid);
6558 g_free(info->wifi->tethering_param);
6559 info->wifi->tethering_param = NULL;
6563 g_free(info->ifname);
6567 static void ap_create_callback(int result,
6568 GSupplicantInterface *interface,
6571 struct wifi_tethering_info *info = user_data;
6573 DBG("result %d ifname %s", result,
6574 g_supplicant_interface_get_ifname(interface));
6576 if ((result < 0) || (info->wifi->ap_supported != WIFI_AP_SUPPORTED)) {
6577 connman_inet_remove_from_bridge(info->wifi->index,
6578 info->wifi->bridge);
6580 if (info->wifi->ap_supported == WIFI_AP_SUPPORTED) {
6581 connman_technology_tethering_notify(info->technology, false);
6582 g_free(info->wifi->tethering_param->ssid);
6583 g_free(info->wifi->tethering_param);
6584 info->wifi->tethering_param = NULL;
6588 g_free(info->ifname);
6594 info->wifi->interface = interface;
6595 g_supplicant_interface_set_data(interface, info->wifi);
6597 if (g_supplicant_interface_set_apscan(interface, 2) < 0)
6598 connman_error("Failed to set interface ap_scan property");
6600 g_supplicant_interface_connect(interface, info->ssid,
6601 ap_start_callback, info);
6604 static void sta_remove_callback(int result,
6605 GSupplicantInterface *interface,
6608 struct wifi_tethering_info *info = user_data;
6609 const char *driver = connman_setting_get_string("wifi");
6611 DBG("ifname %s result %d ", info->ifname, result);
6613 if ((result < 0) || (info->wifi->ap_supported != WIFI_AP_SUPPORTED)) {
6614 info->wifi->tethering = false;
6615 connman_technology_tethering_notify(info->technology, false);
6617 if (info->wifi->ap_supported == WIFI_AP_SUPPORTED) {
6618 g_free(info->wifi->tethering_param->ssid);
6619 g_free(info->wifi->tethering_param);
6620 info->wifi->tethering_param = NULL;
6623 g_free(info->ifname);
6629 info->wifi->interface = NULL;
6631 g_supplicant_interface_create(info->ifname, driver, info->wifi->bridge,
6634 #endif /* TIZEN_EXT */
6639 static int enable_wifi_tethering(struct connman_technology *technology,
6640 const char *bridge, bool available)
6643 GSupplicantInterface *interface;
6644 struct wifi_data *wifi;
6645 struct wifi_tethering_info *info;
6650 for (list = iface_list; list; list = list->next) {
6653 DBG("wifi %p network %p pending_network %p", wifi,
6654 wifi->network, wifi->pending_network);
6656 interface = wifi->interface;
6661 ifname = g_supplicant_interface_get_ifname(wifi->interface);
6665 if (wifi->ap_supported == WIFI_AP_NOT_SUPPORTED) {
6666 DBG("%s does not support AP mode (detected)", ifname);
6670 mode = g_supplicant_interface_get_mode(interface);
6671 if ((mode & G_SUPPLICANT_CAPABILITY_MODE_AP) == 0) {
6672 wifi->ap_supported = WIFI_AP_NOT_SUPPORTED;
6673 DBG("%s does not support AP mode (capability)", ifname);
6677 if (wifi->network && available)
6680 info = g_try_malloc0(sizeof(struct wifi_tethering_info));
6684 wifi->tethering_param = g_try_malloc0(sizeof(struct wifi_tethering_info));
6685 if (!wifi->tethering_param) {
6691 info->technology = technology;
6692 info->wifi->bridge = bridge;
6693 info->ssid = ssid_ap_init(technology);
6697 info->ifname = g_strdup(ifname);
6699 wifi->tethering_param->technology = technology;
6700 wifi->tethering_param->ssid = ssid_ap_init(technology);
6701 if (!wifi->tethering_param->ssid)
6704 info->wifi->tethering = true;
6705 info->wifi->ap_supported = WIFI_AP_SUPPORTED;
6707 berr = connman_technology_tethering_notify(technology, true);
6711 err = g_supplicant_interface_remove(interface,
6712 sta_remove_callback,
6715 DBG("tethering wifi %p ifname %s", wifi, ifname);
6720 g_free(info->ifname);
6723 g_free(wifi->tethering_param);
6724 wifi->tethering_param = NULL;
6727 * Remove bridge if it was correctly created but remove
6728 * operation failed. Instead, if bridge creation failed then
6729 * break out and do not try again on another interface,
6730 * bridge set-up does not depend on it.
6733 connman_technology_tethering_notify(technology, false);
6741 static int tech_set_tethering(struct connman_technology *technology,
6742 const char *bridge, bool enabled)
6745 struct wifi_data *wifi;
6751 for (list = iface_list; list; list = list->next) {
6754 if (wifi->tethering) {
6755 wifi->tethering = false;
6757 connman_inet_remove_from_bridge(wifi->index,
6759 wifi->bridged = false;
6763 connman_technology_tethering_notify(technology, false);
6768 DBG("trying tethering for available devices");
6769 err = enable_wifi_tethering(technology, bridge, true);
6772 DBG("trying tethering for any device");
6773 err = enable_wifi_tethering(technology, bridge, false);
6779 static void regdom_callback(int result, const char *alpha2, void *user_data)
6783 if (!wifi_technology)
6789 connman_technology_regdom_notify(wifi_technology, alpha2);
6792 static int tech_set_regdom(struct connman_technology *technology, const char *alpha2)
6794 return g_supplicant_set_country(alpha2, regdom_callback, NULL);
6797 #if defined TIZEN_EXT
6798 static void supp_ins_init(void)
6801 GSupplicantINSPreferredFreq preferred_freq;
6803 string = connman_setting_get_string("INSPreferredFreqBSSID");
6804 if (g_strcmp0(string, "5GHz") == 0)
6805 preferred_freq = G_SUPPLICANT_INS_PREFERRED_FREQ_5GHZ;
6806 else if (g_strcmp0(string, "2.4GHz") == 0)
6807 preferred_freq = G_SUPPLICANT_INS_PREFERRED_FREQ_24GHZ;
6809 preferred_freq = G_SUPPLICANT_INS_PREFERRED_FREQ_UNKNOWN;
6811 g_supplicant_set_ins_settings(preferred_freq,
6812 connman_setting_get_bool("INSLastConnectedBSSID"),
6813 connman_setting_get_bool("INSAssocReject"),
6814 connman_setting_get_bool("INSSignalBSSID"),
6815 connman_setting_get_uint("INSPreferredFreqBSSIDScore"),
6816 connman_setting_get_uint("INSLastConnectedBSSIDScore"),
6817 connman_setting_get_uint("INSAssocRejectScore"),
6818 connman_setting_get_int("INSSignalLevel3_5GHz"),
6819 connman_setting_get_int("INSSignalLevel3_2_4GHz")
6822 #endif /* defined TIZEN_EXT */
6824 static struct connman_technology_driver tech_driver = {
6826 .type = CONNMAN_SERVICE_TYPE_WIFI,
6827 .probe = tech_probe,
6828 .remove = tech_remove,
6829 .set_tethering = tech_set_tethering,
6830 .set_regdom = tech_set_regdom,
6833 static int wifi_init(void)
6837 err = connman_network_driver_register(&network_driver);
6841 err = g_supplicant_register(&callbacks);
6843 connman_network_driver_unregister(&network_driver);
6847 err = connman_technology_driver_register(&tech_driver);
6849 g_supplicant_unregister(&callbacks);
6850 connman_network_driver_unregister(&network_driver);
6854 #if defined TIZEN_EXT
6855 failed_bssids = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
6857 min_snr = connman_setting_get_int("WifiRoamingMinSNR");
6859 min_rssi_2_4GHz = connman_setting_get_int("WifiRoamingMinRSSI_2_4GHz");
6860 if (min_rssi_2_4GHz >= 0)
6861 min_rssi_2_4GHz = RSSI_LEVEL_2_2_4G;
6863 min_rssi_5GHz = connman_setting_get_int("WifiRoamingMinRSSI_5GHz");
6864 if (min_rssi_5GHz >= 0)
6865 min_rssi_5GHz = RSSI_LEVEL_2_5G;
6867 min_rssi_6GHz = connman_setting_get_int("WifiRoamingMinRSSI_6GHz");
6868 if (min_rssi_6GHz >= 0)
6869 min_rssi_6GHz = RSSI_LEVEL_2_6G;
6871 DBG("Min SNR: %d, Min RSSI: %d(2.4GHz), %d(5GHz), %d(6GHz)",
6872 min_snr, min_rssi_2_4GHz, min_rssi_5GHz, min_rssi_6GHz);
6874 if (TIZEN_INS_ENABLED)
6876 #endif /* defined TIZEN_EXT */
6880 static void wifi_exit(void)
6884 connman_technology_driver_unregister(&tech_driver);
6886 g_supplicant_unregister(&callbacks);
6888 connman_network_driver_unregister(&network_driver);
6890 #if defined TIZEN_EXT
6891 g_hash_table_unref(failed_bssids);
6895 CONNMAN_PLUGIN_DEFINE(wifi, "WiFi interface plugin", VERSION,
6896 CONNMAN_PLUGIN_PRIORITY_DEFAULT, wifi_init, wifi_exit)