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/option.h>
53 #include <connman/storage.h>
54 #include <include/setting.h>
55 #include <connman/provision.h>
56 #include <connman/utsname.h>
57 #include <connman/machine.h>
58 #include <connman/tethering.h>
60 #include <gsupplicant/gsupplicant.h>
62 #define CLEANUP_TIMEOUT 8 /* in seconds */
63 #define INACTIVE_TIMEOUT 12 /* in seconds */
64 #define FAVORITE_MAXIMUM_RETRIES 2
66 #define BGSCAN_DEFAULT "simple:30:-45:300"
67 #define AUTOSCAN_EXPONENTIAL "exponential:3:300"
68 #define AUTOSCAN_SINGLE "single:3"
70 #define P2P_FIND_TIMEOUT 30
71 #define P2P_CONNECTION_TIMEOUT 100
72 #define P2P_LISTEN_PERIOD 500
73 #define P2P_LISTEN_INTERVAL 2000
75 #define ASSOC_STATUS_NO_CLIENT 17
77 #define LOAD_SHAPING_MAX_RETRIES 7
79 #define LOAD_SHAPING_MAX_RETRIES 3
83 #define WIFI_EAP_FAST_PAC_FILE "/var/lib/wifi/wifi.pac" /* path of Pac file for EAP-FAST */
86 static struct connman_technology *wifi_technology = NULL;
87 static struct connman_technology *p2p_technology = NULL;
89 enum wifi_ap_capability{
91 WIFI_AP_SUPPORTED = 1,
92 WIFI_AP_NOT_SUPPORTED = 2,
95 enum wifi_scanning_type {
96 WIFI_SCANNING_UNKNOWN = 0,
97 WIFI_SCANNING_PASSIVE = 1,
98 WIFI_SCANNING_ACTIVE = 2,
101 struct hidden_params {
103 unsigned int ssid_len;
105 char *anonymous_identity;
107 char *altsubject_match;
108 char *domain_suffix_match;
112 GSupplicantScanParams *scan_params;
117 * Used for autoscan "emulation".
118 * Should be removed when wpa_s autoscan support will be by default.
120 struct autoscan_params {
124 unsigned int timeout;
127 struct wifi_tethering_info {
128 struct wifi_data *wifi;
129 struct connman_technology *technology;
131 GSupplicantSSID *ssid;
136 struct connman_device *device;
137 struct connman_network *network;
138 struct connman_network *pending_network;
140 GSupplicantInterface *interface;
141 GSupplicantState state;
145 enum wifi_ap_capability ap_supported;
147 bool interface_ready;
153 int load_shaping_retries;
154 struct hidden_params *hidden;
155 bool postpone_hidden;
156 struct wifi_tethering_info *tethering_param;
158 * autoscan "emulation".
160 struct autoscan_params *autoscan;
161 enum wifi_scanning_type scanning_type;
162 GSupplicantScanParams *scan_params;
163 unsigned int p2p_find_timeout;
164 unsigned int p2p_connection_timeout;
165 struct connman_peer *pending_peer;
170 #if defined TIZEN_EXT
171 int assoc_retry_count;
172 struct connman_network *scan_pending_network;
173 bool allow_full_scan;
174 unsigned int automaxspeed_timeout;
175 GSupplicantScanParams *hidden_scan_params;
179 #if defined TIZEN_EXT_WIFI_MESH
181 struct wifi_mesh_info *mesh_info;
185 #if defined TIZEN_EXT
189 #define TIZEN_ASSOC_RETRY_COUNT 4
191 static gboolean wifi_first_scan = false;
192 static gboolean found_with_first_scan = false;
193 static gboolean is_wifi_notifier_registered = false;
194 static GHashTable *failed_bssids = NULL;
195 static unsigned char buff_bssid[WIFI_BSSID_LEN_MAX] = { 0, };
199 static GList *iface_list = NULL;
201 static GList *pending_wifi_device = NULL;
202 static GList *p2p_iface_list = NULL;
203 static bool wfd_service_registered = false;
205 static void start_autoscan(struct connman_device *device);
206 static int tech_set_tethering(struct connman_technology *technology,
207 const char *identifier, const char *passphrase,
208 const char *bridge, bool enabled);
210 #if defined TIZEN_EXT
211 #define NETCONFIG_SERVICE "net.netconfig"
212 #define NETCONFIG_WIFI_PATH "/net/netconfig/wifi"
213 #define NETCONFIG_WIFI_INTERFACE NETCONFIG_SERVICE ".wifi"
215 struct enc_method_call_data {
216 DBusConnection *connection;
217 struct connman_network *network;
220 static struct enc_method_call_data encrypt_request_data;
222 static void encryption_request_reply(DBusPendingCall *call,
227 DBusMessageIter args;
229 struct connman_service *service;
230 gchar* encrypted_value = NULL;
231 struct connman_network *network = encrypt_request_data.network;
235 reply = dbus_pending_call_steal_reply(call);
237 dbus_error_init(&error);
238 if (dbus_set_error_from_message(&error, reply)) {
239 DBG("send_encryption_request() %s %s", error.name, error.message);
240 dbus_error_free(&error);
244 if (dbus_message_iter_init(reply, &args) == FALSE)
247 dbus_message_iter_get_basic(&args, &out_data);
249 encrypted_value = g_strdup((const gchar *)out_data);
250 service = connman_service_lookup_from_network(network);
253 DBG("encryption result: no service");
257 if (connman_service_get_favorite(service)) {
258 __connman_service_set_passphrase(service, encrypted_value);
259 __connman_service_save(service);
261 connman_network_set_string(network, "WiFi.Passphrase",
264 DBG("encryption result: succeeded");
267 dbus_message_unref(reply);
268 dbus_pending_call_unref(call);
269 dbus_connection_unref(encrypt_request_data.connection);
270 g_free(encrypted_value);
272 encrypt_request_data.connection = NULL;
273 encrypt_request_data.network = NULL;
276 static int send_encryption_request(const char *passphrase,
277 struct connman_network *network)
279 DBusConnection *connection = NULL;
280 DBusMessage *msg = NULL;
281 DBusPendingCall *call;
284 DBG("Invalid parameter");
288 connection = connman_dbus_get_connection();
290 DBG("dbus connection does not exist");
294 msg = dbus_message_new_method_call(NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
295 NETCONFIG_WIFI_INTERFACE, "EncryptPassphrase");
297 dbus_connection_unref(connection);
301 dbus_message_append_args(msg, DBUS_TYPE_STRING, &passphrase,
304 if (!dbus_connection_send_with_reply(connection, msg,
305 &call, DBUS_TIMEOUT_USE_DEFAULT)) {
306 dbus_message_unref(msg);
307 dbus_connection_unref(connection);
312 dbus_message_unref(msg);
313 dbus_connection_unref(connection);
317 encrypt_request_data.connection = connection;
318 encrypt_request_data.network = network;
320 dbus_pending_call_set_notify(call, encryption_request_reply, NULL, NULL);
321 dbus_message_unref(msg);
327 static int p2p_tech_probe(struct connman_technology *technology)
329 p2p_technology = technology;
334 static void p2p_tech_remove(struct connman_technology *technology)
336 p2p_technology = NULL;
339 static struct connman_technology_driver p2p_tech_driver = {
341 .type = CONNMAN_SERVICE_TYPE_P2P,
342 .probe = p2p_tech_probe,
343 .remove = p2p_tech_remove,
346 static bool is_p2p_connecting(void)
350 for (list = iface_list; list; list = list->next) {
351 struct wifi_data *wifi = list->data;
353 if (wifi->p2p_connecting)
360 static void add_pending_wifi_device(struct wifi_data *wifi)
362 if (g_list_find(pending_wifi_device, wifi))
365 pending_wifi_device = g_list_append(pending_wifi_device, wifi);
368 #if defined TIZEN_EXT_WIFI_MESH
369 struct wifi_mesh_info {
370 struct wifi_data *wifi;
371 GSupplicantInterface *interface;
372 struct connman_mesh *mesh;
379 struct mesh_change_peer_status_info {
381 enum connman_mesh_peer_status peer_status;
382 mesh_change_peer_status_cb_t callback;
386 static struct connman_technology_driver mesh_tech_driver = {
388 .type = CONNMAN_SERVICE_TYPE_MESH,
391 static void mesh_interface_create_callback(int result,
392 GSupplicantInterface *interface,
395 struct wifi_mesh_info *mesh_info = user_data;
396 struct wifi_data *wifi;
397 bool success = false;
399 DBG("result %d ifname %s, mesh_info %p", result,
400 g_supplicant_interface_get_ifname(interface),
403 if (result < 0 || !mesh_info)
406 wifi = mesh_info->wifi;
408 mesh_info->interface = interface;
409 mesh_info->identifier = connman_inet_ifaddr(mesh_info->ifname);
410 mesh_info->index = connman_inet_ifindex(mesh_info->ifname);
411 DBG("Mesh Interface identifier %s", mesh_info->identifier);
412 wifi->mesh_interface = true;
413 wifi->mesh_info = mesh_info;
414 g_supplicant_interface_set_data(interface, wifi);
418 connman_mesh_notify_interface_create(success);
421 static int add_mesh_interface(const char *ifname, const char *parent_ifname)
424 struct wifi_data *wifi;
425 struct wifi_mesh_info *mesh_info;
426 const char *wifi_ifname;
427 bool parent_found = false;
428 const char *driver = "nl80211";
430 for (list = iface_list; list; list = list->next) {
433 if (!g_supplicant_interface_has_mesh(wifi->interface))
436 wifi_ifname = g_supplicant_interface_get_ifname(wifi->interface);
440 if (!g_strcmp0(wifi_ifname, parent_ifname)) {
447 DBG("Parent interface %s doesn't exist", parent_ifname);
451 mesh_info = g_try_malloc0(sizeof(struct wifi_mesh_info));
455 mesh_info->wifi = wifi;
456 mesh_info->ifname = g_strdup(ifname);
457 mesh_info->parent_ifname = g_strdup(parent_ifname);
459 g_supplicant_mesh_interface_create(ifname, driver, NULL, parent_ifname,
460 mesh_interface_create_callback, mesh_info);
464 static void mesh_interface_remove_callback(int result,
465 GSupplicantInterface *interface,
468 struct wifi_data *wifi = user_data;
469 struct wifi_mesh_info *mesh_info = wifi->mesh_info;
470 bool success = false;
472 DBG("result %d mesh_info %p", result, mesh_info);
474 if (result < 0 || !mesh_info)
477 mesh_info->interface = NULL;
478 g_free(mesh_info->parent_ifname);
479 g_free(mesh_info->ifname);
480 g_free(mesh_info->identifier);
482 wifi->mesh_interface = false;
483 wifi->mesh_info = NULL;
487 connman_mesh_notify_interface_remove(success);
490 static int remove_mesh_interface(const char *ifname)
493 struct wifi_data *wifi;
494 struct wifi_mesh_info *mesh_info;
495 bool mesh_if_found = false;
498 for (list = iface_list; list; list = list->next) {
501 if (wifi->mesh_interface) {
502 mesh_if_found = true;
507 if (!mesh_if_found) {
508 DBG("Mesh interface %s doesn't exist", ifname);
512 mesh_info = wifi->mesh_info;
513 ret = g_supplicant_interface_remove(mesh_info->interface,
514 mesh_interface_remove_callback, wifi);
521 static void mesh_disconnect_callback(int result,
522 GSupplicantInterface *interface, void *user_data)
524 struct connman_mesh *mesh = user_data;
526 DBG("result %d interface %p mesh %p", result, interface, mesh);
529 static int mesh_peer_disconnect(struct connman_mesh *mesh)
532 struct wifi_data *wifi;
533 struct wifi_mesh_info *mesh_info;
534 bool mesh_if_found = false;
535 GSupplicantInterface *interface;
537 for (list = iface_list; list; list = list->next) {
540 if (wifi->mesh_interface) {
541 mesh_if_found = true;
546 if (!mesh_if_found) {
547 DBG("Mesh interface is not created");
551 mesh_info = wifi->mesh_info;
553 interface = mesh_info->interface;
554 return g_supplicant_interface_disconnect(interface,
555 mesh_disconnect_callback, mesh);
558 static void mesh_connect_callback(int result, GSupplicantInterface *interface,
561 struct connman_mesh *mesh = user_data;
562 DBG("mesh %p result %d", mesh, result);
565 connman_mesh_peer_set_state(mesh, CONNMAN_MESH_STATE_FAILURE);
567 connman_mesh_peer_set_state(mesh, CONNMAN_MESH_STATE_ASSOCIATION);
570 static GSupplicantSecurity mesh_network_security(const char *security)
572 if (g_str_equal(security, "none"))
573 return G_SUPPLICANT_SECURITY_NONE;
574 else if (g_str_equal(security, "sae"))
575 return G_SUPPLICANT_SECURITY_SAE;
577 return G_SUPPLICANT_SECURITY_UNKNOWN;
580 static void mesh_ssid_init(GSupplicantSSID *ssid, struct connman_mesh *mesh)
583 const char *security;
588 memset(ssid, 0, sizeof(*ssid));
589 ssid->mode = G_SUPPLICANT_MODE_MESH;
591 security = connman_mesh_get_security(mesh);
592 ssid->security = mesh_network_security(security);
594 if (ssid->security == G_SUPPLICANT_SECURITY_SAE)
595 ssid->passphrase = connman_mesh_get_passphrase(mesh);
597 ssid->freq = connman_mesh_get_frequency(mesh);
598 name = connman_mesh_get_name(mesh);
600 ssid->ssid_len = strlen(name);
601 ssid->ssid = g_malloc0(ssid->ssid_len + 1);
602 memcpy(ssid->ssid, name, ssid->ssid_len);
607 static int mesh_peer_connect(struct connman_mesh *mesh)
610 struct wifi_data *wifi;
611 struct wifi_mesh_info *mesh_info;
612 bool mesh_if_found = false;
613 GSupplicantInterface *interface;
614 GSupplicantSSID *ssid;
616 for (list = iface_list; list; list = list->next) {
619 if (wifi->mesh_interface) {
620 mesh_if_found = true;
625 if (!mesh_if_found) {
626 DBG("Mesh interface is not created");
630 mesh_info = wifi->mesh_info;
632 interface = mesh_info->interface;
634 ssid = g_try_malloc0(sizeof(GSupplicantSSID));
638 mesh_info->mesh = mesh;
640 mesh_ssid_init(ssid, mesh);
641 return g_supplicant_interface_connect(interface, ssid,
642 mesh_connect_callback, mesh);
645 static void mesh_peer_change_status_callback(int result,
646 GSupplicantInterface *interface,
649 struct mesh_change_peer_status_info *data = user_data;
651 DBG("result %d Peer Status %d", result, data->peer_status);
653 if (result == 0 && data->peer_status == CONNMAN_MESH_PEER_REMOVE) {
654 /* WLAN_REASON_MESH_PEERING_CANCELLED = 52 */
655 connman_mesh_remove_connected_peer(data->peer_address, 52);
659 data->callback(result, data->user_data);
661 g_free(data->peer_address);
666 static int mesh_change_peer_status(const char *peer_address,
667 enum connman_mesh_peer_status status,
668 mesh_change_peer_status_cb_t callback, void *user_data)
671 struct wifi_data *wifi;
672 struct wifi_mesh_info *mesh_info;
673 bool mesh_if_found = false;
674 GSupplicantInterface *interface;
675 struct mesh_change_peer_status_info *data;
678 for (list = iface_list; list; list = list->next) {
681 if (wifi->mesh_interface) {
682 mesh_if_found = true;
687 if (!mesh_if_found) {
688 DBG("Mesh interface is not created");
692 mesh_info = wifi->mesh_info;
694 interface = mesh_info->interface;
697 case CONNMAN_MESH_PEER_ADD:
698 method = "MeshPeerAdd";
700 case CONNMAN_MESH_PEER_REMOVE:
701 method = "MeshPeerRemove";
704 DBG("Invalid method");
708 data = g_try_malloc0(sizeof(struct mesh_change_peer_status_info));
710 DBG("Memory allocation failed");
714 data->peer_address = g_strdup(peer_address);
715 data->peer_status = status;
716 data->callback = callback;
717 data->user_data = user_data;
719 return g_supplicant_interface_mesh_peer_change_status(interface,
720 mesh_peer_change_status_callback, peer_address, method,
724 static struct connman_mesh_driver mesh_driver = {
725 .add_interface = add_mesh_interface,
726 .remove_interface = remove_mesh_interface,
727 .connect = mesh_peer_connect,
728 .disconnect = mesh_peer_disconnect,
729 .change_peer_status = mesh_change_peer_status,
732 static void mesh_support(GSupplicantInterface *interface)
736 if (!g_supplicant_interface_has_mesh(interface))
739 if (connman_technology_driver_register(&mesh_tech_driver) < 0) {
740 DBG("Could not register Mesh technology driver");
744 connman_mesh_driver_register(&mesh_driver);
747 static void check_mesh_technology(void)
749 bool mesh_exists = false;
752 for (list = iface_list; list; list = list->next) {
753 struct wifi_data *w = list->data;
756 g_supplicant_interface_has_mesh(w->interface))
761 connman_technology_driver_unregister(&mesh_tech_driver);
762 connman_mesh_driver_unregister(&mesh_driver);
766 static void mesh_group_started(GSupplicantInterface *interface)
768 struct wifi_data *wifi;
769 struct wifi_mesh_info *mesh_info;
770 struct connman_mesh *mesh;
771 const unsigned char *ssid;
772 unsigned int ssid_len;
775 ssid = g_supplicant_interface_get_mesh_group_ssid(interface, &ssid_len);
776 memcpy(name, ssid, ssid_len);
777 name[ssid_len] = '\0';
778 DBG("name %s", name);
779 wifi = g_supplicant_interface_get_data(interface);
780 DBG("wifi %p", wifi);
785 mesh_info = wifi->mesh_info;
789 mesh = mesh_info->mesh;
793 connman_mesh_peer_set_state(mesh, CONNMAN_MESH_STATE_CONFIGURATION);
796 static void mesh_group_removed(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;
803 int disconnect_reason;
806 ssid = g_supplicant_interface_get_mesh_group_ssid(interface, &ssid_len);
807 memcpy(name, ssid, ssid_len);
808 name[ssid_len] = '\0';
809 DBG("name %s", name);
811 disconnect_reason = g_supplicant_mesh_get_disconnect_reason(interface);
812 DBG("Disconnect Reason %d", disconnect_reason);
814 wifi = g_supplicant_interface_get_data(interface);
815 DBG("wifi %p", wifi);
820 mesh_info = wifi->mesh_info;
824 mesh = connman_get_connected_mesh_from_name(name);
826 DBG("%s is not connected", name);
827 mesh = connman_get_connecting_mesh_from_name(name);
829 DBG("%s is not connecting", name);
834 connman_mesh_peer_set_disconnect_reason(mesh, disconnect_reason);
835 connman_mesh_peer_set_state(mesh, CONNMAN_MESH_STATE_DISCONNECT);
838 static void mesh_peer_connected(GSupplicantMeshPeer *mesh_peer)
840 const char *peer_address;
842 peer_address = g_supplicant_mesh_peer_get_address(mesh_peer);
847 DBG("Peer %s connected", peer_address);
848 connman_mesh_add_connected_peer(peer_address);
851 static void mesh_peer_disconnected(GSupplicantMeshPeer *mesh_peer)
853 const char *peer_address;
856 peer_address = g_supplicant_mesh_peer_get_address(mesh_peer);
861 reason = g_supplicant_mesh_peer_get_disconnect_reason(mesh_peer);
863 DBG("Peer %s disconnected with reason %d", peer_address, reason);
864 connman_mesh_remove_connected_peer(peer_address, reason);
868 static struct wifi_data *get_pending_wifi_data(const char *ifname)
872 for (list = pending_wifi_device; list; list = list->next) {
873 struct wifi_data *wifi;
874 const char *dev_name;
877 if (!wifi || !wifi->device)
880 dev_name = connman_device_get_string(wifi->device, "Interface");
881 if (!g_strcmp0(ifname, dev_name)) {
882 pending_wifi_device = g_list_delete_link(
883 pending_wifi_device, list);
891 static void remove_pending_wifi_device(struct wifi_data *wifi)
895 link = g_list_find(pending_wifi_device, wifi);
900 pending_wifi_device = g_list_delete_link(pending_wifi_device, link);
903 static void peer_cancel_timeout(struct wifi_data *wifi)
905 if (wifi->p2p_connection_timeout > 0)
906 g_source_remove(wifi->p2p_connection_timeout);
908 wifi->p2p_connection_timeout = 0;
909 wifi->p2p_connecting = false;
911 if (wifi->pending_peer) {
912 connman_peer_unref(wifi->pending_peer);
913 wifi->pending_peer = NULL;
917 static gboolean peer_connect_timeout(gpointer data)
919 struct wifi_data *wifi = data;
923 if (wifi->p2p_connecting) {
924 enum connman_peer_state state = CONNMAN_PEER_STATE_FAILURE;
925 GSupplicantPeer *gs_peer =
926 g_supplicant_interface_peer_lookup(wifi->interface,
927 connman_peer_get_identifier(wifi->pending_peer));
929 if (g_supplicant_peer_has_requested_connection(gs_peer))
930 state = CONNMAN_PEER_STATE_IDLE;
932 connman_peer_set_state(wifi->pending_peer, state);
935 peer_cancel_timeout(wifi);
940 static void peer_connect_callback(int result, GSupplicantInterface *interface,
943 struct wifi_data *wifi = user_data;
944 struct connman_peer *peer = wifi->pending_peer;
946 DBG("peer %p - %d", peer, result);
952 peer_connect_timeout(wifi);
956 connman_peer_set_state(peer, CONNMAN_PEER_STATE_ASSOCIATION);
958 wifi->p2p_connection_timeout = g_timeout_add_seconds(
959 P2P_CONNECTION_TIMEOUT,
960 peer_connect_timeout, wifi);
963 static int peer_connect(struct connman_peer *peer,
964 enum connman_peer_wps_method wps_method,
967 struct connman_device *device = connman_peer_get_device(peer);
968 GSupplicantPeerParams *peer_params;
969 GSupplicantPeer *gs_peer;
970 struct wifi_data *wifi;
974 DBG("peer %p", peer);
979 wifi = connman_device_get_data(device);
980 if (!wifi || !wifi->interface)
983 if (wifi->p2p_connecting)
986 gs_peer = g_supplicant_interface_peer_lookup(wifi->interface,
987 connman_peer_get_identifier(peer));
991 pbc = g_supplicant_peer_is_wps_pbc(gs_peer);
992 pin = g_supplicant_peer_is_wps_pin(gs_peer);
994 switch (wps_method) {
995 case CONNMAN_PEER_WPS_UNKNOWN:
996 if ((pbc && pin) || pin)
999 case CONNMAN_PEER_WPS_PBC:
1004 case CONNMAN_PEER_WPS_PIN:
1005 if (!pin || !wps_pin)
1010 peer_params = g_try_malloc0(sizeof(GSupplicantPeerParams));
1014 peer_params->path = g_strdup(g_supplicant_peer_get_path(gs_peer));
1016 peer_params->wps_pin = g_strdup(wps_pin);
1018 peer_params->master = connman_peer_service_is_master();
1020 ret = g_supplicant_interface_p2p_connect(wifi->interface, peer_params,
1021 peer_connect_callback, wifi);
1022 if (ret == -EINPROGRESS) {
1023 wifi->pending_peer = connman_peer_ref(peer);
1024 wifi->p2p_connecting = true;
1025 } else if (ret < 0) {
1026 g_free(peer_params->path);
1027 g_free(peer_params->wps_pin);
1028 g_free(peer_params);
1034 static int peer_disconnect(struct connman_peer *peer)
1036 struct connman_device *device = connman_peer_get_device(peer);
1037 GSupplicantPeerParams peer_params = {};
1038 GSupplicantPeer *gs_peer;
1039 struct wifi_data *wifi;
1042 DBG("peer %p", peer);
1047 wifi = connman_device_get_data(device);
1051 gs_peer = g_supplicant_interface_peer_lookup(wifi->interface,
1052 connman_peer_get_identifier(peer));
1056 peer_params.path = g_strdup(g_supplicant_peer_get_path(gs_peer));
1058 ret = g_supplicant_interface_p2p_disconnect(wifi->interface,
1060 g_free(peer_params.path);
1062 if (ret == -EINPROGRESS) {
1063 peer_cancel_timeout(wifi);
1064 wifi->p2p_device = false;
1070 struct peer_service_registration {
1071 peer_service_registration_cb_t callback;
1075 static bool is_service_wfd(const unsigned char *specs, int length)
1077 if (length < 9 || specs[0] != 0 || specs[1] != 0 || specs[2] != 6)
1083 static void apply_p2p_listen_on_iface(gpointer data, gpointer user_data)
1085 struct wifi_data *wifi = data;
1087 if (!wifi->interface ||
1088 !g_supplicant_interface_has_p2p(wifi->interface))
1091 if (!wifi->servicing) {
1092 g_supplicant_interface_p2p_listen(wifi->interface,
1093 P2P_LISTEN_PERIOD, P2P_LISTEN_INTERVAL);
1099 static void register_wfd_service_cb(int result,
1100 GSupplicantInterface *iface, void *user_data)
1102 struct peer_service_registration *reg_data = user_data;
1107 g_list_foreach(iface_list, apply_p2p_listen_on_iface, NULL);
1109 if (reg_data && reg_data->callback) {
1110 reg_data->callback(result, reg_data->user_data);
1115 static GSupplicantP2PServiceParams *fill_in_peer_service_params(
1116 const unsigned char *spec,
1117 int spec_length, const unsigned char *query,
1118 int query_length, int version)
1120 GSupplicantP2PServiceParams *params;
1122 params = g_try_malloc0(sizeof(GSupplicantP2PServiceParams));
1127 params->version = version;
1128 params->service = g_memdup(spec, spec_length);
1129 } else if (query_length > 0 && spec_length > 0) {
1130 params->query = g_memdup(query, query_length);
1131 params->query_length = query_length;
1133 params->response = g_memdup(spec, spec_length);
1134 params->response_length = spec_length;
1136 params->wfd_ies = g_memdup(spec, spec_length);
1137 params->wfd_ies_length = spec_length;
1143 static void free_peer_service_params(GSupplicantP2PServiceParams *params)
1148 g_free(params->service);
1149 g_free(params->query);
1150 g_free(params->response);
1151 g_free(params->wfd_ies);
1156 static int peer_register_wfd_service(const unsigned char *specification,
1157 int specification_length,
1158 peer_service_registration_cb_t callback,
1161 struct peer_service_registration *reg_data = NULL;
1162 static GSupplicantP2PServiceParams *params;
1167 if (wfd_service_registered)
1170 params = fill_in_peer_service_params(specification,
1171 specification_length, NULL, 0, 0);
1175 reg_data = g_try_malloc0(sizeof(*reg_data));
1181 reg_data->callback = callback;
1182 reg_data->user_data = user_data;
1184 ret = g_supplicant_set_widi_ies(params,
1185 register_wfd_service_cb, reg_data);
1186 if (ret < 0 && ret != -EINPROGRESS)
1189 wfd_service_registered = true;
1193 free_peer_service_params(params);
1199 static void register_peer_service_cb(int result,
1200 GSupplicantInterface *iface, void *user_data)
1202 struct wifi_data *wifi = g_supplicant_interface_get_data(iface);
1203 struct peer_service_registration *reg_data = user_data;
1205 #if defined TIZEN_EXT
1213 apply_p2p_listen_on_iface(wifi, NULL);
1215 if (reg_data->callback)
1216 reg_data->callback(result, reg_data->user_data);
1221 static int peer_register_service(const unsigned char *specification,
1222 int specification_length,
1223 const unsigned char *query,
1224 int query_length, int version,
1225 peer_service_registration_cb_t callback,
1228 struct peer_service_registration *reg_data;
1229 GSupplicantP2PServiceParams *params;
1236 if (specification && !version && !query &&
1237 is_service_wfd(specification, specification_length)) {
1238 return peer_register_wfd_service(specification,
1239 specification_length, callback, user_data);
1242 reg_data = g_try_malloc0(sizeof(*reg_data));
1246 reg_data->callback = callback;
1247 reg_data->user_data = user_data;
1249 ret_f = -EOPNOTSUPP;
1251 for (list = iface_list; list; list = list->next) {
1252 struct wifi_data *wifi = list->data;
1253 GSupplicantInterface *iface = wifi->interface;
1255 if (!g_supplicant_interface_has_p2p(iface))
1258 params = fill_in_peer_service_params(specification,
1259 specification_length, query,
1260 query_length, version);
1265 ret_f = g_supplicant_interface_p2p_add_service(iface,
1266 register_peer_service_cb, params, reg_data);
1267 if (ret_f == 0 || ret_f == -EINPROGRESS)
1271 ret = g_supplicant_interface_p2p_add_service(iface,
1272 register_peer_service_cb, params, NULL);
1273 if (ret != 0 && ret != -EINPROGRESS)
1274 free_peer_service_params(params);
1277 if (ret_f != 0 && ret_f != -EINPROGRESS)
1283 static int peer_unregister_wfd_service(void)
1285 GSupplicantP2PServiceParams *params;
1288 if (!wfd_service_registered)
1291 params = fill_in_peer_service_params(NULL, 0, NULL, 0, 0);
1295 wfd_service_registered = false;
1297 g_supplicant_set_widi_ies(params, NULL, NULL);
1299 for (list = iface_list; list; list = list->next) {
1300 struct wifi_data *wifi = list->data;
1302 if (!g_supplicant_interface_has_p2p(wifi->interface))
1306 if (!wifi->servicing || wifi->servicing < 0) {
1307 g_supplicant_interface_p2p_listen(wifi->interface,
1309 wifi->servicing = 0;
1316 static int peer_unregister_service(const unsigned char *specification,
1317 int specification_length,
1318 const unsigned char *query,
1319 int query_length, int version)
1321 GSupplicantP2PServiceParams *params;
1326 if (specification && !version && !query &&
1327 is_service_wfd(specification, specification_length)) {
1328 ret = peer_unregister_wfd_service();
1329 if (ret != 0 && ret != -EINPROGRESS)
1334 for (list = iface_list; list; list = list->next) {
1335 struct wifi_data *wifi = list->data;
1336 GSupplicantInterface *iface = wifi->interface;
1339 goto stop_listening;
1341 if (!g_supplicant_interface_has_p2p(iface))
1344 params = fill_in_peer_service_params(specification,
1345 specification_length, query,
1346 query_length, version);
1350 ret = g_supplicant_interface_p2p_del_service(iface, params);
1351 if (ret != 0 && ret != -EINPROGRESS)
1352 free_peer_service_params(params);
1355 if (!wifi->servicing || wifi->servicing < 0) {
1356 g_supplicant_interface_p2p_listen(iface, 0, 0);
1357 wifi->servicing = 0;
1364 static struct connman_peer_driver peer_driver = {
1365 .connect = peer_connect,
1366 .disconnect = peer_disconnect,
1367 .register_service = peer_register_service,
1368 .unregister_service = peer_unregister_service,
1371 static void handle_tethering(struct wifi_data *wifi)
1373 if (!wifi->tethering)
1382 DBG("index %d bridge %s", wifi->index, wifi->bridge);
1384 if (connman_inet_add_to_bridge(wifi->index, wifi->bridge) < 0)
1387 wifi->bridged = true;
1390 static void wifi_newlink(unsigned flags, unsigned change, void *user_data)
1392 struct connman_device *device = user_data;
1393 struct wifi_data *wifi = connman_device_get_data(device);
1398 DBG("index %d flags %d change %d", wifi->index, flags, change);
1400 if ((wifi->flags & IFF_UP) != (flags & IFF_UP)) {
1402 DBG("interface up");
1404 DBG("interface down");
1407 if ((wifi->flags & IFF_LOWER_UP) != (flags & IFF_LOWER_UP)) {
1408 if (flags & IFF_LOWER_UP) {
1411 handle_tethering(wifi);
1416 wifi->flags = flags;
1419 static int wifi_probe(struct connman_device *device)
1421 struct wifi_data *wifi;
1423 DBG("device %p", device);
1425 wifi = g_try_new0(struct wifi_data, 1);
1429 wifi->state = G_SUPPLICANT_STATE_INACTIVE;
1430 wifi->ap_supported = WIFI_AP_UNKNOWN;
1431 wifi->tethering_param = NULL;
1433 connman_device_set_data(device, wifi);
1434 wifi->device = connman_device_ref(device);
1436 wifi->index = connman_device_get_index(device);
1439 wifi->watch = connman_rtnl_add_newlink_watch(wifi->index,
1440 wifi_newlink, device);
1441 if (is_p2p_connecting())
1442 add_pending_wifi_device(wifi);
1444 iface_list = g_list_append(iface_list, wifi);
1449 static void remove_networks(struct connman_device *device,
1450 struct wifi_data *wifi)
1454 for (list = wifi->networks; list; list = list->next) {
1455 struct connman_network *network = list->data;
1457 connman_device_remove_network(device, network);
1458 connman_network_unref(network);
1461 g_slist_free(wifi->networks);
1462 wifi->networks = NULL;
1465 static void remove_peers(struct wifi_data *wifi)
1469 for (list = wifi->peers; list; list = list->next) {
1470 struct connman_peer *peer = list->data;
1472 connman_peer_unregister(peer);
1473 connman_peer_unref(peer);
1476 g_slist_free(wifi->peers);
1480 static void reset_autoscan(struct connman_device *device)
1482 struct wifi_data *wifi = connman_device_get_data(device);
1483 struct autoscan_params *autoscan;
1487 if (!wifi || !wifi->autoscan)
1490 autoscan = wifi->autoscan;
1492 autoscan->interval = 0;
1494 if (autoscan->timeout == 0)
1497 g_source_remove(autoscan->timeout);
1498 autoscan->timeout = 0;
1500 connman_device_unref(device);
1503 static void stop_autoscan(struct connman_device *device)
1505 const struct wifi_data *wifi = connman_device_get_data(device);
1507 if (!wifi || !wifi->autoscan)
1510 reset_autoscan(device);
1512 connman_device_set_scanning(device, CONNMAN_SERVICE_TYPE_WIFI, false);
1515 static void check_p2p_technology(void)
1517 bool p2p_exists = false;
1520 for (list = iface_list; list; list = list->next) {
1521 struct wifi_data *w = list->data;
1524 g_supplicant_interface_has_p2p(w->interface))
1529 connman_technology_driver_unregister(&p2p_tech_driver);
1530 connman_peer_driver_unregister(&peer_driver);
1534 struct last_connected {
1540 static gint sort_entry(gconstpointer a, gconstpointer b, gpointer user_data)
1542 GTimeVal *aval = (GTimeVal *)a;
1543 GTimeVal *bval = (GTimeVal *)b;
1545 /* Note that the sort order is descending */
1546 if (aval->tv_sec < bval->tv_sec)
1549 if (aval->tv_sec > bval->tv_sec)
1555 static void free_entry(gpointer data)
1557 struct last_connected *entry = data;
1559 g_free(entry->ssid);
1563 static void wifi_remove(struct connman_device *device)
1565 struct wifi_data *wifi = connman_device_get_data(device);
1567 DBG("device %p wifi %p", device, wifi);
1572 stop_autoscan(device);
1574 if (wifi->p2p_device)
1575 p2p_iface_list = g_list_remove(p2p_iface_list, wifi);
1577 iface_list = g_list_remove(iface_list, wifi);
1579 check_p2p_technology();
1580 #if defined TIZEN_EXT_WIFI_MESH
1581 check_mesh_technology();
1584 remove_pending_wifi_device(wifi);
1586 if (connman_device_get_scanning(device, CONNMAN_SERVICE_TYPE_P2P)) {
1587 g_source_remove(wifi->p2p_find_timeout);
1588 connman_device_unref(wifi->device);
1591 if (wifi->p2p_connection_timeout)
1592 g_source_remove(wifi->p2p_connection_timeout);
1594 #if defined TIZEN_EXT
1595 if (wifi->automaxspeed_timeout != 0) {
1596 g_source_remove(wifi->automaxspeed_timeout);
1597 wifi->automaxspeed_timeout = 0;
1601 remove_networks(device, wifi);
1604 connman_device_set_powered(device, false);
1605 connman_device_set_data(device, NULL);
1606 connman_device_unref(wifi->device);
1607 connman_rtnl_remove_watch(wifi->watch);
1609 g_supplicant_interface_set_data(wifi->interface, NULL);
1611 g_supplicant_interface_cancel(wifi->interface);
1613 if (wifi->scan_params)
1614 g_supplicant_free_scan_params(wifi->scan_params);
1615 #if defined TIZEN_EXT
1616 if (wifi->hidden_scan_params) {
1617 while (wifi->hidden_scan_params->ssids) {
1618 struct scan_ssid *ssid;
1619 ssid = wifi->hidden_scan_params->ssids->data;
1620 wifi->hidden_scan_params->ssids = g_slist_remove(wifi->hidden_scan_params->ssids, ssid);
1622 g_supplicant_free_scan_params(wifi->hidden_scan_params);
1626 g_free(wifi->autoscan);
1627 g_free(wifi->identifier);
1631 static bool is_duplicate(GSList *list, gchar *ssid, int ssid_len)
1635 for (iter = list; iter; iter = g_slist_next(iter)) {
1636 struct scan_ssid *scan_ssid = iter->data;
1638 if (ssid_len == scan_ssid->ssid_len &&
1639 memcmp(ssid, scan_ssid->ssid, ssid_len) == 0)
1646 static int add_scan_param(gchar *hex_ssid, char *raw_ssid, int ssid_len,
1647 int freq, GSupplicantScanParams *scan_data,
1648 int driver_max_scan_ssids, char *ssid_name)
1651 struct scan_ssid *scan_ssid;
1653 if ((driver_max_scan_ssids == 0 ||
1654 driver_max_scan_ssids > scan_data->num_ssids) &&
1655 (hex_ssid || raw_ssid)) {
1657 unsigned int j = 0, hex;
1660 size_t hex_ssid_len = strlen(hex_ssid);
1662 ssid = g_try_malloc0(hex_ssid_len / 2);
1666 for (i = 0; i < hex_ssid_len; i += 2) {
1667 sscanf(hex_ssid + i, "%02x", &hex);
1676 * If we have already added hidden AP to the list,
1677 * then do not do it again. This might happen if you have
1678 * used or are using multiple wifi cards, so in that case
1679 * you might have multiple service files for same AP.
1681 if (is_duplicate(scan_data->ssids, ssid, j)) {
1687 scan_ssid = g_try_new(struct scan_ssid, 1);
1694 memcpy(scan_ssid->ssid, ssid, j);
1695 scan_ssid->ssid_len = j;
1696 scan_data->ssids = g_slist_prepend(scan_data->ssids,
1699 scan_data->num_ssids++;
1701 DBG("SSID %s added to scanned list of %d entries", ssid_name,
1702 scan_data->num_ssids);
1709 scan_data->ssids = g_slist_reverse(scan_data->ssids);
1711 if (!scan_data->freqs) {
1712 scan_data->freqs = g_try_malloc0(sizeof(uint16_t));
1713 if (!scan_data->freqs) {
1714 g_slist_free_full(scan_data->ssids, g_free);
1718 scan_data->num_freqs = 1;
1719 scan_data->freqs[0] = freq;
1721 bool duplicate = false;
1723 /* Don't add duplicate entries */
1724 for (i = 0; i < scan_data->num_freqs; i++) {
1725 if (scan_data->freqs[i] == freq) {
1732 scan_data->num_freqs++;
1733 scan_data->freqs = g_try_realloc(scan_data->freqs,
1734 sizeof(uint16_t) * scan_data->num_freqs);
1735 if (!scan_data->freqs) {
1736 g_slist_free_full(scan_data->ssids, g_free);
1739 scan_data->freqs[scan_data->num_freqs - 1] = freq;
1746 static int get_hidden_connections(GSupplicantScanParams *scan_data)
1748 struct connman_config_entry **entries;
1750 #if defined TIZEN_EXT
1751 gchar **services = NULL;
1754 #endif /* defined TIZEN_EXT */
1758 int num_ssids = 0, add_param_failed = 0;
1759 #if defined TIZEN_EXT
1760 GSequenceIter *iter;
1761 GSequence *latest_list;
1762 struct last_connected *entry;
1765 latest_list = g_sequence_new(free_entry);
1769 services = connman_storage_get_services();
1770 for (i = 0; services && services[i]; i++) {
1771 if (strncmp(services[i], "wifi_", 5) != 0)
1774 keyfile = connman_storage_load_service(services[i]);
1778 value = g_key_file_get_boolean(keyfile,
1779 services[i], "Hidden", NULL);
1781 g_key_file_free(keyfile);
1785 value = g_key_file_get_boolean(keyfile,
1786 services[i], "Favorite", NULL);
1788 g_key_file_free(keyfile);
1792 #if defined TIZEN_EXT
1793 value = g_key_file_get_boolean(keyfile,
1794 services[i], "AutoConnect", NULL);
1796 g_key_file_free(keyfile);
1800 gchar *str = g_key_file_get_string(keyfile,
1801 services[i], "Modified", NULL);
1803 g_key_file_free(keyfile);
1806 g_time_val_from_iso8601(str, &modified);
1810 ssid = g_key_file_get_string(keyfile,
1811 services[i], "SSID", NULL);
1813 name = g_key_file_get_string(keyfile, services[i], "Name",
1816 #if defined TIZEN_EXT
1817 entry = g_try_new(struct last_connected, 1);
1819 g_sequence_free(latest_list);
1822 g_key_file_free(keyfile);
1826 entry->modified = modified;
1829 g_sequence_insert_sorted(latest_list, entry,
1832 ret = add_scan_param(ssid, NULL, 0, 0, scan_data, 0, name);
1841 g_key_file_free(keyfile);
1844 #if defined TIZEN_EXT
1845 gint length = g_sequence_get_length(latest_list);
1846 iter = g_sequence_get_begin_iter(latest_list);
1848 for (i = 0; i < length; i++) {
1849 entry = g_sequence_get(iter);
1851 ret = add_scan_param(entry->ssid, NULL, 0, 0, scan_data, 0, entry->ssid);
1857 iter = g_sequence_iter_next(iter);
1860 g_sequence_free(latest_list);
1864 * Check if there are any hidden AP that needs to be provisioned.
1866 entries = connman_config_get_entries("wifi");
1867 for (i = 0; entries && entries[i]; i++) {
1870 if (!entries[i]->hidden)
1873 if (!entries[i]->ssid) {
1874 ssid = entries[i]->name;
1877 ssid = entries[i]->ssid;
1878 len = entries[i]->ssid_len;
1884 ret = add_scan_param(NULL, ssid, len, 0, scan_data, 0, ssid);
1891 connman_config_free_entries(entries);
1893 if (add_param_failed > 0)
1894 DBG("Unable to scan %d out of %d SSIDs",
1895 add_param_failed, num_ssids);
1897 g_strfreev(services);
1902 static int get_hidden_connections_params(struct wifi_data *wifi,
1903 GSupplicantScanParams *scan_params)
1905 int driver_max_ssids, i;
1906 GSupplicantScanParams *orig_params;
1909 * Scan hidden networks so that we can autoconnect to them.
1910 * We will assume 1 as a default number of ssid to scan.
1912 driver_max_ssids = g_supplicant_interface_get_max_scan_ssids(
1914 if (driver_max_ssids == 0)
1915 driver_max_ssids = 1;
1917 DBG("max ssids %d", driver_max_ssids);
1919 #if defined TIZEN_EXT
1920 if (!wifi->hidden_scan_params) {
1921 wifi->hidden_scan_params = g_try_malloc0(sizeof(GSupplicantScanParams));
1922 if (!wifi->hidden_scan_params)
1925 if (get_hidden_connections(wifi->hidden_scan_params) == 0) {
1926 g_supplicant_free_scan_params(wifi->hidden_scan_params);
1927 wifi->hidden_scan_params = NULL;
1933 orig_params = wifi->hidden_scan_params;
1935 if (!wifi->scan_params) {
1936 wifi->scan_params = g_try_malloc0(sizeof(GSupplicantScanParams));
1937 if (!wifi->scan_params)
1940 if (get_hidden_connections(wifi->scan_params) == 0) {
1941 g_supplicant_free_scan_params(wifi->scan_params);
1942 wifi->scan_params = NULL;
1948 orig_params = wifi->scan_params;
1951 /* Let's transfer driver_max_ssids params */
1952 for (i = 0; i < driver_max_ssids; i++) {
1953 struct scan_ssid *ssid;
1955 #if defined TIZEN_EXT
1956 if (!wifi->hidden_scan_params->ssids)
1958 if (!wifi->scan_params->ssids)
1962 ssid = orig_params->ssids->data;
1963 orig_params->ssids = g_slist_remove(orig_params->ssids, ssid);
1964 scan_params->ssids = g_slist_prepend(scan_params->ssids, ssid);
1968 scan_params->num_ssids = i;
1969 scan_params->ssids = g_slist_reverse(scan_params->ssids);
1971 scan_params->freqs = g_memdup(orig_params->freqs,
1972 sizeof(uint16_t) * orig_params->num_freqs);
1973 if (!scan_params->freqs)
1976 scan_params->num_freqs = orig_params->num_freqs;
1981 orig_params->num_ssids -= scan_params->num_ssids;
1983 return scan_params->num_ssids;
1986 g_slist_free_full(scan_params->ssids, g_free);
1987 #if defined TIZEN_EXT
1988 g_supplicant_free_scan_params(wifi->hidden_scan_params);
1989 wifi->hidden_scan_params = NULL;
1991 g_supplicant_free_scan_params(wifi->scan_params);
1992 wifi->scan_params = NULL;
1998 static int throw_wifi_scan(struct connman_device *device,
1999 GSupplicantInterfaceCallback callback)
2001 struct wifi_data *wifi = connman_device_get_data(device);
2007 DBG("device %p %p", device, wifi->interface);
2009 if (wifi->tethering)
2012 #if defined TIZEN_EXT
2013 if (connman_device_get_scanning(device, CONNMAN_SERVICE_TYPE_WIFI)
2014 && !wifi->allow_full_scan)
2016 if (connman_device_get_scanning(device, CONNMAN_SERVICE_TYPE_WIFI))
2020 connman_device_ref(device);
2022 ret = g_supplicant_interface_scan(wifi->interface, NULL,
2025 connman_device_set_scanning(device,
2026 CONNMAN_SERVICE_TYPE_WIFI, true);
2028 connman_device_unref(device);
2033 static void hidden_free(struct hidden_params *hidden)
2038 if (hidden->scan_params)
2039 g_supplicant_free_scan_params(hidden->scan_params);
2040 g_free(hidden->identity);
2041 g_free(hidden->passphrase);
2042 g_free(hidden->security);
2046 #if defined TIZEN_EXT
2047 static void service_state_changed(struct connman_service *service,
2048 enum connman_service_state state);
2050 static int network_connect(struct connman_network *network);
2052 static struct connman_notifier notifier = {
2054 .priority = CONNMAN_NOTIFIER_PRIORITY_DEFAULT,
2055 .service_state_changed = service_state_changed,
2058 static void service_state_changed(struct connman_service *service,
2059 enum connman_service_state state)
2061 enum connman_service_type type;
2063 type = connman_service_get_type(service);
2064 if (type != CONNMAN_SERVICE_TYPE_WIFI)
2067 DBG("service %p state %d", service, state);
2070 case CONNMAN_SERVICE_STATE_READY:
2071 case CONNMAN_SERVICE_STATE_ONLINE:
2072 case CONNMAN_SERVICE_STATE_FAILURE:
2073 connman_notifier_unregister(¬ifier);
2074 is_wifi_notifier_registered = FALSE;
2076 __connman_device_request_scan(type);
2084 static void scan_callback_hidden(int result,
2085 GSupplicantInterface *interface, void *user_data);
2088 static void scan_callback(int result, GSupplicantInterface *interface,
2091 struct connman_device *device = user_data;
2092 struct wifi_data *wifi = connman_device_get_data(device);
2094 #if defined TIZEN_EXT
2095 GSList *list = NULL;
2096 bool favorite_exists = false;
2097 struct connman_network *network = NULL;
2098 struct connman_service *service = NULL;
2101 DBG("result %d wifi %p", result, wifi);
2104 if (wifi->hidden && !wifi->postpone_hidden) {
2105 connman_network_clear_hidden(wifi->hidden->user_data);
2106 hidden_free(wifi->hidden);
2107 wifi->hidden = NULL;
2110 if (wifi->scan_params) {
2111 g_supplicant_free_scan_params(wifi->scan_params);
2112 wifi->scan_params = NULL;
2115 #if defined TIZEN_EXT
2116 if (wifi->hidden_scan_params && !wifi->hidden_scan_params->ssids) {
2117 g_supplicant_free_scan_params(wifi->hidden_scan_params);
2118 wifi->hidden_scan_params = NULL;
2124 connman_device_reset_scanning(device);
2126 /* User is connecting to a hidden AP, let's wait for finished event */
2127 if (wifi && wifi->hidden && wifi->postpone_hidden) {
2128 GSupplicantScanParams *scan_params;
2131 wifi->postpone_hidden = false;
2132 scan_params = wifi->hidden->scan_params;
2133 wifi->hidden->scan_params = NULL;
2135 reset_autoscan(device);
2137 ret = g_supplicant_interface_scan(wifi->interface, scan_params,
2138 scan_callback, device);
2142 /* On error, let's recall scan_callback, which will cleanup */
2143 return scan_callback(ret, interface, user_data);
2146 #if defined TIZEN_EXT
2148 for (list = wifi->networks; list; list = list->next) {
2149 network = list->data;
2150 service = connman_service_lookup_from_network(network);
2152 if (service != NULL &&
2153 (connman_service_get_favorite(service) == true) &&
2154 (connman_service_get_autoconnect(service) == true)) {
2155 DBG("Favorite service exists [%s]", connman_network_get_string(network, "Name"));
2156 favorite_exists = true;
2162 if (favorite_exists == false) {
2163 if (wifi && wifi->allow_full_scan) {
2165 DBG("Trigger full channel scan");
2166 wifi->allow_full_scan = false;
2168 ret = g_supplicant_interface_scan(wifi->interface, NULL,
2169 scan_callback_hidden, device);
2173 /* On error, let's recall scan_callback, which will cleanup */
2174 return scan_callback(ret, interface, user_data);
2179 scanning = connman_device_get_scanning(device, CONNMAN_SERVICE_TYPE_WIFI);
2182 connman_device_set_scanning(device,
2183 CONNMAN_SERVICE_TYPE_WIFI, false);
2186 if (result != -ENOLINK)
2187 #if defined TIZEN_EXT
2190 start_autoscan(device);
2193 * If we are here then we were scanning; however, if we are
2194 * also mid-flight disabling the interface, then wifi_disable
2195 * has already cleared the device scanning state and
2196 * unreferenced the device, obviating the need to do it here.
2200 connman_device_unref(device);
2202 #if defined TIZEN_EXT
2203 if (wifi && wifi->scan_pending_network && result != -EIO) {
2204 network_connect(wifi->scan_pending_network);
2205 wifi->scan_pending_network = NULL;
2206 connman_network_set_connecting(wifi->network);
2209 if (is_wifi_notifier_registered != true &&
2210 wifi_first_scan == true && found_with_first_scan == true) {
2211 wifi_first_scan = false;
2212 found_with_first_scan = false;
2214 connman_notifier_register(¬ifier);
2215 is_wifi_notifier_registered = true;
2220 static void scan_callback_hidden(int result,
2221 GSupplicantInterface *interface, void *user_data)
2223 struct connman_device *device = user_data;
2224 struct wifi_data *wifi = connman_device_get_data(device);
2225 GSupplicantScanParams *scan_params;
2228 DBG("result %d wifi %p", result, wifi);
2233 /* User is trying to connect to a hidden AP */
2234 if (wifi->hidden && wifi->postpone_hidden)
2237 scan_params = g_try_malloc0(sizeof(GSupplicantScanParams));
2241 if (get_hidden_connections_params(wifi, scan_params) > 0) {
2242 ret = g_supplicant_interface_scan(wifi->interface,
2244 #if defined TIZEN_EXT
2247 scan_callback_hidden,
2254 g_supplicant_free_scan_params(scan_params);
2257 scan_callback(result, interface, user_data);
2260 static gboolean autoscan_timeout(gpointer data)
2262 struct connman_device *device = data;
2263 struct wifi_data *wifi = connman_device_get_data(device);
2264 struct autoscan_params *autoscan;
2270 autoscan = wifi->autoscan;
2272 #if defined TIZEN_EXT
2277 if (autoscan->interval <= 0) {
2278 interval = autoscan->base;
2281 interval = autoscan->interval * autoscan->base;
2283 #if defined TIZEN_EXT
2284 if (autoscan->interval >= autoscan->limit)
2286 if (interval > autoscan->limit)
2288 interval = autoscan->limit;
2290 throw_wifi_scan(wifi->device, scan_callback_hidden);
2293 * In case BackgroundScanning is disabled, interval will reach the
2294 * limit exactly after the very first passive scanning. It allows
2295 * to ensure at most one passive scan is performed in such cases.
2297 if (!connman_setting_get_bool("BackgroundScanning") &&
2298 interval == autoscan->limit) {
2299 g_source_remove(autoscan->timeout);
2300 autoscan->timeout = 0;
2302 connman_device_unref(device);
2308 DBG("interval %d", interval);
2310 autoscan->interval = interval;
2312 autoscan->timeout = g_timeout_add_seconds(interval,
2313 autoscan_timeout, device);
2318 static void start_autoscan(struct connman_device *device)
2320 struct wifi_data *wifi = connman_device_get_data(device);
2321 struct autoscan_params *autoscan;
2328 if (wifi->p2p_device)
2331 if (wifi->connected)
2334 autoscan = wifi->autoscan;
2338 if (autoscan->timeout > 0 || autoscan->interval > 0)
2341 connman_device_ref(device);
2343 autoscan_timeout(device);
2346 static struct autoscan_params *parse_autoscan_params(const char *params)
2348 struct autoscan_params *autoscan;
2355 list_params = g_strsplit(params, ":", 0);
2356 if (list_params == 0)
2359 if (!g_strcmp0(list_params[0], "exponential") &&
2360 g_strv_length(list_params) == 3) {
2361 base = atoi(list_params[1]);
2362 limit = atoi(list_params[2]);
2363 } else if (!g_strcmp0(list_params[0], "single") &&
2364 g_strv_length(list_params) == 2)
2365 base = limit = atoi(list_params[1]);
2367 g_strfreev(list_params);
2371 DBG("Setup %s autoscanning", list_params[0]);
2373 g_strfreev(list_params);
2375 autoscan = g_try_malloc0(sizeof(struct autoscan_params));
2377 DBG("Could not allocate memory for autoscan");
2381 DBG("base %d - limit %d", base, limit);
2382 autoscan->base = base;
2383 autoscan->limit = limit;
2388 static void setup_autoscan(struct wifi_data *wifi)
2391 * If BackgroundScanning is enabled, setup exponential
2392 * autoscanning if it has not been previously done.
2394 if (connman_setting_get_bool("BackgroundScanning")) {
2395 wifi->autoscan = parse_autoscan_params(AUTOSCAN_EXPONENTIAL);
2400 * On the contrary, if BackgroundScanning is disabled, update autoscan
2401 * parameters based on the type of scanning that is being performed.
2403 if (wifi->autoscan) {
2404 g_free(wifi->autoscan);
2405 wifi->autoscan = NULL;
2408 switch (wifi->scanning_type) {
2409 case WIFI_SCANNING_PASSIVE:
2410 /* Do not setup autoscan. */
2412 case WIFI_SCANNING_ACTIVE:
2413 /* Setup one single passive scan after active. */
2414 wifi->autoscan = parse_autoscan_params(AUTOSCAN_SINGLE);
2416 case WIFI_SCANNING_UNKNOWN:
2417 /* Setup autoscan in this case but we should never fall here. */
2418 wifi->autoscan = parse_autoscan_params(AUTOSCAN_SINGLE);
2423 static void finalize_interface_creation(struct wifi_data *wifi)
2425 DBG("interface is ready wifi %p tethering %d", wifi, wifi->tethering);
2427 if (!wifi->device) {
2428 connman_error("WiFi device not set");
2432 connman_device_set_powered(wifi->device, true);
2434 if (wifi->p2p_device)
2437 if (!wifi->autoscan)
2438 setup_autoscan(wifi);
2440 start_autoscan(wifi->device);
2443 static void interface_create_callback(int result,
2444 GSupplicantInterface *interface,
2447 struct wifi_data *wifi = user_data;
2449 DBG("result %d ifname %s, wifi %p", result,
2450 g_supplicant_interface_get_ifname(interface),
2453 if (result < 0 || !wifi)
2456 wifi->interface = interface;
2457 g_supplicant_interface_set_data(interface, wifi);
2459 if (g_supplicant_interface_get_ready(interface)) {
2460 wifi->interface_ready = true;
2461 finalize_interface_creation(wifi);
2465 static int wifi_enable(struct connman_device *device)
2467 struct wifi_data *wifi = connman_device_get_data(device);
2470 const char *driver = connman_option_get_string("wifi");
2473 DBG("device %p %p", device, wifi);
2475 index = connman_device_get_index(device);
2476 if (!wifi || index < 0)
2479 if (is_p2p_connecting())
2480 return -EINPROGRESS;
2482 interface = connman_inet_ifname(index);
2483 ret = g_supplicant_interface_create(interface, driver, NULL,
2484 interface_create_callback,
2491 return -EINPROGRESS;
2494 static int wifi_disable(struct connman_device *device)
2496 struct wifi_data *wifi = connman_device_get_data(device);
2499 DBG("device %p wifi %p", device, wifi);
2504 wifi->connected = false;
2505 wifi->disconnecting = false;
2507 if (wifi->pending_network)
2508 wifi->pending_network = NULL;
2510 #if !defined TIZEN_EXT
2511 stop_autoscan(device);
2514 if (connman_device_get_scanning(device, CONNMAN_SERVICE_TYPE_P2P)) {
2515 g_source_remove(wifi->p2p_find_timeout);
2516 wifi->p2p_find_timeout = 0;
2517 connman_device_set_scanning(device, CONNMAN_SERVICE_TYPE_P2P, false);
2518 connman_device_unref(wifi->device);
2521 #if defined TIZEN_EXT
2522 if (wifi->automaxspeed_timeout != 0) {
2523 g_source_remove(wifi->automaxspeed_timeout);
2524 wifi->automaxspeed_timeout = 0;
2528 /* In case of a user scan, device is still referenced */
2529 if (connman_device_get_scanning(device, CONNMAN_SERVICE_TYPE_WIFI)) {
2530 connman_device_set_scanning(device,
2531 CONNMAN_SERVICE_TYPE_WIFI, false);
2532 connman_device_unref(wifi->device);
2535 #if defined TIZEN_EXT
2536 stop_autoscan(device);
2539 remove_networks(device, wifi);
2542 #if defined TIZEN_EXT
2543 wifi->scan_pending_network = NULL;
2545 if (is_wifi_notifier_registered == true) {
2546 connman_notifier_unregister(¬ifier);
2547 is_wifi_notifier_registered = false;
2551 ret = g_supplicant_interface_remove(wifi->interface, NULL, NULL);
2555 return -EINPROGRESS;
2558 static int get_latest_connections(int max_ssids,
2559 GSupplicantScanParams *scan_data)
2561 GSequenceIter *iter;
2562 GSequence *latest_list;
2563 struct last_connected *entry;
2572 latest_list = g_sequence_new(free_entry);
2576 services = connman_storage_get_services();
2577 for (i = 0; services && services[i]; i++) {
2578 if (strncmp(services[i], "wifi_", 5) != 0)
2581 keyfile = connman_storage_load_service(services[i]);
2585 str = g_key_file_get_string(keyfile,
2586 services[i], "Favorite", NULL);
2587 if (!str || g_strcmp0(str, "true")) {
2589 g_key_file_free(keyfile);
2594 str = g_key_file_get_string(keyfile,
2595 services[i], "AutoConnect", NULL);
2596 if (!str || g_strcmp0(str, "true")) {
2598 g_key_file_free(keyfile);
2603 str = g_key_file_get_string(keyfile,
2604 services[i], "Modified", NULL);
2606 g_key_file_free(keyfile);
2609 g_time_val_from_iso8601(str, &modified);
2612 ssid = g_key_file_get_string(keyfile,
2613 services[i], "SSID", NULL);
2615 freq = g_key_file_get_integer(keyfile, services[i],
2618 entry = g_try_new(struct last_connected, 1);
2620 g_sequence_free(latest_list);
2621 g_key_file_free(keyfile);
2627 entry->modified = modified;
2630 g_sequence_insert_sorted(latest_list, entry,
2636 g_key_file_free(keyfile);
2639 g_strfreev(services);
2641 num_ssids = num_ssids > max_ssids ? max_ssids : num_ssids;
2643 iter = g_sequence_get_begin_iter(latest_list);
2645 for (i = 0; i < num_ssids; i++) {
2646 entry = g_sequence_get(iter);
2648 DBG("ssid %s freq %d modified %lu", entry->ssid, entry->freq,
2649 entry->modified.tv_sec);
2651 add_scan_param(entry->ssid, NULL, 0, entry->freq, scan_data,
2652 max_ssids, entry->ssid);
2654 iter = g_sequence_iter_next(iter);
2657 g_sequence_free(latest_list);
2661 static void wifi_update_scanner_type(struct wifi_data *wifi,
2662 enum wifi_scanning_type new_type)
2666 if (!wifi || wifi->scanning_type == new_type)
2669 wifi->scanning_type = new_type;
2671 setup_autoscan(wifi);
2674 static int wifi_scan_simple(struct connman_device *device)
2676 struct wifi_data *wifi = connman_device_get_data(device);
2678 reset_autoscan(device);
2680 /* Distinguish between devices performing passive and active scanning */
2682 wifi_update_scanner_type(wifi, WIFI_SCANNING_PASSIVE);
2684 return throw_wifi_scan(device, scan_callback_hidden);
2687 static gboolean p2p_find_stop(gpointer data)
2689 struct connman_device *device = data;
2690 struct wifi_data *wifi = connman_device_get_data(device);
2695 wifi->p2p_find_timeout = 0;
2697 g_supplicant_interface_p2p_stop_find(wifi->interface);
2700 connman_device_set_scanning(device, CONNMAN_SERVICE_TYPE_P2P, false);
2702 connman_device_unref(device);
2703 start_autoscan(device);
2708 static void p2p_find_callback(int result, GSupplicantInterface *interface,
2711 struct connman_device *device = user_data;
2712 struct wifi_data *wifi = connman_device_get_data(device);
2714 DBG("result %d wifi %p", result, wifi);
2719 if (wifi->p2p_find_timeout) {
2720 g_source_remove(wifi->p2p_find_timeout);
2721 wifi->p2p_find_timeout = 0;
2727 wifi->p2p_find_timeout = g_timeout_add_seconds(P2P_FIND_TIMEOUT,
2728 p2p_find_stop, device);
2729 if (!wifi->p2p_find_timeout)
2734 p2p_find_stop(device);
2737 static int p2p_find(struct connman_device *device)
2739 struct wifi_data *wifi;
2744 if (!p2p_technology)
2747 wifi = connman_device_get_data(device);
2749 if (g_supplicant_interface_is_p2p_finding(wifi->interface))
2752 reset_autoscan(device);
2753 connman_device_ref(device);
2755 ret = g_supplicant_interface_p2p_find(wifi->interface,
2756 p2p_find_callback, device);
2758 connman_device_unref(device);
2759 start_autoscan(device);
2761 connman_device_set_scanning(device,
2762 CONNMAN_SERVICE_TYPE_P2P, true);
2768 #if defined TIZEN_EXT
2769 static void specific_scan_callback(int result, GSupplicantInterface *interface,
2772 struct connman_device *device = user_data;
2773 struct wifi_data *wifi = connman_device_get_data(device);
2776 DBG("result %d wifi %p", result, wifi);
2778 if (wifi && wifi->scan_params) {
2779 g_supplicant_free_scan_params(wifi->scan_params);
2780 wifi->scan_params = NULL;
2783 scanning = connman_device_get_scanning(device,
2784 CONNMAN_SERVICE_TYPE_WIFI);
2786 connman_device_set_scanning(device,
2787 CONNMAN_SERVICE_TYPE_WIFI, false);
2788 connman_device_unref(device);
2792 static int wifi_specific_scan(enum connman_service_type type,
2793 struct connman_device *device, int scan_type,
2794 GSList *specific_scan_list, void *user_data)
2796 GSList *list = NULL;
2798 struct wifi_data *wifi = connman_device_get_data(device);
2799 GSupplicantScanParams *scan_params = NULL;
2800 struct scan_ssid *scan_ssid = NULL;
2809 if (wifi->p2p_device)
2812 if (type == CONNMAN_SERVICE_TYPE_P2P)
2813 return p2p_find(device);
2815 if (wifi->tethering)
2819 connman_device_get_scanning(device,
2820 CONNMAN_SERVICE_TYPE_WIFI);
2824 DBG("scan_type: %d", scan_type);
2825 if (scan_type == CONNMAN_MULTI_SCAN_SSID) { /* ssid based scan */
2826 scan_params = g_try_malloc0(sizeof(GSupplicantScanParams));
2828 DBG("Failed to allocate memory.");
2832 for (list = specific_scan_list; list; list = list->next) {
2833 ssid = (char *)list->data;
2834 int ssid_len = strlen(ssid);
2836 scan_ssid = g_try_new0(struct scan_ssid, 1);
2838 DBG("Failed to allocate memory.");
2839 g_supplicant_free_scan_params(scan_params);
2843 memcpy(scan_ssid->ssid, ssid, (ssid_len + 1));
2844 /* DBG("scan ssid %s len: %d", scan_ssid->ssid, ssid_len); */
2845 scan_ssid->ssid_len = ssid_len;
2846 scan_params->ssids = g_slist_prepend(scan_params->ssids, scan_ssid);
2849 scan_params->num_ssids = count;
2851 } else if (scan_type == CONNMAN_MULTI_SCAN_FREQ) { /* frequency based scan */
2853 scan_params = g_try_malloc0(sizeof(GSupplicantScanParams));
2855 DBG("Failed to allocate memory.");
2859 guint num_freqs = g_slist_length(specific_scan_list);
2860 DBG("num_freqs: %d", num_freqs);
2862 scan_params->freqs = g_try_new0(uint16_t, num_freqs);
2863 if (!scan_params->freqs) {
2864 DBG("Failed to allocate memory.");
2865 g_free(scan_params);
2870 for (list = specific_scan_list; list; list = list->next) {
2871 freq = (int)list->data;
2873 scan_params->freqs[count] = freq;
2874 DBG("scan_params->freqs[%d]: %d", count, scan_params->freqs[count]);
2877 scan_params->num_freqs = count;
2879 } else if (scan_type == CONNMAN_MULTI_SCAN_SSID_FREQ) { /* SSID & Frequency mixed scan */
2880 int freq_count, ap_count;
2881 scan_params = g_try_malloc0(sizeof(GSupplicantScanParams));
2883 DBG("Failed to allocate memory.");
2887 guint size = g_slist_length(specific_scan_list);
2889 scan_params->freqs = g_try_new0(uint16_t, size/2);
2890 if (!scan_params->freqs) {
2891 DBG("Failed to allocate memory.");
2892 g_free(scan_params);
2896 ap_count = freq_count = 0;
2897 for (list = specific_scan_list; list; list = list->next) {
2898 if (((connman_multi_scan_ap_s *)list->data)->flag == true) { /** ssid */
2899 ssid = ((connman_multi_scan_ap_s *)list->data)->str;
2900 int ssid_len = strlen(ssid);
2902 scan_ssid = g_try_new0(struct scan_ssid, 1);
2904 DBG("Failed to allocate memory.");
2905 g_supplicant_free_scan_params(scan_params);
2909 memcpy(scan_ssid->ssid, ssid, (ssid_len + 1));
2910 /* DBG("scan ssid %s len: %d", scan_ssid->ssid, ssid_len); */
2911 scan_ssid->ssid_len = ssid_len;
2912 scan_params->ssids = g_slist_prepend(scan_params->ssids, scan_ssid);
2916 freq = atoi(((connman_multi_scan_ap_s *)list->data)->str);
2917 scan_params->freqs[freq_count] = freq;
2918 DBG("scan_params->freqs[%d]: %d", freq_count, scan_params->freqs[freq_count]);
2922 scan_params->num_ssids = ap_count;
2923 scan_params->num_freqs = freq_count;
2925 DBG("Invalid scan");
2929 reset_autoscan(device);
2930 connman_device_ref(device);
2932 ret = g_supplicant_interface_scan(wifi->interface, scan_params,
2933 specific_scan_callback, device);
2936 connman_device_set_scanning(device,
2937 CONNMAN_SERVICE_TYPE_WIFI, true);
2939 g_supplicant_free_scan_params(scan_params);
2940 connman_device_unref(device);
2947 #if defined TIZEN_EXT_WIFI_MESH
2948 static void mesh_scan_callback(int result, GSupplicantInterface *interface,
2951 struct connman_device *device = user_data;
2952 struct wifi_data *wifi = connman_device_get_data(device);
2955 DBG("result %d wifi %p", result, wifi);
2957 scanning = connman_device_get_scanning(device,
2958 CONNMAN_SERVICE_TYPE_MESH);
2960 connman_device_set_scanning(device,
2961 CONNMAN_SERVICE_TYPE_MESH, false);
2964 connman_device_unref(device);
2967 static int mesh_scan(struct connman_device *device)
2969 struct wifi_data *wifi;
2970 struct wifi_mesh_info *mesh_info;
2975 wifi = connman_device_get_data(device);
2977 if (!wifi->mesh_interface)
2980 mesh_info = wifi->mesh_info;
2981 reset_autoscan(device);
2982 connman_device_ref(device);
2984 ret = g_supplicant_interface_scan(mesh_info->interface, NULL,
2985 mesh_scan_callback, device);
2987 connman_device_unref(device);
2989 connman_device_set_scanning(device,
2990 CONNMAN_SERVICE_TYPE_MESH, true);
2995 static void abort_scan_callback(int result, GSupplicantInterface *interface,
2998 struct connman_device *device = user_data;
2999 struct wifi_data *wifi = connman_device_get_data(device);
3001 DBG("result %d wifi %p", result, wifi);
3003 __connman_technology_notify_abort_scan(CONNMAN_SERVICE_TYPE_MESH, result);
3006 static int mesh_abort_scan(enum connman_service_type type,
3007 struct connman_device *device)
3009 struct wifi_data *wifi = connman_device_get_data(device);
3010 struct wifi_mesh_info *mesh_info;
3014 if (!wifi || !wifi->mesh_interface)
3017 if (type != CONNMAN_SERVICE_TYPE_MESH)
3020 mesh_info = wifi->mesh_info;
3022 scanning = connman_device_get_scanning(device,
3023 CONNMAN_SERVICE_TYPE_MESH);
3027 ret = g_supplicant_interface_abort_scan(mesh_info->interface,
3028 abort_scan_callback, device);
3033 static int mesh_specific_scan(enum connman_service_type type,
3034 struct connman_device *device, const char *ssid,
3035 unsigned int freq, void *user_data)
3037 struct wifi_data *wifi = connman_device_get_data(device);
3038 GSupplicantScanParams *scan_params = NULL;
3039 struct wifi_mesh_info *mesh_info;
3040 struct scan_ssid *scan_ssid;
3044 if (!wifi || !wifi->mesh_interface)
3047 if (type != CONNMAN_SERVICE_TYPE_MESH)
3050 if (wifi->p2p_device)
3053 mesh_info = wifi->mesh_info;
3055 scanning = connman_device_get_scanning(device,
3056 CONNMAN_SERVICE_TYPE_MESH);
3060 scan_params = g_try_malloc0(sizeof(GSupplicantScanParams));
3064 scan_ssid = g_try_new(struct scan_ssid, 1);
3066 g_free(scan_params);
3070 scan_ssid->ssid_len = strlen(ssid);
3071 memcpy(scan_ssid->ssid, ssid, scan_ssid->ssid_len);
3072 scan_params->ssids = g_slist_prepend(scan_params->ssids, scan_ssid);
3073 scan_params->num_ssids = 1;
3075 scan_params->freqs = g_try_new(uint16_t, 1);
3076 if (!scan_params->freqs) {
3077 g_slist_free_full(scan_params->ssids, g_free);
3078 g_free(scan_params);
3082 scan_params->freqs[0] = freq;
3083 scan_params->num_freqs = 1;
3085 reset_autoscan(device);
3086 connman_device_ref(device);
3088 ret = g_supplicant_interface_scan(mesh_info->interface, scan_params,
3089 mesh_scan_callback, device);
3092 connman_device_set_scanning(device,
3093 CONNMAN_SERVICE_TYPE_MESH, true);
3095 g_supplicant_free_scan_params(scan_params);
3096 connman_device_unref(device);
3104 * Note that the hidden scan is only used when connecting to this specific
3105 * hidden AP first time. It is not used when system autoconnects to hidden AP.
3107 static int wifi_scan(struct connman_device *device,
3108 struct connman_device_scan_params *params)
3110 struct wifi_data *wifi = connman_device_get_data(device);
3111 GSupplicantScanParams *scan_params = NULL;
3112 struct scan_ssid *scan_ssid;
3113 struct hidden_params *hidden;
3115 int driver_max_ssids = 0;
3122 if (wifi->p2p_device)
3125 if (wifi->tethering)
3128 if (params->type == CONNMAN_SERVICE_TYPE_P2P)
3129 return p2p_find(device);
3131 #if defined TIZEN_EXT_WIFI_MESH
3132 if (params->type == CONNMAN_SERVICE_TYPE_MESH)
3133 return mesh_scan(device);
3136 DBG("device %p wifi %p hidden ssid %s", device, wifi->interface,
3139 scanning = connman_device_get_scanning(device, CONNMAN_SERVICE_TYPE_WIFI);
3141 if (!params->ssid || params->ssid_len == 0 || params->ssid_len > 32) {
3145 driver_max_ssids = g_supplicant_interface_get_max_scan_ssids(
3147 DBG("max ssids %d", driver_max_ssids);
3148 if (driver_max_ssids == 0)
3149 return wifi_scan_simple(device);
3153 if (scanning && wifi->hidden && wifi->postpone_hidden)
3159 scan_params = g_try_malloc0(sizeof(GSupplicantScanParams));
3164 scan_ssid = g_try_new(struct scan_ssid, 1);
3166 g_free(scan_params);
3170 memcpy(scan_ssid->ssid, params->ssid, params->ssid_len);
3171 scan_ssid->ssid_len = params->ssid_len;
3172 scan_params->ssids = g_slist_prepend(scan_params->ssids,
3174 scan_params->num_ssids = 1;
3176 hidden = g_try_new0(struct hidden_params, 1);
3178 g_supplicant_free_scan_params(scan_params);
3183 hidden_free(wifi->hidden);
3184 wifi->hidden = NULL;
3187 memcpy(hidden->ssid, params->ssid, params->ssid_len);
3188 hidden->ssid_len = params->ssid_len;
3189 hidden->identity = g_strdup(params->identity);
3190 hidden->passphrase = g_strdup(params->passphrase);
3191 hidden->security = g_strdup(params->security);
3192 hidden->user_data = params->user_data;
3193 wifi->hidden = hidden;
3196 /* Let's keep this active scan for later,
3197 * when current scan will be over. */
3198 wifi->postpone_hidden = TRUE;
3199 hidden->scan_params = scan_params;
3203 } else if (wifi->connected) {
3204 g_supplicant_free_scan_params(scan_params);
3205 return wifi_scan_simple(device);
3206 } else if (!params->force_full_scan) {
3207 ret = get_latest_connections(driver_max_ssids, scan_params);
3209 g_supplicant_free_scan_params(scan_params);
3210 return wifi_scan_simple(device);
3214 /* Distinguish between devices performing passive and active scanning */
3215 wifi_update_scanner_type(wifi, WIFI_SCANNING_ACTIVE);
3217 connman_device_ref(device);
3219 reset_autoscan(device);
3220 #if defined TIZEN_EXT
3222 * When doing a full scan, stored hidden networks also need to be scanned
3223 * so that we can autoconnect to them.
3225 if (params->force_full_scan)
3226 ret = g_supplicant_interface_scan(wifi->interface, scan_params,
3227 scan_callback_hidden, device);
3230 ret = g_supplicant_interface_scan(wifi->interface, scan_params,
3231 scan_callback, device);
3233 connman_device_set_scanning(device,
3234 CONNMAN_SERVICE_TYPE_WIFI, true);
3235 #if defined TIZEN_EXT
3237 * To allow the Full Scan after ssid based scan, set the flag here
3238 * It is required because Tizen does not use the ConnMan specific
3239 * backgroung Scan feature.Tizen has added the BG Scan feature in
3240 * net-config. To sync with up ConnMan, we need to issue the Full Scan
3241 * after SSID specific scan.
3243 if (!params->force_full_scan && !do_hidden)
3244 wifi->allow_full_scan = TRUE;
3247 g_supplicant_free_scan_params(scan_params);
3248 connman_device_unref(device);
3251 hidden_free(wifi->hidden);
3252 wifi->hidden = NULL;
3259 static void wifi_stop_scan(enum connman_service_type type,
3260 struct connman_device *device)
3262 struct wifi_data *wifi = connman_device_get_data(device);
3264 DBG("device %p wifi %p", device, wifi);
3269 if (type == CONNMAN_SERVICE_TYPE_P2P) {
3270 if (connman_device_get_scanning(device, CONNMAN_SERVICE_TYPE_P2P)) {
3271 g_source_remove(wifi->p2p_find_timeout);
3272 p2p_find_stop(device);
3277 static void wifi_regdom_callback(int result,
3281 struct connman_device *device = user_data;
3283 connman_device_regdom_notify(device, result, alpha2);
3285 connman_device_unref(device);
3288 static int wifi_set_regdom(struct connman_device *device, const char *alpha2)
3290 struct wifi_data *wifi = connman_device_get_data(device);
3296 connman_device_ref(device);
3298 ret = g_supplicant_interface_set_country(wifi->interface,
3299 wifi_regdom_callback,
3302 connman_device_unref(device);
3307 static struct connman_device_driver wifi_ng_driver = {
3309 .type = CONNMAN_DEVICE_TYPE_WIFI,
3310 .priority = CONNMAN_DEVICE_PRIORITY_LOW,
3311 .probe = wifi_probe,
3312 .remove = wifi_remove,
3313 .enable = wifi_enable,
3314 .disable = wifi_disable,
3316 .stop_scan = wifi_stop_scan,
3317 .set_regdom = wifi_set_regdom,
3318 #if defined TIZEN_EXT
3319 .specific_scan = wifi_specific_scan,
3321 #if defined TIZEN_EXT_WIFI_MESH
3322 .abort_scan = mesh_abort_scan,
3323 .mesh_specific_scan = mesh_specific_scan,
3327 static void system_ready(void)
3331 if (connman_device_driver_register(&wifi_ng_driver) < 0)
3332 connman_error("Failed to register WiFi driver");
3335 static void system_killed(void)
3339 connman_device_driver_unregister(&wifi_ng_driver);
3342 static int network_probe(struct connman_network *network)
3344 DBG("network %p", network);
3349 static void network_remove(struct connman_network *network)
3351 struct connman_device *device = connman_network_get_device(network);
3352 struct wifi_data *wifi;
3354 DBG("network %p", network);
3356 wifi = connman_device_get_data(device);
3360 if (wifi->network != network)
3363 wifi->network = NULL;
3365 #if defined TIZEN_EXT
3366 wifi->disconnecting = false;
3368 if (wifi->pending_network == network)
3369 wifi->pending_network = NULL;
3371 if (wifi->scan_pending_network == network)
3372 wifi->scan_pending_network = NULL;
3376 static void connect_callback(int result, GSupplicantInterface *interface,
3379 #if defined TIZEN_EXT
3381 struct wifi_data *wifi;
3383 struct connman_network *network = user_data;
3385 DBG("network %p result %d", network, result);
3387 #if defined TIZEN_EXT
3388 set_connman_bssid(RESET_BSSID, NULL);
3390 for (list = iface_list; list; list = list->next) {
3393 if (wifi && wifi->network == network)
3397 /* wifi_data may be invalid because wifi is already disabled */
3402 if (result == -ENOKEY) {
3403 connman_network_set_error(network,
3404 CONNMAN_NETWORK_ERROR_INVALID_KEY);
3405 } else if (result < 0) {
3406 connman_network_set_error(network,
3407 CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL);
3410 connman_network_unref(network);
3413 static GSupplicantSecurity network_security(const char *security)
3415 if (g_str_equal(security, "none"))
3416 return G_SUPPLICANT_SECURITY_NONE;
3417 else if (g_str_equal(security, "wep"))
3418 return G_SUPPLICANT_SECURITY_WEP;
3419 else if (g_str_equal(security, "psk"))
3420 return G_SUPPLICANT_SECURITY_PSK;
3421 else if (g_str_equal(security, "wpa"))
3422 return G_SUPPLICANT_SECURITY_PSK;
3423 else if (g_str_equal(security, "rsn"))
3424 return G_SUPPLICANT_SECURITY_PSK;
3425 else if (g_str_equal(security, "ieee8021x"))
3426 return G_SUPPLICANT_SECURITY_IEEE8021X;
3427 #if defined TIZEN_EXT
3428 else if (g_str_equal(security, "ft_psk") == TRUE)
3429 return G_SUPPLICANT_SECURITY_FT_PSK;
3430 else if (g_str_equal(security, "ft_ieee8021x") == TRUE)
3431 return G_SUPPLICANT_SECURITY_FT_IEEE8021X;
3432 else if (g_str_equal(security, "sae"))
3433 return G_SUPPLICANT_SECURITY_SAE;
3434 else if (g_str_equal(security, "owe"))
3435 return G_SUPPLICANT_SECURITY_OWE;
3436 else if (g_str_equal(security, "dpp"))
3437 return G_SUPPLICANT_SECURITY_DPP;
3440 return G_SUPPLICANT_SECURITY_UNKNOWN;
3443 #if defined TIZEN_EXT
3444 static GSupplicantEapKeymgmt network_eap_keymgmt(const char *security)
3446 if (security == NULL)
3447 return G_SUPPLICANT_EAP_KEYMGMT_NONE;
3449 if (g_str_equal(security, "FT") == TRUE)
3450 return G_SUPPLICANT_EAP_KEYMGMT_FT;
3451 else if (g_str_equal(security, "CCKM") == TRUE)
3452 return G_SUPPLICANT_EAP_KEYMGMT_CCKM;
3454 return G_SUPPLICANT_EAP_KEYMGMT_NONE;
3458 static void ssid_init(GSupplicantSSID *ssid, struct connman_network *network)
3460 const char *security;
3461 #if defined TIZEN_EXT
3462 const void *ssid_data;
3465 memset(ssid, 0, sizeof(*ssid));
3466 ssid->mode = G_SUPPLICANT_MODE_INFRA;
3467 #if defined TIZEN_EXT
3468 ssid_data = connman_network_get_blob(network, "WiFi.SSID",
3470 ssid->ssid = g_try_malloc0(ssid->ssid_len);
3475 memcpy(ssid->ssid, ssid_data, ssid->ssid_len);
3477 ssid->ssid = connman_network_get_blob(network, "WiFi.SSID",
3480 ssid->scan_ssid = 1;
3481 security = connman_network_get_string(network, "WiFi.Security");
3482 ssid->security = network_security(security);
3483 #if defined TIZEN_EXT
3484 ssid->ieee80211w = 1;
3486 ssid->passphrase = connman_network_get_string(network,
3489 ssid->eap = connman_network_get_string(network, "WiFi.EAP");
3492 * If our private key password is unset,
3493 * we use the supplied passphrase. That is needed
3494 * for PEAP where 2 passphrases (identity and client
3495 * cert may have to be provided.
3497 if (!connman_network_get_string(network, "WiFi.PrivateKeyPassphrase"))
3498 connman_network_set_string(network,
3499 "WiFi.PrivateKeyPassphrase",
3501 /* We must have an identity for both PEAP and TLS */
3502 ssid->identity = connman_network_get_string(network, "WiFi.Identity");
3504 /* Use agent provided identity as a fallback */
3505 if (!ssid->identity || strlen(ssid->identity) == 0)
3506 ssid->identity = connman_network_get_string(network,
3507 "WiFi.AgentIdentity");
3509 ssid->anonymous_identity = connman_network_get_string(network,
3510 "WiFi.AnonymousIdentity");
3511 ssid->ca_cert_path = connman_network_get_string(network,
3513 ssid->subject_match = connman_network_get_string(network,
3514 "WiFi.SubjectMatch");
3515 ssid->altsubject_match = connman_network_get_string(network,
3516 "WiFi.AltSubjectMatch");
3517 ssid->domain_suffix_match = connman_network_get_string(network,
3518 "WiFi.DomainSuffixMatch");
3519 ssid->domain_match = connman_network_get_string(network,
3520 "WiFi.DomainMatch");
3521 ssid->client_cert_path = connman_network_get_string(network,
3522 "WiFi.ClientCertFile");
3523 ssid->private_key_path = connman_network_get_string(network,
3524 "WiFi.PrivateKeyFile");
3525 ssid->private_key_passphrase = connman_network_get_string(network,
3526 "WiFi.PrivateKeyPassphrase");
3527 ssid->phase2_auth = connman_network_get_string(network, "WiFi.Phase2");
3529 ssid->use_wps = connman_network_get_bool(network, "WiFi.UseWPS");
3530 ssid->pin_wps = connman_network_get_string(network, "WiFi.PinWPS");
3531 #if defined TIZEN_EXT
3532 ssid->connector = connman_network_get_string(network,
3534 ssid->c_sign_key = connman_network_get_string(network,
3536 ssid->net_access_key = connman_network_get_string(network,
3537 "WiFi.NetAccessKey");
3540 #if defined TIZEN_EXT
3541 if (set_connman_bssid(CHECK_BSSID, NULL) == 6) {
3542 ssid->bssid_for_connect_len = 6;
3543 set_connman_bssid(GET_BSSID, (char *)ssid->bssid_for_connect);
3544 DBG("BSSID : %02x:%02x:%02x:%02x:%02x:%02x",
3545 ssid->bssid_for_connect[0], ssid->bssid_for_connect[1],
3546 ssid->bssid_for_connect[2], ssid->bssid_for_connect[3],
3547 ssid->bssid_for_connect[4], ssid->bssid_for_connect[5]);
3549 ssid->freq = connman_network_get_frequency(network);
3552 GSList *bssid_list = (GSList *)connman_network_get_bssid_list(network);
3553 if (bssid_list && g_slist_length(bssid_list) > 1) {
3555 /* If there are more than one bssid,
3556 * the user-specified bssid is tried only once at the beginning.
3557 * After that, the bssids in the list are tried in order.
3559 if (set_connman_bssid(CHECK_BSSID, NULL) == 6) {
3560 set_connman_bssid(RESET_BSSID, NULL);
3565 char buff[MAC_ADDRESS_LENGTH];
3566 for (list = bssid_list; list; list = list->next) {
3567 struct connman_bssids * bssids = (struct connman_bssids *)list->data;
3569 g_snprintf(buff, MAC_ADDRESS_LENGTH, "%02x:%02x:%02x:%02x:%02x:%02x",
3570 bssids->bssid[0], bssids->bssid[1], bssids->bssid[2],
3571 bssids->bssid[3], bssids->bssid[4], bssids->bssid[5]);
3572 buff[MAC_ADDRESS_LENGTH - 1] = '\0';
3574 gchar *curr_bssid = g_strdup((const gchar *)buff);
3576 if (g_hash_table_contains(failed_bssids, curr_bssid)) {
3577 DBG("bssid match, try next bssid");
3581 g_hash_table_add(failed_bssids, curr_bssid);
3583 memcpy(buff_bssid, bssids->bssid, WIFI_BSSID_LEN_MAX);
3584 ssid->bssid = buff_bssid;
3585 ssid->freq = (unsigned int)bssids->frequency;
3591 ssid->bssid = connman_network_get_bssid(network);
3592 g_hash_table_remove_all(failed_bssids);
3595 ssid->bssid = connman_network_get_bssid(network);
3598 ssid->eap_keymgmt = network_eap_keymgmt(
3599 connman_network_get_string(network, "WiFi.KeymgmtType"));
3600 ssid->phase1 = connman_network_get_string(network, "WiFi.Phase1");
3602 if(g_strcmp0(ssid->eap, "fast") == 0)
3603 ssid->pac_file = g_strdup(WIFI_EAP_FAST_PAC_FILE);
3605 ssid->keymgmt = connman_network_get_keymgmt(network);
3608 if (connman_setting_get_bool("BackgroundScanning"))
3609 ssid->bgscan = BGSCAN_DEFAULT;
3612 static int network_connect(struct connman_network *network)
3614 struct connman_device *device = connman_network_get_device(network);
3615 struct wifi_data *wifi;
3616 GSupplicantInterface *interface;
3617 GSupplicantSSID *ssid;
3619 DBG("network %p", network);
3624 wifi = connman_device_get_data(device);
3628 ssid = g_try_malloc0(sizeof(GSupplicantSSID));
3632 interface = wifi->interface;
3634 ssid_init(ssid, network);
3636 if (wifi->disconnecting) {
3637 wifi->pending_network = network;
3638 #if defined TIZEN_EXT
3643 wifi->network = connman_network_ref(network);
3645 #if defined TIZEN_EXT
3646 wifi->scan_pending_network = NULL;
3649 return g_supplicant_interface_connect(interface, ssid,
3650 connect_callback, network);
3653 return -EINPROGRESS;
3656 static void disconnect_callback(int result, GSupplicantInterface *interface,
3659 #if defined TIZEN_EXT
3661 struct wifi_data *wifi;
3662 struct connman_network *network = user_data;
3664 DBG("network %p result %d", network, result);
3666 for (list = iface_list; list; list = list->next) {
3669 if (wifi->network == NULL && wifi->disconnecting == true)
3670 wifi->disconnecting = false;
3672 if (wifi->network == network)
3676 /* wifi_data may be invalid because wifi is already disabled */
3681 struct wifi_data *wifi = user_data;
3684 DBG("result %d supplicant interface %p wifi %p",
3685 result, interface, wifi);
3687 if (result == -ECONNABORTED) {
3688 DBG("wifi interface no longer available");
3692 if (wifi->network != wifi->pending_network)
3693 connman_network_set_connected(wifi->network, false);
3694 wifi->network = NULL;
3696 wifi->disconnecting = false;
3697 wifi->connected = false;
3699 if (wifi->pending_network) {
3700 network_connect(wifi->pending_network);
3701 wifi->pending_network = NULL;
3704 start_autoscan(wifi->device);
3707 static int network_disconnect(struct connman_network *network)
3709 struct connman_device *device = connman_network_get_device(network);
3710 struct wifi_data *wifi;
3712 #if defined TIZEN_EXT
3713 struct connman_service *service;
3716 DBG("network %p", network);
3718 wifi = connman_device_get_data(device);
3719 if (!wifi || !wifi->interface)
3722 #if defined TIZEN_EXT
3723 if (connman_network_get_associating(network) == true) {
3724 connman_network_clear_associating(network);
3725 connman_network_set_bool(network, "WiFi.UseWPS", false);
3727 service = connman_service_lookup_from_network(network);
3729 if (service != NULL &&
3730 (__connman_service_is_connected_state(service,
3731 CONNMAN_IPCONFIG_TYPE_IPV4) == false &&
3732 __connman_service_is_connected_state(service,
3733 CONNMAN_IPCONFIG_TYPE_IPV6) == false) &&
3734 (connman_service_get_favorite(service) == false))
3735 __connman_service_set_passphrase(service, NULL);
3738 if (wifi->pending_network == network)
3739 wifi->pending_network = NULL;
3741 if (wifi->scan_pending_network == network)
3742 wifi->scan_pending_network = NULL;
3745 connman_network_set_associating(network, false);
3747 if (wifi->disconnecting)
3750 wifi->disconnecting = true;
3752 #if defined TIZEN_EXT
3753 err = g_supplicant_interface_disconnect(wifi->interface,
3754 disconnect_callback, network);
3756 err = g_supplicant_interface_disconnect(wifi->interface,
3757 disconnect_callback, wifi);
3761 wifi->disconnecting = false;
3766 #if defined TIZEN_EXT
3767 static void set_connection_mode(struct connman_network *network,
3770 ieee80211_modes_e phy_mode;
3771 connection_mode_e conn_mode;
3773 phy_mode = connman_network_get_phy_mode(network);
3775 case IEEE80211_MODE_B:
3776 if (linkspeed > 0 && linkspeed <= 11)
3777 conn_mode = CONNECTION_MODE_IEEE80211B;
3779 conn_mode = CONNECTION_MODE_IEEE80211_UNKNOWN;
3782 case IEEE80211_MODE_BG:
3783 if (linkspeed > 0 && linkspeed <= 11)
3784 conn_mode = CONNECTION_MODE_IEEE80211B;
3785 else if (linkspeed > 11 && linkspeed <= 54)
3786 conn_mode = CONNECTION_MODE_IEEE80211G;
3788 conn_mode = CONNECTION_MODE_IEEE80211_UNKNOWN;
3791 case IEEE80211_MODE_BGN:
3792 if (linkspeed > 0 && linkspeed <= 11)
3793 conn_mode = CONNECTION_MODE_IEEE80211B;
3794 else if (linkspeed > 11 && linkspeed <= 54)
3795 conn_mode = CONNECTION_MODE_IEEE80211G;
3796 else if (linkspeed > 54 && linkspeed <= 450)
3797 conn_mode = CONNECTION_MODE_IEEE80211N;
3799 conn_mode = CONNECTION_MODE_IEEE80211_UNKNOWN;
3802 case IEEE80211_MODE_A:
3803 if (linkspeed > 0 && linkspeed <= 54)
3804 conn_mode = CONNECTION_MODE_IEEE80211A;
3806 conn_mode = CONNECTION_MODE_IEEE80211_UNKNOWN;
3809 case IEEE80211_MODE_AN:
3810 if (linkspeed > 0 && linkspeed <= 54)
3811 conn_mode = CONNECTION_MODE_IEEE80211A;
3812 else if (linkspeed > 54 && linkspeed <= 450)
3813 conn_mode = CONNECTION_MODE_IEEE80211N;
3815 conn_mode = CONNECTION_MODE_IEEE80211_UNKNOWN;
3818 case IEEE80211_MODE_ANAC:
3819 if (linkspeed > 0 && linkspeed <= 54)
3820 conn_mode = CONNECTION_MODE_IEEE80211A;
3821 else if (linkspeed > 54 && linkspeed <= 450)
3822 conn_mode = CONNECTION_MODE_IEEE80211N;
3823 else if (linkspeed > 450 && linkspeed <= 1300)
3824 conn_mode = CONNECTION_MODE_IEEE80211AC;
3826 conn_mode = CONNECTION_MODE_IEEE80211_UNKNOWN;
3830 conn_mode = CONNECTION_MODE_IEEE80211_UNKNOWN;
3834 DBG("connection mode(%d)", conn_mode);
3835 connman_network_set_connection_mode(network, conn_mode);
3838 static void signalpoll_callback(int result, int maxspeed, int strength,
3841 struct connman_network *network = user_data;
3844 DBG("Failed to get maxspeed from signalpoll !");
3852 DBG("maxspeed = %d, strength = %d", maxspeed, strength);
3854 connman_network_set_strength(network, (uint8_t)strength);
3855 connman_network_set_maxspeed(network, maxspeed);
3856 set_connection_mode(network, maxspeed);
3860 static int network_signalpoll(struct wifi_data *wifi)
3862 GSupplicantInterface *interface;
3863 struct connman_network *network;
3865 if (!wifi || !wifi->network)
3868 interface = wifi->interface;
3869 network = wifi->network;
3871 DBG("network %p", network);
3873 return g_supplicant_interface_signalpoll(interface, signalpoll_callback, network);
3876 static gboolean autosignalpoll_timeout(gpointer data)
3878 struct wifi_data *wifi = data;
3880 if (!wifi || !wifi->automaxspeed_timeout) {
3881 DBG("automaxspeed_timeout is found to be zero. i.e. currently in disconnected state. !!");
3885 int ret = network_signalpoll(wifi);
3887 DBG("Fail to get max speed !!");
3888 wifi->automaxspeed_timeout = 0;
3896 static struct connman_network_driver network_driver = {
3898 .type = CONNMAN_NETWORK_TYPE_WIFI,
3899 .priority = CONNMAN_NETWORK_PRIORITY_LOW,
3900 .probe = network_probe,
3901 .remove = network_remove,
3902 .connect = network_connect,
3903 .disconnect = network_disconnect,
3906 static void interface_added(GSupplicantInterface *interface)
3908 const char *ifname = g_supplicant_interface_get_ifname(interface);
3909 const char *driver = g_supplicant_interface_get_driver(interface);
3910 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
3912 * Note: If supplicant interface's driver is wired then skip it,
3913 * because it meanti only for ethernet not Wi-Fi.
3915 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
3917 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
3919 #if defined TIZEN_EXT
3920 bool is_5_0_ghz_supported = g_supplicant_interface_get_is_5_0_ghz_supported(interface);
3923 struct wifi_data *wifi;
3925 wifi = g_supplicant_interface_get_data(interface);
3927 wifi = get_pending_wifi_data(ifname);
3931 wifi->interface = interface;
3932 g_supplicant_interface_set_data(interface, wifi);
3933 p2p_iface_list = g_list_append(p2p_iface_list, wifi);
3934 wifi->p2p_device = true;
3937 DBG("ifname %s driver %s wifi %p tethering %d",
3938 ifname, driver, wifi, wifi->tethering);
3940 if (!wifi->device) {
3941 connman_error("WiFi device not set");
3945 connman_device_set_powered(wifi->device, true);
3946 #if defined TIZEN_EXT
3947 connman_techonology_wifi_set_5ghz_supported(wifi_technology, is_5_0_ghz_supported);
3948 /* Max number of SSIDs supported by wlan chipset that can be scanned */
3949 int max_scan_ssids = g_supplicant_interface_get_max_scan_ssids(interface);
3950 connman_techonology_set_max_scan_ssids(wifi_technology, max_scan_ssids);
3954 static bool is_idle(struct wifi_data *wifi)
3956 DBG("state %d", wifi->state);
3958 switch (wifi->state) {
3959 case G_SUPPLICANT_STATE_UNKNOWN:
3960 case G_SUPPLICANT_STATE_DISABLED:
3961 case G_SUPPLICANT_STATE_DISCONNECTED:
3962 case G_SUPPLICANT_STATE_INACTIVE:
3963 case G_SUPPLICANT_STATE_SCANNING:
3966 case G_SUPPLICANT_STATE_AUTHENTICATING:
3967 case G_SUPPLICANT_STATE_ASSOCIATING:
3968 case G_SUPPLICANT_STATE_ASSOCIATED:
3969 case G_SUPPLICANT_STATE_4WAY_HANDSHAKE:
3970 case G_SUPPLICANT_STATE_GROUP_HANDSHAKE:
3971 case G_SUPPLICANT_STATE_COMPLETED:
3978 static bool is_idle_wps(GSupplicantInterface *interface,
3979 struct wifi_data *wifi)
3981 /* First, let's check if WPS processing did not went wrong */
3982 if (g_supplicant_interface_get_wps_state(interface) ==
3983 G_SUPPLICANT_WPS_STATE_FAIL)
3986 /* Unlike normal connection, being associated while processing wps
3987 * actually means that we are idling. */
3988 switch (wifi->state) {
3989 case G_SUPPLICANT_STATE_UNKNOWN:
3990 case G_SUPPLICANT_STATE_DISABLED:
3991 case G_SUPPLICANT_STATE_DISCONNECTED:
3992 case G_SUPPLICANT_STATE_INACTIVE:
3993 case G_SUPPLICANT_STATE_SCANNING:
3994 case G_SUPPLICANT_STATE_ASSOCIATED:
3996 case G_SUPPLICANT_STATE_AUTHENTICATING:
3997 case G_SUPPLICANT_STATE_ASSOCIATING:
3998 case G_SUPPLICANT_STATE_4WAY_HANDSHAKE:
3999 case G_SUPPLICANT_STATE_GROUP_HANDSHAKE:
4000 case G_SUPPLICANT_STATE_COMPLETED:
4007 static bool handle_wps_completion(GSupplicantInterface *interface,
4008 struct connman_network *network,
4009 struct connman_device *device,
4010 struct wifi_data *wifi)
4014 wps = connman_network_get_bool(network, "WiFi.UseWPS");
4016 const unsigned char *ssid, *wps_ssid;
4017 unsigned int ssid_len, wps_ssid_len;
4018 const char *wps_key;
4020 /* Checking if we got associated with requested
4022 ssid = connman_network_get_blob(network, "WiFi.SSID",
4025 wps_ssid = g_supplicant_interface_get_wps_ssid(
4026 interface, &wps_ssid_len);
4028 if (!wps_ssid || wps_ssid_len != ssid_len ||
4029 memcmp(ssid, wps_ssid, ssid_len) != 0) {
4030 connman_network_set_associating(network, false);
4031 #if defined TIZEN_EXT
4032 g_supplicant_interface_disconnect(wifi->interface,
4033 disconnect_callback, wifi->network);
4035 connman_network_set_bool(network, "WiFi.UseWPS", false);
4036 connman_network_set_string(network, "WiFi.PinWPS", NULL);
4038 g_supplicant_interface_disconnect(wifi->interface,
4039 disconnect_callback, wifi);
4044 wps_key = g_supplicant_interface_get_wps_key(interface);
4045 #if defined TIZEN_EXT
4046 /* Check the passphrase and encrypt it
4049 gchar *passphrase = g_strdup(wps_key);
4051 connman_network_set_string(network, "WiFi.PinWPS", NULL);
4053 if (check_passphrase_ext(network, passphrase) < 0) {
4054 DBG("[WPS] Invalid passphrase");
4059 ret = send_encryption_request(passphrase, network);
4064 DBG("[WPS] Encryption request succeeded");
4066 DBG("[WPS] Encryption request failed %d", ret);
4069 connman_network_set_string(network, "WiFi.Passphrase",
4072 connman_network_set_string(network, "WiFi.PinWPS", NULL);
4079 static bool handle_assoc_status_code(GSupplicantInterface *interface,
4080 struct wifi_data *wifi)
4082 if (wifi->state == G_SUPPLICANT_STATE_ASSOCIATING &&
4083 #if defined TIZEN_EXT
4084 wifi->assoc_code > 0 &&
4086 wifi->assoc_code == ASSOC_STATUS_NO_CLIENT &&
4088 wifi->load_shaping_retries < LOAD_SHAPING_MAX_RETRIES) {
4089 wifi->load_shaping_retries ++;
4092 wifi->load_shaping_retries = 0;
4096 static bool handle_4way_handshake_failure(GSupplicantInterface *interface,
4097 struct connman_network *network,
4098 struct wifi_data *wifi)
4100 #if defined TIZEN_EXT
4101 const char *security;
4102 struct connman_service *service;
4104 if (wifi->connected)
4107 security = connman_network_get_string(network, "WiFi.Security");
4109 if (security && g_str_equal(security, "ieee8021x") == true &&
4110 wifi->state == G_SUPPLICANT_STATE_ASSOCIATED) {
4112 connman_network_set_error(network, CONNMAN_NETWORK_ERROR_INVALID_KEY);
4117 if (wifi->state != G_SUPPLICANT_STATE_4WAY_HANDSHAKE)
4120 struct connman_service *service;
4122 if (wifi->state != G_SUPPLICANT_STATE_4WAY_HANDSHAKE)
4125 if (wifi->connected)
4129 service = connman_service_lookup_from_network(network);
4135 if (connman_service_get_favorite(service)) {
4136 if (wifi->retries < FAVORITE_MAXIMUM_RETRIES)
4141 connman_network_set_error(network, CONNMAN_NETWORK_ERROR_INVALID_KEY);
4146 #if defined TIZEN_EXT
4147 static bool handle_wifi_assoc_retry(struct connman_network *network,
4148 struct wifi_data *wifi)
4150 const char *security;
4152 if (!wifi->network || wifi->connected || wifi->disconnecting ||
4153 connman_network_get_connecting(network) != true) {
4154 wifi->assoc_retry_count = 0;
4158 if (wifi->state != G_SUPPLICANT_STATE_ASSOCIATING &&
4159 wifi->state != G_SUPPLICANT_STATE_ASSOCIATED) {
4160 wifi->assoc_retry_count = 0;
4164 security = connman_network_get_string(network, "WiFi.Security");
4165 if (security && g_str_equal(security, "ieee8021x") == true &&
4166 wifi->state == G_SUPPLICANT_STATE_ASSOCIATED) {
4167 wifi->assoc_retry_count = 0;
4171 if (++wifi->assoc_retry_count >= TIZEN_ASSOC_RETRY_COUNT) {
4172 wifi->assoc_retry_count = 0;
4174 /* Honestly it's not an invalid-key error,
4175 * however QA team recommends that the invalid-key error
4176 * might be better to display for user experience.
4178 connman_network_set_error(network, CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
4187 static void interface_state(GSupplicantInterface *interface)
4189 struct connman_network *network;
4190 struct connman_device *device;
4191 struct wifi_data *wifi;
4192 GSupplicantState state = g_supplicant_interface_get_state(interface);
4193 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
4195 * Note: If supplicant interface's driver is wired then skip it,
4196 * because it meanti only for ethernet not Wi-Fi.
4198 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
4200 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
4205 wifi = g_supplicant_interface_get_data(interface);
4207 DBG("wifi %p interface state %d", wifi, state);
4212 device = wifi->device;
4216 if (state == G_SUPPLICANT_STATE_COMPLETED) {
4217 if (wifi->tethering_param) {
4218 g_free(wifi->tethering_param->ssid);
4219 g_free(wifi->tethering_param);
4220 wifi->tethering_param = NULL;
4223 if (wifi->tethering)
4224 stop_autoscan(device);
4227 if (g_supplicant_interface_get_ready(interface) &&
4228 !wifi->interface_ready) {
4229 wifi->interface_ready = true;
4230 finalize_interface_creation(wifi);
4233 network = wifi->network;
4238 case G_SUPPLICANT_STATE_SCANNING:
4239 if (wifi->connected)
4240 connman_network_set_connected(network, false);
4244 case G_SUPPLICANT_STATE_AUTHENTICATING:
4245 case G_SUPPLICANT_STATE_ASSOCIATING:
4246 #if defined TIZEN_EXT
4247 reset_autoscan(device);
4249 stop_autoscan(device);
4252 if (!wifi->connected)
4253 connman_network_set_associating(network, true);
4257 case G_SUPPLICANT_STATE_COMPLETED:
4258 #if defined TIZEN_EXT
4259 /* though it should be already reset: */
4260 reset_autoscan(device);
4262 wifi->assoc_retry_count = 0;
4264 wifi->scan_pending_network = NULL;
4266 /* should be cleared scanning flag */
4267 bool scanning = connman_device_get_scanning(device,
4268 CONNMAN_SERVICE_TYPE_WIFI);
4270 connman_device_set_scanning(device,
4271 CONNMAN_SERVICE_TYPE_WIFI, false);
4272 connman_device_unref(device);
4275 if (!wifi->automaxspeed_timeout) {
4276 DBG("Going to start signalpoll timer!!");
4277 int ret = network_signalpoll(wifi);
4279 DBG("Fail to get max speed !!");
4281 wifi->automaxspeed_timeout = g_timeout_add_seconds(10, autosignalpoll_timeout, wifi);
4284 g_hash_table_remove_all(failed_bssids);
4286 /* though it should be already stopped: */
4287 stop_autoscan(device);
4290 if (!handle_wps_completion(interface, network, device, wifi))
4293 connman_network_set_connected(network, true);
4295 wifi->disconnect_code = 0;
4296 wifi->assoc_code = 0;
4297 wifi->load_shaping_retries = 0;
4300 case G_SUPPLICANT_STATE_DISCONNECTED:
4301 #if defined TIZEN_EXT
4302 connman_network_set_strength(network, 0);
4303 connman_network_set_maxspeed(network, 0);
4305 if (wifi->automaxspeed_timeout != 0) {
4306 g_source_remove(wifi->automaxspeed_timeout);
4307 wifi->automaxspeed_timeout = 0;
4308 DBG("Remove signalpoll timer!!");
4312 * If we're in one of the idle modes, we have
4313 * not started association yet and thus setting
4314 * those ones to FALSE could cancel an association
4317 wps = connman_network_get_bool(network, "WiFi.UseWPS");
4319 if (is_idle_wps(interface, wifi))
4325 #if defined TIZEN_EXT
4326 if (handle_assoc_status_code(interface, wifi)) {
4327 GSList *bssid_list = (GSList *)connman_network_get_bssid_list(network);
4328 const char *group = connman_network_get_group(network);
4329 GSupplicantNetwork *supplicant_network;
4330 guint bssid_length = 0;
4333 supplicant_network = g_supplicant_interface_get_network(interface, group);
4335 connman_network_set_assoc_reject_table(network,
4336 g_supplicant_network_get_assoc_reject_table(supplicant_network));
4338 g_supplicant_network_update_assoc_reject(interface, supplicant_network);
4342 bssid_length = g_slist_length(bssid_list);
4344 if (bssid_length > 1 && bssid_length > g_hash_table_size(failed_bssids)) {
4345 network_connect(network);
4349 wifi->load_shaping_retries = 0;
4352 g_hash_table_remove_all(failed_bssids);
4354 if (handle_assoc_status_code(interface, wifi))
4358 /* If previous state was 4way-handshake, then
4359 * it's either: psk was incorrect and thus we retry
4360 * or if we reach the maximum retries we declare the
4362 if (handle_4way_handshake_failure(interface,
4366 /* See table 8-36 Reason codes in IEEE Std 802.11 */
4367 switch (wifi->disconnect_code) {
4368 case 1: /* Unspecified reason */
4369 /* Let's assume it's because we got blocked */
4371 case 6: /* Class 2 frame received from nonauthenticated STA */
4372 connman_network_set_error(network,
4373 CONNMAN_NETWORK_ERROR_BLOCKED);
4380 #if defined TIZEN_EXT
4381 /* Some of Wi-Fi networks are not comply Wi-Fi specification.
4382 * Retry association until its retry count is expired */
4383 if (handle_wifi_assoc_retry(network, wifi) == true) {
4384 throw_wifi_scan(wifi->device, scan_callback);
4385 wifi->scan_pending_network = wifi->network;
4389 if(wifi->disconnect_code > 0){
4390 DBG("Set disconnect reason code(%d)", wifi->disconnect_code);
4391 connman_network_set_disconnect_reason(network, wifi->disconnect_code);
4395 if (network != wifi->pending_network) {
4396 connman_network_set_connected(network, false);
4397 connman_network_set_associating(network, false);
4399 wifi->disconnecting = false;
4401 start_autoscan(device);
4405 case G_SUPPLICANT_STATE_INACTIVE:
4406 #if defined TIZEN_EXT
4407 if (handle_wps_completion(interface, network, device, wifi) == false)
4410 connman_network_set_associating(network, false);
4411 start_autoscan(device);
4415 case G_SUPPLICANT_STATE_UNKNOWN:
4416 case G_SUPPLICANT_STATE_DISABLED:
4417 case G_SUPPLICANT_STATE_ASSOCIATED:
4418 case G_SUPPLICANT_STATE_4WAY_HANDSHAKE:
4419 case G_SUPPLICANT_STATE_GROUP_HANDSHAKE:
4423 old_connected = wifi->connected;
4424 wifi->state = state;
4426 /* Saving wpa_s state policy:
4427 * If connected and if the state changes are roaming related:
4428 * --> We stay connected
4430 * --> We are connected
4432 * --> We are not connected
4435 case G_SUPPLICANT_STATE_AUTHENTICATING:
4436 case G_SUPPLICANT_STATE_ASSOCIATING:
4437 case G_SUPPLICANT_STATE_ASSOCIATED:
4438 case G_SUPPLICANT_STATE_4WAY_HANDSHAKE:
4439 case G_SUPPLICANT_STATE_GROUP_HANDSHAKE:
4440 if (wifi->connected)
4441 connman_warn("Probably roaming right now!"
4442 " Staying connected...");
4444 case G_SUPPLICANT_STATE_SCANNING:
4445 wifi->connected = false;
4448 start_autoscan(device);
4450 case G_SUPPLICANT_STATE_COMPLETED:
4451 wifi->connected = true;
4454 wifi->connected = false;
4461 static void interface_removed(GSupplicantInterface *interface)
4463 const char *ifname = g_supplicant_interface_get_ifname(interface);
4464 struct wifi_data *wifi;
4465 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
4467 * Note: If supplicant interface's driver is wired then skip it,
4468 * because it meanti only for ethernet not Wi-Fi.
4470 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
4472 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
4475 DBG("ifname %s", ifname);
4477 wifi = g_supplicant_interface_get_data(interface);
4479 #if defined TIZEN_EXT_WIFI_MESH
4480 if (wifi && wifi->mesh_interface) {
4481 DBG("Notify mesh interface remove");
4482 connman_mesh_notify_interface_remove(true);
4483 struct wifi_mesh_info *mesh_info = wifi->mesh_info;
4484 g_free(mesh_info->parent_ifname);
4485 g_free(mesh_info->ifname);
4486 g_free(mesh_info->identifier);
4488 wifi->mesh_interface = false;
4489 wifi->mesh_info = NULL;
4495 wifi->interface = NULL;
4497 if (wifi && wifi->tethering)
4500 if (!wifi || !wifi->device) {
4501 DBG("wifi interface already removed");
4505 connman_device_set_powered(wifi->device, false);
4507 check_p2p_technology();
4508 #if defined TIZEN_EXT_WIFI_MESH
4509 check_mesh_technology();
4513 static void set_device_type(const char *type, char dev_type[17])
4515 const char *oui = "0050F204";
4516 const char *category = "0001";
4517 const char *sub_category = "0000";
4519 if (!g_strcmp0(type, "handset")) {
4521 sub_category = "0005";
4522 } else if (!g_strcmp0(type, "vm") || !g_strcmp0(type, "container"))
4523 sub_category = "0001";
4524 else if (!g_strcmp0(type, "server"))
4525 sub_category = "0002";
4526 else if (!g_strcmp0(type, "laptop"))
4527 sub_category = "0005";
4528 else if (!g_strcmp0(type, "desktop"))
4529 sub_category = "0006";
4530 else if (!g_strcmp0(type, "tablet"))
4531 sub_category = "0009";
4532 else if (!g_strcmp0(type, "watch"))
4535 snprintf(dev_type, 17, "%s%s%s", category, oui, sub_category);
4538 static void p2p_support(GSupplicantInterface *interface)
4540 char dev_type[17] = {};
4541 const char *hostname;
4542 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
4544 * Note: If supplicant interface's driver is wired then skip it,
4545 * because it meanti only for ethernet not Wi-Fi.
4547 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
4549 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
4557 if (!g_supplicant_interface_has_p2p(interface))
4560 if (connman_technology_driver_register(&p2p_tech_driver) < 0) {
4561 DBG("Could not register P2P technology driver");
4565 hostname = connman_utsname_get_hostname();
4567 hostname = "ConnMan";
4569 set_device_type(connman_machine_get_type(), dev_type);
4570 g_supplicant_interface_set_p2p_device_config(interface,
4571 hostname, dev_type);
4572 connman_peer_driver_register(&peer_driver);
4575 static void scan_started(GSupplicantInterface *interface)
4577 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
4579 * Note: If supplicant interface's driver is wired then skip it,
4580 * because it meanti only for ethernet not Wi-Fi.
4582 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
4584 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
4589 static void scan_finished(GSupplicantInterface *interface)
4591 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
4593 * Note: If supplicant interface's driver is wired then skip it,
4594 * because it meanti only for ethernet not Wi-Fi.
4596 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
4598 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
4600 #if defined TIZEN_EXT
4601 struct wifi_data *wifi;
4602 bool is_associating = false;
4603 static bool is_scanning = true;
4608 #if defined TIZEN_EXT
4609 wifi = g_supplicant_interface_get_data(interface);
4610 if (wifi && wifi->scan_pending_network) {
4611 network_connect(wifi->scan_pending_network);
4612 wifi->scan_pending_network = NULL;
4615 //service state - associating
4616 if(!wifi || !wifi->network)
4619 is_associating = connman_network_get_associating(wifi->network);
4620 if(is_associating && is_scanning){
4621 is_scanning = false;
4622 DBG("send scan for connecting");
4623 throw_wifi_scan(wifi->device, scan_callback);
4634 static void ap_create_fail(GSupplicantInterface *interface)
4636 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
4638 * Note: If supplicant interface's driver is wired then skip it,
4639 * because it meanti only for ethernet not Wi-Fi.
4641 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
4643 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
4645 struct wifi_data *wifi = g_supplicant_interface_get_data(interface);
4648 if ((wifi->tethering) && (wifi->tethering_param)) {
4649 DBG("%s create AP fail \n",
4650 g_supplicant_interface_get_ifname(wifi->interface));
4652 connman_inet_remove_from_bridge(wifi->index, wifi->bridge);
4653 wifi->ap_supported = WIFI_AP_NOT_SUPPORTED;
4654 wifi->tethering = false;
4656 ret = tech_set_tethering(wifi->tethering_param->technology,
4657 wifi->tethering_param->ssid->ssid,
4658 wifi->tethering_param->ssid->passphrase,
4659 wifi->bridge, true);
4661 if ((ret == -EOPNOTSUPP) && (wifi_technology)) {
4662 connman_technology_tethering_notify(wifi_technology,false);
4665 g_free(wifi->tethering_param->ssid);
4666 g_free(wifi->tethering_param);
4667 wifi->tethering_param = NULL;
4671 static unsigned char calculate_strength(GSupplicantNetwork *supplicant_network)
4673 unsigned char strength;
4675 strength = 120 + g_supplicant_network_get_signal(supplicant_network);
4676 #if !defined TIZEN_EXT
4684 #if defined TIZEN_EXT_WIFI_MESH
4685 static void mesh_peer_added(GSupplicantNetwork *supplicant_network)
4687 GSupplicantInterface *interface;
4688 struct wifi_data *wifi;
4689 const char *name, *security;
4690 struct connman_mesh *connman_mesh;
4691 struct wifi_mesh_info *mesh_info;
4692 const unsigned char *bssid;
4693 const char *identifier;
4698 interface = g_supplicant_network_get_interface(supplicant_network);
4699 wifi = g_supplicant_interface_get_data(interface);
4700 if (!wifi || !wifi->mesh_interface) {
4701 DBG("Virtual Mesh interface not created");
4705 bssid = g_supplicant_network_get_bssid(supplicant_network);
4706 address = g_malloc0(19);
4707 snprintf(address, 19, "%02x:%02x:%02x:%02x:%02x:%02x", bssid[0], bssid[1],
4708 bssid[2], bssid[3], bssid[4], bssid[5]);
4710 identifier = g_supplicant_network_get_identifier(supplicant_network);
4711 name = g_supplicant_network_get_name(supplicant_network);
4712 security = g_supplicant_network_get_security(supplicant_network);
4713 frequency = g_supplicant_network_get_frequency(supplicant_network);
4715 mesh_info = wifi->mesh_info;
4716 connman_mesh = connman_mesh_get(mesh_info->identifier, identifier);
4720 DBG("Mesh Peer name %s identifier %s security %s added", name, identifier,
4722 connman_mesh = connman_mesh_create(mesh_info->identifier, identifier);
4723 connman_mesh_set_name(connman_mesh, name);
4724 connman_mesh_set_security(connman_mesh, security);
4725 connman_mesh_set_frequency(connman_mesh, frequency);
4726 connman_mesh_set_address(connman_mesh, address);
4727 connman_mesh_set_index(connman_mesh, mesh_info->index);
4728 connman_mesh_set_strength(connman_mesh,
4729 calculate_strength(supplicant_network));
4730 connman_mesh_set_peer_type(connman_mesh, CONNMAN_MESH_PEER_TYPE_DISCOVERED);
4732 ret = connman_mesh_register(connman_mesh);
4733 if (ret == -EALREADY)
4734 DBG("Mesh Peer is already registered");
4740 static void mesh_peer_removed(GSupplicantNetwork *supplicant_network)
4742 GSupplicantInterface *interface;
4743 struct wifi_data *wifi;
4744 struct connman_mesh *connman_mesh;
4745 struct wifi_mesh_info *mesh_info;
4746 const char *identifier;
4748 interface = g_supplicant_network_get_interface(supplicant_network);
4749 wifi = g_supplicant_interface_get_data(interface);
4750 if (!wifi || !wifi->mesh_interface) {
4751 DBG("Virtual Mesh interface not created");
4755 identifier = g_supplicant_network_get_identifier(supplicant_network);
4757 DBG("Failed to get Mesh Peer identifier");
4761 mesh_info = wifi->mesh_info;
4762 connman_mesh = connman_mesh_get(mesh_info->identifier, identifier);
4764 /* Do not unregister connected mesh peer */
4765 if (connman_mesh_peer_is_connected_state(connman_mesh)) {
4766 DBG("Mesh Peer %s is connected", identifier);
4769 DBG("Mesh Peer identifier %s removed", identifier);
4770 connman_mesh_unregister(connman_mesh);
4775 static void network_added(GSupplicantNetwork *supplicant_network)
4777 struct connman_network *network;
4778 GSupplicantInterface *interface;
4779 struct wifi_data *wifi;
4780 const char *name, *identifier, *security, *group, *mode;
4781 const unsigned char *ssid;
4782 unsigned int ssid_len;
4786 bool wps_advertizing;
4788 #if defined TIZEN_EXT
4789 bool owe_transition_mode;
4790 const unsigned char *transition_mode_ssid;
4791 const unsigned char *transition_mode_bssid;
4792 unsigned int transition_mode_ssid_len;
4793 GSList *vsie_list = NULL;
4794 const unsigned char *country_code;
4795 ieee80211_modes_e phy_mode;
4798 mode = g_supplicant_network_get_mode(supplicant_network);
4799 identifier = g_supplicant_network_get_identifier(supplicant_network);
4801 DBG("%s", identifier);
4803 if (!g_strcmp0(mode, "adhoc"))
4806 #if defined TIZEN_EXT_WIFI_MESH
4807 if (!g_strcmp0(mode, "mesh")) {
4808 mesh_peer_added(supplicant_network);
4813 interface = g_supplicant_network_get_interface(supplicant_network);
4814 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
4816 * Note: If supplicant interface's driver is wired then skip it,
4817 * because it meanti only for ethernet not Wi-Fi.
4819 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
4821 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
4823 wifi = g_supplicant_interface_get_data(interface);
4824 name = g_supplicant_network_get_name(supplicant_network);
4825 security = g_supplicant_network_get_security(supplicant_network);
4826 group = g_supplicant_network_get_identifier(supplicant_network);
4827 wps = g_supplicant_network_get_wps(supplicant_network);
4828 wps_pbc = g_supplicant_network_is_wps_pbc(supplicant_network);
4829 wps_ready = g_supplicant_network_is_wps_active(supplicant_network);
4830 wps_advertizing = g_supplicant_network_is_wps_advertizing(
4831 supplicant_network);
4836 ssid = g_supplicant_network_get_ssid(supplicant_network, &ssid_len);
4838 network = connman_device_get_network(wifi->device, identifier);
4841 network = connman_network_create(identifier,
4842 CONNMAN_NETWORK_TYPE_WIFI);
4846 connman_network_set_index(network, wifi->index);
4848 if (connman_device_add_network(wifi->device, network) < 0) {
4849 connman_network_unref(network);
4853 wifi->networks = g_slist_prepend(wifi->networks, network);
4856 if (name && name[0] != '\0')
4857 connman_network_set_name(network, name);
4859 connman_network_set_blob(network, "WiFi.SSID",
4861 #if defined TIZEN_EXT
4862 vsie_list = (GSList *)g_supplicant_network_get_wifi_vsie(supplicant_network);
4864 connman_network_set_vsie_list(network, vsie_list);
4866 DBG("vsie_list is NULL");
4867 country_code = g_supplicant_network_get_countrycode(supplicant_network);
4868 connman_network_set_countrycode(network, country_code);
4869 phy_mode = g_supplicant_network_get_phy_mode(supplicant_network);
4870 connman_network_set_phy_mode(network, phy_mode);
4872 connman_network_set_string(network, "WiFi.Security", security);
4873 connman_network_set_strength(network,
4874 calculate_strength(supplicant_network));
4875 connman_network_set_bool(network, "WiFi.WPS", wps);
4876 connman_network_set_bool(network, "WiFi.WPSAdvertising",
4880 /* Is AP advertizing for WPS association?
4881 * If so, we decide to use WPS by default */
4882 if (wps_ready && wps_pbc &&
4884 #if !defined TIZEN_EXT
4885 connman_network_set_bool(network, "WiFi.UseWPS", true);
4887 DBG("wps is activating by ap but ignore it.");
4891 connman_network_set_frequency(network,
4892 g_supplicant_network_get_frequency(supplicant_network));
4894 #if defined TIZEN_EXT
4895 connman_network_set_bssid(network,
4896 g_supplicant_network_get_bssid(supplicant_network));
4897 owe_transition_mode = (bool)g_supplicant_network_get_transition_mode(supplicant_network);
4898 connman_network_set_bool(network, "WiFi.TRANSITION_MODE", owe_transition_mode);
4899 if (owe_transition_mode) {
4900 transition_mode_ssid = (unsigned char *)g_supplicant_network_get_transition_mode_ssid(supplicant_network, &transition_mode_ssid_len);
4901 connman_network_set_blob(network, "WiFi.TRANSITION_MODE_SSID",
4902 transition_mode_ssid, transition_mode_ssid_len);
4903 transition_mode_bssid = g_supplicant_network_get_transition_mode_bssid(supplicant_network);
4904 connman_network_set_transition_mode_bssid(network, transition_mode_bssid);
4906 connman_network_set_maxrate(network,
4907 g_supplicant_network_get_maxrate(supplicant_network));
4908 connman_network_set_enc_mode(network,
4909 g_supplicant_network_get_enc_mode(supplicant_network));
4910 connman_network_set_rsn_mode(network,
4911 g_supplicant_network_get_rsn_mode(supplicant_network));
4912 connman_network_set_keymgmt(network,
4913 g_supplicant_network_get_keymgmt(supplicant_network));
4914 connman_network_set_bool(network, "WiFi.HS20AP",
4915 g_supplicant_network_is_hs20AP(supplicant_network));
4916 connman_network_set_bssid_list(network,
4917 (GSList *)g_supplicant_network_get_bssid_list(supplicant_network));
4918 connman_network_set_last_connected_bssid(network,
4919 g_supplicant_network_get_last_connected_bssid(supplicant_network));
4920 connman_network_set_assoc_reject_table(network,
4921 g_supplicant_network_get_assoc_reject_table(supplicant_network));
4923 connman_network_set_available(network, true);
4924 connman_network_set_string(network, "WiFi.Mode", mode);
4926 #if defined TIZEN_EXT
4931 connman_network_set_group(network, group);
4933 #if defined TIZEN_EXT
4934 g_supplicant_network_set_last_connected_bssid(supplicant_network,
4935 connman_network_get_last_connected_bssid(network));
4938 #if defined TIZEN_EXT
4939 if (wifi_first_scan == true)
4940 found_with_first_scan = true;
4943 if (wifi->hidden && ssid) {
4944 #if defined TIZEN_EXT
4945 if (network_security(wifi->hidden->security) ==
4946 network_security(security) &&
4948 if (!g_strcmp0(wifi->hidden->security, security) &&
4950 wifi->hidden->ssid_len == ssid_len &&
4951 !memcmp(wifi->hidden->ssid, ssid, ssid_len)) {
4952 connman_network_connect_hidden(network,
4953 wifi->hidden->identity,
4954 wifi->hidden->passphrase,
4955 wifi->hidden->user_data);
4956 wifi->hidden->user_data = NULL;
4957 hidden_free(wifi->hidden);
4958 wifi->hidden = NULL;
4963 static void network_removed(GSupplicantNetwork *network)
4965 GSupplicantInterface *interface;
4966 struct wifi_data *wifi;
4967 const char *name, *identifier;
4968 struct connman_network *connman_network;
4970 #if defined TIZEN_EXT_WIFI_MESH
4972 mode = g_supplicant_network_get_mode(network);
4973 if (!g_strcmp0(mode, "mesh")) {
4974 mesh_peer_removed(network);
4979 interface = g_supplicant_network_get_interface(network);
4980 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
4982 * Note: If supplicant interface's driver is wired then skip it,
4983 * because it meanti only for ethernet not Wi-Fi.
4985 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
4987 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
4989 wifi = g_supplicant_interface_get_data(interface);
4990 identifier = g_supplicant_network_get_identifier(network);
4991 name = g_supplicant_network_get_name(network);
4993 DBG("name %s", name);
4998 connman_network = connman_device_get_network(wifi->device, identifier);
4999 if (!connman_network)
5002 #if defined TIZEN_EXT
5003 if (connman_network == wifi->scan_pending_network)
5004 wifi->scan_pending_network = NULL;
5006 if (connman_network == wifi->pending_network)
5007 wifi->pending_network = NULL;
5009 if(connman_network_get_connecting(connman_network) == true){
5010 connman_network_set_connected(connman_network, false);
5014 wifi->networks = g_slist_remove(wifi->networks, connman_network);
5016 connman_device_remove_network(wifi->device, connman_network);
5017 connman_network_unref(connman_network);
5020 static void network_changed(GSupplicantNetwork *network, const char *property)
5022 GSupplicantInterface *interface;
5023 struct wifi_data *wifi;
5024 const char *name, *identifier;
5025 struct connman_network *connman_network;
5028 #if defined TIZEN_EXT
5029 const unsigned char *bssid;
5030 unsigned int maxrate;
5033 const unsigned char *country_code;
5034 ieee80211_modes_e phy_mode;
5038 interface = g_supplicant_network_get_interface(network);
5039 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
5041 * Note: If supplicant interface's driver is wired then skip it,
5042 * because it meanti only for ethernet not Wi-Fi.
5044 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
5046 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
5048 wifi = g_supplicant_interface_get_data(interface);
5049 identifier = g_supplicant_network_get_identifier(network);
5050 name = g_supplicant_network_get_name(network);
5052 #if defined TIZEN_EXT
5053 DBG("name %s property %s", name, property);
5055 DBG("name %s", name);
5061 connman_network = connman_device_get_network(wifi->device, identifier);
5062 if (!connman_network)
5065 if (g_str_equal(property, "WPSCapabilities")) {
5069 bool wps_advertizing;
5071 wps = g_supplicant_network_get_wps(network);
5072 wps_pbc = g_supplicant_network_is_wps_pbc(network);
5073 wps_ready = g_supplicant_network_is_wps_active(network);
5075 g_supplicant_network_is_wps_advertizing(network);
5077 connman_network_set_bool(connman_network, "WiFi.WPS", wps);
5078 connman_network_set_bool(connman_network,
5079 "WiFi.WPSAdvertising", wps_advertizing);
5083 * Is AP advertizing for WPS association?
5084 * If so, we decide to use WPS by default
5086 if (wps_ready && wps_pbc && wps_advertizing)
5087 connman_network_set_bool(connman_network,
5088 "WiFi.UseWPS", true);
5091 update_needed = true;
5092 } else if (g_str_equal(property, "Signal")) {
5093 connman_network_set_strength(connman_network,
5094 calculate_strength(network));
5095 update_needed = true;
5097 #if defined TIZEN_EXT
5098 else if (g_str_equal(property, "LastConnectedBSSID")) {
5099 const char *ident, *group;
5100 char *service_ident;
5103 ident = connman_device_get_ident(wifi->device);
5104 group = connman_network_get_group(connman_network);
5105 if (ident && group) {
5106 service_ident = g_strdup_printf("%s_%s_%s",
5107 __connman_network_get_type(connman_network), ident, group);
5109 need_save = connman_device_set_last_connected_ident(wifi->device, service_ident);
5111 connman_device_save_last_connected(wifi->device);
5114 connman_network_set_last_connected_bssid(connman_network,
5115 g_supplicant_network_get_last_connected_bssid(network));
5117 update_needed = true;
5118 } else if (g_str_equal(property, "UpdateAssocReject")) {
5119 connman_network_set_assoc_reject_table(connman_network,
5120 g_supplicant_network_get_assoc_reject_table(network));
5121 update_needed = true;
5125 update_needed = false;
5128 connman_network_update(connman_network);
5130 #if defined TIZEN_EXT
5131 bssid = g_supplicant_network_get_bssid(network);
5132 maxrate = g_supplicant_network_get_maxrate(network);
5133 frequency = g_supplicant_network_get_frequency(network);
5134 wps = g_supplicant_network_get_wps(network);
5135 phy_mode = g_supplicant_network_get_phy_mode(network);
5137 connman_network_set_bssid(connman_network, bssid);
5138 connman_network_set_maxrate(connman_network, maxrate);
5139 connman_network_set_frequency(connman_network, frequency);
5140 connman_network_set_bool(connman_network, "WiFi.WPS", wps);
5141 country_code = g_supplicant_network_get_countrycode(network);
5142 connman_network_set_countrycode(connman_network, country_code);
5143 bssid_list = (GSList *)g_supplicant_network_get_bssid_list(network);
5144 connman_network_set_bssid_list(connman_network, bssid_list);
5145 connman_network_set_phy_mode(connman_network, phy_mode);
5147 if (g_str_equal(property, "CheckMultiBssidConnect") &&
5148 connman_network_get_associating(connman_network))
5149 network_connect(connman_network);
5153 static void network_associated(GSupplicantNetwork *network)
5155 GSupplicantInterface *interface;
5156 struct wifi_data *wifi;
5157 struct connman_network *connman_network;
5158 const char *identifier;
5162 interface = g_supplicant_network_get_interface(network);
5165 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
5167 * Note: If supplicant interface's driver is wired then skip it,
5168 * because it meanti only for ethernet not Wi-Fi.
5170 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
5172 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
5175 wifi = g_supplicant_interface_get_data(interface);
5179 /* P2P networks must not be treated as WiFi networks */
5180 if (wifi->p2p_connecting || wifi->p2p_device)
5183 identifier = g_supplicant_network_get_identifier(network);
5185 connman_network = connman_device_get_network(wifi->device, identifier);
5186 if (!connman_network)
5189 if (wifi->network) {
5190 if (wifi->network == connman_network)
5193 unsigned int ssid_len;
5194 DBG("network1 ssid[%s] , OWE[%d],ssid[%s]",
5195 (char *)connman_network_get_blob(wifi->network,"WiFi.SSID", &ssid_len),
5196 connman_network_get_bool(wifi->network,"WiFi.TRANSITION_MODE"),
5197 (char *)connman_network_get_blob(wifi->network,"WiFi.TRANSITION_MODE_SSID", &ssid_len));
5199 DBG("network1 ssid[%s], OWE[%d], ssid[%s]",
5200 (char *)connman_network_get_blob(connman_network,"WiFi.SSID",&ssid_len),
5201 connman_network_get_bool(connman_network,"WiFi.TRANSITION_MODE"),
5202 (char *)connman_network_get_blob(connman_network,"WiFi.TRANSITION_MODE_SSID", &ssid_len));
5203 if (connman_network_check_transition_mode(wifi->network, connman_network)) {//OWE trasition mode check
5204 DBG("OWE transition mode is TRUE");
5209 * This should never happen, we got associated with
5210 * a network different than the one we were expecting.
5212 DBG("Associated to %p while expecting %p",
5213 connman_network, wifi->network);
5215 connman_network_set_associating(wifi->network, false);
5218 DBG("Reconnecting to previous network %p from wpa_s", connman_network);
5220 wifi->network = connman_network_ref(connman_network);
5224 * Interface state changes callback (interface_state) is always
5225 * called before network_associated callback thus we need to call
5226 * interface_state again in order to process the new state now that
5227 * we have the network properly set.
5229 interface_state(interface);
5232 static void sta_authorized(GSupplicantInterface *interface,
5235 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
5237 * Note: If supplicant interface's driver is wired then skip it,
5238 * because it meanti only for ethernet not Wi-Fi.
5240 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
5242 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
5244 struct wifi_data *wifi = g_supplicant_interface_get_data(interface);
5246 DBG("wifi %p station %s authorized", wifi, addr);
5248 if (!wifi || !wifi->tethering)
5251 __connman_tethering_client_register(addr);
5254 static void sta_deauthorized(GSupplicantInterface *interface,
5257 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
5259 * Note: If supplicant interface's driver is wired then skip it,
5260 * because it meanti only for ethernet not Wi-Fi.
5262 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
5264 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
5266 struct wifi_data *wifi = g_supplicant_interface_get_data(interface);
5268 DBG("wifi %p station %s deauthorized", wifi, addr);
5270 if (!wifi || !wifi->tethering)
5273 __connman_tethering_client_unregister(addr);
5276 static void apply_peer_services(GSupplicantPeer *peer,
5277 struct connman_peer *connman_peer)
5279 const unsigned char *data;
5284 connman_peer_reset_services(connman_peer);
5286 data = g_supplicant_peer_get_widi_ies(peer, &length);
5288 connman_peer_add_service(connman_peer,
5289 CONNMAN_PEER_SERVICE_WIFI_DISPLAY, data, length);
5293 static void peer_found(GSupplicantPeer *peer)
5295 GSupplicantInterface *iface = g_supplicant_peer_get_interface(peer);
5296 struct wifi_data *wifi = g_supplicant_interface_get_data(iface);
5297 struct connman_peer *connman_peer;
5298 const char *identifier, *name;
5301 #if defined TIZEN_EXT
5305 identifier = g_supplicant_peer_get_identifier(peer);
5306 name = g_supplicant_peer_get_name(peer);
5308 DBG("ident: %s", identifier);
5310 connman_peer = connman_peer_get(wifi->device, identifier);
5314 connman_peer = connman_peer_create(identifier);
5315 connman_peer_set_name(connman_peer, name);
5316 connman_peer_set_device(connman_peer, wifi->device);
5317 apply_peer_services(peer, connman_peer);
5319 ret = connman_peer_register(connman_peer);
5320 if (ret < 0 && ret != -EALREADY)
5321 connman_peer_unref(connman_peer);
5323 wifi->peers = g_slist_prepend(wifi->peers, connman_peer);
5326 static void peer_lost(GSupplicantPeer *peer)
5328 GSupplicantInterface *iface = g_supplicant_peer_get_interface(peer);
5329 struct wifi_data *wifi = g_supplicant_interface_get_data(iface);
5330 struct connman_peer *connman_peer;
5331 const char *identifier;
5336 identifier = g_supplicant_peer_get_identifier(peer);
5338 DBG("ident: %s", identifier);
5340 connman_peer = connman_peer_get(wifi->device, identifier);
5342 if (wifi->p2p_connecting &&
5343 wifi->pending_peer == connman_peer) {
5344 peer_connect_timeout(wifi);
5346 connman_peer_unregister(connman_peer);
5347 connman_peer_unref(connman_peer);
5350 wifi->peers = g_slist_remove(wifi->peers, connman_peer);
5353 static void peer_changed(GSupplicantPeer *peer, GSupplicantPeerState state)
5355 GSupplicantInterface *iface = g_supplicant_peer_get_interface(peer);
5356 struct wifi_data *wifi = g_supplicant_interface_get_data(iface);
5357 enum connman_peer_state p_state = CONNMAN_PEER_STATE_UNKNOWN;
5358 struct connman_peer *connman_peer;
5359 const char *identifier;
5361 identifier = g_supplicant_peer_get_identifier(peer);
5363 DBG("ident: %s", identifier);
5368 connman_peer = connman_peer_get(wifi->device, identifier);
5373 case G_SUPPLICANT_PEER_SERVICES_CHANGED:
5374 apply_peer_services(peer, connman_peer);
5375 connman_peer_services_changed(connman_peer);
5377 case G_SUPPLICANT_PEER_GROUP_CHANGED:
5378 if (!g_supplicant_peer_is_in_a_group(peer))
5379 p_state = CONNMAN_PEER_STATE_IDLE;
5381 p_state = CONNMAN_PEER_STATE_CONFIGURATION;
5383 case G_SUPPLICANT_PEER_GROUP_STARTED:
5385 case G_SUPPLICANT_PEER_GROUP_FINISHED:
5386 p_state = CONNMAN_PEER_STATE_IDLE;
5388 case G_SUPPLICANT_PEER_GROUP_JOINED:
5389 connman_peer_set_iface_address(connman_peer,
5390 g_supplicant_peer_get_iface_address(peer));
5392 case G_SUPPLICANT_PEER_GROUP_DISCONNECTED:
5393 p_state = CONNMAN_PEER_STATE_IDLE;
5395 case G_SUPPLICANT_PEER_GROUP_FAILED:
5396 if (g_supplicant_peer_has_requested_connection(peer))
5397 p_state = CONNMAN_PEER_STATE_IDLE;
5399 p_state = CONNMAN_PEER_STATE_FAILURE;
5403 if (p_state == CONNMAN_PEER_STATE_CONFIGURATION ||
5404 p_state == CONNMAN_PEER_STATE_FAILURE) {
5405 if (wifi->p2p_connecting
5406 && connman_peer == wifi->pending_peer)
5407 peer_cancel_timeout(wifi);
5409 p_state = CONNMAN_PEER_STATE_UNKNOWN;
5412 if (p_state == CONNMAN_PEER_STATE_UNKNOWN)
5415 if (p_state == CONNMAN_PEER_STATE_CONFIGURATION) {
5416 GSupplicantInterface *g_iface;
5417 struct wifi_data *g_wifi;
5419 g_iface = g_supplicant_peer_get_group_interface(peer);
5423 g_wifi = g_supplicant_interface_get_data(g_iface);
5427 connman_peer_set_as_master(connman_peer,
5428 !g_supplicant_peer_is_client(peer));
5429 connman_peer_set_sub_device(connman_peer, g_wifi->device);
5432 * If wpa_supplicant didn't create a dedicated p2p-group
5433 * interface then mark this interface as p2p_device to avoid
5434 * scan and auto-scan are launched on it while P2P is connected.
5436 if (!g_list_find(p2p_iface_list, g_wifi))
5437 wifi->p2p_device = true;
5440 connman_peer_set_state(connman_peer, p_state);
5443 static void peer_request(GSupplicantPeer *peer)
5445 GSupplicantInterface *iface = g_supplicant_peer_get_interface(peer);
5446 struct wifi_data *wifi = g_supplicant_interface_get_data(iface);
5447 struct connman_peer *connman_peer;
5448 const char *identifier;
5450 #if defined TIZEN_EXT
5455 identifier = g_supplicant_peer_get_identifier(peer);
5457 DBG("ident: %s", identifier);
5459 connman_peer = connman_peer_get(wifi->device, identifier);
5463 connman_peer_request_connection(connman_peer);
5466 #if defined TIZEN_EXT
5467 static void system_power_off(void)
5470 struct wifi_data *wifi;
5471 struct connman_service *service;
5472 struct connman_ipconfig *ipconfig_ipv4;
5474 if (connman_setting_get_bool("WiFiDHCPRelease") == true) {
5475 for (list = iface_list; list; list = list->next) {
5478 if (wifi->network != NULL) {
5479 service = connman_service_lookup_from_network(wifi->network);
5480 ipconfig_ipv4 = __connman_service_get_ip4config(service);
5481 __connman_dhcp_stop(ipconfig_ipv4);
5487 static void network_merged(GSupplicantNetwork *network)
5489 GSupplicantInterface *interface;
5490 GSupplicantState state;
5491 struct wifi_data *wifi;
5492 const char *identifier;
5493 struct connman_network *connman_network;
5497 interface = g_supplicant_network_get_interface(network);
5501 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
5503 * Note: If supplicant interface's driver is wired then skip it,
5504 * because it meanti only for ethernet not Wi-Fi.
5506 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
5508 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
5510 state = g_supplicant_interface_get_state(interface);
5511 if (state < G_SUPPLICANT_STATE_AUTHENTICATING)
5514 wifi = g_supplicant_interface_get_data(interface);
5518 identifier = g_supplicant_network_get_identifier(network);
5520 connman_network = connman_device_get_network(wifi->device, identifier);
5521 if (!connman_network)
5524 DBG("merged identifier %s", identifier);
5526 if (wifi->connected == FALSE) {
5528 case G_SUPPLICANT_STATE_AUTHENTICATING:
5529 case G_SUPPLICANT_STATE_ASSOCIATING:
5530 case G_SUPPLICANT_STATE_ASSOCIATED:
5531 case G_SUPPLICANT_STATE_4WAY_HANDSHAKE:
5532 case G_SUPPLICANT_STATE_GROUP_HANDSHAKE:
5533 connman_network_set_associating(connman_network, TRUE);
5535 case G_SUPPLICANT_STATE_COMPLETED:
5536 connman_network_set_connected(connman_network, TRUE);
5539 DBG("Not handled the state : %d", state);
5544 ishs20AP = g_supplicant_network_is_hs20AP(network);
5547 g_strcmp0(g_supplicant_network_get_security(network), "ieee8021x") == 0) {
5548 temp = g_ascii_strdown(g_supplicant_network_get_eap(network), -1);
5549 connman_network_set_string(connman_network, "WiFi.EAP",
5551 connman_network_set_string(connman_network, "WiFi.Identity",
5552 g_supplicant_network_get_identity(network));
5553 connman_network_set_string(connman_network, "WiFi.Phase2",
5554 g_supplicant_network_get_phase2(network));
5559 wifi->network = connman_network;
5562 static void assoc_failed(void *user_data)
5564 struct connman_network *network = user_data;
5565 connman_network_set_associating(network, false);
5568 static void scan_done(GSupplicantInterface *interface)
5570 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
5572 * Note: If supplicant interface's driver is wired then skip it,
5573 * because it meanti only for ethernet not Wi-Fi.
5575 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
5577 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
5580 int scan_type = CONNMAN_SCAN_TYPE_WPA_SUPPLICANT;
5581 struct wifi_data *wifi;
5584 for (list = iface_list; list; list = list->next) {
5587 if (interface == wifi->interface) {
5588 scanning = connman_device_get_scanning(wifi->device,
5589 CONNMAN_SERVICE_TYPE_WIFI);
5591 __connman_technology_notify_scan_done(scan_type);
5598 static void debug(const char *str)
5600 #if defined TIZEN_EXT
5601 if (connman_setting_get_bool("ConnmanSupplicantDebug"))
5603 if (getenv("CONNMAN_SUPPLICANT_DEBUG"))
5605 connman_debug("%s", str);
5608 static void disconnect_reasoncode(GSupplicantInterface *interface,
5611 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
5613 * Note: If supplicant interface's driver is wired then skip it,
5614 * because it meanti only for ethernet not Wi-Fi.
5616 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
5618 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
5620 struct wifi_data *wifi = g_supplicant_interface_get_data(interface);
5623 wifi->disconnect_code = reasoncode;
5627 static void assoc_status_code(GSupplicantInterface *interface, int status_code)
5629 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
5631 * Note: If supplicant interface's driver is wired then skip it,
5632 * because it meanti only for ethernet not Wi-Fi.
5634 if (!g_strcmp0("wired", g_supplicant_interface_get_driver(interface)))
5636 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
5638 struct wifi_data *wifi = g_supplicant_interface_get_data(interface);
5641 wifi->assoc_code = status_code;
5645 #if defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET
5646 static GSupplicantCallbacks callbacks = {
5647 #else /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
5648 static const GSupplicantCallbacks callbacks = {
5649 #endif /* defined TIZEN_EXT && defined TIZEN_EXT_EAP_ON_ETHERNET */
5650 .system_ready = system_ready,
5651 .system_killed = system_killed,
5652 .interface_added = interface_added,
5653 .interface_state = interface_state,
5654 .interface_removed = interface_removed,
5655 .p2p_support = p2p_support,
5656 .scan_started = scan_started,
5657 .scan_finished = scan_finished,
5658 .ap_create_fail = ap_create_fail,
5659 .network_added = network_added,
5660 .network_removed = network_removed,
5661 .network_changed = network_changed,
5662 .network_associated = network_associated,
5663 .sta_authorized = sta_authorized,
5664 .sta_deauthorized = sta_deauthorized,
5665 .peer_found = peer_found,
5666 .peer_lost = peer_lost,
5667 .peer_changed = peer_changed,
5668 .peer_request = peer_request,
5669 #if defined TIZEN_EXT
5670 .system_power_off = system_power_off,
5671 .network_merged = network_merged,
5672 .assoc_failed = assoc_failed,
5673 .scan_done = scan_done,
5676 .disconnect_reasoncode = disconnect_reasoncode,
5677 .assoc_status_code = assoc_status_code,
5678 #if defined TIZEN_EXT_WIFI_MESH
5679 .mesh_support = mesh_support,
5680 .mesh_group_started = mesh_group_started,
5681 .mesh_group_removed = mesh_group_removed,
5682 .mesh_peer_connected = mesh_peer_connected,
5683 .mesh_peer_disconnected = mesh_peer_disconnected,
5688 static int tech_probe(struct connman_technology *technology)
5690 wifi_technology = technology;
5695 static void tech_remove(struct connman_technology *technology)
5697 wifi_technology = NULL;
5700 static GSupplicantSSID *ssid_ap_init(const char *ssid, const char *passphrase)
5702 GSupplicantSSID *ap;
5704 ap = g_try_malloc0(sizeof(GSupplicantSSID));
5708 ap->mode = G_SUPPLICANT_MODE_MASTER;
5709 #if defined TIZEN_EXT
5710 ap->ssid = (void *) ssid;
5714 ap->ssid_len = strlen(ssid);
5718 if (!passphrase || strlen(passphrase) == 0) {
5719 ap->security = G_SUPPLICANT_SECURITY_NONE;
5720 ap->passphrase = NULL;
5722 ap->security = G_SUPPLICANT_SECURITY_PSK;
5723 ap->protocol = G_SUPPLICANT_PROTO_RSN;
5724 ap->pairwise_cipher = G_SUPPLICANT_PAIRWISE_CCMP;
5725 ap->group_cipher = G_SUPPLICANT_GROUP_CCMP;
5726 ap->passphrase = passphrase;
5732 static void ap_start_callback(int result, GSupplicantInterface *interface,
5735 struct wifi_tethering_info *info = user_data;
5737 DBG("result %d index %d bridge %s",
5738 result, info->wifi->index, info->wifi->bridge);
5740 if ((result < 0) || (info->wifi->ap_supported != WIFI_AP_SUPPORTED)) {
5741 connman_inet_remove_from_bridge(info->wifi->index,
5742 info->wifi->bridge);
5744 if (info->wifi->ap_supported == WIFI_AP_SUPPORTED) {
5745 connman_technology_tethering_notify(info->technology, false);
5746 g_free(info->wifi->tethering_param->ssid);
5747 g_free(info->wifi->tethering_param);
5748 info->wifi->tethering_param = NULL;
5752 g_free(info->ifname);
5756 static void ap_create_callback(int result,
5757 GSupplicantInterface *interface,
5760 struct wifi_tethering_info *info = user_data;
5762 DBG("result %d ifname %s", result,
5763 g_supplicant_interface_get_ifname(interface));
5765 if ((result < 0) || (info->wifi->ap_supported != WIFI_AP_SUPPORTED)) {
5766 connman_inet_remove_from_bridge(info->wifi->index,
5767 info->wifi->bridge);
5769 if (info->wifi->ap_supported == WIFI_AP_SUPPORTED) {
5770 connman_technology_tethering_notify(info->technology, false);
5771 g_free(info->wifi->tethering_param->ssid);
5772 g_free(info->wifi->tethering_param);
5773 info->wifi->tethering_param = NULL;
5777 g_free(info->ifname);
5783 info->wifi->interface = interface;
5784 g_supplicant_interface_set_data(interface, info->wifi);
5786 if (g_supplicant_interface_set_apscan(interface, 2) < 0)
5787 connman_error("Failed to set interface ap_scan property");
5789 g_supplicant_interface_connect(interface, info->ssid,
5790 ap_start_callback, info);
5793 static void sta_remove_callback(int result,
5794 GSupplicantInterface *interface,
5797 struct wifi_tethering_info *info = user_data;
5798 const char *driver = connman_option_get_string("wifi");
5800 DBG("ifname %s result %d ", info->ifname, result);
5802 if ((result < 0) || (info->wifi->ap_supported != WIFI_AP_SUPPORTED)) {
5803 info->wifi->tethering = false;
5804 connman_technology_tethering_notify(info->technology, false);
5806 if (info->wifi->ap_supported == WIFI_AP_SUPPORTED) {
5807 g_free(info->wifi->tethering_param->ssid);
5808 g_free(info->wifi->tethering_param);
5809 info->wifi->tethering_param = NULL;
5812 g_free(info->ifname);
5818 info->wifi->interface = NULL;
5820 g_supplicant_interface_create(info->ifname, driver, info->wifi->bridge,
5825 static int enable_wifi_tethering(struct connman_technology *technology,
5826 const char *bridge, const char *identifier,
5827 const char *passphrase, bool available)
5830 GSupplicantInterface *interface;
5831 struct wifi_data *wifi;
5832 struct wifi_tethering_info *info;
5837 for (list = iface_list; list; list = list->next) {
5840 DBG("wifi %p network %p pending_network %p", wifi,
5841 wifi->network, wifi->pending_network);
5843 interface = wifi->interface;
5848 ifname = g_supplicant_interface_get_ifname(wifi->interface);
5852 if (wifi->ap_supported == WIFI_AP_NOT_SUPPORTED) {
5853 DBG("%s does not support AP mode (detected)", ifname);
5857 mode = g_supplicant_interface_get_mode(interface);
5858 if ((mode & G_SUPPLICANT_CAPABILITY_MODE_AP) == 0) {
5859 wifi->ap_supported = WIFI_AP_NOT_SUPPORTED;
5860 DBG("%s does not support AP mode (capability)", ifname);
5864 if (wifi->network && available)
5867 info = g_try_malloc0(sizeof(struct wifi_tethering_info));
5871 wifi->tethering_param = g_try_malloc0(sizeof(struct wifi_tethering_info));
5872 if (!wifi->tethering_param) {
5878 info->technology = technology;
5879 info->wifi->bridge = bridge;
5880 info->ssid = ssid_ap_init(identifier, passphrase);
5884 info->ifname = g_strdup(ifname);
5886 wifi->tethering_param->technology = technology;
5887 wifi->tethering_param->ssid = ssid_ap_init(identifier, passphrase);
5888 if (!wifi->tethering_param->ssid)
5891 info->wifi->tethering = true;
5892 info->wifi->ap_supported = WIFI_AP_SUPPORTED;
5894 berr = connman_technology_tethering_notify(technology, true);
5898 err = g_supplicant_interface_remove(interface,
5899 sta_remove_callback,
5902 DBG("tethering wifi %p ifname %s", wifi, ifname);
5907 g_free(info->ifname);
5910 g_free(wifi->tethering_param);
5911 wifi->tethering_param = NULL;
5914 * Remove bridge if it was correctly created but remove
5915 * operation failed. Instead, if bridge creation failed then
5916 * break out and do not try again on another interface,
5917 * bridge set-up does not depend on it.
5920 connman_technology_tethering_notify(technology, false);
5928 static int tech_set_tethering(struct connman_technology *technology,
5929 const char *identifier, const char *passphrase,
5930 const char *bridge, bool enabled)
5933 struct wifi_data *wifi;
5939 for (list = iface_list; list; list = list->next) {
5942 if (wifi->tethering) {
5943 wifi->tethering = false;
5945 connman_inet_remove_from_bridge(wifi->index,
5947 wifi->bridged = false;
5951 connman_technology_tethering_notify(technology, false);
5956 DBG("trying tethering for available devices");
5957 err = enable_wifi_tethering(technology, bridge, identifier, passphrase,
5961 DBG("trying tethering for any device");
5962 err = enable_wifi_tethering(technology, bridge, identifier,
5969 static void regdom_callback(int result, const char *alpha2, void *user_data)
5973 if (!wifi_technology)
5979 connman_technology_regdom_notify(wifi_technology, alpha2);
5982 static int tech_set_regdom(struct connman_technology *technology, const char *alpha2)
5984 return g_supplicant_set_country(alpha2, regdom_callback, NULL);
5987 #if defined TIZEN_EXT
5988 static void supp_ins_init(void)
5991 GSupplicantINSPreferredFreq preferred_freq;
5993 string = connman_option_get_string("INSPreferredFreqBSSID");
5994 if (g_strcmp0(string, "5GHz") == 0)
5995 preferred_freq = G_SUPPLICANT_INS_PREFERRED_FREQ_5GHZ;
5996 else if (g_strcmp0(string, "2.4GHz") == 0)
5997 preferred_freq = G_SUPPLICANT_INS_PREFERRED_FREQ_24GHZ;
5999 preferred_freq = G_SUPPLICANT_INS_PREFERRED_FREQ_UNKNOWN;
6001 g_supplicant_set_ins_settings(preferred_freq,
6002 connman_setting_get_bool("INSLastConnectedBSSID"),
6003 connman_setting_get_bool("INSAssocReject"),
6004 connman_setting_get_bool("INSSignalBSSID"),
6005 connman_setting_get_uint("INSPreferredFreqBSSIDScore"),
6006 connman_setting_get_uint("INSLastConnectedBSSIDScore"),
6007 connman_setting_get_uint("INSAssocRejectScore"),
6008 connman_setting_get_int("INSSignalLevel3_5GHz"),
6009 connman_setting_get_int("INSSignalLevel3_24GHz")
6014 static struct connman_technology_driver tech_driver = {
6016 .type = CONNMAN_SERVICE_TYPE_WIFI,
6017 .probe = tech_probe,
6018 .remove = tech_remove,
6019 .set_tethering = tech_set_tethering,
6020 .set_regdom = tech_set_regdom,
6023 static int wifi_init(void)
6027 err = connman_network_driver_register(&network_driver);
6031 err = g_supplicant_register(&callbacks);
6033 connman_network_driver_unregister(&network_driver);
6037 err = connman_technology_driver_register(&tech_driver);
6039 g_supplicant_unregister(&callbacks);
6040 connman_network_driver_unregister(&network_driver);
6044 #if defined TIZEN_EXT
6045 failed_bssids = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
6048 #if defined TIZEN_EXT
6054 static void wifi_exit(void)
6058 connman_technology_driver_unregister(&tech_driver);
6060 g_supplicant_unregister(&callbacks);
6062 connman_network_driver_unregister(&network_driver);
6064 #if defined TIZEN_EXT
6065 g_hash_table_unref(failed_bssids);
6069 CONNMAN_PLUGIN_DEFINE(wifi, "WiFi interface plugin", VERSION,
6070 CONNMAN_PLUGIN_PRIORITY_DEFAULT, wifi_init, wifi_exit)