gsupplicant/supplicant.c

   1 /*
   2  *
   3  *  WPA supplicant library with GLib integration
   4  *
   5  *  Copyright (C) 2012-2013  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 <errno.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <stdint.h>
  31 #include <syslog.h>
  32 #include <ctype.h>
  33 #include <stdbool.h>
  34 #include <netinet/if_ether.h>
  35 #include <netinet/in.h>
  36
  37 #include <glib.h>
  38 #include <gdbus.h>
  39
  40 #include "dbus.h"
  41 #include "gsupplicant.h"
  42
  43 #define IEEE80211_CAP_ESS       0x0001
  44 #define IEEE80211_CAP_IBSS      0x0002
  45 #define IEEE80211_CAP_PRIVACY   0x0010
  46
  47 #if defined TIZEN_EXT
  48 #define WLAN_EID_HT_CAP 45
  49 #define WLAN_EID_VHT_CAP 191
  50 #define WLAN_EID_SUPP_RATES 1
  51 #define WLAN_EID_EXT_SUPP_RATES 50
  52 #define COUNTRY_CODE_LENGTH     2
  53 #define WIFI_BSSID_LEN_MAX 6
  54 #endif
  55
  56 #if defined TIZEN_EXT
  57 #define LAST_CONNECTED_TIMEOUT       (5 * 60)
  58 #define ASSOC_REJECT_TIMEOUT         10
  59 #define FREQ_RANGE_24GHZ_CHANNEL_1   2412
  60 #define FREQ_RANGE_24GHZ_CHANNEL_14  2484
  61 #define FREQ_RANGE_5GHZ_CHANNEL_32   5160
  62 #define FREQ_RANGE_5GHZ_CHANNEL_165  5825
  63
  64 #define MAC2STR(a) (a)[0], (a)[1], (a)[2], (a)[3], (a)[4], (a)[5]
  65 #define MACSTR "%02x:%02x:%02x:%02x:%02x:%02x"
  66 #endif
  67
  68 #define BSS_UNKNOWN_STRENGTH    -90
  69
  70 static DBusConnection *connection;
  71
  72 static const GSupplicantCallbacks *callbacks_pointer;
  73
  74 static dbus_bool_t system_available = FALSE;
  75 static dbus_bool_t system_ready = FALSE;
  76
  77 static dbus_int32_t debug_level;
  78 static dbus_bool_t debug_timestamp = FALSE;
  79 static dbus_bool_t debug_showkeys = FALSE;
  80
  81 static const char *debug_strings[] = {
  82         "msgdump", "debug", "info", "warning", "error", NULL
  83 };
  84
  85 static unsigned int eap_methods;
  86
  87 struct strvalmap {
  88         const char *str;
  89         unsigned int val;
  90 };
  91
  92 static struct strvalmap eap_method_map[] = {
  93         { "MD5",        G_SUPPLICANT_EAP_METHOD_MD5     },
  94         { "TLS",        G_SUPPLICANT_EAP_METHOD_TLS     },
  95         { "MSCHAPV2",   G_SUPPLICANT_EAP_METHOD_MSCHAPV2        },
  96         { "PEAP",       G_SUPPLICANT_EAP_METHOD_PEAP    },
  97         { "TTLS",       G_SUPPLICANT_EAP_METHOD_TTLS    },
  98         { "GTC",        G_SUPPLICANT_EAP_METHOD_GTC     },
  99         { "OTP",        G_SUPPLICANT_EAP_METHOD_OTP     },
 100         { "LEAP",       G_SUPPLICANT_EAP_METHOD_LEAP    },
 101         { "WSC",        G_SUPPLICANT_EAP_METHOD_WSC     },
 102         { }
 103 };
 104
 105 static struct strvalmap keymgmt_map[] = {
 106         { "none",               G_SUPPLICANT_KEYMGMT_NONE               },
 107         { "ieee8021x",          G_SUPPLICANT_KEYMGMT_IEEE8021X  },
 108         { "wpa-none",           G_SUPPLICANT_KEYMGMT_WPA_NONE   },
 109         { "wpa-psk",            G_SUPPLICANT_KEYMGMT_WPA_PSK    },
 110         { "wpa-psk-sha256",     G_SUPPLICANT_KEYMGMT_WPA_PSK_256        },
 111         { "wpa-ft-psk",         G_SUPPLICANT_KEYMGMT_WPA_FT_PSK },
 112         { "wpa-ft-eap",         G_SUPPLICANT_KEYMGMT_WPA_FT_EAP },
 113         { "wpa-eap",            G_SUPPLICANT_KEYMGMT_WPA_EAP    },
 114         { "wpa-eap-sha256",     G_SUPPLICANT_KEYMGMT_WPA_EAP_256        },
 115         { "wps",                G_SUPPLICANT_KEYMGMT_WPS                },
 116 #if defined TIZEN_EXT
 117         { "sae",                G_SUPPLICANT_KEYMGMT_SAE                },
 118         { "owe",                G_SUPPLICANT_KEYMGMT_OWE                },
 119         { "dpp",                G_SUPPLICANT_KEYMGMT_DPP                },
 120 #endif
 121         { }
 122 };
 123
 124 static struct strvalmap authalg_capa_map[] = {
 125         { "open",       G_SUPPLICANT_CAPABILITY_AUTHALG_OPEN    },
 126         { "shared",     G_SUPPLICANT_CAPABILITY_AUTHALG_SHARED  },
 127         { "leap",       G_SUPPLICANT_CAPABILITY_AUTHALG_LEAP    },
 128         { }
 129 };
 130
 131 static struct strvalmap proto_capa_map[] = {
 132         { "wpa",        G_SUPPLICANT_CAPABILITY_PROTO_WPA               },
 133         { "rsn",        G_SUPPLICANT_CAPABILITY_PROTO_RSN               },
 134         { }
 135 };
 136
 137 static struct strvalmap group_map[] = {
 138         { "wep40",      G_SUPPLICANT_GROUP_WEP40        },
 139         { "wep104",     G_SUPPLICANT_GROUP_WEP104       },
 140         { "tkip",       G_SUPPLICANT_GROUP_TKIP },
 141         { "ccmp",       G_SUPPLICANT_GROUP_CCMP },
 142         { }
 143 };
 144
 145 static struct strvalmap pairwise_map[] = {
 146         { "none",       G_SUPPLICANT_PAIRWISE_NONE      },
 147         { "tkip",       G_SUPPLICANT_PAIRWISE_TKIP      },
 148         { "ccmp",       G_SUPPLICANT_PAIRWISE_CCMP      },
 149         { }
 150 };
 151
 152 static struct strvalmap scan_capa_map[] = {
 153         { "active",     G_SUPPLICANT_CAPABILITY_SCAN_ACTIVE     },
 154         { "passive",    G_SUPPLICANT_CAPABILITY_SCAN_PASSIVE    },
 155         { "ssid",       G_SUPPLICANT_CAPABILITY_SCAN_SSID               },
 156         { }
 157 };
 158
 159 static struct strvalmap mode_capa_map[] = {
 160         { "infrastructure",     G_SUPPLICANT_CAPABILITY_MODE_INFRA      },
 161         { "ad-hoc",             G_SUPPLICANT_CAPABILITY_MODE_IBSS       },
 162         { "ap",                 G_SUPPLICANT_CAPABILITY_MODE_AP         },
 163         { "p2p",                G_SUPPLICANT_CAPABILITY_MODE_P2P        },
 164 #if defined TIZEN_EXT_WIFI_MESH
 165         { "mesh",               G_SUPPLICANT_CAPABILITY_MODE_MESH       },
 166 #endif
 167         { }
 168 };
 169
 170 #if defined TIZEN_EXT
 171 struct _GSupplicantINSSettings {
 172         GSupplicantINSPreferredFreq preferred_freq_bssid;
 173         unsigned int preferred_freq_bssid_score;
 174         bool last_connected_bssid;
 175         unsigned int last_connected_bssid_score;
 176         bool assoc_reject;
 177         unsigned int assoc_reject_score;
 178         bool signal_bssid;
 179         int signal_level3_5ghz;
 180         int signal_level3_24ghz;
 181 };
 182
 183 static struct _GSupplicantINSSettings ins_settings;
 184
 185 static unsigned char invalid_bssid[WIFI_BSSID_LEN_MAX] = {
 186         0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 187 };
 188 #endif
 189
 190 static GHashTable *interface_table;
 191 static GHashTable *bss_mapping;
 192 static GHashTable *peer_mapping;
 193 static GHashTable *group_mapping;
 194 static GHashTable *pending_peer_connection;
 195 static GHashTable *config_file_table;
 196
 197 struct _GSupplicantWpsCredentials {
 198         unsigned char ssid[32];
 199         unsigned int ssid_len;
 200         char *key;
 201 };
 202
 203 struct added_network_information {
 204         char * ssid;
 205         GSupplicantSecurity security;
 206         char * passphrase;
 207         char * private_passphrase;
 208 #if defined TIZEN_EXT
 209         char *connector;
 210         char *c_sign_key;
 211         char *net_access_key;
 212 #endif
 213 };
 214
 215 #if defined TIZEN_EXT_WIFI_MESH
 216 struct _GSupplicantMeshGroupInfo {
 217         unsigned char ssid[32];
 218         unsigned int ssid_len;
 219         int disconnect_reason;
 220 };
 221 #endif
 222
 223 struct _GSupplicantInterface {
 224         char *path;
 225         char *network_path;
 226         unsigned int keymgmt_capa;
 227         unsigned int authalg_capa;
 228         unsigned int proto_capa;
 229         unsigned int group_capa;
 230         unsigned int pairwise_capa;
 231         unsigned int scan_capa;
 232         unsigned int mode_capa;
 233         unsigned int max_scan_ssids;
 234         bool p2p_support;
 235         bool p2p_finding;
 236         bool ap_create_in_progress;
 237         dbus_bool_t ready;
 238         GSupplicantState state;
 239         dbus_bool_t scanning;
 240         GSupplicantInterfaceCallback scan_callback;
 241         void *scan_data;
 242         int apscan;
 243         char *ifname;
 244         char *driver;
 245         char *bridge;
 246         struct _GSupplicantWpsCredentials wps_cred;
 247         GSupplicantWpsState wps_state;
 248         GHashTable *network_table;
 249         GHashTable *peer_table;
 250         GHashTable *group_table;
 251         GHashTable *bss_mapping;
 252         void *data;
 253         const char *pending_peer_path;
 254         GSupplicantNetwork *current_network;
 255         struct added_network_information network_info;
 256 #if defined TIZEN_EXT
 257         dbus_bool_t is_5_0_Ghz_supported;
 258         int disconnect_reason;
 259 #endif
 260 #if defined TIZEN_EXT
 261         unsigned char add_network_bssid[WIFI_BSSID_LEN_MAX];
 262         unsigned char connected_bssid[WIFI_BSSID_LEN_MAX];
 263 #endif
 264 #if defined TIZEN_EXT_WIFI_MESH
 265         bool mesh_support;
 266         struct _GSupplicantMeshGroupInfo group_info;
 267 #endif
 268 };
 269
 270 struct g_supplicant_bss {
 271         GSupplicantInterface *interface;
 272         char *path;
 273         unsigned char bssid[6];
 274         unsigned char ssid[32];
 275         unsigned int ssid_len;
 276         dbus_uint16_t frequency;
 277         dbus_uint32_t maxrate;
 278         dbus_int16_t signal;
 279         GSupplicantMode mode;
 280         GSupplicantSecurity security;
 281         dbus_bool_t rsn_selected;
 282         unsigned int wpa_keymgmt;
 283         unsigned int wpa_pairwise;
 284         unsigned int wpa_group;
 285         unsigned int rsn_keymgmt;
 286         unsigned int rsn_pairwise;
 287         unsigned int rsn_group;
 288         unsigned int keymgmt;
 289         dbus_bool_t privacy;
 290         dbus_bool_t psk;
 291         dbus_bool_t ieee8021x;
 292 #if defined TIZEN_EXT
 293         dbus_bool_t ft_psk;
 294         dbus_bool_t ft_ieee8021x;
 295         GSList *vsie_list;
 296         dbus_bool_t hs20;
 297         unsigned char country_code[COUNTRY_CODE_LENGTH];
 298         GSupplicantPhy_mode phy_mode;
 299 #endif
 300         unsigned int wps_capabilities;
 301 #if defined TIZEN_EXT
 302         dbus_bool_t sae;
 303         dbus_bool_t owe;
 304         dbus_bool_t dpp;
 305 #endif
 306 };
 307
 308 struct _GSupplicantNetwork {
 309         GSupplicantInterface *interface;
 310         char *path;
 311         char *group;
 312         char *name;
 313         unsigned char ssid[32];
 314         unsigned int ssid_len;
 315         dbus_int16_t signal;
 316         dbus_uint16_t frequency;
 317         struct g_supplicant_bss *best_bss;
 318         GSupplicantMode mode;
 319         GSupplicantSecurity security;
 320         dbus_bool_t wps;
 321         unsigned int wps_capabilities;
 322         GHashTable *bss_table;
 323         GHashTable *config_table;
 324 #if defined TIZEN_EXT
 325         bool isHS20AP;
 326         char *eap;
 327         char *identity;
 328         char *phase2;
 329         unsigned int keymgmt;
 330         GSList *vsie_list;
 331         unsigned char country_code[COUNTRY_CODE_LENGTH];
 332         GSupplicantPhy_mode phy_mode;
 333 #endif
 334 #if defined TIZEN_EXT
 335         unsigned char last_connected_bssid[WIFI_BSSID_LEN_MAX];
 336         GHashTable *assoc_reject_table;
 337 #endif
 338 };
 339
 340 struct _GSupplicantPeer {
 341         GSupplicantInterface *interface;
 342         char *path;
 343         unsigned char device_address[ETH_ALEN];
 344         unsigned char iface_address[ETH_ALEN];
 345         char *name;
 346         unsigned char *widi_ies;
 347         int widi_ies_length;
 348         char *identifier;
 349         unsigned int wps_capabilities;
 350         GSList *groups;
 351         const GSupplicantInterface *current_group_iface;
 352         bool connection_requested;
 353 };
 354
 355 struct _GSupplicantGroup {
 356         GSupplicantInterface *interface;
 357         GSupplicantInterface *orig_interface;
 358         char *path;
 359         int role;
 360         GSList *members;
 361 };
 362
 363 struct interface_data {
 364         GSupplicantInterface *interface;
 365         char *path; /* Interface path cannot be taken from interface (above) as
 366                      * it might have been freed already.
 367                      */
 368         GSupplicantInterfaceCallback callback;
 369         void *user_data;
 370         bool network_remove_in_progress;
 371         GSupplicantSSID *ssid;
 372 };
 373
 374 #if defined TIZEN_EXT
 375 struct interface_signalpoll_data {
 376         GSupplicantInterface *interface;
 377         char *path;
 378         GSupplicantMaxSpeedCallback callback;
 379         void *user_data;
 380 };
 381 #endif
 382
 383 struct interface_create_data {
 384         char *ifname;
 385         char *driver;
 386         char *bridge;
 387 #if defined TIZEN_EXT_WIFI_MESH
 388         char *parent_ifname;
 389         bool is_mesh_interface;
 390 #endif
 391         GSupplicantInterface *interface;
 392         GSupplicantInterfaceCallback callback;
 393         void *user_data;
 394 };
 395
 396 struct interface_connect_data {
 397         GSupplicantInterface *interface;
 398         char *path;
 399         GSupplicantInterfaceCallback callback;
 400         void *user_data;
 401         union {
 402                 GSupplicantSSID *ssid;
 403                 GSupplicantPeerParams *peer;
 404         };
 405 };
 406
 407 struct interface_scan_data {
 408         GSupplicantInterface *interface;
 409         char *path;
 410         GSupplicantInterfaceCallback callback;
 411         GSupplicantScanParams *scan_params;
 412         void *user_data;
 413 };
 414
 415 #if defined TIZEN_EXT
 416 struct g_connman_bssids {
 417         unsigned char bssid[WIFI_BSSID_LEN_MAX];
 418         uint16_t strength;
 419         uint16_t frequency;
 420         uint16_t assoc_reject_cnt;
 421         bool is_last_connected;
 422 #if defined TIZEN_EXT_INS
 423         int score_last_connected_bssid;
 424         int score_assoc_reject;
 425         int score_frequency;
 426         int score_strength;
 427 #endif
 428         int ins_score;
 429 };
 430
 431 struct update_bssid_data {
 432         GSupplicantNetwork *network;
 433         unsigned char last_connected_bssid[WIFI_BSSID_LEN_MAX];
 434         GHashTable *assoc_reject_table;
 435         GSList *bssid_list;
 436 };
 437
 438 struct assoc_reject_data {
 439         char *bssid;
 440         GSList *reject_time_list;
 441 };
 442
 443 struct assoc_count_data {
 444         time_t ref_time;
 445         int assoc_count;
 446 };
 447
 448 static unsigned int last_connected_bss_timeout = 0;
 449 #endif
 450
 451 static int network_remove(struct interface_data *data);
 452
 453 #if defined TIZEN_EXT_WIFI_MESH
 454 struct _GSupplicantMeshPeer {
 455         GSupplicantInterface *interface;
 456         char *peer_address;
 457         int disconnect_reason;
 458 };
 459 #endif
 460
 461 static inline void debug(const char *format, ...)
 462 {
 463         char str[256];
 464         va_list ap;
 465
 466         if (!callbacks_pointer || !callbacks_pointer->debug)
 467                 return;
 468
 469         va_start(ap, format);
 470
 471         if (vsnprintf(str, sizeof(str), format, ap) > 0)
 472                 callbacks_pointer->debug(str);
 473
 474         va_end(ap);
 475 }
 476
 477 #define SUPPLICANT_DBG(fmt, arg...) \
 478         debug("%s:%s() " fmt, __FILE__, __FUNCTION__ , ## arg);
 479
 480 static GSupplicantMode string2mode(const char *mode)
 481 {
 482         if (!mode)
 483                 return G_SUPPLICANT_MODE_UNKNOWN;
 484
 485         if (g_str_equal(mode, "infrastructure"))
 486                 return G_SUPPLICANT_MODE_INFRA;
 487         else if (g_str_equal(mode, "ad-hoc"))
 488                 return G_SUPPLICANT_MODE_IBSS;
 489 #if defined TIZEN_EXT_WIFI_MESH
 490         else if (g_str_equal(mode, "mesh"))
 491                 return G_SUPPLICANT_MODE_MESH;
 492 #endif
 493
 494         return G_SUPPLICANT_MODE_UNKNOWN;
 495 }
 496
 497 static const char *mode2string(GSupplicantMode mode)
 498 {
 499         switch (mode) {
 500         case G_SUPPLICANT_MODE_UNKNOWN:
 501                 break;
 502         case G_SUPPLICANT_MODE_INFRA:
 503                 return "managed";
 504         case G_SUPPLICANT_MODE_IBSS:
 505                 return "adhoc";
 506         case G_SUPPLICANT_MODE_MASTER:
 507                 return "ap";
 508 #if defined TIZEN_EXT_WIFI_MESH
 509         case G_SUPPLICANT_MODE_MESH:
 510                 return "mesh";
 511 #endif
 512         }
 513
 514         return NULL;
 515 }
 516
 517 static const char *security2string(GSupplicantSecurity security)
 518 {
 519         switch (security) {
 520         case G_SUPPLICANT_SECURITY_UNKNOWN:
 521                 break;
 522         case G_SUPPLICANT_SECURITY_NONE:
 523                 return "none";
 524         case G_SUPPLICANT_SECURITY_WEP:
 525                 return "wep";
 526         case G_SUPPLICANT_SECURITY_PSK:
 527                 return "psk";
 528         case G_SUPPLICANT_SECURITY_IEEE8021X:
 529                 return "ieee8021x";
 530 #if defined TIZEN_EXT
 531         case G_SUPPLICANT_SECURITY_FT_PSK:
 532                 return "ft_psk";
 533         case G_SUPPLICANT_SECURITY_FT_IEEE8021X:
 534                 return "ft_ieee8021x";
 535         case G_SUPPLICANT_SECURITY_SAE:
 536                 return "sae";
 537         case G_SUPPLICANT_SECURITY_OWE:
 538                 return "owe";
 539         case G_SUPPLICANT_SECURITY_DPP:
 540                 return "dpp";
 541 #endif
 542         }
 543
 544         return NULL;
 545 }
 546
 547 static GSupplicantState string2state(const char *state)
 548 {
 549         if (!state)
 550                 return G_SUPPLICANT_STATE_UNKNOWN;
 551
 552         if (g_str_equal(state, "unknown"))
 553                 return G_SUPPLICANT_STATE_UNKNOWN;
 554         else if (g_str_equal(state, "interface_disabled"))
 555                 return G_SUPPLICANT_STATE_DISABLED;
 556         else if (g_str_equal(state, "disconnected"))
 557                 return G_SUPPLICANT_STATE_DISCONNECTED;
 558         else if (g_str_equal(state, "inactive"))
 559                 return G_SUPPLICANT_STATE_INACTIVE;
 560         else if (g_str_equal(state, "scanning"))
 561                 return G_SUPPLICANT_STATE_SCANNING;
 562         else if (g_str_equal(state, "authenticating"))
 563                 return G_SUPPLICANT_STATE_AUTHENTICATING;
 564         else if (g_str_equal(state, "associating"))
 565                 return G_SUPPLICANT_STATE_ASSOCIATING;
 566         else if (g_str_equal(state, "associated"))
 567                 return G_SUPPLICANT_STATE_ASSOCIATED;
 568         else if (g_str_equal(state, "group_handshake"))
 569                 return G_SUPPLICANT_STATE_GROUP_HANDSHAKE;
 570         else if (g_str_equal(state, "4way_handshake"))
 571                 return G_SUPPLICANT_STATE_4WAY_HANDSHAKE;
 572         else if (g_str_equal(state, "completed"))
 573                 return G_SUPPLICANT_STATE_COMPLETED;
 574
 575         return G_SUPPLICANT_STATE_UNKNOWN;
 576 }
 577
 578 static bool compare_network_parameters(GSupplicantInterface *interface,
 579                                 GSupplicantSSID *ssid)
 580 {
 581 #if defined TIZEN_EXT
 582         if (!interface->network_info.ssid)
 583                 return FALSE;
 584 #endif
 585
 586         if (memcmp(interface->network_info.ssid, ssid->ssid, ssid->ssid_len))
 587                 return FALSE;
 588
 589         if (interface->network_info.security != ssid->security)
 590                 return FALSE;
 591
 592         if (interface->network_info.passphrase &&
 593                         g_strcmp0(interface->network_info.passphrase,
 594                                 ssid->passphrase) != 0) {
 595                 return FALSE;
 596         }
 597
 598         if (interface->network_info.private_passphrase &&
 599                         g_strcmp0(interface->network_info.private_passphrase,
 600                                 ssid->private_key_passphrase) != 0) {
 601                 return FALSE;
 602         }
 603
 604 #if defined TIZEN_EXT
 605         if (interface->network_info.connector &&
 606                         g_strcmp0(interface->network_info.connector,
 607                                 ssid->connector) != 0) {
 608                 return FALSE;
 609         }
 610         if (interface->network_info.c_sign_key &&
 611                         g_strcmp0(interface->network_info.c_sign_key,
 612                                 ssid->c_sign_key) != 0) {
 613                 return FALSE;
 614         }
 615         if (interface->network_info.net_access_key &&
 616                         g_strcmp0(interface->network_info.net_access_key,
 617                                 ssid->net_access_key) != 0) {
 618                 return FALSE;
 619         }
 620 #endif
 621         return TRUE;
 622 }
 623
 624 static void remove_network_information(GSupplicantInterface * interface)
 625 {
 626         g_free(interface->network_info.ssid);
 627         g_free(interface->network_info.passphrase);
 628         g_free(interface->network_info.private_passphrase);
 629 #if defined TIZEN_EXT
 630         g_free(interface->network_info.connector);
 631         g_free(interface->network_info.c_sign_key);
 632         g_free(interface->network_info.net_access_key);
 633 #endif
 634         interface->network_info.ssid = NULL;
 635         interface->network_info.passphrase = NULL;
 636         interface->network_info.private_passphrase = NULL;
 637 #if defined TIZEN_EXT
 638         interface->network_info.connector = NULL;
 639         interface->network_info.c_sign_key = NULL;
 640         interface->network_info.net_access_key = NULL;
 641 #endif
 642 }
 643
 644 static int store_network_information(GSupplicantInterface * interface,
 645                                 GSupplicantSSID *ssid)
 646 {
 647         interface->network_info.ssid = g_malloc(ssid->ssid_len + 1);
 648         if (interface->network_info.ssid != NULL) {
 649                 memcpy(interface->network_info.ssid, ssid->ssid,
 650                         ssid->ssid_len);
 651                 interface->network_info.ssid[ssid->ssid_len] = '\0';
 652         } else {
 653                 return -ENOMEM;
 654         }
 655
 656         interface->network_info.security = ssid->security;
 657
 658         if ((ssid->security == G_SUPPLICANT_SECURITY_WEP ||
 659                 ssid->security == G_SUPPLICANT_SECURITY_PSK ||
 660                 ssid->security == G_SUPPLICANT_SECURITY_NONE) &&
 661                 ssid->passphrase) {
 662                 interface->network_info.passphrase = g_strdup(ssid->passphrase);
 663         }
 664
 665         if (ssid->security == G_SUPPLICANT_SECURITY_IEEE8021X &&
 666                         ssid->private_key_passphrase) {
 667                 interface->network_info.private_passphrase =
 668                         g_strdup(ssid->private_key_passphrase);
 669         }
 670
 671         return 0;
 672 }
 673
 674 static void callback_system_ready(void)
 675 {
 676         if (system_ready)
 677                 return;
 678
 679         system_ready = TRUE;
 680
 681         if (!callbacks_pointer)
 682                 return;
 683
 684         if (!callbacks_pointer->system_ready)
 685                 return;
 686
 687         callbacks_pointer->system_ready();
 688 }
 689
 690 static void callback_system_killed(void)
 691 {
 692         system_ready = FALSE;
 693
 694         if (!callbacks_pointer)
 695                 return;
 696
 697         if (!callbacks_pointer->system_killed)
 698                 return;
 699
 700         callbacks_pointer->system_killed();
 701 }
 702
 703 static void callback_interface_added(GSupplicantInterface *interface)
 704 {
 705         SUPPLICANT_DBG("");
 706
 707         if (!callbacks_pointer)
 708                 return;
 709
 710         if (!callbacks_pointer->interface_added)
 711                 return;
 712
 713         callbacks_pointer->interface_added(interface);
 714 }
 715
 716 static void callback_interface_state(GSupplicantInterface *interface)
 717 {
 718         if (!callbacks_pointer)
 719                 return;
 720
 721         if (!callbacks_pointer->interface_state)
 722                 return;
 723
 724         callbacks_pointer->interface_state(interface);
 725 }
 726
 727 static void callback_interface_removed(GSupplicantInterface *interface)
 728 {
 729         if (!callbacks_pointer)
 730                 return;
 731
 732         if (!callbacks_pointer->interface_removed)
 733                 return;
 734
 735         callbacks_pointer->interface_removed(interface);
 736 }
 737
 738 #if !defined TIZEN_EXT
 739 static void callback_p2p_support(GSupplicantInterface *interface)
 740 {
 741         SUPPLICANT_DBG("");
 742
 743         if (!interface->p2p_support)
 744                 return;
 745
 746         if (callbacks_pointer && callbacks_pointer->p2p_support)
 747                 callbacks_pointer->p2p_support(interface);
 748 }
 749 #endif
 750
 751 #if defined TIZEN_EXT_WIFI_MESH
 752 static void callback_mesh_support(GSupplicantInterface *interface)
 753 {
 754         SUPPLICANT_DBG("");
 755
 756         if (!interface->mesh_support)
 757                 return;
 758
 759         if (callbacks_pointer && callbacks_pointer->mesh_support)
 760                 callbacks_pointer->mesh_support(interface);
 761 }
 762
 763 bool g_supplicant_interface_has_mesh(GSupplicantInterface *interface)
 764 {
 765         if (!interface)
 766                 return false;
 767
 768         return interface->mesh_support;
 769 }
 770 #endif
 771
 772 static void callback_scan_started(GSupplicantInterface *interface)
 773 {
 774         if (!callbacks_pointer)
 775                 return;
 776
 777         if (!callbacks_pointer->scan_started)
 778                 return;
 779
 780         callbacks_pointer->scan_started(interface);
 781 }
 782
 783 static void callback_ap_create_fail(GSupplicantInterface *interface)
 784 {
 785         if (!callbacks_pointer)
 786                 return;
 787
 788         if (!callbacks_pointer->ap_create_fail)
 789                 return;
 790
 791         callbacks_pointer->ap_create_fail(interface);
 792 }
 793
 794 static void callback_scan_finished(GSupplicantInterface *interface)
 795 {
 796         if (!callbacks_pointer)
 797                 return;
 798
 799         if (!callbacks_pointer->scan_finished)
 800                 return;
 801
 802         callbacks_pointer->scan_finished(interface);
 803 }
 804
 805 static void callback_network_added(GSupplicantNetwork *network)
 806 {
 807         if (!callbacks_pointer)
 808                 return;
 809
 810         if (!callbacks_pointer->network_added)
 811                 return;
 812
 813         callbacks_pointer->network_added(network);
 814 }
 815
 816 static void callback_network_removed(GSupplicantNetwork *network)
 817 {
 818         if (!callbacks_pointer)
 819                 return;
 820
 821         if (!callbacks_pointer->network_removed)
 822                 return;
 823
 824         callbacks_pointer->network_removed(network);
 825 }
 826
 827 #if defined TIZEN_EXT
 828 static void callback_network_merged(GSupplicantNetwork *network)
 829 {
 830         if (!callbacks_pointer)
 831                 return;
 832
 833         if (!callbacks_pointer->network_merged)
 834                 return;
 835
 836         callbacks_pointer->network_merged(network);
 837 }
 838
 839 static void callback_assoc_failed(void *user_data)
 840 {
 841         if (!callbacks_pointer)
 842                 return;
 843
 844         if (!callbacks_pointer->assoc_failed)
 845                 return;
 846
 847         callbacks_pointer->assoc_failed(user_data);
 848 }
 849
 850 static void callback_scan_done(GSupplicantInterface *interface)
 851 {
 852         if (!callbacks_pointer)
 853                 return;
 854
 855         if (!callbacks_pointer->scan_done)
 856                 return;
 857
 858         callbacks_pointer->scan_done(interface);
 859 }
 860 #endif
 861
 862 static void callback_network_changed(GSupplicantNetwork *network,
 863                                         const char *property)
 864 {
 865         if (!callbacks_pointer)
 866                 return;
 867
 868         if (!callbacks_pointer->network_changed)
 869                 return;
 870
 871         callbacks_pointer->network_changed(network, property);
 872 }
 873
 874 static void callback_network_associated(GSupplicantNetwork *network)
 875 {
 876         if (!callbacks_pointer)
 877                 return;
 878
 879         if (!callbacks_pointer->network_associated)
 880                 return;
 881
 882         callbacks_pointer->network_associated(network);
 883 }
 884
 885 static void callback_sta_authorized(GSupplicantInterface *interface,
 886                                         const char *addr)
 887 {
 888         if (!callbacks_pointer)
 889                 return;
 890
 891         if (!callbacks_pointer->sta_authorized)
 892                 return;
 893
 894         callbacks_pointer->sta_authorized(interface, addr);
 895 }
 896
 897 static void callback_sta_deauthorized(GSupplicantInterface *interface,
 898                                         const char *addr)
 899 {
 900         if (!callbacks_pointer)
 901                 return;
 902
 903         if (!callbacks_pointer->sta_deauthorized)
 904                 return;
 905
 906         callbacks_pointer->sta_deauthorized(interface, addr);
 907 }
 908
 909 static void callback_peer_found(GSupplicantPeer *peer)
 910 {
 911         if (!callbacks_pointer)
 912                 return;
 913
 914         if (!callbacks_pointer->peer_found)
 915                 return;
 916
 917         callbacks_pointer->peer_found(peer);
 918 }
 919
 920 static void callback_peer_lost(GSupplicantPeer *peer)
 921 {
 922         if (!callbacks_pointer)
 923                 return;
 924
 925         if (!callbacks_pointer->peer_lost)
 926                 return;
 927
 928         callbacks_pointer->peer_lost(peer);
 929 }
 930
 931 static void callback_peer_changed(GSupplicantPeer *peer,
 932                                                 GSupplicantPeerState state)
 933 {
 934         if (!callbacks_pointer)
 935                 return;
 936
 937         if (!callbacks_pointer->peer_changed)
 938                 return;
 939
 940         callbacks_pointer->peer_changed(peer, state);
 941 }
 942
 943 static void callback_peer_request(GSupplicantPeer *peer)
 944 {
 945         if (!callbacks_pointer)
 946                 return;
 947
 948         if (!callbacks_pointer->peer_request)
 949                 return;
 950
 951         peer->connection_requested = true;
 952
 953         callbacks_pointer->peer_request(peer);
 954 }
 955
 956 static void callback_disconnect_reason_code(GSupplicantInterface *interface,
 957                                         int reason_code)
 958 {
 959         if (!callbacks_pointer)
 960                 return;
 961
 962         if (!callbacks_pointer->disconnect_reasoncode)
 963                 return;
 964
 965         if (reason_code != 0)
 966                 callbacks_pointer->disconnect_reasoncode(interface,
 967                                                         reason_code);
 968 }
 969
 970 static void callback_assoc_status_code(GSupplicantInterface *interface,
 971                                 int status_code)
 972 {
 973         if (!callbacks_pointer)
 974                 return;
 975
 976         if (!callbacks_pointer->assoc_status_code)
 977                 return;
 978
 979         callbacks_pointer->assoc_status_code(interface, status_code);
 980
 981 }
 982
 983 static void remove_group(gpointer data)
 984 {
 985         GSupplicantGroup *group = data;
 986
 987         if (group->members)
 988                 g_slist_free_full(group->members, g_free);
 989
 990         g_free(group->path);
 991         g_free(group);
 992 }
 993
 994 static void remove_interface(gpointer data)
 995 {
 996         GSupplicantInterface *interface = data;
 997
 998         g_hash_table_destroy(interface->bss_mapping);
 999         g_hash_table_destroy(interface->network_table);
1000         g_hash_table_destroy(interface->peer_table);
1001         g_hash_table_destroy(interface->group_table);
1002
1003         if (interface->scan_callback) {
1004                 SUPPLICANT_DBG("call interface %p callback %p scanning %d",
1005                                 interface, interface->scan_callback,
1006                                 interface->scanning);
1007
1008                 interface->scan_callback(-EIO, interface, interface->scan_data);
1009                 interface->scan_callback = NULL;
1010                 interface->scan_data = NULL;
1011
1012                 if (interface->scanning) {
1013                         interface->scanning = FALSE;
1014                         callback_scan_finished(interface);
1015                 }
1016         }
1017
1018         callback_interface_removed(interface);
1019
1020         g_free(interface->wps_cred.key);
1021         g_free(interface->path);
1022         g_free(interface->network_path);
1023 #if defined TIZEN_EXT
1024         interface->network_path = NULL;
1025 #endif
1026         g_free(interface->ifname);
1027         g_free(interface->driver);
1028         g_free(interface->bridge);
1029         remove_network_information(interface);
1030         g_free(interface);
1031 }
1032
1033 static void remove_network(gpointer data)
1034 {
1035         GSupplicantNetwork *network = data;
1036
1037         g_hash_table_destroy(network->bss_table);
1038
1039         callback_network_removed(network);
1040
1041         g_hash_table_destroy(network->config_table);
1042 #if defined TIZEN_EXT
1043         g_hash_table_destroy(network->assoc_reject_table);
1044 #endif
1045
1046         g_free(network->path);
1047         g_free(network->group);
1048         g_free(network->name);
1049 #if defined TIZEN_EXT
1050         g_free(network->eap);
1051         g_free(network->identity);
1052         g_free(network->phase2);
1053 #endif
1054 #if defined TIZEN_EXT
1055         g_slist_free_full(network->vsie_list, g_free);
1056 #endif
1057
1058         g_free(network);
1059 }
1060
1061 static void remove_bss(gpointer data)
1062 {
1063         struct g_supplicant_bss *bss = data;
1064
1065         supplicant_dbus_property_call_cancel_all(bss);
1066
1067         g_free(bss->path);
1068 #if defined TIZEN_EXT
1069         g_slist_free_full(bss->vsie_list, g_free);
1070 #endif
1071         g_free(bss);
1072 }
1073
1074 static void remove_peer(gpointer data)
1075 {
1076         GSupplicantPeer *peer = data;
1077
1078         callback_peer_lost(peer);
1079
1080         if (peer->groups)
1081                 g_slist_free_full(peer->groups, g_free);
1082
1083         if (peer_mapping)
1084                 g_hash_table_remove(peer_mapping, peer->path);
1085
1086         if (pending_peer_connection)
1087                 g_hash_table_remove(pending_peer_connection, peer->path);
1088
1089         g_free(peer->path);
1090         g_free(peer->name);
1091         g_free(peer->identifier);
1092         g_free(peer->widi_ies);
1093
1094         g_free(peer);
1095 }
1096
1097 #if defined TIZEN_EXT
1098 static void remove_assoc_data(gpointer data)
1099 {
1100         struct assoc_reject_data *assoc_data = data;
1101
1102         g_free(assoc_data->bssid);
1103         g_slist_free(assoc_data->reject_time_list);
1104
1105         g_free(assoc_data);
1106 }
1107 #endif
1108
1109 static void debug_strvalmap(const char *label, struct strvalmap *map,
1110                                                         unsigned int val)
1111 {
1112         int i;
1113
1114         for (i = 0; map[i].str; i++) {
1115                 if (val & map[i].val)
1116                         SUPPLICANT_DBG("%s: %s", label, map[i].str);
1117         }
1118 }
1119
1120 static void interface_capability_keymgmt(DBusMessageIter *iter, void *user_data)
1121 {
1122         GSupplicantInterface *interface = user_data;
1123         const char *str = NULL;
1124         int i;
1125
1126         dbus_message_iter_get_basic(iter, &str);
1127         if (!str)
1128                 return;
1129
1130         for (i = 0; keymgmt_map[i].str; i++)
1131                 if (strcmp(str, keymgmt_map[i].str) == 0) {
1132                         interface->keymgmt_capa |= keymgmt_map[i].val;
1133                         break;
1134                 }
1135 }
1136
1137 static void interface_capability_authalg(DBusMessageIter *iter, void *user_data)
1138 {
1139         GSupplicantInterface *interface = user_data;
1140         const char *str = NULL;
1141         int i;
1142
1143         dbus_message_iter_get_basic(iter, &str);
1144         if (!str)
1145                 return;
1146
1147         for (i = 0; authalg_capa_map[i].str; i++)
1148                 if (strcmp(str, authalg_capa_map[i].str) == 0) {
1149                         interface->authalg_capa |= authalg_capa_map[i].val;
1150                         break;
1151                 }
1152 }
1153
1154 static void interface_capability_proto(DBusMessageIter *iter, void *user_data)
1155 {
1156         GSupplicantInterface *interface = user_data;
1157         const char *str = NULL;
1158         int i;
1159
1160         dbus_message_iter_get_basic(iter, &str);
1161         if (!str)
1162                 return;
1163
1164         for (i = 0; proto_capa_map[i].str; i++)
1165                 if (strcmp(str, proto_capa_map[i].str) == 0) {
1166                         interface->proto_capa |= proto_capa_map[i].val;
1167                         break;
1168                 }
1169 }
1170
1171 static void interface_capability_pairwise(DBusMessageIter *iter,
1172                                                         void *user_data)
1173 {
1174         GSupplicantInterface *interface = user_data;
1175         const char *str = NULL;
1176         int i;
1177
1178         dbus_message_iter_get_basic(iter, &str);
1179         if (!str)
1180                 return;
1181
1182         for (i = 0; pairwise_map[i].str; i++)
1183                 if (strcmp(str, pairwise_map[i].str) == 0) {
1184                         interface->pairwise_capa |= pairwise_map[i].val;
1185                         break;
1186                 }
1187 }
1188
1189 static void interface_capability_group(DBusMessageIter *iter, void *user_data)
1190 {
1191         GSupplicantInterface *interface = user_data;
1192         const char *str = NULL;
1193         int i;
1194
1195         dbus_message_iter_get_basic(iter, &str);
1196         if (!str)
1197                 return;
1198
1199         for (i = 0; group_map[i].str; i++)
1200                 if (strcmp(str, group_map[i].str) == 0) {
1201                         interface->group_capa |= group_map[i].val;
1202                         break;
1203                 }
1204 }
1205
1206 static void interface_capability_scan(DBusMessageIter *iter, void *user_data)
1207 {
1208         GSupplicantInterface *interface = user_data;
1209         const char *str = NULL;
1210         int i;
1211
1212         dbus_message_iter_get_basic(iter, &str);
1213         if (!str)
1214                 return;
1215
1216         for (i = 0; scan_capa_map[i].str; i++)
1217                 if (strcmp(str, scan_capa_map[i].str) == 0) {
1218                         interface->scan_capa |= scan_capa_map[i].val;
1219                         break;
1220                 }
1221 }
1222
1223 static void interface_capability_mode(DBusMessageIter *iter, void *user_data)
1224 {
1225         GSupplicantInterface *interface = user_data;
1226         const char *str = NULL;
1227         int i;
1228
1229         dbus_message_iter_get_basic(iter, &str);
1230         if (!str)
1231                 return;
1232
1233         for (i = 0; mode_capa_map[i].str; i++)
1234                 if (strcmp(str, mode_capa_map[i].str) == 0) {
1235                         interface->mode_capa |= mode_capa_map[i].val;
1236                         break;
1237                 }
1238 }
1239
1240 static void interface_capability(const char *key, DBusMessageIter *iter,
1241                                                         void *user_data)
1242 {
1243         GSupplicantInterface *interface = user_data;
1244
1245         if (!key)
1246                 return;
1247
1248         if (g_strcmp0(key, "KeyMgmt") == 0)
1249                 supplicant_dbus_array_foreach(iter,
1250                                 interface_capability_keymgmt, interface);
1251         else if (g_strcmp0(key, "AuthAlg") == 0)
1252                 supplicant_dbus_array_foreach(iter,
1253                                 interface_capability_authalg, interface);
1254         else if (g_strcmp0(key, "Protocol") == 0)
1255                 supplicant_dbus_array_foreach(iter,
1256                                 interface_capability_proto, interface);
1257         else if (g_strcmp0(key, "Pairwise") == 0)
1258                 supplicant_dbus_array_foreach(iter,
1259                                 interface_capability_pairwise, interface);
1260         else if (g_strcmp0(key, "Group") == 0)
1261                 supplicant_dbus_array_foreach(iter,
1262                                 interface_capability_group, interface);
1263         else if (g_strcmp0(key, "Scan") == 0)
1264                 supplicant_dbus_array_foreach(iter,
1265                                 interface_capability_scan, interface);
1266         else if (g_strcmp0(key, "Modes") == 0)
1267                 supplicant_dbus_array_foreach(iter,
1268                                 interface_capability_mode, interface);
1269         else if (g_strcmp0(key, "MaxScanSSID") == 0) {
1270                 dbus_int32_t max_scan_ssid;
1271
1272                 dbus_message_iter_get_basic(iter, &max_scan_ssid);
1273                 if (max_scan_ssid < 2)
1274                         max_scan_ssid = 0;
1275                 interface->max_scan_ssids = max_scan_ssid;
1276 #if defined TIZEN_EXT
1277         } else if (g_strcmp0(key, "Is5GhzSupported") == 0) {
1278                 dbus_bool_t is_5_0_Ghz_supported;
1279
1280                 dbus_message_iter_get_basic(iter, &is_5_0_Ghz_supported);
1281                 interface->is_5_0_Ghz_supported = is_5_0_Ghz_supported;
1282 #endif
1283         } else
1284                 SUPPLICANT_DBG("key %s type %c",
1285                                 key, dbus_message_iter_get_arg_type(iter));
1286 }
1287
1288 struct set_apscan_data
1289 {
1290         unsigned int ap_scan;
1291         GSupplicantInterface *interface;
1292 };
1293
1294 static void set_apscan(DBusMessageIter *iter, void *user_data)
1295 {
1296         struct set_apscan_data *data = user_data;
1297         unsigned int ap_scan = data->ap_scan;
1298
1299         dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &ap_scan);
1300 }
1301
1302 static void set_apscan_complete(const char *error,
1303                 DBusMessageIter *iter, void *user_data)
1304 {
1305         struct set_apscan_data *data = user_data;
1306         GSupplicantInterface *interface = data->interface;
1307
1308         if (error) {
1309                 interface->ap_create_in_progress = false;
1310                 SUPPLICANT_DBG("Set AP scan error %s", error);
1311                 goto error;
1312         }
1313
1314         interface->ap_create_in_progress = true;
1315 error:
1316         dbus_free(data);
1317 }
1318
1319 int g_supplicant_interface_set_apscan(GSupplicantInterface *interface,
1320                                                         unsigned int ap_scan)
1321 {
1322         struct set_apscan_data *data;
1323         int ret;
1324
1325         data = dbus_malloc0(sizeof(*data));
1326
1327         if (!data)
1328                 return -ENOMEM;
1329
1330         data->ap_scan = ap_scan;
1331         data->interface = interface;
1332
1333         ret = supplicant_dbus_property_set(interface->path,
1334                         SUPPLICANT_INTERFACE ".Interface",
1335                         "ApScan", DBUS_TYPE_UINT32_AS_STRING,
1336                         set_apscan, set_apscan_complete, data, NULL);
1337         if (ret < 0)
1338                 dbus_free(data);
1339
1340         return ret;
1341 }
1342
1343 void g_supplicant_interface_set_data(GSupplicantInterface *interface,
1344                                                                 void *data)
1345 {
1346         if (!interface)
1347                 return;
1348
1349         interface->data = data;
1350
1351         if (!data)
1352                 interface->scan_callback = NULL;
1353 }
1354
1355 void *g_supplicant_interface_get_data(GSupplicantInterface *interface)
1356 {
1357         if (!interface)
1358                 return NULL;
1359
1360         return interface->data;
1361 }
1362
1363 const char *g_supplicant_interface_get_ifname(GSupplicantInterface *interface)
1364 {
1365         if (!interface)
1366                 return NULL;
1367
1368         return interface->ifname;
1369 }
1370
1371 #if defined TIZEN_EXT
1372 bool g_supplicant_interface_get_is_5_0_ghz_supported(GSupplicantInterface *interface)
1373 {
1374         if (!interface)
1375                 return NULL;
1376
1377         return interface->is_5_0_Ghz_supported;
1378 }
1379 #endif
1380
1381 const char *g_supplicant_interface_get_driver(GSupplicantInterface *interface)
1382 {
1383         if (!interface)
1384                 return NULL;
1385
1386         return interface->driver;
1387 }
1388
1389 GSupplicantState g_supplicant_interface_get_state(
1390                                         GSupplicantInterface *interface)
1391 {
1392         if (!interface)
1393                 return G_SUPPLICANT_STATE_UNKNOWN;
1394
1395         return interface->state;
1396 }
1397
1398 const char *g_supplicant_interface_get_wps_key(GSupplicantInterface *interface)
1399 {
1400         if (!interface)
1401                 return NULL;
1402
1403         return (const char *)interface->wps_cred.key;
1404 }
1405
1406 const void *g_supplicant_interface_get_wps_ssid(GSupplicantInterface *interface,
1407                                                         unsigned int *ssid_len)
1408 {
1409         if (!ssid_len)
1410                 return NULL;
1411
1412         if (!interface || interface->wps_cred.ssid_len == 0) {
1413                 *ssid_len = 0;
1414                 return NULL;
1415         }
1416
1417         *ssid_len = interface->wps_cred.ssid_len;
1418         return interface->wps_cred.ssid;
1419 }
1420
1421 GSupplicantWpsState g_supplicant_interface_get_wps_state(
1422                                         GSupplicantInterface *interface)
1423 {
1424         if (!interface)
1425                 return G_SUPPLICANT_WPS_STATE_UNKNOWN;
1426
1427         return interface->wps_state;
1428 }
1429
1430 unsigned int g_supplicant_interface_get_mode(GSupplicantInterface *interface)
1431 {
1432         if (!interface)
1433                 return 0;
1434
1435         return interface->mode_capa;
1436 }
1437
1438 unsigned int g_supplicant_interface_get_max_scan_ssids(
1439                                 GSupplicantInterface *interface)
1440 {
1441         if (!interface)
1442                 return 0;
1443
1444         if (interface->max_scan_ssids == 0)
1445                 return WPAS_MAX_SCAN_SSIDS;
1446
1447         return interface->max_scan_ssids;
1448 }
1449
1450 static void set_network_enabled(DBusMessageIter *iter, void *user_data)
1451 {
1452         dbus_bool_t enable = *(dbus_bool_t *)user_data;
1453
1454         dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &enable);
1455 }
1456
1457 int g_supplicant_interface_enable_selected_network(GSupplicantInterface *interface,
1458                                                         dbus_bool_t enable)
1459 {
1460         if (!interface)
1461                 return -1;
1462
1463         if (!interface->network_path)
1464                 return -1;
1465
1466         SUPPLICANT_DBG(" ");
1467         return supplicant_dbus_property_set(interface->network_path,
1468                                 SUPPLICANT_INTERFACE ".Network",
1469                                 "Enabled", DBUS_TYPE_BOOLEAN_AS_STRING,
1470                                 set_network_enabled, NULL, &enable, NULL);
1471 }
1472
1473 dbus_bool_t g_supplicant_interface_get_ready(GSupplicantInterface *interface)
1474 {
1475         if (!interface)
1476                 return FALSE;
1477
1478         return interface->ready;
1479 }
1480
1481 GSupplicantInterface *g_supplicant_network_get_interface(
1482                                         GSupplicantNetwork *network)
1483 {
1484         if (!network)
1485                 return NULL;
1486
1487         return network->interface;
1488 }
1489
1490 const char *g_supplicant_network_get_name(GSupplicantNetwork *network)
1491 {
1492         if (!network || !network->name)
1493                 return "";
1494
1495         return network->name;
1496 }
1497
1498 const char *g_supplicant_network_get_identifier(GSupplicantNetwork *network)
1499 {
1500         if (!network || !network->group)
1501                 return "";
1502
1503         return network->group;
1504 }
1505
1506 const char *g_supplicant_network_get_path(GSupplicantNetwork *network)
1507 {
1508         if (!network || !network->path)
1509                 return NULL;
1510
1511         return network->path;
1512 }
1513
1514 const char *g_supplicant_network_get_mode(GSupplicantNetwork *network)
1515 {
1516         if (!network)
1517                 return G_SUPPLICANT_MODE_UNKNOWN;
1518
1519         return mode2string(network->mode);
1520 }
1521
1522 const char *g_supplicant_network_get_security(GSupplicantNetwork *network)
1523 {
1524         if (!network)
1525                 return G_SUPPLICANT_SECURITY_UNKNOWN;
1526
1527         return security2string(network->security);
1528 }
1529
1530 const void *g_supplicant_network_get_ssid(GSupplicantNetwork *network,
1531                                                 unsigned int *ssid_len)
1532 {
1533         if (!network) {
1534                 *ssid_len = 0;
1535                 return NULL;
1536         }
1537
1538         *ssid_len = network->ssid_len;
1539         return network->ssid;
1540 }
1541
1542 dbus_int16_t g_supplicant_network_get_signal(GSupplicantNetwork *network)
1543 {
1544         if (!network)
1545                 return 0;
1546
1547         return network->signal;
1548 }
1549
1550 dbus_uint16_t g_supplicant_network_get_frequency(GSupplicantNetwork *network)
1551 {
1552         if (!network)
1553                 return 0;
1554
1555         return network->frequency;
1556 }
1557
1558 dbus_bool_t g_supplicant_network_get_wps(GSupplicantNetwork *network)
1559 {
1560         if (!network)
1561                 return FALSE;
1562
1563         return network->wps;
1564 }
1565
1566 dbus_bool_t g_supplicant_network_is_wps_active(GSupplicantNetwork *network)
1567 {
1568         if (!network)
1569                 return FALSE;
1570
1571         if (network->wps_capabilities & G_SUPPLICANT_WPS_CONFIGURED)
1572                 return TRUE;
1573
1574         return FALSE;
1575 }
1576
1577 dbus_bool_t g_supplicant_network_is_wps_pbc(GSupplicantNetwork *network)
1578 {
1579         if (!network)
1580                 return FALSE;
1581
1582         if (network->wps_capabilities & G_SUPPLICANT_WPS_PBC)
1583                 return TRUE;
1584
1585         return FALSE;
1586 }
1587
1588 dbus_bool_t g_supplicant_network_is_wps_advertizing(GSupplicantNetwork *network)
1589 {
1590         if (!network)
1591                 return FALSE;
1592
1593         if (network->wps_capabilities & G_SUPPLICANT_WPS_REGISTRAR)
1594                 return TRUE;
1595
1596         return FALSE;
1597 }
1598
1599 #ifdef TIZEN_EXT
1600 GSupplicantPhy_mode g_supplicant_network_get_phy_mode(GSupplicantNetwork *network)
1601 {
1602         if (!network)
1603                 return G_SUPPLICANT_MODE_IEEE80211_UNKNOWN;
1604
1605         return network->phy_mode;
1606 }
1607 #endif
1608
1609 GSupplicantInterface *g_supplicant_peer_get_interface(GSupplicantPeer *peer)
1610 {
1611         if (!peer)
1612                 return NULL;
1613
1614         return peer->interface;
1615 }
1616
1617 const char *g_supplicant_peer_get_path(GSupplicantPeer *peer)
1618 {
1619         if (!peer)
1620                 return NULL;
1621
1622         return peer->path;
1623 }
1624
1625 const char *g_supplicant_peer_get_identifier(GSupplicantPeer *peer)
1626 {
1627         if (!peer)
1628                 return NULL;
1629
1630         return peer->identifier;
1631 }
1632
1633 const void *g_supplicant_peer_get_device_address(GSupplicantPeer *peer)
1634 {
1635         if (!peer)
1636                 return NULL;
1637
1638         return peer->device_address;
1639 }
1640
1641 const void *g_supplicant_peer_get_iface_address(GSupplicantPeer *peer)
1642 {
1643         if (!peer)
1644                 return NULL;
1645
1646         return peer->iface_address;
1647 }
1648
1649 const char *g_supplicant_peer_get_name(GSupplicantPeer *peer)
1650 {
1651         if (!peer)
1652                 return NULL;
1653
1654         return peer->name;
1655 }
1656
1657 #if defined TIZEN_EXT
1658 bool g_supplicant_network_is_hs20AP(GSupplicantNetwork *network)
1659 {
1660         if (!network)
1661                 return 0;
1662
1663         return network->isHS20AP;
1664 }
1665
1666 const char *g_supplicant_network_get_eap(GSupplicantNetwork *network)
1667 {
1668         if (!network || !network->eap)
1669                 return NULL;
1670
1671         return network->eap;
1672 }
1673
1674 const char *g_supplicant_network_get_identity(GSupplicantNetwork *network)
1675 {
1676         if (!network || !network->identity)
1677                 return NULL;
1678
1679         return network->identity;
1680 }
1681
1682 const char *g_supplicant_network_get_phase2(GSupplicantNetwork *network)
1683 {
1684         if (!network || !network->phase2)
1685                 return NULL;
1686
1687         return network->phase2;
1688 }
1689
1690 unsigned int g_supplicant_network_get_keymgmt(GSupplicantNetwork *network)
1691 {
1692         if (network == NULL)
1693                 return 0;
1694
1695         return network->keymgmt;
1696 }
1697
1698 const unsigned char *g_supplicant_network_get_countrycode(GSupplicantNetwork
1699                                                           *network)
1700 {
1701         if (!network)
1702                 return NULL;
1703
1704         return network->country_code;
1705 }
1706 #endif
1707
1708 const unsigned char *g_supplicant_peer_get_widi_ies(GSupplicantPeer *peer,
1709                                                                 int *length)
1710 {
1711         if (!peer || !length)
1712                 return NULL;
1713
1714         *length = peer->widi_ies_length;
1715         return peer->widi_ies;
1716 }
1717
1718 bool g_supplicant_peer_is_wps_pbc(GSupplicantPeer *peer)
1719 {
1720         if (!peer)
1721                 return false;
1722
1723         if (peer->wps_capabilities & G_SUPPLICANT_WPS_PBC)
1724                 return true;
1725
1726         return false;
1727 }
1728
1729 bool g_supplicant_peer_is_wps_pin(GSupplicantPeer *peer)
1730 {
1731         if (!peer)
1732                 return false;
1733
1734         if (peer->wps_capabilities & G_SUPPLICANT_WPS_PIN)
1735                 return true;
1736
1737         return false;
1738 }
1739
1740 bool g_supplicant_peer_is_in_a_group(GSupplicantPeer *peer)
1741 {
1742         if (!peer || !peer->groups)
1743                 return false;
1744
1745         return true;
1746 }
1747
1748 GSupplicantInterface *g_supplicant_peer_get_group_interface(GSupplicantPeer *peer)
1749 {
1750         if (!peer)
1751                 return NULL;
1752
1753         return (GSupplicantInterface *) peer->current_group_iface;
1754 }
1755
1756 bool g_supplicant_peer_is_client(GSupplicantPeer *peer)
1757 {
1758         GSupplicantGroup *group;
1759         GSList *list;
1760
1761         if (!peer)
1762                 return false;
1763
1764         for (list = peer->groups; list; list = list->next) {
1765                 const char *path = list->data;
1766
1767                 group = g_hash_table_lookup(group_mapping, path);
1768                 if (!group)
1769                         continue;
1770
1771                 if (group->role != G_SUPPLICANT_GROUP_ROLE_CLIENT ||
1772                                 group->orig_interface != peer->interface)
1773                         continue;
1774
1775                 if (group->interface == peer->current_group_iface)
1776                         return true;
1777         }
1778
1779         return false;
1780 }
1781
1782 bool g_supplicant_peer_has_requested_connection(GSupplicantPeer *peer)
1783 {
1784         if (!peer)
1785                 return false;
1786
1787         return peer->connection_requested;
1788 }
1789
1790 #if defined TIZEN_EXT
1791 /*
1792  * Description: Network client requires additional wifi specific info
1793  */
1794 const unsigned char *g_supplicant_network_get_bssid(GSupplicantNetwork *network)
1795 {
1796         if (network == NULL || network->best_bss == NULL)
1797                 return NULL;
1798
1799         return (const unsigned char *)network->best_bss->bssid;
1800 }
1801
1802 unsigned int g_supplicant_network_get_maxrate(GSupplicantNetwork *network)
1803 {
1804         if (network == NULL || network->best_bss == NULL)
1805                 return 0;
1806
1807         return network->best_bss->maxrate;
1808 }
1809
1810 const char *g_supplicant_network_get_enc_mode(GSupplicantNetwork *network)
1811 {
1812         if (network == NULL || network->best_bss == NULL)
1813                 return NULL;
1814
1815         if (network->best_bss->security == G_SUPPLICANT_SECURITY_PSK ||
1816 #if defined TIZEN_EXT
1817             network->best_bss->security == G_SUPPLICANT_SECURITY_SAE ||
1818             network->best_bss->security == G_SUPPLICANT_SECURITY_OWE ||
1819             network->best_bss->security == G_SUPPLICANT_SECURITY_DPP ||
1820 #endif /* TIZEN_EXT */
1821             network->best_bss->security == G_SUPPLICANT_SECURITY_IEEE8021X) {
1822                 unsigned int pairwise;
1823
1824                 pairwise = network->best_bss->rsn_pairwise |
1825                                 network->best_bss->wpa_pairwise;
1826
1827                 if ((pairwise & G_SUPPLICANT_PAIRWISE_CCMP) &&
1828                     (pairwise & G_SUPPLICANT_PAIRWISE_TKIP))
1829                         return "mixed";
1830                 else if (pairwise & G_SUPPLICANT_PAIRWISE_CCMP)
1831                         return "aes";
1832                 else if (pairwise & G_SUPPLICANT_PAIRWISE_TKIP)
1833                         return "tkip";
1834
1835         } else if (network->best_bss->security == G_SUPPLICANT_SECURITY_WEP)
1836                 return "wep";
1837         else if (network->best_bss->security == G_SUPPLICANT_SECURITY_NONE)
1838                 return "none";
1839
1840         return NULL;
1841 }
1842
1843 bool g_supplicant_network_get_rsn_mode(GSupplicantNetwork *network)
1844 {
1845         if (network == NULL || network->best_bss == NULL)
1846                 return 0;
1847
1848 #if defined TIZEN_EXT
1849         if (network->best_bss->security == G_SUPPLICANT_SECURITY_SAE ||
1850                         network->best_bss->security == G_SUPPLICANT_SECURITY_OWE ||
1851                         network->best_bss->security == G_SUPPLICANT_SECURITY_DPP)
1852                 return false;
1853 #endif /* TIZEN_EXT */
1854
1855         if (network->best_bss->rsn_selected) {
1856                 const char *mode = g_supplicant_network_get_enc_mode(network);
1857                 if (g_strcmp0(mode, "aes") == 0 ||
1858                                 g_strcmp0(mode, "mixed") == 0)
1859                         return true;
1860                 else
1861                         return false;
1862         } else
1863                 return false;
1864 }
1865
1866 void *g_supplicant_network_get_wifi_vsie(GSupplicantNetwork *network)
1867 {
1868         GSList *vsie_list = NULL;
1869
1870         if (!network)
1871                 return NULL;
1872
1873         if (g_slist_length(network->vsie_list) > 0) {
1874                 GSList *list = NULL;
1875                 unsigned char *vsie = NULL;
1876                 for (list = network->vsie_list; list; list = list->next) {
1877                         unsigned char *ie = (unsigned char *)list->data;
1878                         if (ie == NULL)
1879                                 continue;
1880                         vsie = (unsigned char *)g_try_malloc0(ie[1]+2); // tag number size(1), tag length size(1)
1881
1882                         if (vsie) {
1883                                 memcpy(vsie, ie, ie[1]+2);
1884                                 vsie_list = g_slist_append(vsie_list, vsie);
1885                         } else
1886                                 SUPPLICANT_DBG("Failed to allocate memory");
1887                 }
1888         }
1889
1890         return vsie_list;
1891 }
1892
1893 static bool compare_bssid(unsigned char *bssid_a, unsigned char *bssid_b)
1894 {
1895         if (!memcmp(bssid_a, bssid_b, WIFI_BSSID_LEN_MAX))
1896                 return true;
1897
1898         return false;
1899 }
1900
1901 static gchar *convert_bssid_to_str(unsigned char *bssid)
1902 {
1903         GString *bssid_str;
1904         unsigned int i;
1905
1906         bssid_str = g_string_sized_new(18);
1907         if (!bssid_str)
1908                 return NULL;
1909
1910         for (i = 0; i < WIFI_BSSID_LEN_MAX; i++) {
1911                 g_string_append_printf(bssid_str, "%02x", bssid[i]);
1912                 if (i < WIFI_BSSID_LEN_MAX - 1)
1913                         g_string_append(bssid_str, ":");
1914         }
1915
1916         return g_string_free(bssid_str, FALSE);
1917 }
1918
1919 static void count_assoc_reject(gpointer data, gpointer user_data)
1920 {
1921         time_t assoc_reject_time = GPOINTER_TO_INT(data);
1922         struct assoc_count_data *assoc_count = user_data;
1923
1924         if (assoc_reject_time > assoc_count->ref_time)
1925                 assoc_count->assoc_count++;
1926 }
1927
1928 static uint16_t get_assoc_reject_cnt(GHashTable *assoc_reject_table, unsigned char *bssid)
1929 {
1930         gchar *bssid_str;
1931         struct assoc_reject_data *assoc_data;
1932         struct assoc_count_data assoc_count;
1933         time_t curr_time;
1934         struct tm* timeinfo;
1935
1936         if (g_hash_table_size(assoc_reject_table) < 1)
1937                 return 0;
1938
1939         if (!bssid)
1940                 return 0;
1941
1942         if (!memcmp(bssid, invalid_bssid, WIFI_BSSID_LEN_MAX))
1943                 return 0;
1944
1945         bssid_str = convert_bssid_to_str(bssid);
1946         if (!bssid_str)
1947                 return 0;
1948
1949         assoc_data = g_hash_table_lookup(assoc_reject_table, bssid_str);
1950         if (!assoc_data) {
1951                 g_free(bssid_str);
1952                 return 0;
1953         }
1954
1955         if (g_slist_length(assoc_data->reject_time_list) < 1) {
1956                 g_free(bssid_str);
1957                 return 0;
1958         }
1959
1960         /* Only events that occur within one hour are appened. */
1961         curr_time = time(NULL);
1962         timeinfo = localtime(&curr_time);
1963         timeinfo->tm_hour -= 1;
1964
1965         assoc_count.ref_time = mktime(timeinfo);
1966         assoc_count.assoc_count = 0;
1967
1968         g_slist_foreach(assoc_data->reject_time_list, count_assoc_reject, &assoc_count);
1969
1970         g_free(bssid_str);
1971         return assoc_count.assoc_count;
1972 }
1973
1974 static int calculate_score_last_connected_bssid(bool is_last_connected)
1975 {
1976         int score = 0;
1977
1978         if (ins_settings.last_connected_bssid) {
1979                 if (is_last_connected)
1980                         score += ins_settings.last_connected_bssid_score;
1981         }
1982
1983         return score;
1984 }
1985
1986 static int calculate_score_assoc_reject(uint16_t assoc_reject_cnt)
1987 {
1988         int score = 0;
1989
1990         if (ins_settings.assoc_reject)
1991                 score -= (assoc_reject_cnt * ins_settings.assoc_reject_score);
1992
1993         return score;
1994 }
1995
1996 static int calculate_score_frequency(dbus_int16_t strength, dbus_uint16_t frequency)
1997 {
1998         int score = 0;
1999
2000         switch (ins_settings.preferred_freq_bssid) {
2001         case G_SUPPLICANT_INS_PREFERRED_FREQ_24GHZ:
2002                 if ((frequency >= FREQ_RANGE_24GHZ_CHANNEL_1 &&
2003                         frequency <= FREQ_RANGE_24GHZ_CHANNEL_14) &&
2004                         (strength > ins_settings.signal_level3_24ghz))
2005                         score += ins_settings.preferred_freq_bssid_score;
2006
2007                 break;
2008         case G_SUPPLICANT_INS_PREFERRED_FREQ_5GHZ:
2009                 if ((frequency >= FREQ_RANGE_5GHZ_CHANNEL_32 &&
2010                         frequency <= FREQ_RANGE_5GHZ_CHANNEL_165) &&
2011                         (strength > ins_settings.signal_level3_5ghz))
2012                         score += ins_settings.preferred_freq_bssid_score;
2013
2014                 break;
2015         default:
2016                 break;
2017         }
2018
2019         return score;
2020 }
2021
2022 static int calculate_score_strength(dbus_int16_t strength)
2023 {
2024         int score = 0;
2025
2026         if (ins_settings.signal_bssid)
2027                 score += (((strength > -60) ? -60 : strength) + 85);
2028
2029         return score;
2030 }
2031
2032 static int calculate_score(bool is_last_connected, uint16_t assoc_reject_cnt,
2033                 dbus_int16_t strength, dbus_uint16_t frequency)
2034 {
2035         int score = 0;
2036
2037         score += calculate_score_last_connected_bssid(is_last_connected);
2038         score += calculate_score_assoc_reject(assoc_reject_cnt);
2039         score += calculate_score_frequency(strength, frequency);
2040         score += calculate_score_strength(strength);
2041
2042         return score;
2043 }
2044
2045 static void update_bssid_list(gpointer key, gpointer value, gpointer user_data)
2046 {
2047         struct g_supplicant_bss *bss = value;
2048         struct g_connman_bssids *bssids = NULL;
2049         struct update_bssid_data *bssid_data = (struct update_bssid_data *)user_data;
2050
2051         bssids = (struct g_connman_bssids *)g_try_malloc0(sizeof(struct g_connman_bssids));
2052
2053         if (bssids) {
2054                 memcpy(bssids->bssid, bss->bssid, WIFI_BSSID_LEN_MAX);
2055
2056                 bssids->strength = bss->signal;
2057                 bssids->strength += 120;
2058
2059                 if (bssids->strength > 100)
2060                         bssids->strength = 100;
2061
2062                 bssids->frequency = bss->frequency;
2063
2064                 bssids->assoc_reject_cnt = get_assoc_reject_cnt(bssid_data->assoc_reject_table, bssids->bssid);
2065
2066                 bssids->is_last_connected = compare_bssid(bssids->bssid, bssid_data->last_connected_bssid);
2067
2068 #if defined TIZEN_EXT_INS
2069                 bssids->score_last_connected_bssid = calculate_score_last_connected_bssid(bssids->is_last_connected);
2070                 bssids->score_assoc_reject = calculate_score_assoc_reject(bssids->assoc_reject_cnt);
2071                 bssids->score_frequency = calculate_score_frequency(bss->signal, bssids->frequency);
2072                 bssids->score_strength = calculate_score_strength(bssids->strength);
2073 #endif
2074
2075                 bssids->ins_score = calculate_score(bssids->is_last_connected,
2076                         bssids->assoc_reject_cnt, bssids->frequency, bss->signal);
2077
2078                 bssid_data->bssid_list = g_slist_append(bssid_data->bssid_list, bssids);
2079         } else
2080                 SUPPLICANT_DBG("Failed to allocate memory");
2081 }
2082
2083 static gint cmp_bss(gconstpointer a, gconstpointer b)
2084 {
2085         struct g_connman_bssids *entry_a = (struct g_connman_bssids *)a;
2086         struct g_connman_bssids *entry_b = (struct g_connman_bssids *)b;
2087
2088         if (entry_a->ins_score > entry_b->ins_score)
2089                 return -1;
2090
2091         if (entry_a->ins_score < entry_b->ins_score)
2092                 return 1;
2093
2094         return 0;
2095 }
2096
2097 #if defined TIZEN_EXT_INS
2098 static void print_bssid_sort(gpointer data, gpointer user_data)
2099 {
2100         struct g_connman_bssids *bssids = data;
2101
2102         SUPPLICANT_DBG("bssid[" MACSTR "] total[%2d] freq[%2d] "
2103                         "last_conn[%2d] assoc_reject[%2d] strength[%2d]",
2104                         MAC2STR(bssids->bssid), bssids->ins_score,
2105                         bssids->score_frequency, bssids->score_last_connected_bssid,
2106                         bssids->score_assoc_reject, bssids->score_strength);
2107 }
2108 #endif
2109
2110 void *g_supplicant_network_get_bssid_list(GSupplicantNetwork *network)
2111 {
2112         struct update_bssid_data bssid_data;
2113
2114         if (g_hash_table_size(network->bss_table) < 1)
2115                 return NULL;
2116
2117         bssid_data.network = network;
2118         memset(&bssid_data, 0, sizeof(bssid_data));
2119         memcpy(bssid_data.last_connected_bssid, network->last_connected_bssid, WIFI_BSSID_LEN_MAX);
2120         bssid_data.assoc_reject_table = network->assoc_reject_table;
2121
2122         g_hash_table_foreach(network->bss_table, update_bssid_list, &bssid_data);
2123         bssid_data.bssid_list = g_slist_sort(bssid_data.bssid_list, cmp_bss);
2124 #if defined TIZEN_EXT_INS
2125         g_slist_foreach(bssid_data.bssid_list, print_bssid_sort, NULL);
2126 #endif
2127
2128         return bssid_data.bssid_list;
2129 }
2130
2131 void g_supplicant_network_set_last_connected_bssid(GSupplicantNetwork *network, const unsigned char *bssid)
2132 {
2133         if (!bssid)
2134                 return;
2135
2136         if (!memcmp(bssid, invalid_bssid, WIFI_BSSID_LEN_MAX))
2137                 return;
2138
2139         memcpy(network->last_connected_bssid, bssid, WIFI_BSSID_LEN_MAX);
2140
2141         SUPPLICANT_DBG("last connected bssid [" MACSTR "]", MAC2STR(bssid));
2142 }
2143
2144 const unsigned char *g_supplicant_network_get_last_connected_bssid(GSupplicantNetwork *network)
2145 {
2146         if (network == NULL)
2147                 return NULL;
2148
2149         return (const unsigned char *)network->last_connected_bssid;
2150 }
2151
2152 void g_supplicant_network_update_assoc_reject(GSupplicantInterface *interface,
2153                 GSupplicantNetwork *network)
2154 {
2155         struct assoc_reject_data *assoc_data;
2156         gchar *bssid_str;
2157         time_t curr_time;
2158
2159         if (!network)
2160                 return;
2161
2162         bssid_str = convert_bssid_to_str(interface->add_network_bssid);
2163         if (!bssid_str)
2164                 return;
2165
2166         assoc_data = g_hash_table_lookup(network->assoc_reject_table, bssid_str);
2167         if (!assoc_data) {
2168                 assoc_data = g_try_new0(struct assoc_reject_data, 1);
2169                 if (!assoc_data) {
2170                         g_free(bssid_str);
2171                         return;
2172                 }
2173
2174                 assoc_data->bssid = g_strdup(bssid_str);
2175                 g_hash_table_insert(network->assoc_reject_table, assoc_data->bssid, assoc_data);
2176         }
2177
2178         curr_time = time(NULL);
2179         assoc_data->reject_time_list = g_slist_append(assoc_data->reject_time_list, GINT_TO_POINTER(curr_time));
2180
2181         SUPPLICANT_DBG("bssid [%s] time [%u]", bssid_str, curr_time);
2182
2183         g_free(bssid_str);
2184
2185         callback_network_changed(network, "UpdateAssocReject");
2186 }
2187
2188 GHashTable *g_supplicant_network_get_assoc_reject_table(GSupplicantNetwork *network)
2189 {
2190         if (!network)
2191                 return NULL;
2192
2193         return network->assoc_reject_table;
2194 }
2195
2196 GSupplicantNetwork *g_supplicant_interface_get_network(GSupplicantInterface *interface,
2197                 const char *group)
2198 {
2199         if (!interface)
2200                 return NULL;
2201
2202         return g_hash_table_lookup(interface->network_table, group);
2203 }
2204 #endif
2205
2206 static void merge_network(GSupplicantNetwork *network)
2207 {
2208         GString *str;
2209         const char *ssid, *mode, *key_mgmt;
2210 #if defined TIZEN_EXT
2211         const char *isHS20AP;
2212         const char *eap, *identity, *phase2;
2213 #endif
2214         unsigned int i, ssid_len;
2215         char *group;
2216
2217         ssid = g_hash_table_lookup(network->config_table, "ssid");
2218         mode = g_hash_table_lookup(network->config_table, "mode");
2219         key_mgmt = g_hash_table_lookup(network->config_table, "key_mgmt");
2220 #if defined TIZEN_EXT
2221         isHS20AP = g_hash_table_lookup(network->config_table, "isHS20AP");
2222         eap = g_hash_table_lookup(network->config_table, "eap");
2223         identity = g_hash_table_lookup(network->config_table, "identity");
2224         phase2 = g_hash_table_lookup(network->config_table, "phase2");
2225 #endif
2226
2227         SUPPLICANT_DBG("ssid %s mode %s", ssid, mode);
2228
2229         if (ssid)
2230                 ssid_len = strlen(ssid);
2231         else
2232                 ssid_len = 0;
2233
2234         str = g_string_sized_new((ssid_len * 2) + 24);
2235         if (!str)
2236                 return;
2237
2238         for (i = 0; i < ssid_len; i++)
2239 #if defined TIZEN_EXT
2240         {
2241                 if (ssid[i] != '"')
2242 #endif
2243                 g_string_append_printf(str, "%02x", ssid[i]);
2244 #if defined TIZEN_EXT
2245         }
2246 #endif
2247
2248         if (g_strcmp0(mode, "0") == 0)
2249                 g_string_append_printf(str, "_managed");
2250         else if (g_strcmp0(mode, "1") == 0)
2251                 g_string_append_printf(str, "_adhoc");
2252 #if defined TIZEN_EXT_WIFI_MESH
2253         else if (g_strcmp0(mode, "5") == 0)
2254                 g_string_append_printf(str, "_mesh");
2255 #endif
2256
2257         if (g_strcmp0(key_mgmt, "WPA-PSK") == 0)
2258                 g_string_append_printf(str, "_psk");
2259 #if defined TIZEN_EXT
2260         else if (g_strcmp0(key_mgmt, "WPA-EAP") == 0)
2261                 g_string_append_printf(str, "_ieee8021x");
2262         else
2263                 g_string_append_printf(str, "_none");
2264 #endif
2265
2266         group = g_string_free(str, FALSE);
2267
2268         SUPPLICANT_DBG("%s", group);
2269
2270 #if defined TIZEN_EXT
2271         if (g_strcmp0(isHS20AP, "1") == 0) {
2272                 network->isHS20AP = 1;
2273                 if (network->eap)
2274                         g_free(network->eap);
2275                 network->eap = g_strdup(eap);
2276
2277                 if (network->identity)
2278                         g_free(network->identity);
2279                 network->identity = g_strdup(identity);
2280
2281                 if (network->phase2)
2282                         g_free(network->phase2);
2283                 network->phase2 = g_strdup(phase2);
2284         } else
2285                 network->isHS20AP = 0;
2286
2287         network->group = g_strdup(group);
2288         callback_network_merged(network);
2289         g_free(network->group);
2290 #endif
2291
2292         g_free(group);
2293
2294         g_hash_table_destroy(network->config_table);
2295
2296         g_free(network->path);
2297         g_free(network);
2298 }
2299
2300 static void network_property(const char *key, DBusMessageIter *iter,
2301                                                         void *user_data)
2302 {
2303         GSupplicantNetwork *network = user_data;
2304
2305         if (!network->interface)
2306                 return;
2307
2308         if (!key) {
2309                 merge_network(network);
2310                 return;
2311         }
2312
2313         if (g_strcmp0(key, "Enabled") == 0) {
2314                 dbus_bool_t enabled = FALSE;
2315
2316                 dbus_message_iter_get_basic(iter, &enabled);
2317         } else if (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_STRING) {
2318                 const char *str = NULL;
2319
2320                 dbus_message_iter_get_basic(iter, &str);
2321                 if (str) {
2322                         g_hash_table_replace(network->config_table,
2323                                                 g_strdup(key), g_strdup(str));
2324                 }
2325         } else
2326                 SUPPLICANT_DBG("key %s type %c",
2327                                 key, dbus_message_iter_get_arg_type(iter));
2328 }
2329
2330 static void interface_network_added(DBusMessageIter *iter, void *user_data)
2331 {
2332         GSupplicantInterface *interface = user_data;
2333         GSupplicantNetwork *network;
2334         const char *path = NULL;
2335
2336         SUPPLICANT_DBG("");
2337
2338         dbus_message_iter_get_basic(iter, &path);
2339         if (!path)
2340                 return;
2341
2342         if (g_strcmp0(path, "/") == 0)
2343                 return;
2344
2345         network = g_try_new0(GSupplicantNetwork, 1);
2346         if (!network)
2347                 return;
2348
2349         network->interface = interface;
2350         network->path = g_strdup(path);
2351
2352         network->config_table = g_hash_table_new_full(g_str_hash, g_str_equal,
2353                                                         g_free, g_free);
2354
2355         dbus_message_iter_next(iter);
2356         if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_INVALID) {
2357                 supplicant_dbus_property_foreach(iter, network_property,
2358                                                                 network);
2359                 network_property(NULL, NULL, network);
2360                 return;
2361         }
2362
2363         supplicant_dbus_property_get_all(path,
2364                                 SUPPLICANT_INTERFACE ".Network",
2365                                         network_property, network, NULL);
2366 }
2367
2368 static void interface_network_removed(DBusMessageIter *iter, void *user_data)
2369 {
2370         SUPPLICANT_DBG("");
2371 }
2372
2373 static char *create_name(unsigned char *ssid, int ssid_len)
2374 {
2375         GString *string;
2376         const gchar *remainder, *invalid;
2377         int valid_bytes, remaining_bytes;
2378
2379         if (ssid_len < 1 || ssid[0] == '\0')
2380                 return g_strdup("");
2381
2382         string = NULL;
2383         remainder = (const gchar *)ssid;
2384         remaining_bytes = ssid_len;
2385
2386         while (remaining_bytes != 0) {
2387                 if (g_utf8_validate(remainder, remaining_bytes,
2388                                         &invalid)) {
2389                         break;
2390                 }
2391
2392                 valid_bytes = invalid - remainder;
2393
2394                 if (!string)
2395                         string = g_string_sized_new(remaining_bytes);
2396
2397                 g_string_append_len(string, remainder, valid_bytes);
2398
2399                 /* append U+FFFD REPLACEMENT CHARACTER */
2400                 g_string_append(string, "\357\277\275");
2401
2402                 remaining_bytes -= valid_bytes + 1;
2403                 remainder = invalid + 1;
2404         }
2405
2406         if (!string)
2407                 return g_strndup((const gchar *)ssid, ssid_len + 1);
2408
2409         g_string_append(string, remainder);
2410
2411         return g_string_free(string, FALSE);
2412 }
2413
2414 static char *create_group(struct g_supplicant_bss *bss)
2415 {
2416         GString *str;
2417         unsigned int i;
2418         const char *mode, *security;
2419
2420         str = g_string_sized_new((bss->ssid_len * 2) + 24);
2421         if (!str)
2422                 return NULL;
2423
2424         if (bss->ssid_len > 0 && bss->ssid[0] != '\0') {
2425                 for (i = 0; i < bss->ssid_len; i++)
2426                         g_string_append_printf(str, "%02x", bss->ssid[i]);
2427         } else
2428                 g_string_append_printf(str, "hidden");
2429
2430         mode = mode2string(bss->mode);
2431         if (mode)
2432                 g_string_append_printf(str, "_%s", mode);
2433
2434         security = security2string(bss->security);
2435         if (security)
2436                 g_string_append_printf(str, "_%s", security);
2437
2438         return g_string_free(str, FALSE);
2439 }
2440
2441 static bool update_best_bss(GSupplicantNetwork *network,
2442                 struct g_supplicant_bss *bss, struct g_supplicant_bss *best_bss)
2443 {
2444         int score_new;
2445         int score_best;
2446
2447         score_new = calculate_score(
2448                 compare_bssid(bss->bssid, network->last_connected_bssid),
2449                 get_assoc_reject_cnt(network->assoc_reject_table, bss->bssid),
2450                 bss->frequency, bss->signal);
2451         score_best = calculate_score(
2452                 compare_bssid(network->best_bss->bssid, network->last_connected_bssid),
2453                 get_assoc_reject_cnt(network->assoc_reject_table, network->best_bss->bssid),
2454                 network->best_bss->frequency, network->best_bss->signal);
2455
2456         if (score_new > score_best) {
2457                 SUPPLICANT_DBG("new[" MACSTR "][%u] : best[" MACSTR "][%u]",
2458                         MAC2STR(bss->bssid), score_new,
2459                         MAC2STR(network->best_bss->bssid), score_best);
2460
2461                 network->signal = bss->signal;
2462                 network->frequency = bss->frequency;
2463                 network->best_bss = bss;
2464
2465                 SUPPLICANT_DBG("Update best BSS for %s", network->name);
2466
2467                 return true;
2468         }
2469
2470         return false;
2471 }
2472
2473 static int add_or_replace_bss_to_network(struct g_supplicant_bss *bss)
2474 {
2475         GSupplicantInterface *interface = bss->interface;
2476         GSupplicantNetwork *network;
2477         char *group;
2478         bool is_new_network;
2479
2480         group = create_group(bss);
2481         SUPPLICANT_DBG("New group created: %s", group);
2482
2483         if (!group)
2484                 return -ENOMEM;
2485
2486         network = g_hash_table_lookup(interface->network_table, group);
2487         if (network) {
2488                 g_free(group);
2489                 SUPPLICANT_DBG("Network %s already exist", network->name);
2490                 is_new_network = false;
2491
2492                 goto done;
2493         }
2494
2495         is_new_network = true;
2496
2497         network = g_try_new0(GSupplicantNetwork, 1);
2498         if (!network) {
2499                 g_free(group);
2500                 return -ENOMEM;
2501         }
2502
2503         network->interface = interface;
2504         if (!network->path)
2505                 network->path = g_strdup(bss->path);
2506         network->group = group;
2507         network->name = create_name(bss->ssid, bss->ssid_len);
2508         network->mode = bss->mode;
2509         network->security = bss->security;
2510         network->ssid_len = bss->ssid_len;
2511         memcpy(network->ssid, bss->ssid, bss->ssid_len);
2512         network->signal = bss->signal;
2513         network->frequency = bss->frequency;
2514         network->best_bss = bss;
2515
2516         if ((bss->keymgmt & G_SUPPLICANT_KEYMGMT_WPS) != 0) {
2517                 network->wps = TRUE;
2518                 network->wps_capabilities = bss->wps_capabilities;
2519         }
2520
2521 #if defined TIZEN_EXT
2522         network->keymgmt = bss->keymgmt;
2523
2524         if (g_slist_length(bss->vsie_list) > 0) {
2525                 GSList *list = NULL;
2526                 unsigned char *vsie = NULL;
2527                 for (list = bss->vsie_list; list; list = list->next) {
2528                         unsigned char *ie = (unsigned char *)list->data;
2529                         vsie = (unsigned char *)g_try_malloc0(ie[1]+2); // tag number size(1), tag length size(1)
2530
2531                         if (vsie) {
2532                                 memcpy(vsie, ie, ie[1]+2);
2533                                 network->vsie_list = g_slist_append(network->vsie_list, vsie);
2534                         } else
2535                                 SUPPLICANT_DBG("Failed to allocate memory.");
2536                 }
2537         }
2538
2539         network->isHS20AP = bss->hs20;
2540         memcpy(network->country_code, bss->country_code, COUNTRY_CODE_LENGTH);
2541         network->phy_mode = bss->phy_mode;
2542 #endif
2543
2544         SUPPLICANT_DBG("New network %s created", network->name);
2545
2546         network->bss_table = g_hash_table_new_full(g_str_hash, g_str_equal,
2547                                                         NULL, remove_bss);
2548
2549         network->config_table = g_hash_table_new_full(g_str_hash, g_str_equal,
2550                                                         g_free, g_free);
2551
2552 #if defined TIZEN_EXT
2553         network->assoc_reject_table = g_hash_table_new_full(g_str_hash, g_str_equal,
2554                                                         NULL, remove_assoc_data);
2555 #endif
2556
2557         g_hash_table_replace(interface->network_table,
2558                                                 network->group, network);
2559
2560         callback_network_added(network);
2561
2562 done:
2563         /* We update network's WPS properties if only bss provides WPS. */
2564         if ((bss->keymgmt & G_SUPPLICANT_KEYMGMT_WPS) != 0) {
2565                 network->wps = TRUE;
2566                 network->wps_capabilities = bss->wps_capabilities;
2567
2568                 if (!is_new_network)
2569                         callback_network_changed(network, "WPSCapabilities");
2570         }
2571
2572         /*
2573          * Do not change best BSS if we are connected. It will be done through
2574          * CurrentBSS property in case of misalignment with wpa_s or roaming.
2575          */
2576 #if defined TIZEN_EXT
2577         if (network != interface->current_network) {
2578                 if (update_best_bss(network, bss, network->best_bss))
2579                         callback_network_changed(network, "Signal");
2580         }
2581 #else
2582         if (network != interface->current_network &&
2583                                 bss->signal > network->signal) {
2584                 network->signal = bss->signal;
2585                 network->best_bss = bss;
2586                 callback_network_changed(network, "Signal");
2587         }
2588 #endif
2589
2590         g_hash_table_replace(interface->bss_mapping, bss->path, network);
2591         g_hash_table_replace(network->bss_table, bss->path, bss);
2592
2593         g_hash_table_replace(bss_mapping, bss->path, interface);
2594
2595         return 0;
2596 }
2597
2598 static void bss_rates(DBusMessageIter *iter, void *user_data)
2599 {
2600         struct g_supplicant_bss *bss = user_data;
2601         dbus_uint32_t rate = 0;
2602
2603         dbus_message_iter_get_basic(iter, &rate);
2604         if (rate == 0)
2605                 return;
2606
2607         if (rate > bss->maxrate)
2608                 bss->maxrate = rate;
2609 }
2610
2611 static void bss_keymgmt(DBusMessageIter *iter, void *user_data)
2612 {
2613         unsigned int *keymgmt = user_data;
2614         const char *str = NULL;
2615         int i;
2616
2617         dbus_message_iter_get_basic(iter, &str);
2618         if (!str)
2619                 return;
2620
2621         for (i = 0; keymgmt_map[i].str; i++)
2622                 if (strcmp(str, keymgmt_map[i].str) == 0) {
2623                         SUPPLICANT_DBG("Keymgmt: %s", str);
2624                         *keymgmt |= keymgmt_map[i].val;
2625                         break;
2626                 }
2627 }
2628
2629 static void bss_group(DBusMessageIter *iter, void *user_data)
2630 {
2631         unsigned int *group = user_data;
2632         const char *str = NULL;
2633         int i;
2634
2635         dbus_message_iter_get_basic(iter, &str);
2636         if (!str)
2637                 return;
2638
2639         for (i = 0; group_map[i].str; i++)
2640                 if (strcmp(str, group_map[i].str) == 0) {
2641                         SUPPLICANT_DBG("Group: %s", str);
2642                         *group |= group_map[i].val;
2643                         break;
2644                 }
2645 }
2646
2647 static void bss_pairwise(DBusMessageIter *iter, void *user_data)
2648 {
2649         unsigned int *pairwise = user_data;
2650         const char *str = NULL;
2651         int i;
2652
2653         dbus_message_iter_get_basic(iter, &str);
2654         if (!str)
2655                 return;
2656
2657         for (i = 0; pairwise_map[i].str; i++)
2658                 if (strcmp(str, pairwise_map[i].str) == 0) {
2659                         SUPPLICANT_DBG("Pairwise: %s", str);
2660                         *pairwise |= pairwise_map[i].val;
2661                         break;
2662                 }
2663 }
2664
2665 static void bss_wpa(const char *key, DBusMessageIter *iter,
2666                         void *user_data)
2667 {
2668         struct g_supplicant_bss *bss = user_data;
2669         unsigned int value = 0;
2670
2671         SUPPLICANT_DBG("Key: %s", key);
2672
2673         if (g_strcmp0(key, "KeyMgmt") == 0) {
2674                 supplicant_dbus_array_foreach(iter, bss_keymgmt, &value);
2675
2676                 if (bss->rsn_selected)
2677                         bss->rsn_keymgmt = value;
2678                 else
2679                         bss->wpa_keymgmt = value;
2680         } else if (g_strcmp0(key, "Group") == 0) {
2681                 supplicant_dbus_array_foreach(iter, bss_group, &value);
2682
2683                 if (bss->rsn_selected)
2684                         bss->rsn_group = value;
2685                 else
2686                         bss->wpa_group = value;
2687         } else if (g_strcmp0(key, "Pairwise") == 0) {
2688                 supplicant_dbus_array_foreach(iter, bss_pairwise, &value);
2689
2690                 if (bss->rsn_selected)
2691                         bss->rsn_pairwise = value;
2692                 else
2693                         bss->wpa_pairwise = value;
2694         }
2695 }
2696
2697 static unsigned int get_tlv(unsigned char *ie, unsigned int ie_size,
2698                                                         unsigned int type)
2699 {
2700         unsigned int len = 0;
2701
2702         while (len + 4 < ie_size) {
2703                 unsigned int hi = ie[len];
2704                 unsigned int lo = ie[len + 1];
2705                 unsigned int tmp_type = (hi << 8) + lo;
2706                 unsigned int v_len = 0;
2707
2708                 /* hi and lo are used to recreate an unsigned int
2709                  * based on 2 8bits length unsigned int. */
2710
2711                 hi = ie[len + 2];
2712                 lo = ie[len + 3];
2713                 v_len = (hi << 8) + lo;
2714
2715                 if (tmp_type == type) {
2716                         unsigned int ret_value = 0;
2717                         unsigned char *value = (unsigned char *)&ret_value;
2718
2719                         SUPPLICANT_DBG("IE: match type 0x%x", type);
2720
2721                         /* Verifying length relevance */
2722                         if (v_len > sizeof(unsigned int) ||
2723                                 len + 4 + v_len > ie_size)
2724                                 break;
2725
2726                         memcpy(value, ie + len + 4, v_len);
2727
2728                         SUPPLICANT_DBG("returning 0x%x", ret_value);
2729                         return ret_value;
2730                 }
2731
2732                 len += v_len + 4;
2733         }
2734
2735         SUPPLICANT_DBG("returning 0");
2736         return 0;
2737 }
2738
2739 #if defined TIZEN_EXT
2740 static void get_bss_phy_mode(unsigned int max_rate,
2741                 unsigned int max_ext_rate, bool ht, bool vht, void *data)
2742 {
2743         struct g_supplicant_bss *bss = data;
2744         unsigned int freq = bss->frequency;
2745
2746         /* Following conditions are used to determine
2747          * IEEE 802.11 Protocol Modes:-
2748          *
2749          * 1. If “Supported rates” is only till 11 Mbps,
2750          *    and frequency is in 2.4GHz band, then protocol is 11B.
2751          * 2. If “Supported rates” is till 54Mbps or
2752          *    “Extended supported rates” are present,
2753          *    and frequency is in 2.4GHz band, then protocol is 11G.
2754          * 3. If “Supported rates” is only till 54 Mbps,
2755          *    frequency is in 5GHz band , then protocol is 11A.
2756          * 4. If “HT capabilities” is supported , then protocol is 11N.
2757          * 5. If “HT capabilities” & “VHT” is supported and
2758          *    frequency is in 5 GHz band, then protocol is 11AC.
2759          * */
2760
2761         if (freq >= 2412 && freq <= 2484) { /* 2.4 Ghz Band */
2762                 if (max_rate <= 11 && max_ext_rate <= 0 && !ht)
2763                         bss->phy_mode = G_SUPPLICANT_MODE_IEEE80211B;
2764                 else if ((max_rate <= 54 || max_ext_rate > 0) && !ht)
2765                         bss->phy_mode = G_SUPPLICANT_MODE_IEEE80211BG;
2766                 else if ((max_rate >= 54 || max_ext_rate > 0) && ht)
2767                         bss->phy_mode = G_SUPPLICANT_MODE_IEEE80211BGN;
2768                 else
2769                         bss->phy_mode = G_SUPPLICANT_MODE_UNKNOWN;
2770         } else if (freq >= 5180 && freq <= 5825) { /* 5 Ghz Band */
2771                 if (max_rate <= 54 && !ht)
2772                         bss->phy_mode = G_SUPPLICANT_MODE_IEEE80211A;
2773                 else if ((max_rate >= 54 || max_ext_rate > 0) && ht && !vht)
2774                         bss->phy_mode = G_SUPPLICANT_MODE_IEEE80211AN;
2775                 else if ((max_rate >= 54 || max_ext_rate > 0) && ht && vht)
2776                         bss->phy_mode = G_SUPPLICANT_MODE_IEEE80211ANAC;
2777                 else
2778                         bss->phy_mode = G_SUPPLICANT_MODE_UNKNOWN;
2779         }
2780 }
2781 #endif
2782
2783 static void bss_process_ies(DBusMessageIter *iter, void *user_data)
2784 {
2785         struct g_supplicant_bss *bss = user_data;
2786         const unsigned char WPS_OUI[] = { 0x00, 0x50, 0xf2, 0x04 };
2787         unsigned char *ie, *ie_end;
2788         DBusMessageIter array;
2789         unsigned int value;
2790         int ie_len;
2791 #if defined TIZEN_EXT
2792         int r_len, j;
2793         unsigned char *rates = NULL;
2794         unsigned char *ext_rates = NULL;
2795         unsigned int max_rate = 0;
2796         unsigned int max_ext_rate = 0;
2797         bool ht = false;
2798         bool vht = false;
2799 #endif
2800
2801 #define WMM_WPA1_WPS_INFO 221
2802 #define WPS_INFO_MIN_LEN  6
2803 #define WPS_VERSION_TLV   0x104A
2804 #define WPS_STATE_TLV     0x1044
2805 #define WPS_METHODS_TLV   0x1012
2806 #define WPS_REGISTRAR_TLV 0x1041
2807 #define WPS_VERSION       0x10
2808 #define WPS_PBC           0x04
2809 #define WPS_PIN           0x00
2810 #define WPS_CONFIGURED    0x02
2811 #if defined TIZEN_EXT
2812 #define VENDOR_SPECIFIC_INFO 0xDD
2813 #define WLAN_EID_COUNTRY 7
2814 #endif
2815
2816         dbus_message_iter_recurse(iter, &array);
2817         dbus_message_iter_get_fixed_array(&array, &ie, &ie_len);
2818
2819         if (!ie || ie_len < 2)
2820                 return;
2821
2822         bss->wps_capabilities = 0;
2823         bss->keymgmt = 0;
2824
2825         for (ie_end = ie + ie_len; ie < ie_end && ie + ie[1] + 1 <= ie_end;
2826                                                         ie += ie[1] + 2) {
2827 #if defined TIZEN_EXT
2828                 unsigned char *vsie;
2829                 int vsie_len = 0;
2830                 if(ie[0] == VENDOR_SPECIFIC_INFO && memcmp(ie+2, WPS_OUI, sizeof(WPS_OUI)) != 0) {
2831                         SUPPLICANT_DBG("IE: match vendor specific data");
2832
2833                         vsie_len = ie[1]+2;     // tag number size(1), tag length size(1)
2834                         vsie = (unsigned char *)g_try_malloc0(vsie_len);
2835
2836                         if (vsie) {
2837                                 memcpy(vsie, ie, vsie_len);
2838                                 bss->vsie_list = g_slist_append(bss->vsie_list, vsie);
2839                         } else
2840                                 SUPPLICANT_DBG("Failed to allocate memory");
2841                         continue;
2842                 }
2843
2844                 if(ie[0] == WLAN_EID_COUNTRY && ie[1] >= 2) {
2845                         /* Add country code only if it is a valid alphabet */
2846                         if (ie[2] >= 65 && ie[2] <= 90 && ie[3] >= 65 && ie[3] <= 90) {
2847                                 memcpy(bss->country_code, ie+2, COUNTRY_CODE_LENGTH);
2848                                 continue;
2849                         }
2850                 }
2851
2852                 if (ie[0] == WLAN_EID_HT_CAP && ie[1]) {
2853                         ht = true;
2854                         continue;
2855                 }
2856
2857                 if (ie[0] == WLAN_EID_VHT_CAP && ie[1]) {
2858                         vht = true;
2859                         continue;
2860                 }
2861
2862                 if (ie[0] == WLAN_EID_SUPP_RATES && ie[1]) {
2863                         r_len = ie[1];
2864                         rates = g_malloc0(r_len);
2865                         if (!rates)
2866                                 continue;
2867
2868                         for (j = 0; ie && j < r_len; j++) {
2869                                 rates[j] = ((ie[j + 2] & 0x7f) * 500000)/1000000;
2870                                 if (max_rate < rates[j])
2871                                         max_rate = rates[j];
2872                         }
2873                         continue;
2874                 }
2875
2876                 if (ie[0] == WLAN_EID_EXT_SUPP_RATES && ie[1] > 0) {
2877                         r_len = ie[1];
2878                         ext_rates = g_malloc0(r_len);
2879                         if (!ext_rates)
2880                                 continue;
2881
2882                         for (j = 0; ie && j < r_len; j++) {
2883                                 ext_rates[j] = ((ie[j + 2] & 0x7f) * 500000)/1000000;
2884                                 if (max_ext_rate < ext_rates[j])
2885                                         max_ext_rate = ext_rates[j];
2886                         }
2887                         continue;
2888                 }
2889 #endif
2890                 if (ie[0] != WMM_WPA1_WPS_INFO || ie[1] < WPS_INFO_MIN_LEN ||
2891                         memcmp(ie+2, WPS_OUI, sizeof(WPS_OUI)) != 0)
2892                         continue;
2893
2894                 SUPPLICANT_DBG("IE: match WPS_OUI");
2895
2896                 value = get_tlv(&ie[6], ie[1], WPS_STATE_TLV);
2897                 if (get_tlv(&ie[6], ie[1], WPS_VERSION_TLV) == WPS_VERSION &&
2898                                                                 value != 0) {
2899                         bss->keymgmt |= G_SUPPLICANT_KEYMGMT_WPS;
2900
2901                         if (value == WPS_CONFIGURED)
2902                                 bss->wps_capabilities |=
2903                                         G_SUPPLICANT_WPS_CONFIGURED;
2904                 }
2905
2906                 value = get_tlv(&ie[6], ie[1], WPS_METHODS_TLV);
2907                 if (value != 0) {
2908                         if (GUINT16_FROM_BE(value) == WPS_PBC)
2909                                 bss->wps_capabilities |= G_SUPPLICANT_WPS_PBC;
2910                         if (GUINT16_FROM_BE(value) == WPS_PIN)
2911                                 bss->wps_capabilities |= G_SUPPLICANT_WPS_PIN;
2912                 } else
2913                         bss->wps_capabilities |=
2914                                 G_SUPPLICANT_WPS_PBC | G_SUPPLICANT_WPS_PIN;
2915
2916                 /* If the AP sends this it means it's advertizing
2917                  * as a registrar and the WPS process is launched
2918                  * on its side */
2919                 if (get_tlv(&ie[6], ie[1], WPS_REGISTRAR_TLV) != 0)
2920                         bss->wps_capabilities |= G_SUPPLICANT_WPS_REGISTRAR;
2921
2922                 SUPPLICANT_DBG("WPS Methods 0x%x", bss->wps_capabilities);
2923         }
2924 #ifdef TIZEN_EXT
2925         get_bss_phy_mode(max_rate, max_ext_rate, ht, vht, user_data);
2926         if (rates)
2927                 g_free(rates);
2928         if (ext_rates)
2929                 g_free(ext_rates);
2930 #endif
2931 }
2932
2933 static void bss_compute_security(struct g_supplicant_bss *bss)
2934 {
2935         /*
2936          * Combining RSN and WPA keymgmt
2937          * We combine it since parsing IEs might have set something for WPS. */
2938         bss->keymgmt |= bss->rsn_keymgmt | bss->wpa_keymgmt;
2939
2940         bss->ieee8021x = FALSE;
2941         bss->psk = FALSE;
2942 #if defined TIZEN_EXT
2943         bss->ft_ieee8021x = FALSE;
2944         bss->ft_psk = FALSE;
2945 #endif
2946
2947 #if defined TIZEN_EXT
2948         if (bss->keymgmt &
2949                         (G_SUPPLICANT_KEYMGMT_WPA_EAP |
2950                                         G_SUPPLICANT_KEYMGMT_WPA_EAP_256))
2951                 bss->ieee8021x = TRUE;
2952         else if (bss->keymgmt & G_SUPPLICANT_KEYMGMT_WPA_FT_EAP)
2953                 bss->ft_ieee8021x = TRUE;
2954 #else
2955         if (bss->keymgmt &
2956                         (G_SUPPLICANT_KEYMGMT_WPA_EAP |
2957                                 G_SUPPLICANT_KEYMGMT_WPA_FT_EAP |
2958                                 G_SUPPLICANT_KEYMGMT_WPA_EAP_256))
2959                 bss->ieee8021x = TRUE;
2960 #endif
2961
2962 #if defined TIZEN_EXT
2963         if (bss->keymgmt &
2964                         (G_SUPPLICANT_KEYMGMT_WPA_PSK |
2965                                         G_SUPPLICANT_KEYMGMT_WPA_PSK_256))
2966                 bss->psk = TRUE;
2967         else if (bss->keymgmt & G_SUPPLICANT_KEYMGMT_WPA_FT_PSK)
2968                 bss->ft_psk = TRUE;
2969 #else
2970         if (bss->keymgmt &
2971                         (G_SUPPLICANT_KEYMGMT_WPA_PSK |
2972                                 G_SUPPLICANT_KEYMGMT_WPA_FT_PSK |
2973                                 G_SUPPLICANT_KEYMGMT_WPA_PSK_256))
2974                 bss->psk = TRUE;
2975 #endif
2976
2977 #if defined TIZEN_EXT
2978         if (bss->keymgmt & G_SUPPLICANT_KEYMGMT_SAE)
2979                 bss->sae = TRUE;
2980         if (bss->keymgmt & G_SUPPLICANT_KEYMGMT_OWE)
2981                 bss->owe = TRUE;
2982         if (bss->keymgmt & G_SUPPLICANT_KEYMGMT_DPP)
2983                 bss->dpp = TRUE;
2984 #endif
2985
2986         if (bss->ieee8021x)
2987                 bss->security = G_SUPPLICANT_SECURITY_IEEE8021X;
2988         else if (bss->psk)
2989                 bss->security = G_SUPPLICANT_SECURITY_PSK;
2990 #if defined TIZEN_EXT
2991         else if (bss->ft_psk)
2992                 bss->security = G_SUPPLICANT_SECURITY_FT_PSK;
2993         else if (bss->ft_ieee8021x == TRUE)
2994                 bss->security = G_SUPPLICANT_SECURITY_IEEE8021X;
2995         else if (bss->sae)
2996                 bss->security = G_SUPPLICANT_SECURITY_SAE;
2997         else if (bss->owe)
2998                 bss->security = G_SUPPLICANT_SECURITY_OWE;
2999         else if (bss->dpp)
3000                 bss->security = G_SUPPLICANT_SECURITY_DPP;
3001 #endif
3002         else if (bss->privacy)
3003                 bss->security = G_SUPPLICANT_SECURITY_WEP;
3004         else
3005                 bss->security = G_SUPPLICANT_SECURITY_NONE;
3006 }
3007
3008
3009 static void bss_property(const char *key, DBusMessageIter *iter,
3010                                                         void *user_data)
3011 {
3012         struct g_supplicant_bss *bss = user_data;
3013
3014         if (!bss->interface)
3015                 return;
3016
3017         SUPPLICANT_DBG("key %s", key);
3018
3019         if (!key)
3020                 return;
3021
3022         if (g_strcmp0(key, "BSSID") == 0) {
3023                 DBusMessageIter array;
3024                 unsigned char *addr;
3025                 int addr_len;
3026
3027                 dbus_message_iter_recurse(iter, &array);
3028                 dbus_message_iter_get_fixed_array(&array, &addr, &addr_len);
3029
3030                 if (addr_len == 6)
3031                         memcpy(bss->bssid, addr, addr_len);
3032         } else if (g_strcmp0(key, "SSID") == 0) {
3033                 DBusMessageIter array;
3034                 unsigned char *ssid;
3035                 int ssid_len;
3036
3037                 dbus_message_iter_recurse(iter, &array);
3038                 dbus_message_iter_get_fixed_array(&array, &ssid, &ssid_len);
3039
3040                 if (ssid_len > 0 && ssid_len < 33) {
3041                         memcpy(bss->ssid, ssid, ssid_len);
3042                         bss->ssid_len = ssid_len;
3043                 } else {
3044                         memset(bss->ssid, 0, sizeof(bss->ssid));
3045                         bss->ssid_len = 0;
3046                 }
3047         } else if (g_strcmp0(key, "Capabilities") == 0) {
3048                 dbus_uint16_t capabilities = 0x0000;
3049
3050                 dbus_message_iter_get_basic(iter, &capabilities);
3051
3052                 if (capabilities & IEEE80211_CAP_ESS)
3053                         bss->mode = G_SUPPLICANT_MODE_INFRA;
3054                 else if (capabilities & IEEE80211_CAP_IBSS)
3055                         bss->mode = G_SUPPLICANT_MODE_IBSS;
3056
3057                 if (capabilities & IEEE80211_CAP_PRIVACY)
3058                         bss->privacy = TRUE;
3059         } else if (g_strcmp0(key, "Mode") == 0) {
3060                 const char *mode = NULL;
3061
3062                 dbus_message_iter_get_basic(iter, &mode);
3063                 bss->mode = string2mode(mode);
3064         } else if (g_strcmp0(key, "Frequency") == 0) {
3065                 dbus_uint16_t frequency = 0;
3066
3067                 dbus_message_iter_get_basic(iter, &frequency);
3068                 bss->frequency = frequency;
3069         } else if (g_strcmp0(key, "Signal") == 0) {
3070                 dbus_int16_t signal = 0;
3071
3072                 dbus_message_iter_get_basic(iter, &signal);
3073
3074                 bss->signal = signal;
3075                 if (!bss->signal)
3076                         bss->signal = BSS_UNKNOWN_STRENGTH;
3077
3078         } else if (g_strcmp0(key, "Level") == 0) {
3079                 dbus_int32_t level = 0;
3080
3081                 dbus_message_iter_get_basic(iter, &level);
3082         } else if (g_strcmp0(key, "Rates") == 0) {
3083                 supplicant_dbus_array_foreach(iter, bss_rates, bss);
3084         } else if (g_strcmp0(key, "MaxRate") == 0) {
3085                 dbus_uint32_t maxrate = 0;
3086
3087                 dbus_message_iter_get_basic(iter, &maxrate);
3088                 if (maxrate != 0)
3089                         bss->maxrate = maxrate;
3090         } else if (g_strcmp0(key, "Privacy") == 0) {
3091                 dbus_bool_t privacy = FALSE;
3092
3093                 dbus_message_iter_get_basic(iter, &privacy);
3094                 bss->privacy = privacy;
3095         } else if (g_strcmp0(key, "RSN") == 0) {
3096                 bss->rsn_selected = TRUE;
3097
3098                 supplicant_dbus_property_foreach(iter, bss_wpa, bss);
3099         } else if (g_strcmp0(key, "WPA") == 0) {
3100                 bss->rsn_selected = FALSE;
3101
3102                 supplicant_dbus_property_foreach(iter, bss_wpa, bss);
3103 #if defined TIZEN_EXT
3104         } else if (g_strcmp0(key, "HS20") == 0) {
3105                 dbus_bool_t hs20 = FALSE;
3106                 dbus_message_iter_get_basic(iter, &hs20);
3107                 bss->hs20 = hs20;
3108 #endif
3109         } else if (g_strcmp0(key, "IEs") == 0)
3110                 bss_process_ies(iter, bss);
3111         else
3112                 SUPPLICANT_DBG("key %s type %c",
3113                                 key, dbus_message_iter_get_arg_type(iter));
3114 }
3115
3116 static struct g_supplicant_bss *interface_bss_added(DBusMessageIter *iter,
3117                                                         void *user_data)
3118 {
3119         GSupplicantInterface *interface = user_data;
3120         GSupplicantNetwork *network;
3121         struct g_supplicant_bss *bss;
3122         const char *path = NULL;
3123
3124         SUPPLICANT_DBG("");
3125
3126         dbus_message_iter_get_basic(iter, &path);
3127         if (!path)
3128                 return NULL;
3129
3130         if (g_strcmp0(path, "/") == 0)
3131                 return NULL;
3132
3133         SUPPLICANT_DBG("%s", path);
3134
3135         network = g_hash_table_lookup(interface->bss_mapping, path);
3136         if (network) {
3137                 bss = g_hash_table_lookup(network->bss_table, path);
3138                 if (bss)
3139                         return NULL;
3140         }
3141
3142         bss = g_try_new0(struct g_supplicant_bss, 1);
3143         if (!bss)
3144                 return NULL;
3145
3146         bss->interface = interface;
3147         bss->path = g_strdup(path);
3148         bss->signal = BSS_UNKNOWN_STRENGTH;
3149
3150         return bss;
3151 }
3152
3153 static void interface_bss_added_with_keys(DBusMessageIter *iter,
3154                                                 void *user_data)
3155 {
3156         struct g_supplicant_bss *bss;
3157
3158         SUPPLICANT_DBG("");
3159
3160         bss = interface_bss_added(iter, user_data);
3161         if (!bss)
3162                 return;
3163
3164         dbus_message_iter_next(iter);
3165
3166         if (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_INVALID)
3167 #if defined TIZEN_EXT
3168         {
3169                 g_free(bss->path);
3170                 g_free(bss);
3171                 return;
3172         }
3173 #else
3174                 return;
3175 #endif
3176
3177         supplicant_dbus_property_foreach(iter, bss_property, bss);
3178
3179         bss_compute_security(bss);
3180         if (add_or_replace_bss_to_network(bss) < 0)
3181                 SUPPLICANT_DBG("add_or_replace_bss_to_network failed");
3182 }
3183
3184 static void interface_bss_added_without_keys(DBusMessageIter *iter,
3185                                                 void *user_data)
3186 {
3187         struct g_supplicant_bss *bss;
3188
3189         SUPPLICANT_DBG("");
3190
3191         bss = interface_bss_added(iter, user_data);
3192         if (!bss)
3193                 return;
3194
3195         supplicant_dbus_property_get_all(bss->path,
3196                                         SUPPLICANT_INTERFACE ".BSS",
3197                                         bss_property, bss, bss);
3198
3199         bss_compute_security(bss);
3200         if (add_or_replace_bss_to_network(bss) < 0)
3201                         SUPPLICANT_DBG("add_or_replace_bss_to_network failed");
3202 }
3203
3204 static void update_signal(gpointer key, gpointer value,
3205                                                 gpointer user_data)
3206 {
3207         struct g_supplicant_bss *bss = value;
3208         GSupplicantNetwork *network = user_data;
3209
3210 #if defined TIZEN_EXT
3211         if (!network->best_bss || (network->best_bss == bss)) {
3212                 if (bss->signal > network->signal) {
3213                         network->signal = bss->signal;
3214                         network->best_bss = bss;
3215                 }
3216                 return;
3217         }
3218
3219         update_best_bss(network, bss, network->best_bss);
3220 #else
3221         if (bss->signal > network->signal) {
3222                 network->signal = bss->signal;
3223                 network->best_bss = bss;
3224         }
3225 #endif
3226 }
3227
3228 static void update_network_signal(GSupplicantNetwork *network)
3229 {
3230         if (g_hash_table_size(network->bss_table) <= 1 && network->best_bss)
3231                 return;
3232
3233         g_hash_table_foreach(network->bss_table,
3234                                 update_signal, network);
3235
3236         SUPPLICANT_DBG("New network signal %d", network->signal);
3237 }
3238
3239 #if defined TIZEN_EXT
3240 static gboolean last_connected_timeout(gpointer data)
3241 {
3242         GSupplicantInterface *interface = data;
3243         GSupplicantNetwork *current_network = interface->current_network;
3244
3245         SUPPLICANT_DBG("Timeout last connected bss");
3246
3247         if (current_network && current_network->best_bss) {
3248                 if (compare_bssid(current_network->best_bss->bssid, interface->connected_bssid)) {
3249                         g_supplicant_network_set_last_connected_bssid(current_network, interface->connected_bssid);
3250                         callback_network_changed(current_network, "LastConnectedBSSID");
3251                 }
3252         }
3253
3254         last_connected_bss_timeout = 0;
3255         return FALSE;
3256 }
3257
3258 static void add_timer_for_last_connected(GSupplicantInterface *interface)
3259 {
3260         GSupplicantNetwork *current_network = interface->current_network;
3261
3262         if (interface->state == G_SUPPLICANT_STATE_COMPLETED) {
3263                 if (current_network) {
3264                         struct g_supplicant_bss *best_bss = current_network->best_bss;
3265
3266                         memcpy(interface->connected_bssid, best_bss->bssid, WIFI_BSSID_LEN_MAX);
3267
3268                         if (last_connected_bss_timeout)
3269                                 g_source_remove(last_connected_bss_timeout);
3270
3271                         last_connected_bss_timeout = g_timeout_add_seconds(LAST_CONNECTED_TIMEOUT,
3272                                 last_connected_timeout, interface);
3273
3274                         SUPPLICANT_DBG("Add timer for last connected bssid [" MACSTR "]",
3275                                         MAC2STR(best_bss->bssid));
3276                 }
3277         }
3278 }
3279
3280 static void remove_timer_for_last_connected(GSupplicantInterface *interface)
3281 {
3282         if (interface->state == G_SUPPLICANT_STATE_DISCONNECTED) {
3283                 if (last_connected_bss_timeout != 0) {
3284                         g_source_remove(last_connected_bss_timeout);
3285                         last_connected_bss_timeout = 0;
3286                         SUPPLICANT_DBG("Remove timer for last connected bss");
3287                 }
3288         }
3289 }
3290 #endif
3291
3292 static void interface_current_bss(GSupplicantInterface *interface,
3293                                                 DBusMessageIter *iter)
3294 {
3295         GSupplicantNetwork *network;
3296         struct g_supplicant_bss *bss;
3297         const char *path;
3298
3299         dbus_message_iter_get_basic(iter, &path);
3300         if (g_strcmp0(path, "/") == 0) {
3301                 interface->current_network = NULL;
3302                 return;
3303         }
3304
3305         interface_bss_added_without_keys(iter, interface);
3306
3307         network = g_hash_table_lookup(interface->bss_mapping, path);
3308         if (!network)
3309                 return;
3310
3311         bss = g_hash_table_lookup(network->bss_table, path);
3312         if (!bss)
3313                 return;
3314
3315         interface->current_network = network;
3316 #if defined TIZEN_EXT
3317         SUPPLICANT_DBG("current network [%p]", interface->current_network);
3318 #endif
3319
3320         if (bss != network->best_bss) {
3321                 /*
3322                  * This is the case where either wpa_s got associated
3323                  * to a BSS different than the one ConnMan considers
3324                  * the best, or we are roaming.
3325                  */
3326                 SUPPLICANT_DBG("Update best BSS for %s", network->name);
3327
3328                 network->best_bss = bss;
3329
3330                 if (network->signal != bss->signal) {
3331                         SUPPLICANT_DBG("New network signal %d dBm",
3332                                                 bss->signal);
3333
3334                         network->signal = bss->signal;
3335                         callback_network_changed(network, "Signal");
3336                 }
3337         }
3338
3339         /*
3340          * wpa_s could notify about CurrentBSS in any state once
3341          * it got associated. It is not sure such notification will
3342          * arrive together with transition to ASSOCIATED state.
3343          * In fact, for networks with security WEP or OPEN, it
3344          * always arrives together with transition to COMPLETED.
3345          */
3346         switch (interface->state) {
3347         case G_SUPPLICANT_STATE_UNKNOWN:
3348         case G_SUPPLICANT_STATE_DISABLED:
3349         case G_SUPPLICANT_STATE_DISCONNECTED:
3350         case G_SUPPLICANT_STATE_INACTIVE:
3351         case G_SUPPLICANT_STATE_SCANNING:
3352         case G_SUPPLICANT_STATE_AUTHENTICATING:
3353         case G_SUPPLICANT_STATE_ASSOCIATING:
3354                 return;
3355         case G_SUPPLICANT_STATE_ASSOCIATED:
3356         case G_SUPPLICANT_STATE_4WAY_HANDSHAKE:
3357         case G_SUPPLICANT_STATE_GROUP_HANDSHAKE:
3358         case G_SUPPLICANT_STATE_COMPLETED:
3359                 callback_network_associated(network);
3360 #if defined TIZEN_EXT
3361                 add_timer_for_last_connected(interface);
3362 #endif
3363                 break;
3364         }
3365 }
3366
3367 static void interface_bss_removed(DBusMessageIter *iter, void *user_data)
3368 {
3369         GSupplicantInterface *interface = user_data;
3370         GSupplicantNetwork *network;
3371         struct g_supplicant_bss *bss = NULL;
3372         const char *path = NULL;
3373         bool is_current_network_bss = false;
3374
3375         dbus_message_iter_get_basic(iter, &path);
3376         if (!path)
3377                 return;
3378
3379         network = g_hash_table_lookup(interface->bss_mapping, path);
3380         if (!network)
3381                 return;
3382
3383         bss = g_hash_table_lookup(network->bss_table, path);
3384         if (network->best_bss == bss) {
3385                 network->best_bss = NULL;
3386                 network->signal = BSS_UNKNOWN_STRENGTH;
3387                 is_current_network_bss = true;
3388         }
3389
3390         g_hash_table_remove(bss_mapping, path);
3391
3392         g_hash_table_remove(interface->bss_mapping, path);
3393         g_hash_table_remove(network->bss_table, path);
3394
3395         update_network_signal(network);
3396
3397         if (g_hash_table_size(network->bss_table) == 0) {
3398                 g_hash_table_remove(interface->network_table, network->group);
3399         } else {
3400                 if (is_current_network_bss && network->best_bss)
3401 #if defined TIZEN_EXT
3402                         callback_network_changed(network, "CheckMultiBssidConnect");
3403 #else
3404                         callback_network_changed(network, "");
3405 #endif
3406         }
3407 }
3408
3409 static void set_config_methods(DBusMessageIter *iter, void *user_data)
3410 {
3411         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, user_data);
3412 }
3413
3414 static void wps_property(const char *key, DBusMessageIter *iter,
3415                                                         void *user_data)
3416 {
3417         GSupplicantInterface *interface = user_data;
3418
3419         if (!interface)
3420                 return;
3421
3422         SUPPLICANT_DBG("key: %s", key);
3423
3424         if (g_strcmp0(key, "ConfigMethods") == 0) {
3425                 const char *config_methods = "push_button", *str = NULL;
3426
3427                 dbus_message_iter_get_basic(iter, &str);
3428                 if (str && strlen(str) > 0) {
3429                         /* It was already set at wpa_s level, don't modify it. */
3430                         SUPPLICANT_DBG("%s", str);
3431                         return;
3432                 }
3433
3434                 supplicant_dbus_property_set(interface->path,
3435                         SUPPLICANT_INTERFACE ".Interface.WPS",
3436                         "ConfigMethods", DBUS_TYPE_STRING_AS_STRING,
3437                         set_config_methods, NULL, &config_methods, NULL);
3438
3439                 SUPPLICANT_DBG("No value. Set %s", config_methods);
3440         }
3441
3442 }
3443
3444 static void interface_property(const char *key, DBusMessageIter *iter,
3445                                                         void *user_data)
3446 {
3447         GSupplicantInterface *interface = user_data;
3448
3449         if (!interface)
3450                 return;
3451
3452         SUPPLICANT_DBG("%s", key);
3453
3454         if (!key) {
3455                 debug_strvalmap("KeyMgmt capability", keymgmt_map,
3456                                                 interface->keymgmt_capa);
3457                 debug_strvalmap("AuthAlg capability", authalg_capa_map,
3458                                                 interface->authalg_capa);
3459                 debug_strvalmap("Protocol capability", proto_capa_map,
3460                                                 interface->proto_capa);
3461                 debug_strvalmap("Pairwise capability", pairwise_map,
3462                                                 interface->pairwise_capa);
3463                 debug_strvalmap("Group capability", group_map,
3464                                                 interface->group_capa);
3465                 debug_strvalmap("Scan capability", scan_capa_map,
3466                                                 interface->scan_capa);
3467                 debug_strvalmap("Mode capability", mode_capa_map,
3468                                                 interface->mode_capa);
3469
3470                 supplicant_dbus_property_get_all(interface->path,
3471                                 SUPPLICANT_INTERFACE ".Interface.WPS",
3472                                 wps_property, interface, interface);
3473
3474                 if (interface->ready)
3475                         callback_interface_added(interface);
3476
3477                 return;
3478         }
3479
3480         if (g_strcmp0(key, "Capabilities") == 0) {
3481                 supplicant_dbus_property_foreach(iter, interface_capability,
3482                                                                 interface);
3483 #if !defined TIZEN_EXT
3484                 if (interface->mode_capa & G_SUPPLICANT_CAPABILITY_MODE_P2P)
3485                         interface->p2p_support = true;
3486 #endif
3487 #if defined TIZEN_EXT_WIFI_MESH
3488                 if (interface->mode_capa & G_SUPPLICANT_CAPABILITY_MODE_MESH)
3489                         interface->mesh_support = true;
3490 #endif
3491         } else if (g_strcmp0(key, "State") == 0) {
3492                 const char *str = NULL;
3493
3494                 dbus_message_iter_get_basic(iter, &str);
3495                 if (str)
3496                         if (string2state(str) != interface->state) {
3497                                 interface->state = string2state(str);
3498                                 callback_interface_state(interface);
3499                         }
3500 #if defined TIZEN_EXT
3501                 switch (interface->state) {
3502                 case G_SUPPLICANT_STATE_COMPLETED:
3503                         add_timer_for_last_connected(interface);
3504                         break;
3505                 case G_SUPPLICANT_STATE_DISCONNECTED:
3506                         remove_timer_for_last_connected(interface);
3507                         break;
3508                 default:
3509                         break;
3510                 }
3511 #endif
3512                 if (interface->ap_create_in_progress) {
3513                         if (interface->state == G_SUPPLICANT_STATE_DISCONNECTED)
3514                                 callback_ap_create_fail(interface);
3515
3516                         interface->ap_create_in_progress = false;
3517                 }
3518
3519                 if (interface->state == G_SUPPLICANT_STATE_DISABLED)
3520                         interface->ready = FALSE;
3521                 else
3522                         interface->ready = TRUE;
3523
3524                 SUPPLICANT_DBG("state %s (%d)", str, interface->state);
3525         } else if (g_strcmp0(key, "Scanning") == 0) {
3526                 dbus_bool_t scanning = FALSE;
3527
3528                 dbus_message_iter_get_basic(iter, &scanning);
3529                 interface->scanning = scanning;
3530
3531                 if (interface->ready) {
3532                         if (interface->scanning)
3533                                 callback_scan_started(interface);
3534                         else
3535                                 callback_scan_finished(interface);
3536                 }
3537         } else if (g_strcmp0(key, "ApScan") == 0) {
3538                 int apscan = 1;
3539
3540                 dbus_message_iter_get_basic(iter, &apscan);
3541                 interface->apscan = apscan;
3542         } else if (g_strcmp0(key, "Ifname") == 0) {
3543                 const char *str = NULL;
3544
3545                 dbus_message_iter_get_basic(iter, &str);
3546                 if (str) {
3547                         g_free(interface->ifname);
3548                         interface->ifname = g_strdup(str);
3549                 }
3550         } else if (g_strcmp0(key, "Driver") == 0) {
3551                 const char *str = NULL;
3552
3553                 dbus_message_iter_get_basic(iter, &str);
3554                 if (str) {
3555                         g_free(interface->driver);
3556                         interface->driver = g_strdup(str);
3557                 }
3558         } else if (g_strcmp0(key, "BridgeIfname") == 0) {
3559                 const char *str = NULL;
3560
3561                 dbus_message_iter_get_basic(iter, &str);
3562                 if (str) {
3563                         g_free(interface->bridge);
3564                         interface->bridge = g_strdup(str);
3565                 }
3566         } else if (g_strcmp0(key, "ConfigFile") == 0) {
3567                 const char *str = NULL;
3568
3569                 dbus_message_iter_get_basic(iter, &str);
3570                 if (str && strlen(str) > 0 && interface->ifname) {
3571                         SUPPLICANT_DBG("New {%s, %s}", interface->ifname, str);
3572                         g_hash_table_replace(config_file_table,
3573                                 g_strdup(interface->ifname), g_strdup(str));
3574                 }
3575         } else if (g_strcmp0(key, "CurrentBSS") == 0) {
3576                 interface_current_bss(interface, iter);
3577         } else if (g_strcmp0(key, "CurrentNetwork") == 0) {
3578 #if defined TIZEN_EXT
3579                 if (interface->state != G_SUPPLICANT_STATE_COMPLETED)
3580 #endif
3581                 interface_network_added(iter, interface);
3582         } else if (g_strcmp0(key, "BSSs") == 0) {
3583                 supplicant_dbus_array_foreach(iter,
3584                                         interface_bss_added_without_keys,
3585                                         interface);
3586         } else if (g_strcmp0(key, "Blobs") == 0) {
3587                 /* Nothing */
3588         } else if (g_strcmp0(key, "Networks") == 0) {
3589                 supplicant_dbus_array_foreach(iter, interface_network_added,
3590                                                                 interface);
3591         } else if (g_strcmp0(key, "DisconnectReason") == 0) {
3592                 int reason_code;
3593                 if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_INVALID) {
3594                         dbus_message_iter_get_basic(iter, &reason_code);
3595                         callback_disconnect_reason_code(interface, reason_code);
3596 #if defined TIZEN_EXT
3597                         SUPPLICANT_DBG("reason code (%d)", reason_code);
3598 #endif
3599                 }
3600         } else if (g_strcmp0(key, "AssocStatusCode") == 0) {
3601                 int status_code;
3602                 if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_INVALID) {
3603                         dbus_message_iter_get_basic(iter, &status_code);
3604                         callback_assoc_status_code(interface, status_code);
3605 #if defined TIZEN_EXT
3606                         SUPPLICANT_DBG("status code (%d)", status_code);
3607 #endif
3608                 }
3609         } else {
3610                 SUPPLICANT_DBG("key %s type %c",
3611                                 key, dbus_message_iter_get_arg_type(iter));
3612         }
3613 }
3614
3615 static void scan_network_update(DBusMessageIter *iter, void *user_data)
3616 {
3617         GSupplicantInterface *interface = user_data;
3618         GSupplicantNetwork *network;
3619         char *path;
3620
3621         if (!iter)
3622                 return;
3623
3624         dbus_message_iter_get_basic(iter, &path);
3625
3626         if (!path)
3627                 return;
3628
3629         if (g_strcmp0(path, "/") == 0)
3630                 return;
3631
3632         /* Update the network details based on scan BSS data */
3633         network = g_hash_table_lookup(interface->bss_mapping, path);
3634         if (network)
3635                 callback_network_added(network);
3636 }
3637
3638 static void scan_bss_data(const char *key, DBusMessageIter *iter,
3639                                 void *user_data)
3640 {
3641         GSupplicantInterface *interface = user_data;
3642
3643 /*Fixed : stucking in scanning state when scan failed*/
3644 #if defined TIZEN_EXT
3645         GSupplicantInterfaceCallback scan_callback;
3646         SUPPLICANT_DBG("");
3647 #endif
3648
3649         if (iter)
3650                 supplicant_dbus_array_foreach(iter, scan_network_update,
3651                                                 interface);
3652
3653 #if defined TIZEN_EXT
3654         scan_callback = interface->scan_callback;
3655         callback_scan_done(interface);
3656 #endif
3657
3658         if (interface->scan_callback)
3659                 interface->scan_callback(0, interface, interface->scan_data);
3660
3661 #if defined TIZEN_EXT
3662         if (interface->scan_callback == scan_callback) {
3663 #endif
3664         interface->scan_callback = NULL;
3665         interface->scan_data = NULL;
3666 #if defined TIZEN_EXT
3667         }
3668 #endif
3669 }
3670
3671 static GSupplicantInterface *interface_alloc(const char *path)
3672 {
3673         GSupplicantInterface *interface;
3674
3675         interface = g_try_new0(GSupplicantInterface, 1);
3676         if (!interface)
3677                 return NULL;
3678
3679         interface->path = g_strdup(path);
3680
3681         interface->network_table = g_hash_table_new_full(g_str_hash,
3682                                         g_str_equal, NULL, remove_network);
3683         interface->peer_table = g_hash_table_new_full(g_str_hash,
3684                                         g_str_equal, NULL, remove_peer);
3685         interface->group_table = g_hash_table_new_full(g_str_hash,
3686                                         g_str_equal, NULL, remove_group);
3687         interface->bss_mapping = g_hash_table_new_full(g_str_hash, g_str_equal,
3688                                                                 NULL, NULL);
3689
3690         g_hash_table_replace(interface_table, interface->path, interface);
3691
3692         return interface;
3693 }
3694
3695 static void interface_added(DBusMessageIter *iter, void *user_data)
3696 {
3697         GSupplicantInterface *interface;
3698         const char *path = NULL;
3699         bool properties_appended = GPOINTER_TO_UINT(user_data);
3700
3701         SUPPLICANT_DBG("");
3702
3703         dbus_message_iter_get_basic(iter, &path);
3704         if (!path)
3705                 return;
3706
3707         if (g_strcmp0(path, "/") == 0)
3708                 return;
3709
3710         interface = g_hash_table_lookup(interface_table, path);
3711         if (interface)
3712                 return;
3713
3714         interface = interface_alloc(path);
3715         if (!interface)
3716                 return;
3717
3718         if (!properties_appended) {
3719                 supplicant_dbus_property_get_all(path,
3720                                                 SUPPLICANT_INTERFACE ".Interface",
3721                                                 interface_property, interface,
3722                                                 interface);
3723                 return;
3724         }
3725
3726         dbus_message_iter_next(iter);
3727         if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_INVALID) {
3728                 supplicant_dbus_property_foreach(iter, interface_property,
3729                                                                 interface);
3730                 interface_property(NULL, NULL, interface);
3731         }
3732 }
3733
3734 static void interface_removed(DBusMessageIter *iter, void *user_data)
3735 {
3736         const char *path = NULL;
3737         GSupplicantInterface *interface = user_data;
3738
3739         dbus_message_iter_get_basic(iter, &path);
3740         if (!path)
3741                 return;
3742
3743         interface = g_hash_table_lookup(interface_table, path);
3744         g_supplicant_interface_cancel(interface);
3745
3746         g_hash_table_remove(interface_table, path);
3747 }
3748
3749 static void eap_method(DBusMessageIter *iter, void *user_data)
3750 {
3751         const char *str = NULL;
3752         int i;
3753
3754         dbus_message_iter_get_basic(iter, &str);
3755         if (!str)
3756                 return;
3757
3758         for (i = 0; eap_method_map[i].str; i++)
3759                 if (strcmp(str, eap_method_map[i].str) == 0) {
3760                         eap_methods |= eap_method_map[i].val;
3761                         break;
3762                 }
3763 }
3764
3765 static void service_property(const char *key, DBusMessageIter *iter,
3766                                                         void *user_data)
3767 {
3768         if (!key) {
3769                 callback_system_ready();
3770                 return;
3771         }
3772
3773         if (g_strcmp0(key, "DebugLevel") == 0) {
3774                 const char *str = NULL;
3775                 int i;
3776
3777                 dbus_message_iter_get_basic(iter, &str);
3778                 for (i = 0; debug_strings[i]; i++)
3779                         if (g_strcmp0(debug_strings[i], str) == 0) {
3780                                 debug_level = i;
3781                                 break;
3782                         }
3783                 SUPPLICANT_DBG("Debug level %d", debug_level);
3784         } else if (g_strcmp0(key, "DebugTimestamp") == 0) {
3785                 dbus_message_iter_get_basic(iter, &debug_timestamp);
3786                 SUPPLICANT_DBG("Debug timestamp %u", debug_timestamp);
3787         } else if (g_strcmp0(key, "DebugShowKeys") == 0) {
3788                 dbus_message_iter_get_basic(iter, &debug_showkeys);
3789                 SUPPLICANT_DBG("Debug show keys %u", debug_showkeys);
3790         } else if (g_strcmp0(key, "Interfaces") == 0) {
3791                 supplicant_dbus_array_foreach(iter, interface_added, NULL);
3792         } else if (g_strcmp0(key, "EapMethods") == 0) {
3793                 supplicant_dbus_array_foreach(iter, eap_method, NULL);
3794                 debug_strvalmap("EAP method", eap_method_map, eap_methods);
3795         } else if (g_strcmp0(key, "Country") == 0) {
3796                 const char *country = NULL;
3797
3798                 dbus_message_iter_get_basic(iter, &country);
3799                 SUPPLICANT_DBG("Country %s", country);
3800         } else
3801                 SUPPLICANT_DBG("key %s type %c",
3802                                 key, dbus_message_iter_get_arg_type(iter));
3803 }
3804
3805 static void signal_name_owner_changed(const char *path, DBusMessageIter *iter)
3806 {
3807         const char *name = NULL, *old = NULL, *new = NULL;
3808
3809         SUPPLICANT_DBG("");
3810
3811         if (g_strcmp0(path, DBUS_PATH_DBUS) != 0)
3812                 return;
3813
3814         dbus_message_iter_get_basic(iter, &name);
3815         if (!name)
3816                 return;
3817
3818         if (g_strcmp0(name, SUPPLICANT_SERVICE) != 0)
3819                 return;
3820
3821         dbus_message_iter_next(iter);
3822         dbus_message_iter_get_basic(iter, &old);
3823         dbus_message_iter_next(iter);
3824         dbus_message_iter_get_basic(iter, &new);
3825
3826         if (!old || !new)
3827                 return;
3828
3829         if (strlen(old) > 0 && strlen(new) == 0) {
3830                 system_available = FALSE;
3831                 g_hash_table_remove_all(bss_mapping);
3832                 g_hash_table_remove_all(peer_mapping);
3833                 g_hash_table_remove_all(group_mapping);
3834                 g_hash_table_remove_all(config_file_table);
3835                 g_hash_table_remove_all(interface_table);
3836                 callback_system_killed();
3837         }
3838
3839         if (strlen(new) > 0 && strlen(old) == 0) {
3840                 system_available = TRUE;
3841                 supplicant_dbus_property_get_all(SUPPLICANT_PATH,
3842                                                 SUPPLICANT_INTERFACE,
3843                                                 service_property, NULL, NULL);
3844         }
3845 }
3846
3847 static void signal_properties_changed(const char *path, DBusMessageIter *iter)
3848 {
3849         SUPPLICANT_DBG("");
3850
3851         if (g_strcmp0(path, SUPPLICANT_PATH) != 0)
3852                 return;
3853
3854         supplicant_dbus_property_foreach(iter, service_property, NULL);
3855 }
3856
3857 static void signal_interface_added(const char *path, DBusMessageIter *iter)
3858 {
3859         SUPPLICANT_DBG("path %s %s", path, SUPPLICANT_PATH);
3860
3861         if (g_strcmp0(path, SUPPLICANT_PATH) == 0)
3862                 interface_added(iter, GUINT_TO_POINTER(true));
3863 }
3864
3865 static void signal_interface_removed(const char *path, DBusMessageIter *iter)
3866 {
3867         SUPPLICANT_DBG("");
3868
3869         if (g_strcmp0(path, SUPPLICANT_PATH) == 0)
3870                 interface_removed(iter, NULL);
3871 }
3872
3873 static void signal_interface_changed(const char *path, DBusMessageIter *iter)
3874 {
3875         GSupplicantInterface *interface;
3876
3877         SUPPLICANT_DBG("");
3878
3879         interface = g_hash_table_lookup(interface_table, path);
3880         if (!interface)
3881                 return;
3882
3883         supplicant_dbus_property_foreach(iter, interface_property, interface);
3884 }
3885
3886 static void signal_scan_done(const char *path, DBusMessageIter *iter)
3887 {
3888         GSupplicantInterface *interface;
3889         dbus_bool_t success = FALSE;
3890
3891         SUPPLICANT_DBG("");
3892
3893         interface = g_hash_table_lookup(interface_table, path);
3894         if (!interface)
3895                 return;
3896
3897         dbus_message_iter_get_basic(iter, &success);
3898
3899         if (interface->scanning) {
3900                 callback_scan_finished(interface);
3901                 interface->scanning = FALSE;
3902         }
3903
3904         /*
3905          * If scan is unsuccessful return -EIO else get the scanned BSSs
3906          * and update the network details accordingly
3907          */
3908         if (!success) {
3909                 if (interface->scan_callback)
3910                         interface->scan_callback(-EIO, interface,
3911                                                 interface->scan_data);
3912
3913                 interface->scan_callback = NULL;
3914                 interface->scan_data = NULL;
3915
3916                 return;
3917         }
3918
3919         supplicant_dbus_property_get(path, SUPPLICANT_INTERFACE ".Interface",
3920                                 "BSSs", scan_bss_data, interface, interface);
3921 }
3922
3923 static void signal_bss_added(const char *path, DBusMessageIter *iter)
3924 {
3925         GSupplicantInterface *interface;
3926
3927         SUPPLICANT_DBG("");
3928
3929         interface = g_hash_table_lookup(interface_table, path);
3930         if (!interface)
3931                 return;
3932
3933         interface_bss_added_with_keys(iter, interface);
3934 }
3935
3936 static void signal_bss_removed(const char *path, DBusMessageIter *iter)
3937 {
3938         GSupplicantInterface *interface;
3939
3940         SUPPLICANT_DBG("");
3941
3942         interface = g_hash_table_lookup(interface_table, path);
3943         if (!interface)
3944                 return;
3945
3946         interface_bss_removed(iter, interface);
3947 }
3948
3949 static void signal_network_added(const char *path, DBusMessageIter *iter)
3950 {
3951         GSupplicantInterface *interface;
3952
3953         SUPPLICANT_DBG("");
3954
3955         interface = g_hash_table_lookup(interface_table, path);
3956         if (!interface)
3957                 return;
3958
3959         interface_network_added(iter, interface);
3960 }
3961
3962 static void signal_network_removed(const char *path, DBusMessageIter *iter)
3963 {
3964         GSupplicantInterface *interface;
3965
3966         SUPPLICANT_DBG("");
3967
3968         interface = g_hash_table_lookup(interface_table, path);
3969         if (!interface)
3970                 return;
3971
3972         interface_network_removed(iter, interface);
3973 }
3974 #if defined TIZEN_EXT
3975 void *copy_vsie_list(gconstpointer src, gpointer data)
3976 {
3977         return g_strdup(src);
3978 }
3979 #endif
3980
3981
3982 static void signal_sta_authorized(const char *path, DBusMessageIter *iter)
3983 {
3984         GSupplicantInterface *interface;
3985         const char *addr = NULL;
3986
3987         SUPPLICANT_DBG("");
3988
3989         interface = g_hash_table_lookup(interface_table, path);
3990         if (!interface)
3991                 return;
3992
3993         dbus_message_iter_get_basic(iter, &addr);
3994         if (!addr)
3995                 return;
3996
3997         callback_sta_authorized(interface, addr);
3998 }
3999
4000 static void signal_sta_deauthorized(const char *path, DBusMessageIter *iter)
4001 {
4002         GSupplicantInterface *interface;
4003         const char *addr = NULL;
4004
4005         SUPPLICANT_DBG("");
4006
4007         interface = g_hash_table_lookup(interface_table, path);
4008         if (!interface)
4009                 return;
4010
4011         dbus_message_iter_get_basic(iter, &addr);
4012         if (!addr)
4013                 return;
4014
4015         callback_sta_deauthorized(interface, addr);
4016 }
4017
4018 static void signal_bss_changed(const char *path, DBusMessageIter *iter)
4019 {
4020         GSupplicantInterface *interface;
4021         GSupplicantNetwork *network;
4022         GSupplicantSecurity old_security;
4023         unsigned int old_wps_capabilities;
4024         struct g_supplicant_bss *bss;
4025
4026         SUPPLICANT_DBG("");
4027
4028         interface = g_hash_table_lookup(bss_mapping, path);
4029         if (!interface)
4030                 return;
4031
4032         network = g_hash_table_lookup(interface->bss_mapping, path);
4033         if (!network)
4034                 return;
4035
4036         bss = g_hash_table_lookup(network->bss_table, path);
4037         if (!bss)
4038                 return;
4039
4040         supplicant_dbus_property_foreach(iter, bss_property, bss);
4041
4042 #if defined TIZEN_EXT
4043         network->frequency = bss->frequency;
4044         network->phy_mode = bss->phy_mode;
4045 #endif
4046         old_security = network->security;
4047         bss_compute_security(bss);
4048
4049         if (old_security != bss->security) {
4050                 struct g_supplicant_bss *new_bss;
4051
4052                 SUPPLICANT_DBG("New network security for %s with path %s",
4053                                bss->ssid, bss->path);
4054
4055                 /*
4056                  * Security change policy:
4057                  * - We first copy the current bss into a new one with
4058                  *   its own pointer (path)
4059                  * - Clear the old bss pointer and remove the network completely
4060                  *   if there are no more BSSs in the bss table.
4061                  * - The new bss will be added either to an existing network
4062                  *   or an additional network will be created
4063                  */
4064
4065                 new_bss = g_try_new0(struct g_supplicant_bss, 1);
4066                 if (!new_bss)
4067                         return;
4068
4069                 memcpy(new_bss, bss, sizeof(struct g_supplicant_bss));
4070                 new_bss->path = g_strdup(bss->path);
4071 #if defined TIZEN_EXT
4072                 new_bss->vsie_list = g_slist_copy_deep(bss->vsie_list, copy_vsie_list, NULL);
4073 #endif
4074
4075                 if (network->best_bss == bss) {
4076                         network->best_bss = NULL;
4077                         network->signal = BSS_UNKNOWN_STRENGTH;
4078                 }
4079
4080                 g_hash_table_remove(bss_mapping, path);
4081
4082                 g_hash_table_remove(interface->bss_mapping, path);
4083                 g_hash_table_remove(network->bss_table, path);
4084
4085                 update_network_signal(network);
4086
4087                 if (g_hash_table_size(network->bss_table) == 0)
4088                         g_hash_table_remove(interface->network_table,
4089                                             network->group);
4090
4091                 if (add_or_replace_bss_to_network(new_bss) < 0) {
4092                         /*
4093                          * Prevent a memory leak on failure in
4094                          * add_or_replace_bss_to_network
4095                          */
4096                         SUPPLICANT_DBG("Failed to add bss %s to network table",
4097                                        new_bss->path);
4098                         g_free(new_bss->path);
4099                         g_free(new_bss);
4100                 }
4101
4102                 return;
4103         }
4104
4105         old_wps_capabilities = network->wps_capabilities;
4106
4107         if (old_wps_capabilities != bss->wps_capabilities) {
4108                 network->wps_capabilities = bss->wps_capabilities;
4109                 callback_network_changed(network, "WPSCapabilities");
4110         }
4111
4112 #if defined TIZEN_EXT
4113         if ((bss->keymgmt & G_SUPPLICANT_KEYMGMT_WPS) != 0) {
4114                 network->wps = TRUE;
4115                 network->wps_capabilities |= bss->wps_capabilities;
4116         } else
4117                 network->wps = FALSE;
4118 #endif
4119
4120         /* Consider only property changes of the connected BSS */
4121         if (network == interface->current_network && bss != network->best_bss)
4122                 return;
4123
4124         if (bss->signal == network->signal)
4125 #ifndef TIZEN_EXT
4126                 return;
4127 #else
4128         {
4129                 callback_network_changed(network, "");
4130                 return;
4131         }
4132 #endif
4133
4134         /*
4135          * If the new signal is lower than the SSID signal, we need
4136          * to check for the new maximum.
4137          */
4138 #if defined TIZEN_EXT
4139         if (!update_best_bss(network, bss, network->best_bss)) {
4140                 if (bss != network->best_bss) {
4141                         callback_network_changed(network, "");
4142                         return;
4143                 }
4144
4145                 network->signal = bss->signal;
4146                 update_network_signal(network);
4147         }
4148 #else
4149         if (bss->signal < network->signal) {
4150                 if (bss != network->best_bss)
4151                         return;
4152
4153                 network->signal = bss->signal;
4154                 update_network_signal(network);
4155         } else {
4156                 network->signal = bss->signal;
4157                 network->best_bss = bss;
4158         }
4159 #endif
4160
4161         SUPPLICANT_DBG("New network signal for %s %d dBm", network->ssid,
4162                         network->signal);
4163
4164         callback_network_changed(network, "Signal");
4165 }
4166
4167 static void wps_credentials(const char *key, DBusMessageIter *iter,
4168                         void *user_data)
4169 {
4170         GSupplicantInterface *interface = user_data;
4171
4172         if (!key)
4173                 return;
4174
4175         SUPPLICANT_DBG("key %s", key);
4176
4177         if (g_strcmp0(key, "Key") == 0) {
4178                 DBusMessageIter array;
4179                 unsigned char *key_val;
4180                 int key_len;
4181
4182                 dbus_message_iter_recurse(iter, &array);
4183                 dbus_message_iter_get_fixed_array(&array, &key_val, &key_len);
4184
4185                 g_free(interface->wps_cred.key);
4186                 interface->wps_cred.key = g_try_malloc0(
4187                                                 sizeof(char) * key_len + 1);
4188
4189                 if (!interface->wps_cred.key)
4190                         return;
4191
4192                 memcpy(interface->wps_cred.key, key_val,
4193                                                 sizeof(char) * key_len);
4194
4195                 SUPPLICANT_DBG("WPS key present");
4196         } else if (g_strcmp0(key, "SSID") == 0) {
4197                 DBusMessageIter array;
4198                 unsigned char *ssid;
4199                 int ssid_len;
4200
4201                 dbus_message_iter_recurse(iter, &array);
4202                 dbus_message_iter_get_fixed_array(&array, &ssid, &ssid_len);
4203
4204                 if (ssid_len > 0 && ssid_len < 33) {
4205                         memcpy(interface->wps_cred.ssid, ssid, ssid_len);
4206                         interface->wps_cred.ssid_len = ssid_len;
4207                 } else {
4208                         memset(interface->wps_cred.ssid, 0, 32);
4209                         interface->wps_cred.ssid_len = 0;
4210                 }
4211         }
4212 }
4213
4214 static void signal_wps_credentials(const char *path, DBusMessageIter *iter)
4215 {
4216         GSupplicantInterface *interface;
4217
4218         SUPPLICANT_DBG("");
4219
4220         interface = g_hash_table_lookup(interface_table, path);
4221         if (!interface)
4222                 return;
4223
4224         supplicant_dbus_property_foreach(iter, wps_credentials, interface);
4225 }
4226
4227 static void wps_event_args(const char *key, DBusMessageIter *iter,
4228                         void *user_data)
4229 {
4230         GSupplicantInterface *interface = user_data;
4231
4232         if (!key || !interface)
4233                 return;
4234
4235         SUPPLICANT_DBG("Arg Key %s", key);
4236 }
4237
4238 static void signal_wps_event(const char *path, DBusMessageIter *iter)
4239 {
4240         GSupplicantInterface *interface;
4241         const char *name = NULL;
4242
4243         SUPPLICANT_DBG("");
4244
4245         interface = g_hash_table_lookup(interface_table, path);
4246         if (!interface)
4247                 return;
4248
4249         dbus_message_iter_get_basic(iter, &name);
4250
4251         SUPPLICANT_DBG("Name: %s", name);
4252
4253         if (g_strcmp0(name, "success") == 0)
4254                 interface->wps_state = G_SUPPLICANT_WPS_STATE_SUCCESS;
4255         else if (g_strcmp0(name, "fail") == 0)
4256                 interface->wps_state = G_SUPPLICANT_WPS_STATE_FAIL;
4257         else
4258                 interface->wps_state = G_SUPPLICANT_WPS_STATE_UNKNOWN;
4259
4260         if (!dbus_message_iter_has_next(iter))
4261                 return;
4262
4263         dbus_message_iter_next(iter);
4264
4265         supplicant_dbus_property_foreach(iter, wps_event_args, interface);
4266 }
4267
4268 #if defined TIZEN_EXT
4269 static void signal_power_off(const char *path, DBusMessageIter *iter)
4270 {
4271         int poweroff_state = 0;
4272
4273         dbus_message_iter_get_basic(iter, &poweroff_state);
4274
4275         SUPPLICANT_DBG("poweroff_state(%d)", poweroff_state);
4276
4277         /* POWER_OFF_DIRECT 2 && POWER_OFF_RESTART 3 */
4278         if (poweroff_state != 2 && poweroff_state != 3)
4279                 return;
4280
4281         if (callbacks_pointer == NULL)
4282                 return;
4283
4284         if (callbacks_pointer->system_power_off == NULL)
4285                 return;
4286
4287         callbacks_pointer->system_power_off();
4288 }
4289 #endif
4290
4291 static void create_peer_identifier(GSupplicantPeer *peer)
4292 {
4293         const unsigned char test[ETH_ALEN] = {};
4294
4295         if (!peer)
4296                 return;
4297
4298         if (!memcmp(peer->device_address, test, ETH_ALEN)) {
4299                 peer->identifier = g_strdup(peer->name);
4300                 return;
4301         }
4302
4303         peer->identifier = g_malloc0(19);
4304         snprintf(peer->identifier, 19, "%02x%02x%02x%02x%02x%02x",
4305                                                 peer->device_address[0],
4306                                                 peer->device_address[1],
4307                                                 peer->device_address[2],
4308                                                 peer->device_address[3],
4309                                                 peer->device_address[4],
4310                                                 peer->device_address[5]);
4311 }
4312
4313 struct peer_property_data {
4314         GSupplicantPeer *peer;
4315         GSList *old_groups;
4316         bool groups_changed;
4317         bool services_changed;
4318 };
4319
4320 static void peer_groups_relation(DBusMessageIter *iter, void *user_data)
4321 {
4322         struct peer_property_data *data = user_data;
4323         GSupplicantPeer *peer = data->peer;
4324         GSupplicantGroup *group;
4325         const char *str = NULL;
4326         GSList *elem;
4327
4328         dbus_message_iter_get_basic(iter, &str);
4329         if (!str)
4330                 return;
4331
4332         group = g_hash_table_lookup(group_mapping, str);
4333         if (!group)
4334                 return;
4335
4336         elem = g_slist_find_custom(data->old_groups, str, (GCompareFunc)g_strcmp0);
4337         if (elem) {
4338                 data->old_groups = g_slist_remove_link(data->old_groups, elem);
4339                 peer->groups = g_slist_concat(elem, peer->groups);
4340         } else {
4341                 peer->groups = g_slist_prepend(peer->groups, g_strdup(str));
4342                 data->groups_changed = true;
4343         }
4344 }
4345
4346 static void peer_property(const char *key, DBusMessageIter *iter,
4347                                                         void *user_data)
4348 {
4349         GSupplicantPeer *pending_peer;
4350         struct peer_property_data *data = user_data;
4351         GSupplicantPeer *peer = data->peer;
4352
4353         SUPPLICANT_DBG("key: %s", key);
4354
4355         if (!peer->interface)
4356                 return;
4357
4358         if (!key) {
4359                 if (peer->name) {
4360                         create_peer_identifier(peer);
4361                         callback_peer_found(peer);
4362                         pending_peer = g_hash_table_lookup(
4363                                         pending_peer_connection, peer->path);
4364
4365                         if (pending_peer && pending_peer == peer) {
4366                                 callback_peer_request(peer);
4367                                 g_hash_table_remove(pending_peer_connection,
4368                                                 peer->path);
4369                         }
4370
4371                         dbus_free(data);
4372                 }
4373
4374                 return;
4375         }
4376
4377         if (g_strcmp0(key, "DeviceAddress") == 0) {
4378                 unsigned char *dev_addr;
4379                 DBusMessageIter array;
4380                 int len;
4381
4382                 dbus_message_iter_recurse(iter, &array);
4383                 dbus_message_iter_get_fixed_array(&array, &dev_addr, &len);
4384
4385                 if (len == ETH_ALEN)
4386                         memcpy(peer->device_address, dev_addr, len);
4387         } else if (g_strcmp0(key, "DeviceName") == 0) {
4388                 const char *str = NULL;
4389
4390                 dbus_message_iter_get_basic(iter, &str);
4391                 if (str)
4392                         peer->name = g_strdup(str);
4393         } else if (g_strcmp0(key, "config_method") == 0) {
4394                 uint16_t wps_config;
4395
4396                 dbus_message_iter_get_basic(iter, &wps_config);
4397
4398                 if (wps_config & G_SUPPLICANT_WPS_CONFIG_PBC)
4399                         peer->wps_capabilities |= G_SUPPLICANT_WPS_PBC;
4400                 if (wps_config & ~G_SUPPLICANT_WPS_CONFIG_PBC)
4401                         peer->wps_capabilities |= G_SUPPLICANT_WPS_PIN;
4402         } else if (g_strcmp0(key, "Groups") == 0) {
4403                 data->old_groups = peer->groups;
4404                 peer->groups = NULL;
4405
4406                 supplicant_dbus_array_foreach(iter,
4407                                                 peer_groups_relation, data);
4408                 if (g_slist_length(data->old_groups) > 0) {
4409                         g_slist_free_full(data->old_groups, g_free);
4410                         data->groups_changed = true;
4411                 }
4412         } else if (g_strcmp0(key, "IEs") == 0) {
4413                 DBusMessageIter array;
4414                 unsigned char *ie;
4415                 int ie_len;
4416
4417                 dbus_message_iter_recurse(iter, &array);
4418                 dbus_message_iter_get_fixed_array(&array, &ie, &ie_len);
4419
4420                 if (!ie || ie_len < 2)
4421                         return;
4422
4423                 if (peer->widi_ies) {
4424                         if (memcmp(peer->widi_ies, ie, ie_len) == 0)
4425                                 return;
4426
4427                         g_free(peer->widi_ies);
4428                         peer->widi_ies_length = 0;
4429                 }
4430
4431                 peer->widi_ies = g_malloc0(ie_len * sizeof(unsigned char));
4432
4433                 memcpy(peer->widi_ies, ie, ie_len);
4434                 peer->widi_ies_length = ie_len;
4435                 data->services_changed = true;
4436         }
4437 }
4438
4439 static void signal_peer_found(const char *path, DBusMessageIter *iter)
4440 {
4441         struct peer_property_data *property_data;
4442         GSupplicantInterface *interface;
4443         const char *obj_path = NULL;
4444         GSupplicantPeer *peer;
4445
4446         SUPPLICANT_DBG("");
4447
4448         interface = g_hash_table_lookup(interface_table, path);
4449         if (!interface)
4450                 return;
4451
4452         dbus_message_iter_get_basic(iter, &obj_path);
4453         if (!obj_path || g_strcmp0(obj_path, "/") == 0)
4454                 return;
4455
4456         peer = g_hash_table_lookup(interface->peer_table, obj_path);
4457         if (peer)
4458                 return;
4459
4460         peer = g_try_new0(GSupplicantPeer, 1);
4461         if (!peer)
4462                 return;
4463
4464         peer->interface = interface;
4465         peer->path = g_strdup(obj_path);
4466         g_hash_table_insert(interface->peer_table, peer->path, peer);
4467         g_hash_table_replace(peer_mapping, peer->path, interface);
4468
4469         property_data = dbus_malloc0(sizeof(struct peer_property_data));
4470         property_data->peer = peer;
4471
4472         dbus_message_iter_next(iter);
4473         if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_INVALID) {
4474                 supplicant_dbus_property_foreach(iter, peer_property,
4475                                                         property_data);
4476                 peer_property(NULL, NULL, property_data);
4477                 return;
4478         }
4479
4480         supplicant_dbus_property_get_all(obj_path,
4481                                         SUPPLICANT_INTERFACE ".Peer",
4482                                         peer_property, property_data, NULL);
4483 }
4484
4485 static void signal_peer_lost(const char *path, DBusMessageIter *iter)
4486 {
4487         GSupplicantInterface *interface;
4488         const char *obj_path = NULL;
4489         GSupplicantPeer *peer;
4490
4491         SUPPLICANT_DBG("");
4492
4493         interface = g_hash_table_lookup(interface_table, path);
4494         if (!interface)
4495                 return;
4496
4497         dbus_message_iter_get_basic(iter, &obj_path);
4498         if (!obj_path || g_strcmp0(obj_path, "/") == 0)
4499                 return;
4500
4501         peer = g_hash_table_lookup(interface->peer_table, obj_path);
4502         if (!peer)
4503                 return;
4504
4505         g_hash_table_remove(interface->peer_table, obj_path);
4506 }
4507
4508 static void signal_peer_changed(const char *path, DBusMessageIter *iter)
4509 {
4510         struct peer_property_data *property_data;
4511         GSupplicantInterface *interface;
4512         GSupplicantPeer *peer;
4513
4514         SUPPLICANT_DBG("");
4515
4516         interface = g_hash_table_lookup(peer_mapping, path);
4517         if (!interface)
4518                 return;
4519
4520         peer = g_hash_table_lookup(interface->peer_table, path);
4521         if (!peer) {
4522                 g_hash_table_remove(peer_mapping, path);
4523                 return;
4524         }
4525
4526         property_data = dbus_malloc0(sizeof(struct peer_property_data));
4527         property_data->peer = peer;
4528
4529         supplicant_dbus_property_foreach(iter, peer_property, property_data);
4530         if (property_data->services_changed)
4531                 callback_peer_changed(peer,
4532                                         G_SUPPLICANT_PEER_SERVICES_CHANGED);
4533
4534         if (property_data->groups_changed)
4535                 callback_peer_changed(peer, G_SUPPLICANT_PEER_GROUP_CHANGED);
4536
4537         dbus_free(property_data);
4538
4539         if (!g_supplicant_peer_is_in_a_group(peer))
4540                 peer->connection_requested = false;
4541 }
4542
4543 struct group_sig_data {
4544         const char *peer_obj_path;
4545         unsigned char iface_address[ETH_ALEN];
4546         const char *interface_obj_path;
4547         const char *group_obj_path;
4548         int role;
4549 };
4550
4551 static void group_sig_property(const char *key, DBusMessageIter *iter,
4552                                                         void *user_data)
4553 {
4554         struct group_sig_data *data = user_data;
4555
4556         if (!key)
4557                 return;
4558
4559         if (g_strcmp0(key, "peer_interface_addr") == 0) {
4560                 unsigned char *dev_addr;
4561                 DBusMessageIter array;
4562                 int len;
4563
4564                 dbus_message_iter_recurse(iter, &array);
4565                 dbus_message_iter_get_fixed_array(&array, &dev_addr, &len);
4566
4567                 if (len == ETH_ALEN)
4568                         memcpy(data->iface_address, dev_addr, len);
4569         } else if (g_strcmp0(key, "role") == 0) {
4570                 const char *str = NULL;
4571
4572                 dbus_message_iter_get_basic(iter, &str);
4573                 if (g_strcmp0(str, "GO") == 0)
4574                         data->role = G_SUPPLICANT_GROUP_ROLE_GO;
4575                 else
4576                         data->role = G_SUPPLICANT_GROUP_ROLE_CLIENT;
4577         } else if (g_strcmp0(key, "peer_object") == 0)
4578                 dbus_message_iter_get_basic(iter, &data->peer_obj_path);
4579         else if (g_strcmp0(key, "interface_object") == 0)
4580                 dbus_message_iter_get_basic(iter, &data->interface_obj_path);
4581         else if (g_strcmp0(key, "group_object") == 0)
4582                 dbus_message_iter_get_basic(iter, &data->group_obj_path);
4583
4584 }
4585
4586 static void signal_group_success(const char *path, DBusMessageIter *iter)
4587 {
4588         GSupplicantInterface *interface;
4589         struct group_sig_data data = {};
4590         GSupplicantPeer *peer;
4591
4592         SUPPLICANT_DBG("");
4593
4594         interface = g_hash_table_lookup(interface_table, path);
4595         if (!interface)
4596                 return;
4597
4598         supplicant_dbus_property_foreach(iter, group_sig_property, &data);
4599         if (!data.peer_obj_path)
4600                 return;
4601
4602         peer = g_hash_table_lookup(interface->peer_table, data.peer_obj_path);
4603         if (!peer)
4604                 return;
4605
4606         memcpy(peer->iface_address, data.iface_address, ETH_ALEN);
4607         interface->pending_peer_path = peer->path;
4608 }
4609
4610 static void signal_group_failure(const char *path, DBusMessageIter *iter)
4611 {
4612         GSupplicantInterface *interface;
4613         struct group_sig_data data = {};
4614         GSupplicantPeer *peer;
4615
4616         SUPPLICANT_DBG("");
4617
4618         interface = g_hash_table_lookup(interface_table, path);
4619         if (!interface)
4620                 return;
4621
4622         supplicant_dbus_property_foreach(iter, group_sig_property, &data);
4623         if (!data.peer_obj_path)
4624                 return;
4625
4626         peer = g_hash_table_lookup(interface->peer_table, data.peer_obj_path);
4627         if (!peer)
4628                 return;
4629
4630         callback_peer_changed(peer, G_SUPPLICANT_PEER_GROUP_FAILED);
4631         peer->connection_requested = false;
4632 }
4633
4634 static void signal_group_started(const char *path, DBusMessageIter *iter)
4635 {
4636         GSupplicantInterface *interface, *g_interface;
4637         struct group_sig_data data = {};
4638         GSupplicantGroup *group;
4639         GSupplicantPeer *peer;
4640
4641         SUPPLICANT_DBG("");
4642
4643         interface = g_hash_table_lookup(interface_table, path);
4644         if (!interface)
4645                 return;
4646
4647         supplicant_dbus_property_foreach(iter, group_sig_property, &data);
4648         if (!data.interface_obj_path || !data.group_obj_path)
4649                 return;
4650
4651         peer = g_hash_table_lookup(interface->peer_table,
4652                                                 interface->pending_peer_path);
4653         interface->pending_peer_path = NULL;
4654         if (!peer)
4655                 return;
4656
4657         g_interface = g_hash_table_lookup(interface_table,
4658                                                 data.interface_obj_path);
4659         if (!g_interface)
4660                 return;
4661
4662         group = g_hash_table_lookup(interface->group_table,
4663                                                 data.group_obj_path);
4664         if (group)
4665                 return;
4666
4667         group = g_try_new0(GSupplicantGroup, 1);
4668         if (!group)
4669                 return;
4670
4671         group->interface = g_interface;
4672         group->orig_interface = interface;
4673         group->path = g_strdup(data.group_obj_path);
4674         group->role = data.role;
4675
4676         g_hash_table_insert(interface->group_table, group->path, group);
4677         g_hash_table_replace(group_mapping, group->path, group);
4678
4679         peer->current_group_iface = g_interface;
4680         callback_peer_changed(peer, G_SUPPLICANT_PEER_GROUP_STARTED);
4681 }
4682
4683 static void remove_peer_group_interface(GHashTable *group_table,
4684                                 const char* path)
4685 {
4686         GSupplicantGroup *group;
4687         GHashTableIter iter;
4688         gpointer value, key;
4689
4690         if (!group_table)
4691                 return;
4692
4693         group = g_hash_table_lookup(group_table, path);
4694
4695         if (!group || !group->orig_interface)
4696                 return;
4697
4698         g_hash_table_iter_init(&iter, group->orig_interface->peer_table);
4699
4700         while (g_hash_table_iter_next(&iter, &key, &value)) {
4701                 GSupplicantPeer *peer = value;
4702
4703                 if (peer->current_group_iface == group->interface)
4704                         peer->current_group_iface = NULL;
4705         }
4706 }
4707
4708 static void signal_group_finished(const char *path, DBusMessageIter *iter)
4709 {
4710         GSupplicantInterface *interface;
4711         struct group_sig_data data = {};
4712
4713         SUPPLICANT_DBG("");
4714
4715         interface = g_hash_table_lookup(interface_table, path);
4716         if (!interface)
4717                 return;
4718
4719         supplicant_dbus_property_foreach(iter, group_sig_property, &data);
4720         if (!data.interface_obj_path || !data.group_obj_path)
4721                 return;
4722
4723         remove_peer_group_interface(interface->group_table, data.group_obj_path);
4724
4725         g_hash_table_remove(group_mapping, data.group_obj_path);
4726
4727         g_hash_table_remove(interface->group_table, data.group_obj_path);
4728 }
4729
4730 static void signal_group_request(const char *path, DBusMessageIter *iter)
4731 {
4732         GSupplicantInterface *interface;
4733         GSupplicantPeer *peer;
4734         const char *obj_path;
4735
4736         SUPPLICANT_DBG("");
4737
4738         interface = g_hash_table_lookup(interface_table, path);
4739         if (!interface)
4740                 return;
4741
4742         dbus_message_iter_get_basic(iter, &obj_path);
4743         if (!obj_path || !g_strcmp0(obj_path, "/"))
4744                 return;
4745
4746         peer = g_hash_table_lookup(interface->peer_table, obj_path);
4747         if (!peer)
4748                 return;
4749
4750         /*
4751          * Peer has been previously found and property set,
4752          * otherwise, defer connection to when peer property
4753          * is set.
4754          */
4755         if (peer->identifier)
4756                 callback_peer_request(peer);
4757         else
4758                 g_hash_table_replace(pending_peer_connection, peer->path, peer);
4759 }
4760
4761 static void signal_group_peer_joined(const char *path, DBusMessageIter *iter)
4762 {
4763         const char *peer_path = NULL;
4764         GSupplicantInterface *interface;
4765         GSupplicantGroup *group;
4766         GSupplicantPeer *peer;
4767
4768         SUPPLICANT_DBG("");
4769
4770         group = g_hash_table_lookup(group_mapping, path);
4771         if (!group)
4772                 return;
4773
4774         dbus_message_iter_get_basic(iter, &peer_path);
4775         if (!peer_path)
4776                 return;
4777
4778         interface = g_hash_table_lookup(peer_mapping, peer_path);
4779         if (!interface)
4780                 return;
4781
4782         peer = g_hash_table_lookup(interface->peer_table, peer_path);
4783         if (!peer)
4784                 return;
4785
4786         group->members = g_slist_prepend(group->members, g_strdup(peer_path));
4787
4788         callback_peer_changed(peer, G_SUPPLICANT_PEER_GROUP_JOINED);
4789 }
4790
4791 static void signal_group_peer_disconnected(const char *path, DBusMessageIter *iter)
4792 {
4793         const char *peer_path = NULL;
4794         GSupplicantInterface *interface;
4795         GSupplicantGroup *group;
4796         GSupplicantPeer *peer;
4797         GSList *elem;
4798
4799         SUPPLICANT_DBG("");
4800
4801         group = g_hash_table_lookup(group_mapping, path);
4802         if (!group)
4803                 return;
4804
4805         dbus_message_iter_get_basic(iter, &peer_path);
4806         if (!peer_path)
4807                 return;
4808
4809         for (elem = group->members; elem; elem = elem->next) {
4810                 if (!g_strcmp0(elem->data, peer_path))
4811                         break;
4812         }
4813
4814         if (!elem)
4815                 return;
4816
4817         g_free(elem->data);
4818         group->members = g_slist_delete_link(group->members, elem);
4819
4820         interface = g_hash_table_lookup(peer_mapping, peer_path);
4821         if (!interface)
4822                 return;
4823
4824         peer = g_hash_table_lookup(interface->peer_table, peer_path);
4825         if (!peer)
4826                 return;
4827
4828         callback_peer_changed(peer, G_SUPPLICANT_PEER_GROUP_DISCONNECTED);
4829         peer->connection_requested = false;
4830 }
4831
4832 #if defined TIZEN_EXT_WIFI_MESH
4833 const void *g_supplicant_interface_get_mesh_group_ssid(
4834                                                         GSupplicantInterface *interface,
4835                                                         unsigned int *ssid_len)
4836 {
4837         if (!ssid_len)
4838                 return NULL;
4839
4840         if (!interface || interface->group_info.ssid_len == 0) {
4841                 *ssid_len = 0;
4842                 return NULL;
4843         }
4844
4845         *ssid_len = interface->group_info.ssid_len;
4846         return interface->group_info.ssid;
4847 }
4848
4849 int g_supplicant_mesh_get_disconnect_reason(GSupplicantInterface *interface)
4850 {
4851         if (!interface)
4852                 return -EINVAL;
4853
4854         return interface->group_info.disconnect_reason;
4855 }
4856
4857 const char *g_supplicant_mesh_peer_get_address(GSupplicantMeshPeer *mesh_peer)
4858 {
4859         if (!mesh_peer || !mesh_peer->peer_address)
4860                 return NULL;
4861
4862         return mesh_peer->peer_address;
4863 }
4864
4865 int g_supplicant_mesh_peer_get_disconnect_reason(GSupplicantMeshPeer *mesh_peer)
4866 {
4867         if (!mesh_peer)
4868                 return -EINVAL;
4869
4870         return mesh_peer->disconnect_reason;
4871 }
4872
4873 static void callback_mesh_group_started(GSupplicantInterface *interface)
4874 {
4875         if (!callbacks_pointer)
4876                 return;
4877
4878         if (!callbacks_pointer->mesh_group_started)
4879                 return;
4880
4881         callbacks_pointer->mesh_group_started(interface);
4882 }
4883
4884 static void callback_mesh_group_removed(GSupplicantInterface *interface)
4885 {
4886         if (!callbacks_pointer)
4887                 return;
4888
4889         if (!callbacks_pointer->mesh_group_removed)
4890                 return;
4891
4892         callbacks_pointer->mesh_group_removed(interface);
4893 }
4894
4895 static void mesh_group_info(const char *key, DBusMessageIter *iter,
4896                                                         void *user_data)
4897 {
4898         GSupplicantInterface *interface = user_data;
4899         if (!key)
4900                 return;
4901
4902         if (g_strcmp0(key, "SSID") == 0) {
4903                 DBusMessageIter array;
4904                 unsigned char *ssid;
4905                 int ssid_len;
4906
4907                 dbus_message_iter_recurse(iter, &array);
4908                 dbus_message_iter_get_fixed_array(&array, &ssid, &ssid_len);
4909
4910                 if (ssid_len > 0 && ssid_len < 33) {
4911                         memcpy(interface->group_info.ssid, ssid, ssid_len);
4912                         interface->group_info.ssid_len = ssid_len;
4913                 } else {
4914                         memset(interface->group_info.ssid, 0, 32);
4915                         interface->group_info.ssid_len = 0;
4916                 }
4917         } else if (g_strcmp0(key, "DisconnectReason") == 0) {
4918                 int disconnect_reason = 0;
4919                 dbus_message_iter_get_basic(iter, &disconnect_reason);
4920                 interface->group_info.disconnect_reason = disconnect_reason;
4921         }
4922 }
4923
4924 static void signal_mesh_group_started(const char *path, DBusMessageIter *iter)
4925 {
4926         GSupplicantInterface *interface;
4927
4928         interface = g_hash_table_lookup(interface_table, path);
4929         if (!interface)
4930                 return;
4931
4932         supplicant_dbus_property_foreach(iter, mesh_group_info, interface);
4933
4934         callback_mesh_group_started(interface);
4935 }
4936
4937 static void signal_mesh_group_removed(const char *path, DBusMessageIter *iter)
4938 {
4939         GSupplicantInterface *interface;
4940
4941         interface = g_hash_table_lookup(interface_table, path);
4942         if (!interface)
4943                 return;
4944
4945         supplicant_dbus_property_foreach(iter, mesh_group_info, interface);
4946
4947         callback_mesh_group_removed(interface);
4948 }
4949
4950 static void callback_mesh_peer_connected(GSupplicantMeshPeer *mesh_peer)
4951 {
4952         if (!callbacks_pointer)
4953                 return;
4954
4955         if (!callbacks_pointer->mesh_peer_connected)
4956                 return;
4957
4958         callbacks_pointer->mesh_peer_connected(mesh_peer);
4959 }
4960
4961 static void callback_mesh_peer_disconnected(GSupplicantMeshPeer *mesh_peer)
4962 {
4963         if (!callbacks_pointer)
4964                 return;
4965
4966         if (!callbacks_pointer->mesh_peer_disconnected)
4967                 return;
4968
4969         callbacks_pointer->mesh_peer_disconnected(mesh_peer);
4970 }
4971
4972 static void mesh_peer_info(const char *key, DBusMessageIter *iter,
4973                                                         void *user_data)
4974 {
4975         GSupplicantMeshPeer *mesh_peer = user_data;
4976         if (!key)
4977                 return;
4978
4979         if (g_strcmp0(key, "PeerAddress") == 0) {
4980                 DBusMessageIter array;
4981                 unsigned char *addr;
4982                 int addr_len;
4983
4984                 dbus_message_iter_recurse(iter, &array);
4985                 dbus_message_iter_get_fixed_array(&array, &addr, &addr_len);
4986
4987                 if (addr_len == 6) {
4988                         mesh_peer->peer_address = g_malloc0(19);
4989                         snprintf(mesh_peer->peer_address, 19,
4990                                          "%02x:%02x:%02x:%02x:%02x:%02x", addr[0], addr[1],
4991                                          addr[2], addr[3], addr[4], addr[5]);
4992                 }
4993         } else if (g_strcmp0(key, "DisconnectReason") == 0) {
4994                 int disconnect_reason = 0;
4995                 dbus_message_iter_get_basic(iter, &disconnect_reason);
4996                 mesh_peer->disconnect_reason = disconnect_reason;
4997         }
4998 }
4999
5000 static void signal_mesh_peer_connected(const char *path, DBusMessageIter *iter)
5001 {
5002         GSupplicantInterface *interface;
5003         GSupplicantMeshPeer *mesh_peer;
5004
5005         interface = g_hash_table_lookup(interface_table, path);
5006         if (!interface)
5007                 return;
5008
5009         mesh_peer = dbus_malloc0(sizeof(GSupplicantMeshPeer));
5010         mesh_peer->interface = interface;
5011
5012         supplicant_dbus_property_foreach(iter, mesh_peer_info, mesh_peer);
5013
5014         callback_mesh_peer_connected(mesh_peer);
5015         g_free(mesh_peer->peer_address);
5016         g_free(mesh_peer);
5017 }
5018
5019 static void signal_mesh_peer_disconnected(const char *path,
5020                                                                 DBusMessageIter *iter)
5021 {
5022         GSupplicantInterface *interface;
5023         GSupplicantMeshPeer *mesh_peer;
5024
5025         interface = g_hash_table_lookup(interface_table, path);
5026         if (!interface)
5027                 return;
5028
5029         mesh_peer = dbus_malloc0(sizeof(GSupplicantMeshPeer));
5030         mesh_peer->interface = interface;
5031
5032         supplicant_dbus_property_foreach(iter, mesh_peer_info, mesh_peer);
5033
5034         callback_mesh_peer_disconnected(mesh_peer);
5035         g_free(mesh_peer->peer_address);
5036         g_free(mesh_peer);
5037 }
5038 #endif
5039
5040 static struct {
5041         const char *interface;
5042         const char *member;
5043         void (*function) (const char *path, DBusMessageIter *iter);
5044 } signal_map[] = {
5045         { DBUS_INTERFACE_DBUS,  "NameOwnerChanged",  signal_name_owner_changed },
5046
5047         { SUPPLICANT_INTERFACE, "PropertiesChanged", signal_properties_changed },
5048         { SUPPLICANT_INTERFACE, "InterfaceAdded",    signal_interface_added    },
5049         { SUPPLICANT_INTERFACE, "InterfaceCreated",  signal_interface_added    },
5050         { SUPPLICANT_INTERFACE, "InterfaceRemoved",  signal_interface_removed  },
5051
5052         { SUPPLICANT_INTERFACE ".Interface", "PropertiesChanged", signal_interface_changed },
5053         { SUPPLICANT_INTERFACE ".Interface", "ScanDone",          signal_scan_done         },
5054         { SUPPLICANT_INTERFACE ".Interface", "BSSAdded",          signal_bss_added         },
5055         { SUPPLICANT_INTERFACE ".Interface", "BSSRemoved",        signal_bss_removed       },
5056         { SUPPLICANT_INTERFACE ".Interface", "NetworkAdded",      signal_network_added     },
5057         { SUPPLICANT_INTERFACE ".Interface", "NetworkRemoved",    signal_network_removed   },
5058         { SUPPLICANT_INTERFACE ".Interface", "StaAuthorized",     signal_sta_authorized    },
5059         { SUPPLICANT_INTERFACE ".Interface", "StaDeauthorized",   signal_sta_deauthorized  },
5060
5061         { SUPPLICANT_INTERFACE ".BSS", "PropertiesChanged", signal_bss_changed   },
5062
5063         { SUPPLICANT_INTERFACE ".Interface.WPS", "Credentials", signal_wps_credentials },
5064         { SUPPLICANT_INTERFACE ".Interface.WPS", "Event",       signal_wps_event       },
5065 #if defined TIZEN_EXT
5066         { "org.tizen.system.deviced.PowerOff", "ChangeState", signal_power_off },
5067 #endif
5068
5069         { SUPPLICANT_INTERFACE ".Interface.P2PDevice", "DeviceFound", signal_peer_found },
5070         { SUPPLICANT_INTERFACE ".Interface.P2PDevice", "DeviceLost",  signal_peer_lost  },
5071
5072         { SUPPLICANT_INTERFACE ".Peer", "PropertiesChanged", signal_peer_changed },
5073
5074         { SUPPLICANT_INTERFACE ".Interface.P2PDevice", "GONegotiationSuccess", signal_group_success },
5075         { SUPPLICANT_INTERFACE ".Interface.P2PDevice", "GONegotiationFailure", signal_group_failure },
5076         { SUPPLICANT_INTERFACE ".Interface.P2PDevice", "GroupStarted", signal_group_started },
5077         { SUPPLICANT_INTERFACE ".Interface.P2PDevice", "GroupFinished", signal_group_finished },
5078         { SUPPLICANT_INTERFACE ".Interface.P2PDevice", "GONegotiationRequest", signal_group_request },
5079
5080         { SUPPLICANT_INTERFACE ".Group", "PeerJoined", signal_group_peer_joined },
5081         { SUPPLICANT_INTERFACE ".Group", "PeerDisconnected", signal_group_peer_disconnected },
5082 #if defined TIZEN_EXT_WIFI_MESH
5083         { SUPPLICANT_INTERFACE ".Interface.Mesh", "MeshGroupStarted",
5084                 signal_mesh_group_started },
5085         { SUPPLICANT_INTERFACE ".Interface.Mesh", "MeshGroupRemoved",
5086                 signal_mesh_group_removed },
5087         { SUPPLICANT_INTERFACE ".Interface.Mesh", "MeshPeerConnected",
5088                 signal_mesh_peer_connected },
5089         { SUPPLICANT_INTERFACE ".Interface.Mesh", "MeshPeerDisconnected",
5090                 signal_mesh_peer_disconnected },
5091 #endif
5092
5093         { }
5094 };
5095
5096 static DBusHandlerResult g_supplicant_filter(DBusConnection *conn,
5097                                         DBusMessage *message, void *data)
5098 {
5099         DBusMessageIter iter;
5100         const char *path;
5101         int i;
5102
5103         path = dbus_message_get_path(message);
5104         if (!path)
5105                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
5106
5107         if (!dbus_message_iter_init(message, &iter))
5108                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
5109
5110         for (i = 0; signal_map[i].interface; i++) {
5111                 if (!dbus_message_has_interface(message, signal_map[i].interface))
5112                         continue;
5113
5114                 if (!dbus_message_has_member(message, signal_map[i].member))
5115                         continue;
5116
5117                 signal_map[i].function(path, &iter);
5118                 break;
5119         }
5120
5121         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
5122 }
5123
5124 void g_supplicant_interface_cancel(GSupplicantInterface *interface)
5125 {
5126         SUPPLICANT_DBG("Cancelling any pending DBus calls");
5127         supplicant_dbus_method_call_cancel_all(interface);
5128         supplicant_dbus_property_call_cancel_all(interface);
5129 }
5130
5131 struct supplicant_regdom {
5132         GSupplicantCountryCallback callback;
5133         const char *alpha2;
5134         const void *user_data;
5135 };
5136
5137 static void country_result(const char *error,
5138                                 DBusMessageIter *iter, void *user_data)
5139 {
5140         struct supplicant_regdom *regdom = user_data;
5141         int result = 0;
5142
5143         SUPPLICANT_DBG("Country setting result");
5144
5145         if (!user_data)
5146                 return;
5147
5148         if (error) {
5149                 SUPPLICANT_DBG("Country setting failure %s", error);
5150                 result = -EINVAL;
5151         }
5152
5153         if (regdom->callback)
5154                 regdom->callback(result, regdom->alpha2,
5155                                         (void *) regdom->user_data);
5156
5157         g_free(regdom);
5158 }
5159
5160 static void country_params(DBusMessageIter *iter, void *user_data)
5161 {
5162         struct supplicant_regdom *regdom = user_data;
5163
5164         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
5165                                                         &regdom->alpha2);
5166 }
5167
5168 int g_supplicant_set_country(const char *alpha2,
5169                                 GSupplicantCountryCallback callback,
5170                                         const void *user_data)
5171 {
5172         struct supplicant_regdom *regdom;
5173         int ret;
5174
5175         SUPPLICANT_DBG("Country setting %s", alpha2);
5176
5177         if (!system_available)
5178                 return -EFAULT;
5179
5180         regdom = dbus_malloc0(sizeof(*regdom));
5181         if (!regdom)
5182                 return -ENOMEM;
5183
5184         regdom->callback = callback;
5185         regdom->alpha2 = alpha2;
5186         regdom->user_data = user_data;
5187
5188         ret =  supplicant_dbus_property_set(SUPPLICANT_PATH, SUPPLICANT_INTERFACE,
5189                                         "Country", DBUS_TYPE_STRING_AS_STRING,
5190                                         country_params, country_result,
5191                                         regdom, NULL);
5192         if (ret < 0) {
5193                 dbus_free(regdom);
5194                 SUPPLICANT_DBG("Unable to set Country configuration");
5195         }
5196         return ret;
5197 }
5198
5199 int g_supplicant_interface_set_country(GSupplicantInterface *interface,
5200                                         GSupplicantCountryCallback callback,
5201                                                         const char *alpha2,
5202                                                         void *user_data)
5203 {
5204         struct supplicant_regdom *regdom;
5205         int ret;
5206
5207         regdom = dbus_malloc0(sizeof(*regdom));
5208         if (!regdom)
5209                 return -ENOMEM;
5210
5211         regdom->callback = callback;
5212         regdom->alpha2 = alpha2;
5213         regdom->user_data = user_data;
5214
5215         ret =  supplicant_dbus_property_set(interface->path,
5216                                 SUPPLICANT_INTERFACE ".Interface",
5217                                 "Country", DBUS_TYPE_STRING_AS_STRING,
5218                                 country_params, country_result,
5219                                         regdom, NULL);
5220         if (ret < 0) {
5221                 dbus_free(regdom);
5222                 SUPPLICANT_DBG("Unable to set Country configuration");
5223         }
5224
5225         return ret;
5226 }
5227
5228 bool g_supplicant_interface_has_p2p(GSupplicantInterface *interface)
5229 {
5230         if (!interface)
5231                 return false;
5232
5233         return interface->p2p_support;
5234 }
5235
5236 struct supplicant_p2p_dev_config {
5237         char *device_name;
5238         char *dev_type;
5239 };
5240
5241 static void p2p_device_config_result(const char *error,
5242                                         DBusMessageIter *iter, void *user_data)
5243 {
5244         struct supplicant_p2p_dev_config *config = user_data;
5245
5246         if (error)
5247                 SUPPLICANT_DBG("Unable to set P2P Device configuration: %s",
5248                                                                         error);
5249
5250         g_free(config->device_name);
5251         g_free(config->dev_type);
5252         dbus_free(config);
5253 }
5254
5255 static int dev_type_str2bin(const char *type, unsigned char dev_type[8])
5256 {
5257         int length, pos, end;
5258         char b[3] = {};
5259         char *e = NULL;
5260
5261         end = strlen(type);
5262         for (length = pos = 0; type[pos] != '\0' && length < 8; length++) {
5263                 if (pos+2 > end)
5264                         return 0;
5265
5266                 b[0] = type[pos];
5267                 b[1] = type[pos+1];
5268
5269                 dev_type[length] = strtol(b, &e, 16);
5270                 if (e && *e != '\0')
5271                         return 0;
5272
5273                 pos += 2;
5274         }
5275
5276         return 8;
5277 }
5278
5279 static void p2p_device_config_params(DBusMessageIter *iter, void *user_data)
5280 {
5281         struct supplicant_p2p_dev_config *config = user_data;
5282         DBusMessageIter dict;
5283
5284         supplicant_dbus_dict_open(iter, &dict);
5285
5286         supplicant_dbus_dict_append_basic(&dict, "DeviceName",
5287                                 DBUS_TYPE_STRING, &config->device_name);
5288
5289         if (config->dev_type) {
5290                 unsigned char dev_type[8] = {}, *type;
5291                 int len;
5292
5293                 len = dev_type_str2bin(config->dev_type, dev_type);
5294                 if (len) {
5295                         type = dev_type;
5296                         supplicant_dbus_dict_append_fixed_array(&dict,
5297                                         "PrimaryDeviceType",
5298                                         DBUS_TYPE_BYTE, &type, len);
5299                 }
5300         }
5301
5302         supplicant_dbus_dict_close(iter, &dict);
5303 }
5304
5305 int g_supplicant_interface_set_p2p_device_config(GSupplicantInterface *interface,
5306                                         const char *device_name,
5307                                         const char *primary_dev_type)
5308 {
5309         struct supplicant_p2p_dev_config *config;
5310         int ret;
5311
5312         SUPPLICANT_DBG("P2P Device settings %s/%s",
5313                                         device_name, primary_dev_type);
5314
5315         config = dbus_malloc0(sizeof(*config));
5316         if (!config)
5317                 return -ENOMEM;
5318
5319         config->device_name = g_strdup(device_name);
5320         config->dev_type = g_strdup(primary_dev_type);
5321
5322         ret = supplicant_dbus_property_set(interface->path,
5323                                 SUPPLICANT_INTERFACE ".Interface.P2PDevice",
5324                                 "P2PDeviceConfig",
5325                                 DBUS_TYPE_ARRAY_AS_STRING
5326                                 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
5327                                 DBUS_TYPE_STRING_AS_STRING
5328                                 DBUS_TYPE_VARIANT_AS_STRING
5329                                 DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
5330                                 p2p_device_config_params,
5331                                 p2p_device_config_result, config, NULL);
5332         if (ret < 0) {
5333                 g_free(config->device_name);
5334                 g_free(config->dev_type);
5335                 dbus_free(config);
5336                 SUPPLICANT_DBG("Unable to set P2P Device configuration");
5337         }
5338
5339         return ret;
5340 }
5341
5342 static gboolean peer_lookup_by_identifier(gpointer key, gpointer value,
5343                                                         gpointer user_data)
5344 {
5345         const GSupplicantPeer *peer = value;
5346         const char *identifier = user_data;
5347
5348         if (!g_strcmp0(identifier, peer->identifier))
5349                 return TRUE;
5350
5351         return FALSE;
5352 }
5353
5354 GSupplicantPeer *g_supplicant_interface_peer_lookup(GSupplicantInterface *interface,
5355                                                         const char *identifier)
5356 {
5357         GSupplicantPeer *peer;
5358
5359         peer = g_hash_table_find(interface->peer_table,
5360                                         peer_lookup_by_identifier,
5361                                         (void *) identifier);
5362         return peer;
5363 }
5364
5365 static void interface_create_data_free(struct interface_create_data *data)
5366 {
5367         g_free(data->ifname);
5368         g_free(data->driver);
5369         g_free(data->bridge);
5370 #if defined TIZEN_EXT_WIFI_MESH
5371         g_free(data->parent_ifname);
5372 #endif
5373         dbus_free(data);
5374 }
5375
5376 static bool interface_exists(GSupplicantInterface *interface,
5377                                 const char *path)
5378 {
5379         GSupplicantInterface *tmp;
5380
5381         tmp = g_hash_table_lookup(interface_table, path);
5382         if (tmp && tmp == interface)
5383                 return true;
5384
5385         return false;
5386 }
5387
5388 static void interface_create_property(const char *key, DBusMessageIter *iter,
5389                                                         void *user_data)
5390 {
5391         struct interface_create_data *data = user_data;
5392         GSupplicantInterface *interface = data->interface;
5393
5394         if (!key) {
5395                 if (data->callback) {
5396                         data->callback(0, data->interface, data->user_data);
5397 #if !defined TIZEN_EXT
5398                         callback_p2p_support(interface);
5399 #endif
5400 #if defined TIZEN_EXT_WIFI_MESH
5401                         callback_mesh_support(interface);
5402 #endif
5403                 }
5404
5405                 interface_create_data_free(data);
5406         }
5407
5408         interface_property(key, iter, interface);
5409 }
5410
5411 static void interface_create_result(const char *error,
5412                                 DBusMessageIter *iter, void *user_data)
5413 {
5414         struct interface_create_data *data = user_data;
5415         const char *path = NULL;
5416         int err;
5417
5418         SUPPLICANT_DBG("");
5419
5420         if (error) {
5421                 g_message("error %s", error);
5422                 err = -EIO;
5423                 goto done;
5424         }
5425
5426         dbus_message_iter_get_basic(iter, &path);
5427         if (!path) {
5428                 err = -EINVAL;
5429                 goto done;
5430         }
5431
5432         if (!system_available) {
5433                 err = -EFAULT;
5434                 goto done;
5435         }
5436
5437         data->interface = g_hash_table_lookup(interface_table, path);
5438         if (!data->interface) {
5439                 data->interface = interface_alloc(path);
5440                 if (!data->interface) {
5441                         err = -ENOMEM;
5442                         goto done;
5443                 }
5444         }
5445
5446         err = supplicant_dbus_property_get_all(path,
5447                                         SUPPLICANT_INTERFACE ".Interface",
5448                                         interface_create_property, data,
5449                                         NULL);
5450         if (err == 0)
5451                 return;
5452
5453 done:
5454         if (data->callback)
5455                 data->callback(err, NULL, data->user_data);
5456
5457         interface_create_data_free(data);
5458 }
5459
5460 static void interface_create_params(DBusMessageIter *iter, void *user_data)
5461 {
5462         struct interface_create_data *data = user_data;
5463         DBusMessageIter dict;
5464         char *config_file = NULL;
5465
5466         SUPPLICANT_DBG("");
5467
5468         supplicant_dbus_dict_open(iter, &dict);
5469
5470         supplicant_dbus_dict_append_basic(&dict, "Ifname",
5471                                         DBUS_TYPE_STRING, &data->ifname);
5472
5473         if (data->driver)
5474                 supplicant_dbus_dict_append_basic(&dict, "Driver",
5475                                         DBUS_TYPE_STRING, &data->driver);
5476
5477         if (data->bridge)
5478                 supplicant_dbus_dict_append_basic(&dict, "BridgeIfname",
5479                                         DBUS_TYPE_STRING, &data->bridge);
5480
5481         config_file = g_hash_table_lookup(config_file_table, data->ifname);
5482         if (config_file) {
5483                 SUPPLICANT_DBG("[%s] ConfigFile %s", data->ifname, config_file);
5484
5485                 supplicant_dbus_dict_append_basic(&dict, "ConfigFile",
5486                                         DBUS_TYPE_STRING, &config_file);
5487         }
5488
5489 #if defined TIZEN_EXT_WIFI_MESH
5490         if (data->is_mesh_interface) {
5491                 if (data->parent_ifname)
5492                         supplicant_dbus_dict_append_basic(&dict, "ParentIfname",
5493                                         DBUS_TYPE_STRING, &data->parent_ifname);
5494
5495                 supplicant_dbus_dict_append_basic(&dict, "IsMeshInterface",
5496                                         DBUS_TYPE_BOOLEAN, &data->is_mesh_interface);
5497         }
5498 #endif
5499
5500         supplicant_dbus_dict_close(iter, &dict);
5501 }
5502
5503 static void interface_get_result(const char *error,
5504                                 DBusMessageIter *iter, void *user_data)
5505 {
5506         struct interface_create_data *data = user_data;
5507         GSupplicantInterface *interface;
5508         const char *path = NULL;
5509         int err;
5510
5511         SUPPLICANT_DBG("");
5512
5513         if (error) {
5514                 SUPPLICANT_DBG("Interface not created yet");
5515                 goto create;
5516         }
5517
5518         dbus_message_iter_get_basic(iter, &path);
5519         if (!path) {
5520                 err = -EINVAL;
5521                 goto done;
5522         }
5523
5524         interface = g_hash_table_lookup(interface_table, path);
5525         if (!interface) {
5526                 err = -ENOENT;
5527                 goto done;
5528         }
5529
5530         if (data->callback) {
5531                 data->callback(0, interface, data->user_data);
5532 #if !defined TIZEN_EXT
5533                 callback_p2p_support(interface);
5534 #endif
5535 #if defined TIZEN_EXT_WIFI_MESH
5536                 callback_mesh_support(interface);
5537 #endif
5538         }
5539
5540         interface_create_data_free(data);
5541
5542         return;
5543
5544 create:
5545         if (!system_available) {
5546                 err = -EFAULT;
5547                 goto done;
5548         }
5549
5550         SUPPLICANT_DBG("Creating interface");
5551
5552         err = supplicant_dbus_method_call(SUPPLICANT_PATH,
5553                                                 SUPPLICANT_INTERFACE,
5554                                                 "CreateInterface",
5555                                                 interface_create_params,
5556                                                 interface_create_result, data,
5557                                                 NULL);
5558         if (err == 0)
5559                 return;
5560
5561 done:
5562         if (data->callback)
5563                 data->callback(err, NULL, data->user_data);
5564
5565         interface_create_data_free(data);
5566 }
5567
5568 static void interface_get_params(DBusMessageIter *iter, void *user_data)
5569 {
5570         struct interface_create_data *data = user_data;
5571
5572         SUPPLICANT_DBG("");
5573
5574         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &data->ifname);
5575 }
5576
5577 #if defined TIZEN_EXT_WIFI_MESH
5578 int g_supplicant_mesh_interface_create(const char *ifname, const char *driver,
5579                                                 const char *bridge, const char *parent_ifname,
5580                                                 GSupplicantInterfaceCallback callback, void *user_data)
5581 {
5582         struct interface_create_data *data;
5583         int ret;
5584
5585         SUPPLICANT_DBG("ifname %s", ifname);
5586
5587         if (!ifname || !parent_ifname)
5588                 return -EINVAL;
5589
5590         if (!system_available)
5591                 return -EFAULT;
5592
5593         data = dbus_malloc0(sizeof(*data));
5594         if (!data)
5595                 return -ENOMEM;
5596
5597         data->ifname = g_strdup(ifname);
5598         data->driver = g_strdup(driver);
5599         data->bridge = g_strdup(bridge);
5600         data->is_mesh_interface = true;
5601         data->parent_ifname = g_strdup(parent_ifname);
5602         data->callback = callback;
5603         data->user_data = user_data;
5604
5605         ret = supplicant_dbus_method_call(SUPPLICANT_PATH,
5606                                                 SUPPLICANT_INTERFACE,
5607                                                 "CreateInterface",
5608                                                 interface_create_params,
5609                                                 interface_create_result, data,
5610                                                 NULL);
5611         return ret;
5612 }
5613
5614 struct interface_mesh_peer_data {
5615         char *peer_address;
5616         char *method;
5617         GSupplicantInterface *interface;
5618         GSupplicantInterfaceCallback callback;
5619         void *user_data;
5620 };
5621
5622 static void interface_mesh_change_peer_params(DBusMessageIter *iter,
5623                                                 void *user_data)
5624 {
5625         struct interface_mesh_peer_data *data = user_data;
5626
5627         SUPPLICANT_DBG("");
5628
5629         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &data->peer_address);
5630 }
5631
5632 static void interface_mesh_change_peer_result(const char *error,
5633                                 DBusMessageIter *iter, void *user_data)
5634 {
5635         struct interface_mesh_peer_data *data = user_data;
5636         int err = 0;
5637
5638         SUPPLICANT_DBG("%s", data->method);
5639
5640         if (error) {
5641                 err = -EIO;
5642                 SUPPLICANT_DBG("error %s", error);
5643         }
5644
5645         if (data->callback)
5646                 data->callback(err, data->interface, data->user_data);
5647
5648         g_free(data->peer_address);
5649         g_free(data->method);
5650         dbus_free(data);
5651 }
5652
5653 int g_supplicant_interface_mesh_peer_change_status(
5654                                 GSupplicantInterface *interface,
5655                                 GSupplicantInterfaceCallback callback, const char *peer_address,
5656                                 const char *method, void *user_data)
5657 {
5658         struct interface_mesh_peer_data *data;
5659         int ret;
5660
5661         if (!peer_address)
5662                 return -EINVAL;
5663
5664         data = dbus_malloc0(sizeof(*data));
5665         if (!data)
5666                 return -ENOMEM;
5667
5668         data->peer_address = g_strdup(peer_address);
5669         data->method = g_strdup(method);
5670         data->interface = interface;
5671         data->callback = callback;
5672         data->user_data = user_data;
5673
5674         ret = supplicant_dbus_method_call(interface->path,
5675                                                 SUPPLICANT_INTERFACE ".Interface.Mesh",
5676                                                 method, interface_mesh_change_peer_params,
5677                                                 interface_mesh_change_peer_result, data, NULL);
5678         if (ret < 0) {
5679                 g_free(data->peer_address);
5680                 g_free(data->method);
5681                 dbus_free(data);
5682         }
5683
5684         return ret;
5685 }
5686 #endif
5687
5688 int g_supplicant_interface_create(const char *ifname, const char *driver,
5689                                         const char *bridge,
5690                                         GSupplicantInterfaceCallback callback,
5691                                                         void *user_data)
5692 {
5693         struct interface_create_data *data;
5694         int ret;
5695
5696         SUPPLICANT_DBG("ifname %s", ifname);
5697
5698         if (!ifname)
5699                 return -EINVAL;
5700
5701         if (!system_available)
5702                 return -EFAULT;
5703
5704         data = dbus_malloc0(sizeof(*data));
5705         if (!data)
5706                 return -ENOMEM;
5707
5708         data->ifname = g_strdup(ifname);
5709         data->driver = g_strdup(driver);
5710         data->bridge = g_strdup(bridge);
5711         data->callback = callback;
5712         data->user_data = user_data;
5713
5714         ret = supplicant_dbus_method_call(SUPPLICANT_PATH,
5715                                                 SUPPLICANT_INTERFACE,
5716                                                 "GetInterface",
5717                                                 interface_get_params,
5718                                                 interface_get_result, data,
5719                                                 NULL);
5720         if (ret < 0)
5721                 interface_create_data_free(data);
5722
5723         return ret;
5724 }
5725
5726 static void interface_remove_result(const char *error,
5727                                 DBusMessageIter *iter, void *user_data)
5728 {
5729         struct interface_data *data = user_data;
5730         int err;
5731
5732         if (error) {
5733                 err = -EIO;
5734                 SUPPLICANT_DBG("error: %s", error);
5735                 goto done;
5736         }
5737
5738         if (!system_available) {
5739                 err = -EFAULT;
5740                 goto done;
5741         }
5742
5743         /*
5744          * The gsupplicant interface is already freed by the InterfaceRemoved
5745          * signal callback. Simply invoke the interface_data callback.
5746          */
5747         err = 0;
5748
5749 done:
5750         g_free(data->path);
5751
5752         if (data->callback)
5753                 data->callback(err, NULL, data->user_data);
5754
5755         dbus_free(data);
5756 }
5757
5758
5759 static void interface_remove_params(DBusMessageIter *iter, void *user_data)
5760 {
5761         struct interface_data *data = user_data;
5762
5763         dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
5764                                                         &data->interface->path);
5765 }
5766
5767
5768 int g_supplicant_interface_remove(GSupplicantInterface *interface,
5769                         GSupplicantInterfaceCallback callback,
5770                                                         void *user_data)
5771 {
5772         struct interface_data *data;
5773         int ret;
5774
5775         if (!interface)
5776                 return -EINVAL;
5777
5778         if (!system_available)
5779                 return -EFAULT;
5780
5781         g_supplicant_interface_cancel(interface);
5782
5783         data = dbus_malloc0(sizeof(*data));
5784         if (!data)
5785                 return -ENOMEM;
5786
5787         data->interface = interface;
5788         data->path = g_strdup(interface->path);
5789         data->callback = callback;
5790         data->user_data = user_data;
5791
5792         ret = supplicant_dbus_method_call(SUPPLICANT_PATH,
5793                                                 SUPPLICANT_INTERFACE,
5794                                                 "RemoveInterface",
5795                                                 interface_remove_params,
5796                                                 interface_remove_result, data,
5797                                                 NULL);
5798         if (ret < 0) {
5799                 g_free(data->path);
5800                 dbus_free(data);
5801         }
5802         return ret;
5803 }
5804
5805 static void interface_scan_result(const char *error,
5806                                 DBusMessageIter *iter, void *user_data)
5807 {
5808         struct interface_scan_data *data = user_data;
5809         int err = 0;
5810
5811         if (error) {
5812                 SUPPLICANT_DBG("error %s", error);
5813                 err = -EIO;
5814         }
5815
5816         /* A non ready interface cannot send/receive anything */
5817         if (interface_exists(data->interface, data->path)) {
5818                 if (!data->interface->ready)
5819                         err = -ENOLINK;
5820         }
5821
5822         g_free(data->path);
5823
5824         if (err != 0) {
5825                 if (data->callback)
5826                         data->callback(err, data->interface, data->user_data);
5827         } else {
5828                 data->interface->scan_callback = data->callback;
5829                 data->interface->scan_data = data->user_data;
5830         }
5831
5832         if (data->scan_params)
5833                 g_supplicant_free_scan_params(data->scan_params);
5834
5835         dbus_free(data);
5836 }
5837
5838 static void add_scan_frequency(DBusMessageIter *iter, unsigned int freq)
5839 {
5840         DBusMessageIter data;
5841         unsigned int width = 0; /* Not used by wpa_supplicant atm */
5842
5843         dbus_message_iter_open_container(iter, DBUS_TYPE_STRUCT, NULL, &data);
5844
5845         dbus_message_iter_append_basic(&data, DBUS_TYPE_UINT32, &freq);
5846         dbus_message_iter_append_basic(&data, DBUS_TYPE_UINT32, &width);
5847
5848         dbus_message_iter_close_container(iter, &data);
5849 }
5850
5851 static void add_scan_frequencies(DBusMessageIter *iter,
5852                                                 void *user_data)
5853 {
5854         GSupplicantScanParams *scan_data = user_data;
5855         unsigned int freq;
5856         int i;
5857
5858         for (i = 0; i < scan_data->num_freqs; i++) {
5859                 freq = scan_data->freqs[i];
5860                 if (!freq)
5861                         break;
5862
5863                 add_scan_frequency(iter, freq);
5864         }
5865 }
5866
5867 static void append_ssid(DBusMessageIter *iter,
5868                         const void *ssid, unsigned int len)
5869 {
5870         DBusMessageIter array;
5871
5872         dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
5873         DBUS_TYPE_BYTE_AS_STRING, &array);
5874
5875         dbus_message_iter_append_fixed_array(&array, DBUS_TYPE_BYTE,
5876                                                                 &ssid, len);
5877         dbus_message_iter_close_container(iter, &array);
5878 }
5879
5880 static void append_ssids(DBusMessageIter *iter, void *user_data)
5881 {
5882         GSupplicantScanParams *scan_data = user_data;
5883         GSList *list;
5884
5885         for (list = scan_data->ssids; list; list = list->next) {
5886                 struct scan_ssid *scan_ssid = list->data;
5887
5888                 append_ssid(iter, scan_ssid->ssid, scan_ssid->ssid_len);
5889         }
5890 }
5891
5892 static void supplicant_add_scan_frequency(DBusMessageIter *dict,
5893                 supplicant_dbus_array_function function,
5894                                         void *user_data)
5895 {
5896         GSupplicantScanParams *scan_params = user_data;
5897         DBusMessageIter entry, value, array;
5898         const char *key = "Channels";
5899
5900         if (scan_params->freqs && scan_params->freqs[0] != 0) {
5901                 dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
5902                                                 NULL, &entry);
5903
5904                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
5905
5906                 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
5907                                         DBUS_TYPE_ARRAY_AS_STRING
5908                                         DBUS_STRUCT_BEGIN_CHAR_AS_STRING
5909                                         DBUS_TYPE_UINT32_AS_STRING
5910                                         DBUS_TYPE_UINT32_AS_STRING
5911                                         DBUS_STRUCT_END_CHAR_AS_STRING,
5912                                         &value);
5913
5914                 dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
5915                                         DBUS_STRUCT_BEGIN_CHAR_AS_STRING
5916                                         DBUS_TYPE_UINT32_AS_STRING
5917                                         DBUS_TYPE_UINT32_AS_STRING
5918                                         DBUS_STRUCT_END_CHAR_AS_STRING,
5919                                         &array);
5920
5921                 if (function)
5922                         function(&array, user_data);
5923
5924                 dbus_message_iter_close_container(&value, &array);
5925                 dbus_message_iter_close_container(&entry, &value);
5926                 dbus_message_iter_close_container(dict, &entry);
5927         }
5928 }
5929
5930 static void interface_scan_params(DBusMessageIter *iter, void *user_data)
5931 {
5932         DBusMessageIter dict;
5933         const char *type = "passive";
5934         struct interface_scan_data *data = user_data;
5935
5936         supplicant_dbus_dict_open(iter, &dict);
5937
5938         if (data && data->scan_params) {
5939                 type = "active";
5940
5941                 supplicant_dbus_dict_append_basic(&dict, "Type",
5942                                         DBUS_TYPE_STRING, &type);
5943
5944 #if defined TIZEN_EXT
5945                 SUPPLICANT_DBG("[specific_scan] num_ssids %d",
5946                                data->scan_params->num_ssids);
5947 #endif
5948
5949                 if (data->scan_params->ssids) {
5950                         supplicant_dbus_dict_append_array(&dict, "SSIDs",
5951                                                         DBUS_TYPE_STRING,
5952                                                         append_ssids,
5953                                                         data->scan_params);
5954                 }
5955                 supplicant_add_scan_frequency(&dict, add_scan_frequencies,
5956                                                 data->scan_params);
5957         } else
5958                 supplicant_dbus_dict_append_basic(&dict, "Type",
5959                                         DBUS_TYPE_STRING, &type);
5960
5961         supplicant_dbus_dict_close(iter, &dict);
5962 }
5963
5964 static int interface_ready_to_scan(GSupplicantInterface *interface)
5965 {
5966         if (!interface)
5967                 return -EINVAL;
5968
5969         if (!system_available)
5970                 return -EFAULT;
5971
5972         if (interface->scanning)
5973                 return -EALREADY;
5974
5975         switch (interface->state) {
5976         case G_SUPPLICANT_STATE_AUTHENTICATING:
5977         case G_SUPPLICANT_STATE_ASSOCIATING:
5978         case G_SUPPLICANT_STATE_ASSOCIATED:
5979         case G_SUPPLICANT_STATE_4WAY_HANDSHAKE:
5980         case G_SUPPLICANT_STATE_GROUP_HANDSHAKE:
5981                 return -EBUSY;
5982 #if defined TIZEN_EXT
5983         case G_SUPPLICANT_STATE_DISABLED:
5984                 return -ENOLINK;
5985         case G_SUPPLICANT_STATE_UNKNOWN:
5986 #else
5987         case G_SUPPLICANT_STATE_UNKNOWN:
5988         case G_SUPPLICANT_STATE_DISABLED:
5989 #endif
5990         case G_SUPPLICANT_STATE_DISCONNECTED:
5991         case G_SUPPLICANT_STATE_INACTIVE:
5992         case G_SUPPLICANT_STATE_SCANNING:
5993         case G_SUPPLICANT_STATE_COMPLETED:
5994                 break;
5995         }
5996
5997         return 0;
5998 }
5999
6000 #if defined TIZEN_EXT_WIFI_MESH
6001 static void interface_abort_scan_result(const char *error,
6002                                 DBusMessageIter *iter, void *user_data)
6003 {
6004         struct interface_scan_data *data = user_data;
6005         int err = 0;
6006
6007         if (error) {
6008                 SUPPLICANT_DBG("error %s", error);
6009                 err = -EIO;
6010         }
6011
6012         g_free(data->path);
6013
6014                 if (data->callback)
6015                         data->callback(err, data->interface, data->user_data);
6016
6017         dbus_free(data);
6018 }
6019
6020 int g_supplicant_interface_abort_scan(GSupplicantInterface *interface,
6021                                 GSupplicantInterfaceCallback callback, void *user_data)
6022 {
6023         struct interface_scan_data *data;
6024         int ret;
6025
6026         if (!interface->scanning)
6027                 return -EEXIST;
6028
6029         data = dbus_malloc0(sizeof(*data));
6030         if (!data)
6031                 return -ENOMEM;
6032
6033         data->interface = interface;
6034         data->path = g_strdup(interface->path);
6035         data->callback = callback;
6036         data->user_data = user_data;
6037
6038         ret = supplicant_dbus_method_call(interface->path,
6039                         SUPPLICANT_INTERFACE ".Interface", "AbortScan", NULL,
6040                         interface_abort_scan_result, data, interface);
6041
6042         if (ret < 0) {
6043                 g_free(data->path);
6044                 dbus_free(data);
6045         }
6046
6047         return ret;
6048 }
6049 #endif
6050
6051 int g_supplicant_interface_scan(GSupplicantInterface *interface,
6052                                 GSupplicantScanParams *scan_data,
6053                                 GSupplicantInterfaceCallback callback,
6054                                                         void *user_data)
6055 {
6056         struct interface_scan_data *data;
6057         int ret;
6058
6059         ret = interface_ready_to_scan(interface);
6060         if (ret)
6061                 return ret;
6062
6063         data = dbus_malloc0(sizeof(*data));
6064         if (!data)
6065                 return -ENOMEM;
6066
6067         data->interface = interface;
6068         data->path = g_strdup(interface->path);
6069 #if defined TIZEN_EXT
6070         data->interface->scan_callback = data->callback = callback;
6071         data->interface->scan_data = data->user_data = user_data;
6072 #else
6073         data->callback = callback;
6074         data->user_data = user_data;
6075 #endif
6076         data->scan_params = scan_data;
6077
6078         interface->scan_callback = callback;
6079         interface->scan_data = user_data;
6080
6081         ret = supplicant_dbus_method_call(interface->path,
6082                         SUPPLICANT_INTERFACE ".Interface", "Scan",
6083                         interface_scan_params, interface_scan_result, data,
6084                         interface);
6085
6086         if (ret < 0) {
6087                 g_free(data->path);
6088                 dbus_free(data);
6089         }
6090
6091         return ret;
6092 }
6093
6094 #if defined TIZEN_EXT
6095 static void interface_signalpoll_result(const char *error,
6096                                 DBusMessageIter *iter, void *user_data)
6097 {
6098         struct interface_signalpoll_data *data = user_data;
6099         int err = 0;
6100         dbus_int32_t maxspeed = 0;
6101         dbus_int32_t strength = 0;
6102         DBusMessageIter sub_iter, dict;
6103
6104         if (error) {
6105                 err = -EIO;
6106                 SUPPLICANT_DBG("error: %s", error);
6107                 goto out;
6108         }
6109
6110         dbus_message_iter_get_arg_type(iter);
6111         dbus_message_iter_recurse(iter, &sub_iter);
6112         dbus_message_iter_recurse(&sub_iter, &dict);
6113
6114         while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
6115                 DBusMessageIter entry, value;
6116                 const char *key;
6117
6118                 dbus_message_iter_recurse(&dict, &entry);
6119                 dbus_message_iter_get_basic(&entry, &key);
6120                 dbus_message_iter_next(&entry);
6121                 dbus_message_iter_recurse(&entry, &value);
6122
6123                 switch (dbus_message_iter_get_arg_type(&value)) {
6124                 case DBUS_TYPE_INT32:
6125                         if (g_strcmp0(key, "linkspeed") == 0) {
6126                                 dbus_message_iter_get_basic(&value, &maxspeed);
6127                                 SUPPLICANT_DBG("linkspeed = %d", maxspeed);
6128                                 break;
6129                         } else if (g_strcmp0(key, "rssi") == 0) {
6130                                 dbus_message_iter_get_basic(&value, &strength);
6131                                 SUPPLICANT_DBG("Strength = %d", strength);
6132                                 break;
6133                         }
6134                 }
6135                 dbus_message_iter_next(&dict);
6136         }
6137
6138 out:
6139         if(data->callback)
6140                 data->callback(err, maxspeed, strength, data->user_data);
6141
6142         g_free(data->path);
6143         dbus_free(data);
6144 }
6145
6146 int g_supplicant_interface_signalpoll(GSupplicantInterface *interface,
6147                                 GSupplicantMaxSpeedCallback callback,
6148                                 void *user_data)
6149 {
6150         struct interface_signalpoll_data *data;
6151         int ret;
6152
6153         if (!interface)
6154                 return -EINVAL;
6155
6156         if (!system_available)
6157                 return -EFAULT;
6158
6159         data = dbus_malloc0(sizeof(*data));
6160         if (!data)
6161                 return -ENOMEM;
6162
6163         data->interface = interface;
6164         data->path = g_strdup(interface->path);
6165         data->callback = callback;
6166         data->user_data = user_data;
6167
6168         ret = supplicant_dbus_method_call(interface->path,
6169                         SUPPLICANT_INTERFACE ".Interface", "SignalPoll",
6170                         NULL, interface_signalpoll_result, data,
6171                         interface);
6172
6173         if (ret < 0) {
6174                 g_free(data->path);
6175                 dbus_free(data);
6176         }
6177
6178         return ret;
6179 }
6180 #endif
6181
6182 static int parse_supplicant_error(DBusMessageIter *iter)
6183 {
6184         int err = -ECONNABORTED;
6185         char *key;
6186
6187         if (!iter)
6188                 return err;
6189
6190         /* If the given passphrase is malformed wpa_s returns
6191          * "invalid message format" but this error should be interpreted as
6192          * invalid-key.
6193          */
6194         while (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_STRING) {
6195                 dbus_message_iter_get_basic(iter, &key);
6196                 if (strncmp(key, "psk", 3) == 0 ||
6197                                 strncmp(key, "wep_key", 7) == 0 ||
6198                                 strcmp(key, "invalid message format") == 0) {
6199                         err = -ENOKEY;
6200                         break;
6201                 }
6202                 dbus_message_iter_next(iter);
6203         }
6204
6205         return err;
6206 }
6207
6208 static void interface_select_network_result(const char *error,
6209                                 DBusMessageIter *iter, void *user_data)
6210 {
6211         struct interface_connect_data *data = user_data;
6212         int err;
6213
6214         SUPPLICANT_DBG("");
6215
6216         err = 0;
6217         if (error) {
6218 #if defined TIZEN_EXT
6219                 SUPPLICANT_DBG("SelectNetwork errorFreq %s", error);
6220 #else
6221                 SUPPLICANT_DBG("SelectNetwork error %s", error);
6222 #endif
6223                 err = parse_supplicant_error(iter);
6224         }
6225
6226         g_free(data->path);
6227
6228         if (data->callback)
6229                 data->callback(err, data->interface, data->user_data);
6230
6231 #if defined TIZEN_EXT
6232         g_free(data->ssid->ssid);
6233         g_free((char *)data->ssid->passphrase);
6234         g_free((char *)data->ssid->connector);
6235         g_free((char *)data->ssid->c_sign_key);
6236         g_free((char *)data->ssid->net_access_key);
6237 #endif
6238         g_free(data->ssid);
6239         dbus_free(data);
6240 }
6241
6242 static void interface_select_network_params(DBusMessageIter *iter,
6243                                                         void *user_data)
6244 {
6245         struct interface_connect_data *data = user_data;
6246         GSupplicantInterface *interface = data->interface;
6247 #if defined TIZEN_EXT
6248         GSupplicantSSID *ssid = data->ssid;
6249 #endif
6250
6251         dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
6252                                         &interface->network_path);
6253 #if defined TIZEN_EXT
6254         if (!ssid->bssid_for_connect_len)
6255                 dbus_message_iter_append_basic(iter, DBUS_TYPE_INT32, &ssid->freq);
6256 #endif
6257 }
6258
6259 static void interface_add_network_result(const char *error,
6260                                 DBusMessageIter *iter, void *user_data)
6261 {
6262         struct interface_connect_data *data = user_data;
6263         GSupplicantInterface *interface = data->interface;
6264         const char *path;
6265         int err;
6266
6267         if (error)
6268                 goto error;
6269
6270         dbus_message_iter_get_basic(iter, &path);
6271         if (!path)
6272                 goto error;
6273
6274         SUPPLICANT_DBG("PATH: %s", path);
6275
6276 #if defined TIZEN_EXT
6277         if (interface->network_path)
6278                 g_free(interface->network_path);
6279 #endif
6280         interface->network_path = g_strdup(path);
6281
6282         store_network_information(interface, data->ssid);
6283
6284 #if defined TIZEN_EXT
6285         SUPPLICANT_DBG(".Interface.SelectNetworkFreq");
6286         GSupplicantSSID *ssid = data->ssid;
6287
6288         if (!ssid->bssid_for_connect_len)
6289                 supplicant_dbus_method_call(data->interface->path,
6290                                 SUPPLICANT_INTERFACE ".Interface", "SelectNetworkFreq",
6291                                 interface_select_network_params,
6292                                 interface_select_network_result, data,
6293                                 interface);
6294         else
6295                 supplicant_dbus_method_call(data->interface->path,
6296                                 SUPPLICANT_INTERFACE ".Interface", "SelectNetwork",
6297                                 interface_select_network_params,
6298                                 interface_select_network_result, data,
6299                                 interface);
6300 #else
6301         supplicant_dbus_method_call(data->interface->path,
6302                         SUPPLICANT_INTERFACE ".Interface", "SelectNetwork",
6303                         interface_select_network_params,
6304                         interface_select_network_result, data,
6305                         interface);
6306 #endif
6307
6308         return;
6309
6310 error:
6311         SUPPLICANT_DBG("AddNetwork error %s", error);
6312
6313         if (interface_exists(data->interface, data->interface->path)) {
6314                 err = parse_supplicant_error(iter);
6315                 if (data->callback)
6316                         data->callback(err, data->interface, data->user_data);
6317
6318                 g_free(interface->network_path);
6319                 interface->network_path = NULL;
6320         }
6321
6322         g_free(data->path);
6323 #if defined TIZEN_EXT
6324         g_free(data->ssid->ssid);
6325         g_free((char *)data->ssid->passphrase);
6326         g_free((char *)data->ssid->connector);
6327         g_free((char *)data->ssid->c_sign_key);
6328         g_free((char *)data->ssid->net_access_key);
6329 #endif
6330         g_free(data->ssid);
6331         g_free(data);
6332 }
6333
6334 static void add_network_security_none(DBusMessageIter *dict)
6335 {
6336         const char *auth_alg = "OPEN";
6337
6338         supplicant_dbus_dict_append_basic(dict, "auth_alg",
6339                                         DBUS_TYPE_STRING, &auth_alg);
6340 }
6341
6342 static void add_network_security_wep(DBusMessageIter *dict,
6343                                         GSupplicantSSID *ssid)
6344 {
6345         const char *auth_alg = "OPEN SHARED";
6346         dbus_uint32_t key_index = 0;
6347
6348         supplicant_dbus_dict_append_basic(dict, "auth_alg",
6349                                         DBUS_TYPE_STRING, &auth_alg);
6350
6351         if (ssid->passphrase) {
6352                 int size = strlen(ssid->passphrase);
6353                 if (size == 10 || size == 26) {
6354                         unsigned char *key = g_try_malloc(13);
6355                         char tmp[3];
6356                         int i;
6357
6358                         memset(tmp, 0, sizeof(tmp));
6359                         if (!key)
6360                                 size = 0;
6361
6362                         for (i = 0; i < size / 2; i++) {
6363                                 memcpy(tmp, ssid->passphrase + (i * 2), 2);
6364                                 key[i] = (unsigned char) strtol(tmp, NULL, 16);
6365                         }
6366
6367                         supplicant_dbus_dict_append_fixed_array(dict,
6368                                                         "wep_key0",
6369                                                         DBUS_TYPE_BYTE,
6370                                                         &key, size / 2);
6371                         g_free(key);
6372                 } else if (size == 5 || size == 13) {
6373                         unsigned char *key = g_try_malloc(13);
6374                         int i;
6375
6376                         if (!key)
6377                                 size = 0;
6378
6379                         for (i = 0; i < size; i++)
6380                                 key[i] = (unsigned char) ssid->passphrase[i];
6381
6382                         supplicant_dbus_dict_append_fixed_array(dict,
6383                                                                 "wep_key0",
6384                                                                 DBUS_TYPE_BYTE,
6385                                                                 &key, size);
6386                         g_free(key);
6387                 } else
6388                         supplicant_dbus_dict_append_basic(dict,
6389                                                         "wep_key0",
6390                                                         DBUS_TYPE_STRING,
6391                                                         &ssid->passphrase);
6392
6393                 supplicant_dbus_dict_append_basic(dict, "wep_tx_keyidx",
6394                                         DBUS_TYPE_UINT32, &key_index);
6395         }
6396 }
6397
6398 static dbus_bool_t is_psk_raw_key(const char *psk)
6399 {
6400         int i;
6401
6402         /* A raw key is always 64 bytes length... */
6403         if (strlen(psk) != 64)
6404                 return FALSE;
6405
6406         /* ... and its content is in hex representation */
6407         for (i = 0; i < 64; i++)
6408                 if (!isxdigit((unsigned char) psk[i]))
6409                         return FALSE;
6410
6411         return TRUE;
6412 }
6413
6414 static unsigned char hexchar2bin(char c)
6415 {
6416         if ((c >= '0') && (c <= '9'))
6417                 return c - '0';
6418         else if ((c >= 'A') && (c <= 'F'))
6419                 return c - 'A' + 10;
6420         else if ((c >= 'a') && (c <= 'f'))
6421                 return c - 'a' + 10;
6422         else
6423                 return c;
6424 }
6425
6426 static void hexstring2bin(const char *string, unsigned char *data,
6427                                 size_t data_len)
6428 {
6429         size_t i;
6430
6431         for (i = 0; i < data_len; i++)
6432                 data[i] = (hexchar2bin(string[i * 2 + 0]) << 4 |
6433                            hexchar2bin(string[i * 2 + 1]) << 0);
6434 }
6435
6436 static void add_network_security_psk(DBusMessageIter *dict,
6437                                         GSupplicantSSID *ssid)
6438 {
6439         if (ssid->passphrase && strlen(ssid->passphrase) > 0) {
6440                 const char *key = "psk";
6441
6442                 if (is_psk_raw_key(ssid->passphrase)) {
6443                         unsigned char data[32];
6444                         unsigned char *datap = data;
6445
6446                         /* The above pointer alias is required by D-Bus because
6447                          * with D-Bus and GCC, non-heap-allocated arrays cannot
6448                          * be passed directly by their base pointer. */
6449
6450                         hexstring2bin(ssid->passphrase, datap, sizeof(data));
6451
6452                         supplicant_dbus_dict_append_fixed_array(dict,
6453                                                         key, DBUS_TYPE_BYTE,
6454                                                         &datap, sizeof(data));
6455                 } else
6456                         supplicant_dbus_dict_append_basic(dict,
6457                                                         key, DBUS_TYPE_STRING,
6458                                                         &ssid->passphrase);
6459         }
6460 }
6461
6462 static void add_network_security_tls(DBusMessageIter *dict,
6463                                         GSupplicantSSID *ssid)
6464 {
6465         /*
6466          * For TLS, we at least need:
6467          *              The client certificate
6468          *              The client private key file
6469          *              The client private key file password
6470          *
6471          * The Authority certificate is optional.
6472          */
6473         if (!ssid->client_cert_path)
6474                 return;
6475
6476         if (!ssid->private_key_path)
6477                 return;
6478
6479 #if !defined TIZEN_EXT
6480         if (!ssid->private_key_passphrase)
6481                 return;
6482 #endif
6483
6484         if (ssid->ca_cert_path)
6485                 supplicant_dbus_dict_append_basic(dict, "ca_cert",
6486                                         DBUS_TYPE_STRING, &ssid->ca_cert_path);
6487
6488         supplicant_dbus_dict_append_basic(dict, "private_key",
6489                                                 DBUS_TYPE_STRING,
6490                                                 &ssid->private_key_path);
6491 #if !defined TIZEN_EXT
6492         supplicant_dbus_dict_append_basic(dict, "private_key_passwd",
6493                                                 DBUS_TYPE_STRING,
6494                                                 &ssid->private_key_passphrase);
6495 #endif
6496         supplicant_dbus_dict_append_basic(dict, "client_cert",
6497                                                 DBUS_TYPE_STRING,
6498                                                 &ssid->client_cert_path);
6499 }
6500
6501 static void add_network_security_peap(DBusMessageIter *dict,
6502                                         GSupplicantSSID *ssid)
6503 {
6504         char *phase2_auth;
6505
6506         /*
6507          * For PEAP/TTLS, we at least need
6508          *              The authority certificate
6509          *              The 2nd phase authentication method
6510          *              The 2nd phase passphrase
6511          *
6512          * The Client certificate is optional although strongly recommended
6513          * When setting it, we need in addition
6514          *              The Client private key file
6515          *              The Client private key file password
6516          */
6517         if (!ssid->passphrase)
6518                 return;
6519
6520         if (!ssid->phase2_auth)
6521                 return;
6522
6523         if (ssid->client_cert_path) {
6524                 if (!ssid->private_key_path)
6525                         return;
6526
6527 #if !defined TIZEN_EXT
6528                 if (!ssid->private_key_passphrase)
6529                         return;
6530 #endif
6531
6532                 supplicant_dbus_dict_append_basic(dict, "client_cert",
6533                                                 DBUS_TYPE_STRING,
6534                                                 &ssid->client_cert_path);
6535
6536                 supplicant_dbus_dict_append_basic(dict, "private_key",
6537                                                 DBUS_TYPE_STRING,
6538                                                 &ssid->private_key_path);
6539
6540 #if !defined TIZEN_EXT
6541                 supplicant_dbus_dict_append_basic(dict, "private_key_passwd",
6542                                                 DBUS_TYPE_STRING,
6543                                                 &ssid->private_key_passphrase);
6544 #endif
6545
6546         }
6547
6548         if(g_strcmp0(ssid->phase2_auth, "GTC") == 0 && g_strcmp0(ssid->eap, "ttls") == 0)
6549                 phase2_auth = g_strdup_printf("autheap=%s", ssid->phase2_auth);
6550         else if (g_str_has_prefix(ssid->phase2_auth, "EAP-")) {
6551                 phase2_auth = g_strdup_printf("autheap=%s",
6552                                         ssid->phase2_auth + strlen("EAP-"));
6553         } else
6554                 phase2_auth = g_strdup_printf("auth=%s", ssid->phase2_auth);
6555
6556         supplicant_dbus_dict_append_basic(dict, "password",
6557                                                 DBUS_TYPE_STRING,
6558                                                 &ssid->passphrase);
6559
6560         if (ssid->ca_cert_path)
6561                 supplicant_dbus_dict_append_basic(dict, "ca_cert",
6562                                                 DBUS_TYPE_STRING,
6563                                                 &ssid->ca_cert_path);
6564
6565         supplicant_dbus_dict_append_basic(dict, "phase2",
6566                                                 DBUS_TYPE_STRING,
6567                                                 &phase2_auth);
6568
6569         g_free(phase2_auth);
6570 }
6571
6572 #if defined TIZEN_EXT
6573 static void add_network_security_aka_sim(DBusMessageIter *dict,
6574                                         GSupplicantSSID *ssid)
6575 {
6576         if (!ssid->passphrase)
6577                 return;
6578
6579         supplicant_dbus_dict_append_basic(dict, "password",
6580                         DBUS_TYPE_STRING,
6581                         &ssid->passphrase);
6582 }
6583
6584 static void add_network_security_fast(DBusMessageIter *dict,
6585                 GSupplicantSSID *ssid)
6586 {
6587         /*
6588          * For FAST, we at least need:
6589          *              id / password
6590          *              phase1 (provisiong information)
6591          *              pac_file
6592          */
6593
6594         /* Allow provisioing both authenticated and unauthenticated */
6595         const char *phase1 = "fast_provisioning=2";
6596         supplicant_dbus_dict_append_basic(dict, "phase1",
6597                         DBUS_TYPE_STRING,
6598                         &phase1);
6599
6600         SUPPLICANT_DBG("pac_file [%s]", ssid->pac_file);
6601         if(ssid->pac_file)
6602                 supplicant_dbus_dict_append_basic(dict, "pac_file",
6603                                 DBUS_TYPE_STRING,
6604                                 &ssid->pac_file);
6605
6606         supplicant_dbus_dict_append_basic(dict, "password",
6607                         DBUS_TYPE_STRING,
6608                         &ssid->passphrase);
6609 }
6610 #endif
6611
6612 static void add_network_security_eap(DBusMessageIter *dict,
6613                                         GSupplicantSSID *ssid)
6614 {
6615         char *eap_value;
6616
6617 #if defined TIZEN_EXT
6618         if (!ssid->eap)
6619 #else
6620         if (!ssid->eap || !ssid->identity)
6621 #endif
6622                 return;
6623
6624         if (g_strcmp0(ssid->eap, "tls") == 0) {
6625                 add_network_security_tls(dict, ssid);
6626         } else if (g_strcmp0(ssid->eap, "peap") == 0 ||
6627                                 g_strcmp0(ssid->eap, "ttls") == 0) {
6628 #if defined TIZEN_EXT
6629                 if (!ssid->identity)
6630                         return;
6631 #endif
6632                 add_network_security_peap(dict, ssid);
6633
6634 #if defined TIZEN_EXT
6635         } else if (g_strcmp0(ssid->eap, "sim") == 0 ||
6636                         g_strcmp0(ssid->eap, "aka") == 0 ||
6637                         g_strcmp0(ssid->eap, "aka'") == 0) {
6638                 add_network_security_aka_sim(dict, ssid);
6639         } else if (g_strcmp0(ssid->eap, "pwd") == 0) {
6640                 if(!ssid->passphrase)
6641                         return;
6642                 supplicant_dbus_dict_append_basic(dict, "password",
6643                                 DBUS_TYPE_STRING,
6644                                 &ssid->passphrase);
6645         } else if (g_strcmp0(ssid->eap, "fast") == 0){
6646                 if (!ssid->identity || !ssid->passphrase)
6647                         return;
6648
6649                 add_network_security_fast(dict, ssid);
6650 #endif
6651         } else
6652                 return;
6653
6654         eap_value = g_ascii_strup(ssid->eap, -1);
6655
6656         supplicant_dbus_dict_append_basic(dict, "eap",
6657                                                 DBUS_TYPE_STRING,
6658                                                 &eap_value);
6659 #if defined TIZEN_EXT
6660         if (ssid->identity != NULL)
6661                 supplicant_dbus_dict_append_basic(dict, "identity",
6662                                                         DBUS_TYPE_STRING,
6663                                                         &ssid->identity);
6664 #else
6665         supplicant_dbus_dict_append_basic(dict, "identity",
6666                                                 DBUS_TYPE_STRING,
6667                                                 &ssid->identity);
6668 #endif
6669         if(ssid->anonymous_identity)
6670                 supplicant_dbus_dict_append_basic(dict, "anonymous_identity",
6671                                                      DBUS_TYPE_STRING,
6672                                                      &ssid->anonymous_identity);
6673
6674         if(ssid->subject_match)
6675                 supplicant_dbus_dict_append_basic(dict, "subject_match",
6676                                                      DBUS_TYPE_STRING,
6677                                                      &ssid->subject_match);
6678
6679         if(ssid->altsubject_match)
6680                 supplicant_dbus_dict_append_basic(dict, "altsubject_match",
6681                                                      DBUS_TYPE_STRING,
6682                                                      &ssid->altsubject_match);
6683
6684         if(ssid->domain_suffix_match)
6685                 supplicant_dbus_dict_append_basic(dict, "domain_suffix_match",
6686                                                      DBUS_TYPE_STRING,
6687                                                      &ssid->domain_suffix_match);
6688
6689         if(ssid->domain_match)
6690                 supplicant_dbus_dict_append_basic(dict, "domain_match",
6691                                                      DBUS_TYPE_STRING,
6692                                                      &ssid->domain_match);
6693
6694         g_free(eap_value);
6695 }
6696
6697 static void add_network_security_ciphers(DBusMessageIter *dict,
6698                                                 GSupplicantSSID *ssid)
6699 {
6700         unsigned int p_cipher, g_cipher, i;
6701         char *pairwise, *group;
6702         char *pair_ciphers[4];
6703         char *group_ciphers[5];
6704
6705         p_cipher = ssid->pairwise_cipher;
6706         g_cipher = ssid->group_cipher;
6707
6708         if (p_cipher == 0 && g_cipher == 0)
6709                 return;
6710
6711         i = 0;
6712
6713         if (p_cipher & G_SUPPLICANT_PAIRWISE_CCMP)
6714                 pair_ciphers[i++] = "CCMP";
6715
6716         if (p_cipher & G_SUPPLICANT_PAIRWISE_TKIP)
6717                 pair_ciphers[i++] = "TKIP";
6718
6719         if (p_cipher & G_SUPPLICANT_PAIRWISE_NONE)
6720                 pair_ciphers[i++] = "NONE";
6721
6722         pair_ciphers[i] = NULL;
6723
6724         i = 0;
6725
6726         if (g_cipher & G_SUPPLICANT_GROUP_CCMP)
6727                 group_ciphers[i++] = "CCMP";
6728
6729         if (g_cipher & G_SUPPLICANT_GROUP_TKIP)
6730                 group_ciphers[i++] = "TKIP";
6731
6732         if (g_cipher & G_SUPPLICANT_GROUP_WEP104)
6733                 group_ciphers[i++] = "WEP104";
6734
6735         if (g_cipher & G_SUPPLICANT_GROUP_WEP40)
6736                 group_ciphers[i++] = "WEP40";
6737
6738         group_ciphers[i] = NULL;
6739
6740         pairwise = g_strjoinv(" ", pair_ciphers);
6741         group = g_strjoinv(" ", group_ciphers);
6742
6743         SUPPLICANT_DBG("cipher %s %s", pairwise, group);
6744
6745         supplicant_dbus_dict_append_basic(dict, "pairwise",
6746                                                 DBUS_TYPE_STRING,
6747                                                 &pairwise);
6748         supplicant_dbus_dict_append_basic(dict, "group",
6749                                                 DBUS_TYPE_STRING,
6750                                                 &group);
6751
6752         g_free(pairwise);
6753         g_free(group);
6754 }
6755
6756 static void add_network_security_proto(DBusMessageIter *dict,
6757                                                 GSupplicantSSID *ssid)
6758 {
6759         unsigned int protocol, i;
6760         char *proto;
6761         char *protos[3];
6762
6763         protocol = ssid->protocol;
6764
6765         if (protocol == 0)
6766                 return;
6767
6768         i = 0;
6769
6770         if (protocol & G_SUPPLICANT_PROTO_RSN)
6771                 protos[i++] = "RSN";
6772
6773         if (protocol & G_SUPPLICANT_PROTO_WPA)
6774                 protos[i++] = "WPA";
6775
6776         protos[i] = NULL;
6777
6778         proto = g_strjoinv(" ", protos);
6779
6780         SUPPLICANT_DBG("proto %s", proto);
6781
6782         supplicant_dbus_dict_append_basic(dict, "proto",
6783                                                 DBUS_TYPE_STRING,
6784                                                 &proto);
6785
6786         g_free(proto);
6787 }
6788
6789 #if defined TIZEN_EXT
6790 static void add_network_ieee80211w(DBusMessageIter *dict, GSupplicantSSID *ssid)
6791 {
6792         if (ssid->security != G_SUPPLICANT_SECURITY_SAE
6793                         && ssid->security != G_SUPPLICANT_SECURITY_OWE
6794                         && ssid->security != G_SUPPLICANT_SECURITY_DPP)
6795                 return;
6796
6797         supplicant_dbus_dict_append_basic(dict, "ieee80211w", DBUS_TYPE_UINT32,
6798                                           &ssid->ieee80211w);
6799 }
6800
6801 static void add_network_security_connector(DBusMessageIter *dict, GSupplicantSSID *ssid)
6802 {
6803         if (ssid->connector && strlen(ssid->connector) > 0) {
6804                 const char *key = "dpp_connector";
6805
6806                 supplicant_dbus_dict_append_basic(dict,
6807                                 key, DBUS_TYPE_STRING,
6808                                 &ssid->connector);
6809         }
6810 }
6811
6812 static size_t convert_hexstr_to_bin(const char *hex_str, unsigned char **bin)
6813 {
6814         unsigned char *bin_res = NULL;
6815         unsigned int i, j, hex;
6816         size_t hex_str_len;
6817
6818         if (!hex_str || strlen(hex_str) == 0)
6819                 return 0;
6820
6821         hex_str_len = strlen(hex_str);
6822         bin_res = g_try_malloc0(hex_str_len / 2);
6823         if (!bin_res)
6824                 return 0;
6825
6826         j = 0;
6827         for (i = 0; i < hex_str_len; i+=2) {
6828                 sscanf(hex_str + i, "%02x", &hex);
6829                 bin_res[j++] = hex;
6830         }
6831
6832         *bin = bin_res;
6833         return hex_str_len / 2;
6834 }
6835
6836 static void add_network_security_c_sign_key(DBusMessageIter *dict, GSupplicantSSID *ssid)
6837 {
6838         if (ssid->c_sign_key && strlen(ssid->c_sign_key) > 0) {
6839                 const char *key = "dpp_csign";
6840                 unsigned char *bin_csign = NULL;
6841                 size_t bin_csign_len = convert_hexstr_to_bin(ssid->c_sign_key, &bin_csign);
6842                 if  (bin_csign_len != 0)
6843                         supplicant_dbus_dict_append_fixed_array(dict,
6844                                         key, DBUS_TYPE_BYTE,
6845                                         &bin_csign, bin_csign_len);
6846                 g_free(bin_csign);
6847         }
6848 }
6849
6850 static void add_network_security_net_access_key(DBusMessageIter *dict, GSupplicantSSID *ssid)
6851 {
6852         if (ssid->net_access_key && strlen(ssid->net_access_key) > 0) {
6853                 const char *key = "dpp_netaccesskey";
6854                 unsigned char *bin_netaccesskey = NULL;
6855                 size_t bin_netaccesskey_len = convert_hexstr_to_bin(ssid->net_access_key, &bin_netaccesskey);
6856                 if  (bin_netaccesskey_len != 0)
6857                         supplicant_dbus_dict_append_fixed_array(dict,
6858                                         key, DBUS_TYPE_BYTE,
6859                                         &bin_netaccesskey, bin_netaccesskey_len);
6860                 g_free(bin_netaccesskey);
6861         }
6862 }
6863
6864 #endif
6865
6866 static void add_network_security(DBusMessageIter *dict, GSupplicantSSID *ssid)
6867 {
6868         char *key_mgmt;
6869
6870         switch (ssid->security) {
6871         case G_SUPPLICANT_SECURITY_NONE:
6872                 key_mgmt = "NONE";
6873                 add_network_security_none(dict);
6874                 add_network_security_ciphers(dict, ssid);
6875                 break;
6876         case G_SUPPLICANT_SECURITY_UNKNOWN:
6877         case G_SUPPLICANT_SECURITY_WEP:
6878                 key_mgmt = "NONE";
6879                 add_network_security_wep(dict, ssid);
6880                 add_network_security_ciphers(dict, ssid);
6881                 break;
6882         case G_SUPPLICANT_SECURITY_PSK:
6883                 key_mgmt = "WPA-PSK";
6884                 add_network_security_psk(dict, ssid);
6885                 add_network_security_ciphers(dict, ssid);
6886                 add_network_security_proto(dict, ssid);
6887                 break;
6888         case G_SUPPLICANT_SECURITY_IEEE8021X:
6889                 key_mgmt = "WPA-EAP";
6890                 add_network_security_eap(dict, ssid);
6891                 add_network_security_ciphers(dict, ssid);
6892                 add_network_security_proto(dict, ssid);
6893                 break;
6894 #if defined TIZEN_EXT
6895         case G_SUPPLICANT_SECURITY_FT_PSK:
6896                 key_mgmt = "FT-PSK";
6897                 add_network_security_psk(dict, ssid);
6898                 add_network_security_ciphers(dict, ssid);
6899                 add_network_security_proto(dict, ssid);
6900                 break;
6901         case G_SUPPLICANT_SECURITY_FT_IEEE8021X:
6902                 key_mgmt = "FT-EAP";
6903                 add_network_security_eap(dict, ssid);
6904                 add_network_security_ciphers(dict, ssid);
6905                 add_network_security_proto(dict, ssid);
6906                 break;
6907         case G_SUPPLICANT_SECURITY_SAE:
6908                 key_mgmt = "SAE";
6909                 add_network_security_psk(dict, ssid);
6910                 break;
6911         case G_SUPPLICANT_SECURITY_OWE:
6912                 key_mgmt = "OWE";
6913                 add_network_security_ciphers(dict, ssid);
6914                 add_network_security_proto(dict, ssid);
6915                 break;
6916         case G_SUPPLICANT_SECURITY_DPP:
6917                 key_mgmt = "DPP";
6918                 add_network_security_connector(dict, ssid);
6919                 add_network_security_c_sign_key(dict, ssid);
6920                 add_network_security_net_access_key(dict, ssid);
6921                 break;
6922 #endif
6923         }
6924
6925         supplicant_dbus_dict_append_basic(dict, "key_mgmt",
6926                                 DBUS_TYPE_STRING, &key_mgmt);
6927 }
6928
6929 static void add_network_mode(DBusMessageIter *dict, GSupplicantSSID *ssid)
6930 {
6931         dbus_uint32_t mode;
6932
6933         switch (ssid->mode) {
6934         case G_SUPPLICANT_MODE_UNKNOWN:
6935         case G_SUPPLICANT_MODE_INFRA:
6936                 mode = 0;
6937                 break;
6938         case G_SUPPLICANT_MODE_IBSS:
6939                 mode = 1;
6940                 break;
6941         case G_SUPPLICANT_MODE_MASTER:
6942                 mode = 2;
6943                 break;
6944 #if defined TIZEN_EXT_WIFI_MESH
6945         case G_SUPPLICANT_MODE_MESH:
6946                 mode = 5;
6947                 break;
6948 #endif
6949         }
6950
6951         supplicant_dbus_dict_append_basic(dict, "mode",
6952                                 DBUS_TYPE_UINT32, &mode);
6953 }
6954
6955 static void interface_add_network_params(DBusMessageIter *iter, void *user_data)
6956 {
6957         DBusMessageIter dict;
6958         struct interface_connect_data *data = user_data;
6959         GSupplicantSSID *ssid = data->ssid;
6960 #if defined TIZEN_EXT
6961         GSupplicantInterface *interface = data->interface;
6962 #endif
6963
6964         supplicant_dbus_dict_open(iter, &dict);
6965
6966         if (ssid->scan_ssid)
6967                 supplicant_dbus_dict_append_basic(&dict, "scan_ssid",
6968                                          DBUS_TYPE_UINT32, &ssid->scan_ssid);
6969
6970         if (ssid->freq)
6971                 supplicant_dbus_dict_append_basic(&dict, "frequency",
6972                                          DBUS_TYPE_UINT32, &ssid->freq);
6973
6974         if (ssid->bgscan)
6975                 supplicant_dbus_dict_append_basic(&dict, "bgscan",
6976                                         DBUS_TYPE_STRING, &ssid->bgscan);
6977
6978         add_network_mode(&dict, ssid);
6979
6980         add_network_security(&dict, ssid);
6981
6982 #if defined TIZEN_EXT
6983         add_network_ieee80211w(&dict, ssid);
6984 #endif
6985
6986         supplicant_dbus_dict_append_fixed_array(&dict, "ssid",
6987                                         DBUS_TYPE_BYTE, &ssid->ssid,
6988                                                 ssid->ssid_len);
6989
6990 #if defined TIZEN_EXT
6991         if (ssid->bssid) {
6992                 char *bssid = NULL;
6993                 bssid = g_try_malloc0(18);
6994                 if (bssid == NULL) {
6995                         SUPPLICANT_DBG("memory allocation error");
6996                         supplicant_dbus_dict_close(iter, &dict);
6997                         return;
6998                 }
6999
7000                 if (ssid->bssid_for_connect_len) {
7001                         snprintf(bssid, 18, MACSTR, MAC2STR(ssid->bssid_for_connect));
7002                         memcpy(interface->add_network_bssid, ssid->bssid_for_connect, WIFI_BSSID_LEN_MAX);
7003                 } else {
7004                         snprintf(bssid, 18, MACSTR, MAC2STR(ssid->bssid));
7005                         memcpy(interface->add_network_bssid, ssid->bssid, WIFI_BSSID_LEN_MAX);
7006                 }
7007
7008                 SUPPLICANT_DBG("bssid [" MACSTR "]", MAC2STR(interface->add_network_bssid));
7009
7010                 supplicant_dbus_dict_append_basic(&dict, "bssid",
7011                                         DBUS_TYPE_STRING, &bssid);
7012                 g_free(bssid);
7013         }
7014 #endif
7015
7016         supplicant_dbus_dict_close(iter, &dict);
7017 }
7018
7019 static void interface_wps_start_result(const char *error,
7020                                 DBusMessageIter *iter, void *user_data)
7021 {
7022         struct interface_connect_data *data = user_data;
7023         int err;
7024
7025         SUPPLICANT_DBG("");
7026
7027         err = 0;
7028         if (error) {
7029                 SUPPLICANT_DBG("error: %s", error);
7030                 err = parse_supplicant_error(iter);
7031         }
7032
7033         if(data->callback)
7034                 data->callback(err, data->interface, data->user_data);
7035
7036         g_free(data->path);
7037         g_free(data->ssid);
7038         dbus_free(data);
7039 }
7040
7041 static void interface_add_wps_params(DBusMessageIter *iter, void *user_data)
7042 {
7043         struct interface_connect_data *data = user_data;
7044         GSupplicantSSID *ssid = data->ssid;
7045         const char *role = "enrollee", *type;
7046         DBusMessageIter dict;
7047
7048         SUPPLICANT_DBG("");
7049
7050         supplicant_dbus_dict_open(iter, &dict);
7051
7052         supplicant_dbus_dict_append_basic(&dict, "Role",
7053                                                 DBUS_TYPE_STRING, &role);
7054
7055         type = "pbc";
7056         if (ssid->pin_wps) {
7057                 type = "pin";
7058                 supplicant_dbus_dict_append_basic(&dict, "Pin",
7059                                         DBUS_TYPE_STRING, &ssid->pin_wps);
7060         }
7061
7062         supplicant_dbus_dict_append_basic(&dict, "Type",
7063                                         DBUS_TYPE_STRING, &type);
7064
7065 #if defined TIZEN_EXT
7066         if (ssid->bssid)
7067                 supplicant_dbus_dict_append_fixed_array(&dict, "Bssid",
7068                                                 DBUS_TYPE_BYTE, &ssid->bssid, 6);
7069 #endif
7070
7071         supplicant_dbus_dict_close(iter, &dict);
7072 }
7073
7074 static void wps_start(const char *error, DBusMessageIter *iter, void *user_data)
7075 {
7076         struct interface_connect_data *data = user_data;
7077
7078         SUPPLICANT_DBG("");
7079
7080         if (error) {
7081                 SUPPLICANT_DBG("error: %s", error);
7082                 g_free(data->path);
7083                 g_free(data->ssid);
7084                 dbus_free(data);
7085                 return;
7086         }
7087
7088 #if defined TIZEN_EXT
7089         GSupplicantSSID *ssid = data->ssid;
7090         if (ssid->pin_wps != NULL) {
7091                 if (!g_utf8_validate(ssid->pin_wps, 8, NULL)) {
7092                         SUPPLICANT_DBG("Invalid characters in WPS_PIN");
7093                         g_free(data->ssid);
7094                         dbus_free(data);
7095                         return;
7096                 }
7097         }
7098 #endif
7099         supplicant_dbus_method_call(data->interface->path,
7100                         SUPPLICANT_INTERFACE ".Interface.WPS", "Start",
7101                         interface_add_wps_params,
7102                         interface_wps_start_result, data, NULL);
7103 }
7104
7105 static void wps_process_credentials(DBusMessageIter *iter, void *user_data)
7106 {
7107         dbus_bool_t credentials = TRUE;
7108
7109         SUPPLICANT_DBG("");
7110
7111         dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &credentials);
7112 }
7113
7114
7115 #if defined TIZEN_EXT
7116 #define NETCONFIG_SERVICE "net.netconfig"
7117 #define NETCONFIG_WIFI_PATH "/net/netconfig/wifi"
7118 #define NETCONFIG_WIFI_INTERFACE NETCONFIG_SERVICE ".wifi"
7119
7120 struct dec_method_call_data {
7121         struct interface_connect_data *data;
7122         DBusPendingCall *pending_call;
7123 };
7124
7125 static struct dec_method_call_data decrypt_request_data;
7126
7127 static void crypt_method_call_cancel(void)
7128 {
7129         if (decrypt_request_data.pending_call) {
7130                 dbus_pending_call_cancel(decrypt_request_data.pending_call);
7131                 dbus_pending_call_unref(decrypt_request_data.pending_call);
7132                 decrypt_request_data.pending_call = NULL;
7133         }
7134
7135         g_free(decrypt_request_data.data->path);
7136         g_free(decrypt_request_data.data->ssid);
7137         dbus_free(decrypt_request_data.data);
7138         decrypt_request_data.data = NULL;
7139 }
7140
7141 static void decryption_request_reply(DBusPendingCall *call,
7142                                                 void *user_data)
7143 {
7144         DBusMessage *reply;
7145         DBusError error;
7146         DBusMessageIter args;
7147         char *out_data;
7148         int ret;
7149         struct interface_connect_data *data = user_data;
7150
7151         SUPPLICANT_DBG("");
7152
7153         reply = dbus_pending_call_steal_reply(call);
7154
7155         dbus_error_init(&error);
7156         if (dbus_set_error_from_message(&error, reply)) {
7157                 SUPPLICANT_DBG("decryption_request_reply() %s %s", error.name, error.message);
7158                 dbus_error_free(&error);
7159                 ret = -EINVAL;
7160                 goto done;
7161         }
7162
7163         if (dbus_message_iter_init(reply, &args) == FALSE) {
7164                 SUPPLICANT_DBG("dbus_message_iter_init() failed");
7165                 ret = -EINVAL;
7166                 goto done;
7167         }
7168
7169         dbus_message_iter_get_basic(&args, &out_data);
7170         data->ssid->passphrase = g_strdup((const gchar *)out_data);
7171
7172         ret = supplicant_dbus_method_call(data->interface->path,
7173                 SUPPLICANT_INTERFACE ".Interface", "AddNetwork",
7174                 interface_add_network_params,
7175                 interface_add_network_result, data,
7176                 data->interface);
7177
7178 done:
7179         if (ret < 0) {
7180                 SUPPLICANT_DBG("AddNetwork failed %d", ret);
7181                 callback_assoc_failed(decrypt_request_data.data->user_data);
7182                 g_free(data->path);
7183                 g_free(data->ssid->ssid);
7184                 g_free((char *)data->ssid->passphrase);
7185                 g_free((char *)data->ssid->connector);
7186                 g_free((char *)data->ssid->c_sign_key);
7187                 g_free((char *)data->ssid->net_access_key);
7188                 g_free(data->ssid);
7189                 dbus_free(data);
7190         }
7191
7192         dbus_message_unref(reply);
7193         dbus_pending_call_unref(call);
7194
7195         decrypt_request_data.pending_call = NULL;
7196         decrypt_request_data.data = NULL;
7197 }
7198
7199 static int send_decryption_request(const char *passphrase,
7200                         struct interface_connect_data *data)
7201 {
7202         DBusMessage *msg = NULL;
7203         DBusPendingCall *call;
7204
7205         SUPPLICANT_DBG("Decryption request");
7206
7207         if (!passphrase) {
7208                 SUPPLICANT_DBG("Invalid parameter");
7209                 return -EINVAL;
7210         }
7211
7212         if (!connection)
7213                 return -EINVAL;
7214
7215         msg = dbus_message_new_method_call(NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
7216                         NETCONFIG_WIFI_INTERFACE, "DecryptPassphrase");
7217         if (!msg)
7218                 return -EINVAL;
7219
7220         dbus_message_append_args(msg, DBUS_TYPE_STRING, &passphrase,
7221                                                         DBUS_TYPE_INVALID);
7222
7223         if (!dbus_connection_send_with_reply(connection, msg,
7224                                 &call, DBUS_TIMEOUT_USE_DEFAULT)) {
7225                 dbus_message_unref(msg);
7226                 return -EIO;
7227         }
7228
7229         if (!call) {
7230                 dbus_message_unref(msg);
7231                 return -EIO;
7232         }
7233
7234         decrypt_request_data.pending_call = call;
7235         decrypt_request_data.data = data;
7236
7237         dbus_pending_call_set_notify(call, decryption_request_reply, data, NULL);
7238         dbus_message_unref(msg);
7239
7240         SUPPLICANT_DBG("Decryption request succeeded");
7241
7242         return 0;
7243 }
7244
7245 static void decrypt_conf_obj_reply(DBusPendingCall *call,
7246                                                 void *user_data)
7247 {
7248         DBusMessage *reply;
7249         DBusError error;
7250         DBusMessageIter iter, dict;
7251         char *out_data;
7252         int ret;
7253         struct interface_connect_data *data = user_data;
7254
7255         reply = dbus_pending_call_steal_reply(call);
7256
7257         dbus_error_init(&error);
7258         if (dbus_set_error_from_message(&error, reply)) {
7259                 SUPPLICANT_DBG("decryption_conf_obj_reply() %s %s", error.name, error.message);
7260                 dbus_error_free(&error);
7261                 ret = -EINVAL;
7262                 goto done;
7263         }
7264
7265         if (dbus_message_iter_init(reply, &iter) == FALSE) {
7266                 SUPPLICANT_DBG("dbus_message_iter_init() failed");
7267                 ret = -EINVAL;
7268                 goto done;
7269         }
7270
7271         dbus_message_iter_recurse(&iter, &dict);
7272
7273         while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
7274                 DBusMessageIter entry, value;
7275                 const char *key;
7276
7277                 dbus_message_iter_recurse(&dict, &entry);
7278                 dbus_message_iter_get_basic(&entry, &key);
7279                 dbus_message_iter_next(&entry);
7280                 dbus_message_iter_recurse(&entry, &value);
7281                 if (dbus_message_iter_get_arg_type(&value) == DBUS_TYPE_STRING) {
7282                         if (g_strcmp0(key, "connector") == 0) {
7283                                 dbus_message_iter_get_basic(&value, &out_data);
7284                                 data->ssid->connector = g_strdup((const gchar *)out_data);
7285                                 SUPPLICANT_DBG("connector %s", data->ssid->connector);
7286                         } else if (g_strcmp0(key, "c_sign_key") == 0) {
7287                                 dbus_message_iter_get_basic(&value, &out_data);
7288                                 data->ssid->c_sign_key = g_strdup((const gchar *)out_data);
7289                                 SUPPLICANT_DBG("c_sign_key %s", data->ssid->c_sign_key);
7290                         } else if (g_strcmp0(key, "net_access_key") == 0) {
7291                                 dbus_message_iter_get_basic(&value, &out_data);
7292                                 data->ssid->net_access_key = g_strdup((const gchar *)out_data);
7293                                 SUPPLICANT_DBG("net_access_key %s", data->ssid->net_access_key);
7294                         }
7295                 }
7296                 dbus_message_iter_next(&dict);
7297         }
7298
7299         ret = supplicant_dbus_method_call(data->interface->path,
7300                 SUPPLICANT_INTERFACE ".Interface", "AddNetwork",
7301                 interface_add_network_params,
7302                 interface_add_network_result, data,
7303                 data->interface);
7304
7305 done:
7306         if (ret < 0) {
7307                 SUPPLICANT_DBG("AddNetwork failed %d", ret);
7308                 callback_assoc_failed(decrypt_request_data.data->user_data);
7309                 g_free(data->path);
7310                 g_free(data->ssid->ssid);
7311                 g_free((char *)data->ssid->connector);
7312                 g_free((char *)data->ssid->c_sign_key);
7313                 g_free((char *)data->ssid->net_access_key);
7314                 g_free(data->ssid);
7315                 dbus_free(data);
7316         }
7317
7318         dbus_message_unref(reply);
7319         dbus_pending_call_unref(call);
7320
7321         decrypt_request_data.pending_call = NULL;
7322         decrypt_request_data.data = NULL;
7323 }
7324
7325 static int send_decryption_conf_obj_request(GSupplicantSSID *ssid,
7326                         struct interface_connect_data *data)
7327 {
7328         DBusMessage *msg = NULL;
7329         DBusPendingCall *call;
7330
7331         SUPPLICANT_DBG("Decryption configuration object request");
7332
7333         if (!ssid) {
7334                 SUPPLICANT_DBG("Invalid parameter");
7335                 return -EINVAL;
7336         }
7337
7338         if (!connection)
7339                 return -EINVAL;
7340
7341         msg = dbus_message_new_method_call(NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
7342                         NETCONFIG_WIFI_INTERFACE, "DecryptConfObj");
7343         if (!msg)
7344                 return -EINVAL;
7345
7346         dbus_message_append_args(msg, DBUS_TYPE_STRING, &ssid->connector,
7347                                                         DBUS_TYPE_INVALID);
7348         dbus_message_append_args(msg, DBUS_TYPE_STRING, &ssid->c_sign_key,
7349                                                         DBUS_TYPE_INVALID);
7350         dbus_message_append_args(msg, DBUS_TYPE_STRING, &ssid->net_access_key,
7351                                                         DBUS_TYPE_INVALID);
7352
7353         if (!dbus_connection_send_with_reply(connection, msg,
7354                                 &call, DBUS_TIMEOUT_USE_DEFAULT)) {
7355                 dbus_message_unref(msg);
7356                 return -EIO;
7357         }
7358
7359         if (!call) {
7360                 dbus_message_unref(msg);
7361                 return -EIO;
7362         }
7363
7364         decrypt_request_data.pending_call = call;
7365         decrypt_request_data.data = data;
7366
7367         dbus_pending_call_set_notify(call, decrypt_conf_obj_reply, data, NULL);
7368         dbus_message_unref(msg);
7369
7370         SUPPLICANT_DBG("Decrypt Conf Obj request succeeded");
7371
7372         return 0;
7373 }
7374
7375 static bool is_valid_config_object(GSupplicantSSID *ssid)
7376 {
7377         return ((ssid->connector &&
7378                         g_strcmp0(ssid->connector, "") != 0) &&
7379                         (ssid->c_sign_key &&
7380                         g_strcmp0(ssid->c_sign_key, "") != 0) &&
7381                         (ssid->net_access_key &&
7382                         g_strcmp0(ssid->net_access_key, "") != 0));
7383 }
7384 #endif
7385
7386 int g_supplicant_interface_connect(GSupplicantInterface *interface,
7387                                 GSupplicantSSID *ssid,
7388                                 GSupplicantInterfaceCallback callback,
7389                                                         void *user_data)
7390 {
7391         struct interface_connect_data *data;
7392         struct interface_data *intf_data;
7393         int ret = 0;
7394
7395         SUPPLICANT_DBG("");
7396
7397         if (!interface)
7398                 return -EINVAL;
7399
7400         if (!system_available)
7401                 return -EFAULT;
7402
7403         /* TODO: Check if we're already connected and switch */
7404
7405         data = dbus_malloc0(sizeof(*data));
7406         if (!data)
7407                 return -ENOMEM;
7408
7409         data->interface = interface;
7410         data->path = g_strdup(interface->path);
7411         data->callback = callback;
7412         data->ssid = ssid;
7413         data->user_data = user_data;
7414
7415         if (ssid->use_wps) {
7416                 g_free(interface->wps_cred.key);
7417                 memset(&interface->wps_cred, 0,
7418                                 sizeof(struct _GSupplicantWpsCredentials));
7419
7420                 ret = supplicant_dbus_property_set(interface->path,
7421                         SUPPLICANT_INTERFACE ".Interface.WPS",
7422                         "ProcessCredentials", DBUS_TYPE_BOOLEAN_AS_STRING,
7423                         wps_process_credentials, wps_start, data, interface);
7424         } else {
7425                 /* By the time there is a request for connect and the network
7426                  * path is not NULL it means that connman has not removed the
7427                  * previous network pointer. This can happen in the case AP
7428                  * deauthenticated client and connman does not remove the
7429                  * previously connected network pointer. This causes supplicant
7430                  * to reallocate the memory for struct wpa_ssid again even if it
7431                  * is the same SSID. This causes memory usage of wpa_supplicnat
7432                  * to go high. The idea here is that if the previously connected
7433                  * network is not removed at the time of next connection attempt
7434                  * check if the network path is not NULL. In case it is non-NULL
7435                  * first remove the network and then once removal is successful, add
7436                  * the network.
7437                  */
7438
7439                 if (interface->network_path != NULL) {
7440                         g_free(data->path);
7441                         dbus_free(data);
7442
7443                         /*
7444                          * If this add network is for the same network for
7445                          * which wpa_supplicant already has a profile then do
7446                          * not need to add another profile. Only if the
7447                          * profile that needs to get added is different from
7448                          * what is there in wpa_s delete the current one. A
7449                          * network is identified by its SSID, security_type
7450                          * and passphrase (private passphrase in case security
7451                          * type is 802.11x).
7452                          */
7453                         if (compare_network_parameters(interface, ssid)) {
7454                                 return -EALREADY;
7455                         }
7456
7457                         intf_data = dbus_malloc0(sizeof(*intf_data));
7458                         if (!intf_data)
7459                                 return -ENOMEM;
7460
7461                         intf_data->interface = interface;
7462                         intf_data->path = g_strdup(interface->path);
7463                         intf_data->callback = callback;
7464                         intf_data->ssid = ssid;
7465                         intf_data->user_data = user_data;
7466                         intf_data->network_remove_in_progress = TRUE;
7467                         network_remove(intf_data);
7468                 } else {
7469 #if defined TIZEN_EXT
7470                         if (ssid->passphrase &&
7471                             g_strcmp0(ssid->passphrase, "") != 0 &&
7472 #if defined TIZEN_EXT_WIFI_MESH
7473                             ssid->mode != G_SUPPLICANT_MODE_MESH &&
7474 #endif
7475                             !ssid->eap) {
7476                                 ret = send_decryption_request(ssid->passphrase, data);
7477                                 if (ret < 0)
7478                                         SUPPLICANT_DBG("Decryption request failed %d", ret);
7479                         } else if (is_valid_config_object(ssid)) {
7480                                 ret = send_decryption_conf_obj_request(ssid, data);
7481                                 if (ret < 0)
7482                                         SUPPLICANT_DBG("Decryption Conf Obj request failed %d", ret);
7483
7484                         } else
7485 #endif
7486                         ret = supplicant_dbus_method_call(interface->path,
7487                                         SUPPLICANT_INTERFACE ".Interface", "AddNetwork",
7488                                         interface_add_network_params,
7489                                         interface_add_network_result, data,
7490                                         interface);
7491                 }
7492         }
7493
7494         if (ret < 0) {
7495                 g_free(data->path);
7496                 dbus_free(data);
7497                 return ret;
7498         }
7499
7500         return -EINPROGRESS;
7501 }
7502
7503 static void network_remove_result(const char *error,
7504                                 DBusMessageIter *iter, void *user_data)
7505 {
7506         struct interface_data *data = user_data;
7507         struct interface_connect_data *connect_data;
7508         int result = 0;
7509
7510         SUPPLICANT_DBG("");
7511
7512         if (error) {
7513                 result = -EIO;
7514                 SUPPLICANT_DBG("error: %s", error);
7515
7516                 if (g_strcmp0("org.freedesktop.DBus.Error.UnknownMethod",
7517                                                 error) == 0)
7518                         result = -ECONNABORTED;
7519         }
7520
7521         g_free(data->interface->network_path);
7522         data->interface->network_path = NULL;
7523
7524         remove_network_information(data->interface);
7525
7526         if (data->network_remove_in_progress == TRUE) {
7527                 data->network_remove_in_progress = FALSE;
7528                 connect_data = dbus_malloc0(sizeof(*connect_data));
7529                 if (!connect_data)
7530                         return;
7531
7532                 connect_data->interface = data->interface;
7533                 connect_data->path = g_strdup(data->path);
7534                 connect_data->callback = data->callback;
7535                 connect_data->ssid = data->ssid;
7536                 connect_data->user_data = data->user_data;
7537
7538 #if defined TIZEN_EXT
7539                 int ret;
7540                 if (data->ssid->passphrase && g_strcmp0(data->ssid->passphrase, "") != 0
7541                         && !data->ssid->eap) {
7542                         ret = send_decryption_request(data->ssid->passphrase, connect_data);
7543                         if (ret < 0) {
7544                                 SUPPLICANT_DBG("Decryption request failed %d", ret);
7545                                 g_free(connect_data->ssid);
7546                                 g_free(connect_data->path);
7547                                 dbus_free(connect_data);
7548                         }
7549                 } else if (is_valid_config_object(data->ssid)) {
7550                         ret = send_decryption_conf_obj_request(data->ssid, connect_data);
7551                         if (ret < 0) {
7552                                 SUPPLICANT_DBG("Decryption Conf Obj request failed %d", ret);
7553                                 g_free(connect_data->ssid);
7554                                 g_free(connect_data->path);
7555                                 dbus_free(connect_data);
7556                         }
7557                 } else
7558 #endif
7559                 supplicant_dbus_method_call(data->interface->path,
7560                         SUPPLICANT_INTERFACE ".Interface", "AddNetwork",
7561                         interface_add_network_params,
7562                         interface_add_network_result, connect_data,
7563                         connect_data->interface);
7564         } else {
7565                 if (data->callback)
7566                         data->callback(result, data->interface, data->user_data);
7567         }
7568         g_free(data->path);
7569         dbus_free(data);
7570 }
7571
7572 static void network_remove_params(DBusMessageIter *iter, void *user_data)
7573 {
7574         struct interface_data *data = user_data;
7575         const char *path = data->interface->network_path;
7576
7577         SUPPLICANT_DBG("path %s", path);
7578
7579         dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH, &path);
7580 }
7581
7582 static int network_remove(struct interface_data *data)
7583 {
7584         GSupplicantInterface *interface = data->interface;
7585
7586         SUPPLICANT_DBG("");
7587
7588 #if defined TIZEN_EXT
7589         GSupplicantInterface *intf = NULL;
7590         /*
7591          * Check if 'interface' is valid
7592          */
7593         intf = g_hash_table_lookup(interface_table, interface->path);
7594         if (intf == NULL)
7595                 return -EINVAL;
7596 #endif
7597
7598         return supplicant_dbus_method_call(interface->path,
7599                         SUPPLICANT_INTERFACE ".Interface", "RemoveNetwork",
7600                         network_remove_params, network_remove_result, data,
7601                         interface);
7602 }
7603
7604 static void interface_disconnect_result(const char *error,
7605                                 DBusMessageIter *iter, void *user_data)
7606 {
7607         struct interface_data *data = user_data;
7608         int result = 0;
7609
7610         SUPPLICANT_DBG("");
7611
7612         if (error) {
7613                 result = -EIO;
7614                 SUPPLICANT_DBG("error: %s", error);
7615
7616                 if (g_strcmp0("org.freedesktop.DBus.Error.UnknownMethod",
7617                                                 error) == 0)
7618                         result = -ECONNABORTED;
7619         }
7620
7621         /* If we are disconnecting from previous WPS successful
7622          * association. i.e.: it did not went through AddNetwork,
7623          * and interface->network_path was never set. */
7624         if (!data->interface->network_path) {
7625                 if (data->callback)
7626                         data->callback(result, data->interface,
7627                                                         data->user_data);
7628
7629                 g_free(data->path);
7630                 dbus_free(data);
7631                 return;
7632         }
7633
7634         if (result < 0 && data->callback) {
7635                 data->callback(result, data->interface, data->user_data);
7636                 data->callback = NULL;
7637         }
7638
7639         if (result != -ECONNABORTED) {
7640                 if (network_remove(data) < 0) {
7641                         g_free(data->path);
7642                         dbus_free(data);
7643                 }
7644         } else {
7645                 g_free(data->path);
7646                 dbus_free(data);
7647         }
7648 }
7649
7650 int g_supplicant_interface_disconnect(GSupplicantInterface *interface,
7651                                         GSupplicantInterfaceCallback callback,
7652                                                         void *user_data)
7653 {
7654         struct interface_data *data;
7655         int ret;
7656
7657         SUPPLICANT_DBG("");
7658
7659         if (!interface)
7660                 return -EINVAL;
7661
7662         if (!system_available)
7663                 return -EFAULT;
7664 #if defined TIZEN_EXT
7665         if (decrypt_request_data.pending_call &&
7666                         decrypt_request_data.data &&
7667                         decrypt_request_data.data->user_data == user_data) {
7668
7669                 callback_assoc_failed(decrypt_request_data.data->user_data);
7670                 crypt_method_call_cancel();
7671
7672                 return 0;
7673         }
7674 #endif
7675         data = dbus_malloc0(sizeof(*data));
7676         if (!data)
7677                 return -ENOMEM;
7678
7679         data->interface = interface;
7680         data->path = g_strdup(interface->path);
7681         data->callback = callback;
7682         data->user_data = user_data;
7683
7684         ret = supplicant_dbus_method_call(interface->path,
7685                         SUPPLICANT_INTERFACE ".Interface", "Disconnect",
7686                         NULL, interface_disconnect_result, data,
7687                         interface);
7688
7689         if (ret < 0) {
7690                 g_free(data->path);
7691                 dbus_free(data);
7692         }
7693
7694         return ret;
7695 }
7696
7697 static void interface_p2p_find_result(const char *error,
7698                                         DBusMessageIter *iter, void *user_data)
7699 {
7700         struct interface_scan_data *data = user_data;
7701         int err = 0;
7702
7703         SUPPLICANT_DBG("error %s", error);
7704
7705         if (error)
7706                 err = -EIO;
7707
7708         if (interface_exists(data->interface, data->path)) {
7709                 if (!data->interface->ready)
7710                         err = -ENOLINK;
7711                 if (!err)
7712                         data->interface->p2p_finding = true;
7713         }
7714
7715         if (data->callback)
7716                 data->callback(err, data->interface, data->user_data);
7717
7718         g_free(data->path);
7719         dbus_free(data);
7720 }
7721
7722 static void interface_p2p_find_params(DBusMessageIter *iter, void *user_data)
7723 {
7724         DBusMessageIter dict;
7725
7726         supplicant_dbus_dict_open(iter, &dict);
7727         supplicant_dbus_dict_close(iter, &dict);
7728 }
7729
7730 int g_supplicant_interface_p2p_find(GSupplicantInterface *interface,
7731                                         GSupplicantInterfaceCallback callback,
7732                                                         void *user_data)
7733 {
7734         struct interface_scan_data *data;
7735         int ret;
7736
7737         if (!interface->p2p_support)
7738                 return -ENOTSUP;
7739
7740         ret = interface_ready_to_scan(interface);
7741         if (ret && ret != -EALREADY)
7742                 return ret;
7743
7744         data = dbus_malloc0(sizeof(*data));
7745         if (!data)
7746                 return -ENOMEM;
7747
7748         data->interface = interface;
7749         data->path = g_strdup(interface->path);
7750         data->callback = callback;
7751         data->user_data = user_data;
7752
7753         ret = supplicant_dbus_method_call(interface->path,
7754                         SUPPLICANT_INTERFACE ".Interface.P2PDevice", "Find",
7755                         interface_p2p_find_params, interface_p2p_find_result,
7756                         data, interface);
7757         if (ret < 0) {
7758                 g_free(data->path);
7759                 dbus_free(data);
7760         }
7761
7762         return ret;
7763 }
7764
7765 bool g_supplicant_interface_is_p2p_finding(GSupplicantInterface *interface)
7766 {
7767         if (!interface)
7768                 return false;
7769
7770         return interface->p2p_finding;
7771 }
7772
7773 int g_supplicant_interface_p2p_stop_find(GSupplicantInterface *interface)
7774 {
7775         if (!interface->p2p_finding)
7776                 return 0;
7777
7778         SUPPLICANT_DBG("");
7779
7780         interface->p2p_finding = false;
7781
7782         return supplicant_dbus_method_call(interface->path,
7783                 SUPPLICANT_INTERFACE ".Interface.P2PDevice", "StopFind",
7784                 NULL, NULL, NULL, NULL);
7785 }
7786
7787 static void interface_p2p_connect_result(const char *error,
7788                                         DBusMessageIter *iter, void *user_data)
7789 {
7790         struct interface_connect_data *data = user_data;
7791         int err = 0;
7792
7793         SUPPLICANT_DBG("");
7794
7795         if (error) {
7796                 SUPPLICANT_DBG("error: %s", error);
7797                 err = parse_supplicant_error(iter);
7798         }
7799
7800         if (data->callback)
7801                 data->callback(err, data->interface, data->user_data);
7802
7803         g_free(data->path);
7804         g_free(data->peer->wps_pin);
7805         g_free(data->peer->path);
7806         g_free(data->peer);
7807         g_free(data);
7808 }
7809
7810 static void interface_p2p_connect_params(DBusMessageIter *iter, void *user_data)
7811 {
7812         struct interface_connect_data *data = user_data;
7813         const char *wps = "pbc";
7814         DBusMessageIter dict;
7815         int go_intent = 7;
7816
7817         SUPPLICANT_DBG("");
7818
7819         supplicant_dbus_dict_open(iter, &dict);
7820
7821         if (data->peer->master)
7822                 go_intent = 15;
7823
7824         if (data->peer->wps_pin)
7825                 wps = "pin";
7826
7827         supplicant_dbus_dict_append_basic(&dict, "peer",
7828                                 DBUS_TYPE_OBJECT_PATH, &data->peer->path);
7829         supplicant_dbus_dict_append_basic(&dict, "wps_method",
7830                                 DBUS_TYPE_STRING, &wps);
7831         if (data->peer->wps_pin) {
7832                 supplicant_dbus_dict_append_basic(&dict, "pin",
7833                                 DBUS_TYPE_STRING, &data->peer->wps_pin);
7834         }
7835
7836         supplicant_dbus_dict_append_basic(&dict, "go_intent",
7837                                         DBUS_TYPE_INT32, &go_intent);
7838
7839         supplicant_dbus_dict_close(iter, &dict);
7840 }
7841
7842 int g_supplicant_interface_p2p_connect(GSupplicantInterface *interface,
7843                                         GSupplicantPeerParams *peer_params,
7844                                         GSupplicantInterfaceCallback callback,
7845                                         void *user_data)
7846 {
7847         struct interface_connect_data *data;
7848         int ret;
7849
7850         SUPPLICANT_DBG("");
7851
7852         if (!interface->p2p_support)
7853                 return -ENOTSUP;
7854
7855         data = dbus_malloc0(sizeof(*data));
7856         if (!data)
7857                 return -ENOMEM;
7858
7859         data->interface = interface;
7860         data->path = g_strdup(interface->path);
7861         data->peer = peer_params;
7862         data->callback = callback;
7863         data->user_data = user_data;
7864
7865         ret = supplicant_dbus_method_call(interface->path,
7866                 SUPPLICANT_INTERFACE ".Interface.P2PDevice", "Connect",
7867                 interface_p2p_connect_params, interface_p2p_connect_result,
7868                 data, interface);
7869         if (ret < 0) {
7870                 g_free(data->path);
7871                 dbus_free(data);
7872                 return ret;
7873         }
7874
7875         return -EINPROGRESS;
7876 }
7877
7878 int g_supplicant_interface_p2p_disconnect(GSupplicantInterface *interface,
7879                                         GSupplicantPeerParams *peer_params)
7880 {
7881         GSupplicantPeer *peer;
7882         int count = 0;
7883         GSList *list;
7884
7885         SUPPLICANT_DBG("");
7886
7887         if (!interface->p2p_support)
7888                 return -ENOTSUP;
7889
7890         peer = g_hash_table_lookup(interface->peer_table, peer_params->path);
7891         if (!peer)
7892                 return -ENODEV;
7893
7894         for (list = peer->groups; list; list = list->next, count++) {
7895                 const char *group_obj_path = list->data;
7896                 GSupplicantInterface *g_interface;
7897                 GSupplicantGroup *group;
7898
7899                 group = g_hash_table_lookup(group_mapping, group_obj_path);
7900                 if (!group || !group->interface)
7901                         continue;
7902
7903                 g_interface = group->interface;
7904                 supplicant_dbus_method_call(g_interface->path,
7905                                 SUPPLICANT_INTERFACE ".Interface.P2PDevice",
7906                                 "Disconnect", NULL, NULL, NULL, g_interface);
7907         }
7908
7909         if (count == 0 && peer->current_group_iface) {
7910                 supplicant_dbus_method_call(peer->current_group_iface->path,
7911                                 SUPPLICANT_INTERFACE ".Interface.P2PDevice",
7912                                 "Disconnect", NULL, NULL, NULL,
7913                                 peer->current_group_iface->path);
7914         }
7915
7916         peer->current_group_iface = NULL;
7917
7918         return -EINPROGRESS;
7919 }
7920
7921 struct p2p_service_data {
7922         bool registration;
7923         GSupplicantInterface *interface;
7924         GSupplicantP2PServiceParams *service;
7925         GSupplicantInterfaceCallback callback;
7926         void *user_data;
7927 };
7928
7929 static void interface_p2p_service_result(const char *error,
7930                                         DBusMessageIter *iter, void *user_data)
7931 {
7932         struct p2p_service_data *data = user_data;
7933         int result = 0;
7934
7935         SUPPLICANT_DBG("%s result - %s", data->registration ?
7936                                 "Registration" : "Deletion",
7937                                 error ? error : "Success");
7938         if (error)
7939                 result = -EINVAL;
7940
7941         if (data->callback)
7942                 data->callback(result, data->interface, data->user_data);
7943
7944         g_free(data->service->query);
7945         g_free(data->service->response);
7946         g_free(data->service->service);
7947         g_free(data->service->wfd_ies);
7948         g_free(data->service);
7949         dbus_free(data);
7950 }
7951
7952 static void interface_p2p_service_params(DBusMessageIter *iter,
7953                                                         void *user_data)
7954 {
7955         struct p2p_service_data *data = user_data;
7956         GSupplicantP2PServiceParams *service;
7957         DBusMessageIter dict;
7958         const char *type;
7959
7960         SUPPLICANT_DBG("");
7961
7962         service = data->service;
7963
7964         supplicant_dbus_dict_open(iter, &dict);
7965
7966         if (service->query && service->response) {
7967                 type = "bonjour";
7968                 supplicant_dbus_dict_append_basic(&dict, "service_type",
7969                                                 DBUS_TYPE_STRING, &type);
7970                 supplicant_dbus_dict_append_fixed_array(&dict, "query",
7971                                         DBUS_TYPE_BYTE, &service->query,
7972                                         service->query_length);
7973                 supplicant_dbus_dict_append_fixed_array(&dict, "response",
7974                                         DBUS_TYPE_BYTE, &service->response,
7975                                         service->response_length);
7976         } else if (service->version && service->service) {
7977                 type = "upnp";
7978                 supplicant_dbus_dict_append_basic(&dict, "service_type",
7979                                                 DBUS_TYPE_STRING, &type);
7980                 supplicant_dbus_dict_append_basic(&dict, "version",
7981                                         DBUS_TYPE_INT32, &service->version);
7982                 supplicant_dbus_dict_append_basic(&dict, "service",
7983                                         DBUS_TYPE_STRING, &service->service);
7984         }
7985
7986         supplicant_dbus_dict_close(iter, &dict);
7987 }
7988
7989 int g_supplicant_interface_p2p_add_service(GSupplicantInterface *interface,
7990                                 GSupplicantInterfaceCallback callback,
7991                                 GSupplicantP2PServiceParams *p2p_service_params,
7992                                 void *user_data)
7993 {
7994         struct p2p_service_data *data;
7995         int ret;
7996
7997         SUPPLICANT_DBG("");
7998
7999         if (!interface->p2p_support)
8000                 return -ENOTSUP;
8001
8002         data = dbus_malloc0(sizeof(*data));
8003         if (!data)
8004                 return -ENOMEM;
8005
8006         data->registration = true;
8007         data->interface = interface;
8008         data->service = p2p_service_params;
8009         data->callback = callback;
8010         data->user_data = user_data;
8011
8012         ret = supplicant_dbus_method_call(interface->path,
8013                 SUPPLICANT_INTERFACE ".Interface.P2PDevice", "AddService",
8014                 interface_p2p_service_params, interface_p2p_service_result,
8015                 data, interface);
8016         if (ret < 0) {
8017                 dbus_free(data);
8018                 return ret;
8019         }
8020
8021         return -EINPROGRESS;
8022 }
8023
8024 int g_supplicant_interface_p2p_del_service(GSupplicantInterface *interface,
8025                                 GSupplicantP2PServiceParams *p2p_service_params)
8026 {
8027         struct p2p_service_data *data;
8028         int ret;
8029
8030         SUPPLICANT_DBG("");
8031
8032         if (!interface->p2p_support)
8033                 return -ENOTSUP;
8034
8035         data = dbus_malloc0(sizeof(*data));
8036         if (!data)
8037                 return -ENOMEM;
8038
8039         data->interface = interface;
8040         data->service = p2p_service_params;
8041
8042         ret = supplicant_dbus_method_call(interface->path,
8043                 SUPPLICANT_INTERFACE ".Interface.P2PDevice", "DeleteService",
8044                 interface_p2p_service_params, interface_p2p_service_result,
8045                 data, interface);
8046         if (ret < 0) {
8047                 dbus_free(data);
8048                 return ret;
8049         }
8050
8051         return -EINPROGRESS;
8052 }
8053
8054 struct p2p_listen_data {
8055         int period;
8056         int interval;
8057 };
8058
8059 static void interface_p2p_listen_params(DBusMessageIter *iter, void *user_data)
8060 {
8061         struct p2p_listen_data *params = user_data;
8062         DBusMessageIter dict;
8063
8064         supplicant_dbus_dict_open(iter, &dict);
8065
8066         supplicant_dbus_dict_append_basic(&dict, "period",
8067                                         DBUS_TYPE_INT32, &params->period);
8068         supplicant_dbus_dict_append_basic(&dict, "interval",
8069                                         DBUS_TYPE_INT32, &params->interval);
8070         supplicant_dbus_dict_close(iter, &dict);
8071 }
8072
8073 int g_supplicant_interface_p2p_listen(GSupplicantInterface *interface,
8074                                                 int period, int interval)
8075 {
8076         struct p2p_listen_data params;
8077
8078         SUPPLICANT_DBG("");
8079
8080         if (!interface->p2p_support)
8081                 return -ENOTSUP;
8082
8083         params.period = period;
8084         params.interval = interval;
8085
8086         return supplicant_dbus_method_call(interface->path,
8087                         SUPPLICANT_INTERFACE ".Interface.P2PDevice",
8088                         "ExtendedListen", interface_p2p_listen_params,
8089                         NULL, &params, NULL);
8090 }
8091
8092 static void widi_ies_params(DBusMessageIter *iter, void *user_data)
8093 {
8094         struct p2p_service_data *data = user_data;
8095         GSupplicantP2PServiceParams *service = data->service;
8096         DBusMessageIter array;
8097
8098         SUPPLICANT_DBG("%p - %d", service->wfd_ies, service->wfd_ies_length);
8099
8100         dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
8101                                         DBUS_TYPE_BYTE_AS_STRING, &array);
8102
8103         if (service->wfd_ies && service->wfd_ies_length > 0) {
8104                 dbus_message_iter_append_fixed_array(&array, DBUS_TYPE_BYTE,
8105                                 &service->wfd_ies, service->wfd_ies_length);
8106         }
8107
8108         dbus_message_iter_close_container(iter, &array);
8109 }
8110
8111 int g_supplicant_set_widi_ies(GSupplicantP2PServiceParams *p2p_service_params,
8112                                         GSupplicantInterfaceCallback callback,
8113                                         void *user_data)
8114 {
8115         struct p2p_service_data *data;
8116         int ret;
8117
8118         SUPPLICANT_DBG("");
8119
8120         if (!system_available)
8121                 return -EFAULT;
8122
8123         data = dbus_malloc0(sizeof(*data));
8124         if (!data)
8125                 return -ENOMEM;
8126
8127         data->service = p2p_service_params;
8128         data->callback = callback;
8129         data->user_data = user_data;
8130
8131         if (p2p_service_params->wfd_ies)
8132                 data->registration = true;
8133
8134         ret = supplicant_dbus_property_set(SUPPLICANT_PATH,
8135                                         SUPPLICANT_INTERFACE, "WFDIEs",
8136                                         DBUS_TYPE_ARRAY_AS_STRING
8137                                         DBUS_TYPE_BYTE_AS_STRING,
8138                                         widi_ies_params,
8139                                         interface_p2p_service_result,
8140                                         data, NULL);
8141         if (ret < 0 && ret != -EINPROGRESS) {
8142                 dbus_free(data);
8143                 return ret;
8144         }
8145
8146         return -EINPROGRESS;
8147 }
8148
8149
8150 static const char *g_supplicant_rule0 = "type=signal,"
8151                                         "path=" DBUS_PATH_DBUS ","
8152                                         "sender=" DBUS_SERVICE_DBUS ","
8153                                         "interface=" DBUS_INTERFACE_DBUS ","
8154                                         "member=NameOwnerChanged,"
8155                                         "arg0=" SUPPLICANT_SERVICE;
8156 static const char *g_supplicant_rule1 = "type=signal,"
8157                         "interface=" SUPPLICANT_INTERFACE;
8158 static const char *g_supplicant_rule2 = "type=signal,"
8159                         "interface=" SUPPLICANT_INTERFACE ".Interface";
8160 static const char *g_supplicant_rule3 = "type=signal,"
8161                         "interface=" SUPPLICANT_INTERFACE ".Interface.WPS";
8162 static const char *g_supplicant_rule4 = "type=signal,"
8163                         "interface=" SUPPLICANT_INTERFACE ".BSS";
8164 static const char *g_supplicant_rule5 = "type=signal,"
8165                         "interface=" SUPPLICANT_INTERFACE ".Network";
8166 #if !defined TIZEN_EXT
8167 static const char *g_supplicant_rule6 = "type=signal,"
8168                 "interface=" SUPPLICANT_INTERFACE ".Interface.P2PDevice";
8169 static const char *g_supplicant_rule7 = "type=signal,"
8170                 "interface=" SUPPLICANT_INTERFACE ".Peer";
8171 static const char *g_supplicant_rule8 = "type=signal,"
8172                 "interface=" SUPPLICANT_INTERFACE ".Group";
8173 #endif
8174 #if defined TIZEN_EXT_WIFI_MESH
8175 static const char *g_supplicant_rule9 = "type=signal,"
8176                 "interface=" SUPPLICANT_INTERFACE ".Interface.Mesh";
8177 #endif
8178
8179 static void invoke_introspect_method(void)
8180 {
8181         DBusMessage *message;
8182
8183         message = dbus_message_new_method_call(SUPPLICANT_SERVICE,
8184                                         SUPPLICANT_PATH,
8185                                         DBUS_INTERFACE_INTROSPECTABLE,
8186                                         "Introspect");
8187
8188         if (!message)
8189                 return;
8190
8191         dbus_message_set_no_reply(message, TRUE);
8192         dbus_connection_send(connection, message, NULL);
8193         dbus_message_unref(message);
8194 }
8195
8196 #if defined TIZEN_EXT
8197 void g_supplicant_set_ins_settings(GSupplicantINSPreferredFreq preferred_freq_bssid,
8198                 bool last_connected_bssid, bool assoc_reject, bool signal_bssid,
8199                 unsigned int preferred_freq_bssid_score, unsigned int last_connected_bssid_score,
8200                 unsigned int assoc_reject_score, int signal_level3_5ghz, int signal_level3_24ghz)
8201 {
8202         ins_settings.preferred_freq_bssid = preferred_freq_bssid;
8203         ins_settings.last_connected_bssid = last_connected_bssid;
8204         ins_settings.assoc_reject = assoc_reject;
8205         ins_settings.signal_bssid = signal_bssid;
8206         ins_settings.preferred_freq_bssid_score = preferred_freq_bssid_score;
8207         ins_settings.last_connected_bssid_score = last_connected_bssid_score;
8208         ins_settings.assoc_reject_score = assoc_reject_score;
8209         ins_settings.signal_level3_5ghz = signal_level3_5ghz;
8210         ins_settings.signal_level3_24ghz = signal_level3_24ghz;
8211
8212         SUPPLICANT_DBG("preferred_freq_bssid [%s]", preferred_freq_bssid ? "true" : "false");
8213         SUPPLICANT_DBG("preferred_freq_bssid_score [%d]", preferred_freq_bssid_score);
8214         SUPPLICANT_DBG("last_connected_bssid [%s]", last_connected_bssid ? "true" : "false");
8215         SUPPLICANT_DBG("last_connected_bssid_score [%d]", last_connected_bssid_score);
8216         SUPPLICANT_DBG("assoc_reject [%s]", assoc_reject ? "true" : "false");
8217         SUPPLICANT_DBG("assoc_reject_score [%d]", assoc_reject_score);
8218         SUPPLICANT_DBG("signal_bssid [%s]", signal_bssid ? "true" : "false");
8219         SUPPLICANT_DBG("signal_level3_5ghz [%d]", signal_level3_5ghz);
8220         SUPPLICANT_DBG("signal_level3_24ghz [%d]", signal_level3_24ghz);
8221 }
8222 #endif
8223
8224 int g_supplicant_register(const GSupplicantCallbacks *callbacks)
8225 {
8226         connection = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
8227         if (!connection)
8228                 return -EIO;
8229
8230         if (!dbus_connection_add_filter(connection, g_supplicant_filter,
8231                                                 NULL, NULL)) {
8232                 dbus_connection_unref(connection);
8233                 connection = NULL;
8234                 return -EIO;
8235         }
8236
8237         callbacks_pointer = callbacks;
8238         eap_methods = 0;
8239
8240         interface_table = g_hash_table_new_full(g_str_hash, g_str_equal,
8241                                                 NULL, remove_interface);
8242
8243         bss_mapping = g_hash_table_new_full(g_str_hash, g_str_equal,
8244                                                                 NULL, NULL);
8245         peer_mapping = g_hash_table_new_full(g_str_hash, g_str_equal,
8246                                                                 NULL, NULL);
8247         group_mapping = g_hash_table_new_full(g_str_hash, g_str_equal,
8248                                                                 NULL, NULL);
8249         pending_peer_connection = g_hash_table_new_full(g_str_hash, g_str_equal,
8250                                                                 NULL, NULL);
8251         config_file_table = g_hash_table_new_full(g_str_hash, g_str_equal,
8252                                                                 g_free, g_free);
8253
8254         supplicant_dbus_setup(connection);
8255
8256         dbus_bus_add_match(connection, g_supplicant_rule0, NULL);
8257         dbus_bus_add_match(connection, g_supplicant_rule1, NULL);
8258         dbus_bus_add_match(connection, g_supplicant_rule2, NULL);
8259         dbus_bus_add_match(connection, g_supplicant_rule3, NULL);
8260         dbus_bus_add_match(connection, g_supplicant_rule4, NULL);
8261         dbus_bus_add_match(connection, g_supplicant_rule5, NULL);
8262 #if defined TIZEN_EXT
8263         dbus_bus_add_match(connection,
8264                         "type=signal,interface=org.tizen.system.deviced.PowerOff,"
8265                         "member=ChangeState", NULL);
8266 #endif
8267 #if !defined TIZEN_EXT
8268         dbus_bus_add_match(connection, g_supplicant_rule6, NULL);
8269         dbus_bus_add_match(connection, g_supplicant_rule7, NULL);
8270         dbus_bus_add_match(connection, g_supplicant_rule8, NULL);
8271 #endif
8272 #if defined TIZEN_EXT_WIFI_MESH
8273         dbus_bus_add_match(connection, g_supplicant_rule9, NULL);
8274 #endif
8275         dbus_connection_flush(connection);
8276
8277         if (dbus_bus_name_has_owner(connection,
8278                                         SUPPLICANT_SERVICE, NULL)) {
8279                 system_available = TRUE;
8280                 supplicant_dbus_property_get_all(SUPPLICANT_PATH,
8281                                                 SUPPLICANT_INTERFACE,
8282                                                 service_property, NULL, NULL);
8283         } else
8284                 invoke_introspect_method();
8285
8286         return 0;
8287 }
8288
8289 static void unregister_interface_remove_params(DBusMessageIter *iter,
8290                                                 void *user_data)
8291 {
8292         const char *path = user_data;
8293
8294         dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
8295                                                         &path);
8296 }
8297
8298
8299 static void unregister_remove_interface(gpointer key, gpointer value,
8300                                                 gpointer user_data)
8301 {
8302         GSupplicantInterface *interface = value;
8303
8304         supplicant_dbus_method_call(SUPPLICANT_PATH,
8305                                         SUPPLICANT_INTERFACE,
8306                                         "RemoveInterface",
8307                                         unregister_interface_remove_params,
8308                                         NULL, interface->path, NULL);
8309 }
8310
8311 void g_supplicant_unregister(const GSupplicantCallbacks *callbacks)
8312 {
8313         SUPPLICANT_DBG("");
8314
8315         if (connection) {
8316 #if defined TIZEN_EXT_WIFI_MESH
8317                 dbus_bus_remove_match(connection, g_supplicant_rule9, NULL);
8318 #endif
8319 #if !defined TIZEN_EXT
8320                 dbus_bus_remove_match(connection, g_supplicant_rule8, NULL);
8321                 dbus_bus_remove_match(connection, g_supplicant_rule7, NULL);
8322                 dbus_bus_remove_match(connection, g_supplicant_rule6, NULL);
8323 #endif
8324                 dbus_bus_remove_match(connection, g_supplicant_rule5, NULL);
8325                 dbus_bus_remove_match(connection, g_supplicant_rule4, NULL);
8326                 dbus_bus_remove_match(connection, g_supplicant_rule3, NULL);
8327                 dbus_bus_remove_match(connection, g_supplicant_rule2, NULL);
8328                 dbus_bus_remove_match(connection, g_supplicant_rule1, NULL);
8329                 dbus_bus_remove_match(connection, g_supplicant_rule0, NULL);
8330                 dbus_connection_flush(connection);
8331
8332                 dbus_connection_remove_filter(connection,
8333                                                 g_supplicant_filter, NULL);
8334         }
8335
8336         if (config_file_table) {
8337                 g_hash_table_destroy(config_file_table);
8338                 config_file_table = NULL;
8339         }
8340
8341         if (bss_mapping) {
8342                 g_hash_table_destroy(bss_mapping);
8343                 bss_mapping = NULL;
8344         }
8345
8346         if (peer_mapping) {
8347                 g_hash_table_destroy(peer_mapping);
8348                 peer_mapping = NULL;
8349         }
8350
8351         if (group_mapping) {
8352                 g_hash_table_destroy(group_mapping);
8353                 group_mapping = NULL;
8354         }
8355
8356         if (interface_table) {
8357                 g_hash_table_foreach(interface_table,
8358                                         unregister_remove_interface, NULL);
8359                 g_hash_table_destroy(interface_table);
8360                 interface_table = NULL;
8361         }
8362
8363         if (system_available)
8364                 callback_system_killed();
8365
8366         if (connection) {
8367                 dbus_connection_unref(connection);
8368                 connection = NULL;
8369         }
8370
8371         callbacks_pointer = NULL;
8372         eap_methods = 0;
8373 }