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 #define IFF_LOWER_UP 0x10000
40 #include <dbus/dbus.h>
43 #define CONNMAN_API_SUBJECT_TO_CHANGE
44 #include <connman/plugin.h>
45 #include <connman/inet.h>
46 #include <connman/device.h>
47 #include <connman/rtnl.h>
48 #include <connman/technology.h>
49 #include <connman/service.h>
50 #include <connman/peer.h>
51 #include <connman/log.h>
52 #include <connman/storage.h>
53 #include <include/setting.h>
54 #include <connman/provision.h>
55 #include <connman/utsname.h>
56 #include <connman/machine.h>
57 #include <connman/tethering.h>
59 #include <gsupplicant/gsupplicant.h>
61 #include "src/shared/util.h"
63 #define CLEANUP_TIMEOUT 8 /* in seconds */
64 #define INACTIVE_TIMEOUT 12 /* in seconds */
65 #define FAVORITE_MAXIMUM_RETRIES 2
67 #define BGSCAN_DEFAULT "simple:30:-65:300"
68 #define AUTOSCAN_EXPONENTIAL "exponential:3:300"
69 #define AUTOSCAN_SINGLE "single:3"
70 #define SCAN_MAX_DURATION 10
72 #define P2P_FIND_TIMEOUT 30
73 #define P2P_CONNECTION_TIMEOUT 100
74 #define P2P_LISTEN_PERIOD 500
75 #define P2P_LISTEN_INTERVAL 2000
77 #define ASSOC_STATUS_AUTH_TIMEOUT 16
78 #define ASSOC_STATUS_NO_CLIENT 17
80 #define LOAD_SHAPING_MAX_RETRIES 7
82 #define LOAD_SHAPING_MAX_RETRIES 3
86 #define WIFI_EAP_FAST_PAC_FILE "/var/lib/wifi/wifi.pac" /* path of Pac file for EAP-FAST */
88 /* Wi-Fi Signal Strength (for 2.4G (dB))
92 * Very weak : -83 ~ -88
95 * Wi-Fi Signal Strength (for 5G (dB))
99 * Very weak : -83 ~ -88
102 #define RSSI_LEVEL_2_5G -77
103 #define RSSI_LEVEL_2_24G -75
104 #define RSSI_LEVEL_3_5G -68
105 #define RSSI_LEVEL_3_24G -64
106 #define ROAM_SCAN_INTERVAL 60 /* 60 seconds */
109 static struct connman_technology *wifi_technology = NULL;
110 static struct connman_technology *p2p_technology = NULL;
112 enum wifi_ap_capability{
114 WIFI_AP_SUPPORTED = 1,
115 WIFI_AP_NOT_SUPPORTED = 2,
118 enum wifi_scanning_type {
119 WIFI_SCANNING_UNKNOWN = 0,
120 WIFI_SCANNING_PASSIVE = 1,
121 WIFI_SCANNING_ACTIVE = 2,
124 struct hidden_params {
126 unsigned int ssid_len;
128 char *anonymous_identity;
130 char *altsubject_match;
131 char *domain_suffix_match;
135 GSupplicantScanParams *scan_params;
140 * Used for autoscan "emulation".
141 * Should be removed when wpa_s autoscan support will be by default.
143 struct autoscan_params {
147 unsigned int timeout;
150 struct wifi_tethering_info {
151 struct wifi_data *wifi;
152 struct connman_technology *technology;
154 GSupplicantSSID *ssid;
159 struct connman_device *device;
160 struct connman_network *network;
161 struct connman_network *pending_network;
163 GSupplicantInterface *interface;
164 GSupplicantState state;
168 enum wifi_ap_capability ap_supported;
170 bool interface_ready;
176 int load_shaping_retries;
177 struct hidden_params *hidden;
178 bool postpone_hidden;
179 struct wifi_tethering_info *tethering_param;
181 * autoscan "emulation".
183 struct autoscan_params *autoscan;
184 enum wifi_scanning_type scanning_type;
185 GSupplicantScanParams *scan_params;
186 unsigned int p2p_find_timeout;
187 unsigned int p2p_connection_timeout;
188 struct connman_peer *pending_peer;
193 #if defined TIZEN_EXT
194 int assoc_retry_count;
195 struct connman_network *scan_pending_network;
196 bool allow_full_scan;
197 unsigned int automaxspeed_timeout;
198 GSupplicantScanParams *hidden_scan_params;
199 unsigned int mac_policy;
200 unsigned int preassoc_mac_policy;
201 unsigned int mac_lifetime;
205 #if defined TIZEN_EXT_WIFI_MESH
207 struct wifi_mesh_info *mesh_info;
211 struct disconnect_data {
212 struct wifi_data *wifi;
213 struct connman_network *network;
216 #if defined TIZEN_EXT
220 #define TIZEN_ASSOC_RETRY_COUNT 4
222 static gboolean wifi_first_scan = false;
223 static gboolean found_with_first_scan = false;
224 static gboolean is_wifi_notifier_registered = false;
225 static GHashTable *failed_bssids = NULL;
226 static unsigned char buff_bssid[WIFI_BSSID_LEN_MAX] = { 0, };
229 static GList *iface_list = NULL;
231 static GList *pending_wifi_device = NULL;
232 static GList *p2p_iface_list = NULL;
233 static bool wfd_service_registered = false;
235 static void start_autoscan(struct connman_device *device);
236 static int tech_set_tethering(struct connman_technology *technology,
237 const char *identifier, const char *passphrase,
238 const char *bridge, bool enabled);
240 #if defined TIZEN_EXT
241 #define NETCONFIG_SERVICE "net.netconfig"
242 #define NETCONFIG_WIFI_PATH "/net/netconfig/wifi"
243 #define NETCONFIG_WIFI_INTERFACE NETCONFIG_SERVICE ".wifi"
245 struct enc_method_call_data {
246 DBusConnection *connection;
247 struct connman_network *network;
250 static struct enc_method_call_data encrypt_request_data;
252 static void encryption_request_reply(DBusPendingCall *call,
257 DBusMessageIter args;
259 struct connman_service *service;
260 gchar* encrypted_value = NULL;
261 struct connman_network *network = encrypt_request_data.network;
265 reply = dbus_pending_call_steal_reply(call);
267 dbus_error_init(&error);
268 if (dbus_set_error_from_message(&error, reply)) {
269 DBG("send_encryption_request() %s %s", error.name, error.message);
270 dbus_error_free(&error);
274 if (dbus_message_iter_init(reply, &args) == FALSE)
277 dbus_message_iter_get_basic(&args, &out_data);
279 encrypted_value = g_strdup((const gchar *)out_data);
280 service = connman_service_lookup_from_network(network);
283 DBG("encryption result: no service");
287 if (connman_service_get_favorite(service)) {
288 __connman_service_set_passphrase(service, encrypted_value);
289 __connman_service_save(service);
291 connman_network_set_string(network, "WiFi.Passphrase",
294 DBG("encryption result: succeeded");
297 dbus_message_unref(reply);
298 dbus_pending_call_unref(call);
299 dbus_connection_unref(encrypt_request_data.connection);
300 g_free(encrypted_value);
302 encrypt_request_data.connection = NULL;
303 encrypt_request_data.network = NULL;
306 static int send_encryption_request(const char *passphrase,
307 struct connman_network *network)
309 DBusConnection *connection = NULL;
310 DBusMessage *msg = NULL;
311 DBusPendingCall *call;
314 DBG("Invalid parameter");
318 connection = connman_dbus_get_connection();
320 DBG("dbus connection does not exist");
324 msg = dbus_message_new_method_call(NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
325 NETCONFIG_WIFI_INTERFACE, "EncryptPassphrase");
327 dbus_connection_unref(connection);
331 dbus_message_append_args(msg, DBUS_TYPE_STRING, &passphrase,
334 if (!dbus_connection_send_with_reply(connection, msg,
335 &call, DBUS_TIMEOUT_USE_DEFAULT)) {
336 dbus_message_unref(msg);
337 dbus_connection_unref(connection);
342 dbus_message_unref(msg);
343 dbus_connection_unref(connection);
347 encrypt_request_data.connection = connection;
348 encrypt_request_data.network = network;
350 dbus_pending_call_set_notify(call, encryption_request_reply, NULL, NULL);
351 dbus_message_unref(msg);
357 static int p2p_tech_probe(struct connman_technology *technology)
359 p2p_technology = technology;
364 static void p2p_tech_remove(struct connman_technology *technology)
366 p2p_technology = NULL;
369 static struct connman_technology_driver p2p_tech_driver = {
371 .type = CONNMAN_SERVICE_TYPE_P2P,
372 .probe = p2p_tech_probe,
373 .remove = p2p_tech_remove,
376 static bool is_p2p_connecting(void)
380 for (list = iface_list; list; list = list->next) {
381 struct wifi_data *wifi = list->data;
383 if (wifi->p2p_connecting)
390 static void add_pending_wifi_device(struct wifi_data *wifi)
392 if (g_list_find(pending_wifi_device, wifi))
395 pending_wifi_device = g_list_append(pending_wifi_device, wifi);
398 #if defined TIZEN_EXT_WIFI_MESH
399 struct wifi_mesh_info {
400 struct wifi_data *wifi;
401 GSupplicantInterface *interface;
402 struct connman_mesh *mesh;
409 struct mesh_change_peer_status_info {
411 enum connman_mesh_peer_status peer_status;
412 mesh_change_peer_status_cb_t callback;
416 static struct connman_technology_driver mesh_tech_driver = {
418 .type = CONNMAN_SERVICE_TYPE_MESH,
421 static void mesh_interface_create_callback(int result,
422 GSupplicantInterface *interface,
425 struct wifi_mesh_info *mesh_info = user_data;
426 struct wifi_data *wifi;
427 bool success = false;
429 DBG("result %d ifname %s, mesh_info %p", result,
430 g_supplicant_interface_get_ifname(interface),
433 if (result < 0 || !mesh_info)
436 wifi = mesh_info->wifi;
438 mesh_info->interface = interface;
439 mesh_info->identifier = connman_inet_ifaddr(mesh_info->ifname);
440 mesh_info->index = connman_inet_ifindex(mesh_info->ifname);
441 DBG("Mesh Interface identifier %s", mesh_info->identifier);
442 wifi->mesh_interface = true;
443 wifi->mesh_info = mesh_info;
444 g_supplicant_interface_set_data(interface, wifi);
448 connman_mesh_notify_interface_create(success);
451 static int add_mesh_interface(const char *ifname, const char *parent_ifname)
454 struct wifi_data *wifi;
455 struct wifi_mesh_info *mesh_info;
456 const char *wifi_ifname;
457 bool parent_found = false;
458 const char *driver = "nl80211";
460 for (list = iface_list; list; list = list->next) {
463 if (!g_supplicant_interface_has_mesh(wifi->interface))
466 wifi_ifname = g_supplicant_interface_get_ifname(wifi->interface);
470 if (!g_strcmp0(wifi_ifname, parent_ifname)) {
477 DBG("Parent interface %s doesn't exist", parent_ifname);
481 mesh_info = g_try_malloc0(sizeof(struct wifi_mesh_info));
485 mesh_info->wifi = wifi;
486 mesh_info->ifname = g_strdup(ifname);
487 mesh_info->parent_ifname = g_strdup(parent_ifname);
489 g_supplicant_mesh_interface_create(ifname, driver, NULL, parent_ifname,
490 mesh_interface_create_callback, mesh_info);
494 static void mesh_interface_remove_callback(int result,
495 GSupplicantInterface *interface,
498 struct wifi_data *wifi = user_data;
499 struct wifi_mesh_info *mesh_info = wifi->mesh_info;
500 bool success = false;
502 DBG("result %d mesh_info %p", result, mesh_info);
504 if (result < 0 || !mesh_info)
507 mesh_info->interface = NULL;
508 g_free(mesh_info->parent_ifname);
509 g_free(mesh_info->ifname);
510 g_free(mesh_info->identifier);
512 wifi->mesh_interface = false;
513 wifi->mesh_info = NULL;
517 connman_mesh_notify_interface_remove(success);
520 static int remove_mesh_interface(const char *ifname)
523 struct wifi_data *wifi;
524 struct wifi_mesh_info *mesh_info;
525 bool mesh_if_found = false;
528 for (list = iface_list; list; list = list->next) {
531 if (wifi->mesh_interface) {
532 mesh_if_found = true;
537 if (!mesh_if_found) {
538 DBG("Mesh interface %s doesn't exist", ifname);
542 mesh_info = wifi->mesh_info;
543 ret = g_supplicant_interface_remove(mesh_info->interface,
544 mesh_interface_remove_callback, wifi);
551 static void mesh_disconnect_callback(int result,
552 GSupplicantInterface *interface, void *user_data)
554 struct connman_mesh *mesh = user_data;
556 DBG("result %d interface %p mesh %p", result, interface, mesh);
559 static int mesh_peer_disconnect(struct connman_mesh *mesh)
562 struct wifi_data *wifi;
563 struct wifi_mesh_info *mesh_info;
564 bool mesh_if_found = false;
565 GSupplicantInterface *interface;
567 for (list = iface_list; list; list = list->next) {
570 if (wifi->mesh_interface) {
571 mesh_if_found = true;
576 if (!mesh_if_found) {
577 DBG("Mesh interface is not created");
581 mesh_info = wifi->mesh_info;
583 interface = mesh_info->interface;
584 return g_supplicant_interface_disconnect(interface,
585 mesh_disconnect_callback, mesh);
588 static void mesh_connect_callback(int result, GSupplicantInterface *interface,
591 struct connman_mesh *mesh = user_data;
592 DBG("mesh %p result %d", mesh, result);
595 connman_mesh_peer_set_state(mesh, CONNMAN_MESH_STATE_FAILURE);
597 connman_mesh_peer_set_state(mesh, CONNMAN_MESH_STATE_ASSOCIATION);
600 static GSupplicantSecurity mesh_network_security(const char *security)
602 if (g_str_equal(security, "none"))
603 return G_SUPPLICANT_SECURITY_NONE;
604 else if (g_str_equal(security, "sae"))
605 return G_SUPPLICANT_SECURITY_SAE;
607 return G_SUPPLICANT_SECURITY_UNKNOWN;
610 static void mesh_ssid_init(GSupplicantSSID *ssid, struct connman_mesh *mesh)
613 const char *security;
618 memset(ssid, 0, sizeof(*ssid));
619 ssid->mode = G_SUPPLICANT_MODE_MESH;
621 security = connman_mesh_get_security(mesh);
622 ssid->security = mesh_network_security(security);
624 if (ssid->security == G_SUPPLICANT_SECURITY_SAE)
625 ssid->passphrase = connman_mesh_get_passphrase(mesh);
627 ssid->freq = connman_mesh_get_frequency(mesh);
628 name = connman_mesh_get_name(mesh);
630 ssid->ssid_len = strlen(name);
631 ssid->ssid = g_malloc0(ssid->ssid_len + 1);
632 memcpy(ssid->ssid, name, ssid->ssid_len);
637 static int mesh_peer_connect(struct connman_mesh *mesh)
640 struct wifi_data *wifi;
641 struct wifi_mesh_info *mesh_info;
642 bool mesh_if_found = false;
643 GSupplicantInterface *interface;
644 GSupplicantSSID *ssid;
646 for (list = iface_list; list; list = list->next) {
649 if (wifi->mesh_interface) {
650 mesh_if_found = true;
655 if (!mesh_if_found) {
656 DBG("Mesh interface is not created");
660 mesh_info = wifi->mesh_info;
662 interface = mesh_info->interface;
664 ssid = g_try_malloc0(sizeof(GSupplicantSSID));
668 mesh_info->mesh = mesh;
670 mesh_ssid_init(ssid, mesh);
671 return g_supplicant_interface_connect(interface, ssid,
672 mesh_connect_callback, mesh);
675 static void mesh_peer_change_status_callback(int result,
676 GSupplicantInterface *interface,
679 struct mesh_change_peer_status_info *data = user_data;
681 DBG("result %d Peer Status %d", result, data->peer_status);
683 if (result == 0 && data->peer_status == CONNMAN_MESH_PEER_REMOVE) {
684 /* WLAN_REASON_MESH_PEERING_CANCELLED = 52 */
685 connman_mesh_remove_connected_peer(data->peer_address, 52);
689 data->callback(result, data->user_data);
691 g_free(data->peer_address);
696 static int mesh_change_peer_status(const char *peer_address,
697 enum connman_mesh_peer_status status,
698 mesh_change_peer_status_cb_t callback, void *user_data)
701 struct wifi_data *wifi;
702 struct wifi_mesh_info *mesh_info;
703 bool mesh_if_found = false;
704 GSupplicantInterface *interface;
705 struct mesh_change_peer_status_info *data;
708 for (list = iface_list; list; list = list->next) {
711 if (wifi->mesh_interface) {
712 mesh_if_found = true;
717 if (!mesh_if_found) {
718 DBG("Mesh interface is not created");
722 mesh_info = wifi->mesh_info;
724 interface = mesh_info->interface;
727 case CONNMAN_MESH_PEER_ADD:
728 method = "MeshPeerAdd";
730 case CONNMAN_MESH_PEER_REMOVE:
731 method = "MeshPeerRemove";
734 DBG("Invalid method");
738 data = g_try_malloc0(sizeof(struct mesh_change_peer_status_info));
740 DBG("Memory allocation failed");
744 data->peer_address = g_strdup(peer_address);
745 data->peer_status = status;
746 data->callback = callback;
747 data->user_data = user_data;
749 return g_supplicant_interface_mesh_peer_change_status(interface,
750 mesh_peer_change_status_callback, peer_address, method,
754 static struct connman_mesh_driver mesh_driver = {
755 .add_interface = add_mesh_interface,
756 .remove_interface = remove_mesh_interface,
757 .connect = mesh_peer_connect,
758 .disconnect = mesh_peer_disconnect,
759 .change_peer_status = mesh_change_peer_status,
762 static void mesh_support(GSupplicantInterface *interface)
766 if (!g_supplicant_interface_has_mesh(interface))
769 if (connman_technology_driver_register(&mesh_tech_driver) < 0) {
770 DBG("Could not register Mesh technology driver");
774 connman_mesh_driver_register(&mesh_driver);
777 static void check_mesh_technology(void)
779 bool mesh_exists = false;
782 for (list = iface_list; list; list = list->next) {
783 struct wifi_data *w = list->data;
786 g_supplicant_interface_has_mesh(w->interface))
791 connman_technology_driver_unregister(&mesh_tech_driver);
792 connman_mesh_driver_unregister(&mesh_driver);
796 static void mesh_group_started(GSupplicantInterface *interface)
798 struct wifi_data *wifi;
799 struct wifi_mesh_info *mesh_info;
800 struct connman_mesh *mesh;
801 const unsigned char *ssid;
802 unsigned int ssid_len;
805 ssid = g_supplicant_interface_get_mesh_group_ssid(interface, &ssid_len);
806 memcpy(name, ssid, ssid_len);
807 name[ssid_len] = '\0';
808 DBG("name %s", name);
809 wifi = g_supplicant_interface_get_data(interface);
810 DBG("wifi %p", wifi);
815 mesh_info = wifi->mesh_info;
819 mesh = mesh_info->mesh;
823 connman_mesh_peer_set_state(mesh, CONNMAN_MESH_STATE_CONFIGURATION);
826 static void mesh_group_removed(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;
833 int disconnect_reason;
836 ssid = g_supplicant_interface_get_mesh_group_ssid(interface, &ssid_len);
837 memcpy(name, ssid, ssid_len);
838 name[ssid_len] = '\0';
839 DBG("name %s", name);
841 disconnect_reason = g_supplicant_mesh_get_disconnect_reason(interface);
842 DBG("Disconnect Reason %d", disconnect_reason);
844 wifi = g_supplicant_interface_get_data(interface);
845 DBG("wifi %p", wifi);
850 mesh_info = wifi->mesh_info;
854 mesh = connman_get_connected_mesh_from_name(name);
856 DBG("%s is not connected", name);
857 mesh = connman_get_connecting_mesh_from_name(name);
859 DBG("%s is not connecting", name);
864 connman_mesh_peer_set_disconnect_reason(mesh, disconnect_reason);
865 connman_mesh_peer_set_state(mesh, CONNMAN_MESH_STATE_DISCONNECT);
868 static void mesh_peer_connected(GSupplicantMeshPeer *mesh_peer)
870 const char *peer_address;
872 peer_address = g_supplicant_mesh_peer_get_address(mesh_peer);
877 DBG("Peer %s connected", peer_address);
878 connman_mesh_add_connected_peer(peer_address);
881 static void mesh_peer_disconnected(GSupplicantMeshPeer *mesh_peer)
883 const char *peer_address;
886 peer_address = g_supplicant_mesh_peer_get_address(mesh_peer);
891 reason = g_supplicant_mesh_peer_get_disconnect_reason(mesh_peer);
893 DBG("Peer %s disconnected with reason %d", peer_address, reason);
894 connman_mesh_remove_connected_peer(peer_address, reason);
898 static struct wifi_data *get_pending_wifi_data(const char *ifname)
902 for (list = pending_wifi_device; list; list = list->next) {
903 struct wifi_data *wifi;
904 const char *dev_name;
907 if (!wifi || !wifi->device)
910 dev_name = connman_device_get_string(wifi->device, "Interface");
911 if (!g_strcmp0(ifname, dev_name)) {
912 pending_wifi_device = g_list_delete_link(
913 pending_wifi_device, list);
921 static void remove_pending_wifi_device(struct wifi_data *wifi)
925 link = g_list_find(pending_wifi_device, wifi);
930 pending_wifi_device = g_list_delete_link(pending_wifi_device, link);
933 static void peer_cancel_timeout(struct wifi_data *wifi)
935 if (wifi->p2p_connection_timeout > 0)
936 g_source_remove(wifi->p2p_connection_timeout);
938 wifi->p2p_connection_timeout = 0;
939 wifi->p2p_connecting = false;
941 if (wifi->pending_peer) {
942 connman_peer_unref(wifi->pending_peer);
943 wifi->pending_peer = NULL;
947 static gboolean peer_connect_timeout(gpointer data)
949 struct wifi_data *wifi = data;
953 if (wifi->p2p_connecting) {
954 enum connman_peer_state state = CONNMAN_PEER_STATE_FAILURE;
955 GSupplicantPeer *gs_peer =
956 g_supplicant_interface_peer_lookup(wifi->interface,
957 connman_peer_get_identifier(wifi->pending_peer));
959 if (g_supplicant_peer_has_requested_connection(gs_peer))
960 state = CONNMAN_PEER_STATE_IDLE;
962 connman_peer_set_state(wifi->pending_peer, state);
965 peer_cancel_timeout(wifi);
970 static void peer_connect_callback(int result, GSupplicantInterface *interface,
973 struct wifi_data *wifi = user_data;
974 struct connman_peer *peer = wifi->pending_peer;
976 DBG("peer %p - %d", peer, result);
982 peer_connect_timeout(wifi);
986 connman_peer_set_state(peer, CONNMAN_PEER_STATE_ASSOCIATION);
988 wifi->p2p_connection_timeout = g_timeout_add_seconds(
989 P2P_CONNECTION_TIMEOUT,
990 peer_connect_timeout, wifi);
993 static int peer_connect(struct connman_peer *peer,
994 enum connman_peer_wps_method wps_method,
997 struct connman_device *device = connman_peer_get_device(peer);
998 GSupplicantPeerParams *peer_params;
999 GSupplicantPeer *gs_peer;
1000 struct wifi_data *wifi;
1004 DBG("peer %p", peer);
1009 wifi = connman_device_get_data(device);
1010 if (!wifi || !wifi->interface)
1013 if (wifi->p2p_connecting)
1016 gs_peer = g_supplicant_interface_peer_lookup(wifi->interface,
1017 connman_peer_get_identifier(peer));
1021 pbc = g_supplicant_peer_is_wps_pbc(gs_peer);
1022 pin = g_supplicant_peer_is_wps_pin(gs_peer);
1024 switch (wps_method) {
1025 case CONNMAN_PEER_WPS_UNKNOWN:
1026 if ((pbc && pin) || pin)
1029 case CONNMAN_PEER_WPS_PBC:
1034 case CONNMAN_PEER_WPS_PIN:
1035 if (!pin || !wps_pin)
1040 peer_params = g_try_malloc0(sizeof(GSupplicantPeerParams));
1044 peer_params->path = g_strdup(g_supplicant_peer_get_path(gs_peer));
1046 peer_params->wps_pin = g_strdup(wps_pin);
1048 peer_params->master = connman_peer_service_is_master();
1050 ret = g_supplicant_interface_p2p_connect(wifi->interface, peer_params,
1051 peer_connect_callback, wifi);
1052 if (ret == -EINPROGRESS) {
1053 wifi->pending_peer = connman_peer_ref(peer);
1054 wifi->p2p_connecting = true;
1055 } else if (ret < 0) {
1056 g_free(peer_params->path);
1057 g_free(peer_params->wps_pin);
1058 g_free(peer_params);
1064 static int peer_disconnect(struct connman_peer *peer)
1066 struct connman_device *device = connman_peer_get_device(peer);
1067 GSupplicantPeerParams peer_params = {};
1068 GSupplicantPeer *gs_peer;
1069 struct wifi_data *wifi;
1072 DBG("peer %p", peer);
1077 wifi = connman_device_get_data(device);
1081 gs_peer = g_supplicant_interface_peer_lookup(wifi->interface,
1082 connman_peer_get_identifier(peer));
1086 peer_params.path = g_strdup(g_supplicant_peer_get_path(gs_peer));
1088 ret = g_supplicant_interface_p2p_disconnect(wifi->interface,
1090 g_free(peer_params.path);
1092 if (ret == -EINPROGRESS) {
1093 peer_cancel_timeout(wifi);
1094 wifi->p2p_device = false;
1100 struct peer_service_registration {
1101 peer_service_registration_cb_t callback;
1105 static bool is_service_wfd(const unsigned char *specs, int length)
1107 if (length < 9 || specs[0] != 0 || specs[1] != 0 || specs[2] != 6)
1113 static void apply_p2p_listen_on_iface(gpointer data, gpointer user_data)
1115 struct wifi_data *wifi = data;
1117 if (!wifi->interface ||
1118 !g_supplicant_interface_has_p2p(wifi->interface))
1121 if (!wifi->servicing) {
1122 g_supplicant_interface_p2p_listen(wifi->interface,
1123 P2P_LISTEN_PERIOD, P2P_LISTEN_INTERVAL);
1129 static void register_wfd_service_cb(int result,
1130 GSupplicantInterface *iface, void *user_data)
1132 struct peer_service_registration *reg_data = user_data;
1137 g_list_foreach(iface_list, apply_p2p_listen_on_iface, NULL);
1139 if (reg_data && reg_data->callback) {
1140 reg_data->callback(result, reg_data->user_data);
1145 static GSupplicantP2PServiceParams *fill_in_peer_service_params(
1146 const unsigned char *spec,
1147 int spec_length, const unsigned char *query,
1148 int query_length, int version)
1150 GSupplicantP2PServiceParams *params;
1152 params = g_try_malloc0(sizeof(GSupplicantP2PServiceParams));
1157 params->version = version;
1158 if (spec_length > 0) {
1159 params->service = g_malloc(spec_length);
1160 memcpy(params->service, spec, spec_length);
1162 } else if (query_length > 0 && spec_length > 0) {
1163 params->query = g_malloc(query_length);
1164 memcpy(params->query, query, query_length);
1165 params->query_length = query_length;
1167 params->response = g_malloc(spec_length);
1168 memcpy(params->response, spec, spec_length);
1169 params->response_length = spec_length;
1171 if (spec_length > 0) {
1172 params->wfd_ies = g_malloc(spec_length);
1173 memcpy(params->wfd_ies, spec, spec_length);
1175 params->wfd_ies_length = spec_length;
1181 static void free_peer_service_params(GSupplicantP2PServiceParams *params)
1186 g_free(params->service);
1187 g_free(params->query);
1188 g_free(params->response);
1189 g_free(params->wfd_ies);
1194 static int peer_register_wfd_service(const unsigned char *specification,
1195 int specification_length,
1196 peer_service_registration_cb_t callback,
1199 struct peer_service_registration *reg_data = NULL;
1200 static GSupplicantP2PServiceParams *params;
1205 if (wfd_service_registered)
1208 params = fill_in_peer_service_params(specification,
1209 specification_length, NULL, 0, 0);
1213 reg_data = g_try_malloc0(sizeof(*reg_data));
1219 reg_data->callback = callback;
1220 reg_data->user_data = user_data;
1222 ret = g_supplicant_set_widi_ies(params,
1223 register_wfd_service_cb, reg_data);
1224 if (ret < 0 && ret != -EINPROGRESS)
1227 wfd_service_registered = true;
1231 free_peer_service_params(params);
1237 static void register_peer_service_cb(int result,
1238 GSupplicantInterface *iface, void *user_data)
1240 struct wifi_data *wifi = g_supplicant_interface_get_data(iface);
1241 struct peer_service_registration *reg_data = user_data;
1243 #if defined TIZEN_EXT
1251 apply_p2p_listen_on_iface(wifi, NULL);
1253 if (reg_data->callback)
1254 reg_data->callback(result, reg_data->user_data);
1259 static int peer_register_service(const unsigned char *specification,
1260 int specification_length,
1261 const unsigned char *query,
1262 int query_length, int version,
1263 peer_service_registration_cb_t callback,
1266 struct peer_service_registration *reg_data;
1267 GSupplicantP2PServiceParams *params;
1274 if (specification && !version && !query &&
1275 is_service_wfd(specification, specification_length)) {
1276 return peer_register_wfd_service(specification,
1277 specification_length, callback, user_data);
1280 reg_data = g_try_malloc0(sizeof(*reg_data));
1284 reg_data->callback = callback;
1285 reg_data->user_data = user_data;
1287 ret_f = -EOPNOTSUPP;
1289 for (list = iface_list; list; list = list->next) {
1290 struct wifi_data *wifi = list->data;
1291 GSupplicantInterface *iface = wifi->interface;
1293 if (!g_supplicant_interface_has_p2p(iface))
1296 params = fill_in_peer_service_params(specification,
1297 specification_length, query,
1298 query_length, version);
1303 ret_f = g_supplicant_interface_p2p_add_service(iface,
1304 register_peer_service_cb, params, reg_data);
1305 if (ret_f == 0 || ret_f == -EINPROGRESS)
1309 ret = g_supplicant_interface_p2p_add_service(iface,
1310 register_peer_service_cb, params, NULL);
1311 if (ret != 0 && ret != -EINPROGRESS)
1312 free_peer_service_params(params);
1315 if (ret_f != 0 && ret_f != -EINPROGRESS)
1321 static int peer_unregister_wfd_service(void)
1323 GSupplicantP2PServiceParams *params;
1326 if (!wfd_service_registered)
1329 params = fill_in_peer_service_params(NULL, 0, NULL, 0, 0);
1333 wfd_service_registered = false;
1335 g_supplicant_set_widi_ies(params, NULL, NULL);
1337 for (list = iface_list; list; list = list->next) {
1338 struct wifi_data *wifi = list->data;
1340 if (!g_supplicant_interface_has_p2p(wifi->interface))
1344 if (!wifi->servicing || wifi->servicing < 0) {
1345 g_supplicant_interface_p2p_listen(wifi->interface,
1347 wifi->servicing = 0;
1354 static int peer_unregister_service(const unsigned char *specification,
1355 int specification_length,
1356 const unsigned char *query,
1357 int query_length, int version)
1359 GSupplicantP2PServiceParams *params;
1364 if (specification && !version && !query &&
1365 is_service_wfd(specification, specification_length)) {
1366 ret = peer_unregister_wfd_service();
1367 if (ret != 0 && ret != -EINPROGRESS)
1372 for (list = iface_list; list; list = list->next) {
1373 struct wifi_data *wifi = list->data;
1374 GSupplicantInterface *iface = wifi->interface;
1377 goto stop_listening;
1379 if (!g_supplicant_interface_has_p2p(iface))
1382 params = fill_in_peer_service_params(specification,
1383 specification_length, query,
1384 query_length, version);
1388 ret = g_supplicant_interface_p2p_del_service(iface, params);
1389 if (ret != 0 && ret != -EINPROGRESS)
1390 free_peer_service_params(params);
1393 if (!wifi->servicing || wifi->servicing < 0) {
1394 g_supplicant_interface_p2p_listen(iface, 0, 0);
1395 wifi->servicing = 0;
1402 static struct connman_peer_driver peer_driver = {
1403 .connect = peer_connect,
1404 .disconnect = peer_disconnect,
1405 .register_service = peer_register_service,
1406 .unregister_service = peer_unregister_service,
1409 static void handle_tethering(struct wifi_data *wifi)
1411 if (!wifi->tethering)
1420 DBG("index %d bridge %s", wifi->index, wifi->bridge);
1422 if (connman_inet_add_to_bridge(wifi->index, wifi->bridge) < 0)
1425 wifi->bridged = true;
1428 static void wifi_newlink(unsigned flags, unsigned change, void *user_data)
1430 struct connman_device *device = user_data;
1431 struct wifi_data *wifi = connman_device_get_data(device);
1436 DBG("index %d flags %d change %d", wifi->index, flags, change);
1438 if ((wifi->flags & IFF_UP) != (flags & IFF_UP)) {
1440 DBG("interface up");
1442 DBG("interface down");
1445 if ((wifi->flags & IFF_LOWER_UP) != (flags & IFF_LOWER_UP)) {
1446 if (flags & IFF_LOWER_UP)
1452 if (flags & IFF_LOWER_UP)
1453 handle_tethering(wifi);
1455 wifi->flags = flags;
1458 static int wifi_probe(struct connman_device *device)
1460 struct wifi_data *wifi;
1462 DBG("device %p", device);
1464 wifi = g_try_new0(struct wifi_data, 1);
1468 wifi->state = G_SUPPLICANT_STATE_INACTIVE;
1469 wifi->ap_supported = WIFI_AP_UNKNOWN;
1470 wifi->tethering_param = NULL;
1472 connman_device_set_data(device, wifi);
1473 wifi->device = connman_device_ref(device);
1475 wifi->index = connman_device_get_index(device);
1478 wifi->watch = connman_rtnl_add_newlink_watch(wifi->index,
1479 wifi_newlink, device);
1480 if (is_p2p_connecting())
1481 add_pending_wifi_device(wifi);
1483 iface_list = g_list_append(iface_list, wifi);
1488 static void remove_networks(struct connman_device *device,
1489 struct wifi_data *wifi)
1493 for (list = wifi->networks; list; list = list->next) {
1494 struct connman_network *network = list->data;
1496 connman_device_remove_network(device, network);
1497 connman_network_unref(network);
1500 g_slist_free(wifi->networks);
1501 wifi->networks = NULL;
1504 static void remove_peers(struct wifi_data *wifi)
1508 for (list = wifi->peers; list; list = list->next) {
1509 struct connman_peer *peer = list->data;
1511 connman_peer_unregister(peer);
1512 connman_peer_unref(peer);
1515 g_slist_free(wifi->peers);
1519 static void reset_autoscan(struct connman_device *device)
1521 struct wifi_data *wifi = connman_device_get_data(device);
1522 struct autoscan_params *autoscan;
1526 if (!wifi || !wifi->autoscan)
1529 autoscan = wifi->autoscan;
1531 autoscan->interval = 0;
1533 if (autoscan->timeout == 0)
1536 g_source_remove(autoscan->timeout);
1537 autoscan->timeout = 0;
1539 connman_device_unref(device);
1542 static void stop_autoscan(struct connman_device *device)
1544 const struct wifi_data *wifi = connman_device_get_data(device);
1546 if (!wifi || !wifi->autoscan)
1549 reset_autoscan(device);
1551 connman_device_set_scanning(device, CONNMAN_SERVICE_TYPE_WIFI, false);
1554 static void check_p2p_technology(void)
1556 bool p2p_exists = false;
1559 for (list = iface_list; list; list = list->next) {
1560 struct wifi_data *w = list->data;
1563 g_supplicant_interface_has_p2p(w->interface))
1568 connman_technology_driver_unregister(&p2p_tech_driver);
1569 connman_peer_driver_unregister(&peer_driver);
1573 struct last_connected {
1579 static gint sort_entry(gconstpointer a, gconstpointer b, gpointer user_data)
1581 GTimeVal *aval = (GTimeVal *)a;
1582 GTimeVal *bval = (GTimeVal *)b;
1584 /* Note that the sort order is descending */
1585 if (aval->tv_sec < bval->tv_sec)
1588 if (aval->tv_sec > bval->tv_sec)
1594 static void free_entry(gpointer data)
1596 struct last_connected *entry = data;
1598 g_free(entry->ssid);
1602 static void wifi_remove(struct connman_device *device)
1604 struct wifi_data *wifi = connman_device_get_data(device);
1606 DBG("device %p wifi %p", device, wifi);
1611 stop_autoscan(device);
1613 if (wifi->p2p_device)
1614 p2p_iface_list = g_list_remove(p2p_iface_list, wifi);
1616 iface_list = g_list_remove(iface_list, wifi);
1618 check_p2p_technology();
1619 #if defined TIZEN_EXT_WIFI_MESH
1620 check_mesh_technology();
1623 remove_pending_wifi_device(wifi);
1625 if (connman_device_get_scanning(device, CONNMAN_SERVICE_TYPE_P2P)) {
1626 g_source_remove(wifi->p2p_find_timeout);
1627 connman_device_unref(wifi->device);
1630 if (wifi->p2p_connection_timeout)
1631 g_source_remove(wifi->p2p_connection_timeout);
1633 #if defined TIZEN_EXT
1634 if (wifi->automaxspeed_timeout != 0) {
1635 g_source_remove(wifi->automaxspeed_timeout);
1636 wifi->automaxspeed_timeout = 0;
1640 remove_networks(device, wifi);
1643 connman_device_set_powered(device, false);
1644 connman_device_set_data(device, NULL);
1645 connman_device_unref(wifi->device);
1646 connman_rtnl_remove_watch(wifi->watch);
1648 g_supplicant_interface_set_data(wifi->interface, NULL);
1650 g_supplicant_interface_cancel(wifi->interface);
1652 if (wifi->scan_params)
1653 g_supplicant_free_scan_params(wifi->scan_params);
1654 #if defined TIZEN_EXT
1655 if (wifi->hidden_scan_params) {
1656 while (wifi->hidden_scan_params->ssids) {
1657 struct scan_ssid *ssid;
1658 ssid = wifi->hidden_scan_params->ssids->data;
1659 wifi->hidden_scan_params->ssids = g_slist_remove(wifi->hidden_scan_params->ssids, ssid);
1661 g_supplicant_free_scan_params(wifi->hidden_scan_params);
1665 g_free(wifi->autoscan);
1666 g_free(wifi->identifier);
1670 static bool is_duplicate(GSList *list, gchar *ssid, int ssid_len)
1674 for (iter = list; iter; iter = g_slist_next(iter)) {
1675 struct scan_ssid *scan_ssid = iter->data;
1677 if (ssid_len == scan_ssid->ssid_len &&
1678 memcmp(ssid, scan_ssid->ssid, ssid_len) == 0)
1685 static int add_scan_param(gchar *hex_ssid, char *raw_ssid, int ssid_len,
1686 int freq, GSupplicantScanParams *scan_data,
1687 int driver_max_scan_ssids, char *ssid_name)
1690 struct scan_ssid *scan_ssid;
1692 if ((driver_max_scan_ssids == 0 ||
1693 driver_max_scan_ssids > scan_data->num_ssids) &&
1694 (hex_ssid || raw_ssid)) {
1696 unsigned int j = 0, hex;
1699 size_t hex_ssid_len = strlen(hex_ssid);
1701 ssid = g_try_malloc0(hex_ssid_len / 2);
1705 for (i = 0; i < hex_ssid_len; i += 2) {
1706 sscanf(hex_ssid + i, "%02x", &hex);
1715 * If we have already added hidden AP to the list,
1716 * then do not do it again. This might happen if you have
1717 * used or are using multiple wifi cards, so in that case
1718 * you might have multiple service files for same AP.
1720 if (is_duplicate(scan_data->ssids, ssid, j)) {
1726 scan_ssid = g_try_new(struct scan_ssid, 1);
1733 memcpy(scan_ssid->ssid, ssid, j);
1734 scan_ssid->ssid_len = j;
1735 scan_data->ssids = g_slist_prepend(scan_data->ssids,
1738 scan_data->num_ssids++;
1740 DBG("SSID %s added to scanned list of %d entries", ssid_name,
1741 scan_data->num_ssids);
1748 scan_data->ssids = g_slist_reverse(scan_data->ssids);
1750 if (!scan_data->freqs) {
1751 scan_data->freqs = g_try_malloc0(sizeof(uint16_t));
1752 if (!scan_data->freqs) {
1753 g_slist_free_full(scan_data->ssids, g_free);
1757 scan_data->num_freqs = 1;
1758 scan_data->freqs[0] = freq;
1760 bool duplicate = false;
1762 /* Don't add duplicate entries */
1763 for (i = 0; i < scan_data->num_freqs; i++) {
1764 if (scan_data->freqs[i] == freq) {
1771 scan_data->num_freqs++;
1772 scan_data->freqs = g_try_realloc(scan_data->freqs,
1773 sizeof(uint16_t) * scan_data->num_freqs);
1774 if (!scan_data->freqs) {
1775 g_slist_free_full(scan_data->ssids, g_free);
1778 scan_data->freqs[scan_data->num_freqs - 1] = freq;
1785 static int get_hidden_connections(GSupplicantScanParams *scan_data)
1787 struct connman_config_entry **entries;
1789 #if defined TIZEN_EXT
1790 gchar **services = NULL;
1793 #endif /* defined TIZEN_EXT */
1797 int num_ssids = 0, add_param_failed = 0;
1798 #if defined TIZEN_EXT
1799 GSequenceIter *iter;
1800 GSequence *latest_list;
1801 struct last_connected *entry;
1804 latest_list = g_sequence_new(free_entry);
1808 services = connman_storage_get_services();
1809 for (i = 0; services && services[i]; i++) {
1810 if (strncmp(services[i], "wifi_", 5) != 0)
1813 keyfile = connman_storage_load_service(services[i]);
1817 value = g_key_file_get_boolean(keyfile,
1818 services[i], "Hidden", NULL);
1820 g_key_file_free(keyfile);
1824 value = g_key_file_get_boolean(keyfile,
1825 services[i], "Favorite", NULL);
1827 g_key_file_free(keyfile);
1831 #if defined TIZEN_EXT
1832 value = g_key_file_get_boolean(keyfile,
1833 services[i], "AutoConnect", NULL);
1835 g_key_file_free(keyfile);
1839 gchar *str = g_key_file_get_string(keyfile,
1840 services[i], "Modified", NULL);
1842 g_key_file_free(keyfile);
1845 g_time_val_from_iso8601(str, &modified);
1849 ssid = g_key_file_get_string(keyfile,
1850 services[i], "SSID", NULL);
1852 name = g_key_file_get_string(keyfile, services[i], "Name",
1855 #if defined TIZEN_EXT
1856 entry = g_try_new(struct last_connected, 1);
1858 g_sequence_free(latest_list);
1861 g_key_file_free(keyfile);
1865 entry->modified = modified;
1868 g_sequence_insert_sorted(latest_list, entry,
1871 ret = add_scan_param(ssid, NULL, 0, 0, scan_data, 0, name);
1880 g_key_file_free(keyfile);
1883 #if defined TIZEN_EXT
1884 gint length = g_sequence_get_length(latest_list);
1885 iter = g_sequence_get_begin_iter(latest_list);
1887 for (i = 0; i < length; i++) {
1888 entry = g_sequence_get(iter);
1890 ret = add_scan_param(entry->ssid, NULL, 0, 0, scan_data, 0, entry->ssid);
1896 iter = g_sequence_iter_next(iter);
1899 g_sequence_free(latest_list);
1903 * Check if there are any hidden AP that needs to be provisioned.
1905 entries = connman_config_get_entries("wifi");
1906 for (i = 0; entries && entries[i]; i++) {
1909 if (!entries[i]->hidden)
1912 if (!entries[i]->ssid) {
1913 ssid = entries[i]->name;
1916 ssid = entries[i]->ssid;
1917 len = entries[i]->ssid_len;
1923 ret = add_scan_param(NULL, ssid, len, 0, scan_data, 0, ssid);
1930 connman_config_free_entries(entries);
1932 if (add_param_failed > 0)
1933 DBG("Unable to scan %d out of %d SSIDs",
1934 add_param_failed, num_ssids);
1936 g_strfreev(services);
1941 static int get_hidden_connections_params(struct wifi_data *wifi,
1942 GSupplicantScanParams *scan_params)
1944 int driver_max_ssids, i;
1945 GSupplicantScanParams *orig_params;
1948 * Scan hidden networks so that we can autoconnect to them.
1949 * We will assume 1 as a default number of ssid to scan.
1951 driver_max_ssids = g_supplicant_interface_get_max_scan_ssids(
1953 if (driver_max_ssids == 0)
1954 driver_max_ssids = 1;
1956 DBG("max ssids %d", driver_max_ssids);
1958 #if defined TIZEN_EXT
1959 if (!wifi->hidden_scan_params) {
1960 wifi->hidden_scan_params = g_try_malloc0(sizeof(GSupplicantScanParams));
1961 if (!wifi->hidden_scan_params)
1964 if (get_hidden_connections(wifi->hidden_scan_params) == 0) {
1965 g_supplicant_free_scan_params(wifi->hidden_scan_params);
1966 wifi->hidden_scan_params = NULL;
1972 orig_params = wifi->hidden_scan_params;
1974 if (!wifi->scan_params) {
1975 wifi->scan_params = g_try_malloc0(sizeof(GSupplicantScanParams));
1976 if (!wifi->scan_params)
1979 if (get_hidden_connections(wifi->scan_params) == 0) {
1980 g_supplicant_free_scan_params(wifi->scan_params);
1981 wifi->scan_params = NULL;
1987 orig_params = wifi->scan_params;
1990 /* Let's transfer driver_max_ssids params */
1991 for (i = 0; i < driver_max_ssids; i++) {
1992 struct scan_ssid *ssid;
1994 #if defined TIZEN_EXT
1995 if (!wifi->hidden_scan_params->ssids)
1997 if (!wifi->scan_params->ssids)
2001 ssid = orig_params->ssids->data;
2002 orig_params->ssids = g_slist_remove(orig_params->ssids, ssid);
2003 scan_params->ssids = g_slist_prepend(scan_params->ssids, ssid);
2007 scan_params->num_ssids = i;
2008 scan_params->ssids = g_slist_reverse(scan_params->ssids);
2010 if (orig_params->num_freqs <= 0)
2013 scan_params->freqs =
2014 g_malloc(sizeof(uint16_t) * orig_params->num_freqs);
2015 memcpy(scan_params->freqs, orig_params->freqs,
2016 sizeof(uint16_t) *orig_params->num_freqs);
2018 scan_params->num_freqs = orig_params->num_freqs;
2023 orig_params->num_ssids -= scan_params->num_ssids;
2025 return scan_params->num_ssids;
2028 g_slist_free_full(scan_params->ssids, g_free);
2029 #if defined TIZEN_EXT
2030 g_supplicant_free_scan_params(wifi->hidden_scan_params);
2031 wifi->hidden_scan_params = NULL;
2033 g_supplicant_free_scan_params(wifi->scan_params);
2034 wifi->scan_params = NULL;
2040 static int throw_wifi_scan(struct connman_device *device,
2041 GSupplicantInterfaceCallback callback)
2043 struct wifi_data *wifi = connman_device_get_data(device);
2049 DBG("device %p %p", device, wifi->interface);
2051 if (wifi->tethering)
2054 #if defined TIZEN_EXT
2055 if (connman_device_get_scanning(device, CONNMAN_SERVICE_TYPE_WIFI)
2056 && !wifi->allow_full_scan)
2058 if (connman_device_get_scanning(device, CONNMAN_SERVICE_TYPE_WIFI))
2062 connman_device_ref(device);
2064 ret = g_supplicant_interface_scan(wifi->interface, NULL,
2067 connman_device_set_scanning(device,
2068 CONNMAN_SERVICE_TYPE_WIFI, true);
2070 connman_device_unref(device);
2075 static void hidden_free(struct hidden_params *hidden)
2080 if (hidden->scan_params)
2081 g_supplicant_free_scan_params(hidden->scan_params);
2082 g_free(hidden->identity);
2083 g_free(hidden->passphrase);
2084 g_free(hidden->security);
2088 #if defined TIZEN_EXT
2089 static void service_state_changed(struct connman_service *service,
2090 enum connman_service_state state);
2092 static int network_connect(struct connman_network *network);
2094 static struct connman_notifier notifier = {
2096 .priority = CONNMAN_NOTIFIER_PRIORITY_DEFAULT,
2097 .service_state_changed = service_state_changed,
2100 static void service_state_changed(struct connman_service *service,
2101 enum connman_service_state state)
2103 enum connman_service_type type;
2105 type = connman_service_get_type(service);
2106 if (type != CONNMAN_SERVICE_TYPE_WIFI)
2109 DBG("service %p state %d", service, state);
2112 case CONNMAN_SERVICE_STATE_READY:
2113 case CONNMAN_SERVICE_STATE_ONLINE:
2114 case CONNMAN_SERVICE_STATE_FAILURE:
2115 connman_notifier_unregister(¬ifier);
2116 is_wifi_notifier_registered = FALSE;
2118 __connman_device_request_scan(type);
2126 static gboolean need_bss_transition(uint16_t freq, int snr, int strength)
2129 * Since bssid->strength is a positive value,
2130 * it need to be changed to its original value.
2132 int signal = strength - 120;
2135 * If the currently connected AP matches the following conditions,
2136 * scan for BSS transition is started.
2137 * - SNR is less than 20 or RSSI level is less than 3
2139 if (snr < 20 && snr != 0)
2141 else if (freq > 4900 && signal <= RSSI_LEVEL_2_5G)
2143 else if (freq <= 4900 && signal <= RSSI_LEVEL_2_24G)
2149 static gboolean check_bss_condition(uint16_t freq, int snr, uint16_t strength)
2152 * Since bssid->strength is a positive value,
2153 * it need to be changed to its original value.
2155 int signal = strength - 120;
2158 * If the AP that matches the following conditions exists in the SCAN result,
2159 * BSS transition is started.
2160 * - SNR is 25 or more and RSSI level is greater than 3
2162 if (snr < 25 && snr != 0)
2165 if (freq > 4900 && signal > RSSI_LEVEL_3_5G)
2167 else if (freq <= 4900 && signal > RSSI_LEVEL_3_24G)
2173 static void scan_callback_hidden(int result,
2174 GSupplicantInterface *interface, void *user_data);
2176 static int network_disconnect(struct connman_network *network);
2178 static void start_roaming(struct wifi_data *wifi)
2180 bool roaming_ap_found = false;
2181 GSList *bssid_list = NULL;
2183 if (!wifi || !wifi->network)
2186 if (connman_setting_get_bool("WifiRoaming")) {
2187 struct connman_network *network = wifi->network;
2188 bssid_list = connman_network_get_bssid_list(network);
2190 if (g_slist_length(bssid_list) <= 1)
2193 if (!connman_network_get_connected(network))
2196 if (connman_network_get_bool(network, "WiFi.Roaming"))
2199 if (!need_bss_transition(
2200 connman_network_get_frequency(network),
2201 connman_network_get_snr(network),
2202 connman_network_get_strength(network)))
2205 for (bssid_list; bssid_list; bssid_list = bssid_list->next) {
2206 struct g_connman_bssids *bssid = bssid_list->data;
2208 if (check_bss_condition(bssid->frequency,
2209 bssid->score_snr, bssid->strength))
2210 roaming_ap_found = true;
2213 if (roaming_ap_found) {
2214 char bssid_buff[WIFI_BSSID_STR_LEN] = {0,};
2215 char *bssid_str = bssid_buff;
2216 unsigned char *bssid;
2218 bssid = connman_network_get_bssid(network);
2219 snprintf(bssid_str, WIFI_BSSID_STR_LEN, MACSTR, MAC2STR(bssid));
2220 connman_network_set_string(network,
2221 "WiFi.RoamingCurBSSID", bssid_str);
2223 network_disconnect(network);
2224 wifi->pending_network = network;
2225 connman_network_set_bool(network, "WiFi.Roaming", true);
2232 static void scan_callback(int result, GSupplicantInterface *interface,
2235 struct connman_device *device = user_data;
2236 struct wifi_data *wifi = connman_device_get_data(device);
2238 #if defined TIZEN_EXT
2239 GSList *list = NULL;
2240 bool favorite_exists = false;
2241 struct connman_network *network = NULL;
2242 struct connman_service *service = NULL;
2245 DBG("result %d wifi %p", result, wifi);
2248 if (wifi->hidden && !wifi->postpone_hidden) {
2249 connman_network_clear_hidden(wifi->hidden->user_data);
2250 hidden_free(wifi->hidden);
2251 wifi->hidden = NULL;
2254 if (wifi->scan_params) {
2255 g_supplicant_free_scan_params(wifi->scan_params);
2256 wifi->scan_params = NULL;
2259 #if defined TIZEN_EXT
2260 if (wifi->hidden_scan_params && !wifi->hidden_scan_params->ssids) {
2261 g_supplicant_free_scan_params(wifi->hidden_scan_params);
2262 wifi->hidden_scan_params = NULL;
2268 connman_device_reset_scanning(device);
2270 /* User is connecting to a hidden AP, let's wait for finished event */
2271 if (wifi && wifi->hidden && wifi->postpone_hidden) {
2272 GSupplicantScanParams *scan_params;
2275 wifi->postpone_hidden = false;
2276 scan_params = wifi->hidden->scan_params;
2277 wifi->hidden->scan_params = NULL;
2279 reset_autoscan(device);
2281 ret = g_supplicant_interface_scan(wifi->interface, scan_params,
2282 scan_callback, device);
2286 /* On error, let's recall scan_callback, which will cleanup */
2287 return scan_callback(ret, interface, user_data);
2290 #if defined TIZEN_EXT
2292 for (list = wifi->networks; list; list = list->next) {
2293 network = list->data;
2294 service = connman_service_lookup_from_network(network);
2296 if (service != NULL &&
2297 (connman_service_get_favorite(service) == true) &&
2298 (connman_service_get_autoconnect(service) == true)) {
2299 DBG("Favorite service exists [%s]",
2300 connman_network_get_string(network, "Name"));
2301 favorite_exists = true;
2307 if (favorite_exists == false) {
2308 if (wifi && wifi->allow_full_scan) {
2310 DBG("Trigger full channel scan");
2311 wifi->allow_full_scan = false;
2313 ret = g_supplicant_interface_scan(wifi->interface, NULL,
2314 scan_callback_hidden, device);
2318 /* On error, let's recall scan_callback, which will cleanup */
2319 return scan_callback(ret, interface, user_data);
2322 wifi->allow_full_scan = false;
2325 scanning = connman_device_get_scanning(device, CONNMAN_SERVICE_TYPE_WIFI);
2328 connman_device_set_scanning(device,
2329 CONNMAN_SERVICE_TYPE_WIFI, false);
2332 if (result != -ENOLINK)
2333 #if defined TIZEN_EXT
2336 start_autoscan(device);
2339 * If we are here then we were scanning; however, if we are
2340 * also mid-flight disabling the interface, then wifi_disable
2341 * has already cleared the device scanning state and
2342 * unreferenced the device, obviating the need to do it here.
2346 connman_device_unref(device);
2348 #if defined TIZEN_EXT
2352 if (wifi->scan_pending_network && result != -EIO) {
2353 network_connect(wifi->scan_pending_network);
2354 wifi->scan_pending_network = NULL;
2355 connman_network_set_connecting(wifi->network);
2357 start_roaming(wifi);
2361 if (is_wifi_notifier_registered != true &&
2362 wifi_first_scan == true && found_with_first_scan == true) {
2363 wifi_first_scan = false;
2364 found_with_first_scan = false;
2366 connman_notifier_register(¬ifier);
2367 is_wifi_notifier_registered = true;
2372 static void scan_callback_hidden(int result,
2373 GSupplicantInterface *interface, void *user_data)
2375 struct connman_device *device = user_data;
2376 struct wifi_data *wifi = connman_device_get_data(device);
2377 GSupplicantScanParams *scan_params;
2380 DBG("result %d wifi %p", result, wifi);
2385 /* User is trying to connect to a hidden AP */
2386 if (wifi->hidden && wifi->postpone_hidden)
2389 scan_params = g_try_malloc0(sizeof(GSupplicantScanParams));
2393 if (get_hidden_connections_params(wifi, scan_params) > 0) {
2394 ret = g_supplicant_interface_scan(wifi->interface,
2396 #if defined TIZEN_EXT
2399 scan_callback_hidden,
2406 g_supplicant_free_scan_params(scan_params);
2409 scan_callback(result, interface, user_data);
2412 static gboolean autoscan_timeout(gpointer data)
2414 struct connman_device *device = data;
2415 struct wifi_data *wifi = connman_device_get_data(device);
2416 struct autoscan_params *autoscan;
2422 autoscan = wifi->autoscan;
2424 #if defined TIZEN_EXT
2429 if (autoscan->interval <= 0) {
2430 interval = autoscan->base;
2433 interval = autoscan->interval * autoscan->base;
2435 #if defined TIZEN_EXT
2436 if (autoscan->interval >= autoscan->limit)
2438 if (interval > autoscan->limit)
2440 interval = autoscan->limit;
2442 throw_wifi_scan(wifi->device, scan_callback_hidden);
2445 * In case BackgroundScanning is disabled, interval will reach the
2446 * limit exactly after the very first passive scanning. It allows
2447 * to ensure at most one passive scan is performed in such cases.
2449 if (!connman_setting_get_bool("BackgroundScanning") &&
2450 interval == autoscan->limit) {
2451 g_source_remove(autoscan->timeout);
2452 autoscan->timeout = 0;
2454 connman_device_unref(device);
2460 DBG("interval %d", interval);
2462 autoscan->interval = interval;
2464 autoscan->timeout = g_timeout_add_seconds(interval,
2465 autoscan_timeout, device);
2470 static void start_autoscan(struct connman_device *device)
2472 struct wifi_data *wifi = connman_device_get_data(device);
2473 struct autoscan_params *autoscan;
2480 if (wifi->p2p_device)
2483 if (wifi->connected)
2486 autoscan = wifi->autoscan;
2490 if (autoscan->timeout > 0 || autoscan->interval > 0)
2493 connman_device_ref(device);
2495 autoscan_timeout(device);
2498 static struct autoscan_params *parse_autoscan_params(const char *params)
2500 struct autoscan_params *autoscan;
2507 list_params = g_strsplit(params, ":", 0);
2508 if (list_params == 0)
2511 if (!g_strcmp0(list_params[0], "exponential") &&
2512 g_strv_length(list_params) == 3) {
2513 base = atoi(list_params[1]);
2514 limit = atoi(list_params[2]);
2515 } else if (!g_strcmp0(list_params[0], "single") &&
2516 g_strv_length(list_params) == 2)
2517 base = limit = atoi(list_params[1]);
2519 g_strfreev(list_params);
2523 DBG("Setup %s autoscanning", list_params[0]);
2525 g_strfreev(list_params);
2527 autoscan = g_try_malloc0(sizeof(struct autoscan_params));
2529 DBG("Could not allocate memory for autoscan");
2533 DBG("base %d - limit %d", base, limit);
2534 autoscan->base = base;
2535 autoscan->limit = limit;
2540 static void setup_autoscan(struct wifi_data *wifi)
2543 * If BackgroundScanning is enabled, setup exponential
2544 * autoscanning if it has not been previously done.
2546 if (connman_setting_get_bool("BackgroundScanning")) {
2547 wifi->autoscan = parse_autoscan_params(AUTOSCAN_EXPONENTIAL);
2550 #if defined TIZEN_EXT
2552 if (wifi->autoscan) {
2553 g_free(wifi->autoscan);
2554 wifi->autoscan = NULL;
2557 DBG("BackgroundScanning is disabled");
2564 * On the contrary, if BackgroundScanning is disabled, update autoscan
2565 * parameters based on the type of scanning that is being performed.
2567 if (wifi->autoscan) {
2568 g_free(wifi->autoscan);
2569 wifi->autoscan = NULL;
2572 switch (wifi->scanning_type) {
2573 case WIFI_SCANNING_PASSIVE:
2574 /* Do not setup autoscan. */
2576 case WIFI_SCANNING_ACTIVE:
2577 /* Setup one single passive scan after active. */
2578 wifi->autoscan = parse_autoscan_params(AUTOSCAN_SINGLE);
2580 case WIFI_SCANNING_UNKNOWN:
2581 /* Setup autoscan in this case but we should never fall here. */
2582 wifi->autoscan = parse_autoscan_params(AUTOSCAN_SINGLE);
2588 static void finalize_interface_creation(struct wifi_data *wifi)
2590 DBG("interface is ready wifi %p tethering %d", wifi, wifi->tethering);
2592 if (!wifi->device) {
2593 connman_error("WiFi device not set");
2597 connman_device_set_powered(wifi->device, true);
2599 if (wifi->p2p_device)
2602 if (!wifi->autoscan)
2603 setup_autoscan(wifi);
2605 start_autoscan(wifi->device);
2608 static void interface_create_callback(int result,
2609 GSupplicantInterface *interface,
2612 struct wifi_data *wifi = user_data;
2613 char *bgscan_range_max;
2616 DBG("result %d ifname %s, wifi %p", result,
2617 g_supplicant_interface_get_ifname(interface),
2620 if (result < 0 || !wifi)
2623 wifi->interface = interface;
2624 g_supplicant_interface_set_data(interface, wifi);
2626 if (g_supplicant_interface_get_ready(interface)) {
2627 wifi->interface_ready = true;
2628 finalize_interface_creation(wifi);
2632 * Set the BSS expiration age to match the long scanning
2633 * interval to avoid the loss of unconnected networks between
2636 bgscan_range_max = strrchr(BGSCAN_DEFAULT, ':');
2637 if (!bgscan_range_max || strlen(bgscan_range_max) < 1)
2640 value = strtol(bgscan_range_max + 1, NULL, 10);
2641 if (value <= 0 || errno == ERANGE)
2644 if (g_supplicant_interface_set_bss_expiration_age(interface,
2645 value + SCAN_MAX_DURATION) < 0) {
2646 connman_warn("Failed to set bss expiration age");
2650 static int wifi_enable(struct connman_device *device)
2652 struct wifi_data *wifi = connman_device_get_data(device);
2655 const char *driver = connman_setting_get_string("wifi");
2658 DBG("device %p %p", device, wifi);
2660 index = connman_device_get_index(device);
2661 if (!wifi || index < 0)
2664 if (is_p2p_connecting())
2665 return -EINPROGRESS;
2667 interface = connman_inet_ifname(index);
2668 ret = g_supplicant_interface_create(interface, driver, NULL,
2670 connman_device_get_mac_policy(device),
2671 connman_device_get_preassoc_mac_policy(device),
2672 connman_device_get_random_mac_lifetime(device),
2673 #endif /* TIZEN_EXT */
2674 interface_create_callback,
2681 return -EINPROGRESS;
2684 static int wifi_disable(struct connman_device *device)
2686 struct wifi_data *wifi = connman_device_get_data(device);
2689 DBG("device %p wifi %p", device, wifi);
2694 wifi->connected = false;
2695 wifi->disconnecting = false;
2697 if (wifi->pending_network)
2698 wifi->pending_network = NULL;
2700 #if !defined TIZEN_EXT
2701 stop_autoscan(device);
2704 if (connman_device_get_scanning(device, CONNMAN_SERVICE_TYPE_P2P)) {
2705 g_source_remove(wifi->p2p_find_timeout);
2706 wifi->p2p_find_timeout = 0;
2707 connman_device_set_scanning(device, CONNMAN_SERVICE_TYPE_P2P, false);
2708 connman_device_unref(wifi->device);
2711 #if defined TIZEN_EXT
2712 if (wifi->automaxspeed_timeout != 0) {
2713 g_source_remove(wifi->automaxspeed_timeout);
2714 wifi->automaxspeed_timeout = 0;
2718 /* In case of a user scan, device is still referenced */
2719 if (connman_device_get_scanning(device, CONNMAN_SERVICE_TYPE_WIFI)) {
2720 connman_device_set_scanning(device,
2721 CONNMAN_SERVICE_TYPE_WIFI, false);
2722 connman_device_unref(wifi->device);
2725 #if defined TIZEN_EXT
2726 stop_autoscan(device);
2729 remove_networks(device, wifi);
2732 #if defined TIZEN_EXT
2733 wifi->scan_pending_network = NULL;
2735 if (is_wifi_notifier_registered == true) {
2736 connman_notifier_unregister(¬ifier);
2737 is_wifi_notifier_registered = false;
2741 ret = g_supplicant_interface_remove(wifi->interface, NULL, NULL);
2745 return -EINPROGRESS;
2748 static int get_latest_connections(int max_ssids,
2749 GSupplicantScanParams *scan_data)
2751 GSequenceIter *iter;
2752 GSequence *latest_list;
2753 struct last_connected *entry;
2762 latest_list = g_sequence_new(free_entry);
2766 services = connman_storage_get_services();
2767 for (i = 0; services && services[i]; i++) {
2768 if (strncmp(services[i], "wifi_", 5) != 0)
2771 keyfile = connman_storage_load_service(services[i]);
2775 str = g_key_file_get_string(keyfile,
2776 services[i], "Favorite", NULL);
2777 if (!str || g_strcmp0(str, "true")) {
2779 g_key_file_free(keyfile);
2784 str = g_key_file_get_string(keyfile,
2785 services[i], "AutoConnect", NULL);
2786 if (!str || g_strcmp0(str, "true")) {
2788 g_key_file_free(keyfile);
2793 str = g_key_file_get_string(keyfile,
2794 services[i], "Modified", NULL);
2796 g_key_file_free(keyfile);
2799 util_iso8601_to_timeval(str, &modified);
2802 ssid = g_key_file_get_string(keyfile,
2803 services[i], "SSID", NULL);
2805 freq = g_key_file_get_integer(keyfile, services[i],
2808 entry = g_try_new(struct last_connected, 1);
2810 g_sequence_free(latest_list);
2811 g_key_file_free(keyfile);
2813 #if defined TIZEN_EXT
2814 g_strfreev(services);
2820 entry->modified = modified;
2823 g_sequence_insert_sorted(latest_list, entry,
2829 g_key_file_free(keyfile);
2832 g_strfreev(services);
2834 num_ssids = num_ssids > max_ssids ? max_ssids : num_ssids;
2836 iter = g_sequence_get_begin_iter(latest_list);
2838 for (i = 0; i < num_ssids; i++) {
2839 entry = g_sequence_get(iter);
2841 DBG("ssid %s freq %d modified %lu", entry->ssid, entry->freq,
2842 entry->modified.tv_sec);
2844 add_scan_param(entry->ssid, NULL, 0, entry->freq, scan_data,
2845 max_ssids, entry->ssid);
2847 iter = g_sequence_iter_next(iter);
2850 g_sequence_free(latest_list);
2854 static void wifi_update_scanner_type(struct wifi_data *wifi,
2855 enum wifi_scanning_type new_type)
2859 if (!wifi || wifi->scanning_type == new_type)
2862 wifi->scanning_type = new_type;
2864 setup_autoscan(wifi);
2867 static int wifi_scan_simple(struct connman_device *device)
2869 struct wifi_data *wifi = connman_device_get_data(device);
2871 reset_autoscan(device);
2873 /* Distinguish between devices performing passive and active scanning */
2875 wifi_update_scanner_type(wifi, WIFI_SCANNING_PASSIVE);
2877 return throw_wifi_scan(device, scan_callback_hidden);
2880 static gboolean p2p_find_stop(gpointer data)
2882 struct connman_device *device = data;
2883 struct wifi_data *wifi = connman_device_get_data(device);
2888 wifi->p2p_find_timeout = 0;
2890 g_supplicant_interface_p2p_stop_find(wifi->interface);
2893 connman_device_set_scanning(device, CONNMAN_SERVICE_TYPE_P2P, false);
2895 connman_device_unref(device);
2896 start_autoscan(device);
2901 static void p2p_find_callback(int result, GSupplicantInterface *interface,
2904 struct connman_device *device = user_data;
2905 struct wifi_data *wifi = connman_device_get_data(device);
2907 DBG("result %d wifi %p", result, wifi);
2912 if (wifi->p2p_find_timeout) {
2913 g_source_remove(wifi->p2p_find_timeout);
2914 wifi->p2p_find_timeout = 0;
2920 wifi->p2p_find_timeout = g_timeout_add_seconds(P2P_FIND_TIMEOUT,
2921 p2p_find_stop, device);
2922 if (!wifi->p2p_find_timeout)
2927 p2p_find_stop(device);
2930 static int p2p_find(struct connman_device *device)
2932 struct wifi_data *wifi;
2937 if (!p2p_technology)
2940 wifi = connman_device_get_data(device);
2942 if (g_supplicant_interface_is_p2p_finding(wifi->interface))
2945 reset_autoscan(device);
2946 connman_device_ref(device);
2948 ret = g_supplicant_interface_p2p_find(wifi->interface,
2949 p2p_find_callback, device);
2951 connman_device_unref(device);
2952 start_autoscan(device);
2954 connman_device_set_scanning(device,
2955 CONNMAN_SERVICE_TYPE_P2P, true);
2961 #if defined TIZEN_EXT
2962 static void specific_scan_callback(int result, GSupplicantInterface *interface,
2965 struct connman_device *device = user_data;
2966 struct wifi_data *wifi = connman_device_get_data(device);
2969 DBG("result %d device %p wifi %p", result, device, wifi);
2971 if (wifi && wifi->scan_params) {
2972 g_supplicant_free_scan_params(wifi->scan_params);
2973 wifi->scan_params = NULL;
2976 scanning = connman_device_get_scanning(device,
2977 CONNMAN_SERVICE_TYPE_WIFI);
2979 connman_device_set_scanning(device,
2980 CONNMAN_SERVICE_TYPE_WIFI, false);
2981 connman_device_unref(device);
2984 start_roaming(wifi);
2987 static int wifi_specific_scan(enum connman_service_type type,
2988 struct connman_device *device, int scan_type,
2989 GSList *specific_scan_list, void *user_data)
2991 GSList *list = NULL;
2993 struct wifi_data *wifi = connman_device_get_data(device);
2994 GSupplicantScanParams *scan_params = NULL;
2995 struct scan_ssid *scan_ssid = NULL;
3004 if (wifi->p2p_device)
3007 if (type == CONNMAN_SERVICE_TYPE_P2P)
3008 return p2p_find(device);
3010 if (wifi->tethering)
3014 connman_device_get_scanning(device,
3015 CONNMAN_SERVICE_TYPE_WIFI);
3019 DBG("scan_type: %d", scan_type);
3020 if (scan_type == CONNMAN_MULTI_SCAN_SSID) { /* ssid based scan */
3021 scan_params = g_try_malloc0(sizeof(GSupplicantScanParams));
3023 DBG("Failed to allocate memory.");
3027 for (list = specific_scan_list; list; list = list->next) {
3028 ssid = (char *)list->data;
3029 int ssid_len = strlen(ssid);
3031 scan_ssid = g_try_new0(struct scan_ssid, 1);
3033 DBG("Failed to allocate memory.");
3034 g_supplicant_free_scan_params(scan_params);
3038 memcpy(scan_ssid->ssid, ssid, (ssid_len + 1));
3039 /* DBG("scan ssid %s len: %d", scan_ssid->ssid, ssid_len); */
3040 scan_ssid->ssid_len = ssid_len;
3041 scan_params->ssids = g_slist_prepend(scan_params->ssids, scan_ssid);
3044 scan_params->num_ssids = count;
3046 } else if (scan_type == CONNMAN_MULTI_SCAN_FREQ) { /* frequency based scan */
3048 scan_params = g_try_malloc0(sizeof(GSupplicantScanParams));
3050 DBG("Failed to allocate memory.");
3054 guint num_freqs = g_slist_length(specific_scan_list);
3055 DBG("num_freqs: %d", num_freqs);
3057 scan_params->freqs = g_try_new0(uint16_t, num_freqs);
3058 if (!scan_params->freqs) {
3059 DBG("Failed to allocate memory.");
3060 g_free(scan_params);
3065 for (list = specific_scan_list; list; list = list->next) {
3066 freq = (int)list->data;
3068 scan_params->freqs[count] = freq;
3069 DBG("scan_params->freqs[%d]: %d", count, scan_params->freqs[count]);
3072 scan_params->num_freqs = count;
3074 } else if (scan_type == CONNMAN_MULTI_SCAN_SSID_FREQ) { /* SSID & Frequency mixed scan */
3075 int freq_count, ap_count;
3076 scan_params = g_try_malloc0(sizeof(GSupplicantScanParams));
3078 DBG("Failed to allocate memory.");
3082 guint size = g_slist_length(specific_scan_list);
3084 scan_params->freqs = g_try_new0(uint16_t, size/2);
3085 if (!scan_params->freqs) {
3086 DBG("Failed to allocate memory.");
3087 g_free(scan_params);
3091 ap_count = freq_count = 0;
3092 for (list = specific_scan_list; list; list = list->next) {
3093 if (((connman_multi_scan_ap_s *)list->data)->flag == true) { /** ssid */
3094 ssid = ((connman_multi_scan_ap_s *)list->data)->str;
3095 int ssid_len = strlen(ssid);
3097 scan_ssid = g_try_new0(struct scan_ssid, 1);
3099 DBG("Failed to allocate memory.");
3100 g_supplicant_free_scan_params(scan_params);
3104 memcpy(scan_ssid->ssid, ssid, (ssid_len + 1));
3105 /* DBG("scan ssid %s len: %d", scan_ssid->ssid, ssid_len); */
3106 scan_ssid->ssid_len = ssid_len;
3107 scan_params->ssids = g_slist_prepend(scan_params->ssids, scan_ssid);
3111 freq = atoi(((connman_multi_scan_ap_s *)list->data)->str);
3112 scan_params->freqs[freq_count] = freq;
3113 DBG("scan_params->freqs[%d]: %d", freq_count, scan_params->freqs[freq_count]);
3117 scan_params->num_ssids = ap_count;
3118 scan_params->num_freqs = freq_count;
3120 DBG("Invalid scan");
3124 reset_autoscan(device);
3125 connman_device_ref(device);
3127 ret = g_supplicant_interface_scan(wifi->interface, scan_params,
3128 specific_scan_callback, device);
3131 connman_device_set_scanning(device,
3132 CONNMAN_SERVICE_TYPE_WIFI, true);
3134 g_supplicant_free_scan_params(scan_params);
3135 connman_device_unref(device);
3141 static void wifi_mac_policy_callback(int result,
3142 unsigned int policy,
3145 struct connman_device *device = user_data;
3148 connman_device_mac_policy_notify(device, result, policy);
3150 connman_device_unref(device);
3153 int wifi_set_mac_policy(struct connman_device *device, unsigned int policy)
3155 struct wifi_data *wifi = connman_device_get_data(device);
3161 connman_device_ref(device);
3163 ret = g_supplicant_interface_set_mac_policy(wifi->interface,
3164 wifi_mac_policy_callback,
3167 connman_device_unref(device);
3172 static void wifi_preassoc_mac_policy_callback(int result,
3173 unsigned int policy,
3176 struct connman_device *device = user_data;
3179 connman_device_preassoc_mac_policy_notify(device, result, policy);
3181 connman_device_unref(device);
3184 int wifi_set_preassoc_mac_policy(struct connman_device *device, unsigned int policy)
3186 struct wifi_data *wifi = connman_device_get_data(device);
3192 connman_device_ref(device);
3194 ret = g_supplicant_interface_set_preassoc_mac_policy(wifi->interface,
3195 wifi_preassoc_mac_policy_callback,
3198 connman_device_unref(device);
3203 static void wifi_random_mac_lifetime_callback(int result,
3204 unsigned int lifetime,
3207 struct connman_device *device = user_data;
3210 connman_device_random_mac_lifetime_notify(device, result, lifetime);
3212 connman_device_unref(device);
3215 int wifi_set_random_mac_lifetime(struct connman_device *device, unsigned int lifetime)
3217 struct wifi_data *wifi = connman_device_get_data(device);
3223 connman_device_ref(device);
3225 ret = g_supplicant_interface_set_random_mac_lifetime(wifi->interface,
3226 wifi_random_mac_lifetime_callback,
3229 connman_device_unref(device);
3235 #if defined TIZEN_EXT_WIFI_MESH
3236 static void mesh_scan_callback(int result, GSupplicantInterface *interface,
3239 struct connman_device *device = user_data;
3240 struct wifi_data *wifi = connman_device_get_data(device);
3243 DBG("result %d wifi %p", result, wifi);
3245 scanning = connman_device_get_scanning(device,
3246 CONNMAN_SERVICE_TYPE_MESH);
3248 connman_device_set_scanning(device,
3249 CONNMAN_SERVICE_TYPE_MESH, false);
3252 connman_device_unref(device);
3255 static int mesh_scan(struct connman_device *device)
3257 struct wifi_data *wifi;
3258 struct wifi_mesh_info *mesh_info;
3263 wifi = connman_device_get_data(device);
3265 if (!wifi || !wifi->mesh_interface)
3268 mesh_info = wifi->mesh_info;
3269 reset_autoscan(device);
3270 connman_device_ref(device);
3272 ret = g_supplicant_interface_scan(mesh_info->interface, NULL,
3273 mesh_scan_callback, device);
3275 connman_device_unref(device);
3277 connman_device_set_scanning(device,
3278 CONNMAN_SERVICE_TYPE_MESH, true);
3283 static void abort_scan_callback(int result, GSupplicantInterface *interface,
3286 struct connman_device *device = user_data;
3287 struct wifi_data *wifi = connman_device_get_data(device);
3289 DBG("result %d wifi %p", result, wifi);
3291 __connman_technology_notify_abort_scan(CONNMAN_SERVICE_TYPE_MESH, result);
3294 static int mesh_abort_scan(enum connman_service_type type,
3295 struct connman_device *device)
3297 struct wifi_data *wifi = connman_device_get_data(device);
3298 struct wifi_mesh_info *mesh_info;
3302 if (!wifi || !wifi->mesh_interface)
3305 if (type != CONNMAN_SERVICE_TYPE_MESH)
3308 mesh_info = wifi->mesh_info;
3310 scanning = connman_device_get_scanning(device,
3311 CONNMAN_SERVICE_TYPE_MESH);
3315 ret = g_supplicant_interface_abort_scan(mesh_info->interface,
3316 abort_scan_callback, device);
3321 static int mesh_specific_scan(enum connman_service_type type,
3322 struct connman_device *device, const char *ssid,
3323 unsigned int freq, void *user_data)
3325 struct wifi_data *wifi = connman_device_get_data(device);
3326 GSupplicantScanParams *scan_params = NULL;
3327 struct wifi_mesh_info *mesh_info;
3328 struct scan_ssid *scan_ssid;
3332 if (!wifi || !wifi->mesh_interface)
3335 if (type != CONNMAN_SERVICE_TYPE_MESH)
3338 if (wifi->p2p_device)
3341 mesh_info = wifi->mesh_info;
3343 scanning = connman_device_get_scanning(device,
3344 CONNMAN_SERVICE_TYPE_MESH);
3348 scan_params = g_try_malloc0(sizeof(GSupplicantScanParams));
3352 scan_ssid = g_try_new(struct scan_ssid, 1);
3354 g_free(scan_params);
3358 scan_ssid->ssid_len = strlen(ssid);
3359 memcpy(scan_ssid->ssid, ssid, scan_ssid->ssid_len);
3360 scan_params->ssids = g_slist_prepend(scan_params->ssids, scan_ssid);
3361 scan_params->num_ssids = 1;
3363 scan_params->freqs = g_try_new(uint16_t, 1);
3364 if (!scan_params->freqs) {
3365 g_slist_free_full(scan_params->ssids, g_free);
3366 g_free(scan_params);
3370 scan_params->freqs[0] = freq;
3371 scan_params->num_freqs = 1;
3373 reset_autoscan(device);
3374 connman_device_ref(device);
3376 ret = g_supplicant_interface_scan(mesh_info->interface, scan_params,
3377 mesh_scan_callback, device);
3380 connman_device_set_scanning(device,
3381 CONNMAN_SERVICE_TYPE_MESH, true);
3383 g_supplicant_free_scan_params(scan_params);
3384 connman_device_unref(device);
3392 * Note that the hidden scan is only used when connecting to this specific
3393 * hidden AP first time. It is not used when system autoconnects to hidden AP.
3395 static int wifi_scan(struct connman_device *device,
3396 struct connman_device_scan_params *params)
3398 struct wifi_data *wifi = connman_device_get_data(device);
3399 GSupplicantScanParams *scan_params = NULL;
3400 struct scan_ssid *scan_ssid;
3401 struct hidden_params *hidden;
3403 int driver_max_ssids = 0;
3410 if (wifi->p2p_device)
3413 if (wifi->tethering)
3416 if (params->type == CONNMAN_SERVICE_TYPE_P2P)
3417 return p2p_find(device);
3419 #if defined TIZEN_EXT_WIFI_MESH
3420 if (params->type == CONNMAN_SERVICE_TYPE_MESH)
3421 return mesh_scan(device);
3424 DBG("device %p wifi %p hidden ssid %s", device, wifi->interface,
3427 scanning = connman_device_get_scanning(device, CONNMAN_SERVICE_TYPE_WIFI);
3429 if (!params->ssid || params->ssid_len == 0 || params->ssid_len > 32) {
3433 driver_max_ssids = g_supplicant_interface_get_max_scan_ssids(
3435 DBG("max ssids %d", driver_max_ssids);
3436 if (driver_max_ssids == 0)
3437 return wifi_scan_simple(device);
3441 if (scanning && wifi->hidden && wifi->postpone_hidden)
3447 scan_params = g_try_malloc0(sizeof(GSupplicantScanParams));
3452 scan_ssid = g_try_new(struct scan_ssid, 1);
3454 g_free(scan_params);
3458 memcpy(scan_ssid->ssid, params->ssid, params->ssid_len);
3459 scan_ssid->ssid_len = params->ssid_len;
3460 scan_params->ssids = g_slist_prepend(scan_params->ssids,
3462 scan_params->num_ssids = 1;
3464 hidden = g_try_new0(struct hidden_params, 1);
3466 g_supplicant_free_scan_params(scan_params);
3471 hidden_free(wifi->hidden);
3472 wifi->hidden = NULL;
3475 memcpy(hidden->ssid, params->ssid, params->ssid_len);
3476 hidden->ssid_len = params->ssid_len;
3477 hidden->identity = g_strdup(params->identity);
3478 hidden->passphrase = g_strdup(params->passphrase);
3479 hidden->security = g_strdup(params->security);
3480 hidden->user_data = params->user_data;
3481 wifi->hidden = hidden;
3484 /* Let's keep this active scan for later,
3485 * when current scan will be over. */
3486 wifi->postpone_hidden = TRUE;
3487 hidden->scan_params = scan_params;
3491 } else if (wifi->connected) {
3492 g_supplicant_free_scan_params(scan_params);
3493 return wifi_scan_simple(device);
3494 } else if (!params->force_full_scan) {
3495 ret = get_latest_connections(driver_max_ssids, scan_params);
3497 g_supplicant_free_scan_params(scan_params);
3498 return wifi_scan_simple(device);
3502 /* Distinguish between devices performing passive and active scanning */
3503 wifi_update_scanner_type(wifi, WIFI_SCANNING_ACTIVE);
3505 connman_device_ref(device);
3507 reset_autoscan(device);
3508 #if defined TIZEN_EXT
3510 * When doing a full scan, stored hidden networks also need to be scanned
3511 * so that we can autoconnect to them.
3513 if (params->force_full_scan)
3514 ret = g_supplicant_interface_scan(wifi->interface, scan_params,
3515 scan_callback_hidden, device);
3518 ret = g_supplicant_interface_scan(wifi->interface, scan_params,
3519 scan_callback, device);
3521 connman_device_set_scanning(device,
3522 CONNMAN_SERVICE_TYPE_WIFI, true);
3523 #if defined TIZEN_EXT
3525 * To allow the Full Scan after ssid based scan, set the flag here
3526 * It is required because Tizen does not use the ConnMan specific
3527 * backgroung Scan feature.Tizen has added the BG Scan feature in
3528 * net-config. To sync with up ConnMan, we need to issue the Full Scan
3529 * after SSID specific scan.
3531 if (!params->force_full_scan && !do_hidden)
3532 wifi->allow_full_scan = TRUE;
3535 g_supplicant_free_scan_params(scan_params);
3536 connman_device_unref(device);
3539 hidden_free(wifi->hidden);
3540 wifi->hidden = NULL;
3547 static void wifi_stop_scan(enum connman_service_type type,
3548 struct connman_device *device)
3550 struct wifi_data *wifi = connman_device_get_data(device);
3552 DBG("device %p wifi %p", device, wifi);
3557 if (type == CONNMAN_SERVICE_TYPE_P2P) {
3558 if (connman_device_get_scanning(device, CONNMAN_SERVICE_TYPE_P2P)) {
3559 g_source_remove(wifi->p2p_find_timeout);
3560 p2p_find_stop(device);
3565 static void wifi_regdom_callback(int result,
3569 struct connman_device *device = user_data;
3571 connman_device_regdom_notify(device, result, alpha2);
3573 connman_device_unref(device);
3576 static int wifi_set_regdom(struct connman_device *device, const char *alpha2)
3578 struct wifi_data *wifi = connman_device_get_data(device);
3584 connman_device_ref(device);
3586 ret = g_supplicant_interface_set_country(wifi->interface,
3587 wifi_regdom_callback,
3590 connman_device_unref(device);
3595 static struct connman_device_driver wifi_ng_driver = {
3597 .type = CONNMAN_DEVICE_TYPE_WIFI,
3598 .priority = CONNMAN_DEVICE_PRIORITY_LOW,
3599 .probe = wifi_probe,
3600 .remove = wifi_remove,
3601 .enable = wifi_enable,
3602 .disable = wifi_disable,
3604 .stop_scan = wifi_stop_scan,
3605 .set_regdom = wifi_set_regdom,
3606 #if defined TIZEN_EXT
3607 .specific_scan = wifi_specific_scan,
3608 .set_mac_policy = wifi_set_mac_policy,
3609 .set_preassoc_mac_policy = wifi_set_preassoc_mac_policy,
3610 .set_random_mac_lifetime = wifi_set_random_mac_lifetime,
3612 #if defined TIZEN_EXT_WIFI_MESH
3613 .abort_scan = mesh_abort_scan,
3614 .mesh_specific_scan = mesh_specific_scan,
3618 static void system_ready(void)
3622 if (connman_device_driver_register(&wifi_ng_driver) < 0)
3623 connman_error("Failed to register WiFi driver");
3626 static void system_killed(void)
3630 connman_device_driver_unregister(&wifi_ng_driver);
3633 static int network_probe(struct connman_network *network)
3635 #if defined TIZEN_EXT
3636 if (!simplified_log)
3638 DBG("network %p", network);
3643 static void network_remove(struct connman_network *network)
3645 struct connman_device *device = connman_network_get_device(network);
3646 struct wifi_data *wifi;
3648 DBG("network %p", network);
3650 wifi = connman_device_get_data(device);
3654 if (wifi->network != network)
3657 wifi->network = NULL;
3659 #if defined TIZEN_EXT
3660 wifi->disconnecting = false;
3662 if (wifi->pending_network == network)
3663 wifi->pending_network = NULL;
3665 if (wifi->scan_pending_network == network)
3666 wifi->scan_pending_network = NULL;
3670 static void connect_callback(int result, GSupplicantInterface *interface,
3673 #if defined TIZEN_EXT
3675 struct wifi_data *wifi;
3677 struct connman_network *network = user_data;
3679 DBG("network %p result %d", network, result);
3681 #if defined TIZEN_EXT
3682 const char *ifname = g_supplicant_interface_get_ifname(interface);
3683 set_connman_bssid(RESET_BSSID, NULL, ifname);
3685 for (list = iface_list; list; list = list->next) {
3688 if (wifi && wifi->network == network)
3692 /* wifi_data may be invalid because wifi is already disabled */
3696 if (connman_network_get_bool(network, "WiFi.Roaming")) {
3698 connman_network_set_bool(network, "WiFi.Roaming", false);
3699 connman_network_set_string(network,
3700 "WiFi.RoamingCurBSSID", NULL);
3702 char bssid_buff[WIFI_BSSID_STR_LEN] = {0,};
3703 char *bssid_str = bssid_buff;
3704 unsigned char *bssid;
3705 const char *cur_bssid;
3707 bssid = g_supplicant_interface_get_add_network_bssid(interface);
3709 connman_network_set_bool(network, "WiFi.Roaming", false);
3710 connman_network_set_string(network,
3711 "WiFi.RoamingCurBSSID", NULL);
3715 MACSTR, MAC2STR(bssid));
3717 connman_network_set_string(network,
3718 "WiFi.RoamingDstBSSID", bssid_str);
3720 cur_bssid = connman_network_get_string(network,
3721 "WiFi.RoamingCurBSSID");
3723 __connman_technology_notify_roaming_state(ifname,
3724 "started", cur_bssid, bssid_str);
3729 if (result == -ENOKEY) {
3730 connman_network_set_error(network,
3731 CONNMAN_NETWORK_ERROR_INVALID_KEY);
3732 } else if (result < 0) {
3733 connman_network_set_error(network,
3734 CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL);
3737 connman_network_unref(network);
3740 static GSupplicantSecurity network_security(const char *security)
3742 if (g_str_equal(security, "none"))
3743 return G_SUPPLICANT_SECURITY_NONE;
3744 else if (g_str_equal(security, "wep"))
3745 return G_SUPPLICANT_SECURITY_WEP;
3746 else if (g_str_equal(security, "psk"))
3747 return G_SUPPLICANT_SECURITY_PSK;
3748 else if (g_str_equal(security, "wpa"))
3749 return G_SUPPLICANT_SECURITY_PSK;
3750 else if (g_str_equal(security, "rsn"))
3751 return G_SUPPLICANT_SECURITY_PSK;
3752 else if (g_str_equal(security, "ieee8021x"))
3753 return G_SUPPLICANT_SECURITY_IEEE8021X;
3754 #if defined TIZEN_EXT
3755 else if (g_str_equal(security, "ft_psk") == TRUE)
3756 return G_SUPPLICANT_SECURITY_FT_PSK;
3757 else if (g_str_equal(security, "ft_ieee8021x") == TRUE)
3758 return G_SUPPLICANT_SECURITY_FT_IEEE8021X;
3759 else if (g_str_equal(security, "sae"))
3760 return G_SUPPLICANT_SECURITY_SAE;
3761 else if (g_str_equal(security, "owe"))
3762 return G_SUPPLICANT_SECURITY_OWE;
3763 else if (g_str_equal(security, "dpp"))
3764 return G_SUPPLICANT_SECURITY_DPP;
3767 return G_SUPPLICANT_SECURITY_UNKNOWN;
3770 #if defined TIZEN_EXT
3771 static GSupplicantEapKeymgmt network_eap_keymgmt(const char *security)
3773 if (security == NULL)
3774 return G_SUPPLICANT_EAP_KEYMGMT_NONE;
3776 if (g_str_equal(security, "FT") == TRUE)
3777 return G_SUPPLICANT_EAP_KEYMGMT_FT;
3778 else if (g_str_equal(security, "CCKM") == TRUE)
3779 return G_SUPPLICANT_EAP_KEYMGMT_CCKM;
3781 return G_SUPPLICANT_EAP_KEYMGMT_NONE;
3785 static void ssid_init(GSupplicantSSID *ssid, struct connman_network *network)
3787 const char *security;
3788 #if defined TIZEN_EXT
3789 const void *ssid_data;
3792 memset(ssid, 0, sizeof(*ssid));
3793 ssid->mode = G_SUPPLICANT_MODE_INFRA;
3794 #if defined TIZEN_EXT
3795 ssid_data = connman_network_get_blob(network, "WiFi.SSID",
3797 ssid->ssid = g_try_malloc0(ssid->ssid_len);
3802 memcpy(ssid->ssid, ssid_data, ssid->ssid_len);
3804 ssid->ssid = connman_network_get_blob(network, "WiFi.SSID",
3807 ssid->scan_ssid = 1;
3808 security = connman_network_get_string(network, "WiFi.Security");
3809 ssid->security = network_security(security);
3810 #if defined TIZEN_EXT
3811 ssid->ieee80211w = 1;
3813 ssid->passphrase = connman_network_get_string(network,
3816 ssid->eap = connman_network_get_string(network, "WiFi.EAP");
3819 * If our private key password is unset,
3820 * we use the supplied passphrase. That is needed
3821 * for PEAP where 2 passphrases (identity and client
3822 * cert may have to be provided.
3824 if (!connman_network_get_string(network, "WiFi.PrivateKeyPassphrase"))
3825 connman_network_set_string(network,
3826 "WiFi.PrivateKeyPassphrase",
3828 /* We must have an identity for both PEAP and TLS */
3829 ssid->identity = connman_network_get_string(network, "WiFi.Identity");
3831 /* Use agent provided identity as a fallback */
3832 if (!ssid->identity || strlen(ssid->identity) == 0)
3833 ssid->identity = connman_network_get_string(network,
3834 "WiFi.AgentIdentity");
3836 ssid->anonymous_identity = connman_network_get_string(network,
3837 "WiFi.AnonymousIdentity");
3838 ssid->ca_cert_path = connman_network_get_string(network,
3840 ssid->subject_match = connman_network_get_string(network,
3841 "WiFi.SubjectMatch");
3842 ssid->altsubject_match = connman_network_get_string(network,
3843 "WiFi.AltSubjectMatch");
3844 ssid->domain_suffix_match = connman_network_get_string(network,
3845 "WiFi.DomainSuffixMatch");
3846 ssid->domain_match = connman_network_get_string(network,
3847 "WiFi.DomainMatch");
3848 ssid->client_cert_path = connman_network_get_string(network,
3849 "WiFi.ClientCertFile");
3850 ssid->private_key_path = connman_network_get_string(network,
3851 "WiFi.PrivateKeyFile");
3852 ssid->private_key_passphrase = connman_network_get_string(network,
3853 "WiFi.PrivateKeyPassphrase");
3854 ssid->phase2_auth = connman_network_get_string(network, "WiFi.Phase2");
3856 ssid->use_wps = connman_network_get_bool(network, "WiFi.UseWPS");
3857 ssid->pin_wps = connman_network_get_string(network, "WiFi.PinWPS");
3858 #if defined TIZEN_EXT
3859 ssid->connector = connman_network_get_string(network,
3861 ssid->c_sign_key = connman_network_get_string(network,
3863 ssid->net_access_key = connman_network_get_string(network,
3864 "WiFi.NetAccessKey");
3867 #if defined TIZEN_EXT
3868 const char *ifname = connman_device_get_string(
3869 connman_network_get_device(network), "Interface");
3870 if (set_connman_bssid(CHECK_BSSID, NULL, ifname) == 6) {
3871 ssid->bssid_for_connect_len = 6;
3872 set_connman_bssid(GET_BSSID, (char *)ssid->bssid_for_connect, ifname);
3873 DBG("BSSID : %02x:%02x:%02x:%02x:%02x:%02x",
3874 ssid->bssid_for_connect[0], ssid->bssid_for_connect[1],
3875 ssid->bssid_for_connect[2], ssid->bssid_for_connect[3],
3876 ssid->bssid_for_connect[4], ssid->bssid_for_connect[5]);
3878 ssid->freq = connman_network_get_frequency(network);
3881 GSList *bssid_list = (GSList *)connman_network_get_bssid_list(network);
3882 if (bssid_list && g_slist_length(bssid_list) > 1) {
3884 /* If there are more than one bssid,
3885 * the user-specified bssid is tried only once at the beginning.
3886 * After that, the bssids in the list are tried in order.
3888 if (set_connman_bssid(CHECK_BSSID, NULL, ifname) == 6) {
3889 set_connman_bssid(RESET_BSSID, NULL, ifname);
3894 char buff[MAC_ADDRESS_LENGTH];
3895 for (list = bssid_list; list; list = list->next) {
3896 struct connman_bssids * bssids = (struct connman_bssids *)list->data;
3898 g_snprintf(buff, MAC_ADDRESS_LENGTH, "%02x:%02x:%02x:%02x:%02x:%02x",
3899 bssids->bssid[0], bssids->bssid[1], bssids->bssid[2],
3900 bssids->bssid[3], bssids->bssid[4], bssids->bssid[5]);
3901 buff[MAC_ADDRESS_LENGTH - 1] = '\0';
3903 gchar *curr_bssid = g_strdup((const gchar *)buff);
3905 if (g_hash_table_contains(failed_bssids, curr_bssid)) {
3906 DBG("bssid match, try next bssid");
3910 g_hash_table_add(failed_bssids, curr_bssid);
3912 memcpy(buff_bssid, bssids->bssid, WIFI_BSSID_LEN_MAX);
3913 ssid->bssid = buff_bssid;
3914 ssid->freq = (unsigned int)bssids->frequency;
3920 ssid->bssid = connman_network_get_bssid(network);
3921 g_hash_table_remove_all(failed_bssids);
3924 ssid->bssid = connman_network_get_bssid(network);
3927 ssid->eap_keymgmt = network_eap_keymgmt(
3928 connman_network_get_string(network, "WiFi.KeymgmtType"));
3929 ssid->phase1 = connman_network_get_string(network, "WiFi.Phase1");
3931 if (g_strcmp0(ssid->eap, "fast") == 0)
3932 ssid->pac_file = g_strdup(WIFI_EAP_FAST_PAC_FILE);
3934 ssid->keymgmt = connman_network_get_keymgmt(network);
3937 if (connman_setting_get_bool("BackgroundScanning"))
3938 ssid->bgscan = BGSCAN_DEFAULT;
3941 static int network_connect(struct connman_network *network)
3943 struct connman_device *device = connman_network_get_device(network);
3944 struct wifi_data *wifi;
3945 GSupplicantInterface *interface;
3946 GSupplicantSSID *ssid;
3948 DBG("network %p", network);
3953 wifi = connman_device_get_data(device);
3957 ssid = g_try_malloc0(sizeof(GSupplicantSSID));
3961 interface = wifi->interface;
3963 ssid_init(ssid, network);
3965 if (wifi->disconnecting) {
3966 wifi->pending_network = network;
3967 #if defined TIZEN_EXT
3972 wifi->network = connman_network_ref(network);
3974 #if defined TIZEN_EXT
3975 wifi->scan_pending_network = NULL;
3978 return g_supplicant_interface_connect(interface, ssid,
3979 connect_callback, network);
3982 return -EINPROGRESS;
3985 static void disconnect_callback(int result, GSupplicantInterface *interface,
3988 struct disconnect_data *dd = user_data;
3989 struct connman_network *network = dd->network;
3990 #if defined TIZEN_EXT
3992 struct wifi_data *wifi;
3995 DBG("network %p result %d", network, result);
3997 for (list = iface_list; list; list = list->next) {
4000 if (wifi->network == NULL && wifi->disconnecting == true)
4001 wifi->disconnecting = false;
4003 if (wifi->network == network)
4007 if (network == wifi->pending_network)
4008 wifi->pending_network = NULL;
4010 /* wifi_data may be invalid because wifi is already disabled */
4015 struct wifi_data *wifi = dd->wifi;
4019 DBG("result %d supplicant interface %p wifi %p networks: current %p "
4020 "pending %p disconnected %p", result, interface, wifi,
4021 wifi->network, wifi->pending_network, network);
4023 if (result == -ECONNABORTED) {
4024 DBG("wifi interface no longer available");
4028 #if defined TIZEN_EXT
4029 if (g_slist_find(wifi->networks, network) &&
4030 wifi->network != wifi->pending_network)
4032 if (g_slist_find(wifi->networks, network))
4034 connman_network_set_connected(network, false);
4036 wifi->disconnecting = false;
4038 if (network != wifi->network) {
4039 if (network == wifi->pending_network)
4040 wifi->pending_network = NULL;
4041 DBG("current wifi network has changed since disconnection");
4045 wifi->network = NULL;
4047 wifi->connected = false;
4049 if (wifi->pending_network) {
4050 network_connect(wifi->pending_network);
4051 wifi->pending_network = NULL;
4054 start_autoscan(wifi->device);
4057 static int network_disconnect(struct connman_network *network)
4059 struct connman_device *device = connman_network_get_device(network);
4060 struct disconnect_data *dd;
4061 struct wifi_data *wifi;
4063 #if defined TIZEN_EXT
4064 struct connman_service *service;
4067 DBG("network %p", network);
4069 wifi = connman_device_get_data(device);
4070 if (!wifi || !wifi->interface)
4073 #if defined TIZEN_EXT
4074 if (connman_network_get_associating(network) == true) {
4075 connman_network_clear_associating(network);
4076 connman_network_set_bool(network, "WiFi.UseWPS", false);
4078 service = connman_service_lookup_from_network(network);
4080 if (service != NULL &&
4081 (__connman_service_is_connected_state(service,
4082 CONNMAN_IPCONFIG_TYPE_IPV4) == false &&
4083 __connman_service_is_connected_state(service,
4084 CONNMAN_IPCONFIG_TYPE_IPV6) == false) &&
4085 (connman_service_get_favorite(service) == false))
4086 __connman_service_set_passphrase(service, NULL);
4089 if (wifi->pending_network == network)
4090 wifi->pending_network = NULL;
4092 if (wifi->scan_pending_network == network)
4093 wifi->scan_pending_network = NULL;
4096 connman_network_set_associating(network, false);
4098 if (wifi->disconnecting)
4101 wifi->disconnecting = true;
4103 dd = g_malloc0(sizeof(*dd));
4105 dd->network = network;
4107 err = g_supplicant_interface_disconnect(wifi->interface,
4108 disconnect_callback, dd);
4110 wifi->disconnecting = false;
4117 #if defined TIZEN_EXT
4118 static void set_connection_mode(struct connman_network *network,
4121 ieee80211_modes_e phy_mode;
4122 connection_mode_e conn_mode;
4124 phy_mode = connman_network_get_phy_mode(network);
4126 case IEEE80211_MODE_B:
4127 if (linkspeed > 0 && linkspeed <= 11)
4128 conn_mode = CONNECTION_MODE_IEEE80211B;
4130 conn_mode = CONNECTION_MODE_IEEE80211_UNKNOWN;
4133 case IEEE80211_MODE_BG:
4134 if (linkspeed > 0 && linkspeed <= 11)
4135 conn_mode = CONNECTION_MODE_IEEE80211B;
4136 else if (linkspeed > 11 && linkspeed <= 54)
4137 conn_mode = CONNECTION_MODE_IEEE80211G;
4139 conn_mode = CONNECTION_MODE_IEEE80211_UNKNOWN;
4142 case IEEE80211_MODE_BGN:
4143 if (linkspeed > 0 && linkspeed <= 11)
4144 conn_mode = CONNECTION_MODE_IEEE80211B;
4145 else if (linkspeed > 11 && linkspeed <= 54)
4146 conn_mode = CONNECTION_MODE_IEEE80211G;
4147 else if (linkspeed > 54 && linkspeed <= 450)
4148 conn_mode = CONNECTION_MODE_IEEE80211N;
4150 conn_mode = CONNECTION_MODE_IEEE80211_UNKNOWN;
4153 case IEEE80211_MODE_A:
4154 if (linkspeed > 0 && linkspeed <= 54)
4155 conn_mode = CONNECTION_MODE_IEEE80211A;
4157 conn_mode = CONNECTION_MODE_IEEE80211_UNKNOWN;
4160 case IEEE80211_MODE_AN:
4161 if (linkspeed > 0 && linkspeed <= 54)
4162 conn_mode = CONNECTION_MODE_IEEE80211A;
4163 else if (linkspeed > 54 && linkspeed <= 450)
4164 conn_mode = CONNECTION_MODE_IEEE80211N;
4166 conn_mode = CONNECTION_MODE_IEEE80211_UNKNOWN;
4169 case IEEE80211_MODE_ANAC:
4170 if (linkspeed > 0 && linkspeed <= 54)
4171 conn_mode = CONNECTION_MODE_IEEE80211A;
4172 else if (linkspeed > 54 && linkspeed <= 450)
4173 conn_mode = CONNECTION_MODE_IEEE80211N;
4174 else if (linkspeed > 450 && linkspeed <= 1300)
4175 conn_mode = CONNECTION_MODE_IEEE80211AC;
4177 conn_mode = CONNECTION_MODE_IEEE80211_UNKNOWN;
4181 conn_mode = CONNECTION_MODE_IEEE80211_UNKNOWN;
4185 DBG("connection mode(%d)", conn_mode);
4186 connman_network_set_connection_mode(network, conn_mode);
4189 static void signalpoll_callback(int result, int maxspeed, int strength,
4190 int snr, void *user_data)
4192 char bssid_buff[WIFI_BSSID_STR_LEN] = {0,};
4193 char *bssid_str = bssid_buff;
4194 unsigned char *bssid;
4195 struct timespec curr_time = {0};
4196 __time_t roam_scan_time;
4197 const char *interface = NULL;
4198 struct connman_device *device;
4199 struct connman_network *network = user_data;
4200 GSupplicantNetwork *supplicant_network;
4201 struct wifi_data *wifi;
4202 uint16_t freq = connman_network_get_frequency(network);
4203 const char *group = connman_network_get_group(network);
4206 DBG("Failed to get maxspeed from signalpoll !");
4207 connman_network_unref(network);
4211 device = connman_network_get_device(network);
4213 wifi = connman_device_get_data(device);
4216 supplicant_network = g_supplicant_interface_get_network(wifi->interface, group);
4217 if (supplicant_network) {
4218 g_supplicant_network_set_signal(supplicant_network, strength);
4219 g_supplicant_network_set_bss_signal(supplicant_network, strength, snr);
4227 bssid = connman_network_get_bssid(network);
4228 snprintf(bssid_str, WIFI_BSSID_STR_LEN, MACSTR, MAC2STR(bssid));
4230 DBG("network %p, bssid %s, freq %u, maxspeed %d, strength %d, snr %d",
4231 network, bssid_str, freq, maxspeed, strength, snr);
4233 connman_network_set_strength(network, (uint8_t)strength);
4234 connman_network_set_snr(network, snr);
4235 connman_network_set_maxspeed(network, maxspeed);
4236 set_connection_mode(network, maxspeed);
4238 if (connman_network_get_max_bssid_count(network) <= 1)
4241 clock_gettime(CLOCK_MONOTONIC, &curr_time);
4242 roam_scan_time = connman_network_get_roam_scan_time(network);
4243 if (curr_time.tv_sec <= roam_scan_time + ROAM_SCAN_INTERVAL)
4246 if (device && need_bss_transition(freq, snr, strength)) {
4248 interface = connman_device_get_string(device, "Interface");
4249 __connman_technology_notify_roaming_state(interface, "required", bssid_str, NULL);
4251 if (connman_setting_get_bool("WifiRoamingScan") == false)
4254 throw_wifi_scan(device, scan_callback);
4255 connman_network_set_roam_scan_time(network, curr_time.tv_sec);
4259 connman_network_unref(network);
4262 static int network_signalpoll(struct wifi_data *wifi)
4264 GSupplicantInterface *interface;
4265 struct connman_network *network;
4267 if (!wifi || !wifi->network)
4270 wifi->network = connman_network_ref(wifi->network);
4272 interface = wifi->interface;
4273 network = wifi->network;
4275 DBG("network %p", network);
4277 return g_supplicant_interface_signalpoll(interface, signalpoll_callback, network);
4280 static gboolean autosignalpoll_timeout(gpointer data)
4282 struct wifi_data *wifi = data;
4284 if (!wifi || !wifi->automaxspeed_timeout) {
4285 DBG("automaxspeed_timeout is found to be zero. i.e. currently in disconnected state. !!");
4289 int ret = network_signalpoll(wifi);
4291 DBG("Fail to get max speed !!");
4292 wifi->automaxspeed_timeout = 0;
4295 connman_network_unref(wifi->network);
4304 static struct connman_network_driver network_driver = {
4306 .type = CONNMAN_NETWORK_TYPE_WIFI,
4307 .priority = CONNMAN_NETWORK_PRIORITY_LOW,
4308 .probe = network_probe,
4309 .remove = network_remove,
4310 .connect = network_connect,
4311 .disconnect = network_disconnect,
4314 static void interface_added(GSupplicantInterface *interface)
4316 const char *ifname = g_supplicant_interface_get_ifname(interface);
4317 const char *driver = g_supplicant_interface_get_driver(interface);
4318 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
4320 * Note: If supplicant interface's driver is wired then skip it,
4321 * because it meanti only for ethernet not Wi-Fi.
4323 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
4325 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
4327 #if defined TIZEN_EXT
4328 bool is_5_0_ghz_supported = g_supplicant_interface_get_is_5_0_ghz_supported(interface);
4331 struct wifi_data *wifi;
4333 wifi = g_supplicant_interface_get_data(interface);
4335 wifi = get_pending_wifi_data(ifname);
4339 wifi->interface = interface;
4340 g_supplicant_interface_set_data(interface, wifi);
4341 p2p_iface_list = g_list_append(p2p_iface_list, wifi);
4342 wifi->p2p_device = true;
4345 DBG("ifname %s driver %s wifi %p tethering %d",
4346 ifname, driver, wifi, wifi->tethering);
4348 if (!wifi->device) {
4349 connman_error("WiFi device not set");
4353 connman_device_set_powered(wifi->device, true);
4354 #if defined TIZEN_EXT
4355 connman_device_set_wifi_5ghz_supported(wifi->device, is_5_0_ghz_supported);
4356 /* Max number of SSIDs supported by wlan chipset that can be scanned */
4357 int max_scan_ssids = g_supplicant_interface_get_max_scan_ssids(interface);
4358 connman_device_set_max_scan_ssids(wifi->device, max_scan_ssids);
4362 static bool is_idle(struct wifi_data *wifi)
4364 DBG("state %d", wifi->state);
4366 switch (wifi->state) {
4367 case G_SUPPLICANT_STATE_UNKNOWN:
4368 case G_SUPPLICANT_STATE_DISABLED:
4369 case G_SUPPLICANT_STATE_DISCONNECTED:
4370 case G_SUPPLICANT_STATE_INACTIVE:
4371 case G_SUPPLICANT_STATE_SCANNING:
4374 case G_SUPPLICANT_STATE_AUTHENTICATING:
4375 case G_SUPPLICANT_STATE_ASSOCIATING:
4376 case G_SUPPLICANT_STATE_ASSOCIATED:
4377 case G_SUPPLICANT_STATE_4WAY_HANDSHAKE:
4378 case G_SUPPLICANT_STATE_GROUP_HANDSHAKE:
4379 case G_SUPPLICANT_STATE_COMPLETED:
4386 static bool is_idle_wps(GSupplicantInterface *interface,
4387 struct wifi_data *wifi)
4389 /* First, let's check if WPS processing did not went wrong */
4390 if (g_supplicant_interface_get_wps_state(interface) ==
4391 G_SUPPLICANT_WPS_STATE_FAIL)
4394 /* Unlike normal connection, being associated while processing wps
4395 * actually means that we are idling. */
4396 switch (wifi->state) {
4397 case G_SUPPLICANT_STATE_UNKNOWN:
4398 case G_SUPPLICANT_STATE_DISABLED:
4399 case G_SUPPLICANT_STATE_DISCONNECTED:
4400 case G_SUPPLICANT_STATE_INACTIVE:
4401 case G_SUPPLICANT_STATE_SCANNING:
4402 case G_SUPPLICANT_STATE_ASSOCIATED:
4404 case G_SUPPLICANT_STATE_AUTHENTICATING:
4405 case G_SUPPLICANT_STATE_ASSOCIATING:
4406 case G_SUPPLICANT_STATE_4WAY_HANDSHAKE:
4407 case G_SUPPLICANT_STATE_GROUP_HANDSHAKE:
4408 case G_SUPPLICANT_STATE_COMPLETED:
4415 static bool handle_wps_completion(GSupplicantInterface *interface,
4416 struct connman_network *network,
4417 struct connman_device *device,
4418 struct wifi_data *wifi)
4422 wps = connman_network_get_bool(network, "WiFi.UseWPS");
4424 const unsigned char *ssid, *wps_ssid;
4425 unsigned int ssid_len, wps_ssid_len;
4426 struct disconnect_data *dd;
4427 const char *wps_key;
4429 /* Checking if we got associated with requested
4431 ssid = connman_network_get_blob(network, "WiFi.SSID",
4434 wps_ssid = g_supplicant_interface_get_wps_ssid(
4435 interface, &wps_ssid_len);
4437 if (!wps_ssid || wps_ssid_len != ssid_len ||
4438 memcmp(ssid, wps_ssid, ssid_len) != 0) {
4439 dd = g_malloc0(sizeof(*dd));
4441 dd->network = network;
4443 connman_network_set_associating(network, false);
4444 g_supplicant_interface_disconnect(wifi->interface,
4445 disconnect_callback, dd);
4446 #if defined TIZEN_EXT
4447 connman_network_set_bool(network, "WiFi.UseWPS", false);
4448 connman_network_set_string(network, "WiFi.PinWPS", NULL);
4453 wps_key = g_supplicant_interface_get_wps_key(interface);
4454 #if defined TIZEN_EXT
4455 /* Check the passphrase and encrypt it
4458 gchar *passphrase = g_strdup(wps_key);
4460 connman_network_set_string(network, "WiFi.PinWPS", NULL);
4462 if (check_passphrase_ext(network, passphrase) < 0) {
4463 DBG("[WPS] Invalid passphrase");
4468 ret = send_encryption_request(passphrase, network);
4473 DBG("[WPS] Encryption request succeeded");
4475 DBG("[WPS] Encryption request failed %d", ret);
4478 connman_network_set_string(network, "WiFi.Passphrase",
4481 connman_network_set_string(network, "WiFi.PinWPS", NULL);
4488 static bool handle_assoc_status_code(GSupplicantInterface *interface,
4489 struct wifi_data *wifi)
4491 #if defined TIZEN_EXT
4492 if ((wifi->state == G_SUPPLICANT_STATE_ASSOCIATING ||
4493 wifi->state == G_SUPPLICANT_STATE_AUTHENTICATING ||
4494 wifi->state == G_SUPPLICANT_STATE_ASSOCIATED) &&
4496 if (wifi->state == G_SUPPLICANT_STATE_ASSOCIATING &&
4497 wifi->assoc_code == ASSOC_STATUS_NO_CLIENT &&
4499 wifi->load_shaping_retries < LOAD_SHAPING_MAX_RETRIES) {
4500 wifi->load_shaping_retries ++;
4503 wifi->load_shaping_retries = 0;
4507 static bool handle_4way_handshake_failure(GSupplicantInterface *interface,
4508 struct connman_network *network,
4509 struct wifi_data *wifi)
4511 struct connman_service *service;
4513 #if defined TIZEN_EXT
4514 const char *security;
4515 if (wifi->connected)
4518 security = connman_network_get_string(network, "WiFi.Security");
4520 if (security && g_str_equal(security, "ieee8021x") == true &&
4521 wifi->state == G_SUPPLICANT_STATE_ASSOCIATED) {
4523 connman_network_set_error(network, CONNMAN_NETWORK_ERROR_INVALID_KEY);
4528 if (wifi->state != G_SUPPLICANT_STATE_4WAY_HANDSHAKE)
4531 if ((wifi->state != G_SUPPLICANT_STATE_4WAY_HANDSHAKE) &&
4532 !((wifi->state == G_SUPPLICANT_STATE_ASSOCIATING) &&
4533 (wifi->assoc_code == ASSOC_STATUS_AUTH_TIMEOUT)))
4536 if (wifi->connected)
4540 service = connman_service_lookup_from_network(network);
4546 if (connman_service_get_favorite(service)) {
4547 if (wifi->retries < FAVORITE_MAXIMUM_RETRIES)
4552 connman_network_set_error(network, CONNMAN_NETWORK_ERROR_INVALID_KEY);
4557 #if defined TIZEN_EXT
4558 static bool handle_wifi_assoc_retry(struct connman_network *network,
4559 struct wifi_data *wifi)
4561 const char *security;
4563 if (!wifi->network || wifi->connected || wifi->disconnecting ||
4564 connman_network_get_connecting(network) != true) {
4565 wifi->assoc_retry_count = 0;
4569 if (wifi->state != G_SUPPLICANT_STATE_AUTHENTICATING &&
4570 wifi->state != G_SUPPLICANT_STATE_ASSOCIATING &&
4571 wifi->state != G_SUPPLICANT_STATE_ASSOCIATED) {
4572 wifi->assoc_retry_count = 0;
4576 security = connman_network_get_string(network, "WiFi.Security");
4577 if (security && g_str_equal(security, "ieee8021x") == true &&
4578 wifi->state == G_SUPPLICANT_STATE_ASSOCIATED) {
4579 wifi->assoc_retry_count = 0;
4583 if (++wifi->assoc_retry_count >= TIZEN_ASSOC_RETRY_COUNT) {
4584 wifi->assoc_retry_count = 0;
4586 /* Honestly it's not an invalid-key error,
4587 * however QA team recommends that the invalid-key error
4588 * might be better to display for user experience.
4590 switch (wifi->state) {
4591 case G_SUPPLICANT_STATE_AUTHENTICATING:
4592 connman_network_set_error(network, CONNMAN_NETWORK_ERROR_AUTHENTICATE_FAIL);
4594 case G_SUPPLICANT_STATE_ASSOCIATED:
4595 connman_network_set_error(network, CONNMAN_NETWORK_ERROR_INVALID_KEY);
4598 connman_network_set_error(network, CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
4608 static void handle_wifi_roaming_complete(struct connman_network *network)
4610 const char *cur_bssid;
4611 const char *dst_bssid;
4613 struct connman_device *device;
4614 struct connman_service *service;
4615 struct connman_ipconfig *ipconfig_ipv4;
4616 enum connman_ipconfig_type type;
4617 enum connman_ipconfig_method method;
4619 if (!connman_setting_get_bool("WifiRoaming") ||
4620 !connman_network_get_bool(network, "WiFi.Roaming"))
4623 device = connman_network_get_device(network);
4625 ifname = connman_device_get_string(device, "Interface");
4626 cur_bssid = connman_network_get_string(network,
4627 "WiFi.RoamingCurBSSID");
4628 dst_bssid = connman_network_get_string(network,
4629 "WiFi.RoamingDstBSSID");
4632 if (device && ifname && cur_bssid && dst_bssid) {
4633 __connman_technology_notify_roaming_state(ifname,
4634 "success", cur_bssid, dst_bssid);
4635 connman_network_set_bool(network,
4636 "WiFi.Roaming", false);
4637 connman_network_set_string(network,
4638 "WiFi.RoamingCurBSSID", NULL);
4639 connman_network_set_string(network,
4640 "WiFi.RoamingDstBSSID", NULL);
4642 service = connman_service_lookup_from_network(network);
4646 ipconfig_ipv4 = __connman_service_get_ip4config(service);
4647 if (!ipconfig_ipv4) {
4648 connman_error("Service has no IPv4 configuration");
4652 type = __connman_ipconfig_get_config_type(ipconfig_ipv4);
4653 if (type != CONNMAN_IPCONFIG_TYPE_IPV4)
4656 method = __connman_ipconfig_get_method(ipconfig_ipv4);
4657 if (method != CONNMAN_IPCONFIG_METHOD_DHCP)
4660 connman_network_set_bool(network, "WiFi.RoamingDHCP", true);
4662 if (set_connected_dhcp(network) != 0)
4663 connman_network_set_bool(network, "WiFi.RoamingDHCP", false);
4668 static void interface_state(GSupplicantInterface *interface)
4670 struct connman_network *network;
4671 struct connman_device *device;
4672 struct wifi_data *wifi;
4673 GSupplicantState state = g_supplicant_interface_get_state(interface);
4674 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
4676 * Note: If supplicant interface's driver is wired then skip it,
4677 * because it meanti only for ethernet not Wi-Fi.
4679 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
4681 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
4686 wifi = g_supplicant_interface_get_data(interface);
4688 DBG("wifi %p interface state %d", wifi, state);
4693 device = wifi->device;
4697 if (state == G_SUPPLICANT_STATE_COMPLETED) {
4698 if (wifi->tethering_param) {
4699 g_free(wifi->tethering_param->ssid);
4700 g_free(wifi->tethering_param);
4701 wifi->tethering_param = NULL;
4704 if (wifi->tethering)
4705 stop_autoscan(device);
4708 if (g_supplicant_interface_get_ready(interface) &&
4709 !wifi->interface_ready) {
4710 wifi->interface_ready = true;
4711 finalize_interface_creation(wifi);
4714 network = wifi->network;
4719 case G_SUPPLICANT_STATE_SCANNING:
4720 #if defined TIZEN_EXT
4721 if (wifi->automaxspeed_timeout != 0) {
4722 g_source_remove(wifi->automaxspeed_timeout);
4723 wifi->automaxspeed_timeout = 0;
4724 DBG("Remove signalpoll timer!!");
4727 if (!connman_network_get_bool(wifi->network, "WiFi.Roaming"))
4729 if (wifi->connected)
4730 connman_network_set_connected(network, false);
4734 case G_SUPPLICANT_STATE_AUTHENTICATING:
4735 case G_SUPPLICANT_STATE_ASSOCIATING:
4736 #if defined TIZEN_EXT
4737 reset_autoscan(device);
4739 stop_autoscan(device);
4741 #if defined TIZEN_EXT
4742 if (!connman_network_get_bool(wifi->network, "WiFi.Roaming"))
4744 if (!wifi->connected)
4745 connman_network_set_associating(network, true);
4749 case G_SUPPLICANT_STATE_COMPLETED:
4750 #if defined TIZEN_EXT
4751 /* though it should be already reset: */
4752 reset_autoscan(device);
4754 wifi->assoc_retry_count = 0;
4756 wifi->scan_pending_network = NULL;
4758 /* should be cleared scanning flag */
4759 bool scanning = connman_device_get_scanning(device,
4760 CONNMAN_SERVICE_TYPE_WIFI);
4762 connman_device_set_scanning(device,
4763 CONNMAN_SERVICE_TYPE_WIFI, false);
4764 connman_device_unref(device);
4767 if (!wifi->automaxspeed_timeout) {
4768 DBG("Going to start signalpoll timer!!");
4769 int ret = network_signalpoll(wifi);
4771 DBG("Fail to get max speed !!");
4773 wifi->automaxspeed_timeout = g_timeout_add_seconds(10, autosignalpoll_timeout, wifi);
4776 g_hash_table_remove_all(failed_bssids);
4777 handle_wifi_roaming_complete(network);
4779 /* though it should be already stopped: */
4780 stop_autoscan(device);
4783 if (!handle_wps_completion(interface, network, device, wifi))
4786 connman_network_set_connected(network, true);
4788 wifi->disconnect_code = 0;
4789 wifi->assoc_code = 0;
4790 wifi->load_shaping_retries = 0;
4793 case G_SUPPLICANT_STATE_DISCONNECTED:
4794 #if defined TIZEN_EXT
4795 connman_network_set_strength(network, 0);
4796 connman_network_set_maxspeed(network, 0);
4798 if (wifi->automaxspeed_timeout != 0) {
4799 g_source_remove(wifi->automaxspeed_timeout);
4800 wifi->automaxspeed_timeout = 0;
4801 DBG("Remove signalpoll timer!!");
4805 * If we're in one of the idle modes, we have
4806 * not started association yet and thus setting
4807 * those ones to FALSE could cancel an association
4810 wps = connman_network_get_bool(network, "WiFi.UseWPS");
4812 if (is_idle_wps(interface, wifi))
4818 #if defined TIZEN_EXT
4819 if (!wifi->connected && handle_assoc_status_code(interface, wifi)) {
4820 const char *group = connman_network_get_group(network);
4821 GSupplicantNetwork *supplicant_network;
4822 GSList *bssid_list = NULL;
4823 guint bssid_length = 0;
4826 supplicant_network = g_supplicant_interface_get_network(interface, group);
4828 connman_network_set_assoc_reject_table(network,
4829 g_supplicant_network_clone_assoc_reject_table(supplicant_network));
4831 g_supplicant_network_update_assoc_reject(interface, supplicant_network);
4834 bssid_list = (GSList *)connman_network_get_bssid_list(network);
4836 bssid_length = g_slist_length(bssid_list);
4838 if (bssid_length > 1 && bssid_length > g_hash_table_size(failed_bssids)) {
4839 network_connect(network);
4843 wifi->load_shaping_retries = 0;
4846 g_hash_table_remove_all(failed_bssids);
4848 if (handle_assoc_status_code(interface, wifi))
4852 /* If previous state was 4way-handshake, then
4853 * it's either: psk was incorrect and thus we retry
4854 * or if we reach the maximum retries we declare the
4856 if (handle_4way_handshake_failure(interface,
4860 /* See table 8-36 Reason codes in IEEE Std 802.11 */
4861 switch (wifi->disconnect_code) {
4862 #if defined TIZEN_EXT
4863 case 1: /* Unspecified reason */
4864 /* Let's assume it's because we got blocked */
4866 case 6: /* Class 2 frame received from nonauthenticated STA */
4867 connman_network_set_error(network,
4868 CONNMAN_NETWORK_ERROR_BLOCKED);
4875 #if defined TIZEN_EXT
4876 /* Some of Wi-Fi networks are not comply Wi-Fi specification.
4877 * Retry association until its retry count is expired */
4878 if (handle_wifi_assoc_retry(network, wifi) == true) {
4879 throw_wifi_scan(wifi->device, scan_callback);
4880 wifi->scan_pending_network = wifi->network;
4884 if (wifi->disconnect_code > 0){
4885 DBG("Set disconnect reason code(%d)", wifi->disconnect_code);
4886 connman_network_set_disconnect_reason(network, wifi->disconnect_code);
4890 if (network != wifi->pending_network) {
4891 connman_network_set_connected(network, false);
4892 connman_network_set_associating(network, false);
4894 wifi->disconnecting = false;
4896 start_autoscan(device);
4900 case G_SUPPLICANT_STATE_INACTIVE:
4901 #if defined TIZEN_EXT
4902 if (handle_wps_completion(interface, network, device, wifi) == false)
4905 connman_network_set_associating(network, false);
4906 start_autoscan(device);
4910 case G_SUPPLICANT_STATE_UNKNOWN:
4911 case G_SUPPLICANT_STATE_DISABLED:
4912 case G_SUPPLICANT_STATE_ASSOCIATED:
4913 case G_SUPPLICANT_STATE_4WAY_HANDSHAKE:
4914 case G_SUPPLICANT_STATE_GROUP_HANDSHAKE:
4918 old_connected = wifi->connected;
4919 wifi->state = state;
4921 /* Saving wpa_s state policy:
4922 * If connected and if the state changes are roaming related:
4923 * --> We stay connected
4925 * --> We are connected
4927 * --> We are not connected
4930 case G_SUPPLICANT_STATE_AUTHENTICATING:
4931 case G_SUPPLICANT_STATE_ASSOCIATING:
4932 case G_SUPPLICANT_STATE_ASSOCIATED:
4933 case G_SUPPLICANT_STATE_4WAY_HANDSHAKE:
4934 case G_SUPPLICANT_STATE_GROUP_HANDSHAKE:
4935 if (wifi->connected)
4936 connman_warn("Probably roaming right now!"
4937 " Staying connected...");
4939 case G_SUPPLICANT_STATE_SCANNING:
4940 wifi->connected = false;
4943 start_autoscan(device);
4945 case G_SUPPLICANT_STATE_COMPLETED:
4946 wifi->connected = true;
4949 wifi->connected = false;
4956 static void interface_removed(GSupplicantInterface *interface)
4958 const char *ifname = g_supplicant_interface_get_ifname(interface);
4959 struct wifi_data *wifi;
4960 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
4962 * Note: If supplicant interface's driver is wired then skip it,
4963 * because it meanti only for ethernet not Wi-Fi.
4965 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
4967 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
4970 DBG("ifname %s", ifname);
4972 wifi = g_supplicant_interface_get_data(interface);
4974 #if defined TIZEN_EXT_WIFI_MESH
4975 if (wifi && wifi->mesh_interface) {
4976 DBG("Notify mesh interface remove");
4977 connman_mesh_notify_interface_remove(true);
4978 struct wifi_mesh_info *mesh_info = wifi->mesh_info;
4979 g_free(mesh_info->parent_ifname);
4980 g_free(mesh_info->ifname);
4981 g_free(mesh_info->identifier);
4983 wifi->mesh_interface = false;
4984 wifi->mesh_info = NULL;
4990 wifi->interface = NULL;
4992 if (wifi && wifi->tethering)
4995 if (!wifi || !wifi->device) {
4996 DBG("wifi interface already removed");
5000 connman_device_set_powered(wifi->device, false);
5002 check_p2p_technology();
5003 #if defined TIZEN_EXT_WIFI_MESH
5004 check_mesh_technology();
5008 static void set_device_type(const char *type, char dev_type[17])
5010 const char *oui = "0050F204";
5011 const char *category = "0001";
5012 const char *sub_category = "0000";
5014 if (!g_strcmp0(type, "handset")) {
5016 sub_category = "0005";
5017 } else if (!g_strcmp0(type, "vm") || !g_strcmp0(type, "container"))
5018 sub_category = "0001";
5019 else if (!g_strcmp0(type, "server"))
5020 sub_category = "0002";
5021 else if (!g_strcmp0(type, "laptop"))
5022 sub_category = "0005";
5023 else if (!g_strcmp0(type, "desktop"))
5024 sub_category = "0006";
5025 else if (!g_strcmp0(type, "tablet"))
5026 sub_category = "0009";
5027 else if (!g_strcmp0(type, "watch"))
5030 snprintf(dev_type, 17, "%s%s%s", category, oui, sub_category);
5033 static void p2p_support(GSupplicantInterface *interface)
5035 char dev_type[17] = {};
5036 const char *hostname;
5037 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
5039 * Note: If supplicant interface's driver is wired then skip it,
5040 * because it meanti only for ethernet not Wi-Fi.
5042 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
5044 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
5052 if (!g_supplicant_interface_has_p2p(interface))
5055 if (connman_technology_driver_register(&p2p_tech_driver) < 0) {
5056 DBG("Could not register P2P technology driver");
5060 hostname = connman_utsname_get_hostname();
5062 hostname = "ConnMan";
5064 set_device_type(connman_machine_get_type(), dev_type);
5065 g_supplicant_interface_set_p2p_device_config(interface,
5066 hostname, dev_type);
5067 connman_peer_driver_register(&peer_driver);
5070 static void scan_started(GSupplicantInterface *interface)
5072 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
5074 * Note: If supplicant interface's driver is wired then skip it,
5075 * because it meanti only for ethernet not Wi-Fi.
5077 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
5079 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
5084 static void scan_finished(GSupplicantInterface *interface)
5086 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
5088 * Note: If supplicant interface's driver is wired then skip it,
5089 * because it meanti only for ethernet not Wi-Fi.
5091 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
5093 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
5095 #if defined TIZEN_EXT
5096 struct wifi_data *wifi;
5097 bool is_associating = false;
5098 static bool is_scanning = true;
5103 #if defined TIZEN_EXT
5104 wifi = g_supplicant_interface_get_data(interface);
5105 if (wifi && wifi->scan_pending_network) {
5106 network_connect(wifi->scan_pending_network);
5107 wifi->scan_pending_network = NULL;
5110 //service state - associating
5111 if(!wifi || !wifi->network)
5114 is_associating = connman_network_get_associating(wifi->network);
5115 if(is_associating && is_scanning){
5116 is_scanning = false;
5117 DBG("send scan for connecting");
5118 throw_wifi_scan(wifi->device, scan_callback);
5129 static void ap_create_fail(GSupplicantInterface *interface)
5131 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
5133 * Note: If supplicant interface's driver is wired then skip it,
5134 * because it meanti only for ethernet not Wi-Fi.
5136 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
5138 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
5140 struct wifi_data *wifi = g_supplicant_interface_get_data(interface);
5143 if ((wifi->tethering) && (wifi->tethering_param)) {
5144 DBG("%s create AP fail \n",
5145 g_supplicant_interface_get_ifname(wifi->interface));
5147 connman_inet_remove_from_bridge(wifi->index, wifi->bridge);
5148 wifi->ap_supported = WIFI_AP_NOT_SUPPORTED;
5149 wifi->tethering = false;
5151 ret = tech_set_tethering(wifi->tethering_param->technology,
5152 wifi->tethering_param->ssid->ssid,
5153 wifi->tethering_param->ssid->passphrase,
5154 wifi->bridge, true);
5156 if ((ret == -EOPNOTSUPP) && (wifi_technology)) {
5157 connman_technology_tethering_notify(wifi_technology,false);
5160 g_free(wifi->tethering_param->ssid);
5161 g_free(wifi->tethering_param);
5162 wifi->tethering_param = NULL;
5166 static unsigned char calculate_strength(GSupplicantNetwork *supplicant_network)
5168 unsigned char strength;
5170 strength = 120 + g_supplicant_network_get_signal(supplicant_network);
5171 #if !defined TIZEN_EXT
5179 #if defined TIZEN_EXT_WIFI_MESH
5180 static void mesh_peer_added(GSupplicantNetwork *supplicant_network)
5182 GSupplicantInterface *interface;
5183 struct wifi_data *wifi;
5184 const char *name, *security;
5185 struct connman_mesh *connman_mesh;
5186 struct wifi_mesh_info *mesh_info;
5187 const unsigned char *bssid;
5188 const char *identifier;
5193 interface = g_supplicant_network_get_interface(supplicant_network);
5194 wifi = g_supplicant_interface_get_data(interface);
5195 if (!wifi || !wifi->mesh_interface) {
5196 DBG("Virtual Mesh interface not created");
5200 bssid = g_supplicant_network_get_bssid(supplicant_network);
5201 address = g_malloc0(19);
5202 snprintf(address, 19, "%02x:%02x:%02x:%02x:%02x:%02x", bssid[0], bssid[1],
5203 bssid[2], bssid[3], bssid[4], bssid[5]);
5205 identifier = g_supplicant_network_get_identifier(supplicant_network);
5206 name = g_supplicant_network_get_name(supplicant_network);
5207 security = g_supplicant_network_get_security(supplicant_network);
5208 frequency = g_supplicant_network_get_frequency(supplicant_network);
5210 mesh_info = wifi->mesh_info;
5211 connman_mesh = connman_mesh_get(mesh_info->identifier, identifier);
5215 DBG("Mesh Peer name %s identifier %s security %s added", name, identifier,
5217 connman_mesh = connman_mesh_create(mesh_info->identifier, identifier);
5218 connman_mesh_set_name(connman_mesh, name);
5219 connman_mesh_set_security(connman_mesh, security);
5220 connman_mesh_set_frequency(connman_mesh, frequency);
5221 connman_mesh_set_address(connman_mesh, address);
5222 connman_mesh_set_index(connman_mesh, mesh_info->index);
5223 connman_mesh_set_strength(connman_mesh,
5224 calculate_strength(supplicant_network));
5225 connman_mesh_set_peer_type(connman_mesh, CONNMAN_MESH_PEER_TYPE_DISCOVERED);
5227 ret = connman_mesh_register(connman_mesh);
5228 if (ret == -EALREADY)
5229 DBG("Mesh Peer is already registered");
5235 static void mesh_peer_removed(GSupplicantNetwork *supplicant_network)
5237 GSupplicantInterface *interface;
5238 struct wifi_data *wifi;
5239 struct connman_mesh *connman_mesh;
5240 struct wifi_mesh_info *mesh_info;
5241 const char *identifier;
5243 interface = g_supplicant_network_get_interface(supplicant_network);
5244 wifi = g_supplicant_interface_get_data(interface);
5245 if (!wifi || !wifi->mesh_interface) {
5246 DBG("Virtual Mesh interface not created");
5250 identifier = g_supplicant_network_get_identifier(supplicant_network);
5252 DBG("Failed to get Mesh Peer identifier");
5256 mesh_info = wifi->mesh_info;
5257 connman_mesh = connman_mesh_get(mesh_info->identifier, identifier);
5259 /* Do not unregister connected mesh peer */
5260 if (connman_mesh_peer_is_connected_state(connman_mesh)) {
5261 DBG("Mesh Peer %s is connected", identifier);
5264 DBG("Mesh Peer identifier %s removed", identifier);
5265 connman_mesh_unregister(connman_mesh);
5271 #if defined TIZEN_EXT
5272 static GSList *get_supported_security_list(unsigned int keymgmt,
5273 bool owe_transition_mode,
5274 GSupplicantNetwork *supplicant_network)
5276 GSList *sec_list = NULL;
5277 dbus_bool_t privacy = g_supplicant_network_get_privacy(supplicant_network);
5278 const char *enc_mode = g_supplicant_network_get_enc_mode(supplicant_network);
5281 (G_SUPPLICANT_KEYMGMT_WPA_EAP |
5282 G_SUPPLICANT_KEYMGMT_WPA_EAP_256))
5283 sec_list = g_slist_prepend (sec_list, "ieee8021x");
5284 else if (keymgmt & G_SUPPLICANT_KEYMGMT_WPA_FT_EAP)
5285 sec_list = g_slist_prepend (sec_list, "ft_ieee8021x");
5291 (G_SUPPLICANT_KEYMGMT_WPA_PSK |
5292 G_SUPPLICANT_KEYMGMT_WPA_PSK_256)) {
5293 if (!g_strcmp0(enc_mode, "aes"))
5294 sec_list = g_slist_prepend (sec_list, "rsn");
5295 else if (!g_strcmp0(enc_mode, "tkip"))
5296 sec_list = g_slist_prepend (sec_list, "psk");
5297 else if (!g_strcmp0(enc_mode, "mixed")) {
5298 sec_list = g_slist_prepend (sec_list, "psk");
5299 sec_list = g_slist_prepend (sec_list, "rsn");
5301 } else if (keymgmt & G_SUPPLICANT_KEYMGMT_WPA_FT_PSK)
5302 sec_list = g_slist_prepend (sec_list, "ft_psk");
5304 if (keymgmt & G_SUPPLICANT_KEYMGMT_SAE)
5305 sec_list = g_slist_prepend (sec_list, "sae");
5306 if (keymgmt & G_SUPPLICANT_KEYMGMT_OWE || owe_transition_mode)
5307 sec_list = g_slist_prepend (sec_list, "owe");
5308 if (keymgmt & G_SUPPLICANT_KEYMGMT_DPP)
5309 sec_list = g_slist_prepend (sec_list, "dpp");
5315 sec_list = g_slist_prepend (sec_list, "wep");
5317 sec_list = g_slist_prepend (sec_list, "none");
5323 static void network_added(GSupplicantNetwork *supplicant_network)
5325 struct connman_network *network;
5326 GSupplicantInterface *interface;
5327 struct wifi_data *wifi;
5328 const char *name, *identifier, *security, *group, *mode;
5329 const unsigned char *ssid;
5330 unsigned int ssid_len;
5334 bool wps_advertizing;
5336 #if defined TIZEN_EXT
5337 bool owe_transition_mode;
5338 const unsigned char *transition_mode_ssid;
5339 const unsigned char *transition_mode_bssid;
5340 unsigned int transition_mode_ssid_len;
5341 unsigned int keymgmt;
5342 GSList *vsie_list = NULL;
5343 GSList *sec_list = NULL;
5344 const unsigned char *country_code;
5345 ieee80211_modes_e phy_mode;
5348 mode = g_supplicant_network_get_mode(supplicant_network);
5349 identifier = g_supplicant_network_get_identifier(supplicant_network);
5350 #if defined TIZEN_EXT
5351 if (!simplified_log)
5353 DBG("%s", identifier);
5355 if (!g_strcmp0(mode, "adhoc"))
5358 #if defined TIZEN_EXT_WIFI_MESH
5359 if (!g_strcmp0(mode, "mesh")) {
5360 mesh_peer_added(supplicant_network);
5365 interface = g_supplicant_network_get_interface(supplicant_network);
5366 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
5368 * Note: If supplicant interface's driver is wired then skip it,
5369 * because it meanti only for ethernet not Wi-Fi.
5371 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
5373 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
5375 wifi = g_supplicant_interface_get_data(interface);
5376 name = g_supplicant_network_get_name(supplicant_network);
5377 security = g_supplicant_network_get_security(supplicant_network);
5378 group = g_supplicant_network_get_identifier(supplicant_network);
5379 wps = g_supplicant_network_get_wps(supplicant_network);
5380 wps_pbc = g_supplicant_network_is_wps_pbc(supplicant_network);
5381 wps_ready = g_supplicant_network_is_wps_active(supplicant_network);
5382 wps_advertizing = g_supplicant_network_is_wps_advertizing(
5383 supplicant_network);
5388 ssid = g_supplicant_network_get_ssid(supplicant_network, &ssid_len);
5390 network = connman_device_get_network(wifi->device, identifier);
5393 network = connman_network_create(identifier,
5394 CONNMAN_NETWORK_TYPE_WIFI);
5398 connman_network_set_index(network, wifi->index);
5400 if (connman_device_add_network(wifi->device, network) < 0) {
5401 connman_network_unref(network);
5405 wifi->networks = g_slist_prepend(wifi->networks, network);
5408 if (name && name[0] != '\0')
5409 connman_network_set_name(network, name);
5411 connman_network_set_blob(network, "WiFi.SSID",
5413 #if defined TIZEN_EXT
5414 vsie_list = (GSList *)g_supplicant_network_get_wifi_vsie(supplicant_network);
5416 connman_network_set_vsie_list(network, vsie_list);
5418 DBG("vsie_list is NULL");
5419 country_code = g_supplicant_network_get_countrycode(supplicant_network);
5420 connman_network_set_countrycode(network, country_code);
5421 phy_mode = g_supplicant_network_get_phy_mode(supplicant_network);
5422 connman_network_set_phy_mode(network, phy_mode);
5424 connman_network_set_string(network, "WiFi.Security", security);
5425 connman_network_set_strength(network,
5426 calculate_strength(supplicant_network));
5427 connman_network_set_bool(network, "WiFi.WPS", wps);
5428 connman_network_set_bool(network, "WiFi.WPSAdvertising",
5432 /* Is AP advertizing for WPS association?
5433 * If so, we decide to use WPS by default */
5434 if (wps_ready && wps_pbc &&
5436 #if !defined TIZEN_EXT
5437 connman_network_set_bool(network, "WiFi.UseWPS", true);
5439 DBG("wps is activating by ap but ignore it.");
5443 connman_network_set_frequency(network,
5444 g_supplicant_network_get_frequency(supplicant_network));
5446 #if defined TIZEN_EXT
5447 keymgmt = g_supplicant_network_get_keymgmt(supplicant_network);
5448 connman_network_set_bssid(network,
5449 g_supplicant_network_get_bssid(supplicant_network));
5450 owe_transition_mode = (bool)g_supplicant_network_get_transition_mode(supplicant_network);
5451 connman_network_set_bool(network, "WiFi.TRANSITION_MODE", owe_transition_mode);
5452 if (owe_transition_mode) {
5453 transition_mode_ssid = (unsigned char *)g_supplicant_network_get_transition_mode_ssid(supplicant_network, &transition_mode_ssid_len);
5454 connman_network_set_blob(network, "WiFi.TRANSITION_MODE_SSID",
5455 transition_mode_ssid, transition_mode_ssid_len);
5456 transition_mode_bssid = g_supplicant_network_get_transition_mode_bssid(supplicant_network);
5457 connman_network_set_transition_mode_bssid(network, transition_mode_bssid);
5460 sec_list = get_supported_security_list(keymgmt,
5461 owe_transition_mode, supplicant_network);
5463 connman_network_set_sec_list(network, sec_list);
5464 connman_network_set_maxrate(network,
5465 g_supplicant_network_get_maxrate(supplicant_network));
5466 connman_network_set_enc_mode(network,
5467 g_supplicant_network_get_enc_mode(supplicant_network));
5468 connman_network_set_rsn_mode(network,
5469 g_supplicant_network_get_rsn_mode(supplicant_network));
5470 connman_network_set_bool(network, "WiFi.PMFRequired",
5471 (bool)g_supplicant_network_is_pmf_required(supplicant_network));
5472 connman_network_set_keymgmt(network, keymgmt);
5473 connman_network_set_bool(network, "WiFi.HS20AP",
5474 g_supplicant_network_is_hs20AP(supplicant_network));
5475 connman_network_set_bssid_list(network,
5476 (GSList *)g_supplicant_network_get_bssid_list(supplicant_network));
5477 connman_network_set_last_connected_bssid(network,
5478 g_supplicant_network_get_last_connected_bssid(supplicant_network));
5479 connman_network_set_assoc_reject_table(network,
5480 g_supplicant_network_clone_assoc_reject_table(supplicant_network));
5482 connman_network_set_available(network, true);
5483 connman_network_set_string(network, "WiFi.Mode", mode);
5485 #if defined TIZEN_EXT
5490 connman_network_set_group(network, group);
5492 #if defined TIZEN_EXT
5493 g_supplicant_network_set_last_connected_bssid(supplicant_network,
5494 connman_network_get_last_connected_bssid(network));
5497 #if defined TIZEN_EXT
5498 if (wifi_first_scan == true)
5499 found_with_first_scan = true;
5502 if (wifi->hidden && ssid) {
5503 #if defined TIZEN_EXT
5504 if (network_security(wifi->hidden->security) ==
5505 network_security(security) &&
5507 if (!g_strcmp0(wifi->hidden->security, security) &&
5509 wifi->hidden->ssid_len == ssid_len &&
5510 !memcmp(wifi->hidden->ssid, ssid, ssid_len)) {
5511 connman_network_connect_hidden(network,
5512 wifi->hidden->identity,
5513 wifi->hidden->passphrase,
5514 wifi->hidden->user_data);
5515 wifi->hidden->user_data = NULL;
5516 hidden_free(wifi->hidden);
5517 wifi->hidden = NULL;
5522 static void network_removed(GSupplicantNetwork *network)
5524 GSupplicantInterface *interface;
5525 struct wifi_data *wifi;
5526 const char *name, *identifier;
5527 struct connman_network *connman_network;
5529 #if defined TIZEN_EXT_WIFI_MESH
5531 mode = g_supplicant_network_get_mode(network);
5532 if (!g_strcmp0(mode, "mesh")) {
5533 mesh_peer_removed(network);
5538 interface = g_supplicant_network_get_interface(network);
5539 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
5541 * Note: If supplicant interface's driver is wired then skip it,
5542 * because it meanti only for ethernet not Wi-Fi.
5544 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
5546 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
5548 wifi = g_supplicant_interface_get_data(interface);
5549 identifier = g_supplicant_network_get_identifier(network);
5550 name = g_supplicant_network_get_name(network);
5552 DBG("name %s", name);
5557 connman_network = connman_device_get_network(wifi->device, identifier);
5558 if (!connman_network)
5561 #if defined TIZEN_EXT
5562 if (connman_network == wifi->scan_pending_network)
5563 wifi->scan_pending_network = NULL;
5565 if (connman_network == wifi->pending_network)
5566 wifi->pending_network = NULL;
5568 if(connman_network_get_connecting(connman_network) == true){
5569 connman_network_set_connected(connman_network, false);
5573 wifi->networks = g_slist_remove(wifi->networks, connman_network);
5575 connman_device_remove_network(wifi->device, connman_network);
5576 connman_network_unref(connman_network);
5579 static void network_changed(GSupplicantNetwork *network, const char *property)
5581 GSupplicantInterface *interface;
5582 struct wifi_data *wifi;
5583 const char *name, *identifier;
5584 struct connman_network *connman_network;
5587 #if defined TIZEN_EXT
5588 const unsigned char *bssid;
5589 unsigned int maxrate;
5592 const unsigned char *country_code;
5593 ieee80211_modes_e phy_mode;
5597 interface = g_supplicant_network_get_interface(network);
5598 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
5600 * Note: If supplicant interface's driver is wired then skip it,
5601 * because it meanti only for ethernet not Wi-Fi.
5603 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
5605 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
5607 wifi = g_supplicant_interface_get_data(interface);
5608 identifier = g_supplicant_network_get_identifier(network);
5609 name = g_supplicant_network_get_name(network);
5611 #if defined TIZEN_EXT
5612 if (!simplified_log)
5613 DBG("name %s property %s", name, property);
5615 DBG("name %s", name);
5621 connman_network = connman_device_get_network(wifi->device, identifier);
5622 if (!connman_network)
5625 if (g_str_equal(property, "WPSCapabilities")) {
5629 bool wps_advertizing;
5631 wps = g_supplicant_network_get_wps(network);
5632 wps_pbc = g_supplicant_network_is_wps_pbc(network);
5633 wps_ready = g_supplicant_network_is_wps_active(network);
5635 g_supplicant_network_is_wps_advertizing(network);
5637 connman_network_set_bool(connman_network, "WiFi.WPS", wps);
5638 connman_network_set_bool(connman_network,
5639 "WiFi.WPSAdvertising", wps_advertizing);
5643 * Is AP advertizing for WPS association?
5644 * If so, we decide to use WPS by default
5646 if (wps_ready && wps_pbc && wps_advertizing)
5647 connman_network_set_bool(connman_network,
5648 "WiFi.UseWPS", true);
5651 update_needed = true;
5652 } else if (g_str_equal(property, "Signal")) {
5653 connman_network_set_strength(connman_network,
5654 calculate_strength(network));
5655 update_needed = true;
5657 #if defined TIZEN_EXT && defined TIZEN_EXT_INS
5658 else if (g_str_equal(property, "LastConnectedBSSID")) {
5659 const char *ident, *group;
5660 char *service_ident;
5663 ident = connman_device_get_ident(wifi->device);
5664 group = connman_network_get_group(connman_network);
5665 if (ident && group) {
5666 service_ident = g_strdup_printf("%s_%s_%s",
5667 __connman_network_get_type(connman_network), ident, group);
5669 need_save = connman_device_set_last_connected_ident(wifi->device, service_ident);
5671 connman_device_save_last_connected(wifi->device);
5673 g_free(service_ident);
5676 connman_network_set_last_connected_bssid(connman_network,
5677 g_supplicant_network_get_last_connected_bssid(network));
5679 update_needed = true;
5681 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_INS */
5682 #if defined TIZEN_EXT
5683 else if (g_str_equal(property, "UpdateAssocReject")) {
5684 connman_network_set_assoc_reject_table(connman_network,
5685 g_supplicant_network_clone_assoc_reject_table(network));
5686 update_needed = true;
5690 update_needed = false;
5693 connman_network_update(connman_network);
5695 #if defined TIZEN_EXT
5696 bssid = g_supplicant_network_get_bssid(network);
5697 maxrate = g_supplicant_network_get_maxrate(network);
5698 frequency = g_supplicant_network_get_frequency(network);
5699 wps = g_supplicant_network_get_wps(network);
5700 phy_mode = g_supplicant_network_get_phy_mode(network);
5702 connman_network_set_bssid(connman_network, bssid);
5703 connman_network_set_maxrate(connman_network, maxrate);
5704 connman_network_set_frequency(connman_network, frequency);
5705 connman_network_set_bool(connman_network, "WiFi.WPS", wps);
5706 country_code = g_supplicant_network_get_countrycode(network);
5707 connman_network_set_countrycode(connman_network, country_code);
5708 bssid_list = (GSList *)g_supplicant_network_get_bssid_list(network);
5709 connman_network_set_bssid_list(connman_network, bssid_list);
5710 connman_network_set_phy_mode(connman_network, phy_mode);
5712 if (g_str_equal(property, "CheckMultiBssidConnect") &&
5713 connman_network_get_associating(connman_network))
5714 network_connect(connman_network);
5718 static void network_associated(GSupplicantNetwork *network)
5720 GSupplicantInterface *interface;
5721 struct wifi_data *wifi;
5722 struct connman_network *connman_network;
5723 const char *identifier;
5727 interface = g_supplicant_network_get_interface(network);
5730 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
5732 * Note: If supplicant interface's driver is wired then skip it,
5733 * because it meanti only for ethernet not Wi-Fi.
5735 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
5737 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
5740 wifi = g_supplicant_interface_get_data(interface);
5744 /* P2P networks must not be treated as WiFi networks */
5745 if (wifi->p2p_connecting || wifi->p2p_device)
5748 identifier = g_supplicant_network_get_identifier(network);
5750 connman_network = connman_device_get_network(wifi->device, identifier);
5751 if (!connman_network)
5754 if (wifi->network) {
5755 if (wifi->network == connman_network)
5758 unsigned int ssid_len;
5759 DBG("network1 ssid[%s] , OWE[%d],ssid[%s]",
5760 (char *)connman_network_get_blob(wifi->network,"WiFi.SSID", &ssid_len),
5761 connman_network_get_bool(wifi->network,"WiFi.TRANSITION_MODE"),
5762 (char *)connman_network_get_blob(wifi->network,"WiFi.TRANSITION_MODE_SSID", &ssid_len));
5764 DBG("network1 ssid[%s], OWE[%d], ssid[%s]",
5765 (char *)connman_network_get_blob(connman_network,"WiFi.SSID",&ssid_len),
5766 connman_network_get_bool(connman_network,"WiFi.TRANSITION_MODE"),
5767 (char *)connman_network_get_blob(connman_network,"WiFi.TRANSITION_MODE_SSID", &ssid_len));
5768 if (connman_network_check_transition_mode(wifi->network, connman_network)) {//OWE trasition mode check
5769 DBG("OWE transition mode is TRUE");
5774 * This should never happen, we got associated with
5775 * a network different than the one we were expecting.
5777 DBG("Associated to %p while expecting %p",
5778 connman_network, wifi->network);
5780 connman_network_set_associating(wifi->network, false);
5783 DBG("Reconnecting to previous network %p from wpa_s", connman_network);
5785 wifi->network = connman_network_ref(connman_network);
5789 * Interface state changes callback (interface_state) is always
5790 * called before network_associated callback thus we need to call
5791 * interface_state again in order to process the new state now that
5792 * we have the network properly set.
5794 interface_state(interface);
5797 static void sta_authorized(GSupplicantInterface *interface,
5800 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
5802 * Note: If supplicant interface's driver is wired then skip it,
5803 * because it meanti only for ethernet not Wi-Fi.
5805 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
5807 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
5809 struct wifi_data *wifi = g_supplicant_interface_get_data(interface);
5811 DBG("wifi %p station %s authorized", wifi, addr);
5813 if (!wifi || !wifi->tethering)
5816 __connman_tethering_client_register(addr);
5819 static void sta_deauthorized(GSupplicantInterface *interface,
5822 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
5824 * Note: If supplicant interface's driver is wired then skip it,
5825 * because it meanti only for ethernet not Wi-Fi.
5827 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
5829 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
5831 struct wifi_data *wifi = g_supplicant_interface_get_data(interface);
5833 DBG("wifi %p station %s deauthorized", wifi, addr);
5835 if (!wifi || !wifi->tethering)
5838 __connman_tethering_client_unregister(addr);
5841 static void apply_peer_services(GSupplicantPeer *peer,
5842 struct connman_peer *connman_peer)
5844 const unsigned char *data;
5849 connman_peer_reset_services(connman_peer);
5851 data = g_supplicant_peer_get_widi_ies(peer, &length);
5853 connman_peer_add_service(connman_peer,
5854 CONNMAN_PEER_SERVICE_WIFI_DISPLAY, data, length);
5858 static void peer_found(GSupplicantPeer *peer)
5860 GSupplicantInterface *iface = g_supplicant_peer_get_interface(peer);
5861 struct wifi_data *wifi = g_supplicant_interface_get_data(iface);
5862 struct connman_peer *connman_peer;
5863 const char *identifier, *name;
5866 #if defined TIZEN_EXT
5870 identifier = g_supplicant_peer_get_identifier(peer);
5871 name = g_supplicant_peer_get_name(peer);
5873 DBG("ident: %s", identifier);
5875 connman_peer = connman_peer_get(wifi->device, identifier);
5879 connman_peer = connman_peer_create(identifier);
5880 connman_peer_set_name(connman_peer, name);
5881 connman_peer_set_device(connman_peer, wifi->device);
5882 apply_peer_services(peer, connman_peer);
5884 ret = connman_peer_register(connman_peer);
5885 if (ret < 0 && ret != -EALREADY)
5886 connman_peer_unref(connman_peer);
5888 wifi->peers = g_slist_prepend(wifi->peers, connman_peer);
5891 static void peer_lost(GSupplicantPeer *peer)
5893 GSupplicantInterface *iface = g_supplicant_peer_get_interface(peer);
5894 struct wifi_data *wifi = g_supplicant_interface_get_data(iface);
5895 struct connman_peer *connman_peer;
5896 const char *identifier;
5901 identifier = g_supplicant_peer_get_identifier(peer);
5903 DBG("ident: %s", identifier);
5905 connman_peer = connman_peer_get(wifi->device, identifier);
5907 if (wifi->p2p_connecting &&
5908 wifi->pending_peer == connman_peer) {
5909 peer_connect_timeout(wifi);
5911 connman_peer_unregister(connman_peer);
5912 connman_peer_unref(connman_peer);
5915 wifi->peers = g_slist_remove(wifi->peers, connman_peer);
5918 static void peer_changed(GSupplicantPeer *peer, GSupplicantPeerState state)
5920 GSupplicantInterface *iface = g_supplicant_peer_get_interface(peer);
5921 struct wifi_data *wifi = g_supplicant_interface_get_data(iface);
5922 enum connman_peer_state p_state = CONNMAN_PEER_STATE_UNKNOWN;
5923 struct connman_peer *connman_peer;
5924 const char *identifier;
5926 identifier = g_supplicant_peer_get_identifier(peer);
5928 DBG("ident: %s", identifier);
5933 connman_peer = connman_peer_get(wifi->device, identifier);
5938 case G_SUPPLICANT_PEER_SERVICES_CHANGED:
5939 apply_peer_services(peer, connman_peer);
5940 connman_peer_services_changed(connman_peer);
5942 case G_SUPPLICANT_PEER_GROUP_CHANGED:
5943 if (!g_supplicant_peer_is_in_a_group(peer))
5944 p_state = CONNMAN_PEER_STATE_IDLE;
5946 p_state = CONNMAN_PEER_STATE_CONFIGURATION;
5948 case G_SUPPLICANT_PEER_GROUP_STARTED:
5950 case G_SUPPLICANT_PEER_GROUP_FINISHED:
5951 p_state = CONNMAN_PEER_STATE_IDLE;
5953 case G_SUPPLICANT_PEER_GROUP_JOINED:
5954 connman_peer_set_iface_address(connman_peer,
5955 g_supplicant_peer_get_iface_address(peer));
5957 case G_SUPPLICANT_PEER_GROUP_DISCONNECTED:
5958 p_state = CONNMAN_PEER_STATE_IDLE;
5960 case G_SUPPLICANT_PEER_GROUP_FAILED:
5961 if (g_supplicant_peer_has_requested_connection(peer))
5962 p_state = CONNMAN_PEER_STATE_IDLE;
5964 p_state = CONNMAN_PEER_STATE_FAILURE;
5968 if (p_state == CONNMAN_PEER_STATE_CONFIGURATION ||
5969 p_state == CONNMAN_PEER_STATE_FAILURE) {
5970 if (wifi->p2p_connecting
5971 && connman_peer == wifi->pending_peer)
5972 peer_cancel_timeout(wifi);
5974 p_state = CONNMAN_PEER_STATE_UNKNOWN;
5977 if (p_state == CONNMAN_PEER_STATE_UNKNOWN)
5980 if (p_state == CONNMAN_PEER_STATE_CONFIGURATION) {
5981 GSupplicantInterface *g_iface;
5982 struct wifi_data *g_wifi;
5984 g_iface = g_supplicant_peer_get_group_interface(peer);
5988 g_wifi = g_supplicant_interface_get_data(g_iface);
5992 connman_peer_set_as_master(connman_peer,
5993 !g_supplicant_peer_is_client(peer));
5994 connman_peer_set_sub_device(connman_peer, g_wifi->device);
5997 * If wpa_supplicant didn't create a dedicated p2p-group
5998 * interface then mark this interface as p2p_device to avoid
5999 * scan and auto-scan are launched on it while P2P is connected.
6001 if (!g_list_find(p2p_iface_list, g_wifi))
6002 wifi->p2p_device = true;
6005 connman_peer_set_state(connman_peer, p_state);
6008 static void peer_request(GSupplicantPeer *peer)
6010 GSupplicantInterface *iface = g_supplicant_peer_get_interface(peer);
6011 struct wifi_data *wifi = g_supplicant_interface_get_data(iface);
6012 struct connman_peer *connman_peer;
6013 const char *identifier;
6015 #if defined TIZEN_EXT
6020 identifier = g_supplicant_peer_get_identifier(peer);
6022 DBG("ident: %s", identifier);
6024 connman_peer = connman_peer_get(wifi->device, identifier);
6028 connman_peer_request_connection(connman_peer);
6031 #if defined TIZEN_EXT
6032 static void system_power_off(void)
6035 struct wifi_data *wifi;
6036 struct connman_service *service;
6037 struct connman_ipconfig *ipconfig_ipv4;
6039 if (connman_setting_get_bool("WiFiDHCPRelease") == true) {
6040 for (list = iface_list; list; list = list->next) {
6043 if (wifi->network != NULL) {
6044 service = connman_service_lookup_from_network(wifi->network);
6045 ipconfig_ipv4 = __connman_service_get_ip4config(service);
6046 __connman_dhcp_stop(ipconfig_ipv4);
6052 static void network_merged(GSupplicantNetwork *network)
6054 GSupplicantInterface *interface;
6055 GSupplicantState state;
6056 struct wifi_data *wifi;
6057 const char *identifier;
6058 struct connman_network *connman_network;
6062 interface = g_supplicant_network_get_interface(network);
6066 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
6068 * Note: If supplicant interface's driver is wired then skip it,
6069 * because it meanti only for ethernet not Wi-Fi.
6071 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
6073 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
6075 state = g_supplicant_interface_get_state(interface);
6076 if (state < G_SUPPLICANT_STATE_AUTHENTICATING)
6079 wifi = g_supplicant_interface_get_data(interface);
6083 identifier = g_supplicant_network_get_identifier(network);
6085 connman_network = connman_device_get_network(wifi->device, identifier);
6086 if (!connman_network)
6089 DBG("merged identifier %s", identifier);
6091 if (wifi->connected == FALSE) {
6093 case G_SUPPLICANT_STATE_AUTHENTICATING:
6094 case G_SUPPLICANT_STATE_ASSOCIATING:
6095 case G_SUPPLICANT_STATE_ASSOCIATED:
6096 case G_SUPPLICANT_STATE_4WAY_HANDSHAKE:
6097 case G_SUPPLICANT_STATE_GROUP_HANDSHAKE:
6098 connman_network_set_associating(connman_network, TRUE);
6100 case G_SUPPLICANT_STATE_COMPLETED:
6101 connman_network_set_connected(connman_network, TRUE);
6104 DBG("Not handled the state : %d", state);
6109 ishs20AP = g_supplicant_network_is_hs20AP(network);
6112 g_strcmp0(g_supplicant_network_get_security(network), "ieee8021x") == 0) {
6113 temp = g_ascii_strdown(g_supplicant_network_get_eap(network), -1);
6114 connman_network_set_string(connman_network, "WiFi.EAP",
6116 connman_network_set_string(connman_network, "WiFi.Identity",
6117 g_supplicant_network_get_identity(network));
6118 connman_network_set_string(connman_network, "WiFi.Phase2",
6119 g_supplicant_network_get_phase2(network));
6124 wifi->network = connman_network;
6127 static void assoc_failed(void *user_data)
6129 struct connman_network *network = user_data;
6130 connman_network_set_associating(network, false);
6133 static void scan_done(GSupplicantInterface *interface)
6135 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
6137 * Note: If supplicant interface's driver is wired then skip it,
6138 * because it meanti only for ethernet not Wi-Fi.
6140 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
6142 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
6145 int scan_type = CONNMAN_SCAN_TYPE_WPA_SUPPLICANT;
6146 struct wifi_data *wifi;
6149 for (list = iface_list; list; list = list->next) {
6152 if (interface == wifi->interface) {
6153 scanning = connman_device_get_scanning(wifi->device,
6154 CONNMAN_SERVICE_TYPE_WIFI);
6156 __connman_technology_notify_scan_done(
6157 connman_device_get_string(wifi->device, "Interface"), scan_type);
6164 static void debug(const char *str)
6166 #if defined TIZEN_EXT
6167 if (connman_setting_get_bool("ConnmanSupplicantDebug"))
6169 if (getenv("CONNMAN_SUPPLICANT_DEBUG"))
6171 connman_debug("%s", str);
6174 static void disconnect_reasoncode(GSupplicantInterface *interface,
6177 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
6179 * Note: If supplicant interface's driver is wired then skip it,
6180 * because it meanti only for ethernet not Wi-Fi.
6182 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
6184 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
6186 struct wifi_data *wifi = g_supplicant_interface_get_data(interface);
6189 wifi->disconnect_code = reasoncode;
6193 static void assoc_status_code(GSupplicantInterface *interface, int status_code)
6195 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
6197 * Note: If supplicant interface's driver is wired then skip it,
6198 * because it meanti only for ethernet not Wi-Fi.
6200 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
6202 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
6204 struct wifi_data *wifi = g_supplicant_interface_get_data(interface);
6207 wifi->assoc_code = status_code;
6211 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
6212 static GSupplicantCallbacks callbacks = {
6213 #else /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
6214 static const GSupplicantCallbacks callbacks = {
6215 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
6216 .system_ready = system_ready,
6217 .system_killed = system_killed,
6218 .interface_added = interface_added,
6219 .interface_state = interface_state,
6220 .interface_removed = interface_removed,
6221 .p2p_support = p2p_support,
6222 .scan_started = scan_started,
6223 .scan_finished = scan_finished,
6224 .ap_create_fail = ap_create_fail,
6225 .network_added = network_added,
6226 .network_removed = network_removed,
6227 .network_changed = network_changed,
6228 .network_associated = network_associated,
6229 .sta_authorized = sta_authorized,
6230 .sta_deauthorized = sta_deauthorized,
6231 .peer_found = peer_found,
6232 .peer_lost = peer_lost,
6233 .peer_changed = peer_changed,
6234 .peer_request = peer_request,
6235 #if defined TIZEN_EXT
6236 .system_power_off = system_power_off,
6237 .network_merged = network_merged,
6238 .assoc_failed = assoc_failed,
6239 .scan_done = scan_done,
6242 .disconnect_reasoncode = disconnect_reasoncode,
6243 .assoc_status_code = assoc_status_code,
6244 #if defined TIZEN_EXT_WIFI_MESH
6245 .mesh_support = mesh_support,
6246 .mesh_group_started = mesh_group_started,
6247 .mesh_group_removed = mesh_group_removed,
6248 .mesh_peer_connected = mesh_peer_connected,
6249 .mesh_peer_disconnected = mesh_peer_disconnected,
6254 static int tech_probe(struct connman_technology *technology)
6256 wifi_technology = technology;
6261 static void tech_remove(struct connman_technology *technology)
6263 wifi_technology = NULL;
6266 static GSupplicantSSID *ssid_ap_init(const char *ssid, const char *passphrase)
6268 GSupplicantSSID *ap;
6270 ap = g_try_malloc0(sizeof(GSupplicantSSID));
6274 ap->mode = G_SUPPLICANT_MODE_MASTER;
6275 #if defined TIZEN_EXT
6276 ap->ssid = (void *) ssid;
6280 ap->ssid_len = strlen(ssid);
6284 if (!passphrase || strlen(passphrase) == 0) {
6285 ap->security = G_SUPPLICANT_SECURITY_NONE;
6286 ap->passphrase = NULL;
6288 ap->security = G_SUPPLICANT_SECURITY_PSK;
6289 ap->protocol = G_SUPPLICANT_PROTO_RSN;
6290 ap->pairwise_cipher = G_SUPPLICANT_PAIRWISE_CCMP;
6291 ap->group_cipher = G_SUPPLICANT_GROUP_CCMP;
6292 ap->passphrase = passphrase;
6298 static void ap_start_callback(int result, GSupplicantInterface *interface,
6301 struct wifi_tethering_info *info = user_data;
6303 DBG("result %d index %d bridge %s",
6304 result, info->wifi->index, info->wifi->bridge);
6306 if ((result < 0) || (info->wifi->ap_supported != WIFI_AP_SUPPORTED)) {
6307 connman_inet_remove_from_bridge(info->wifi->index,
6308 info->wifi->bridge);
6310 if (info->wifi->ap_supported == WIFI_AP_SUPPORTED) {
6311 connman_technology_tethering_notify(info->technology, false);
6312 g_free(info->wifi->tethering_param->ssid);
6313 g_free(info->wifi->tethering_param);
6314 info->wifi->tethering_param = NULL;
6318 g_free(info->ifname);
6322 static void ap_create_callback(int result,
6323 GSupplicantInterface *interface,
6326 struct wifi_tethering_info *info = user_data;
6328 DBG("result %d ifname %s", result,
6329 g_supplicant_interface_get_ifname(interface));
6331 if ((result < 0) || (info->wifi->ap_supported != WIFI_AP_SUPPORTED)) {
6332 connman_inet_remove_from_bridge(info->wifi->index,
6333 info->wifi->bridge);
6335 if (info->wifi->ap_supported == WIFI_AP_SUPPORTED) {
6336 connman_technology_tethering_notify(info->technology, false);
6337 g_free(info->wifi->tethering_param->ssid);
6338 g_free(info->wifi->tethering_param);
6339 info->wifi->tethering_param = NULL;
6343 g_free(info->ifname);
6349 info->wifi->interface = interface;
6350 g_supplicant_interface_set_data(interface, info->wifi);
6352 if (g_supplicant_interface_set_apscan(interface, 2) < 0)
6353 connman_error("Failed to set interface ap_scan property");
6355 g_supplicant_interface_connect(interface, info->ssid,
6356 ap_start_callback, info);
6359 static void sta_remove_callback(int result,
6360 GSupplicantInterface *interface,
6363 struct wifi_tethering_info *info = user_data;
6364 const char *driver = connman_setting_get_string("wifi");
6366 DBG("ifname %s result %d ", info->ifname, result);
6368 if ((result < 0) || (info->wifi->ap_supported != WIFI_AP_SUPPORTED)) {
6369 info->wifi->tethering = false;
6370 connman_technology_tethering_notify(info->technology, false);
6372 if (info->wifi->ap_supported == WIFI_AP_SUPPORTED) {
6373 g_free(info->wifi->tethering_param->ssid);
6374 g_free(info->wifi->tethering_param);
6375 info->wifi->tethering_param = NULL;
6378 g_free(info->ifname);
6384 info->wifi->interface = NULL;
6386 g_supplicant_interface_create(info->ifname, driver, info->wifi->bridge,
6389 #endif /* TIZEN_EXT */
6394 static int enable_wifi_tethering(struct connman_technology *technology,
6395 const char *bridge, const char *identifier,
6396 const char *passphrase, bool available)
6399 GSupplicantInterface *interface;
6400 struct wifi_data *wifi;
6401 struct wifi_tethering_info *info;
6406 for (list = iface_list; list; list = list->next) {
6409 DBG("wifi %p network %p pending_network %p", wifi,
6410 wifi->network, wifi->pending_network);
6412 interface = wifi->interface;
6417 ifname = g_supplicant_interface_get_ifname(wifi->interface);
6421 if (wifi->ap_supported == WIFI_AP_NOT_SUPPORTED) {
6422 DBG("%s does not support AP mode (detected)", ifname);
6426 mode = g_supplicant_interface_get_mode(interface);
6427 if ((mode & G_SUPPLICANT_CAPABILITY_MODE_AP) == 0) {
6428 wifi->ap_supported = WIFI_AP_NOT_SUPPORTED;
6429 DBG("%s does not support AP mode (capability)", ifname);
6433 if (wifi->network && available)
6436 info = g_try_malloc0(sizeof(struct wifi_tethering_info));
6440 wifi->tethering_param = g_try_malloc0(sizeof(struct wifi_tethering_info));
6441 if (!wifi->tethering_param) {
6447 info->technology = technology;
6448 info->wifi->bridge = bridge;
6449 info->ssid = ssid_ap_init(identifier, passphrase);
6453 info->ifname = g_strdup(ifname);
6455 wifi->tethering_param->technology = technology;
6456 wifi->tethering_param->ssid = ssid_ap_init(identifier, passphrase);
6457 if (!wifi->tethering_param->ssid)
6460 info->wifi->tethering = true;
6461 info->wifi->ap_supported = WIFI_AP_SUPPORTED;
6463 berr = connman_technology_tethering_notify(technology, true);
6467 err = g_supplicant_interface_remove(interface,
6468 sta_remove_callback,
6471 DBG("tethering wifi %p ifname %s", wifi, ifname);
6476 g_free(info->ifname);
6479 g_free(wifi->tethering_param);
6480 wifi->tethering_param = NULL;
6483 * Remove bridge if it was correctly created but remove
6484 * operation failed. Instead, if bridge creation failed then
6485 * break out and do not try again on another interface,
6486 * bridge set-up does not depend on it.
6489 connman_technology_tethering_notify(technology, false);
6497 static int tech_set_tethering(struct connman_technology *technology,
6498 const char *identifier, const char *passphrase,
6499 const char *bridge, bool enabled)
6502 struct wifi_data *wifi;
6508 for (list = iface_list; list; list = list->next) {
6511 if (wifi->tethering) {
6512 wifi->tethering = false;
6514 connman_inet_remove_from_bridge(wifi->index,
6516 wifi->bridged = false;
6520 connman_technology_tethering_notify(technology, false);
6525 DBG("trying tethering for available devices");
6526 err = enable_wifi_tethering(technology, bridge, identifier, passphrase,
6530 DBG("trying tethering for any device");
6531 err = enable_wifi_tethering(technology, bridge, identifier,
6538 static void regdom_callback(int result, const char *alpha2, void *user_data)
6542 if (!wifi_technology)
6548 connman_technology_regdom_notify(wifi_technology, alpha2);
6551 static int tech_set_regdom(struct connman_technology *technology, const char *alpha2)
6553 return g_supplicant_set_country(alpha2, regdom_callback, NULL);
6556 #if defined TIZEN_EXT && defined TIZEN_EXT_INS
6557 static void supp_ins_init(void)
6560 GSupplicantINSPreferredFreq preferred_freq;
6562 string = connman_setting_get_string("INSPreferredFreqBSSID");
6563 if (g_strcmp0(string, "5GHz") == 0)
6564 preferred_freq = G_SUPPLICANT_INS_PREFERRED_FREQ_5GHZ;
6565 else if (g_strcmp0(string, "2.4GHz") == 0)
6566 preferred_freq = G_SUPPLICANT_INS_PREFERRED_FREQ_24GHZ;
6568 preferred_freq = G_SUPPLICANT_INS_PREFERRED_FREQ_UNKNOWN;
6570 g_supplicant_set_ins_settings(preferred_freq,
6571 connman_setting_get_bool("INSLastConnectedBSSID"),
6572 connman_setting_get_bool("INSAssocReject"),
6573 connman_setting_get_bool("INSSignalBSSID"),
6574 connman_setting_get_uint("INSPreferredFreqBSSIDScore"),
6575 connman_setting_get_uint("INSLastConnectedBSSIDScore"),
6576 connman_setting_get_uint("INSAssocRejectScore"),
6577 connman_setting_get_int("INSSignalLevel3_5GHz"),
6578 connman_setting_get_int("INSSignalLevel3_24GHz")
6581 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_INS */
6583 static struct connman_technology_driver tech_driver = {
6585 .type = CONNMAN_SERVICE_TYPE_WIFI,
6586 .probe = tech_probe,
6587 .remove = tech_remove,
6588 .set_tethering = tech_set_tethering,
6589 .set_regdom = tech_set_regdom,
6592 static int wifi_init(void)
6596 err = connman_network_driver_register(&network_driver);
6600 err = g_supplicant_register(&callbacks);
6602 connman_network_driver_unregister(&network_driver);
6606 err = connman_technology_driver_register(&tech_driver);
6608 g_supplicant_unregister(&callbacks);
6609 connman_network_driver_unregister(&network_driver);
6613 #if defined TIZEN_EXT
6614 failed_bssids = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
6617 #if defined TIZEN_EXT && defined TIZEN_EXT_INS
6619 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_INS */
6623 static void wifi_exit(void)
6627 connman_technology_driver_unregister(&tech_driver);
6629 g_supplicant_unregister(&callbacks);
6631 connman_network_driver_unregister(&network_driver);
6633 #if defined TIZEN_EXT
6634 g_hash_table_unref(failed_bssids);
6638 CONNMAN_PLUGIN_DEFINE(wifi, "WiFi interface plugin", VERSION,
6639 CONNMAN_PLUGIN_PRIORITY_DEFAULT, wifi_init, wifi_exit)