plugins/wifi.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   5  *  Copyright (C) 2007-2014  Intel Corporation. All rights reserved.
   6  *
   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.
  10  *
  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.
  15  *
  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
  19  *
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <unistd.h>
  27 #include <stdlib.h>
  28 #include <errno.h>
  29 #include <stdio.h>
  30 #include <string.h>
  31 #include <sys/ioctl.h>
  32 #include <sys/socket.h>
  33 #include <linux/if_arp.h>
  34 #include <linux/wireless.h>
  35 #include <net/ethernet.h>
  36
  37 #ifndef IFF_LOWER_UP
  38 #define IFF_LOWER_UP    0x10000
  39 #endif
  40
  41 #include <dbus/dbus.h>
  42 #include <glib.h>
  43
  44 #define CONNMAN_API_SUBJECT_TO_CHANGE
  45 #include <connman/plugin.h>
  46 #include <connman/inet.h>
  47 #include <connman/device.h>
  48 #include <connman/rtnl.h>
  49 #include <connman/technology.h>
  50 #include <connman/service.h>
  51 #include <connman/peer.h>
  52 #include <connman/log.h>
  53 #include <connman/option.h>
  54 #include <connman/storage.h>
  55 #include <include/setting.h>
  56 #include <connman/provision.h>
  57 #include <connman/utsname.h>
  58 #include <connman/machine.h>
  59
  60 #include <gsupplicant/gsupplicant.h>
  61
  62 #define CLEANUP_TIMEOUT   8     /* in seconds */
  63 #define INACTIVE_TIMEOUT  12    /* in seconds */
  64 #define FAVORITE_MAXIMUM_RETRIES 2
  65
  66 #define BGSCAN_DEFAULT "simple:30:-45:300"
  67 #define AUTOSCAN_DEFAULT "exponential:3:300"
  68
  69 #define P2P_FIND_TIMEOUT 30
  70 #define P2P_CONNECTION_TIMEOUT 100
  71 #define P2P_LISTEN_PERIOD 500
  72 #define P2P_LISTEN_INTERVAL 2000
  73
  74 static struct connman_technology *wifi_technology = NULL;
  75 static struct connman_technology *p2p_technology = NULL;
  76
  77 struct hidden_params {
  78         char ssid[32];
  79         unsigned int ssid_len;
  80         char *identity;
  81         char *passphrase;
  82         char *security;
  83         GSupplicantScanParams *scan_params;
  84         gpointer user_data;
  85 };
  86
  87 /**
  88  * Used for autoscan "emulation".
  89  * Should be removed when wpa_s autoscan support will be by default.
  90  */
  91 struct autoscan_params {
  92         int base;
  93         int limit;
  94         int interval;
  95         unsigned int timeout;
  96 };
  97
  98 struct wifi_data {
  99         char *identifier;
 100         struct connman_device *device;
 101         struct connman_network *network;
 102         struct connman_network *pending_network;
 103         GSList *networks;
 104         GSupplicantInterface *interface;
 105         GSupplicantState state;
 106         bool connected;
 107         bool disconnecting;
 108         bool tethering;
 109         bool bridged;
 110         bool interface_ready;
 111         const char *bridge;
 112         int index;
 113         unsigned flags;
 114         unsigned int watch;
 115         int retries;
 116         struct hidden_params *hidden;
 117         bool postpone_hidden;
 118         /**
 119          * autoscan "emulation".
 120          */
 121         struct autoscan_params *autoscan;
 122
 123         GSupplicantScanParams *scan_params;
 124         unsigned int p2p_find_timeout;
 125         unsigned int p2p_connection_timeout;
 126         struct connman_peer *pending_peer;
 127         GSupplicantPeer *peer;
 128         bool p2p_connecting;
 129         bool p2p_device;
 130         int servicing;
 131 #if defined TIZEN_EXT
 132         int assoc_retry_count;
 133         struct connman_network *interface_disconnected_network;
 134         struct connman_network *scan_pending_network;
 135 #endif
 136 };
 137
 138 #if defined TIZEN_EXT
 139 #include "connman.h"
 140
 141 #define TIZEN_ASSOC_RETRY_COUNT         3
 142
 143 static gboolean wifi_first_scan = false;
 144 static gboolean found_with_first_scan = false;
 145 static gboolean is_wifi_notifier_registered = false;
 146 #endif
 147
 148 static GList *iface_list = NULL;
 149
 150 static GList *pending_wifi_device = NULL;
 151 static GList *p2p_iface_list = NULL;
 152 bool wfd_service_registered = false;
 153
 154 static void start_autoscan(struct connman_device *device);
 155
 156 static int p2p_tech_probe(struct connman_technology *technology)
 157 {
 158         p2p_technology = technology;
 159
 160         return 0;
 161 }
 162
 163 static void p2p_tech_remove(struct connman_technology *technology)
 164 {
 165         p2p_technology = NULL;
 166 }
 167
 168 static struct connman_technology_driver p2p_tech_driver = {
 169         .name           = "p2p",
 170         .type           = CONNMAN_SERVICE_TYPE_P2P,
 171         .probe          = p2p_tech_probe,
 172         .remove         = p2p_tech_remove,
 173 };
 174
 175 static bool is_p2p_connecting(void)
 176 {
 177         GList *list;
 178
 179         for (list = iface_list; list; list = list->next) {
 180                 struct wifi_data *wifi = list->data;
 181
 182                 if (wifi->p2p_connecting)
 183                         return true;
 184         }
 185
 186         return false;
 187 }
 188
 189 static void add_pending_wifi_device(struct wifi_data *wifi)
 190 {
 191         if (g_list_find(pending_wifi_device, wifi))
 192                 return;
 193
 194         pending_wifi_device = g_list_append(pending_wifi_device, wifi);
 195 }
 196
 197 static struct wifi_data *get_pending_wifi_data(const char *ifname)
 198 {
 199         GList *list;
 200
 201         for (list = pending_wifi_device; list; list = list->next) {
 202                 struct wifi_data *wifi;
 203                 const char *dev_name;
 204
 205                 wifi = list->data;
 206                 if (!wifi || !wifi->device)
 207                         continue;
 208
 209                 dev_name = connman_device_get_string(wifi->device, "Interface");
 210                 if (!g_strcmp0(ifname, dev_name)) {
 211                         pending_wifi_device = g_list_delete_link(
 212                                                 pending_wifi_device, list);
 213                         return wifi;
 214                 }
 215         }
 216
 217         return NULL;
 218 }
 219
 220 static void remove_pending_wifi_device(struct wifi_data *wifi)
 221 {
 222         GList *link;
 223
 224         link = g_list_find(pending_wifi_device, wifi);
 225
 226         if (!link)
 227                 return;
 228
 229         pending_wifi_device = g_list_delete_link(pending_wifi_device, link);
 230 }
 231
 232 static void peer_cancel_timeout(struct wifi_data *wifi)
 233 {
 234         if (wifi->p2p_connection_timeout > 0)
 235                 g_source_remove(wifi->p2p_connection_timeout);
 236
 237         wifi->p2p_connection_timeout = 0;
 238         wifi->p2p_connecting = false;
 239
 240         if (wifi->pending_peer) {
 241                 connman_peer_unref(wifi->pending_peer);
 242                 wifi->pending_peer = NULL;
 243         }
 244
 245         wifi->peer = NULL;
 246 }
 247
 248 static gboolean peer_connect_timeout(gpointer data)
 249 {
 250         struct wifi_data *wifi = data;
 251
 252         DBG("");
 253
 254         if (wifi->p2p_connecting) {
 255                 enum connman_peer_state state = CONNMAN_PEER_STATE_FAILURE;
 256
 257                 if (g_supplicant_peer_has_requested_connection(wifi->peer))
 258                         state = CONNMAN_PEER_STATE_IDLE;
 259
 260                 connman_peer_set_state(wifi->pending_peer, state);
 261         }
 262
 263         peer_cancel_timeout(wifi);
 264
 265         return FALSE;
 266 }
 267
 268 static void peer_connect_callback(int result, GSupplicantInterface *interface,
 269                                                         void *user_data)
 270 {
 271         struct wifi_data *wifi = user_data;
 272         struct connman_peer *peer = wifi->pending_peer;
 273
 274         DBG("peer %p - %d", peer, result);
 275
 276         if (!peer)
 277                 return;
 278
 279         if (result < 0) {
 280                 peer_connect_timeout(wifi);
 281                 return;
 282         }
 283
 284         connman_peer_set_state(peer, CONNMAN_PEER_STATE_ASSOCIATION);
 285
 286         wifi->p2p_connection_timeout = g_timeout_add_seconds(
 287                                                 P2P_CONNECTION_TIMEOUT,
 288                                                 peer_connect_timeout, wifi);
 289 }
 290
 291 static int peer_connect(struct connman_peer *peer,
 292                         enum connman_peer_wps_method wps_method,
 293                         const char *wps_pin)
 294 {
 295         struct connman_device *device = connman_peer_get_device(peer);
 296         GSupplicantPeerParams *peer_params;
 297         GSupplicantPeer *gs_peer;
 298         struct wifi_data *wifi;
 299         bool pbc, pin;
 300         int ret;
 301
 302         DBG("peer %p", peer);
 303
 304         if (!device)
 305                 return -ENODEV;
 306
 307         wifi = connman_device_get_data(device);
 308         if (!wifi)
 309                 return -ENODEV;
 310
 311         if (wifi->p2p_connecting)
 312                 return -EBUSY;
 313
 314         wifi->peer = NULL;
 315
 316         gs_peer = g_supplicant_interface_peer_lookup(wifi->interface,
 317                                         connman_peer_get_identifier(peer));
 318         if (!gs_peer)
 319                 return -EINVAL;
 320
 321         pbc = g_supplicant_peer_is_wps_pbc(gs_peer);
 322         pin = g_supplicant_peer_is_wps_pin(gs_peer);
 323
 324         switch (wps_method) {
 325         case CONNMAN_PEER_WPS_UNKNOWN:
 326                 if ((pbc && pin) || pin)
 327                         return -ENOKEY;
 328                 break;
 329         case CONNMAN_PEER_WPS_PBC:
 330                 if (!pbc)
 331                         return -EINVAL;
 332                 wps_pin = NULL;
 333                 break;
 334         case CONNMAN_PEER_WPS_PIN:
 335                 if (!pin || !wps_pin)
 336                         return -EINVAL;
 337                 break;
 338         }
 339
 340         peer_params = g_try_malloc0(sizeof(GSupplicantPeerParams));
 341         if (!peer_params)
 342                 return -ENOMEM;
 343
 344         peer_params->path = g_strdup(g_supplicant_peer_get_path(gs_peer));
 345         if (wps_pin)
 346                 peer_params->wps_pin = g_strdup(wps_pin);
 347
 348         peer_params->master = connman_peer_service_is_master();
 349
 350         ret = g_supplicant_interface_p2p_connect(wifi->interface, peer_params,
 351                                                 peer_connect_callback, wifi);
 352         if (ret == -EINPROGRESS) {
 353                 wifi->pending_peer = connman_peer_ref(peer);
 354                 wifi->peer = gs_peer;
 355                 wifi->p2p_connecting = true;
 356         } else if (ret < 0)
 357                 g_free(peer_params);
 358
 359         return ret;
 360 }
 361
 362 static int peer_disconnect(struct connman_peer *peer)
 363 {
 364         struct connman_device *device = connman_peer_get_device(peer);
 365         GSupplicantPeerParams peer_params = {};
 366         GSupplicantPeer *gs_peer;
 367         struct wifi_data *wifi;
 368         int ret;
 369
 370         DBG("peer %p", peer);
 371
 372         if (!device)
 373                 return -ENODEV;
 374
 375         wifi = connman_device_get_data(device);
 376         if (!wifi)
 377                 return -ENODEV;
 378
 379         gs_peer = g_supplicant_interface_peer_lookup(wifi->interface,
 380                                         connman_peer_get_identifier(peer));
 381         if (!gs_peer)
 382                 return -EINVAL;
 383
 384         peer_params.path = g_strdup(g_supplicant_peer_get_path(gs_peer));
 385
 386         ret = g_supplicant_interface_p2p_disconnect(wifi->interface,
 387                                                         &peer_params);
 388         g_free(peer_params.path);
 389
 390         if (ret == -EINPROGRESS)
 391                 peer_cancel_timeout(wifi);
 392
 393         return ret;
 394 }
 395
 396 struct peer_service_registration {
 397         peer_service_registration_cb_t callback;
 398         void *user_data;
 399 };
 400
 401 static bool is_service_wfd(const unsigned char *specs, int length)
 402 {
 403         if (length < 9 || specs[0] != 0 || specs[1] != 0 || specs[2] != 6)
 404                 return false;
 405
 406         return true;
 407 }
 408
 409 static void apply_p2p_listen_on_iface(gpointer data, gpointer user_data)
 410 {
 411         struct wifi_data *wifi = data;
 412
 413         if (!wifi->interface ||
 414                         !g_supplicant_interface_has_p2p(wifi->interface))
 415                 return;
 416
 417         if (!wifi->servicing) {
 418                 g_supplicant_interface_p2p_listen(wifi->interface,
 419                                 P2P_LISTEN_PERIOD, P2P_LISTEN_INTERVAL);
 420         }
 421
 422         wifi->servicing++;
 423 }
 424
 425 static void register_wfd_service_cb(int result,
 426                                 GSupplicantInterface *iface, void *user_data)
 427 {
 428         struct peer_service_registration *reg_data = user_data;
 429
 430         DBG("");
 431
 432         if (result == 0)
 433                 g_list_foreach(iface_list, apply_p2p_listen_on_iface, NULL);
 434
 435         if (reg_data && reg_data->callback) {
 436                 reg_data->callback(result, reg_data->user_data);
 437                 g_free(reg_data);
 438         }
 439 }
 440
 441 static GSupplicantP2PServiceParams *fill_in_peer_service_params(
 442                                 const unsigned char *spec,
 443                                 int spec_length, const unsigned char *query,
 444                                 int query_length, int version)
 445 {
 446         GSupplicantP2PServiceParams *params;
 447
 448         params = g_try_malloc0(sizeof(GSupplicantP2PServiceParams));
 449         if (!params)
 450                 return NULL;
 451
 452         if (version > 0) {
 453                 params->version = version;
 454                 params->service = g_memdup(spec, spec_length);
 455         } else if (query_length > 0 && spec_length > 0) {
 456                 params->query = g_memdup(query, query_length);
 457                 params->query_length = query_length;
 458
 459                 params->response = g_memdup(spec, spec_length);
 460                 params->response_length = spec_length;
 461         } else {
 462                 params->wfd_ies = g_memdup(spec, spec_length);
 463                 params->wfd_ies_length = spec_length;
 464         }
 465
 466         return params;
 467 }
 468
 469 static void free_peer_service_params(GSupplicantP2PServiceParams *params)
 470 {
 471         if (!params)
 472                 return;
 473
 474         g_free(params->service);
 475         g_free(params->query);
 476         g_free(params->response);
 477         g_free(params->wfd_ies);
 478
 479         g_free(params);
 480 }
 481
 482 static int peer_register_wfd_service(const unsigned char *specification,
 483                                 int specification_length,
 484                                 peer_service_registration_cb_t callback,
 485                                 void *user_data)
 486 {
 487         struct peer_service_registration *reg_data = NULL;
 488         static GSupplicantP2PServiceParams *params;
 489         int ret;
 490
 491         DBG("");
 492
 493         if (wfd_service_registered)
 494                 return -EBUSY;
 495
 496         params = fill_in_peer_service_params(specification,
 497                                         specification_length, NULL, 0, 0);
 498         if (!params)
 499                 return -ENOMEM;
 500
 501         reg_data = g_try_malloc0(sizeof(*reg_data));
 502         if (!reg_data) {
 503                 ret = -ENOMEM;
 504                 goto error;
 505         }
 506
 507         reg_data->callback = callback;
 508         reg_data->user_data = user_data;
 509
 510         ret = g_supplicant_set_widi_ies(params,
 511                                         register_wfd_service_cb, reg_data);
 512         if (ret < 0 && ret != -EINPROGRESS)
 513                 goto error;
 514
 515         wfd_service_registered = true;
 516
 517         return ret;
 518 error:
 519         free_peer_service_params(params);
 520         g_free(reg_data);
 521
 522         return ret;
 523 }
 524
 525 static void register_peer_service_cb(int result,
 526                                 GSupplicantInterface *iface, void *user_data)
 527 {
 528         struct wifi_data *wifi = g_supplicant_interface_get_data(iface);
 529         struct peer_service_registration *reg_data = user_data;
 530
 531         DBG("");
 532
 533         if (result == 0)
 534                 apply_p2p_listen_on_iface(wifi, NULL);
 535
 536         if (reg_data->callback)
 537                 reg_data->callback(result, reg_data->user_data);
 538
 539         g_free(reg_data);
 540 }
 541
 542 static int peer_register_service(const unsigned char *specification,
 543                                 int specification_length,
 544                                 const unsigned char *query,
 545                                 int query_length, int version,
 546                                 peer_service_registration_cb_t callback,
 547                                 void *user_data)
 548 {
 549         struct peer_service_registration *reg_data;
 550         GSupplicantP2PServiceParams *params;
 551         bool found = false;
 552         int ret, ret_f;
 553         GList *list;
 554
 555         DBG("");
 556
 557         if (specification && !version && !query &&
 558                         is_service_wfd(specification, specification_length)) {
 559                 return peer_register_wfd_service(specification,
 560                                 specification_length, callback, user_data);
 561         }
 562
 563         reg_data = g_try_malloc0(sizeof(*reg_data));
 564         if (!reg_data)
 565                 return -ENOMEM;
 566
 567         reg_data->callback = callback;
 568         reg_data->user_data = user_data;
 569
 570         ret_f = -EOPNOTSUPP;
 571
 572         for (list = iface_list; list; list = list->next) {
 573                 struct wifi_data *wifi = list->data;
 574                 GSupplicantInterface *iface = wifi->interface;
 575
 576                 if (!g_supplicant_interface_has_p2p(iface))
 577                         continue;
 578
 579                 params = fill_in_peer_service_params(specification,
 580                                                 specification_length, query,
 581                                                 query_length, version);
 582                 if (!params) {
 583                         ret = -ENOMEM;
 584                         continue;
 585                 }
 586
 587                 if (!found) {
 588                         ret_f = g_supplicant_interface_p2p_add_service(iface,
 589                                 register_peer_service_cb, params, reg_data);
 590                         if (ret_f == 0 || ret_f == -EINPROGRESS)
 591                                 found = true;
 592                         ret = ret_f;
 593                 } else
 594                         ret = g_supplicant_interface_p2p_add_service(iface,
 595                                 register_peer_service_cb, params, NULL);
 596                 if (ret != 0 && ret != -EINPROGRESS)
 597                         free_peer_service_params(params);
 598         }
 599
 600         if (ret_f != 0 && ret_f != -EINPROGRESS)
 601                 g_free(reg_data);
 602
 603         return ret_f;
 604 }
 605
 606 static int peer_unregister_wfd_service(void)
 607 {
 608         GSupplicantP2PServiceParams *params;
 609         GList *list;
 610
 611         if (!wfd_service_registered)
 612                 return -EALREADY;
 613
 614         params = fill_in_peer_service_params(NULL, 0, NULL, 0, 0);
 615         if (!params)
 616                 return -ENOMEM;
 617
 618         wfd_service_registered = false;
 619
 620         g_supplicant_set_widi_ies(params, NULL, NULL);
 621
 622         for (list = iface_list; list; list = list->next) {
 623                 struct wifi_data *wifi = list->data;
 624
 625                 if (!g_supplicant_interface_has_p2p(wifi->interface))
 626                         continue;
 627
 628                 wifi->servicing--;
 629                 if (!wifi->servicing || wifi->servicing < 0) {
 630                         g_supplicant_interface_p2p_listen(wifi->interface,
 631                                                                         0, 0);
 632                         wifi->servicing = 0;
 633                 }
 634         }
 635
 636         return 0;
 637 }
 638
 639 static int peer_unregister_service(const unsigned char *specification,
 640                                                 int specification_length,
 641                                                 const unsigned char *query,
 642                                                 int query_length, int version)
 643 {
 644         GSupplicantP2PServiceParams *params;
 645         bool wfd = false;
 646         GList *list;
 647         int ret;
 648
 649         if (specification && !version && !query &&
 650                         is_service_wfd(specification, specification_length)) {
 651                 ret = peer_unregister_wfd_service();
 652                 if (ret != 0 && ret != -EINPROGRESS)
 653                         return ret;
 654                 wfd = true;
 655         }
 656
 657         for (list = iface_list; list; list = list->next) {
 658                 struct wifi_data *wifi = list->data;
 659                 GSupplicantInterface *iface = wifi->interface;
 660
 661                 if (wfd)
 662                         goto stop_listening;
 663
 664                 if (!g_supplicant_interface_has_p2p(iface))
 665                         continue;
 666
 667                 params = fill_in_peer_service_params(specification,
 668                                                 specification_length, query,
 669                                                 query_length, version);
 670                 if (!params) {
 671                         ret = -ENOMEM;
 672                         continue;
 673                 }
 674
 675                 ret = g_supplicant_interface_p2p_del_service(iface, params);
 676                 if (ret != 0 && ret != -EINPROGRESS)
 677                         free_peer_service_params(params);
 678 stop_listening:
 679                 wifi->servicing--;
 680                 if (!wifi->servicing || wifi->servicing < 0) {
 681                         g_supplicant_interface_p2p_listen(iface, 0, 0);
 682                         wifi->servicing = 0;
 683                 }
 684         }
 685
 686         return 0;
 687 }
 688
 689 static struct connman_peer_driver peer_driver = {
 690         .connect    = peer_connect,
 691         .disconnect = peer_disconnect,
 692         .register_service = peer_register_service,
 693         .unregister_service = peer_unregister_service,
 694 };
 695
 696 static void handle_tethering(struct wifi_data *wifi)
 697 {
 698         if (!wifi->tethering)
 699                 return;
 700
 701         if (!wifi->bridge)
 702                 return;
 703
 704         if (wifi->bridged)
 705                 return;
 706
 707         DBG("index %d bridge %s", wifi->index, wifi->bridge);
 708
 709         if (connman_inet_add_to_bridge(wifi->index, wifi->bridge) < 0)
 710                 return;
 711
 712         wifi->bridged = true;
 713 }
 714
 715 static void wifi_newlink(unsigned flags, unsigned change, void *user_data)
 716 {
 717         struct connman_device *device = user_data;
 718         struct wifi_data *wifi = connman_device_get_data(device);
 719
 720         if (!wifi)
 721                 return;
 722
 723         DBG("index %d flags %d change %d", wifi->index, flags, change);
 724
 725         if ((wifi->flags & IFF_UP) != (flags & IFF_UP)) {
 726                 if (flags & IFF_UP)
 727                         DBG("interface up");
 728                 else
 729                         DBG("interface down");
 730         }
 731
 732         if ((wifi->flags & IFF_LOWER_UP) != (flags & IFF_LOWER_UP)) {
 733                 if (flags & IFF_LOWER_UP) {
 734                         DBG("carrier on");
 735
 736                         handle_tethering(wifi);
 737                 } else
 738                         DBG("carrier off");
 739         }
 740
 741         wifi->flags = flags;
 742 }
 743
 744 static int wifi_probe(struct connman_device *device)
 745 {
 746         struct wifi_data *wifi;
 747
 748         DBG("device %p", device);
 749
 750         wifi = g_try_new0(struct wifi_data, 1);
 751         if (!wifi)
 752                 return -ENOMEM;
 753
 754         wifi->state = G_SUPPLICANT_STATE_INACTIVE;
 755
 756         connman_device_set_data(device, wifi);
 757         wifi->device = connman_device_ref(device);
 758
 759         wifi->index = connman_device_get_index(device);
 760         wifi->flags = 0;
 761
 762         wifi->watch = connman_rtnl_add_newlink_watch(wifi->index,
 763                                                         wifi_newlink, device);
 764         if (is_p2p_connecting())
 765                 add_pending_wifi_device(wifi);
 766         else
 767                 iface_list = g_list_append(iface_list, wifi);
 768
 769         return 0;
 770 }
 771
 772 static void remove_networks(struct connman_device *device,
 773                                 struct wifi_data *wifi)
 774 {
 775         GSList *list;
 776
 777         for (list = wifi->networks; list; list = list->next) {
 778                 struct connman_network *network = list->data;
 779
 780                 connman_device_remove_network(device, network);
 781                 connman_network_unref(network);
 782         }
 783
 784         g_slist_free(wifi->networks);
 785         wifi->networks = NULL;
 786 }
 787
 788 static void reset_autoscan(struct connman_device *device)
 789 {
 790         struct wifi_data *wifi = connman_device_get_data(device);
 791         struct autoscan_params *autoscan;
 792
 793         DBG("");
 794
 795         if (!wifi || !wifi->autoscan)
 796                 return;
 797
 798         autoscan = wifi->autoscan;
 799
 800         if (autoscan->timeout == 0 && autoscan->interval == 0)
 801                 return;
 802
 803         g_source_remove(autoscan->timeout);
 804
 805         autoscan->timeout = 0;
 806         autoscan->interval = 0;
 807
 808         connman_device_unref(device);
 809 }
 810
 811 static void stop_autoscan(struct connman_device *device)
 812 {
 813         const struct wifi_data *wifi = connman_device_get_data(device);
 814
 815         if (!wifi || !wifi->autoscan)
 816                 return;
 817
 818         reset_autoscan(device);
 819
 820         connman_device_set_scanning(device, CONNMAN_SERVICE_TYPE_WIFI, false);
 821 }
 822
 823 static void check_p2p_technology(void)
 824 {
 825         bool p2p_exists = false;
 826         GList *list;
 827
 828         for (list = iface_list; list; list = list->next) {
 829                 struct wifi_data *w = list->data;
 830
 831                 if (w->interface &&
 832                                 g_supplicant_interface_has_p2p(w->interface))
 833                         p2p_exists = true;
 834         }
 835
 836         if (!p2p_exists) {
 837                 connman_technology_driver_unregister(&p2p_tech_driver);
 838                 connman_peer_driver_unregister(&peer_driver);
 839         }
 840 }
 841
 842 static void wifi_remove(struct connman_device *device)
 843 {
 844         struct wifi_data *wifi = connman_device_get_data(device);
 845
 846         DBG("device %p wifi %p", device, wifi);
 847
 848         if (!wifi)
 849                 return;
 850
 851         stop_autoscan(device);
 852
 853         if (wifi->p2p_device)
 854                 p2p_iface_list = g_list_remove(p2p_iface_list, wifi);
 855         else
 856                 iface_list = g_list_remove(iface_list, wifi);
 857
 858         check_p2p_technology();
 859
 860         remove_pending_wifi_device(wifi);
 861
 862         if (wifi->p2p_find_timeout) {
 863                 g_source_remove(wifi->p2p_find_timeout);
 864                 connman_device_unref(wifi->device);
 865         }
 866
 867         if (wifi->p2p_connection_timeout)
 868                 g_source_remove(wifi->p2p_connection_timeout);
 869
 870         remove_networks(device, wifi);
 871
 872         connman_device_set_powered(device, false);
 873         connman_device_set_data(device, NULL);
 874         connman_device_unref(wifi->device);
 875         connman_rtnl_remove_watch(wifi->watch);
 876
 877         g_supplicant_interface_set_data(wifi->interface, NULL);
 878
 879         g_supplicant_interface_cancel(wifi->interface);
 880
 881         if (wifi->scan_params)
 882                 g_supplicant_free_scan_params(wifi->scan_params);
 883
 884         g_free(wifi->autoscan);
 885         g_free(wifi->identifier);
 886         g_free(wifi);
 887 }
 888
 889 static bool is_duplicate(GSList *list, gchar *ssid, int ssid_len)
 890 {
 891         GSList *iter;
 892
 893         for (iter = list; iter; iter = g_slist_next(iter)) {
 894                 struct scan_ssid *scan_ssid = iter->data;
 895
 896                 if (ssid_len == scan_ssid->ssid_len &&
 897                                 memcmp(ssid, scan_ssid->ssid, ssid_len) == 0)
 898                         return true;
 899         }
 900
 901         return false;
 902 }
 903
 904 static int add_scan_param(gchar *hex_ssid, char *raw_ssid, int ssid_len,
 905                         int freq, GSupplicantScanParams *scan_data,
 906                         int driver_max_scan_ssids, char *ssid_name)
 907 {
 908         unsigned int i;
 909         struct scan_ssid *scan_ssid;
 910
 911         if ((driver_max_scan_ssids == 0 ||
 912                         driver_max_scan_ssids > scan_data->num_ssids) &&
 913                         (hex_ssid || raw_ssid)) {
 914                 gchar *ssid;
 915                 unsigned int j = 0, hex;
 916
 917                 if (hex_ssid) {
 918                         size_t hex_ssid_len = strlen(hex_ssid);
 919
 920                         ssid = g_try_malloc0(hex_ssid_len / 2);
 921                         if (!ssid)
 922                                 return -ENOMEM;
 923
 924                         for (i = 0; i < hex_ssid_len; i += 2) {
 925                                 sscanf(hex_ssid + i, "%02x", &hex);
 926                                 ssid[j++] = hex;
 927                         }
 928                 } else {
 929                         ssid = raw_ssid;
 930                         j = ssid_len;
 931                 }
 932
 933                 /*
 934                  * If we have already added hidden AP to the list,
 935                  * then do not do it again. This might happen if you have
 936                  * used or are using multiple wifi cards, so in that case
 937                  * you might have multiple service files for same AP.
 938                  */
 939                 if (is_duplicate(scan_data->ssids, ssid, j)) {
 940                         if (hex_ssid)
 941                                 g_free(ssid);
 942                         return 0;
 943                 }
 944
 945                 scan_ssid = g_try_new(struct scan_ssid, 1);
 946                 if (!scan_ssid) {
 947                         if (hex_ssid)
 948                                 g_free(ssid);
 949                         return -ENOMEM;
 950                 }
 951
 952                 memcpy(scan_ssid->ssid, ssid, j);
 953                 scan_ssid->ssid_len = j;
 954                 scan_data->ssids = g_slist_prepend(scan_data->ssids,
 955                                                                 scan_ssid);
 956
 957                 scan_data->num_ssids++;
 958
 959                 DBG("SSID %s added to scanned list of %d entries", ssid_name,
 960                                                         scan_data->num_ssids);
 961
 962                 if (hex_ssid)
 963                         g_free(ssid);
 964         } else
 965                 return -EINVAL;
 966
 967         scan_data->ssids = g_slist_reverse(scan_data->ssids);
 968
 969         if (!scan_data->freqs) {
 970                 scan_data->freqs = g_try_malloc0(sizeof(uint16_t));
 971                 if (!scan_data->freqs) {
 972                         g_slist_free_full(scan_data->ssids, g_free);
 973                         return -ENOMEM;
 974                 }
 975
 976                 scan_data->num_freqs = 1;
 977                 scan_data->freqs[0] = freq;
 978         } else {
 979                 bool duplicate = false;
 980
 981                 /* Don't add duplicate entries */
 982                 for (i = 0; i < scan_data->num_freqs; i++) {
 983                         if (scan_data->freqs[i] == freq) {
 984                                 duplicate = true;
 985                                 break;
 986                         }
 987                 }
 988
 989                 if (!duplicate) {
 990                         scan_data->num_freqs++;
 991                         scan_data->freqs = g_try_realloc(scan_data->freqs,
 992                                 sizeof(uint16_t) * scan_data->num_freqs);
 993                         if (!scan_data->freqs) {
 994                                 g_slist_free_full(scan_data->ssids, g_free);
 995                                 return -ENOMEM;
 996                         }
 997                         scan_data->freqs[scan_data->num_freqs - 1] = freq;
 998                 }
 999         }
1000
1001         return 1;
1002 }
1003
1004 static int get_hidden_connections(GSupplicantScanParams *scan_data)
1005 {
1006         struct connman_config_entry **entries;
1007         GKeyFile *keyfile;
1008         gchar **services;
1009         char *ssid, *name;
1010         int i, ret;
1011         bool value;
1012         int num_ssids = 0, add_param_failed = 0;
1013
1014         services = connman_storage_get_services();
1015         for (i = 0; services && services[i]; i++) {
1016                 if (strncmp(services[i], "wifi_", 5) != 0)
1017                         continue;
1018
1019                 keyfile = connman_storage_load_service(services[i]);
1020                 if (!keyfile)
1021                         continue;
1022
1023                 value = g_key_file_get_boolean(keyfile,
1024                                         services[i], "Hidden", NULL);
1025                 if (!value) {
1026                         g_key_file_free(keyfile);
1027                         continue;
1028                 }
1029
1030                 value = g_key_file_get_boolean(keyfile,
1031                                         services[i], "Favorite", NULL);
1032                 if (!value) {
1033                         g_key_file_free(keyfile);
1034                         continue;
1035                 }
1036
1037 #if defined TIZEN_EXT
1038                 value = g_key_file_get_boolean(keyfile,
1039                                         services[i], "AutoConnect", NULL);
1040                 if (!value) {
1041                         g_key_file_free(keyfile);
1042                         continue;
1043                 }
1044 #endif
1045
1046                 ssid = g_key_file_get_string(keyfile,
1047                                         services[i], "SSID", NULL);
1048
1049                 name = g_key_file_get_string(keyfile, services[i], "Name",
1050                                                                 NULL);
1051
1052                 ret = add_scan_param(ssid, NULL, 0, 0, scan_data, 0, name);
1053                 if (ret < 0)
1054                         add_param_failed++;
1055                 else if (ret > 0)
1056                         num_ssids++;
1057
1058                 g_free(ssid);
1059                 g_free(name);
1060                 g_key_file_free(keyfile);
1061         }
1062
1063         /*
1064          * Check if there are any hidden AP that needs to be provisioned.
1065          */
1066         entries = connman_config_get_entries("wifi");
1067         for (i = 0; entries && entries[i]; i++) {
1068                 int len;
1069
1070                 if (!entries[i]->hidden)
1071                         continue;
1072
1073                 if (!entries[i]->ssid) {
1074                         ssid = entries[i]->name;
1075                         len = strlen(ssid);
1076                 } else {
1077                         ssid = entries[i]->ssid;
1078                         len = entries[i]->ssid_len;
1079                 }
1080
1081                 if (!ssid)
1082                         continue;
1083
1084                 ret = add_scan_param(NULL, ssid, len, 0, scan_data, 0, ssid);
1085                 if (ret < 0)
1086                         add_param_failed++;
1087                 else if (ret > 0)
1088                         num_ssids++;
1089         }
1090
1091         connman_config_free_entries(entries);
1092
1093         if (add_param_failed > 0)
1094                 DBG("Unable to scan %d out of %d SSIDs",
1095                                         add_param_failed, num_ssids);
1096
1097         g_strfreev(services);
1098
1099         return num_ssids;
1100 }
1101
1102 static int get_hidden_connections_params(struct wifi_data *wifi,
1103                                         GSupplicantScanParams *scan_params)
1104 {
1105         int driver_max_ssids, i;
1106         GSupplicantScanParams *orig_params;
1107
1108         /*
1109          * Scan hidden networks so that we can autoconnect to them.
1110          * We will assume 1 as a default number of ssid to scan.
1111          */
1112         driver_max_ssids = g_supplicant_interface_get_max_scan_ssids(
1113                                                         wifi->interface);
1114         if (driver_max_ssids == 0)
1115                 driver_max_ssids = 1;
1116
1117         DBG("max ssids %d", driver_max_ssids);
1118
1119         if (!wifi->scan_params) {
1120                 wifi->scan_params = g_try_malloc0(sizeof(GSupplicantScanParams));
1121                 if (!wifi->scan_params)
1122                         return 0;
1123
1124                 if (get_hidden_connections(wifi->scan_params) == 0) {
1125                         g_supplicant_free_scan_params(wifi->scan_params);
1126                         wifi->scan_params = NULL;
1127
1128                         return 0;
1129                 }
1130         }
1131
1132         orig_params = wifi->scan_params;
1133
1134         /* Let's transfer driver_max_ssids params */
1135         for (i = 0; i < driver_max_ssids; i++) {
1136                 struct scan_ssid *ssid;
1137
1138                 if (!wifi->scan_params->ssids)
1139                         break;
1140
1141                 ssid = orig_params->ssids->data;
1142                 orig_params->ssids = g_slist_remove(orig_params->ssids, ssid);
1143                 scan_params->ssids = g_slist_prepend(scan_params->ssids, ssid);
1144         }
1145
1146         if (i > 0) {
1147                 scan_params->num_ssids = i;
1148                 scan_params->ssids = g_slist_reverse(scan_params->ssids);
1149
1150                 scan_params->freqs = g_memdup(orig_params->freqs,
1151                                 sizeof(uint16_t) * orig_params->num_freqs);
1152                 if (!scan_params->freqs)
1153                         goto err;
1154
1155                 scan_params->num_freqs = orig_params->num_freqs;
1156
1157         } else
1158                 goto err;
1159
1160         orig_params->num_ssids -= scan_params->num_ssids;
1161
1162         return scan_params->num_ssids;
1163
1164 err:
1165         g_slist_free_full(scan_params->ssids, g_free);
1166         g_supplicant_free_scan_params(wifi->scan_params);
1167         wifi->scan_params = NULL;
1168
1169         return 0;
1170 }
1171
1172 static int throw_wifi_scan(struct connman_device *device,
1173                         GSupplicantInterfaceCallback callback)
1174 {
1175         struct wifi_data *wifi = connman_device_get_data(device);
1176         int ret;
1177
1178         if (!wifi)
1179                 return -ENODEV;
1180
1181         DBG("device %p %p", device, wifi->interface);
1182
1183         if (wifi->tethering)
1184                 return -EBUSY;
1185
1186         if (connman_device_get_scanning(device))
1187                 return -EALREADY;
1188
1189         connman_device_ref(device);
1190
1191         ret = g_supplicant_interface_scan(wifi->interface, NULL,
1192                                                 callback, device);
1193         if (ret == 0) {
1194                 connman_device_set_scanning(device,
1195                                 CONNMAN_SERVICE_TYPE_WIFI, true);
1196         } else
1197                 connman_device_unref(device);
1198
1199         return ret;
1200 }
1201
1202 static void hidden_free(struct hidden_params *hidden)
1203 {
1204         if (!hidden)
1205                 return;
1206
1207         if (hidden->scan_params)
1208                 g_supplicant_free_scan_params(hidden->scan_params);
1209         g_free(hidden->identity);
1210         g_free(hidden->passphrase);
1211         g_free(hidden->security);
1212         g_free(hidden);
1213 }
1214
1215 #if defined TIZEN_EXT
1216 static void service_state_changed(struct connman_service *service,
1217                                         enum connman_service_state state);
1218
1219 static int network_connect(struct connman_network *network);
1220
1221 static struct connman_notifier notifier = {
1222         .name                   = "wifi",
1223         .priority               = CONNMAN_NOTIFIER_PRIORITY_DEFAULT,
1224         .service_state_changed  = service_state_changed,
1225 };
1226
1227 static void service_state_changed(struct connman_service *service,
1228                                         enum connman_service_state state)
1229 {
1230         enum connman_service_type type;
1231
1232         type = connman_service_get_type(service);
1233         if (type != CONNMAN_SERVICE_TYPE_WIFI)
1234                 return;
1235
1236         DBG("service %p state %d", service, state);
1237
1238         switch (state) {
1239         case CONNMAN_SERVICE_STATE_READY:
1240         case CONNMAN_SERVICE_STATE_ONLINE:
1241         case CONNMAN_SERVICE_STATE_FAILURE:
1242                 connman_notifier_unregister(&notifier);
1243                 is_wifi_notifier_registered = FALSE;
1244
1245                 __connman_device_request_scan(type);
1246                 break;
1247
1248         default:
1249                 break;
1250         }
1251 }
1252 #endif
1253
1254 static void scan_callback(int result, GSupplicantInterface *interface,
1255                                                 void *user_data)
1256 {
1257         struct connman_device *device = user_data;
1258         struct wifi_data *wifi = connman_device_get_data(device);
1259         bool scanning;
1260
1261         DBG("result %d wifi %p", result, wifi);
1262
1263         if (wifi) {
1264                 if (wifi->hidden && !wifi->postpone_hidden) {
1265                         connman_network_clear_hidden(wifi->hidden->user_data);
1266                         hidden_free(wifi->hidden);
1267                         wifi->hidden = NULL;
1268                 }
1269
1270                 if (wifi->scan_params) {
1271                         g_supplicant_free_scan_params(wifi->scan_params);
1272                         wifi->scan_params = NULL;
1273                 }
1274         }
1275
1276         if (result < 0)
1277                 connman_device_reset_scanning(device);
1278
1279         /* User is connecting to a hidden AP, let's wait for finished event */
1280         if (wifi && wifi->hidden && wifi->postpone_hidden) {
1281                 GSupplicantScanParams *scan_params;
1282                 int ret;
1283
1284                 wifi->postpone_hidden = false;
1285                 scan_params = wifi->hidden->scan_params;
1286                 wifi->hidden->scan_params = NULL;
1287
1288                 reset_autoscan(device);
1289
1290                 ret = g_supplicant_interface_scan(wifi->interface, scan_params,
1291                                                         scan_callback, device);
1292                 if (ret == 0)
1293                         return;
1294
1295                 /* On error, let's recall scan_callback, which will cleanup */
1296                 return scan_callback(ret, interface, user_data);
1297         }
1298
1299         scanning = connman_device_get_scanning(device);
1300
1301         if (scanning) {
1302                 connman_device_set_scanning(device,
1303                                 CONNMAN_SERVICE_TYPE_WIFI, false);
1304         }
1305
1306         if (result != -ENOLINK)
1307 #if defined TIZEN_EXT
1308         if (result != -EIO)
1309 #endif
1310                 start_autoscan(device);
1311
1312         /*
1313          * If we are here then we were scanning; however, if we are
1314          * also mid-flight disabling the interface, then wifi_disable
1315          * has already cleared the device scanning state and
1316          * unreferenced the device, obviating the need to do it here.
1317          */
1318
1319         if (scanning)
1320                 connman_device_unref(device);
1321
1322 #if defined TIZEN_EXT
1323         if (wifi && wifi->scan_pending_network) {
1324                 network_connect(wifi->scan_pending_network);
1325                 wifi->scan_pending_network = NULL;
1326         }
1327
1328         if (is_wifi_notifier_registered != true &&
1329                         wifi_first_scan == true && found_with_first_scan == true) {
1330                 wifi_first_scan = false;
1331                 found_with_first_scan = false;
1332
1333                 connman_notifier_register(&notifier);
1334                 is_wifi_notifier_registered = true;
1335         }
1336 #endif
1337 }
1338
1339 static void scan_callback_hidden(int result,
1340                         GSupplicantInterface *interface, void *user_data)
1341 {
1342         struct connman_device *device = user_data;
1343         struct wifi_data *wifi = connman_device_get_data(device);
1344         GSupplicantScanParams *scan_params;
1345         int ret;
1346
1347         DBG("result %d wifi %p", result, wifi);
1348
1349         if (!wifi)
1350                 goto out;
1351
1352         /* User is trying to connect to a hidden AP */
1353         if (wifi->hidden && wifi->postpone_hidden)
1354                 goto out;
1355
1356         scan_params = g_try_malloc0(sizeof(GSupplicantScanParams));
1357         if (!scan_params)
1358                 goto out;
1359
1360         if (get_hidden_connections_params(wifi, scan_params) > 0) {
1361                 ret = g_supplicant_interface_scan(wifi->interface,
1362                                                         scan_params,
1363                                                         scan_callback_hidden,
1364                                                         device);
1365                 if (ret == 0)
1366                         return;
1367         }
1368
1369         g_supplicant_free_scan_params(scan_params);
1370
1371 out:
1372         scan_callback(result, interface, user_data);
1373 }
1374
1375 static gboolean autoscan_timeout(gpointer data)
1376 {
1377         struct connman_device *device = data;
1378         struct wifi_data *wifi = connman_device_get_data(device);
1379         struct autoscan_params *autoscan;
1380         int interval;
1381
1382         if (!wifi)
1383                 return FALSE;
1384
1385         autoscan = wifi->autoscan;
1386
1387         if (autoscan->interval <= 0) {
1388                 interval = autoscan->base;
1389                 goto set_interval;
1390         } else
1391                 interval = autoscan->interval * autoscan->base;
1392
1393 #if defined TIZEN_EXT
1394         if (autoscan->interval >= autoscan->limit)
1395 #else
1396         if (interval > autoscan->limit)
1397 #endif
1398                 interval = autoscan->limit;
1399
1400         throw_wifi_scan(wifi->device, scan_callback_hidden);
1401
1402 set_interval:
1403         DBG("interval %d", interval);
1404
1405         autoscan->interval = interval;
1406
1407         autoscan->timeout = g_timeout_add_seconds(interval,
1408                                                 autoscan_timeout, device);
1409
1410         return FALSE;
1411 }
1412
1413 static void start_autoscan(struct connman_device *device)
1414 {
1415         struct wifi_data *wifi = connman_device_get_data(device);
1416         struct autoscan_params *autoscan;
1417
1418         DBG("");
1419
1420         if (!wifi)
1421                 return;
1422
1423         if (wifi->p2p_device)
1424                 return;
1425
1426         if (wifi->connected)
1427                 return;
1428
1429         autoscan = wifi->autoscan;
1430         if (!autoscan)
1431                 return;
1432
1433         if (autoscan->timeout > 0 || autoscan->interval > 0)
1434                 return;
1435
1436         connman_device_ref(device);
1437
1438         autoscan_timeout(device);
1439 }
1440
1441 static struct autoscan_params *parse_autoscan_params(const char *params)
1442 {
1443         struct autoscan_params *autoscan;
1444         char **list_params;
1445         int limit;
1446         int base;
1447
1448         DBG("Emulating autoscan");
1449
1450         list_params = g_strsplit(params, ":", 0);
1451         if (list_params == 0)
1452                 return NULL;
1453
1454         if (g_strv_length(list_params) < 3) {
1455                 g_strfreev(list_params);
1456                 return NULL;
1457         }
1458
1459         base = atoi(list_params[1]);
1460         limit = atoi(list_params[2]);
1461
1462         g_strfreev(list_params);
1463
1464         autoscan = g_try_malloc0(sizeof(struct autoscan_params));
1465         if (!autoscan) {
1466                 DBG("Could not allocate memory for autoscan");
1467                 return NULL;
1468         }
1469
1470         DBG("base %d - limit %d", base, limit);
1471         autoscan->base = base;
1472         autoscan->limit = limit;
1473
1474         return autoscan;
1475 }
1476
1477 static void setup_autoscan(struct wifi_data *wifi)
1478 {
1479         if (!wifi->autoscan)
1480                 wifi->autoscan = parse_autoscan_params(AUTOSCAN_DEFAULT);
1481
1482         start_autoscan(wifi->device);
1483 }
1484
1485 static void finalize_interface_creation(struct wifi_data *wifi)
1486 {
1487         DBG("interface is ready wifi %p tethering %d", wifi, wifi->tethering);
1488
1489         if (!wifi->device) {
1490                 connman_error("WiFi device not set");
1491                 return;
1492         }
1493
1494         connman_device_set_powered(wifi->device, true);
1495
1496         if (!connman_setting_get_bool("BackgroundScanning"))
1497                 return;
1498
1499         if (wifi->p2p_device)
1500                 return;
1501
1502         setup_autoscan(wifi);
1503 }
1504
1505 static void interface_create_callback(int result,
1506                                         GSupplicantInterface *interface,
1507                                                         void *user_data)
1508 {
1509         struct wifi_data *wifi = user_data;
1510
1511         DBG("result %d ifname %s, wifi %p", result,
1512                                 g_supplicant_interface_get_ifname(interface),
1513                                 wifi);
1514
1515         if (result < 0 || !wifi)
1516                 return;
1517
1518         wifi->interface = interface;
1519         g_supplicant_interface_set_data(interface, wifi);
1520
1521         if (g_supplicant_interface_get_ready(interface)) {
1522                 wifi->interface_ready = true;
1523                 finalize_interface_creation(wifi);
1524         }
1525 }
1526
1527 static int wifi_enable(struct connman_device *device)
1528 {
1529         struct wifi_data *wifi = connman_device_get_data(device);
1530         int index;
1531         char *interface;
1532         const char *driver = connman_option_get_string("wifi");
1533         int ret;
1534
1535         DBG("device %p %p", device, wifi);
1536
1537         index = connman_device_get_index(device);
1538         if (!wifi || index < 0)
1539                 return -ENODEV;
1540
1541         if (is_p2p_connecting())
1542                 return -EINPROGRESS;
1543
1544         interface = connman_inet_ifname(index);
1545         ret = g_supplicant_interface_create(interface, driver, NULL,
1546                                                 interface_create_callback,
1547                                                         wifi);
1548         g_free(interface);
1549
1550         if (ret < 0)
1551                 return ret;
1552
1553         return -EINPROGRESS;
1554 }
1555
1556 static int wifi_disable(struct connman_device *device)
1557 {
1558         struct wifi_data *wifi = connman_device_get_data(device);
1559         int ret;
1560
1561         DBG("device %p wifi %p", device, wifi);
1562
1563         if (!wifi)
1564                 return -ENODEV;
1565
1566         wifi->connected = false;
1567         wifi->disconnecting = false;
1568
1569         if (wifi->pending_network)
1570                 wifi->pending_network = NULL;
1571
1572         stop_autoscan(device);
1573
1574         if (wifi->p2p_find_timeout) {
1575                 g_source_remove(wifi->p2p_find_timeout);
1576                 wifi->p2p_find_timeout = 0;
1577                 connman_device_set_scanning(device, CONNMAN_SERVICE_TYPE_P2P, false);
1578                 connman_device_unref(wifi->device);
1579         }
1580
1581         /* In case of a user scan, device is still referenced */
1582         if (connman_device_get_scanning(device)) {
1583                 connman_device_set_scanning(device,
1584                                 CONNMAN_SERVICE_TYPE_WIFI, false);
1585                 connman_device_unref(wifi->device);
1586         }
1587
1588         remove_networks(device, wifi);
1589
1590 #if defined TIZEN_EXT
1591         wifi->scan_pending_network = NULL;
1592         wifi->interface_disconnected_network = NULL;
1593
1594         if (is_wifi_notifier_registered == true) {
1595                 connman_notifier_unregister(&notifier);
1596                 is_wifi_notifier_registered = false;
1597         }
1598 #endif
1599
1600         ret = g_supplicant_interface_remove(wifi->interface, NULL, NULL);
1601         if (ret < 0)
1602                 return ret;
1603
1604         return -EINPROGRESS;
1605 }
1606
1607 struct last_connected {
1608         GTimeVal modified;
1609         gchar *ssid;
1610         int freq;
1611 };
1612
1613 static gint sort_entry(gconstpointer a, gconstpointer b, gpointer user_data)
1614 {
1615         GTimeVal *aval = (GTimeVal *)a;
1616         GTimeVal *bval = (GTimeVal *)b;
1617
1618         /* Note that the sort order is descending */
1619         if (aval->tv_sec < bval->tv_sec)
1620                 return 1;
1621
1622         if (aval->tv_sec > bval->tv_sec)
1623                 return -1;
1624
1625         return 0;
1626 }
1627
1628 static void free_entry(gpointer data)
1629 {
1630         struct last_connected *entry = data;
1631
1632         g_free(entry->ssid);
1633         g_free(entry);
1634 }
1635
1636 static int get_latest_connections(int max_ssids,
1637                                 GSupplicantScanParams *scan_data)
1638 {
1639         GSequenceIter *iter;
1640         GSequence *latest_list;
1641         struct last_connected *entry;
1642         GKeyFile *keyfile;
1643         GTimeVal modified;
1644         gchar **services;
1645         gchar *str;
1646         char *ssid;
1647         int i, freq;
1648         int num_ssids = 0;
1649
1650         latest_list = g_sequence_new(free_entry);
1651         if (!latest_list)
1652                 return -ENOMEM;
1653
1654         services = connman_storage_get_services();
1655         for (i = 0; services && services[i]; i++) {
1656                 if (strncmp(services[i], "wifi_", 5) != 0)
1657                         continue;
1658
1659                 keyfile = connman_storage_load_service(services[i]);
1660                 if (!keyfile)
1661                         continue;
1662
1663                 str = g_key_file_get_string(keyfile,
1664                                         services[i], "Favorite", NULL);
1665                 if (!str || g_strcmp0(str, "true")) {
1666                         g_free(str);
1667                         g_key_file_free(keyfile);
1668                         continue;
1669                 }
1670                 g_free(str);
1671
1672                 str = g_key_file_get_string(keyfile,
1673                                         services[i], "AutoConnect", NULL);
1674                 if (!str || g_strcmp0(str, "true")) {
1675                         g_free(str);
1676                         g_key_file_free(keyfile);
1677                         continue;
1678                 }
1679                 g_free(str);
1680
1681                 str = g_key_file_get_string(keyfile,
1682                                         services[i], "Modified", NULL);
1683                 if (!str) {
1684                         g_key_file_free(keyfile);
1685                         continue;
1686                 }
1687                 g_time_val_from_iso8601(str, &modified);
1688                 g_free(str);
1689
1690                 ssid = g_key_file_get_string(keyfile,
1691                                         services[i], "SSID", NULL);
1692
1693                 freq = g_key_file_get_integer(keyfile, services[i],
1694                                         "Frequency", NULL);
1695                 if (freq) {
1696                         entry = g_try_new(struct last_connected, 1);
1697                         if (!entry) {
1698                                 g_sequence_free(latest_list);
1699                                 g_key_file_free(keyfile);
1700                                 g_free(ssid);
1701                                 return -ENOMEM;
1702                         }
1703
1704                         entry->ssid = ssid;
1705                         entry->modified = modified;
1706                         entry->freq = freq;
1707
1708                         g_sequence_insert_sorted(latest_list, entry,
1709                                                 sort_entry, NULL);
1710                         num_ssids++;
1711                 } else
1712                         g_free(ssid);
1713
1714                 g_key_file_free(keyfile);
1715         }
1716
1717         g_strfreev(services);
1718
1719         num_ssids = num_ssids > max_ssids ? max_ssids : num_ssids;
1720
1721         iter = g_sequence_get_begin_iter(latest_list);
1722
1723         for (i = 0; i < num_ssids; i++) {
1724                 entry = g_sequence_get(iter);
1725
1726                 DBG("ssid %s freq %d modified %lu", entry->ssid, entry->freq,
1727                                                 entry->modified.tv_sec);
1728
1729                 add_scan_param(entry->ssid, NULL, 0, entry->freq, scan_data,
1730                                                 max_ssids, entry->ssid);
1731
1732                 iter = g_sequence_iter_next(iter);
1733         }
1734
1735         g_sequence_free(latest_list);
1736         return num_ssids;
1737 }
1738
1739 static int wifi_scan_simple(struct connman_device *device)
1740 {
1741         reset_autoscan(device);
1742
1743         return throw_wifi_scan(device, scan_callback_hidden);
1744 }
1745
1746 static gboolean p2p_find_stop(gpointer data)
1747 {
1748         struct connman_device *device = data;
1749         struct wifi_data *wifi = connman_device_get_data(device);
1750
1751         DBG("");
1752
1753         wifi->p2p_find_timeout = 0;
1754
1755         connman_device_set_scanning(device, CONNMAN_SERVICE_TYPE_P2P, false);
1756
1757         g_supplicant_interface_p2p_stop_find(wifi->interface);
1758
1759         connman_device_unref(device);
1760         reset_autoscan(device);
1761
1762         return FALSE;
1763 }
1764
1765 static void p2p_find_callback(int result, GSupplicantInterface *interface,
1766                                                         void *user_data)
1767 {
1768         struct connman_device *device = user_data;
1769         struct wifi_data *wifi = connman_device_get_data(device);
1770
1771         DBG("result %d wifi %p", result, wifi);
1772
1773         if (wifi->p2p_find_timeout) {
1774                 g_source_remove(wifi->p2p_find_timeout);
1775                 wifi->p2p_find_timeout = 0;
1776         }
1777
1778         if (result)
1779                 goto error;
1780
1781         wifi->p2p_find_timeout = g_timeout_add_seconds(P2P_FIND_TIMEOUT,
1782                                                         p2p_find_stop, device);
1783         if (!wifi->p2p_find_timeout)
1784                 goto error;
1785
1786         return;
1787 error:
1788         p2p_find_stop(device);
1789 }
1790
1791 static int p2p_find(struct connman_device *device)
1792 {
1793         struct wifi_data *wifi;
1794         int ret;
1795
1796         DBG("");
1797
1798         if (!p2p_technology)
1799                 return -ENOTSUP;
1800
1801         wifi = connman_device_get_data(device);
1802
1803         if (g_supplicant_interface_is_p2p_finding(wifi->interface))
1804                 return -EALREADY;
1805
1806         reset_autoscan(device);
1807         connman_device_ref(device);
1808
1809         ret = g_supplicant_interface_p2p_find(wifi->interface,
1810                                                 p2p_find_callback, device);
1811         if (ret) {
1812                 connman_device_unref(device);
1813                 start_autoscan(device);
1814         } else {
1815                 connman_device_set_scanning(device,
1816                                 CONNMAN_SERVICE_TYPE_P2P, true);
1817         }
1818
1819         return ret;
1820 }
1821
1822 /*
1823  * Note that the hidden scan is only used when connecting to this specific
1824  * hidden AP first time. It is not used when system autoconnects to hidden AP.
1825  */
1826 static int wifi_scan(enum connman_service_type type,
1827                         struct connman_device *device,
1828                         const char *ssid, unsigned int ssid_len,
1829                         const char *identity, const char* passphrase,
1830                         const char *security, void *user_data)
1831 {
1832         struct wifi_data *wifi = connman_device_get_data(device);
1833         GSupplicantScanParams *scan_params = NULL;
1834         struct scan_ssid *scan_ssid;
1835         struct hidden_params *hidden;
1836         int ret;
1837         int driver_max_ssids = 0;
1838         bool do_hidden;
1839         bool scanning;
1840
1841         if (!wifi)
1842                 return -ENODEV;
1843
1844         if (wifi->p2p_device)
1845                 return 0;
1846
1847         if (type == CONNMAN_SERVICE_TYPE_P2P)
1848                 return p2p_find(device);
1849
1850         DBG("device %p wifi %p hidden ssid %s", device, wifi->interface, ssid);
1851
1852         if (wifi->tethering)
1853                 return 0;
1854
1855         scanning = connman_device_get_scanning(device);
1856
1857         if (!ssid || ssid_len == 0 || ssid_len > 32) {
1858                 if (scanning)
1859                         return -EALREADY;
1860
1861                 driver_max_ssids = g_supplicant_interface_get_max_scan_ssids(
1862                                                         wifi->interface);
1863                 DBG("max ssids %d", driver_max_ssids);
1864                 if (driver_max_ssids == 0)
1865                         return wifi_scan_simple(device);
1866
1867                 do_hidden = false;
1868         } else {
1869                 if (scanning && wifi->hidden && wifi->postpone_hidden)
1870                         return -EALREADY;
1871
1872                 do_hidden = true;
1873         }
1874
1875         scan_params = g_try_malloc0(sizeof(GSupplicantScanParams));
1876         if (!scan_params)
1877                 return -ENOMEM;
1878
1879         if (do_hidden) {
1880                 scan_ssid = g_try_new(struct scan_ssid, 1);
1881                 if (!scan_ssid) {
1882                         g_free(scan_params);
1883                         return -ENOMEM;
1884                 }
1885
1886                 memcpy(scan_ssid->ssid, ssid, ssid_len);
1887                 scan_ssid->ssid_len = ssid_len;
1888                 scan_params->ssids = g_slist_prepend(scan_params->ssids,
1889                                                                 scan_ssid);
1890                 scan_params->num_ssids = 1;
1891
1892                 hidden = g_try_new0(struct hidden_params, 1);
1893                 if (!hidden) {
1894                         g_supplicant_free_scan_params(scan_params);
1895                         return -ENOMEM;
1896                 }
1897
1898                 if (wifi->hidden) {
1899                         hidden_free(wifi->hidden);
1900                         wifi->hidden = NULL;
1901                 }
1902
1903                 memcpy(hidden->ssid, ssid, ssid_len);
1904                 hidden->ssid_len = ssid_len;
1905                 hidden->identity = g_strdup(identity);
1906                 hidden->passphrase = g_strdup(passphrase);
1907                 hidden->security = g_strdup(security);
1908                 hidden->user_data = user_data;
1909                 wifi->hidden = hidden;
1910
1911                 if (scanning) {
1912                         /* Let's keep this active scan for later,
1913                          * when current scan will be over. */
1914                         wifi->postpone_hidden = TRUE;
1915                         hidden->scan_params = scan_params;
1916
1917                         return 0;
1918                 }
1919         } else if (wifi->connected) {
1920                 g_supplicant_free_scan_params(scan_params);
1921                 return wifi_scan_simple(device);
1922         } else {
1923                 ret = get_latest_connections(driver_max_ssids, scan_params);
1924                 if (ret <= 0) {
1925                         g_supplicant_free_scan_params(scan_params);
1926                         return wifi_scan_simple(device);
1927                 }
1928         }
1929
1930         connman_device_ref(device);
1931
1932         reset_autoscan(device);
1933
1934 #if defined TIZEN_EXT
1935         if (wifi->hidden) {
1936                 ret = g_supplicant_interface_scan(wifi->interface, scan_params,
1937                                                 scan_callback, device);
1938         }
1939         else {
1940                 ret = g_supplicant_interface_scan(wifi->interface, NULL,
1941                                                         scan_callback_hidden, device);
1942         }
1943 #else
1944         ret = g_supplicant_interface_scan(wifi->interface, scan_params,
1945                                                 scan_callback, device);
1946 #endif
1947         if (ret == 0) {
1948                 connman_device_set_scanning(device,
1949                                 CONNMAN_SERVICE_TYPE_WIFI, true);
1950         } else {
1951                 g_supplicant_free_scan_params(scan_params);
1952                 connman_device_unref(device);
1953
1954                 if (do_hidden) {
1955                         hidden_free(wifi->hidden);
1956                         wifi->hidden = NULL;
1957                 }
1958         }
1959
1960         return ret;
1961 }
1962
1963 static void wifi_regdom_callback(int result,
1964                                         const char *alpha2,
1965                                                 void *user_data)
1966 {
1967         struct connman_device *device = user_data;
1968
1969         connman_device_regdom_notify(device, result, alpha2);
1970
1971         connman_device_unref(device);
1972 }
1973
1974 static int wifi_set_regdom(struct connman_device *device, const char *alpha2)
1975 {
1976         struct wifi_data *wifi = connman_device_get_data(device);
1977         int ret;
1978
1979         if (!wifi)
1980                 return -EINVAL;
1981
1982         connman_device_ref(device);
1983
1984         ret = g_supplicant_interface_set_country(wifi->interface,
1985                                                 wifi_regdom_callback,
1986                                                         alpha2, device);
1987         if (ret != 0)
1988                 connman_device_unref(device);
1989
1990         return ret;
1991 }
1992
1993 static struct connman_device_driver wifi_ng_driver = {
1994         .name           = "wifi",
1995         .type           = CONNMAN_DEVICE_TYPE_WIFI,
1996         .priority       = CONNMAN_DEVICE_PRIORITY_LOW,
1997         .probe          = wifi_probe,
1998         .remove         = wifi_remove,
1999         .enable         = wifi_enable,
2000         .disable        = wifi_disable,
2001         .scan           = wifi_scan,
2002         .set_regdom     = wifi_set_regdom,
2003 };
2004
2005 static void system_ready(void)
2006 {
2007         DBG("");
2008
2009         if (connman_device_driver_register(&wifi_ng_driver) < 0)
2010                 connman_error("Failed to register WiFi driver");
2011 }
2012
2013 static void system_killed(void)
2014 {
2015         DBG("");
2016
2017         connman_device_driver_unregister(&wifi_ng_driver);
2018 }
2019
2020 static int network_probe(struct connman_network *network)
2021 {
2022         DBG("network %p", network);
2023
2024         return 0;
2025 }
2026
2027 static void network_remove(struct connman_network *network)
2028 {
2029         struct connman_device *device = connman_network_get_device(network);
2030         struct wifi_data *wifi;
2031
2032         DBG("network %p", network);
2033
2034         wifi = connman_device_get_data(device);
2035         if (!wifi)
2036                 return;
2037
2038         if (wifi->network != network)
2039                 return;
2040
2041         wifi->network = NULL;
2042
2043 #if defined TIZEN_EXT
2044         wifi->disconnecting = false;
2045
2046         if (wifi->pending_network == network)
2047                 wifi->pending_network = NULL;
2048
2049         if (wifi->scan_pending_network == network)
2050                 wifi->scan_pending_network = NULL;
2051
2052         if (wifi->interface_disconnected_network == network)
2053                 wifi->interface_disconnected_network = NULL;
2054 #endif
2055 }
2056
2057 static void connect_callback(int result, GSupplicantInterface *interface,
2058                                                         void *user_data)
2059 {
2060 #if defined TIZEN_EXT
2061         GList *list;
2062         struct wifi_data *wifi;
2063 #endif
2064         struct connman_network *network = user_data;
2065
2066         DBG("network %p result %d", network, result);
2067
2068 #if defined TIZEN_EXT
2069         for (list = iface_list; list; list = list->next) {
2070                 wifi = list->data;
2071
2072                 if (wifi && wifi->network == network)
2073                         goto found;
2074         }
2075
2076         /* wifi_data may be invalid because wifi is already disabled */
2077         return;
2078
2079 found:
2080         wifi->interface_disconnected_network = NULL;
2081 #endif
2082         if (result == -ENOKEY) {
2083                 connman_network_set_error(network,
2084                                         CONNMAN_NETWORK_ERROR_INVALID_KEY);
2085         } else if (result < 0) {
2086                 connman_network_set_error(network,
2087                                         CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL);
2088         }
2089
2090         connman_network_unref(network);
2091 }
2092
2093 static GSupplicantSecurity network_security(const char *security)
2094 {
2095         if (g_str_equal(security, "none"))
2096                 return G_SUPPLICANT_SECURITY_NONE;
2097         else if (g_str_equal(security, "wep"))
2098                 return G_SUPPLICANT_SECURITY_WEP;
2099         else if (g_str_equal(security, "psk"))
2100                 return G_SUPPLICANT_SECURITY_PSK;
2101         else if (g_str_equal(security, "wpa"))
2102                 return G_SUPPLICANT_SECURITY_PSK;
2103         else if (g_str_equal(security, "rsn"))
2104                 return G_SUPPLICANT_SECURITY_PSK;
2105         else if (g_str_equal(security, "ieee8021x"))
2106                 return G_SUPPLICANT_SECURITY_IEEE8021X;
2107 #if defined TIZEN_EXT
2108         else if (g_str_equal(security, "ft_psk") == TRUE)
2109                 return G_SUPPLICANT_SECURITY_FT_PSK;
2110         else if (g_str_equal(security, "ft_ieee8021x") == TRUE)
2111                 return G_SUPPLICANT_SECURITY_FT_IEEE8021X;
2112 #endif
2113
2114         return G_SUPPLICANT_SECURITY_UNKNOWN;
2115 }
2116
2117 static void ssid_init(GSupplicantSSID *ssid, struct connman_network *network)
2118 {
2119         const char *security;
2120
2121         memset(ssid, 0, sizeof(*ssid));
2122         ssid->mode = G_SUPPLICANT_MODE_INFRA;
2123         ssid->ssid = connman_network_get_blob(network, "WiFi.SSID",
2124                                                 &ssid->ssid_len);
2125         ssid->scan_ssid = 1;
2126         security = connman_network_get_string(network, "WiFi.Security");
2127         ssid->security = network_security(security);
2128         ssid->passphrase = connman_network_get_string(network,
2129                                                 "WiFi.Passphrase");
2130
2131         ssid->eap = connman_network_get_string(network, "WiFi.EAP");
2132
2133         /*
2134          * If our private key password is unset,
2135          * we use the supplied passphrase. That is needed
2136          * for PEAP where 2 passphrases (identity and client
2137          * cert may have to be provided.
2138          */
2139         if (!connman_network_get_string(network, "WiFi.PrivateKeyPassphrase"))
2140                 connman_network_set_string(network,
2141                                                 "WiFi.PrivateKeyPassphrase",
2142                                                 ssid->passphrase);
2143         /* We must have an identity for both PEAP and TLS */
2144         ssid->identity = connman_network_get_string(network, "WiFi.Identity");
2145
2146         /* Use agent provided identity as a fallback */
2147         if (!ssid->identity || strlen(ssid->identity) == 0)
2148                 ssid->identity = connman_network_get_string(network,
2149                                                         "WiFi.AgentIdentity");
2150
2151         ssid->ca_cert_path = connman_network_get_string(network,
2152                                                         "WiFi.CACertFile");
2153         ssid->client_cert_path = connman_network_get_string(network,
2154                                                         "WiFi.ClientCertFile");
2155         ssid->private_key_path = connman_network_get_string(network,
2156                                                         "WiFi.PrivateKeyFile");
2157         ssid->private_key_passphrase = connman_network_get_string(network,
2158                                                 "WiFi.PrivateKeyPassphrase");
2159         ssid->phase2_auth = connman_network_get_string(network, "WiFi.Phase2");
2160
2161         ssid->use_wps = connman_network_get_bool(network, "WiFi.UseWPS");
2162         ssid->pin_wps = connman_network_get_string(network, "WiFi.PinWPS");
2163
2164 #if defined TIZEN_EXT
2165         ssid->bssid = connman_network_get_bssid(network);
2166 #endif
2167
2168         if (connman_setting_get_bool("BackgroundScanning"))
2169                 ssid->bgscan = BGSCAN_DEFAULT;
2170 }
2171
2172 static int network_connect(struct connman_network *network)
2173 {
2174         struct connman_device *device = connman_network_get_device(network);
2175         struct wifi_data *wifi;
2176         GSupplicantInterface *interface;
2177         GSupplicantSSID *ssid;
2178
2179         DBG("network %p", network);
2180
2181         if (!device)
2182                 return -ENODEV;
2183
2184         wifi = connman_device_get_data(device);
2185         if (!wifi)
2186                 return -ENODEV;
2187
2188         ssid = g_try_malloc0(sizeof(GSupplicantSSID));
2189         if (!ssid)
2190                 return -ENOMEM;
2191
2192         interface = wifi->interface;
2193
2194         ssid_init(ssid, network);
2195
2196 #if defined TIZEN_EXT
2197         if (wifi->interface_disconnected_network == network) {
2198                 g_free(ssid);
2199                 throw_wifi_scan(device, scan_callback);
2200
2201                 if (wifi->disconnecting != TRUE) {
2202                         wifi->scan_pending_network = network;
2203                         wifi->interface_disconnected_network = NULL;
2204                 }
2205
2206                 return -EINPROGRESS;
2207         }
2208 #endif
2209
2210         if (wifi->disconnecting) {
2211                 wifi->pending_network = network;
2212                 g_free(ssid);
2213         } else {
2214                 wifi->network = connman_network_ref(network);
2215                 wifi->retries = 0;
2216 #if defined TIZEN_EXT
2217                 wifi->interface_disconnected_network = NULL;
2218                 wifi->scan_pending_network = NULL;
2219 #endif
2220
2221                 return g_supplicant_interface_connect(interface, ssid,
2222                                                 connect_callback, network);
2223         }
2224
2225         return -EINPROGRESS;
2226 }
2227
2228 static void disconnect_callback(int result, GSupplicantInterface *interface,
2229                                                                 void *user_data)
2230 {
2231 #if defined TIZEN_EXT
2232         GList *list;
2233         struct wifi_data *wifi;
2234         struct connman_network *network = user_data;
2235
2236         DBG("network %p result %d", network, result);
2237
2238         for (list = iface_list; list; list = list->next) {
2239                 wifi = list->data;
2240
2241                 if (wifi->network == NULL && wifi->disconnecting == true)
2242                         wifi->disconnecting = false;
2243
2244                 if (wifi->network == network)
2245                         goto found;
2246         }
2247
2248         /* wifi_data may be invalid because wifi is already disabled */
2249         return;
2250
2251 found:
2252 #else
2253         struct wifi_data *wifi = user_data;
2254 #endif
2255
2256         DBG("result %d supplicant interface %p wifi %p",
2257                         result, interface, wifi);
2258
2259         if (result == -ECONNABORTED) {
2260                 DBG("wifi interface no longer available");
2261                 return;
2262         }
2263
2264         if (wifi->network) {
2265                 /*
2266                  * if result < 0 supplican return an error because
2267                  * the network is not current.
2268                  * we wont receive G_SUPPLICANT_STATE_DISCONNECTED since it
2269                  * failed, call connman_network_set_connected to report
2270                  * disconnect is completed.
2271                  */
2272                 if (result < 0)
2273                         connman_network_set_connected(wifi->network, false);
2274         }
2275
2276         wifi->network = NULL;
2277
2278         wifi->disconnecting = false;
2279
2280         if (wifi->pending_network) {
2281                 network_connect(wifi->pending_network);
2282                 wifi->pending_network = NULL;
2283         }
2284
2285         start_autoscan(wifi->device);
2286 }
2287
2288 static int network_disconnect(struct connman_network *network)
2289 {
2290         struct connman_device *device = connman_network_get_device(network);
2291         struct wifi_data *wifi;
2292         int err;
2293 #if defined TIZEN_EXT
2294         struct connman_service *service;
2295 #endif
2296
2297         DBG("network %p", network);
2298
2299         wifi = connman_device_get_data(device);
2300         if (!wifi || !wifi->interface)
2301                 return -ENODEV;
2302
2303 #if defined TIZEN_EXT
2304         if (connman_network_get_associating(network) == true) {
2305                 connman_network_clear_associating(network);
2306                 connman_network_set_bool(network, "WiFi.UseWPS", false);
2307         } else {
2308                 service = connman_service_lookup_from_network(network);
2309
2310                 if (service != NULL &&
2311                         (__connman_service_is_connected_state(service,
2312                                         CONNMAN_IPCONFIG_TYPE_IPV4) == false &&
2313                         __connman_service_is_connected_state(service,
2314                                         CONNMAN_IPCONFIG_TYPE_IPV6) == false) &&
2315                         (connman_service_get_favorite(service) == false))
2316                                         __connman_service_set_passphrase(service, NULL);
2317         }
2318
2319         if (wifi->pending_network == network)
2320                 wifi->pending_network = NULL;
2321
2322         if (wifi->scan_pending_network == network)
2323                 wifi->scan_pending_network = NULL;
2324
2325         if (wifi->interface_disconnected_network == network)
2326                 wifi->interface_disconnected_network = NULL;
2327 #endif
2328         connman_network_set_associating(network, false);
2329
2330         if (wifi->disconnecting)
2331                 return -EALREADY;
2332
2333         wifi->disconnecting = true;
2334
2335 #if defined TIZEN_EXT
2336         err = g_supplicant_interface_disconnect(wifi->interface,
2337                                                 disconnect_callback, network);
2338 #else
2339         err = g_supplicant_interface_disconnect(wifi->interface,
2340                                                 disconnect_callback, wifi);
2341 #endif
2342
2343         if (err < 0)
2344                 wifi->disconnecting = false;
2345
2346         return err;
2347 }
2348
2349 static struct connman_network_driver network_driver = {
2350         .name           = "wifi",
2351         .type           = CONNMAN_NETWORK_TYPE_WIFI,
2352         .priority       = CONNMAN_NETWORK_PRIORITY_LOW,
2353         .probe          = network_probe,
2354         .remove         = network_remove,
2355         .connect        = network_connect,
2356         .disconnect     = network_disconnect,
2357 };
2358
2359 static void interface_added(GSupplicantInterface *interface)
2360 {
2361         const char *ifname = g_supplicant_interface_get_ifname(interface);
2362         const char *driver = g_supplicant_interface_get_driver(interface);
2363         struct wifi_data *wifi;
2364
2365         wifi = g_supplicant_interface_get_data(interface);
2366         if (!wifi) {
2367                 wifi = get_pending_wifi_data(ifname);
2368                 if (!wifi)
2369                         return;
2370
2371                 g_supplicant_interface_set_data(interface, wifi);
2372                 p2p_iface_list = g_list_append(p2p_iface_list, wifi);
2373                 wifi->p2p_device = true;
2374         }
2375
2376         DBG("ifname %s driver %s wifi %p tethering %d",
2377                         ifname, driver, wifi, wifi->tethering);
2378
2379         if (!wifi->device) {
2380                 connman_error("WiFi device not set");
2381                 return;
2382         }
2383
2384         connman_device_set_powered(wifi->device, true);
2385 }
2386
2387 static bool is_idle(struct wifi_data *wifi)
2388 {
2389         DBG("state %d", wifi->state);
2390
2391         switch (wifi->state) {
2392         case G_SUPPLICANT_STATE_UNKNOWN:
2393         case G_SUPPLICANT_STATE_DISABLED:
2394         case G_SUPPLICANT_STATE_DISCONNECTED:
2395         case G_SUPPLICANT_STATE_INACTIVE:
2396         case G_SUPPLICANT_STATE_SCANNING:
2397                 return true;
2398
2399         case G_SUPPLICANT_STATE_AUTHENTICATING:
2400         case G_SUPPLICANT_STATE_ASSOCIATING:
2401         case G_SUPPLICANT_STATE_ASSOCIATED:
2402         case G_SUPPLICANT_STATE_4WAY_HANDSHAKE:
2403         case G_SUPPLICANT_STATE_GROUP_HANDSHAKE:
2404         case G_SUPPLICANT_STATE_COMPLETED:
2405                 return false;
2406         }
2407
2408         return false;
2409 }
2410
2411 static bool is_idle_wps(GSupplicantInterface *interface,
2412                                                 struct wifi_data *wifi)
2413 {
2414         /* First, let's check if WPS processing did not went wrong */
2415         if (g_supplicant_interface_get_wps_state(interface) ==
2416                 G_SUPPLICANT_WPS_STATE_FAIL)
2417                 return false;
2418
2419         /* Unlike normal connection, being associated while processing wps
2420          * actually means that we are idling. */
2421         switch (wifi->state) {
2422         case G_SUPPLICANT_STATE_UNKNOWN:
2423         case G_SUPPLICANT_STATE_DISABLED:
2424         case G_SUPPLICANT_STATE_DISCONNECTED:
2425         case G_SUPPLICANT_STATE_INACTIVE:
2426         case G_SUPPLICANT_STATE_SCANNING:
2427         case G_SUPPLICANT_STATE_ASSOCIATED:
2428                 return true;
2429         case G_SUPPLICANT_STATE_AUTHENTICATING:
2430         case G_SUPPLICANT_STATE_ASSOCIATING:
2431         case G_SUPPLICANT_STATE_4WAY_HANDSHAKE:
2432         case G_SUPPLICANT_STATE_GROUP_HANDSHAKE:
2433         case G_SUPPLICANT_STATE_COMPLETED:
2434                 return false;
2435         }
2436
2437         return false;
2438 }
2439
2440 static bool handle_wps_completion(GSupplicantInterface *interface,
2441                                         struct connman_network *network,
2442                                         struct connman_device *device,
2443                                         struct wifi_data *wifi)
2444 {
2445         bool wps;
2446
2447         wps = connman_network_get_bool(network, "WiFi.UseWPS");
2448         if (wps) {
2449                 const unsigned char *ssid, *wps_ssid;
2450                 unsigned int ssid_len, wps_ssid_len;
2451                 const char *wps_key;
2452
2453                 /* Checking if we got associated with requested
2454                  * network */
2455                 ssid = connman_network_get_blob(network, "WiFi.SSID",
2456                                                 &ssid_len);
2457
2458                 wps_ssid = g_supplicant_interface_get_wps_ssid(
2459                         interface, &wps_ssid_len);
2460
2461                 if (!wps_ssid || wps_ssid_len != ssid_len ||
2462                                 memcmp(ssid, wps_ssid, ssid_len) != 0) {
2463                         connman_network_set_associating(network, false);
2464 #if defined TIZEN_EXT
2465                         g_supplicant_interface_disconnect(wifi->interface,
2466                                                 disconnect_callback, wifi->network);
2467
2468                         connman_network_set_bool(network, "WiFi.UseWPS", false);
2469                         connman_network_set_string(network, "WiFi.PinWPS", NULL);
2470 #else
2471                         g_supplicant_interface_disconnect(wifi->interface,
2472                                                 disconnect_callback, wifi);
2473 #endif
2474                         return false;
2475                 }
2476
2477                 wps_key = g_supplicant_interface_get_wps_key(interface);
2478                 connman_network_set_string(network, "WiFi.Passphrase",
2479                                         wps_key);
2480
2481                 connman_network_set_string(network, "WiFi.PinWPS", NULL);
2482         }
2483
2484         return true;
2485 }
2486
2487 static bool handle_4way_handshake_failure(GSupplicantInterface *interface,
2488                                         struct connman_network *network,
2489                                         struct wifi_data *wifi)
2490 {
2491 #if defined TIZEN_EXT
2492         const char *security;
2493         struct connman_service *service;
2494
2495         if (wifi->connected)
2496                 return false;
2497
2498         security = connman_network_get_string(network, "WiFi.Security");
2499
2500         if (g_str_equal(security, "ieee8021x") == true &&
2501                         wifi->state == G_SUPPLICANT_STATE_ASSOCIATED) {
2502                 wifi->retries = 0;
2503                 connman_network_set_error(network, CONNMAN_NETWORK_ERROR_INVALID_KEY);
2504
2505                 return false;
2506         }
2507
2508         if (wifi->state != G_SUPPLICANT_STATE_4WAY_HANDSHAKE)
2509                 return false;
2510 #else
2511         struct connman_service *service;
2512
2513         if (wifi->state != G_SUPPLICANT_STATE_4WAY_HANDSHAKE)
2514                 return false;
2515
2516         if (wifi->connected)
2517                 return false;
2518 #endif
2519
2520         service = connman_service_lookup_from_network(network);
2521         if (!service)
2522                 return false;
2523
2524         wifi->retries++;
2525
2526         if (connman_service_get_favorite(service)) {
2527                 if (wifi->retries < FAVORITE_MAXIMUM_RETRIES)
2528                         return true;
2529         }
2530
2531         wifi->retries = 0;
2532         connman_network_set_error(network, CONNMAN_NETWORK_ERROR_INVALID_KEY);
2533
2534 #if defined TIZEN_EXT
2535         /* not retry autoconnect in case of invalid-key error */
2536         __connman_service_set_autoconnect(service, false);
2537 #endif
2538
2539         return false;
2540 }
2541
2542 #if defined TIZEN_EXT
2543 static bool handle_wifi_assoc_retry(struct connman_network *network,
2544                                         struct wifi_data *wifi)
2545 {
2546         const char *security;
2547
2548         if (!wifi->network || wifi->connected || wifi->disconnecting ||
2549                         connman_network_get_connecting(network) != true) {
2550                 wifi->assoc_retry_count = 0;
2551                 return false;
2552         }
2553
2554         if (wifi->state != G_SUPPLICANT_STATE_ASSOCIATING &&
2555                         wifi->state != G_SUPPLICANT_STATE_ASSOCIATED) {
2556                 wifi->assoc_retry_count = 0;
2557                 return false;
2558         }
2559
2560         security = connman_network_get_string(network, "WiFi.Security");
2561         if (g_str_equal(security, "ieee8021x") == true &&
2562                         wifi->state == G_SUPPLICANT_STATE_ASSOCIATED) {
2563                 wifi->assoc_retry_count = 0;
2564                 return false;
2565         }
2566
2567         if (++wifi->assoc_retry_count >= TIZEN_ASSOC_RETRY_COUNT) {
2568                 wifi->assoc_retry_count = 0;
2569
2570                 /* Honestly it's not an invalid-key error,
2571                  * however QA team recommends that the invalid-key error
2572                  * might be better to display for user experience.
2573                  */
2574                 connman_network_set_error(network, CONNMAN_NETWORK_ERROR_INVALID_KEY);
2575
2576                 return false;
2577         }
2578
2579         return true;
2580 }
2581 #endif
2582
2583 static void interface_state(GSupplicantInterface *interface)
2584 {
2585         struct connman_network *network;
2586         struct connman_device *device;
2587         struct wifi_data *wifi;
2588         GSupplicantState state = g_supplicant_interface_get_state(interface);
2589         bool wps;
2590
2591         wifi = g_supplicant_interface_get_data(interface);
2592
2593         DBG("wifi %p interface state %d", wifi, state);
2594
2595         if (!wifi)
2596                 return;
2597
2598         device = wifi->device;
2599         if (!device)
2600                 return;
2601
2602         if (g_supplicant_interface_get_ready(interface) &&
2603                                         !wifi->interface_ready) {
2604                 wifi->interface_ready = true;
2605                 finalize_interface_creation(wifi);
2606         }
2607
2608         network = wifi->network;
2609         if (!network)
2610                 return;
2611
2612         switch (state) {
2613         case G_SUPPLICANT_STATE_SCANNING:
2614                 break;
2615
2616         case G_SUPPLICANT_STATE_AUTHENTICATING:
2617         case G_SUPPLICANT_STATE_ASSOCIATING:
2618 #if defined TIZEN_EXT
2619                 reset_autoscan(device);
2620 #else
2621                 stop_autoscan(device);
2622 #endif
2623
2624                 if (!wifi->connected)
2625                         connman_network_set_associating(network, true);
2626
2627                 break;
2628
2629         case G_SUPPLICANT_STATE_COMPLETED:
2630 #if defined TIZEN_EXT
2631                 /* though it should be already reset: */
2632                 reset_autoscan(device);
2633
2634                 wifi->assoc_retry_count = 0;
2635 #else
2636                 /* though it should be already stopped: */
2637                 stop_autoscan(device);
2638 #endif
2639
2640                 if (!handle_wps_completion(interface, network, device, wifi))
2641                         break;
2642
2643                 connman_network_set_connected(network, true);
2644                 break;
2645
2646         case G_SUPPLICANT_STATE_DISCONNECTED:
2647                 /*
2648                  * If we're in one of the idle modes, we have
2649                  * not started association yet and thus setting
2650                  * those ones to FALSE could cancel an association
2651                  * in progress.
2652                  */
2653                 wps = connman_network_get_bool(network, "WiFi.UseWPS");
2654                 if (wps)
2655                         if (is_idle_wps(interface, wifi))
2656                                 break;
2657
2658                 if (is_idle(wifi))
2659                         break;
2660
2661                 /* If previous state was 4way-handshake, then
2662                  * it's either: psk was incorrect and thus we retry
2663                  * or if we reach the maximum retries we declare the
2664                  * psk as wrong */
2665                 if (handle_4way_handshake_failure(interface,
2666                                                 network, wifi))
2667                         break;
2668
2669                 /* We disable the selected network, if not then
2670                  * wpa_supplicant will loop retrying */
2671                 if (g_supplicant_interface_enable_selected_network(interface,
2672                                                 FALSE) != 0)
2673                         DBG("Could not disables selected network");
2674
2675 #if defined TIZEN_EXT
2676                 /* Some of Wi-Fi networks are not comply Wi-Fi specification.
2677                  * Retry association until its retry count is expired */
2678                 if (handle_wifi_assoc_retry(network, wifi) == true) {
2679                         throw_wifi_scan(wifi->device, scan_callback);
2680                         wifi->scan_pending_network = wifi->network;
2681                         break;
2682                 }
2683
2684                 /* To avoid unnecessary repeated association in wpa_supplicant,
2685                  * "RemoveNetwork" should be made when Wi-Fi is disconnected */
2686                 if (wps != true && wifi->network && wifi->disconnecting == false) {
2687 #if 0 /* temporary disabled */
2688                         int err;
2689
2690                         wifi->disconnecting = true;
2691                         err = g_supplicant_interface_disconnect(wifi->interface,
2692                                                         disconnect_callback, wifi->network);
2693                         if (err < 0)
2694                                 wifi->disconnecting = false;
2695 #endif
2696
2697                         if (wifi->connected)
2698                                 wifi->interface_disconnected_network = wifi->network;
2699                         else
2700                                 wifi->interface_disconnected_network = NULL;
2701
2702                 connman_network_set_connected(network, false);
2703                 connman_network_set_associating(network, false);
2704
2705                 start_autoscan(device);
2706
2707                 break;
2708                 }
2709 #endif
2710
2711                 connman_network_set_connected(network, false);
2712                 connman_network_set_associating(network, false);
2713                 wifi->disconnecting = false;
2714
2715                 start_autoscan(device);
2716
2717                 break;
2718
2719         case G_SUPPLICANT_STATE_INACTIVE:
2720 #if defined TIZEN_EXT
2721                 if (handle_wps_completion(interface, network, device, wifi) == false)
2722                         break;
2723 #endif
2724                 connman_network_set_associating(network, false);
2725                 start_autoscan(device);
2726
2727                 break;
2728
2729         case G_SUPPLICANT_STATE_UNKNOWN:
2730         case G_SUPPLICANT_STATE_DISABLED:
2731         case G_SUPPLICANT_STATE_ASSOCIATED:
2732         case G_SUPPLICANT_STATE_4WAY_HANDSHAKE:
2733         case G_SUPPLICANT_STATE_GROUP_HANDSHAKE:
2734                 break;
2735         }
2736
2737         wifi->state = state;
2738
2739         /* Saving wpa_s state policy:
2740          * If connected and if the state changes are roaming related:
2741          * --> We stay connected
2742          * If completed
2743          * --> We are connected
2744          * All other case:
2745          * --> We are not connected
2746          * */
2747         switch (state) {
2748 #if defined TIZEN_EXT
2749         case G_SUPPLICANT_STATE_SCANNING:
2750                 break;
2751 #endif
2752         case G_SUPPLICANT_STATE_AUTHENTICATING:
2753         case G_SUPPLICANT_STATE_ASSOCIATING:
2754         case G_SUPPLICANT_STATE_ASSOCIATED:
2755         case G_SUPPLICANT_STATE_4WAY_HANDSHAKE:
2756         case G_SUPPLICANT_STATE_GROUP_HANDSHAKE:
2757                 if (wifi->connected)
2758                         connman_warn("Probably roaming right now!"
2759                                                 " Staying connected...");
2760                 else
2761                         wifi->connected = false;
2762                 break;
2763         case G_SUPPLICANT_STATE_COMPLETED:
2764                 wifi->connected = true;
2765                 break;
2766         default:
2767                 wifi->connected = false;
2768                 break;
2769         }
2770
2771         DBG("DONE");
2772 }
2773
2774 static void interface_removed(GSupplicantInterface *interface)
2775 {
2776         const char *ifname = g_supplicant_interface_get_ifname(interface);
2777         struct wifi_data *wifi;
2778
2779         DBG("ifname %s", ifname);
2780
2781         wifi = g_supplicant_interface_get_data(interface);
2782
2783         if (wifi)
2784                 wifi->interface = NULL;
2785
2786         if (wifi && wifi->tethering)
2787                 return;
2788
2789         if (!wifi || !wifi->device) {
2790                 DBG("wifi interface already removed");
2791                 return;
2792         }
2793
2794         connman_device_set_powered(wifi->device, false);
2795
2796         check_p2p_technology();
2797 }
2798
2799 static void set_device_type(const char *type, char dev_type[17])
2800 {
2801         const char *oui = "0050F204";
2802         const char *category = "0100";
2803         const char *sub_category = "0000";
2804
2805         if (!g_strcmp0(type, "handset")) {
2806                 category = "0A00";
2807                 sub_category = "0500";
2808         } else if (!g_strcmp0(type, "vm") || !g_strcmp0(type, "container"))
2809                 sub_category = "0100";
2810         else if (!g_strcmp0(type, "server"))
2811                 sub_category = "0200";
2812         else if (!g_strcmp0(type, "laptop"))
2813                 sub_category = "0500";
2814         else if (!g_strcmp0(type, "desktop"))
2815                 sub_category = "0600";
2816         else if (!g_strcmp0(type, "tablet"))
2817                 sub_category = "0900";
2818         else if (!g_strcmp0(type, "watch"))
2819                 category = "FF00";
2820
2821         snprintf(dev_type, 17, "%s%s%s", category, oui, sub_category);
2822 }
2823
2824 static void p2p_support(GSupplicantInterface *interface)
2825 {
2826         char dev_type[17] = {};
2827         const char *hostname;
2828
2829         DBG("");
2830
2831         if (!g_supplicant_interface_has_p2p(interface))
2832                 return;
2833
2834         if (connman_technology_driver_register(&p2p_tech_driver) < 0) {
2835                 DBG("Could not register P2P technology driver");
2836                 return;
2837         }
2838
2839         hostname = connman_utsname_get_hostname();
2840         if (!hostname)
2841                 hostname = "ConnMan";
2842
2843         set_device_type(connman_machine_get_type(), dev_type);
2844         g_supplicant_interface_set_p2p_device_config(interface,
2845                                                         hostname, dev_type);
2846         connman_peer_driver_register(&peer_driver);
2847 }
2848
2849 static void scan_started(GSupplicantInterface *interface)
2850 {
2851         DBG("");
2852 }
2853
2854 static void scan_finished(GSupplicantInterface *interface)
2855 {
2856 #if defined TIZEN_EXT
2857         struct wifi_data *wifi;
2858 #endif
2859
2860         DBG("");
2861
2862 #if defined TIZEN_EXT
2863         wifi = g_supplicant_interface_get_data(interface);
2864         if (wifi && wifi->scan_pending_network) {
2865                 network_connect(wifi->scan_pending_network);
2866                 wifi->scan_pending_network = NULL;
2867         }
2868 #endif
2869 }
2870
2871 static unsigned char calculate_strength(GSupplicantNetwork *supplicant_network)
2872 {
2873         unsigned char strength;
2874
2875         strength = 120 + g_supplicant_network_get_signal(supplicant_network);
2876         if (strength > 100)
2877                 strength = 100;
2878
2879         return strength;
2880 }
2881
2882 static void network_added(GSupplicantNetwork *supplicant_network)
2883 {
2884         struct connman_network *network;
2885         GSupplicantInterface *interface;
2886         struct wifi_data *wifi;
2887         const char *name, *identifier, *security, *group, *mode;
2888         const unsigned char *ssid;
2889         unsigned int ssid_len;
2890         bool wps;
2891         bool wps_pbc;
2892         bool wps_ready;
2893         bool wps_advertizing;
2894
2895         mode = g_supplicant_network_get_mode(supplicant_network);
2896         identifier = g_supplicant_network_get_identifier(supplicant_network);
2897
2898         DBG("%s", identifier);
2899
2900         if (!g_strcmp0(mode, "adhoc"))
2901                 return;
2902
2903         interface = g_supplicant_network_get_interface(supplicant_network);
2904         wifi = g_supplicant_interface_get_data(interface);
2905         name = g_supplicant_network_get_name(supplicant_network);
2906         security = g_supplicant_network_get_security(supplicant_network);
2907         group = g_supplicant_network_get_identifier(supplicant_network);
2908         wps = g_supplicant_network_get_wps(supplicant_network);
2909         wps_pbc = g_supplicant_network_is_wps_pbc(supplicant_network);
2910         wps_ready = g_supplicant_network_is_wps_active(supplicant_network);
2911         wps_advertizing = g_supplicant_network_is_wps_advertizing(
2912                                                         supplicant_network);
2913
2914         if (!wifi)
2915                 return;
2916
2917         ssid = g_supplicant_network_get_ssid(supplicant_network, &ssid_len);
2918
2919         network = connman_device_get_network(wifi->device, identifier);
2920
2921         if (!network) {
2922                 network = connman_network_create(identifier,
2923                                                 CONNMAN_NETWORK_TYPE_WIFI);
2924                 if (!network)
2925                         return;
2926
2927                 connman_network_set_index(network, wifi->index);
2928
2929                 if (connman_device_add_network(wifi->device, network) < 0) {
2930                         connman_network_unref(network);
2931                         return;
2932                 }
2933
2934                 wifi->networks = g_slist_prepend(wifi->networks, network);
2935         }
2936
2937         if (name && name[0] != '\0')
2938                 connman_network_set_name(network, name);
2939
2940         connman_network_set_blob(network, "WiFi.SSID",
2941                                                 ssid, ssid_len);
2942         connman_network_set_string(network, "WiFi.Security", security);
2943         connman_network_set_strength(network,
2944                                 calculate_strength(supplicant_network));
2945         connman_network_set_bool(network, "WiFi.WPS", wps);
2946
2947         if (wps) {
2948                 /* Is AP advertizing for WPS association?
2949                  * If so, we decide to use WPS by default */
2950                 if (wps_ready && wps_pbc &&
2951                                                 wps_advertizing) {
2952 #if !defined TIZEN_EXT
2953                         connman_network_set_bool(network, "WiFi.UseWPS", true);
2954 #else
2955                         DBG("wps is activating by ap but ignore it.");
2956 #endif
2957                 }
2958         }
2959
2960         connman_network_set_frequency(network,
2961                         g_supplicant_network_get_frequency(supplicant_network));
2962 #if defined TIZEN_EXT
2963         connman_network_set_bssid(network,
2964                         g_supplicant_network_get_bssid(supplicant_network));
2965         connman_network_set_maxrate(network,
2966                         g_supplicant_network_get_maxrate(supplicant_network));
2967         connman_network_set_enc_mode(network,
2968                         g_supplicant_network_get_enc_mode(supplicant_network));
2969         connman_network_set_rsn_selected(network,
2970                         g_supplicant_network_get_rsn_selected(supplicant_network));
2971 #endif
2972         connman_network_set_available(network, true);
2973         connman_network_set_string(network, "WiFi.Mode", mode);
2974
2975 #if defined TIZEN_EXT
2976         if (group)
2977 #else
2978         if (ssid)
2979 #endif
2980                 connman_network_set_group(network, group);
2981
2982 #if defined TIZEN_EXT
2983         if (wifi_first_scan == true)
2984                 found_with_first_scan = true;
2985 #endif
2986
2987         if (wifi->hidden && ssid) {
2988                 if (!g_strcmp0(wifi->hidden->security, security) &&
2989                                 wifi->hidden->ssid_len == ssid_len &&
2990                                 !memcmp(wifi->hidden->ssid, ssid, ssid_len)) {
2991                         connman_network_connect_hidden(network,
2992                                         wifi->hidden->identity,
2993                                         wifi->hidden->passphrase,
2994                                         wifi->hidden->user_data);
2995                         wifi->hidden->user_data = NULL;
2996                         hidden_free(wifi->hidden);
2997                         wifi->hidden = NULL;
2998                 }
2999         }
3000 }
3001
3002 static void network_removed(GSupplicantNetwork *network)
3003 {
3004         GSupplicantInterface *interface;
3005         struct wifi_data *wifi;
3006         const char *name, *identifier;
3007         struct connman_network *connman_network;
3008
3009         interface = g_supplicant_network_get_interface(network);
3010         wifi = g_supplicant_interface_get_data(interface);
3011         identifier = g_supplicant_network_get_identifier(network);
3012         name = g_supplicant_network_get_name(network);
3013
3014         DBG("name %s", name);
3015
3016         if (!wifi)
3017                 return;
3018
3019         connman_network = connman_device_get_network(wifi->device, identifier);
3020         if (!connman_network)
3021                 return;
3022
3023 #if defined TIZEN_EXT
3024         if (connman_network == wifi->scan_pending_network)
3025                 wifi->scan_pending_network = NULL;
3026
3027         if (connman_network == wifi->interface_disconnected_network)
3028                 wifi->interface_disconnected_network = NULL;
3029
3030         if (connman_network == wifi->pending_network)
3031                 wifi->pending_network = NULL;
3032
3033         if(connman_network_get_connecting(connman_network) == true){
3034                 connman_network_set_connected(connman_network, false);
3035         }
3036 #endif
3037
3038         wifi->networks = g_slist_remove(wifi->networks, connman_network);
3039
3040         connman_device_remove_network(wifi->device, connman_network);
3041         connman_network_unref(connman_network);
3042 }
3043
3044 static void network_changed(GSupplicantNetwork *network, const char *property)
3045 {
3046         GSupplicantInterface *interface;
3047         struct wifi_data *wifi;
3048         const char *name, *identifier;
3049         struct connman_network *connman_network;
3050
3051 #if defined TIZEN_EXT
3052         const unsigned char *bssid;
3053         unsigned int maxrate;
3054         uint16_t frequency;
3055         bool wps;
3056 #endif
3057
3058         interface = g_supplicant_network_get_interface(network);
3059         wifi = g_supplicant_interface_get_data(interface);
3060         identifier = g_supplicant_network_get_identifier(network);
3061         name = g_supplicant_network_get_name(network);
3062
3063         DBG("name %s", name);
3064
3065         if (!wifi)
3066                 return;
3067
3068         connman_network = connman_device_get_network(wifi->device, identifier);
3069         if (!connman_network)
3070                 return;
3071
3072         if (g_str_equal(property, "Signal")) {
3073                connman_network_set_strength(connman_network,
3074                                         calculate_strength(network));
3075                connman_network_update(connman_network);
3076         }
3077
3078 #if defined TIZEN_EXT
3079         bssid = g_supplicant_network_get_bssid(network);
3080         maxrate = g_supplicant_network_get_maxrate(network);
3081         frequency = g_supplicant_network_get_frequency(network);
3082         wps = g_supplicant_network_get_wps(network);
3083
3084         connman_network_set_bssid(connman_network, bssid);
3085         connman_network_set_maxrate(connman_network, maxrate);
3086         connman_network_set_frequency(connman_network, frequency);
3087         connman_network_set_bool(connman_network, "WiFi.WPS", wps);
3088 #endif
3089 }
3090
3091 static void apply_peer_services(GSupplicantPeer *peer,
3092                                 struct connman_peer *connman_peer)
3093 {
3094         const unsigned char *data;
3095         int length;
3096
3097         DBG("");
3098
3099         connman_peer_reset_services(connman_peer);
3100
3101         data = g_supplicant_peer_get_widi_ies(peer, &length);
3102         if (data) {
3103                 connman_peer_add_service(connman_peer,
3104                         CONNMAN_PEER_SERVICE_WIFI_DISPLAY, data, length);
3105         }
3106 }
3107
3108 static void add_station(const char *mac)
3109 {
3110         connman_technology_tethering_add_station(CONNMAN_SERVICE_TYPE_WIFI,
3111                                                  mac);
3112 }
3113
3114 static void remove_station(const char *mac)
3115 {
3116         connman_technology_tethering_remove_station(mac);
3117 }
3118
3119 static void peer_found(GSupplicantPeer *peer)
3120 {
3121         GSupplicantInterface *iface = g_supplicant_peer_get_interface(peer);
3122         struct wifi_data *wifi = g_supplicant_interface_get_data(iface);
3123         struct connman_peer *connman_peer;
3124         const char *identifier, *name;
3125         int ret;
3126
3127         identifier = g_supplicant_peer_get_identifier(peer);
3128         name = g_supplicant_peer_get_name(peer);
3129
3130         DBG("ident: %s", identifier);
3131
3132         connman_peer = connman_peer_get(wifi->device, identifier);
3133         if (connman_peer)
3134                 return;
3135
3136         connman_peer = connman_peer_create(identifier);
3137         connman_peer_set_name(connman_peer, name);
3138         connman_peer_set_device(connman_peer, wifi->device);
3139         apply_peer_services(peer, connman_peer);
3140
3141         ret = connman_peer_register(connman_peer);
3142         if (ret < 0 && ret != -EALREADY)
3143                 connman_peer_unref(connman_peer);
3144 }
3145
3146 static void peer_lost(GSupplicantPeer *peer)
3147 {
3148         GSupplicantInterface *iface = g_supplicant_peer_get_interface(peer);
3149         struct wifi_data *wifi = g_supplicant_interface_get_data(iface);
3150         struct connman_peer *connman_peer;
3151         const char *identifier;
3152
3153         if (!wifi)
3154                 return;
3155
3156         identifier = g_supplicant_peer_get_identifier(peer);
3157
3158         DBG("ident: %s", identifier);
3159
3160         connman_peer = connman_peer_get(wifi->device, identifier);
3161         if (connman_peer) {
3162                 if (wifi->p2p_connecting &&
3163                                 wifi->pending_peer == connman_peer) {
3164                         peer_connect_timeout(wifi);
3165                 }
3166                 connman_peer_unregister(connman_peer);
3167                 connman_peer_unref(connman_peer);
3168         }
3169 }
3170
3171 static void peer_changed(GSupplicantPeer *peer, GSupplicantPeerState state)
3172 {
3173         GSupplicantInterface *iface = g_supplicant_peer_get_interface(peer);
3174         struct wifi_data *wifi = g_supplicant_interface_get_data(iface);
3175         enum connman_peer_state p_state = CONNMAN_PEER_STATE_UNKNOWN;
3176         struct connman_peer *connman_peer;
3177         const char *identifier;
3178
3179         identifier = g_supplicant_peer_get_identifier(peer);
3180
3181         DBG("ident: %s", identifier);
3182
3183         connman_peer = connman_peer_get(wifi->device, identifier);
3184         if (!connman_peer)
3185                 return;
3186
3187         switch (state) {
3188         case G_SUPPLICANT_PEER_SERVICES_CHANGED:
3189                 apply_peer_services(peer, connman_peer);
3190                 connman_peer_services_changed(connman_peer);
3191                 return;
3192         case G_SUPPLICANT_PEER_GROUP_CHANGED:
3193                 if (!g_supplicant_peer_is_in_a_group(peer))
3194                         p_state = CONNMAN_PEER_STATE_IDLE;
3195                 else
3196                         p_state = CONNMAN_PEER_STATE_CONFIGURATION;
3197                 break;
3198         case G_SUPPLICANT_PEER_GROUP_STARTED:
3199                 break;
3200         case G_SUPPLICANT_PEER_GROUP_FINISHED:
3201                 p_state = CONNMAN_PEER_STATE_IDLE;
3202                 break;
3203         case G_SUPPLICANT_PEER_GROUP_JOINED:
3204                 connman_peer_set_iface_address(connman_peer,
3205                                 g_supplicant_peer_get_iface_address(peer));
3206                 break;
3207         case G_SUPPLICANT_PEER_GROUP_DISCONNECTED:
3208                 p_state = CONNMAN_PEER_STATE_IDLE;
3209                 break;
3210         case G_SUPPLICANT_PEER_GROUP_FAILED:
3211                 if (g_supplicant_peer_has_requested_connection(peer))
3212                         p_state = CONNMAN_PEER_STATE_IDLE;
3213                 else
3214                         p_state = CONNMAN_PEER_STATE_FAILURE;
3215                 break;
3216         }
3217
3218         if (p_state == CONNMAN_PEER_STATE_CONFIGURATION ||
3219                                         p_state == CONNMAN_PEER_STATE_FAILURE) {
3220                 if (wifi->p2p_connecting
3221                                 && connman_peer == wifi->pending_peer)
3222                         peer_cancel_timeout(wifi);
3223                 else
3224                         p_state = CONNMAN_PEER_STATE_UNKNOWN;
3225         }
3226
3227         if (p_state == CONNMAN_PEER_STATE_UNKNOWN)
3228                 return;
3229
3230         if (p_state == CONNMAN_PEER_STATE_CONFIGURATION) {
3231                 GSupplicantInterface *g_iface;
3232                 struct wifi_data *g_wifi;
3233
3234                 g_iface = g_supplicant_peer_get_group_interface(peer);
3235                 if (!g_iface)
3236                         return;
3237
3238                 g_wifi = g_supplicant_interface_get_data(g_iface);
3239                 if (!g_wifi)
3240                         return;
3241
3242                 connman_peer_set_as_master(connman_peer,
3243                                         !g_supplicant_peer_is_client(peer));
3244                 connman_peer_set_sub_device(connman_peer, g_wifi->device);
3245         }
3246
3247         connman_peer_set_state(connman_peer, p_state);
3248 }
3249
3250 static void peer_request(GSupplicantPeer *peer)
3251 {
3252         GSupplicantInterface *iface = g_supplicant_peer_get_interface(peer);
3253         struct wifi_data *wifi = g_supplicant_interface_get_data(iface);
3254         struct connman_peer *connman_peer;
3255         const char *identifier;
3256
3257         identifier = g_supplicant_peer_get_identifier(peer);
3258
3259         DBG("ident: %s", identifier);
3260
3261         connman_peer = connman_peer_get(wifi->device, identifier);
3262         if (!connman_peer)
3263                 return;
3264
3265         connman_peer_request_connection(connman_peer);
3266 }
3267
3268 #if defined TIZEN_EXT
3269 static void system_power_off(void)
3270 {
3271         GList *list;
3272         struct wifi_data *wifi;
3273         struct connman_service *service;
3274         struct connman_ipconfig *ipconfig_ipv4;
3275
3276         if (connman_setting_get_bool("WiFiDHCPRelease") == true) {
3277                 for (list = iface_list; list; list = list->next) {
3278                         wifi = list->data;
3279
3280                         if (wifi->network != NULL) {
3281                                 service = connman_service_lookup_from_network(wifi->network);
3282                                 ipconfig_ipv4 = __connman_service_get_ip4config(service);
3283                                 __connman_dhcp_stop(ipconfig_ipv4);
3284                         }
3285                 }
3286         }
3287 }
3288
3289 static void network_merged(GSupplicantNetwork *network)
3290 {
3291         GSupplicantInterface *interface;
3292         GSupplicantState state;
3293         struct wifi_data *wifi;
3294         const char *identifier;
3295         struct connman_network *connman_network;
3296         unsigned int ishs20AP = 0;
3297         char *temp = NULL;
3298
3299         interface = g_supplicant_network_get_interface(network);
3300         if (!interface)
3301                 return;
3302
3303         state = g_supplicant_interface_get_state(interface);
3304         if (state < G_SUPPLICANT_STATE_AUTHENTICATING)
3305                 return;
3306
3307         wifi = g_supplicant_interface_get_data(interface);
3308         if (!wifi)
3309                 return;
3310
3311         identifier = g_supplicant_network_get_identifier(network);
3312
3313         connman_network = connman_device_get_network(wifi->device, identifier);
3314         if (!connman_network)
3315                 return;
3316
3317         DBG("merged identifier %s", identifier);
3318
3319         if (wifi->connected == FALSE) {
3320                 switch (state) {
3321                 case G_SUPPLICANT_STATE_AUTHENTICATING:
3322                 case G_SUPPLICANT_STATE_ASSOCIATING:
3323                 case G_SUPPLICANT_STATE_ASSOCIATED:
3324                 case G_SUPPLICANT_STATE_4WAY_HANDSHAKE:
3325                 case G_SUPPLICANT_STATE_GROUP_HANDSHAKE:
3326                         connman_network_set_associating(connman_network, TRUE);
3327                         break;
3328                 case G_SUPPLICANT_STATE_COMPLETED:
3329                         connman_network_set_connected(connman_network, TRUE);
3330                         break;
3331                 default:
3332                         DBG("Not handled the state : %d", state);
3333                         break;
3334                 }
3335         }
3336
3337         ishs20AP = g_supplicant_network_is_hs20AP(network);
3338         connman_network_set_is_hs20AP(connman_network, ishs20AP);
3339
3340         if (ishs20AP &&
3341                 g_strcmp0(g_supplicant_network_get_security(network), "ieee8021x") == 0) {
3342                 temp = g_ascii_strdown(g_supplicant_network_get_eap(network), -1);
3343                 connman_network_set_string(connman_network, "WiFi.EAP",
3344                                 temp);
3345                 connman_network_set_string(connman_network, "WiFi.Identity",
3346                                 g_supplicant_network_get_identity(network));
3347                 connman_network_set_string(connman_network, "WiFi.Phase2",
3348                                 g_supplicant_network_get_phase2(network));
3349
3350                 g_free(temp);
3351         }
3352
3353         wifi->network = connman_network;
3354 }
3355 #endif
3356
3357 static void debug(const char *str)
3358 {
3359         if (getenv("CONNMAN_SUPPLICANT_DEBUG"))
3360                 connman_debug("%s", str);
3361 }
3362
3363 static const GSupplicantCallbacks callbacks = {
3364         .system_ready           = system_ready,
3365         .system_killed          = system_killed,
3366         .interface_added        = interface_added,
3367         .interface_state        = interface_state,
3368         .interface_removed      = interface_removed,
3369         .p2p_support            = p2p_support,
3370         .scan_started           = scan_started,
3371         .scan_finished          = scan_finished,
3372         .network_added          = network_added,
3373         .network_removed        = network_removed,
3374         .network_changed        = network_changed,
3375         .add_station            = add_station,
3376         .remove_station         = remove_station,
3377         .peer_found             = peer_found,
3378         .peer_lost              = peer_lost,
3379         .peer_changed           = peer_changed,
3380         .peer_request           = peer_request,
3381 #if defined TIZEN_EXT
3382         .system_power_off       = system_power_off,
3383         .network_merged = network_merged,
3384 #endif
3385         .debug                  = debug,
3386 };
3387
3388
3389 static int tech_probe(struct connman_technology *technology)
3390 {
3391         wifi_technology = technology;
3392
3393         return 0;
3394 }
3395
3396 static void tech_remove(struct connman_technology *technology)
3397 {
3398         wifi_technology = NULL;
3399 }
3400
3401 struct wifi_tethering_info {
3402         struct wifi_data *wifi;
3403         struct connman_technology *technology;
3404         char *ifname;
3405         GSupplicantSSID *ssid;
3406 };
3407
3408 static GSupplicantSSID *ssid_ap_init(const char *ssid,
3409                 const char *passphrase, bool hidden)
3410 {
3411         GSupplicantSSID *ap;
3412
3413         ap = g_try_malloc0(sizeof(GSupplicantSSID));
3414         if (!ap)
3415                 return NULL;
3416
3417         ap->mode = G_SUPPLICANT_MODE_MASTER;
3418         ap->ssid = ssid;
3419         ap->ssid_len = strlen(ssid);
3420         ap->scan_ssid = 0;
3421         ap->freq = 2412;
3422
3423         if (!passphrase || strlen(passphrase) == 0) {
3424                 ap->security = G_SUPPLICANT_SECURITY_NONE;
3425                 ap->passphrase = NULL;
3426         } else {
3427                ap->security = G_SUPPLICANT_SECURITY_PSK;
3428                ap->protocol = G_SUPPLICANT_PROTO_RSN;
3429                ap->pairwise_cipher = G_SUPPLICANT_PAIRWISE_CCMP;
3430                ap->group_cipher = G_SUPPLICANT_GROUP_CCMP;
3431                ap->passphrase = passphrase;
3432         }
3433
3434         if (hidden)
3435                 ap->ignore_broadcast_ssid =
3436                                 G_SUPPLICANT_AP_HIDDEN_SSID_ZERO_CONTENTS;
3437         else
3438                 ap->ignore_broadcast_ssid = G_SUPPLICANT_AP_NO_SSID_HIDING;
3439
3440         return ap;
3441 }
3442
3443 static void ap_start_callback(int result, GSupplicantInterface *interface,
3444                                                         void *user_data)
3445 {
3446         struct wifi_tethering_info *info = user_data;
3447
3448         DBG("result %d index %d bridge %s",
3449                 result, info->wifi->index, info->wifi->bridge);
3450
3451         if (result < 0) {
3452                 connman_inet_remove_from_bridge(info->wifi->index,
3453                                                         info->wifi->bridge);
3454                 connman_technology_tethering_notify(info->technology, false);
3455         }
3456
3457         g_free(info->ifname);
3458         g_free(info);
3459 }
3460
3461 static void ap_create_callback(int result,
3462                                 GSupplicantInterface *interface,
3463                                         void *user_data)
3464 {
3465         struct wifi_tethering_info *info = user_data;
3466
3467         DBG("result %d ifname %s", result,
3468                                 g_supplicant_interface_get_ifname(interface));
3469
3470         if (result < 0) {
3471                 connman_inet_remove_from_bridge(info->wifi->index,
3472                                                         info->wifi->bridge);
3473                 connman_technology_tethering_notify(info->technology, false);
3474
3475                 g_free(info->ifname);
3476                 g_free(info->ssid);
3477                 g_free(info);
3478                 return;
3479         }
3480
3481         info->wifi->interface = interface;
3482         g_supplicant_interface_set_data(interface, info->wifi);
3483
3484         if (g_supplicant_interface_set_apscan(interface, 2) < 0)
3485                 connman_error("Failed to set interface ap_scan property");
3486
3487         g_supplicant_interface_connect(interface, info->ssid,
3488                                                 ap_start_callback, info);
3489 }
3490
3491 static void sta_remove_callback(int result,
3492                                 GSupplicantInterface *interface,
3493                                         void *user_data)
3494 {
3495         struct wifi_tethering_info *info = user_data;
3496         const char *driver = connman_option_get_string("wifi");
3497
3498         DBG("ifname %s result %d ", info->ifname, result);
3499
3500         if (result < 0) {
3501                 info->wifi->tethering = true;
3502
3503                 g_free(info->ifname);
3504                 g_free(info->ssid);
3505                 g_free(info);
3506                 return;
3507         }
3508
3509         info->wifi->interface = NULL;
3510
3511         connman_technology_tethering_notify(info->technology, true);
3512
3513         g_supplicant_interface_create(info->ifname, driver, info->wifi->bridge,
3514                                                 ap_create_callback,
3515                                                         info);
3516 }
3517
3518 static int tech_set_tethering(struct connman_technology *technology,
3519                                 const char *identifier, const char *passphrase,
3520                                 const char *bridge, bool enabled, bool hidden)
3521 {
3522         GList *list;
3523         GSupplicantInterface *interface;
3524         struct wifi_data *wifi;
3525         struct wifi_tethering_info *info;
3526         const char *ifname;
3527         unsigned int mode;
3528         int err;
3529
3530         DBG("");
3531
3532         if (!enabled) {
3533                 for (list = iface_list; list; list = list->next) {
3534                         wifi = list->data;
3535
3536                         if (wifi->tethering) {
3537                                 wifi->tethering = false;
3538
3539                                 connman_inet_remove_from_bridge(wifi->index,
3540                                                                         bridge);
3541                                 wifi->bridged = false;
3542                         }
3543                 }
3544
3545                 connman_technology_tethering_notify(technology, false);
3546
3547                 return 0;
3548         }
3549
3550         for (list = iface_list; list; list = list->next) {
3551                 wifi = list->data;
3552
3553                 interface = wifi->interface;
3554
3555                 if (!interface)
3556                         continue;
3557
3558                 ifname = g_supplicant_interface_get_ifname(wifi->interface);
3559
3560                 mode = g_supplicant_interface_get_mode(interface);
3561                 if ((mode & G_SUPPLICANT_CAPABILITY_MODE_AP) == 0) {
3562                         DBG("%s does not support AP mode", ifname);
3563                         continue;
3564                 }
3565
3566                 info = g_try_malloc0(sizeof(struct wifi_tethering_info));
3567                 if (!info)
3568                         return -ENOMEM;
3569
3570                 info->wifi = wifi;
3571                 info->technology = technology;
3572                 info->wifi->bridge = bridge;
3573                 info->ssid = ssid_ap_init(identifier, passphrase, hidden);
3574                 if (!info->ssid) {
3575                         g_free(info);
3576                         continue;
3577                 }
3578                 info->ifname = g_strdup(ifname);
3579                 if (!info->ifname) {
3580                         g_free(info->ssid);
3581                         g_free(info);
3582                         continue;
3583                 }
3584
3585                 info->wifi->tethering = true;
3586
3587                 err = g_supplicant_interface_remove(interface,
3588                                                 sta_remove_callback,
3589                                                         info);
3590                 if (err == 0)
3591                         return err;
3592         }
3593
3594         return -EOPNOTSUPP;
3595 }
3596
3597 static void regdom_callback(int result, const char *alpha2, void *user_data)
3598 {
3599         DBG("");
3600
3601         if (!wifi_technology)
3602                 return;
3603
3604         if (result != 0)
3605                 alpha2 = NULL;
3606
3607         connman_technology_regdom_notify(wifi_technology, alpha2);
3608 }
3609
3610 static int tech_set_regdom(struct connman_technology *technology, const char *alpha2)
3611 {
3612         return g_supplicant_set_country(alpha2, regdom_callback, NULL);
3613 }
3614
3615 static struct connman_technology_driver tech_driver = {
3616         .name           = "wifi",
3617         .type           = CONNMAN_SERVICE_TYPE_WIFI,
3618         .probe          = tech_probe,
3619         .remove         = tech_remove,
3620         .set_tethering  = tech_set_tethering,
3621         .set_regdom     = tech_set_regdom,
3622 };
3623
3624 static int wifi_init(void)
3625 {
3626         int err;
3627
3628         err = connman_network_driver_register(&network_driver);
3629         if (err < 0)
3630                 return err;
3631
3632         err = g_supplicant_register(&callbacks);
3633         if (err < 0) {
3634                 connman_network_driver_unregister(&network_driver);
3635                 return err;
3636         }
3637
3638         err = connman_technology_driver_register(&tech_driver);
3639         if (err < 0) {
3640                 g_supplicant_unregister(&callbacks);
3641                 connman_network_driver_unregister(&network_driver);
3642                 return err;
3643         }
3644
3645         return 0;
3646 }
3647
3648 static void wifi_exit(void)
3649 {
3650         DBG();
3651
3652         connman_technology_driver_unregister(&tech_driver);
3653
3654         g_supplicant_unregister(&callbacks);
3655
3656         connman_network_driver_unregister(&network_driver);
3657 }
3658
3659 CONNMAN_PLUGIN_DEFINE(wifi, "WiFi interface plugin", VERSION,
3660                 CONNMAN_PLUGIN_PRIORITY_DEFAULT, wifi_init, wifi_exit)