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